@pney/whatsapp-web 1.34.6-3 → 1.34.7-1

package/src/Client.js

@@ -5,15 +5,37 @@ const puppeteer = require('puppeteer');
 
 const Util = require('./util/Util');
 const InterfaceController = require('./util/InterfaceController');
-const { WhatsWebURL, DefaultOptions, Events, WAState, MessageTypes } = require('./util/Constants');
+const {
+    WhatsWebURL,
+    DefaultOptions,
+    Events,
+    WAState,
+    MessageTypes,
+} = require('./util/Constants');
 const { ExposeAuthStore } = require('./util/Injected/AuthStore/AuthStore');
 const { LoadUtils } = require('./util/Injected/Utils');
 const ChatFactory = require('./factories/ChatFactory');
 const ContactFactory = require('./factories/ContactFactory');
 const WebCacheFactory = require('./webCache/WebCacheFactory');
-const { ClientInfo, Message, MessageMedia, Contact, Location, Poll, PollVote, GroupNotification, Label, Call, Buttons, List, Reaction, Broadcast, ScheduledEvent } = require('./structures');
+const {
+    ClientInfo,
+    Message,
+    MessageMedia,
+    Contact,
+    Location,
+    Poll,
+    PollVote,
+    GroupNotification,
+    Label,
+    Call,
+    Buttons,
+    List,
+    Reaction,
+    Broadcast,
+    ScheduledEvent,
+} = require('./structures');
 const NoAuth = require('./authStrategies/NoAuth');
-const {exposeFunctionIfAbsent} = require('./util/Puppeteer');
+const { exposeFunctionIfAbsent } = require('./util/Puppeteer');
 
 /**
  * Starting point for interacting with the WhatsApp Web API
@@ -29,12 +51,12 @@ const {exposeFunctionIfAbsent} = require('./util/Puppeteer');
  * @param {number} options.takeoverOnConflict - If another whatsapp web session is detected (another browser), take over the session in the current browser
  * @param {number} options.takeoverTimeoutMs - How much time to wait before taking over the session
  * @param {string} options.userAgent - User agent to use in puppeteer
- * @param {string} options.ffmpegPath - Ffmpeg path to use when formatting videos to webp while sending stickers 
+ * @param {string} options.ffmpegPath - Ffmpeg path to use when formatting videos to webp while sending stickers
  * @param {boolean} options.bypassCSP - Sets bypassing of page's Content-Security-Policy.
  * @param {string} options.deviceName - Sets the device name of a current linked device., i.e.: 'TEST'.
  * @param {string} options.browserName - Sets the browser name of a current linked device, i.e.: 'Firefox'.
  * @param {object} options.proxyAuthentication - Proxy Authentication object.
- * 
+ *
  * @fires Client#qr
  * @fires Client#authenticated
  * @fires Client#auth_failure
@@ -62,8 +84,8 @@ class Client extends EventEmitter {
         super();
 
         this.options = Util.mergeDefault(DefaultOptions, options);
-        
-        if(!this.options.authStrategy) {
+
+        if (!this.options.authStrategy) {
             this.authStrategy = new NoAuth();
         } else {
             this.authStrategy = this.options.authStrategy;
@@ -85,26 +107,37 @@ class Client extends EventEmitter {
 
         Util.setFfmpegPath(this.options.ffmpegPath);
     }
+
     /**
      * Injection logic
      * Private function
      */
     async inject() {
-        if(this.options.authTimeoutMs === undefined || this.options.authTimeoutMs==0){
+        if (
+            this.options.authTimeoutMs === undefined ||
+            this.options.authTimeoutMs == 0
+        ) {
             this.options.authTimeoutMs = 30000;
         }
         let start = Date.now();
         let timeout = this.options.authTimeoutMs;
         let res = false;
-        while(start > (Date.now() - timeout)){
-            res = await this.pupPage.evaluate('window.Debug?.VERSION != undefined');
-            if(res){break;}
-            await new Promise(r => setTimeout(r, 200));
+        while (start > Date.now() - timeout) {
+            res = await this.pupPage.evaluate(
+                'window.Debug?.VERSION != undefined',
+            );
+            if (res) {
+                break;
+            }
+            await new Promise((r) => setTimeout(r, 200));
         }
-        if(!res){ 
+        if (!res) {
             throw 'auth timeout';
-        }       
-        await this.setDeviceName(this.options.deviceName, this.options.browserName);
+        }
+        await this.setDeviceName(
+            this.options.deviceName,
+            this.options.browserName,
+        );
         const pairWithPhoneNumber = this.options.pairWithPhoneNumber;
         const version = await this.getWWebVersion();
 
@@ -113,25 +146,44 @@ class Client extends EventEmitter {
         const needAuthentication = await this.pupPage.evaluate(async () => {
             let state = window.require('WAWebSocketModel').Socket.state;
 
-            if (state === 'OPENING' || state === 'UNLAUNCHED' || state === 'PAIRING') {
+            if (
+                state === 'OPENING' ||
+                state === 'UNLAUNCHED' ||
+                state === 'PAIRING'
+            ) {
                 // wait till state changes
-                await new Promise(r => {
-                    window.require('WAWebSocketModel').Socket.on('change:state', function waitTillInit(_AppState, state) {
-                        if (state !== 'OPENING' && state !== 'UNLAUNCHED' && state !== 'PAIRING') {
-                            window.require('WAWebSocketModel').Socket.off('change:state', waitTillInit);
-                            r();
-                        } 
-                    });
-                }); 
+                await new Promise((r) => {
+                    window
+                        .require('WAWebSocketModel')
+                        .Socket.on(
+                            'change:state',
+                            function waitTillInit(_AppState, state) {
+                                if (
+                                    state !== 'OPENING' &&
+                                    state !== 'UNLAUNCHED' &&
+                                    state !== 'PAIRING'
+                                ) {
+                                    window
+                                        .require('WAWebSocketModel')
+                                        .Socket.off(
+                                            'change:state',
+                                            waitTillInit,
+                                        );
+                                    r();
+                                }
+                            },
+                        );
+                });
             }
             state = window.require('WAWebSocketModel').Socket.state;
             return state == 'UNPAIRED' || state == 'UNPAIRED_IDLE';
         });
 
         if (needAuthentication) {
-            const { failed, failureEventPayload, restart } = await this.authStrategy.onAuthenticationNeeded();
+            const { failed, failureEventPayload, restart } =
+                await this.authStrategy.onAuthenticationNeeded();
 
-            if(failed) {
+            if (failed) {
                 /**
                  * Emitted when there has been an error while trying to restore an existing session
                  * @event Client#auth_failure
@@ -148,129 +200,219 @@ class Client extends EventEmitter {
 
             // Register qr/code events
             if (pairWithPhoneNumber.phoneNumber) {
-                await exposeFunctionIfAbsent(this.pupPage, 'onCodeReceivedEvent', async (code) => {
-                    /**
-                    * Emitted when a pairing code is received
-                    * @event Client#code
-                    * @param {string} code Code
-                    * @returns {string} Code that was just received
-                    */
-                    this.emit(Events.CODE_RECEIVED, code);
-                    return code;
-                });
-                this.requestPairingCode(pairWithPhoneNumber.phoneNumber, pairWithPhoneNumber.showNotification, pairWithPhoneNumber.intervalMs);
+                await exposeFunctionIfAbsent(
+                    this.pupPage,
+                    'onCodeReceivedEvent',
+                    async (code) => {
+                        /**
+                         * Emitted when a pairing code is received
+                         * @event Client#code
+                         * @param {string} code Code
+                         * @returns {string} Code that was just received
+                         */
+                        this.emit(Events.CODE_RECEIVED, code);
+                        return code;
+                    },
+                );
+                this.requestPairingCode(
+                    pairWithPhoneNumber.phoneNumber,
+                    pairWithPhoneNumber.showNotification,
+                    pairWithPhoneNumber.intervalMs,
+                );
             } else {
                 let qrRetries = 0;
-                await exposeFunctionIfAbsent(this.pupPage, 'onQRChangedEvent', async (qr) => {
-                    /**
-                    * Emitted when a QR code is received
-                    * @event Client#qr
-                    * @param {string} qr QR Code
-                    */
-                    this.emit(Events.QR_RECEIVED, qr);
-                    if (this.options.qrMaxRetries > 0) {
-                        qrRetries++;
-                        if (qrRetries > this.options.qrMaxRetries) {
-                            this.emit(Events.DISCONNECTED, 'Max qrcode retries reached');
-                            await this.destroy();
+                await exposeFunctionIfAbsent(
+                    this.pupPage,
+                    'onQRChangedEvent',
+                    async (qr) => {
+                        /**
+                         * Emitted when a QR code is received
+                         * @event Client#qr
+                         * @param {string} qr QR Code
+                         */
+                        this.emit(Events.QR_RECEIVED, qr);
+                        if (this.options.qrMaxRetries > 0) {
+                            qrRetries++;
+                            if (qrRetries > this.options.qrMaxRetries) {
+                                this.emit(
+                                    Events.DISCONNECTED,
+                                    'Max qrcode retries reached',
+                                );
+                                await this.destroy();
+                            }
                         }
-                    }
-                });
-
+                    },
+                );
 
                 await this.pupPage.evaluate(async () => {
-                    const registrationInfo = await window.AuthStore.RegistrationUtils.waSignalStore.getRegistrationInfo();
-                    const noiseKeyPair = await window.AuthStore.RegistrationUtils.waNoiseInfo.get();
-                    const staticKeyB64 = window.AuthStore.Base64Tools.encodeB64(noiseKeyPair.staticKeyPair.pubKey);
-                    const identityKeyB64 = window.AuthStore.Base64Tools.encodeB64(registrationInfo.identityKeyPair.pubKey);
-                    const advSecretKey = await window.AuthStore.RegistrationUtils.getADVSecretKey();
-                    const platform = window.AuthStore.RegistrationUtils.DEVICE_PLATFORM;
-                    const getQR = (ref) => ref + ',' + staticKeyB64 + ',' + identityKeyB64 + ',' + advSecretKey + ',' + platform;
-
+                    const registrationInfo =
+                        await window.AuthStore.RegistrationUtils.waSignalStore.getRegistrationInfo();
+                    const noiseKeyPair =
+                        await window.AuthStore.RegistrationUtils.waNoiseInfo.get();
+                    const staticKeyB64 = window.AuthStore.Base64Tools.encodeB64(
+                        noiseKeyPair.staticKeyPair.pubKey,
+                    );
+                    const identityKeyB64 =
+                        window.AuthStore.Base64Tools.encodeB64(
+                            registrationInfo.identityKeyPair.pubKey,
+                        );
+                    const platform =
+                        window.AuthStore.RegistrationUtils.DEVICE_PLATFORM;
+                    const getQR = (ref) =>
+                        ref +
+                        ',' +
+                        staticKeyB64 +
+                        ',' +
+                        identityKeyB64 +
+                        ',' +
+                        window
+                            .require('WAWebUserPrefsMultiDevice')
+                            .getADVSecretKey() +
+                        ',' +
+                        platform;
                     window.onQRChangedEvent(getQR(window.AuthStore.Conn.ref)); // initial qr
-                    window.AuthStore.Conn.on('change:ref', (_, ref) => { window.onQRChangedEvent(getQR(ref)); }); // future QR changes
+                    window.AuthStore.Conn.on('change:ref', (_, ref) => {
+                        window.onQRChangedEvent(getQR(ref));
+                    }); // future QR changes
                 });
             }
         }
 
-        await exposeFunctionIfAbsent(this.pupPage, 'onAuthAppStateChangedEvent', async (state) => {
-            if (state == 'UNPAIRED_IDLE' && !pairWithPhoneNumber.phoneNumber) {
-                // refresh qr code
-                window.require('WAWebCmd').Cmd.refreshQR();
-            }
-        });
-
-        await exposeFunctionIfAbsent(this.pupPage, 'onAppStateHasSyncedEvent', async () => {
-            const authEventPayload = await this.authStrategy.getAuthEventPayload();
-            /**
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onAuthAppStateChangedEvent',
+            async (state) => {
+                if (
+                    state == 'UNPAIRED_IDLE' &&
+                    !pairWithPhoneNumber.phoneNumber
+                ) {
+                    // refresh qr code
+                    window.require('WAWebCmd').Cmd.refreshQR();
+                }
+            },
+        );
+
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onAppStateHasSyncedEvent',
+            async () => {
+                const authEventPayload =
+                    await this.authStrategy.getAuthEventPayload();
+                /**
                  * Emitted when authentication is successful
                  * @event Client#authenticated
                  */
-            this.emit(Events.AUTHENTICATED, authEventPayload);
+                this.emit(Events.AUTHENTICATED, authEventPayload);
 
-            const injected = await this.pupPage.evaluate(async () => {
-                return typeof window.WWebJS !== 'undefined';
-            });
+                const injected = await this.pupPage.evaluate(async () => {
+                    return typeof window.WWebJS !== 'undefined';
+                });
 
-            if (!injected) {
-                if (this.options.webVersionCache.type === 'local' && this.currentIndexHtml) {
-                    const { type: webCacheType, ...webCacheOptions } = this.options.webVersionCache;
-                    const webCache = WebCacheFactory.createWebCache(webCacheType, webCacheOptions);
-            
-                    await webCache.persist(this.currentIndexHtml, version);
-                }
+                if (!injected) {
+                    if (
+                        this.options.webVersionCache.type === 'local' &&
+                        this.currentIndexHtml
+                    ) {
+                        const { type: webCacheType, ...webCacheOptions } =
+                            this.options.webVersionCache;
+                        const webCache = WebCacheFactory.createWebCache(
+                            webCacheType,
+                            webCacheOptions,
+                        );
+
+                        await webCache.persist(this.currentIndexHtml, version);
+                    }
 
-                //Load util functions (serializers, helper functions)
-                await this.pupPage.evaluate(LoadUtils);
-                
-                let start = Date.now();
-                let res = false;
-                while(start > (Date.now() - 30000)){
-                    // Check window.WWebJS Injection
-                    res = await this.pupPage.evaluate('window.WWebJS != undefined');
-                    if(res){break;}
-                    await new Promise(r => setTimeout(r, 200));
-                }
-                if(!res){
-                    throw 'ready timeout';
-                }
-            
-                /**
+                    // Load util functions (serializers, helper functions)
+                    await this.pupPage.evaluate(LoadUtils);
+
+                    let start = Date.now();
+                    let res = false;
+                    while (start > Date.now() - 30000) {
+                        // Check window.WWebJS Injection
+                        res = await this.pupPage.evaluate(
+                            'window.WWebJS != undefined',
+                        );
+                        if (res) {
+                            break;
+                        }
+                        await new Promise((r) => setTimeout(r, 200));
+                    }
+                    if (!res) {
+                        throw 'ready timeout';
+                    }
+
+                    /**
                      * Current connection information
                      * @type {ClientInfo}
                      */
-                this.info = new ClientInfo(this, await this.pupPage.evaluate(() => {
-                    return { ...(window.require('WAWebConnModel').Conn).serialize(), wid: (window.require('WAWebUserPrefsMeUser')).getMaybeMePnUser() || (window.require('WAWebUserPrefsMeUser')).getMaybeMeLidUser() };
-                }));
+                    this.info = new ClientInfo(
+                        this,
+                        await this.pupPage.evaluate(() => {
+                            return {
+                                ...window
+                                    .require('WAWebConnModel')
+                                    .Conn.serialize(),
+                                wid:
+                                    window
+                                        .require('WAWebUserPrefsMeUser')
+                                        .getMaybeMePnUser() ||
+                                    window
+                                        .require('WAWebUserPrefsMeUser')
+                                        .getMaybeMeLidUser(),
+                            };
+                        }),
+                    );
 
-                this.interface = new InterfaceController(this);
+                    this.interface = new InterfaceController(this);
 
-                await this.attachEventListeners();
-            }
-            /**
+                    await this.attachEventListeners();
+                }
+                /**
                  * Emitted when the client has initialized and is ready to receive messages.
                  * @event Client#ready
                  */
-            this.emit(Events.READY);
-            this.authStrategy.afterAuthReady();
-        });
+                this.emit(Events.READY);
+                this.authStrategy.afterAuthReady();
+            },
+        );
         let lastPercent = null;
-        await exposeFunctionIfAbsent(this.pupPage, 'onOfflineProgressUpdateEvent', async (percent) => {
-            if (lastPercent !== percent) {
-                lastPercent = percent;
-                this.emit(Events.LOADING_SCREEN, percent, 'WhatsApp'); // Message is hardcoded as "WhatsApp" for now
-            }
-        });
-        await exposeFunctionIfAbsent(this.pupPage, 'onLogoutEvent', async () => {
-            this.lastLoggedOut = true;
-            await this.pupPage.waitForNavigation({waitUntil: 'load', timeout: 5000}).catch((_) => _);
-        });
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onOfflineProgressUpdateEvent',
+            async (percent) => {
+                if (lastPercent !== percent) {
+                    lastPercent = percent;
+                    this.emit(Events.LOADING_SCREEN, percent, 'WhatsApp'); // Message is hardcoded as "WhatsApp" for now
+                }
+            },
+        );
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onLogoutEvent',
+            async () => {
+                this.lastLoggedOut = true;
+                await this.pupPage
+                    .waitForNavigation({ waitUntil: 'load', timeout: 5000 })
+                    .catch((_) => _);
+            },
+        );
         await this.pupPage.evaluate(() => {
-            window.require('WAWebSocketModel').Socket.on('change:state', (_AppState, state) => { window.onAuthAppStateChangedEvent(state); });
-            window.require('WAWebSocketModel').Socket.on('change:hasSynced', () => { window.onAppStateHasSyncedEvent(); });
+            window
+                .require('WAWebSocketModel')
+                .Socket.on('change:state', (_AppState, state) => {
+                    window.onAuthAppStateChangedEvent(state);
+                });
+            window
+                .require('WAWebSocketModel')
+                .Socket.on('change:hasSynced', () => {
+                    window.onAppStateHasSyncedEvent();
+                });
             const Cmd = window.require('WAWebCmd').Cmd;
             Cmd.on('offline_progress_update_from_bridge', () => {
-                window.onOfflineProgressUpdateEvent(window.AuthStore.OfflineMessageHandler.getOfflineDeliveryProgress()); 
+                window.onOfflineProgressUpdateEvent(
+                    window.AuthStore.OfflineMessageHandler.getOfflineDeliveryProgress(),
+                );
             });
             Cmd.on('logout', async () => {
                 await window.onLogoutEvent();
@@ -285,12 +427,10 @@ class Client extends EventEmitter {
      * Sets up events and requirements, kicks off authentication request
      */
     async initialize() {
-
-        let 
-            /**
+        let /**
              * @type {puppeteer.Browser}
              */
-            browser, 
+            browser,
             /**
              * @type {puppeteer.Page}
              */
@@ -302,25 +442,34 @@ class Client extends EventEmitter {
         await this.authStrategy.beforeBrowserInitialized();
 
         const puppeteerOpts = this.options.puppeteer;
-        if (puppeteerOpts && (puppeteerOpts.browserWSEndpoint || puppeteerOpts.browserURL)) {
+        if (
+            puppeteerOpts &&
+            (puppeteerOpts.browserWSEndpoint || puppeteerOpts.browserURL)
+        ) {
             browser = await puppeteer.connect(puppeteerOpts);
             page = await browser.newPage();
         } else {
             const browserArgs = [...(puppeteerOpts.args || [])];
-            if(this.options.userAgent !== false && !browserArgs.find(arg => arg.includes('--user-agent'))) {
+            if (
+                this.options.userAgent !== false &&
+                !browserArgs.find((arg) => arg.includes('--user-agent'))
+            ) {
                 browserArgs.push(`--user-agent=${this.options.userAgent}`);
             }
             // navigator.webdriver fix
             browserArgs.push('--disable-blink-features=AutomationControlled');
 
-            browser = await puppeteer.launch({...puppeteerOpts, args: browserArgs});
+            browser = await puppeteer.launch({
+                ...puppeteerOpts,
+                args: browserArgs,
+            });
             page = (await browser.pages())[0];
         }
 
         if (this.options.proxyAuthentication !== undefined) {
             await page.authenticate(this.options.proxyAuthentication);
         }
-        if(this.options.userAgent !== false) {
+        if (this.options.userAgent !== false) {
             await page.setUserAgent(this.options.userAgent);
         }
         if (this.options.bypassCSP) await page.setBypassCSP(true);
@@ -330,21 +479,21 @@ class Client extends EventEmitter {
 
         await this.authStrategy.afterBrowserInitialized();
         await this.initWebVersionCache();
-        
+
         if (this.options.evalOnNewDoc !== undefined) {
             await page.evaluateOnNewDocument(this.options.evalOnNewDoc);
         }
-        
+
         await page.goto(WhatsWebURL, {
             waitUntil: 'load',
             timeout: 0,
-            referer: 'https://whatsapp.com/'
+            referer: 'https://whatsapp.com/',
         });
 
         await this.inject();
 
         this.pupPage.on('framenavigated', async (frame) => {
-            if(frame.url().includes('post_logout=1') || this.lastLoggedOut) {
+            if (frame.url().includes('post_logout=1') || this.lastLoggedOut) {
                 this.emit(Events.DISCONNECTED, 'LOGOUT');
                 await this.authStrategy.logout();
                 await this.authStrategy.beforeBrowserInitialized();
@@ -362,29 +511,70 @@ class Client extends EventEmitter {
      * @param {number} [intervalMs = 180000] - The interval in milliseconds on how frequent to generate pairing code (WhatsApp default to 3 minutes)
      * @returns {Promise<string>} - Returns a pairing code in format "ABCDEFGH"
      */
-    async requestPairingCode(phoneNumber, showNotification = true, intervalMs = 180000) {
-        return await this.pupPage.evaluate(async (phoneNumber, showNotification, intervalMs) => {
-            const getCode = async () => {
-                while (!window.AuthStore.PairingCodeLinkUtils) {
-                    await new Promise(resolve => setTimeout(resolve, 250));
+    async requestPairingCode(
+        phoneNumber,
+        showNotification = true,
+        intervalMs = 180000,
+    ) {
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onCodeReceivedEvent',
+            async (code) => {
+                this.emit(Events.CODE_RECEIVED, code);
+                return code;
+            },
+        );
+        return await this.pupPage.evaluate(
+            async (phoneNumber, showNotification, intervalMs) => {
+                const getCode = async () => {
+                    while (!window.AuthStore.PairingCodeLinkUtils) {
+                        await new Promise((resolve) =>
+                            setTimeout(resolve, 250),
+                        );
+                    }
+                    window.AuthStore.PairingCodeLinkUtils.setPairingType(
+                        'ALT_DEVICE_LINKING',
+                    );
+                    await window.AuthStore.PairingCodeLinkUtils.initializeAltDeviceLinking();
+                    return window.AuthStore.PairingCodeLinkUtils.startAltLinkingFlow(
+                        phoneNumber,
+                        showNotification,
+                    );
+                };
+                if (window.codeInterval) {
+                    clearInterval(window.codeInterval); // remove existing interval
                 }
-                window.AuthStore.PairingCodeLinkUtils.setPairingType('ALT_DEVICE_LINKING');
-                await window.AuthStore.PairingCodeLinkUtils.initializeAltDeviceLinking();
-                return window.AuthStore.PairingCodeLinkUtils.startAltLinkingFlow(phoneNumber, showNotification);
-            };
+                window.codeInterval = setInterval(async () => {
+                    const state =
+                        window.require('WAWebSocketModel').Socket.state;
+                    if (state != 'UNPAIRED' && state != 'UNPAIRED_IDLE') {
+                        clearInterval(window.codeInterval);
+                        return;
+                    }
+                    window.onCodeReceivedEvent(await getCode());
+                }, intervalMs);
+                return window.onCodeReceivedEvent(await getCode());
+            },
+            phoneNumber,
+            showNotification,
+            intervalMs,
+        );
+    }
+
+    /**
+     * Cancels an active pairing code session and returns to QR code mode
+     */
+    async cancelPairingCode() {
+        await this.pupPage.evaluate(async () => {
             if (window.codeInterval) {
-                clearInterval(window.codeInterval); // remove existing interval
+                clearInterval(window.codeInterval);
+                window.codeInterval = undefined;
             }
-            window.codeInterval = setInterval(async () => {
-                const state = window.require('WAWebSocketModel').Socket.state;
-                if (state != 'UNPAIRED' && state != 'UNPAIRED_IDLE') {
-                    clearInterval(window.codeInterval);
-                    return;
-                }
-                window.onCodeReceivedEvent(await getCode());
-            }, intervalMs);
-            return window.onCodeReceivedEvent(await getCode());
-        }, phoneNumber, showNotification, intervalMs);
+            window.require('WAWebLaunchSocketUtils').refreshQR();
+            await window
+                .require('WAWebAltDeviceLinkingApi')
+                .initializeQRLinking();
+        });
     }
 
     /**
@@ -393,32 +583,45 @@ class Client extends EventEmitter {
      * @property {boolean} reinject is this a reinject?
      */
     async attachEventListeners() {
-        await exposeFunctionIfAbsent(this.pupPage, 'onAddMessageEvent', msg => {
-            if (msg.type === 'gp2') {
-                const notification = new GroupNotification(this, msg);
-                if (['add', 'invite', 'linked_group_join'].includes(msg.subtype)) {
-                    /**
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onAddMessageEvent',
+            (msg) => {
+                if (msg.type === 'gp2') {
+                    const notification = new GroupNotification(this, msg);
+                    if (
+                        ['add', 'invite', 'linked_group_join'].includes(
+                            msg.subtype,
+                        )
+                    ) {
+                        /**
                          * Emitted when a user joins the chat via invite link or is added by an admin.
                          * @event Client#group_join
                          * @param {GroupNotification} notification GroupNotification with more information about the action
                          */
-                    this.emit(Events.GROUP_JOIN, notification);
-                } else if (msg.subtype === 'remove' || msg.subtype === 'leave') {
-                    /**
+                        this.emit(Events.GROUP_JOIN, notification);
+                    } else if (
+                        msg.subtype === 'remove' ||
+                        msg.subtype === 'leave'
+                    ) {
+                        /**
                          * Emitted when a user leaves the chat or is removed by an admin.
                          * @event Client#group_leave
                          * @param {GroupNotification} notification GroupNotification with more information about the action
                          */
-                    this.emit(Events.GROUP_LEAVE, notification);
-                } else if (msg.subtype === 'promote' || msg.subtype === 'demote') {
-                    /**
+                        this.emit(Events.GROUP_LEAVE, notification);
+                    } else if (
+                        msg.subtype === 'promote' ||
+                        msg.subtype === 'demote'
+                    ) {
+                        /**
                          * Emitted when a current user is promoted to an admin or demoted to a regular user.
                          * @event Client#group_admin_changed
                          * @param {GroupNotification} notification GroupNotification with more information about the action
                          */
-                    this.emit(Events.GROUP_ADMIN_CHANGED, notification);
-                } else if (msg.subtype === 'membership_approval_request') {
-                    /**
+                        this.emit(Events.GROUP_ADMIN_CHANGED, notification);
+                    } else if (msg.subtype === 'membership_approval_request') {
+                        /**
                          * Emitted when some user requested to join the group
                          * that has the membership approval mode turned on
                          * @event Client#group_membership_request
@@ -427,89 +630,106 @@ class Client extends EventEmitter {
                          * @param {string} notification.author The user ID that made a request
                          * @param {number} notification.timestamp The timestamp the request was made at
                          */
-                    this.emit(Events.GROUP_MEMBERSHIP_REQUEST, notification);
-                } else {
-                    /**
+                        this.emit(
+                            Events.GROUP_MEMBERSHIP_REQUEST,
+                            notification,
+                        );
+                    } else {
+                        /**
                          * Emitted when group settings are updated, such as subject, description or picture.
                          * @event Client#group_update
                          * @param {GroupNotification} notification GroupNotification with more information about the action
                          */
-                    this.emit(Events.GROUP_UPDATE, notification);
+                        this.emit(Events.GROUP_UPDATE, notification);
+                    }
+                    return;
                 }
-                return;
-            }
 
-            const message = new Message(this, msg);
+                const message = new Message(this, msg);
 
-            /**
+                /**
                  * Emitted when a new message is created, which may include the current user's own messages.
                  * @event Client#message_create
                  * @param {Message} message The message that was created
                  */
-            this.emit(Events.MESSAGE_CREATE, message);
+                this.emit(Events.MESSAGE_CREATE, message);
 
-            if (msg.id.fromMe) return;
+                if (msg.id.fromMe) return;
 
-            /**
+                /**
                  * Emitted when a new message is received.
                  * @event Client#message
                  * @param {Message} message The message that was received
                  */
-            this.emit(Events.MESSAGE_RECEIVED, message);
-        });
+                this.emit(Events.MESSAGE_RECEIVED, message);
+            },
+        );
 
         let last_message;
 
-        await exposeFunctionIfAbsent(this.pupPage, 'onChangeMessageTypeEvent', (msg) => {
-
-            if (msg.type === 'revoked') {
-                const message = new Message(this, msg);
-                let revoked_msg;
-                if (last_message && msg.id.id === last_message.id.id) {
-                    revoked_msg = new Message(this, last_message);
-
-                    if (message.protocolMessageKey)
-                        revoked_msg.id = { ...message.protocolMessageKey };                    
-                }
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onChangeMessageTypeEvent',
+            (msg) => {
+                if (msg.type === 'revoked') {
+                    const message = new Message(this, msg);
+                    let revoked_msg;
+                    if (last_message && msg.id.id === last_message.id.id) {
+                        revoked_msg = new Message(this, last_message);
+
+                        if (message.protocolMessageKey)
+                            revoked_msg.id = { ...message.protocolMessageKey };
+                    }
 
-                /**
+                    /**
                      * Emitted when a message is deleted for everyone in the chat.
                      * @event Client#message_revoke_everyone
                      * @param {Message} message The message that was revoked, in its current state. It will not contain the original message's data.
-                     * @param {?Message} revoked_msg The message that was revoked, before it was revoked. It will contain the message's original data. 
+                     * @param {?Message} revoked_msg The message that was revoked, before it was revoked. It will contain the message's original data.
                      * Note that due to the way this data is captured, it may be possible that this param will be undefined.
                      */
-                this.emit(Events.MESSAGE_REVOKED_EVERYONE, message, revoked_msg);
-            }
-
-        });
-
-        await exposeFunctionIfAbsent(this.pupPage, 'onChangeMessageEvent', (msg) => {
-
-            if (msg.type !== 'revoked') {
-                last_message = msg;
-            }
+                    this.emit(
+                        Events.MESSAGE_REVOKED_EVERYONE,
+                        message,
+                        revoked_msg,
+                    );
+                }
+            },
+        );
+
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onChangeMessageEvent',
+            (msg) => {
+                if (msg.type !== 'revoked') {
+                    last_message = msg;
+                }
 
-            /**
+                /**
                  * The event notification that is received when one of
                  * the group participants changes their phone number.
                  */
-            const isParticipant = msg.type === 'gp2' && msg.subtype === 'modify';
+                const isParticipant =
+                    msg.type === 'gp2' && msg.subtype === 'modify';
 
-            /**
+                /**
                  * The event notification that is received when one of
                  * the contacts changes their phone number.
                  */
-            const isContact = msg.type === 'notification_template' && msg.subtype === 'change_number';
+                const isContact =
+                    msg.type === 'notification_template' &&
+                    msg.subtype === 'change_number';
 
-            if (isParticipant || isContact) {
-                /** @type {GroupNotification} object does not provide enough information about this event, so a @type {Message} object is used. */
-                const message = new Message(this, msg);
+                if (isParticipant || isContact) {
+                    /** @type {GroupNotification} object does not provide enough information about this event, so a @type {Message} object is used. */
+                    const message = new Message(this, msg);
 
-                const newId = isParticipant ? msg.recipients[0] : msg.to;
-                const oldId = isParticipant ? msg.author : msg.templateParams.find(id => id !== newId);
+                    const newId = isParticipant ? msg.recipients[0] : msg.to;
+                    const oldId = isParticipant
+                        ? msg.author
+                        : msg.templateParams.find((id) => id !== newId);
 
-                /**
+                    /**
                      * Emitted when a contact or a group participant changes their phone number.
                      * @event Client#contact_changed
                      * @param {Message} message Message with more information about the event.
@@ -518,98 +738,132 @@ class Client extends EventEmitter {
                      * @param {String} newId The user's new id after the change.
                      * @param {Boolean} isContact Indicates if a contact or a group participant changed their phone number.
                      */
-                this.emit(Events.CONTACT_CHANGED, message, oldId, newId, isContact);
-            }
-        });
-
-        await exposeFunctionIfAbsent(this.pupPage, 'onRemoveMessageEvent', (msg) => {
+                    this.emit(
+                        Events.CONTACT_CHANGED,
+                        message,
+                        oldId,
+                        newId,
+                        isContact,
+                    );
+                }
+            },
+        );
 
-            if (!msg.isNewMsg) return;
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onRemoveMessageEvent',
+            (msg) => {
+                if (!msg.isNewMsg) return;
 
-            const message = new Message(this, msg);
+                const message = new Message(this, msg);
 
-            /**
+                /**
                  * Emitted when a message is deleted by the current user.
                  * @event Client#message_revoke_me
                  * @param {Message} message The message that was revoked
                  */
-            this.emit(Events.MESSAGE_REVOKED_ME, message);
-
-        });
-
-        await exposeFunctionIfAbsent(this.pupPage, 'onMessageAckEvent', (msg, ack) => {
-
-            const message = new Message(this, msg);
+                this.emit(Events.MESSAGE_REVOKED_ME, message);
+            },
+        );
+
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onMessageAckEvent',
+            (msg, ack) => {
+                const message = new Message(this, msg);
 
-            /**
+                /**
                  * Emitted when an ack event occurrs on message type.
                  * @event Client#message_ack
                  * @param {Message} message The message that was affected
                  * @param {MessageAck} ack The new ACK value
                  */
-            this.emit(Events.MESSAGE_ACK, message, ack);
+                this.emit(Events.MESSAGE_ACK, message, ack);
+            },
+        );
 
-        });
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onChatUnreadCountEvent',
+            async (data) => {
+                const chat = await this.getChatById(data.id);
 
-        await exposeFunctionIfAbsent(this.pupPage, 'onChatUnreadCountEvent', async (data) =>{
-            const chat = await this.getChatById(data.id);
-                
-            /**
+                /**
                  * Emitted when the chat unread count changes
                  */
-            this.emit(Events.UNREAD_COUNT, chat);
-        });
-
-        await exposeFunctionIfAbsent(this.pupPage, 'onMessageMediaUploadedEvent', (msg) => {
-
-            const message = new Message(this, msg);
+                this.emit(Events.UNREAD_COUNT, chat);
+            },
+        );
+
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onMessageMediaUploadedEvent',
+            (msg) => {
+                const message = new Message(this, msg);
 
-            /**
+                /**
                  * Emitted when media has been uploaded for a message sent by the client.
                  * @event Client#media_uploaded
                  * @param {Message} message The message with media that was uploaded
                  */
-            this.emit(Events.MEDIA_UPLOADED, message);
-        });
-
-        await exposeFunctionIfAbsent(this.pupPage, 'onAppStateChangedEvent', async (state) => {
-            /**
+                this.emit(Events.MEDIA_UPLOADED, message);
+            },
+        );
+
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onAppStateChangedEvent',
+            async (state) => {
+                /**
                  * Emitted when the connection state changes
                  * @event Client#change_state
                  * @param {WAState} state the new connection state
                  */
-            this.emit(Events.STATE_CHANGED, state);
-
-            const ACCEPTED_STATES = [WAState.CONNECTED, WAState.OPENING, WAState.PAIRING, WAState.TIMEOUT];
-
-            if (this.options.takeoverOnConflict) {
-                ACCEPTED_STATES.push(WAState.CONFLICT);
-
-                if (state === WAState.CONFLICT) {
-                    setTimeout(() => {
-                        this.pupPage.evaluate(() => window.require('WAWebSocketModel').Socket.takeover());
-                    }, this.options.takeoverTimeoutMs);
+                this.emit(Events.STATE_CHANGED, state);
+
+                const ACCEPTED_STATES = [
+                    WAState.CONNECTED,
+                    WAState.OPENING,
+                    WAState.PAIRING,
+                    WAState.TIMEOUT,
+                ];
+
+                if (this.options.takeoverOnConflict) {
+                    ACCEPTED_STATES.push(WAState.CONFLICT);
+
+                    if (state === WAState.CONFLICT) {
+                        setTimeout(() => {
+                            this.pupPage.evaluate(() =>
+                                window
+                                    .require('WAWebSocketModel')
+                                    .Socket.takeover(),
+                            );
+                        }, this.options.takeoverTimeoutMs);
+                    }
                 }
-            }
 
-            if (!ACCEPTED_STATES.includes(state)) {
-                /**
+                if (!ACCEPTED_STATES.includes(state)) {
+                    /**
                      * Emitted when the client has been disconnected
                      * @event Client#disconnected
                      * @param {WAState|"LOGOUT"} reason reason that caused the disconnect
                      */
-                await this.authStrategy.disconnect();
-                this.emit(Events.DISCONNECTED, state);
-                this.destroy();
-            }
-        });
+                    await this.authStrategy.disconnect();
+                    this.emit(Events.DISCONNECTED, state);
+                    this.destroy();
+                }
+            },
+        );
 
-        await exposeFunctionIfAbsent(this.pupPage, 'onBatteryStateChangedEvent', (state) => {
-            const { battery, plugged } = state;
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onBatteryStateChangedEvent',
+            (state) => {
+                const { battery, plugged } = state;
 
-            if (battery === undefined) return;
+                if (battery === undefined) return;
 
-            /**
+                /**
                  * Emitted when the battery percentage for the attached device changes. Will not be sent if using multi-device.
                  * @event Client#change_battery
                  * @param {object} batteryInfo
@@ -617,30 +871,34 @@ class Client extends EventEmitter {
                  * @param {boolean} batteryInfo.plugged - Indicates if the phone is plugged in (true) or not (false)
                  * @deprecated
                  */
-            this.emit(Events.BATTERY_CHANGED, { battery, plugged });
-        });
+                this.emit(Events.BATTERY_CHANGED, { battery, plugged });
+            },
+        );
 
         await exposeFunctionIfAbsent(this.pupPage, 'onIncomingCall', (call) => {
             /**
-                 * Emitted when a call is received
-                 * @event Client#incoming_call
-                 * @param {object} call
-                 * @param {number} call.id - Call id
-                 * @param {string} call.peerJid - Who called
-                 * @param {boolean} call.isVideo - if is video
-                 * @param {boolean} call.isGroup - if is group
-                 * @param {boolean} call.canHandleLocally - if we can handle in waweb
-                 * @param {boolean} call.outgoing - if is outgoing
-                 * @param {boolean} call.webClientShouldHandle - If Waweb should handle
-                 * @param {object} call.participants - Participants
-                 */
+             * Emitted when a call is received
+             * @event Client#incoming_call
+             * @param {object} call
+             * @param {number} call.id - Call id
+             * @param {string} call.peerJid - Who called
+             * @param {boolean} call.isVideo - if is video
+             * @param {boolean} call.isGroup - if is group
+             * @param {boolean} call.canHandleLocally - if we can handle in waweb
+             * @param {boolean} call.outgoing - if is outgoing
+             * @param {boolean} call.webClientShouldHandle - If Waweb should handle
+             * @param {object} call.participants - Participants
+             */
             const cll = new Call(this, call);
             this.emit(Events.INCOMING_CALL, cll);
         });
 
-        await exposeFunctionIfAbsent(this.pupPage, 'onReaction', (reactions) => {
-            for (const reaction of reactions) {
-                /**
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onReaction',
+            (reactions) => {
+                for (const reaction of reactions) {
+                    /**
                      * Emitted when a reaction is sent, received, updated or removed
                      * @event Client#message_reaction
                      * @param {object} reaction
@@ -655,168 +913,357 @@ class Client extends EventEmitter {
                      * @param {?number} reaction.ack - Ack
                      */
 
-                this.emit(Events.MESSAGE_REACTION, new Reaction(this, reaction));
-            }
-        });
+                    this.emit(
+                        Events.MESSAGE_REACTION,
+                        new Reaction(this, reaction),
+                    );
+                }
+            },
+        );
 
-        await exposeFunctionIfAbsent(this.pupPage, 'onRemoveChatEvent', async (chat) => {
-            const _chat = await this.getChatById(chat.id);
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onRemoveChatEvent',
+            async (chat) => {
+                const _chat = await this.getChatById(chat.id);
 
-            /**
+                /**
                  * Emitted when a chat is removed
                  * @event Client#chat_removed
                  * @param {Chat} chat
                  */
-            this.emit(Events.CHAT_REMOVED, _chat);
-        });
-            
-        await exposeFunctionIfAbsent(this.pupPage, 'onArchiveChatEvent', async (chat, currState, prevState) => {
-            const _chat = await this.getChatById(chat.id);
-                
-            /**
+                this.emit(Events.CHAT_REMOVED, _chat);
+            },
+        );
+
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onArchiveChatEvent',
+            async (chat, currState, prevState) => {
+                const _chat = await this.getChatById(chat.id);
+
+                /**
                  * Emitted when a chat is archived/unarchived
                  * @event Client#chat_archived
                  * @param {Chat} chat
                  * @param {boolean} currState
                  * @param {boolean} prevState
                  */
-            this.emit(Events.CHAT_ARCHIVED, _chat, currState, prevState);
-        });
-
-        await exposeFunctionIfAbsent(this.pupPage, 'onEditMessageEvent', (msg, newBody, prevBody) => {
-                
-            if(msg.type === 'revoked'){
-                return;
-            }
-            /**
+                this.emit(Events.CHAT_ARCHIVED, _chat, currState, prevState);
+            },
+        );
+
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onEditMessageEvent',
+            (msg, newBody, prevBody) => {
+                if (msg.type === 'revoked') {
+                    return;
+                }
+                /**
                  * Emitted when messages are edited
                  * @event Client#message_edit
                  * @param {Message} message
                  * @param {string} newBody
                  * @param {string} prevBody
                  */
-            this.emit(Events.MESSAGE_EDIT, new Message(this, msg), newBody, prevBody);
-        });
-            
-        await exposeFunctionIfAbsent(this.pupPage, 'onAddMessageCiphertextEvent', msg => {
-                
-            /**
-                 * Emitted when messages are edited
+                this.emit(
+                    Events.MESSAGE_EDIT,
+                    new Message(this, msg),
+                    newBody,
+                    prevBody,
+                );
+            },
+        );
+
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onAddMessageCiphertextEvent',
+            (msg) => {
+                /**
+                 * Emitted when a message is received as ciphertext (not yet decrypted)
                  * @event Client#message_ciphertext
                  * @param {Message} message
                  */
-            this.emit(Events.MESSAGE_CIPHERTEXT, new Message(this, msg));
-        });
-
-        await exposeFunctionIfAbsent(this.pupPage, 'onPollVoteEvent', (votes) => {
-            for (const vote of votes) {
+                this.emit(Events.MESSAGE_CIPHERTEXT, new Message(this, msg));
+            },
+        );
+
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onCiphertextFailedEvent',
+            (msg) => {
                 /**
-                 * Emitted when some poll option is selected or deselected,
-                 * shows a user's current selected option(s) on the poll
-                 * @event Client#vote_update
+                 * Emitted when a ciphertext message failed to decrypt after recovery attempt
+                 * @event Client#message_ciphertext_failed
+                 * @param {Message} message
                  */
-                this.emit(Events.VOTE_UPDATE, new PollVote(this, vote));
-            }
-        });
+                this.emit(
+                    Events.MESSAGE_CIPHERTEXT_FAILED,
+                    new Message(this, msg),
+                );
+            },
+        );
+
+        await exposeFunctionIfAbsent(
+            this.pupPage,
+            'onPollVoteEvent',
+            (votes) => {
+                for (const vote of votes) {
+                    /**
+                     * Emitted when some poll option is selected or deselected,
+                     * shows a user's current selected option(s) on the poll
+                     * @event Client#vote_update
+                     */
+                    this.emit(Events.VOTE_UPDATE, new PollVote(this, vote));
+                }
+            },
+        );
 
         await this.pupPage.evaluate(() => {
-            const { Msg, Chat, WAWebCallCollection } = window.require('WAWebCollections');
+            const { Msg, Chat } = window.require('WAWebCollections');
             const AppState = window.require('WAWebSocketModel').Socket;
-            Msg.on('change', (msg) => { window.onChangeMessageEvent(window.WWebJS.getMessageModel(msg)); });
-            Msg.on('change:type', (msg) => { window.onChangeMessageTypeEvent(window.WWebJS.getMessageModel(msg)); });
-            Msg.on('change:ack', (msg, ack) => { window.onMessageAckEvent(window.WWebJS.getMessageModel(msg), ack); });
-            Msg.on('change:isUnsentMedia', (msg, unsent) => { if (msg.id.fromMe && !unsent) window.onMessageMediaUploadedEvent(window.WWebJS.getMessageModel(msg)); });
-            Msg.on('remove', (msg) => { if (msg.isNewMsg) window.onRemoveMessageEvent(window.WWebJS.getMessageModel(msg)); });
-            Msg.on('change:body change:caption', (msg, newBody, prevBody) => { window.onEditMessageEvent(window.WWebJS.getMessageModel(msg), newBody, prevBody); });
-            AppState.on('change:state', (_AppState, state) => { window.onAppStateChangedEvent(state); });
-            (window.require('WAWebConnModel').Conn).on('change:battery', (state) => { window.onBatteryStateChangedEvent(state); });
-            if (WAWebCallCollection && typeof WAWebCallCollection.on === 'function') {
-                WAWebCallCollection.on('add', (call) => { window.onIncomingCall(call); });
+
+            // Enable placeholder message resend (recovery for ciphertext messages)
+            const gatingUtils = window.require('WAWebSyncGatingUtils');
+            gatingUtils.isPlaceholderMessageResendEnabled = () => true;
+
+            Msg.on('change', (msg) => {
+                window.onChangeMessageEvent(window.WWebJS.getMessageModel(msg));
+            });
+            Msg.on('change:type', (msg) => {
+                window.onChangeMessageTypeEvent(
+                    window.WWebJS.getMessageModel(msg),
+                );
+            });
+            Msg.on('change:ack', (msg, ack) => {
+                window.onMessageAckEvent(
+                    window.WWebJS.getMessageModel(msg),
+                    ack,
+                );
+            });
+            Msg.on('change:isUnsentMedia', (msg, unsent) => {
+                if (msg.id.fromMe && !unsent)
+                    window.onMessageMediaUploadedEvent(
+                        window.WWebJS.getMessageModel(msg),
+                    );
+            });
+            Msg.on('remove', (msg) => {
+                if (msg.isNewMsg)
+                    window.onRemoveMessageEvent(
+                        window.WWebJS.getMessageModel(msg),
+                    );
+            });
+            Msg.on('change:body change:caption', (msg, newBody, prevBody) => {
+                window.onEditMessageEvent(
+                    window.WWebJS.getMessageModel(msg),
+                    newBody,
+                    prevBody,
+                );
+            });
+            AppState.on('change:state', (_AppState, state) => {
+                window.onAppStateChangedEvent(state);
+            });
+            window
+                .require('WAWebConnModel')
+                .Conn.on('change:battery', (state) => {
+                    window.onBatteryStateChangedEvent(state);
+                });
+            const WAWebCallCollection = window.require('WAWebCallCollection');
+            if (
+                WAWebCallCollection &&
+                typeof WAWebCallCollection.on === 'function'
+            ) {
+                const mapKey = Object.keys(WAWebCallCollection).find(
+                    (k) => WAWebCallCollection[k] instanceof Map,
+                );
+                const internalCallMap = WAWebCallCollection[mapKey];
+                const originalMapSet =
+                    internalCallMap.set.bind(internalCallMap);
+
+                internalCallMap.set = function (key, value) {
+                    window.onIncomingCall({
+                        id: value.id,
+                        peerJid: value.peerJid,
+                        isVideo: value.isVideo,
+                        isGroup: value.isGroup,
+                        canHandleLocally: value.canHandleLocally,
+                        outgoing: value.outgoing,
+                        webClientShouldHandle: value.webClientShouldHandle,
+                        participants: value.participants,
+                    });
+                    return originalMapSet(key, value);
+                };
             }
-            Chat.on('remove', async (chat) => { window.onRemoveChatEvent(await window.WWebJS.getChatModel(chat)); });
-            Chat.on('change:archive', async (chat, currState, prevState) => { window.onArchiveChatEvent(await window.WWebJS.getChatModel(chat), currState, prevState); });
-            Msg.on('add', (msg) => { 
-                if (msg.isNewMsg) {
-                    if(msg.type === 'ciphertext') {
-                        // defer message event until ciphertext is resolved (type changed)
-                        msg.once('change:type', (_msg) => window.onAddMessageEvent(window.WWebJS.getMessageModel(_msg)));
-                        window.onAddMessageCiphertextEvent(window.WWebJS.getMessageModel(msg));
-                    } else {
-                        window.onAddMessageEvent(window.WWebJS.getMessageModel(msg)); 
-                    }
-                }
+            Chat.on('remove', async (chat) => {
+                window.onRemoveChatEvent(
+                    await window.WWebJS.getChatModel(chat),
+                );
+            });
+            Chat.on('change:archive', async (chat, currState, prevState) => {
+                window.onArchiveChatEvent(
+                    await window.WWebJS.getChatModel(chat),
+                    currState,
+                    prevState,
+                );
             });
-            Chat.on('change:unreadCount', (chat) => {window.onChatUnreadCountEvent(chat);});
+            const pendingResend = new Set();
+            let resendFlush = null;
+
+            function requestResend(msg) {
+                pendingResend.add(msg);
+                if (resendFlush) return;
+                resendFlush = setTimeout(() => {
+                    resendFlush = null;
+                    const msgs = [...pendingResend];
+                    pendingResend.clear();
+                    if (msgs.length === 0) return;
+                    window
+                        .require(
+                            'WAWebNonMessageDataRequestPlaceholderMessageResendUtils',
+                        )
+                        .handlePlaceholderMsgsSeen(msgs, true);
+                }, 5000);
+            }
 
-            window.WWebJS.injectToFunction({ module: 'WAWebAddonReactionTableMode', function: 'reactionTableMode.bulkUpsert'}, (module, origFunction, ...args) => {
-                window.onReaction(args[0].map(reaction => {
-                    const msgKey = reaction.id;
-                    const parentMsgKey = reaction.reactionParentKey;
-                    const timestamp = reaction.reactionTimestamp / 1000;
-                    const sender = reaction.author ?? reaction.from;
-                    const senderUserJid = sender._serialized;
+            Msg.on('add', (msg) => {
+                if (!msg.isNewMsg) return;
 
-                    return {...reaction, msgKey, parentMsgKey, senderUserJid, timestamp };
-                }));
+                if (msg.type !== 'ciphertext') {
+                    window.onAddMessageEvent(
+                        window.WWebJS.getMessageModel(msg),
+                    );
+                    return;
+                }
 
-                return origFunction.apply(module, args);
-            });
-            
-            window.WWebJS.injectToFunction({ module: 'WAWebAddonPollVoteTableMode', function: 'pollVoteTableMode.bulkUpsert'}, async (module, origFunction, ...args) => {
-                const votes = await Promise.all(args[0].map(async vote => {
-                    const msgKey = vote.id;
-                    const parentMsgKey = vote.pollUpdateParentKey;
-                    const timestamp = vote.t / 1000;
-                    const sender = vote.author ?? vote.from;
-                    const senderUserJid = sender._serialized;
-
-                    let parentMessage = Msg.get(parentMsgKey._serialized);
-                    if (!parentMessage) {
-                        const fetched = await Msg.getMessagesById([parentMsgKey._serialized]);
-                        parentMessage = fetched?.messages?.[0] || null;
-                    }
+                window.onAddMessageCiphertextEvent(
+                    window.WWebJS.getMessageModel(msg),
+                );
 
-                    return {
-                        ...vote,
-                        msgKey,
-                        sender,
-                        parentMsgKey,
-                        senderUserJid,
-                        timestamp,
-                        parentMessage
-                    };
-                }));
+                if (msg.subtype && msg.subtype.endsWith('_unavailable_fanout'))
+                    return;
 
-                window.onPollVoteEvent(votes);
+                requestResend(msg);
 
-                return origFunction.apply(module, args);
+                const failTimer = setTimeout(() => {
+                    if (msg.type !== 'ciphertext') return;
+                    window.onCiphertextFailedEvent(
+                        window.WWebJS.getMessageModel(msg),
+                    );
+                }, 15000);
+
+                msg.once('change:type', (_msg) => {
+                    clearTimeout(failTimer);
+                    pendingResend.delete(_msg);
+                    if (_msg.type === 'revoked') return;
+                    window.onAddMessageEvent(
+                        window.WWebJS.getMessageModel(_msg),
+                    );
+                });
+            });
+            Chat.on('change:unreadCount', (chat) => {
+                window.onChatUnreadCountEvent(chat);
             });
+
+            window.WWebJS.injectToFunction(
+                {
+                    module: 'WAWebAddonReactionTableMode',
+                    function: 'reactionTableMode.bulkUpsert',
+                },
+                (module, origFunction, ...args) => {
+                    window.onReaction(
+                        args[0].map((reaction) => {
+                            const msgKey = reaction.id;
+                            const parentMsgKey = reaction.reactionParentKey;
+                            const timestamp = reaction.reactionTimestamp / 1000;
+                            const sender = reaction.author ?? reaction.from;
+                            const senderUserJid = sender._serialized;
+
+                            return {
+                                ...reaction,
+                                msgKey,
+                                parentMsgKey,
+                                senderUserJid,
+                                timestamp,
+                            };
+                        }),
+                    );
+
+                    return origFunction.apply(module, args);
+                },
+            );
+
+            window.WWebJS.injectToFunction(
+                {
+                    module: 'WAWebAddonPollVoteTableMode',
+                    function: 'pollVoteTableMode.bulkUpsert',
+                },
+                async (module, origFunction, ...args) => {
+                    const votes = await Promise.all(
+                        args[0].map(async (vote) => {
+                            const msgKey = vote.id;
+                            const parentMsgKey = vote.pollUpdateParentKey;
+                            const timestamp = vote.t / 1000;
+                            const sender = vote.author ?? vote.from;
+                            const senderUserJid = sender._serialized;
+
+                            let parentMessage = Msg.get(
+                                parentMsgKey._serialized,
+                            );
+                            if (!parentMessage) {
+                                const fetched = await Msg.getMessagesById([
+                                    parentMsgKey._serialized,
+                                ]);
+                                parentMessage = fetched?.messages?.[0] || null;
+                            }
+
+                            return {
+                                ...vote,
+                                msgKey,
+                                sender,
+                                parentMsgKey,
+                                senderUserJid,
+                                timestamp,
+                                parentMessage,
+                            };
+                        }),
+                    );
+
+                    window.onPollVoteEvent(votes);
+
+                    return origFunction.apply(module, args);
+                },
+            );
         });
-    }    
+    }
 
     async initWebVersionCache() {
-        const { type: webCacheType, ...webCacheOptions } = this.options.webVersionCache;
-        const webCache = WebCacheFactory.createWebCache(webCacheType, webCacheOptions);
+        const { type: webCacheType, ...webCacheOptions } =
+            this.options.webVersionCache;
+        const webCache = WebCacheFactory.createWebCache(
+            webCacheType,
+            webCacheOptions,
+        );
 
         const requestedVersion = this.options.webVersion;
         const versionContent = await webCache.resolve(requestedVersion);
 
-        if(versionContent) {
+        if (versionContent) {
             await this.pupPage.setRequestInterception(true);
             this.pupPage.on('request', async (req) => {
-                if(req.url() === WhatsWebURL) {
+                if (req.url() === WhatsWebURL) {
                     req.respond({
                         status: 200,
                         contentType: 'text/html',
-                        body: versionContent
-                    }); 
+                        body: versionContent,
+                    });
                 } else {
                     req.continue();
                 }
             });
         } else {
             this.pupPage.on('response', async (res) => {
-                if(res.ok() && res.url() === WhatsWebURL) {
+                if (res.ok() && res.url() === WhatsWebURL) {
                     const indexHtml = await res.text();
                     this.currentIndexHtml = indexHtml;
                 }
@@ -844,13 +1291,14 @@ class Client extends EventEmitter {
             return window.require('WAWebSocketModel').Socket.logout();
         });
         await this.pupBrowser.close();
-        
+
         let maxDelay = 0;
-        while (this.pupBrowser.isConnected() && (maxDelay < 10)) { // waits a maximum of 1 second before calling the AuthStrategy
-            await new Promise(resolve => setTimeout(resolve, 100));
-            maxDelay++; 
+        while (this.pupBrowser.isConnected() && maxDelay < 10) {
+            // waits a maximum of 1 second before calling the AuthStrategy
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            maxDelay++;
         }
-        
+
         await this.authStrategy.logout();
     }
 
@@ -865,23 +1313,28 @@ class Client extends EventEmitter {
     }
 
     async setDeviceName(deviceName, browserName) {
-        (deviceName || browserName) && await this.pupPage.evaluate((deviceName, browserName) => {
-            const func = window.require('WAWebMiscBrowserUtils').info;
-            window.require('WAWebMiscBrowserUtils').info = () => {
-                return {
-                    ...func(),
-                    ...(deviceName ? { os: deviceName } : {}),
-                    ...(browserName ? { name: browserName } : {})
-                };
-            };
-        }, deviceName, browserName);
+        (deviceName || browserName) &&
+            (await this.pupPage.evaluate(
+                (deviceName, browserName) => {
+                    const func = window.require('WAWebMiscBrowserUtils').info;
+                    window.require('WAWebMiscBrowserUtils').info = () => {
+                        return {
+                            ...func(),
+                            ...(deviceName ? { os: deviceName } : {}),
+                            ...(browserName ? { name: browserName } : {}),
+                        };
+                    };
+                },
+                deviceName,
+                browserName,
+            ));
     }
 
     /**
      * Mark as seen for the Chat
      *  @param {string} chatId
      *  @returns {Promise<boolean>} result
-     * 
+     *
      */
     async sendSeen(chatId) {
         return await this.pupPage.evaluate(async (chatId) => {
@@ -921,50 +1374,84 @@ class Client extends EventEmitter {
      * @property {MessageMedia} [media] - Media to be sent
      * @property {any} [extra] - Extra options
      */
-    
+
     /**
      * Send a message to a specific chatId
      * @param {string} chatId
      * @param {string|MessageMedia|Location|Poll|Contact|Array<Contact>|Buttons|List} content
      * @param {MessageSendOptions} [options] - Options used when sending the message
-     * 
+     *
      * @returns {Promise<Message>} Message that was just sent
      */
     async sendMessage(chatId, content, options = {}) {
         const isChannel = /@\w*newsletter\b/.test(chatId);
         const isStatus = /@\w*broadcast\b/.test(chatId);
 
-        if (isChannel && [
-            options.sendMediaAsDocument, options.quotedMessageId,
-            options.parseVCards, options.isViewOnce,
-            content instanceof Location, content instanceof Contact,
-            content instanceof Buttons, content instanceof List,
-            Array.isArray(content) && content.length > 0 && content[0] instanceof Contact
-        ].includes(true)) {
-            console.warn('The message type is currently not supported for sending in channels,\nthe supported message types are: text, image, sticker, gif, video, voice and poll.');
+        if (
+            isChannel &&
+            [
+                options.sendMediaAsDocument,
+                options.quotedMessageId,
+                options.parseVCards,
+                options.isViewOnce,
+                content instanceof Location,
+                content instanceof Contact,
+                content instanceof Buttons,
+                content instanceof List,
+                Array.isArray(content) &&
+                    content.length > 0 &&
+                    content[0] instanceof Contact,
+            ].includes(true)
+        ) {
+            console.warn(
+                'The message type is currently not supported for sending in channels,\nthe supported message types are: text, image, sticker, gif, video, voice and poll.',
+            );
             return null;
-
-        } else if (isStatus && [
-            options.sendMediaAsDocument, options.quotedMessageId,
-            options.parseVCards, options.isViewOnce, options.sendMediaAsSticker,
-            content instanceof Location, content instanceof Contact,
-            content instanceof Poll, content instanceof Buttons, content instanceof List,
-            Array.isArray(content) && content.length > 0 && content[0] instanceof Contact
-        ].includes(true)) {
-            console.warn('The message type is currently not supported for sending in status broadcast,\nthe supported message types are: text, image, gif, audio and video.');
+        } else if (
+            isStatus &&
+            [
+                options.sendMediaAsDocument,
+                options.quotedMessageId,
+                options.parseVCards,
+                options.isViewOnce,
+                options.sendMediaAsSticker,
+                content instanceof Location,
+                content instanceof Contact,
+                content instanceof Poll,
+                content instanceof Buttons,
+                content instanceof List,
+                Array.isArray(content) &&
+                    content.length > 0 &&
+                    content[0] instanceof Contact,
+            ].includes(true)
+        ) {
+            console.warn(
+                'The message type is currently not supported for sending in status broadcast,\nthe supported message types are: text, image, gif, audio and video.',
+            );
             return null;
         }
-    
+
         if (options.mentions) {
-            !Array.isArray(options.mentions) && (options.mentions = [options.mentions]);
-            if (options.mentions.some((possiblyContact) => possiblyContact instanceof Contact)) {
-                console.warn('Mentions with an array of Contact are now deprecated. See more at https://github.com/pedroslopez/whatsapp-web.js/pull/2166.');
-                options.mentions = options.mentions.map((a) => a.id._serialized);
+            !Array.isArray(options.mentions) &&
+                (options.mentions = [options.mentions]);
+            if (
+                options.mentions.some(
+                    (possiblyContact) => possiblyContact instanceof Contact,
+                )
+            ) {
+                console.warn(
+                    'Mentions with an array of Contact are now deprecated. See more at https://github.com/wwebjssapp-web.js/pull/2166.',
+                );
+                options.mentions = options.mentions.map(
+                    (a) => a.id._serialized,
+                );
             }
         }
 
-        options.groupMentions && !Array.isArray(options.groupMentions) && (options.groupMentions = [options.groupMentions]);
-        
+        options.groupMentions &&
+            !Array.isArray(options.groupMentions) &&
+            (options.groupMentions = [options.groupMentions]);
+
         let internalOptions = {
             linkPreview: options.linkPreview === false ? undefined : true,
             sendAudioAsVoice: options.sendAudioAsVoice,
@@ -981,20 +1468,18 @@ class Client extends EventEmitter {
             invokedBotWid: options.invokedBotWid,
             ignoreQuoteErrors: options.ignoreQuoteErrors !== false,
             waitUntilMsgSent: options.waitUntilMsgSent || false,
-            extraOptions: options.extra
+            extraOptions: options.extra,
         };
 
         const sendSeen = options.sendSeen !== false;
 
         if (content instanceof MessageMedia) {
             internalOptions.media = content;
-            internalOptions.isViewOnce = options.isViewOnce,
-            content = '';
+            ((internalOptions.isViewOnce = options.isViewOnce), (content = ''));
         } else if (options.media instanceof MessageMedia) {
             internalOptions.media = options.media;
             internalOptions.caption = content;
-            internalOptions.isViewOnce = options.isViewOnce,
-            content = '';
+            ((internalOptions.isViewOnce = options.isViewOnce), (content = ''));
         } else if (content instanceof Location) {
             internalOptions.location = content;
             content = '';
@@ -1007,48 +1492,97 @@ class Client extends EventEmitter {
         } else if (content instanceof Contact) {
             internalOptions.contactCard = content.id._serialized;
             content = '';
-        } else if (Array.isArray(content) && content.length > 0 && content[0] instanceof Contact) {
-            internalOptions.contactCardList = content.map(contact => contact.id._serialized);
+        } else if (
+            Array.isArray(content) &&
+            content.length > 0 &&
+            content[0] instanceof Contact
+        ) {
+            internalOptions.contactCardList = content.map(
+                (contact) => contact.id._serialized,
+            );
             content = '';
         } else if (content instanceof Buttons) {
-            console.warn('Buttons are now deprecated. See more at https://www.youtube.com/watch?v=hv1R1rLeVVE.');
-            if (content.type !== 'chat') { internalOptions.attachment = content.body; }
+            console.warn(
+                'Buttons are now deprecated. See more at https://www.youtube.com/watch?v=hv1R1rLeVVE.',
+            );
+            if (content.type !== 'chat') {
+                internalOptions.attachment = content.body;
+            }
             internalOptions.buttons = content;
             content = '';
         } else if (content instanceof List) {
-            console.warn('Lists are now deprecated. See more at https://www.youtube.com/watch?v=hv1R1rLeVVE.');
+            console.warn(
+                'Lists are now deprecated. See more at https://www.youtube.com/watch?v=hv1R1rLeVVE.',
+            );
             internalOptions.list = content;
             content = '';
         }
 
         if (internalOptions.sendMediaAsSticker && internalOptions.media) {
             internalOptions.media = await Util.formatToWebpSticker(
-                internalOptions.media, {
+                internalOptions.media,
+                {
                     name: options.stickerName,
                     author: options.stickerAuthor,
-                    categories: options.stickerCategories
-                }, this.pupPage
+                    categories: options.stickerCategories,
+                },
+                this.pupPage,
             );
         }
 
-        const sentMsg = await this.pupPage.evaluate(async (chatId, content, options, sendSeen) => {
-            const chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
-
-            if (!chat) return null;
+        const sentMsg = await this.pupPage.evaluate(
+            async (chatId, content, options, sendSeen) => {
+                const chat = await window.WWebJS.getChat(chatId, {
+                    getAsModel: false,
+                });
 
-            if (sendSeen) {
-                await window.WWebJS.sendSeen(chatId);
-            }
+                if (!chat) return null;
 
-            const msg = await window.WWebJS.sendMessage(chat, content, options);
-            return msg
-                ? window.WWebJS.getMessageModel(msg)
-                : undefined;
-        }, chatId, content, internalOptions, sendSeen);
+                if (sendSeen) {
+                    await window.WWebJS.sendSeen(chatId);
+                }
 
-        return sentMsg
-            ? new Message(this, sentMsg)
-            : undefined;
+                const msg = await window.WWebJS.sendMessage(
+                    chat,
+                    content,
+                    options,
+                );
+                return msg ? window.WWebJS.getMessageModel(msg) : undefined;
+            },
+            chatId,
+            content,
+            internalOptions,
+            sendSeen,
+        );
+
+        return sentMsg ? new Message(this, sentMsg) : undefined;
+    }
+
+    /**
+     * Send an emoji reaction to a specific message
+     * @param {string} messageId - Id of the message to add the reaction.
+     * @param {string} reaction  - Emoji to react with. Send an empty string to remove the reaction.
+     * @return {Promise}
+     */
+    async sendReaction(messageId, reaction) {
+        await this.pupPage.evaluate(
+            async (messageId, reaction) => {
+                if (!messageId) return null;
+                const msg =
+                    window.require('WAWebCollections').Msg.get(messageId) ||
+                    (
+                        await window
+                            .require('WAWebCollections')
+                            .Msg.getMessagesById([messageId])
+                    )?.messages?.[0];
+                if (!msg) return null;
+                await window
+                    .require('WAWebSendReactionMsgAction')
+                    .sendReactionToMsg(msg, reaction);
+            },
+            messageId,
+            reaction,
+        );
     }
 
     /**
@@ -1060,34 +1594,45 @@ class Client extends EventEmitter {
      * Sends a channel admin invitation to a user, allowing them to become an admin of the channel
      * @param {string} chatId The ID of a user to send the channel admin invitation to
      * @param {string} channelId The ID of a channel for which the invitation is being sent
-     * @param {SendChannelAdminInviteOptions} options 
+     * @param {SendChannelAdminInviteOptions} options
      * @returns {Promise<boolean>} Returns true if an invitation was sent successfully, false otherwise
      */
     async sendChannelAdminInvite(chatId, channelId, options = {}) {
-        const response = await this.pupPage.evaluate(async (chatId, channelId, options) => {
-            const { createWid } = window.require('WAWebWidFactory');
-            const channelWid = createWid(channelId);
-            const chatWid = createWid(chatId);
-            const chat = window.require('WAWebCollections').Chat.get(chatWid) || (await (window.require('WAWebCollections')).Chat.find(chatWid));
-
-            if (!chatWid.isUser()) {
-                return false;
-            }
-            
-            return await (window.require('WAWebNewsletterSendMsgAction')).sendNewsletterAdminInviteMessage(
-                chat,
-                {
-                    newsletterWid: channelWid,
-                    invitee: chatWid,
-                    inviteMessage: options.comment,
-                    base64Thumb: await window.WWebJS.getProfilePicThumbToBase64(channelWid)
+        const response = await this.pupPage.evaluate(
+            async (chatId, channelId, options) => {
+                const { createWid } = window.require('WAWebWidFactory');
+                const channelWid = createWid(channelId);
+                const chatWid = createWid(chatId);
+                const chat =
+                    window.require('WAWebCollections').Chat.get(chatWid) ||
+                    (await window
+                        .require('WAWebCollections')
+                        .Chat.find(chatWid));
+
+                if (!chatWid.isUser()) {
+                    return false;
                 }
-            );
-        }, chatId, channelId, options);
+
+                return await window
+                    .require('WAWebNewsletterSendMsgAction')
+                    .sendNewsletterAdminInviteMessage(chat, {
+                        newsletterWid: channelWid,
+                        invitee: chatWid,
+                        inviteMessage: options.comment,
+                        base64Thumb:
+                            await window.WWebJS.getProfilePicThumbToBase64(
+                                channelWid,
+                            ),
+                    });
+            },
+            chatId,
+            channelId,
+            options,
+        );
 
         return response.messageSendResult === 'OK';
     }
-    
+
     /**
      * Searches for messages
      * @param {string} query
@@ -1098,12 +1643,22 @@ class Client extends EventEmitter {
      * @returns {Promise<Message[]>}
      */
     async searchMessages(query, options = {}) {
-        const messages = await this.pupPage.evaluate(async (query, page, count, remote) => {
-            const { messages } = await (window.require('WAWebCollections')).Msg.search(query, page, count, remote);
-            return messages.map(msg => window.WWebJS.getMessageModel(msg));
-        }, query, options.page, options.limit, options.chatId);
+        const messages = await this.pupPage.evaluate(
+            async (query, page, count, remote) => {
+                const { messages } = await window
+                    .require('WAWebCollections')
+                    .Msg.search(query, page, count, remote);
+                return messages.map((msg) =>
+                    window.WWebJS.getMessageModel(msg),
+                );
+            },
+            query,
+            options.page,
+            options.limit,
+            options.chatId,
+        );
 
-        return messages.map(msg => new Message(this, msg));
+        return messages.map((msg) => new Message(this, msg));
     }
 
     /**
@@ -1115,7 +1670,7 @@ class Client extends EventEmitter {
             return await window.WWebJS.getChats();
         });
 
-        return chats.map(chat => ChatFactory.create(this, chat));
+        return chats.map((chat) => ChatFactory.create(this, chat));
     }
 
     /**
@@ -1132,16 +1687,14 @@ class Client extends EventEmitter {
 
     /**
      * Gets chat or channel instance by ID
-     * @param {string} chatId 
+     * @param {string} chatId
      * @returns {Promise<Chat|Channel>}
      */
     async getChatById(chatId) {
-        const chat = await this.pupPage.evaluate(async chatId => {
+        const chat = await this.pupPage.evaluate(async (chatId) => {
             return await window.WWebJS.getChat(chatId);
         }, chatId);
-        return chat
-            ? ChatFactory.create(this, chat)
-            : undefined;
+        return chat ? ChatFactory.create(this, chat) : undefined;
     }
 
     /**
@@ -1153,7 +1706,8 @@ class Client extends EventEmitter {
         const channel = await this.pupPage.evaluate(async (inviteCode) => {
             let channelMetadata;
             try {
-                channelMetadata = await window.WWebJS.getChannelMetadata(inviteCode);
+                channelMetadata =
+                    await window.WWebJS.getChannelMetadata(inviteCode);
             } catch (err) {
                 if (err.name === 'ServerStatusCodeError') return null;
                 throw err;
@@ -1161,9 +1715,7 @@ class Client extends EventEmitter {
             return await window.WWebJS.getChat(channelMetadata.id);
         }, inviteCode);
 
-        return channel
-            ? ChatFactory.create(this, channel)
-            : undefined;
+        return channel ? ChatFactory.create(this, channel) : undefined;
     }
 
     /**
@@ -1175,7 +1727,7 @@ class Client extends EventEmitter {
             return window.WWebJS.getContacts();
         });
 
-        return contacts.map(contact => ContactFactory.create(this, contact));
+        return contacts.map((contact) => ContactFactory.create(this, contact));
     }
 
     /**
@@ -1184,7 +1736,7 @@ class Client extends EventEmitter {
      * @returns {Promise<Contact>}
      */
     async getContactById(contactId) {
-        let contact = await this.pupPage.evaluate(contactId => {
+        let contact = await this.pupPage.evaluate((contactId) => {
             return window.WWebJS.getContact(contactId);
         }, contactId);
 
@@ -1197,20 +1749,24 @@ class Client extends EventEmitter {
      * @returns {Promise<Message>}
      */
     async getMessageById(messageId) {
-        const msg = await this.pupPage.evaluate(async messageId => {
-            let msg = (window.require('WAWebCollections')).Msg.get(messageId);
-            if(msg) return window.WWebJS.getMessageModel(msg);
+        const msg = await this.pupPage.evaluate(async (messageId) => {
+            let msg = window.require('WAWebCollections').Msg.get(messageId);
+            if (msg) return window.WWebJS.getMessageModel(msg);
 
             const params = messageId.split('_');
-            if (params.length !== 3 && params.length !== 4) throw new Error('Invalid serialized message id specified');
+            if (params.length !== 3 && params.length !== 4)
+                throw new Error('Invalid serialized message id specified');
+
+            let messagesObject = await window
+                .require('WAWebCollections')
+                .Msg.getMessagesById([messageId]);
+            if (messagesObject && messagesObject.messages.length)
+                msg = messagesObject.messages[0];
 
-            let messagesObject = await (window.require('WAWebCollections')).Msg.getMessagesById([messageId]);
-            if (messagesObject && messagesObject.messages.length) msg = messagesObject.messages[0];
-            
-            if(msg) return window.WWebJS.getMessageModel(msg);
+            if (msg) return window.WWebJS.getMessageModel(msg);
         }, messageId);
 
-        if(msg) return new Message(this, msg);
+        if (msg) return new Message(this, msg);
         return null;
     }
 
@@ -1222,23 +1778,36 @@ class Client extends EventEmitter {
     async getPinnedMessages(chatId) {
         const pinnedMsgs = await this.pupPage.evaluate(async (chatId) => {
             const chatWid = window.require('WAWebWidFactory').createWid(chatId);
-            const chat = (window.require('WAWebCollections')).Chat.get(chatWid) ?? await (window.require('WAWebCollections')).Chat.find(chatWid);
+            const chat =
+                window.require('WAWebCollections').Chat.get(chatWid) ??
+                (await window.require('WAWebCollections').Chat.find(chatWid));
             if (!chat) return [];
-            
-            const msgs = await (window.require('WAWebPinInChatSchema')).getTable().equals(['chatId'], chatWid.toString());
+
+            const msgs = await window
+                .require('WAWebPinInChatSchema')
+                .getTable()
+                .equals(['chatId'], chatWid.toString());
 
             const pinnedMsgs = (
                 await Promise.all(
-                    msgs.filter(msg => msg.pinType == 1).map(async (msg) => {
-                        const res = await (window.require('WAWebCollections')).Msg.getMessagesById([msg.parentMsgKey]);
-                        return res?.messages?.[0];
-                    })
+                    msgs
+                        .filter((msg) => msg.pinType == 1)
+                        .map(async (msg) => {
+                            const res = await window
+                                .require('WAWebCollections')
+                                .Msg.getMessagesById([msg.parentMsgKey]);
+                            return res?.messages?.[0];
+                        }),
                 )
             ).filter(Boolean);
 
             return !pinnedMsgs.length
                 ? []
-                : await Promise.all(pinnedMsgs.map((msg) => window.WWebJS.getMessageModel(msg)));
+                : await Promise.all(
+                      pinnedMsgs.map((msg) =>
+                          window.WWebJS.getMessageModel(msg),
+                      ),
+                  );
         }, chatId);
 
         return pinnedMsgs.map((msg) => new Message(this, msg));
@@ -1246,12 +1815,14 @@ class Client extends EventEmitter {
 
     /**
      * Returns an object with information about the invite code's group
-     * @param {string} inviteCode 
+     * @param {string} inviteCode
      * @returns {Promise<object>} Invite information
      */
     async getInviteInfo(inviteCode) {
-        return await this.pupPage.evaluate(inviteCode => {
-            return (window.require('WAWebGroupQueryJob')).queryGroupInvite(inviteCode);
+        return await this.pupPage.evaluate((inviteCode) => {
+            return window
+                .require('WAWebGroupQueryJob')
+                .queryGroupInvite(inviteCode);
         }, inviteCode);
     }
 
@@ -1261,8 +1832,10 @@ class Client extends EventEmitter {
      * @returns {Promise<string>} Id of the joined Chat
      */
     async acceptInvite(inviteCode) {
-        const res = await this.pupPage.evaluate(async inviteCode => {
-            return await (window.require('WAWebGroupQueryJob')).joinGroupViaInvite(inviteCode);
+        const res = await this.pupPage.evaluate(async (inviteCode) => {
+            return await window
+                .require('WAWebGroupInviteJob')
+                .joinGroupViaInvite(inviteCode);
         }, inviteCode);
 
         return res.gid._serialized;
@@ -1276,7 +1849,9 @@ class Client extends EventEmitter {
     async acceptChannelAdminInvite(channelId) {
         return await this.pupPage.evaluate(async (channelId) => {
             try {
-                await (window.require('WAWebMexAcceptNewsletterAdminInviteJob')).acceptNewsletterAdminInvite(channelId);
+                await window
+                    .require('WAWebMexAcceptNewsletterAdminInviteJob')
+                    .acceptNewsletterAdminInvite(channelId);
                 return true;
             } catch (err) {
                 if (err.name === 'ServerStatusCodeError') return false;
@@ -1292,16 +1867,24 @@ class Client extends EventEmitter {
      * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
      */
     async revokeChannelAdminInvite(channelId, userId) {
-        return await this.pupPage.evaluate(async (channelId, userId) => {
-            try {
-                const userWid = window.require('WAWebWidFactory').createWid(userId);
-                await (window.require('WAWebMexRevokeNewsletterAdminInviteJob')).revokeNewsletterAdminInvite(channelId, userWid);
-                return true;
-            } catch (err) {
-                if (err.name === 'ServerStatusCodeError') return false;
-                throw err;
-            }
-        }, channelId, userId);
+        return await this.pupPage.evaluate(
+            async (channelId, userId) => {
+                try {
+                    const userWid = window
+                        .require('WAWebWidFactory')
+                        .createWid(userId);
+                    await window
+                        .require('WAWebMexRevokeNewsletterAdminInviteJob')
+                        .revokeNewsletterAdminInvite(channelId, userWid);
+                    return true;
+                } catch (err) {
+                    if (err.name === 'ServerStatusCodeError') return false;
+                    throw err;
+                }
+            },
+            channelId,
+            userId,
+        );
     }
 
     /**
@@ -1311,16 +1894,24 @@ class Client extends EventEmitter {
      * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
      */
     async demoteChannelAdmin(channelId, userId) {
-        return await this.pupPage.evaluate(async (channelId, userId) => {
-            try {
-                const userWid = window.require('WAWebWidFactory').createWid(userId);
-                await (window.require('WAWebDemoteNewsletterAdminAction')).demoteNewsletterAdmin(channelId, userWid);
-                return true;
-            } catch (err) {
-                if (err.name === 'ServerStatusCodeError') return false;
-                throw err;
-            }
-        }, channelId, userId);
+        return await this.pupPage.evaluate(
+            async (channelId, userId) => {
+                try {
+                    const userWid = window
+                        .require('WAWebWidFactory')
+                        .createWid(userId);
+                    await window
+                        .require('WAWebDemoteNewsletterAdminAction')
+                        .demoteNewsletterAdmin(channelId, userWid);
+                    return true;
+                } catch (err) {
+                    if (err.name === 'ServerStatusCodeError') return false;
+                    throw err;
+                }
+            },
+            channelId,
+            userId,
+        );
     }
 
     /**
@@ -1329,12 +1920,20 @@ class Client extends EventEmitter {
      * @returns {Promise<Object>}
      */
     async acceptGroupV4Invite(inviteInfo) {
-        if (!inviteInfo.inviteCode) throw 'Invalid invite code, try passing the message.inviteV4 object';
+        if (!inviteInfo.inviteCode)
+            throw 'Invalid invite code, try passing the message.inviteV4 object';
         if (inviteInfo.inviteCodeExp == 0) throw 'Expired invite code';
-        return this.pupPage.evaluate(async inviteInfo => {
+        return this.pupPage.evaluate(async (inviteInfo) => {
             let { groupId, fromId, inviteCode, inviteCodeExp } = inviteInfo;
             let userWid = window.require('WAWebWidFactory').createWid(fromId);
-            return await (window.require('WAWebGroupInviteV4Job')).joinGroupViaInviteV4(inviteCode, String(inviteCodeExp), groupId, userWid);
+            return await window
+                .require('WAWebGroupInviteV4Job')
+                .joinGroupViaInviteV4(
+                    inviteCode,
+                    String(inviteCodeExp),
+                    groupId,
+                    userWid,
+                );
         }, inviteInfo);
     }
 
@@ -1343,30 +1942,35 @@ class Client extends EventEmitter {
      * @param {string} status New status message
      */
     async setStatus(status) {
-        await this.pupPage.evaluate(async status => {
-            return await (window.require('WAWebContactStatusBridge')).setMyStatus(status);
+        await this.pupPage.evaluate(async (status) => {
+            return await window
+                .require('WAWebContactStatusBridge')
+                .setMyStatus(status);
         }, status);
     }
 
     /**
-     * Sets the current user's display name. 
+     * Sets the current user's display name.
      * This is the name shown to WhatsApp users that have not added you as a contact beside your number in groups and in your profile.
      * @param {string} displayName New display name
      * @returns {Promise<Boolean>}
      */
     async setDisplayName(displayName) {
-        const couldSet = await this.pupPage.evaluate(async displayName => {
-            if(!(window.require('WAWebConnModel').Conn).canSetMyPushname()) return false;
-            await (window.require('WAWebSetPushnameConnAction')).setPushname(displayName);
+        const couldSet = await this.pupPage.evaluate(async (displayName) => {
+            if (!window.require('WAWebConnModel').Conn.canSetMyPushname())
+                return false;
+            await window
+                .require('WAWebSetPushnameConnAction')
+                .setPushname(displayName);
             return true;
         }, displayName);
 
         return couldSet;
     }
-    
+
     /**
      * Gets the current connection state for the client
-     * @returns {WAState} 
+     * @returns {WAState}
      */
     async getState() {
         return await this.pupPage.evaluate(() => {
@@ -1379,7 +1983,9 @@ class Client extends EventEmitter {
      */
     async sendPresenceAvailable() {
         return await this.pupPage.evaluate(() => {
-            return window.require('WAWebPresenceChatAction').sendPresenceAvailable();
+            return window
+                .require('WAWebPresenceChatAction')
+                .sendPresenceAvailable();
         });
     }
 
@@ -1388,7 +1994,9 @@ class Client extends EventEmitter {
      */
     async sendPresenceUnavailable() {
         return await this.pupPage.evaluate(() => {
-            return window.require('WAWebPresenceChatAction').sendPresenceUnavailable();
+            return window
+                .require('WAWebPresenceChatAction')
+                .sendPresenceUnavailable();
         });
     }
 
@@ -1397,9 +2005,11 @@ class Client extends EventEmitter {
      * @returns {boolean}
      */
     async archiveChat(chatId) {
-        return await this.pupPage.evaluate(async chatId => {
-            let chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
-            await (window.require('WAWebCmd').Cmd).archiveChat(chat, true);
+        return await this.pupPage.evaluate(async (chatId) => {
+            let chat = await window.WWebJS.getChat(chatId, {
+                getAsModel: false,
+            });
+            await window.require('WAWebCmd').Cmd.archiveChat(chat, true);
             return true;
         }, chatId);
     }
@@ -1409,9 +2019,11 @@ class Client extends EventEmitter {
      * @returns {boolean}
      */
     async unarchiveChat(chatId) {
-        return await this.pupPage.evaluate(async chatId => {
-            let chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
-            await (window.require('WAWebCmd').Cmd).archiveChat(chat, false);
+        return await this.pupPage.evaluate(async (chatId) => {
+            let chat = await window.WWebJS.getChat(chatId, {
+                getAsModel: false,
+            });
+            await window.require('WAWebCmd').Cmd.archiveChat(chat, false);
             return false;
         }, chatId);
     }
@@ -1421,20 +2033,24 @@ class Client extends EventEmitter {
      * @returns {Promise<boolean>} New pin state. Could be false if the max number of pinned chats was reached.
      */
     async pinChat(chatId) {
-        return this.pupPage.evaluate(async chatId => {
-            let chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
+        return this.pupPage.evaluate(async (chatId) => {
+            let chat = await window.WWebJS.getChat(chatId, {
+                getAsModel: false,
+            });
             if (chat.pin) {
                 return true;
             }
             const MAX_PIN_COUNT = 3;
-            const chatModels = (window.require('WAWebCollections')).Chat.getModelsArray();
+            const chatModels = window
+                .require('WAWebCollections')
+                .Chat.getModelsArray();
             if (chatModels.length > MAX_PIN_COUNT) {
                 let maxPinned = chatModels[MAX_PIN_COUNT - 1].pin;
                 if (maxPinned) {
                     return false;
                 }
             }
-            await (window.require('WAWebCmd').Cmd).pinChat(chat, true);
+            await window.require('WAWebCmd').Cmd.pinChat(chat, true);
             return true;
         }, chatId);
     }
@@ -1444,12 +2060,14 @@ class Client extends EventEmitter {
      * @returns {Promise<boolean>} New pin state
      */
     async unpinChat(chatId) {
-        return this.pupPage.evaluate(async chatId => {
-            let chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
+        return this.pupPage.evaluate(async (chatId) => {
+            let chat = await window.WWebJS.getChat(chatId, {
+                getAsModel: false,
+            });
             if (!chat.pin) {
                 return false;
             }
-            await (window.require('WAWebCmd').Cmd).pinChat(chat, false);
+            await window.require('WAWebCmd').Cmd.pinChat(chat, false);
             return false;
         }, chatId);
     }
@@ -1481,14 +2099,29 @@ class Client extends EventEmitter {
      * @param {number} unmuteDateTs Timestamp at which the chat will be unmuted
      * @returns {Promise<{isMuted: boolean, muteExpiration: number}>}
      */
-    async _muteUnmuteChat (chatId, action, unmuteDateTs) {
-        return this.pupPage.evaluate(async (chatId, action, unmuteDateTs) => {
-            const chat = (window.require('WAWebCollections')).Chat.get(chatId) ?? await (window.require('WAWebCollections')).Chat.find(chatId);
-            action === 'MUTE'
-                ? await chat.mute.mute({ expiration: unmuteDateTs, sendDevice: true })
-                : await chat.mute.unmute({ sendDevice: true });
-            return { isMuted: chat.mute.expiration !== 0, muteExpiration: chat.mute.expiration };
-        }, chatId, action, unmuteDateTs || -1);
+    async _muteUnmuteChat(chatId, action, unmuteDateTs) {
+        return this.pupPage.evaluate(
+            async (chatId, action, unmuteDateTs) => {
+                const chat =
+                    window.require('WAWebCollections').Chat.get(chatId) ??
+                    (await window
+                        .require('WAWebCollections')
+                        .Chat.find(chatId));
+                action === 'MUTE'
+                    ? await chat.mute.mute({
+                          expiration: unmuteDateTs,
+                          sendDevice: true,
+                      })
+                    : await chat.mute.unmute({ sendDevice: true });
+                return {
+                    isMuted: chat.mute.expiration !== 0,
+                    muteExpiration: chat.mute.expiration,
+                };
+            },
+            chatId,
+            action,
+            unmuteDateTs || -1,
+        );
     }
 
     /**
@@ -1496,9 +2129,11 @@ class Client extends EventEmitter {
      * @param {string} chatId ID of the chat that will be marked as unread
      */
     async markChatUnread(chatId) {
-        await this.pupPage.evaluate(async chatId => {
-            let chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
-            await (window.require('WAWebCmd').Cmd).markChatUnread(chat, true);
+        await this.pupPage.evaluate(async (chatId) => {
+            let chat = await window.WWebJS.getChat(chatId, {
+                getAsModel: false,
+            });
+            await window.require('WAWebCmd').Cmd.markChatUnread(chat, true);
         }, chatId);
     }
 
@@ -1508,19 +2143,18 @@ class Client extends EventEmitter {
      * @returns {Promise<string>}
      */
     async getProfilePicUrl(contactId) {
-        const profilePic = await this.pupPage.evaluate(async contactId => {
+        const profilePic = await this.pupPage.evaluate(async (contactId) => {
             try {
-                const chatWid = window.require('WAWebWidFactory').createWid(contactId);
-                const chat = await window.WWebJS.getChat(contactId, { getAsModel: false });
-                return window.WWebJS.compareWwebVersions(window.Debug.VERSION, '<', '2.3000.0')
-                    ? await window.require('WAWebContactProfilePicThumbBridge').profilePicFind(chatWid)
-                    : await window.require('WAWebContactProfilePicThumbBridge').requestProfilePicFromServer(chat);
+                const chat = await window.WWebJS.getChat(contactId);
+                return await window
+                    .require('WAWebContactProfilePicThumbBridge')
+                    .requestProfilePicFromServer(chat);
             } catch (err) {
-                if(err.name === 'ServerStatusCodeError') return undefined;
+                if (err.name === 'ServerStatusCodeError') return undefined;
                 throw err;
             }
         }, contactId);
-        
+
         return profilePic ? profilePic.eurl : undefined;
     }
 
@@ -1531,17 +2165,26 @@ class Client extends EventEmitter {
      */
     async getCommonGroups(contactId) {
         const commonGroups = await this.pupPage.evaluate(async (contactId) => {
-            let contact = (window.require('WAWebCollections')).Contact.get(contactId);
+            let contact = window
+                .require('WAWebCollections')
+                .Contact.get(contactId);
             if (!contact) {
-                const wid = window.require('WAWebWidFactory').createWid(contactId);
-                const chatConstructor = (window.require('WAWebCollections')).Contact.getModelsArray().find(c=>!c.isGroup).constructor;
-                contact = new chatConstructor({id: wid});
+                const wid = window
+                    .require('WAWebWidFactory')
+                    .createWid(contactId);
+                const chatConstructor = window
+                    .require('WAWebCollections')
+                    .Contact.getModelsArray()
+                    .find((c) => !c.isGroup).constructor;
+                contact = new chatConstructor({ id: wid });
             }
 
             if (contact.commonGroups) {
                 return contact.commonGroups.serialize();
             }
-            const status = await (window.require('WAWebFindCommonGroupsContactAction').findCommonGroups)(contact);
+            const status = await window
+                .require('WAWebFindCommonGroupsContactAction')
+                .findCommonGroups(contact);
             if (status) {
                 return contact.commonGroups.serialize();
             }
@@ -1556,10 +2199,10 @@ class Client extends EventEmitter {
 
     /**
      * Force reset of connection state for the client
-    */
+     */
     async resetState() {
         await this.pupPage.evaluate(() => {
-            window.require('WAWebSocketModel').Socket.reconnect(); 
+            window.require('WAWebSocketModel').Socket.reconnect();
         });
     }
 
@@ -1573,7 +2216,7 @@ class Client extends EventEmitter {
     }
 
     /**
-     * Get the registered WhatsApp ID for a number. 
+     * Get the registered WhatsApp ID for a number.
      * Will return null if the number is not registered on WhatsApp.
      * @param {string} number Number or ID ("@c.us" will be automatically appended if not specified)
      * @returns {Promise<Object|null>}
@@ -1583,9 +2226,11 @@ class Client extends EventEmitter {
             number += '@c.us';
         }
 
-        return await this.pupPage.evaluate(async number => {
+        return await this.pupPage.evaluate(async (number) => {
             const wid = window.require('WAWebWidFactory').createWid(number);
-            const result = await (window.require('WAWebQueryExistsJob').queryWidExists)(wid);
+            const result = await window
+                .require('WAWebQueryExistsJob')
+                .queryWidExists(wid);
             if (!result || result.wid === undefined) return null;
             return result.wid;
         }, number);
@@ -1597,11 +2242,15 @@ class Client extends EventEmitter {
      * @returns {Promise<string>}
      */
     async getFormattedNumber(number) {
-        if (!number.endsWith('@s.whatsapp.net')) number = number.replace('c.us', 's.whatsapp.net');
-        if (!number.includes('@s.whatsapp.net')) number = `${number}@s.whatsapp.net`;
-
-        return await this.pupPage.evaluate(async numberId => {
-            return window.require('WAWebPhoneUtils').formattedPhoneNumber(numberId);
+        if (!number.endsWith('@s.whatsapp.net'))
+            number = number.replace('c.us', 's.whatsapp.net');
+        if (!number.includes('@s.whatsapp.net'))
+            number = `${number}@s.whatsapp.net`;
+
+        return await this.pupPage.evaluate(async (numberId) => {
+            return window
+                .require('WAWebPhoneUtils')
+                .formattedPhoneNumber(numberId);
         }, number);
     }
 
@@ -1613,7 +2262,7 @@ class Client extends EventEmitter {
     async getCountryCode(number) {
         number = number.replace(' ', '').replace('+', '').replace('@c.us', '');
 
-        return await this.pupPage.evaluate(async numberId => {
+        return await this.pupPage.evaluate(async (numberId) => {
             return window.require('WAPhoneFindCC').findCC(numberId);
         }, number);
     }
@@ -1660,92 +2309,137 @@ class Client extends EventEmitter {
      */
     async createGroup(title, participants = [], options = {}) {
         !Array.isArray(participants) && (participants = [participants]);
-        participants.map(p => (p instanceof Contact) ? p.id._serialized : p);
-
-        return await this.pupPage.evaluate(async (title, participants, options) => {
-            const {
-                messageTimer = 0,
-                parentGroupId,
-                autoSendInviteV4 = true,
-                comment = '',
-            } = options;
-            const participantData = {}, participantWids = [], failedParticipants = [];
-            let createGroupResult, parentGroupWid;
-
-            const addParticipantResultCodes = {
-                default: 'An unknown error occupied while adding a participant',
-                200: 'The participant was added successfully',
-                403: 'The participant can be added by sending private invitation only',
-                404: 'The phone number is not registered on WhatsApp'
-            };
-
-            for (const participant of participants) {
-                const pWid = window.require('WAWebWidFactory').createWid(participant);
-                if ((await (window.require('WAWebQueryExistsJob').queryWidExists)(pWid))?.wid) {
-                    participantWids.push({ phoneNumber: pWid });
+        participants.map((p) => (p instanceof Contact ? p.id._serialized : p));
+
+        return await this.pupPage.evaluate(
+            async (title, participants, options) => {
+                const {
+                    messageTimer = 0,
+                    parentGroupId,
+                    autoSendInviteV4 = true,
+                    comment = '',
+                } = options;
+                const participantData = {},
+                    participantWids = [],
+                    failedParticipants = [];
+                let createGroupResult, parentGroupWid;
+
+                const addParticipantResultCodes = {
+                    default:
+                        'An unknown error occupied while adding a participant',
+                    200: 'The participant was added successfully',
+                    403: 'The participant can be added by sending private invitation only',
+                    404: 'The phone number is not registered on WhatsApp',
+                };
+
+                for (const participant of participants) {
+                    const pWid = window
+                        .require('WAWebWidFactory')
+                        .createWid(participant);
+                    if (
+                        (
+                            await window
+                                .require('WAWebQueryExistsJob')
+                                .queryWidExists(pWid)
+                        )?.wid
+                    ) {
+                        participantWids.push({ phoneNumber: pWid });
+                    } else failedParticipants.push(participant);
                 }
-                else failedParticipants.push(participant);
-            }
 
-            parentGroupId && (parentGroupWid = window.require('WAWebWidFactory').createWid(parentGroupId));
+                parentGroupId &&
+                    (parentGroupWid = window
+                        .require('WAWebWidFactory')
+                        .createWid(parentGroupId));
+
+                try {
+                    createGroupResult = await window
+                        .require('WAWebGroupCreateJob')
+                        .createGroup(
+                            {
+                                addressingModeOverride: 'lid',
+                                memberAddMode: options.memberAddMode ?? false,
+                                membershipApprovalMode:
+                                    options.membershipApprovalMode ?? false,
+                                announce: options.announce ?? false,
+                                restrict:
+                                    options.isRestrict !== undefined
+                                        ? !options.isRestrict
+                                        : false,
+                                ephemeralDuration: messageTimer,
+                                parentGroupId: parentGroupWid,
+                                title: title,
+                            },
+                            participantWids,
+                        );
+                } catch (ignoredError) {
+                    return 'CreateGroupError: An unknown error occupied while creating a group';
+                }
 
-            try {
-                createGroupResult = await (window.require('WAWebGroupCreateJob')).createGroup(
-                    {
-                        'addressingModeOverride': 'lid',
-                        'memberAddMode': options.memberAddMode ?? false,
-                        'membershipApprovalMode': options.membershipApprovalMode ?? false,
-                        'announce': options.announce ?? false,
-                        'restrict': options.isRestrict !== undefined ? !options.isRestrict : false,
-                        'ephemeralDuration': messageTimer,
-                        'parentGroupId': parentGroupWid,
-                        'title': title,
-                    },
-                    participantWids
-                );
-            } catch (err) {
-                return 'CreateGroupError: An unknown error occupied while creating a group';
-            }
+                for (const participant of createGroupResult.participants) {
+                    let isInviteV4Sent = false;
+                    participant.wid.server == 'lid' &&
+                        (participant.wid = window
+                            .require('WAWebApiContact')
+                            .getPhoneNumber(participant.wid));
+                    const participantId = participant.wid._serialized;
+                    const statusCode = participant.error || 200;
+
+                    if (autoSendInviteV4 && statusCode === 403) {
+                        window
+                            .require('WAWebCollections')
+                            .Contact.gadd(participant.wid, { silent: true });
+                        const addParticipantResult = await window
+                            .require('WAWebChatSendMessages')
+                            .sendGroupInviteMessage(
+                                window
+                                    .require('WAWebCollections')
+                                    .Chat.get(participant.wid) ||
+                                    (await window
+                                        .require('WAWebCollections')
+                                        .Chat.find(participant.wid)),
+                                createGroupResult.wid._serialized,
+                                createGroupResult.subject,
+                                participant.invite_code,
+                                participant.invite_code_exp,
+                                comment,
+                                await window.WWebJS.getProfilePicThumbToBase64(
+                                    createGroupResult.wid,
+                                ),
+                            );
+                        isInviteV4Sent =
+                            addParticipantResult.messageSendResult === 'OK';
+                    }
 
-            for (const participant of createGroupResult.participants) {
-                let isInviteV4Sent = false;
-                participant.wid.server == 'lid' && (participant.wid = window.require('WAWebApiContact').getPhoneNumber(participant.wid));
-                const participantId = participant.wid._serialized;
-                const statusCode = participant.error || 200;
-
-                if (autoSendInviteV4 && statusCode === 403) {
-                    (window.require('WAWebCollections')).Contact.gadd(participant.wid, { silent: true });
-                    const addParticipantResult = await (window.require('WAWebChatSendMessages')).sendGroupInviteMessage(
-                        (window.require('WAWebCollections')).Chat.get(participant.wid) || await (window.require('WAWebCollections')).Chat.find(participant.wid),
-                        createGroupResult.wid._serialized,
-                        createGroupResult.subject,
-                        participant.invite_code,
-                        participant.invite_code_exp,
-                        comment,
-                        await window.WWebJS.getProfilePicThumbToBase64(createGroupResult.wid)
-                    );
-                    isInviteV4Sent = addParticipantResult.messageSendResult === 'OK';
+                    participantData[participantId] = {
+                        statusCode: statusCode,
+                        message:
+                            addParticipantResultCodes[statusCode] ||
+                            addParticipantResultCodes.default,
+                        isGroupCreator: participant.type === 'superadmin',
+                        isInviteV4Sent: isInviteV4Sent,
+                    };
                 }
 
-                participantData[participantId] = {
-                    statusCode: statusCode,
-                    message: addParticipantResultCodes[statusCode] || addParticipantResultCodes.default,
-                    isGroupCreator: participant.type === 'superadmin',
-                    isInviteV4Sent: isInviteV4Sent
-                };
-            }
+                for (const f of failedParticipants) {
+                    participantData[f] = {
+                        statusCode: 404,
+                        message: addParticipantResultCodes[404],
+                        isGroupCreator: false,
+                        isInviteV4Sent: false,
+                    };
+                }
 
-            for (const f of failedParticipants) {
-                participantData[f] = {
-                    statusCode: 404,
-                    message: addParticipantResultCodes[404],
-                    isGroupCreator: false,
-                    isInviteV4Sent: false
+                return {
+                    title: title,
+                    gid: createGroupResult.wid,
+                    participants: participantData,
                 };
-            }
-
-            return { title: title, gid: createGroupResult.wid, participants: participantData };
-        }, title, participants, options);
+            },
+            title,
+            participants,
+            options,
+        );
     }
 
     /**
@@ -1770,46 +2464,61 @@ class Client extends EventEmitter {
     /**
      * Creates a new channel
      * @param {string} title The channel name
-     * @param {CreateChannelOptions} options 
+     * @param {CreateChannelOptions} options
      * @returns {Promise<CreateChannelResult|string>} Returns an object that handles the result for the channel creation or an error message as a string
      */
     async createChannel(title, options = {}) {
-        return await this.pupPage.evaluate(async (title, options) => {
-            let response, { description = null, picture = null } = options;
-
-            if (!(window.require('WAWebNewsletterGatingUtils')).isNewsletterCreationEnabled()) {
-                return 'CreateChannelError: A channel creation is not enabled';
-            }
+        return await this.pupPage.evaluate(
+            async (title, options) => {
+                let response,
+                    { description = null, picture = null } = options;
+
+                if (
+                    !window
+                        .require('WAWebNewsletterGatingUtils')
+                        .isNewsletterCreationEnabled()
+                ) {
+                    return 'CreateChannelError: A channel creation is not enabled';
+                }
 
-            if (picture) {
-                picture = await window.WWebJS.cropAndResizeImage(picture, {
-                    asDataUrl: true,
-                    mimetype: 'image/jpeg',
-                    size: 640,
-                    quality: 1
-                });
-            }
+                if (picture) {
+                    picture = await window.WWebJS.cropAndResizeImage(picture, {
+                        asDataUrl: true,
+                        mimetype: 'image/jpeg',
+                        size: 640,
+                        quality: 1,
+                    });
+                }
 
-            try {
-                response = await (window.require('WAWebNewsletterCreateQueryJob')).createNewsletterQuery({
-                    name: title,
-                    description: description,
-                    picture: picture,
-                });
-            } catch (err) {
-                if (err.name === 'ServerStatusCodeError') {
-                    return 'CreateChannelError: An error occupied while creating a channel';
+                try {
+                    response = await window
+                        .require('WAWebNewsletterCreateQueryJob')
+                        .createNewsletterQuery({
+                            name: title,
+                            description: description,
+                            picture: picture,
+                        });
+                } catch (err) {
+                    if (err.name === 'ServerStatusCodeError') {
+                        return 'CreateChannelError: An error occupied while creating a channel';
+                    }
+                    throw err;
                 }
-                throw err;
-            }
 
-            return {
-                title: title,
-                nid: window.require('WAWebJidToWid').newsletterJidToWid(response.idJid),
-                inviteLink: `https://whatsapp.com/channel/${response.newsletterInviteLinkMetadataMixin.inviteCode}`,
-                createdAtTs: response.newsletterCreationTimeMetadataMixin.creationTimeValue
-            };
-        }, title, options);
+                return {
+                    title: title,
+                    nid: window
+                        .require('WAWebJidToWid')
+                        .newsletterJidToWid(response.idJid),
+                    inviteLink: `https://whatsapp.com/channel/${response.newsletterInviteLinkMetadataMixin.inviteCode}`,
+                    createdAtTs:
+                        response.newsletterCreationTimeMetadataMixin
+                            .creationTimeValue,
+                };
+            },
+            title,
+            options,
+        );
     }
 
     /**
@@ -1819,7 +2528,10 @@ class Client extends EventEmitter {
      */
     async subscribeToChannel(channelId) {
         return await this.pupPage.evaluate(async (channelId) => {
-            return await window.WWebJS.subscribeToUnsubscribeFromChannel(channelId, 'Subscribe');
+            return await window.WWebJS.subscribeToUnsubscribeFromChannel(
+                channelId,
+                'Subscribe',
+            );
         }, channelId);
     }
 
@@ -1836,9 +2548,17 @@ class Client extends EventEmitter {
      * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
      */
     async unsubscribeFromChannel(channelId, options) {
-        return await this.pupPage.evaluate(async (channelId, options) => {
-            return await window.WWebJS.subscribeToUnsubscribeFromChannel(channelId, 'Unsubscribe', options);
-        }, channelId, options);
+        return await this.pupPage.evaluate(
+            async (channelId, options) => {
+                return await window.WWebJS.subscribeToUnsubscribeFromChannel(
+                    channelId,
+                    'Unsubscribe',
+                    options,
+                );
+            },
+            channelId,
+            options,
+        );
     }
 
     /**
@@ -1856,26 +2576,51 @@ class Client extends EventEmitter {
      * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
      */
     async transferChannelOwnership(channelId, newOwnerId, options = {}) {
-        return await this.pupPage.evaluate(async (channelId, newOwnerId, options) => {
-            const channel = await window.WWebJS.getChat(channelId, { getAsModel: false });
-            const newOwner = (window.require('WAWebCollections')).Contact.get(newOwnerId) || (await (window.require('WAWebCollections')).Contact.find(newOwnerId));
-            if (!channel.newsletterMetadata) {
-                await (window.require('WAWebCollections')).NewsletterMetadataCollection.update(channel.id);
-            }
-
-            try {
-                await (window.require('WAWebChangeNewsletterOwnerAction')).changeNewsletterOwnerAction(channel, newOwner);
+        return await this.pupPage.evaluate(
+            async (channelId, newOwnerId, options) => {
+                const channel = await window.WWebJS.getChat(channelId, {
+                    getAsModel: false,
+                });
+                const newOwner =
+                    window
+                        .require('WAWebCollections')
+                        .Contact.get(newOwnerId) ||
+                    (await window
+                        .require('WAWebCollections')
+                        .Contact.find(newOwnerId));
+                if (!channel.newsletterMetadata) {
+                    await window
+                        .require('WAWebCollections')
+                        .NewsletterMetadataCollection.update(channel.id);
+                }
 
-                if (options.shouldDismissSelfAsAdmin) {
-                    const meContact = window.require('WAWebContactCollection').getMeContact();
-                    meContact && (await (window.require('WAWebNewsletterDemoteAdminJob')).demoteNewsletterAdminAction(channel, meContact));
+                try {
+                    await window
+                        .require('WAWebChangeNewsletterOwnerAction')
+                        .changeNewsletterOwnerAction(channel, newOwner);
+
+                    if (options.shouldDismissSelfAsAdmin) {
+                        const meContact = window
+                            .require('WAWebContactCollection')
+                            .getMeContact();
+                        meContact &&
+                            (await window
+                                .require('WAWebNewsletterDemoteAdminJob')
+                                .demoteNewsletterAdminAction(
+                                    channel,
+                                    meContact,
+                                ));
+                    }
+                } catch (ignoredError) {
+                    return false;
                 }
-            } catch (error) {
-                return false;
-            }
 
-            return true;
-        }, channelId, newOwnerId, options);
+                return true;
+            },
+            channelId,
+            newOwnerId,
+            options,
+        );
     }
 
     /**
@@ -1898,51 +2643,78 @@ class Client extends EventEmitter {
      * @returns {Promise<Array<Channel>>} Returns an array of Channel objects or an empty array if no channels were found
      */
     async searchChannels(searchOptions = {}) {
-        return await this.pupPage.evaluate(async ({
-            searchText = '',
-            countryCodes = [],
-            skipSubscribedNewsletters = false,
-            view = 0,
-            limit = 50
-        }) => {
-            searchText = searchText.trim();
-            const currentRegion = window.require('WAWebL10N').getRegion();
-            if (countryCodes.length === 0) countryCodes[0] = currentRegion;
-            if (![0, 1, 2, 3].includes(view)) view = 0;
-
-            const { countryCodesIso } = window.require('WAWebCountriesNativeCountryNames');
-            
-            countryCodes = countryCodes.length === 1 && countryCodes[0] === currentRegion
-                ? countryCodes
-                : countryCodes.filter((code) => Object.keys(countryCodesIso).includes(code));
-
-            const viewTypeMapping = {
-                0: 'RECOMMENDED',
-                1: 'TRENDING',
-                2: 'POPULAR',
-                3: 'NEW'
-            };
-
-            searchOptions = {
-                searchText: searchText,
-                countryCodes: countryCodes,
-                skipSubscribedNewsletters: skipSubscribedNewsletters,
-                view: viewTypeMapping[view],
-                categories: [],
-                cursorToken: ''
-            };
-            
-            const originalFunction = window.require('WAWebNewsletterGatingUtils').getNewsletterDirectoryPageSize;
-            limit !== 50 && (window.require('WAWebNewsletterGatingUtils').getNewsletterDirectoryPageSize = () => limit);
-
-            const channels = (await (window.require('WAWebNewsletterDirectorySearchAction')).fetchNewsletterDirectories(searchOptions)).newsletters;
-
-            limit !== 50 && (window.require('WAWebNewsletterGatingUtils').getNewsletterDirectoryPageSize = originalFunction);
-
-            return channels
-                ? await Promise.all(channels.map((channel) => window.WWebJS.getChatModel(channel, { isChannel: true })))
-                : [];
-        }, searchOptions);
+        return await this.pupPage.evaluate(
+            async ({
+                searchText = '',
+                countryCodes = [],
+                skipSubscribedNewsletters = false,
+                view = 0,
+                limit = 50,
+            }) => {
+                searchText = searchText.trim();
+                const currentRegion = window.require('WAWebL10N').getRegion();
+                if (countryCodes.length === 0) countryCodes[0] = currentRegion;
+                if (![0, 1, 2, 3].includes(view)) view = 0;
+
+                const { countryCodesIso } = window.require(
+                    'WAWebCountriesNativeCountryNames',
+                );
+
+                countryCodes =
+                    countryCodes.length === 1 &&
+                    countryCodes[0] === currentRegion
+                        ? countryCodes
+                        : countryCodes.filter((code) =>
+                              Object.keys(countryCodesIso).includes(code),
+                          );
+
+                const viewTypeMapping = {
+                    0: 'RECOMMENDED',
+                    1: 'TRENDING',
+                    2: 'POPULAR',
+                    3: 'NEW',
+                };
+
+                searchOptions = {
+                    searchText: searchText,
+                    countryCodes: countryCodes,
+                    skipSubscribedNewsletters: skipSubscribedNewsletters,
+                    view: viewTypeMapping[view],
+                    categories: [],
+                    cursorToken: '',
+                };
+
+                const originalFunction = window.require(
+                    'WAWebNewsletterGatingUtils',
+                ).getNewsletterDirectoryPageSize;
+                limit !== 50 &&
+                    (window.require(
+                        'WAWebNewsletterGatingUtils',
+                    ).getNewsletterDirectoryPageSize = () => limit);
+
+                const channels = (
+                    await window
+                        .require('WAWebNewsletterDirectorySearchAction')
+                        .fetchNewsletterDirectories(searchOptions)
+                ).newsletters;
+
+                limit !== 50 &&
+                    (window.require(
+                        'WAWebNewsletterGatingUtils',
+                    ).getNewsletterDirectoryPageSize = originalFunction);
+
+                return channels
+                    ? await Promise.all(
+                          channels.map((channel) =>
+                              window.WWebJS.getChatModel(channel, {
+                                  isChannel: true,
+                              }),
+                          ),
+                      )
+                    : [];
+            },
+            searchOptions,
+        );
     }
 
     /**
@@ -1952,10 +2724,14 @@ class Client extends EventEmitter {
      */
     async deleteChannel(channelId) {
         return await this.pupPage.evaluate(async (channelId) => {
-            const channel = await window.WWebJS.getChat(channelId, { getAsModel: false });
+            const channel = await window.WWebJS.getChat(channelId, {
+                getAsModel: false,
+            });
             if (!channel) return false;
             try {
-                await (window.require('WAWebNewsletterDeleteAction')).deleteNewsletterAction(channel);
+                await window
+                    .require('WAWebNewsletterDeleteAction')
+                    .deleteNewsletterAction(channel);
                 return true;
             } catch (err) {
                 if (err.name === 'ServerStatusCodeError') return false;
@@ -1973,7 +2749,7 @@ class Client extends EventEmitter {
             return window.WWebJS.getLabels();
         });
 
-        return labels.map(data => new Label(this, data));
+        return labels.map((data) => new Label(this, data));
     }
 
     /**
@@ -1984,7 +2760,7 @@ class Client extends EventEmitter {
         const broadcasts = await this.pupPage.evaluate(async () => {
             return window.WWebJS.getAllStatuses();
         });
-        return broadcasts.map(data => new Broadcast(this, data));
+        return broadcasts.map((data) => new Broadcast(this, data));
     }
 
     /**
@@ -1996,9 +2772,11 @@ class Client extends EventEmitter {
         const broadcast = await this.pupPage.evaluate(async (userId) => {
             let status;
             try {
-                status = (window.require('WAWebCollections')).Status.get(userId);
+                status = window.require('WAWebCollections').Status.get(userId);
                 if (!status) {
-                    status = await (window.require('WAWebCollections')).Status.find(userId);
+                    status = await window
+                        .require('WAWebCollections')
+                        .Status.find(userId);
                 }
             } catch {
                 status = null;
@@ -2016,17 +2794,26 @@ class Client extends EventEmitter {
      */
     async revokeStatusMessage(messageId) {
         return await this.pupPage.evaluate(async (msgId) => {
-            const status = (window.require('WAWebCollections')).Status.getMyStatus();
+            const status = window
+                .require('WAWebCollections')
+                .Status.getMyStatus();
             if (!status) return;
 
             const msg =
-                (window.require('WAWebCollections')).Msg.get(msgId) || (await (window.require('WAWebCollections')).Msg.getMessagesById([msgId]))?.messages?.[0];
+                window.require('WAWebCollections').Msg.get(msgId) ||
+                (
+                    await window
+                        .require('WAWebCollections')
+                        .Msg.getMessagesById([msgId])
+                )?.messages?.[0];
             if (!msg) return;
 
             if (!msg.id.fromMe || !msg.id.remote.isStatus())
                 throw 'Invalid usage! Can only revoke the message its from own status broadcast';
 
-            return await (window.require('WAWebRevokeStatusAction')).sendStatusRevokeMsgAction(status, msg);
+            return await window
+                .require('WAWebRevokeStatusAction')
+                .sendStatusRevokeMsgAction(status, msg);
         }, messageId);
     }
 
@@ -2044,7 +2831,7 @@ class Client extends EventEmitter {
     }
 
     /**
-     * Get all Labels assigned to a chat 
+     * Get all Labels assigned to a chat
      * @param {string} chatId
      * @returns {Promise<Array<Label>>}
      */
@@ -2053,7 +2840,7 @@ class Client extends EventEmitter {
             return window.WWebJS.getChatLabels(chatId);
         }, chatId);
 
-        return labels.map(data => new Label(this, data));
+        return labels.map((data) => new Label(this, data));
     }
 
     /**
@@ -2063,7 +2850,7 @@ class Client extends EventEmitter {
      */
     async getChatsByLabelId(labelId) {
         const chatIds = await this.pupPage.evaluate(async (labelId) => {
-            const label = (window.require('WAWebCollections')).Label.get(labelId);
+            const label = window.require('WAWebCollections').Label.get(labelId);
             const labelItems = label.labelItemCollection.getModelsArray();
             return labelItems.reduce((result, item) => {
                 if (item.parentType === 'Chat') {
@@ -2073,7 +2860,7 @@ class Client extends EventEmitter {
             }, []);
         }, labelId);
 
-        return Promise.all(chatIds.map(id => this.getChatById(id)));
+        return Promise.all(chatIds.map((id) => this.getChatById(id)));
     }
 
     /**
@@ -2082,11 +2869,18 @@ class Client extends EventEmitter {
      */
     async getBlockedContacts() {
         const blockedContacts = await this.pupPage.evaluate(() => {
-            let chatIds = (window.require('WAWebCollections')).Blocklist.getModelsArray().map(a => a.id._serialized);
-            return Promise.all(chatIds.map(id => window.WWebJS.getContact(id)));
+            let chatIds = window
+                .require('WAWebCollections')
+                .Blocklist.getModelsArray()
+                .map((a) => a.id._serialized);
+            return Promise.all(
+                chatIds.map((id) => window.WWebJS.getContact(id)),
+            );
         });
 
-        return blockedContacts.map(contact => ContactFactory.create(this.client, contact));
+        return blockedContacts.map((contact) =>
+            ContactFactory.create(this.client, contact),
+        );
     }
 
     /**
@@ -2095,9 +2889,13 @@ class Client extends EventEmitter {
      * @returns {Promise<boolean>} Returns true if the picture was properly updated.
      */
     async setProfilePicture(media) {
-        const success = await this.pupPage.evaluate((chatid, media) => {
-            return window.WWebJS.setPicture(chatid, media);
-        }, this.info.wid._serialized, media);
+        const success = await this.pupPage.evaluate(
+            (chatid, media) => {
+                return window.WWebJS.setPicture(chatid, media);
+            },
+            this.info.wid._serialized,
+            media,
+        );
 
         return success;
     }
@@ -2113,7 +2911,7 @@ class Client extends EventEmitter {
 
         return success;
     }
-    
+
     /**
      * Change labels in chats
      * @param {Array<number|string>} labelIds
@@ -2121,26 +2919,42 @@ class Client extends EventEmitter {
      * @returns {Promise<void>}
      */
     async addOrRemoveLabels(labelIds, chatIds) {
+        return this.pupPage.evaluate(
+            async (labelIds, chatIds) => {
+                if (
+                    ['smba', 'smbi'].indexOf(
+                        window.require('WAWebConnModel').Conn.platform,
+                    ) === -1
+                ) {
+                    throw '[LT01] Only Whatsapp business';
+                }
+                const labels = window.WWebJS.getLabels().filter(
+                    (e) => labelIds.find((l) => l == e.id) !== undefined,
+                );
+                const chats = window
+                    .require('WAWebCollections')
+                    .Chat.filter((e) => chatIds.includes(e.id._serialized));
 
-        return this.pupPage.evaluate(async (labelIds, chatIds) => {
-            if (['smba', 'smbi'].indexOf((window.require('WAWebConnModel').Conn).platform) === -1) {
-                throw '[LT01] Only Whatsapp business';
-            }
-            const labels = window.WWebJS.getLabels().filter(e => labelIds.find(l => l == e.id) !== undefined);
-            const chats = (window.require('WAWebCollections')).Chat.filter(e => chatIds.includes(e.id._serialized));
-
-            let actions = labels.map(label => ({id: label.id, type: 'add'}));
+                let actions = labels.map((label) => ({
+                    id: label.id,
+                    type: 'add',
+                }));
 
-            chats.forEach(chat => {
-                (chat.labels || []).forEach(n => {
-                    if (!actions.find(e => e.id == n)) {
-                        actions.push({id: n, type: 'remove'});
-                    }
+                chats.forEach((chat) => {
+                    (chat.labels || []).forEach((n) => {
+                        if (!actions.find((e) => e.id == n)) {
+                            actions.push({ id: n, type: 'remove' });
+                        }
+                    });
                 });
-            });
 
-            return await (window.require('WAWebCollections')).Label.addOrRemoveLabels(actions, chats);
-        }, labelIds, chatIds);
+                return await window
+                    .require('WAWebCollections')
+                    .Label.addOrRemoveLabels(actions, chats);
+            },
+            labelIds,
+            chatIds,
+        );
     }
 
     /**
@@ -2160,8 +2974,12 @@ class Client extends EventEmitter {
      */
     async getGroupMembershipRequests(groupId) {
         return await this.pupPage.evaluate(async (groupId) => {
-            const groupWid = window.require('WAWebWidFactory').createWid(groupId);
-            return await (window.require('WAWebApiMembershipApprovalRequestStore')).getMembershipApprovalRequests(groupWid);
+            const groupWid = window
+                .require('WAWebWidFactory')
+                .createWid(groupId);
+            return await window
+                .require('WAWebApiMembershipApprovalRequestStore')
+                .getMembershipApprovalRequests(groupWid);
         }, groupId);
     }
 
@@ -2187,10 +3005,19 @@ class Client extends EventEmitter {
      * @returns {Promise<Array<MembershipRequestActionResult>>} Returns an array of requester IDs whose membership requests were approved and an error for each requester, if any occurred during the operation. If there are no requests, an empty array will be returned
      */
     async approveGroupMembershipRequests(groupId, options = {}) {
-        return await this.pupPage.evaluate(async (groupId, options) => {
-            const { requesterIds = null, sleep = [250, 500] } = options;
-            return await window.WWebJS.membershipRequestAction(groupId, 'Approve', requesterIds, sleep);
-        }, groupId, options);
+        return await this.pupPage.evaluate(
+            async (groupId, options) => {
+                const { requesterIds = null, sleep = [250, 500] } = options;
+                return await window.WWebJS.membershipRequestAction(
+                    groupId,
+                    'Approve',
+                    requesterIds,
+                    sleep,
+                );
+            },
+            groupId,
+            options,
+        );
     }
 
     /**
@@ -2200,24 +3027,36 @@ class Client extends EventEmitter {
      * @returns {Promise<Array<MembershipRequestActionResult>>} Returns an array of requester IDs whose membership requests were rejected and an error for each requester, if any occurred during the operation. If there are no requests, an empty array will be returned
      */
     async rejectGroupMembershipRequests(groupId, options = {}) {
-        return await this.pupPage.evaluate(async (groupId, options) => {
-            const { requesterIds = null, sleep = [250, 500] } = options;
-            return await window.WWebJS.membershipRequestAction(groupId, 'Reject', requesterIds, sleep);
-        }, groupId, options);
+        return await this.pupPage.evaluate(
+            async (groupId, options) => {
+                const { requesterIds = null, sleep = [250, 500] } = options;
+                return await window.WWebJS.membershipRequestAction(
+                    groupId,
+                    'Reject',
+                    requesterIds,
+                    sleep,
+                );
+            },
+            groupId,
+            options,
+        );
     }
 
-
     /**
      * Setting  autoload download audio
      * @param {boolean} flag true/false
      */
     async setAutoDownloadAudio(flag) {
-        await this.pupPage.evaluate(async flag => {
-            const autoDownload = (window.require('WAWebUserPrefsGeneral')).getAutoDownloadAudio();
+        await this.pupPage.evaluate(async (flag) => {
+            const autoDownload = window
+                .require('WAWebUserPrefsGeneral')
+                .getAutoDownloadAudio();
             if (autoDownload === flag) {
                 return flag;
             }
-            await (window.require('WAWebUserPrefsGeneral')).setAutoDownloadAudio(flag);
+            await window
+                .require('WAWebUserPrefsGeneral')
+                .setAutoDownloadAudio(flag);
             return flag;
         }, flag);
     }
@@ -2227,12 +3066,16 @@ class Client extends EventEmitter {
      * @param {boolean} flag true/false
      */
     async setAutoDownloadDocuments(flag) {
-        await this.pupPage.evaluate(async flag => {
-            const autoDownload = (window.require('WAWebUserPrefsGeneral')).getAutoDownloadDocuments();
+        await this.pupPage.evaluate(async (flag) => {
+            const autoDownload = window
+                .require('WAWebUserPrefsGeneral')
+                .getAutoDownloadDocuments();
             if (autoDownload === flag) {
                 return flag;
             }
-            await (window.require('WAWebUserPrefsGeneral')).setAutoDownloadDocuments(flag);
+            await window
+                .require('WAWebUserPrefsGeneral')
+                .setAutoDownloadDocuments(flag);
             return flag;
         }, flag);
     }
@@ -2242,12 +3085,16 @@ class Client extends EventEmitter {
      * @param {boolean} flag true/false
      */
     async setAutoDownloadPhotos(flag) {
-        await this.pupPage.evaluate(async flag => {
-            const autoDownload = (window.require('WAWebUserPrefsGeneral')).getAutoDownloadPhotos();
+        await this.pupPage.evaluate(async (flag) => {
+            const autoDownload = window
+                .require('WAWebUserPrefsGeneral')
+                .getAutoDownloadPhotos();
             if (autoDownload === flag) {
                 return flag;
             }
-            await (window.require('WAWebUserPrefsGeneral')).setAutoDownloadPhotos(flag);
+            await window
+                .require('WAWebUserPrefsGeneral')
+                .setAutoDownloadPhotos(flag);
             return flag;
         }, flag);
     }
@@ -2257,12 +3104,16 @@ class Client extends EventEmitter {
      * @param {boolean} flag true/false
      */
     async setAutoDownloadVideos(flag) {
-        await this.pupPage.evaluate(async flag => {
-            const autoDownload = (window.require('WAWebUserPrefsGeneral')).getAutoDownloadVideos();
+        await this.pupPage.evaluate(async (flag) => {
+            const autoDownload = window
+                .require('WAWebUserPrefsGeneral')
+                .getAutoDownloadVideos();
             if (autoDownload === flag) {
                 return flag;
             }
-            await (window.require('WAWebUserPrefsGeneral')).setAutoDownloadVideos(flag);
+            await window
+                .require('WAWebUserPrefsGeneral')
+                .setAutoDownloadVideos(flag);
             return flag;
         }, flag);
     }
@@ -2274,16 +3125,20 @@ class Client extends EventEmitter {
      * @returns {Promise<boolean>}
      */
     async setBackgroundSync(flag) {
-        return await this.pupPage.evaluate(async flag => {
-            const backSync = (window.require('WAWebUserPrefsNotifications')).getGlobalOfflineNotifications();
+        return await this.pupPage.evaluate(async (flag) => {
+            const backSync = window
+                .require('WAWebUserPrefsNotifications')
+                .getGlobalOfflineNotifications();
             if (backSync === flag) {
                 return flag;
             }
-            await (window.require('WAWebUserPrefsNotifications')).setGlobalOfflineNotifications(flag);
+            await window
+                .require('WAWebUserPrefsNotifications')
+                .setGlobalOfflineNotifications(flag);
             return flag;
         }, flag);
     }
-    
+
     /**
      * Get user device count by ID
      * Each WaWeb Connection counts as one device, and the phone (if exists) counts as one
@@ -2293,8 +3148,17 @@ class Client extends EventEmitter {
      */
     async getContactDeviceCount(userId) {
         return await this.pupPage.evaluate(async (userId) => {
-            const devices = await (window.require('WAWebApiDeviceList')).getDeviceIds([window.require('WAWebWidFactory').createWid(userId)]);
-            if (devices && devices.length && devices[0] != null && typeof devices[0].devices == 'object') {
+            const devices = await window
+                .require('WAWebApiDeviceList')
+                .getDeviceIds([
+                    window.require('WAWebWidFactory').createWid(userId),
+                ]);
+            if (
+                devices &&
+                devices.length &&
+                devices[0] != null &&
+                typeof devices[0].devices == 'object'
+            ) {
                 return devices[0].devices.length;
             }
             return 0;
@@ -2309,17 +3173,21 @@ class Client extends EventEmitter {
     async syncHistory(chatId) {
         return await this.pupPage.evaluate(async (chatId) => {
             const chatWid = window.require('WAWebWidFactory').createWid(chatId);
-            const chat = (window.require('WAWebCollections')).Chat.get(chatWid) ?? (await (window.require('WAWebCollections')).Chat.find(chatWid));
+            const chat =
+                window.require('WAWebCollections').Chat.get(chatWid) ??
+                (await window.require('WAWebCollections').Chat.find(chatWid));
             if (chat?.endOfHistoryTransferType === 0) {
-                await (window.require('WAWebSendNonMessageDataRequest')).sendPeerDataOperationRequest(3, {
-                    chatId: chat.id
-                });
+                await window
+                    .require('WAWebSendNonMessageDataRequest')
+                    .sendPeerDataOperationRequest(3, {
+                        chatId: chat.id,
+                    });
                 return true;
             }
             return false;
         }, chatId);
     }
-  
+
     /**
      * Generates a WhatsApp call link (video call or voice call)
      * @param {Date} startTime The start time of the call
@@ -2328,17 +3196,27 @@ class Client extends EventEmitter {
      */
     async createCallLink(startTime, callType) {
         if (!['video', 'voice'].includes(callType)) {
-            throw new class CreateCallLinkError extends Error {
-                constructor(m) { super(m); }
-            }('Invalid \'callType\' parameter value is provided. Valid values are: \'voice\' | \'video\'.');
+            throw new (class CreateCallLinkError extends Error {
+                constructor(m) {
+                    super(m);
+                }
+            })(
+                "Invalid 'callType' parameter value is provided. Valid values are: 'voice' | 'video'.",
+            );
         }
 
         startTime = Math.floor(startTime.getTime() / 1000);
-        
-        return await this.pupPage.evaluate(async (startTimeTs, callType) => {
-            const response = await (window.require('WAWebGenerateEventCallLink')).createEventCallLink(startTimeTs, callType);
-            return response ?? '';
-        }, startTime, callType);
+
+        return await this.pupPage.evaluate(
+            async (startTimeTs, callType) => {
+                const response = await window
+                    .require('WAWebGenerateEventCallLink')
+                    .createEventCallLink(startTimeTs, callType);
+                return response ?? '';
+            },
+            startTime,
+            callType,
+        );
     }
 
     /**
@@ -2350,35 +3228,59 @@ class Client extends EventEmitter {
     async sendResponseToScheduledEvent(response, eventMessageId) {
         if (![0, 1, 2, 3].includes(response)) return false;
 
-        return await this.pupPage.evaluate(async (response, msgId) => {
-            const eventMsg = (window.require('WAWebCollections')).Msg.get(msgId) || (await (window.require('WAWebCollections')).Msg.getMessagesById([msgId]))?.messages?.[0];
-            if (!eventMsg) return false;
-
-            await (window.require('WAWebSendEventResponseMsgAction')).sendEventResponseMsg(response, eventMsg);
-            return true;
-        }, response, eventMessageId);
+        return await this.pupPage.evaluate(
+            async (response, msgId) => {
+                const eventMsg =
+                    window.require('WAWebCollections').Msg.get(msgId) ||
+                    (
+                        await window
+                            .require('WAWebCollections')
+                            .Msg.getMessagesById([msgId])
+                    )?.messages?.[0];
+                if (!eventMsg) return false;
+
+                await window
+                    .require('WAWebSendEventResponseMsgAction')
+                    .sendEventResponseMsg(response, eventMsg);
+                return true;
+            },
+            response,
+            eventMessageId,
+        );
     }
-  
+
     /**
      * Save new contact to user's addressbook or edit the existing one
      * @param {string} phoneNumber The contact's phone number in a format "17182222222", where "1" is a country code
-     * @param {string} firstName 
-     * @param {string} lastName 
+     * @param {string} firstName
+     * @param {string} lastName
      * @param {boolean} [syncToAddressbook = false] If set to true, the contact will also be saved to the user's address book on their phone. False by default
      * @returns {Promise<void>}
      */
-    async saveOrEditAddressbookContact(phoneNumber, firstName, lastName, syncToAddressbook = false)
-    {
-        return await this.pupPage.evaluate(async (phoneNumber, firstName, lastName, syncToAddressbook) => {
-            return await (window.require('WAWebSaveContactAction')).saveContactAction({
-                'firstName' : firstName,
-                'lastName' : lastName,
-                'phoneNumber' : phoneNumber,
-                'prevPhoneNumber' : phoneNumber,
-                'syncToAddressbook': syncToAddressbook,
-                'username' : undefined
-            });
-        }, phoneNumber, firstName, lastName, syncToAddressbook);
+    async saveOrEditAddressbookContact(
+        phoneNumber,
+        firstName,
+        lastName,
+        syncToAddressbook = false,
+    ) {
+        return await this.pupPage.evaluate(
+            async (phoneNumber, firstName, lastName, syncToAddressbook) => {
+                return await window
+                    .require('WAWebSaveContactAction')
+                    .saveContactAction({
+                        firstName: firstName,
+                        lastName: lastName,
+                        phoneNumber: phoneNumber,
+                        prevPhoneNumber: phoneNumber,
+                        syncToAddressbook: syncToAddressbook,
+                        username: undefined,
+                    });
+            },
+            phoneNumber,
+            firstName,
+            lastName,
+            syncToAddressbook,
+        );
     }
 
     /**
@@ -2386,11 +3288,14 @@ class Client extends EventEmitter {
      * @param {string} phoneNumber The contact's phone number in a format "17182222222", where "1" is a country code
      * @returns {Promise<void>}
      */
-    async deleteAddressbookContact(phoneNumber)
-    {
+    async deleteAddressbookContact(phoneNumber) {
         return await this.pupPage.evaluate(async (phoneNumber) => {
-            const wid = window.require('WAWebWidFactory').createWid(phoneNumber);
-            return await (window.require('WAWebDeleteContactAction')).deleteContactAction({phoneNumber: wid});
+            const wid = window
+                .require('WAWebWidFactory')
+                .createWid(phoneNumber);
+            return await window
+                .require('WAWebDeleteContactAction')
+                .deleteContactAction({ phoneNumber: wid });
         }, phoneNumber);
     }
 
@@ -2403,14 +3308,17 @@ class Client extends EventEmitter {
         return await this.pupPage.evaluate(async (userIds) => {
             if (!Array.isArray(userIds)) userIds = [userIds];
 
-            return await Promise.all(userIds.map(async (userId) => {
-                const { lid, phone } = await window.WWebJS.enforceLidAndPnRetrieval(userId);
+            return await Promise.all(
+                userIds.map(async (userId) => {
+                    const { lid, phone } =
+                        await window.WWebJS.enforceLidAndPnRetrieval(userId);
 
-                return {
-                    lid: lid?._serialized,
-                    pn: phone?._serialized
-                };
-            }));
+                    return {
+                        lid: lid?._serialized,
+                        pn: phone?._serialized,
+                    };
+                }),
+            );
         }, userIds);
     }
 
@@ -2422,15 +3330,28 @@ class Client extends EventEmitter {
      * @returns {Promise<void>}
      */
     async addOrEditCustomerNote(userId, note) {
-        return await this.pupPage.evaluate(async (userId, note) => {
-            if (!(window.require('WAWebBizGatingUtils')).smbNotesV1Enabled()) return;
+        return await this.pupPage.evaluate(
+            async (userId, note) => {
+                if (!window.require('WAWebBizGatingUtils').smbNotesV1Enabled())
+                    return;
 
-            return (window.require('WAWebNoteAction')).noteAddAction(
-                'unstructured',
-                window.require('WAWebWidToJid').widToUserJid(window.require('WAWebWidFactory').createWid(userId)),
-                note
-            );
-        }, userId, note);
+                return window
+                    .require('WAWebNoteAction')
+                    .noteAddAction(
+                        'unstructured',
+                        window
+                            .require('WAWebWidToJid')
+                            .widToUserJid(
+                                window
+                                    .require('WAWebWidFactory')
+                                    .createWid(userId),
+                            ),
+                        note,
+                    );
+            },
+            userId,
+            note,
+        );
     }
 
     /**
@@ -2448,47 +3369,65 @@ class Client extends EventEmitter {
      */
     async getCustomerNote(userId) {
         return await this.pupPage.evaluate(async (userId) => {
-            if (!(window.require('WAWebBizGatingUtils')).smbNotesV1Enabled()) return null;
-
-            const note = await (window.require('WAWebNoteAction')).retrieveOnlyNoteForChatJid(
-                window.require('WAWebWidToJid').widToUserJid(window.require('WAWebWidFactory').createWid(userId))
-            );
+            if (!window.require('WAWebBizGatingUtils').smbNotesV1Enabled())
+                return null;
+
+            const note = await window
+                .require('WAWebNoteAction')
+                .retrieveOnlyNoteForChatJid(
+                    window
+                        .require('WAWebWidToJid')
+                        .widToUserJid(
+                            window.require('WAWebWidFactory').createWid(userId),
+                        ),
+                );
 
             let serialized = note?.serialize();
 
             if (!serialized) return null;
 
-            serialized.chatId = window.require('WAWebJidToWid').userJidToUserWid(serialized.chatJid)._serialized;
+            serialized.chatId = window
+                .require('WAWebJidToWid')
+                .userJidToUserWid(serialized.chatJid)._serialized;
             delete serialized.chatJid;
 
             return serialized;
         }, userId);
     }
-    
+
     /**
      * Get Poll Votes
      * @param {string} messageId
-     * @return {Promise<Array<PollVote>>} 
+     * @return {Promise<Array<PollVote>>}
      */
     async getPollVotes(messageId) {
         const msg = await this.getMessageById(messageId);
         if (!msg) return [];
-        if (msg.type != MessageTypes.POLL_CREATION) throw 'Invalid usage! Can only be used with a pollCreation message';
-
-        const pollVotes = await this.pupPage.evaluate( async (msg) => {
-            const msgKey = (window.require('WAWebMsgKey')).fromString(msg.id._serialized);
-            let pollVotes = await (window.require('WAWebPollsVotesSchema')).getTable().equals(['parentMsgKey'], msgKey.toString());
-            
-            return pollVotes.map(item => {
+        if (msg.type != MessageTypes.POLL_CREATION)
+            throw 'Invalid usage! Can only be used with a pollCreation message';
+
+        const pollVotes = await this.pupPage.evaluate(async (msg) => {
+            const msgKey = window
+                .require('WAWebMsgKey')
+                .fromString(msg.id._serialized);
+            let pollVotes = await window
+                .require('WAWebPollsVotesSchema')
+                .getTable()
+                .equals(['parentMsgKey'], msgKey.toString());
+
+            return pollVotes.map((item) => {
                 const typedArray = new Uint8Array(item.selectedOptionLocalIds);
                 return {
                     ...item,
-                    selectedOptionLocalIds: Array.from(typedArray)
+                    selectedOptionLocalIds: Array.from(typedArray),
                 };
             });
         }, msg);
 
-        return pollVotes.map((pollVote) => new PollVote(this.client, {...pollVote, parentMessage: msg}));
+        return pollVotes.map(
+            (pollVote) =>
+                new PollVote(this.client, { ...pollVote, parentMessage: msg }),
+        );
     }
 }