@neelegirl/baileys 1.5.3 → 1.5.5

package/lib/Signal/libsignal.js

@@ -1,391 +0,0 @@
-"use strict"
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k
-    var desc = Object.getOwnPropertyDescriptor(m, k)
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k] } }
-    }
-    Object.defineProperty(o, k2, desc)
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k
-    o[k2] = m[k]
-}))
-
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v })
-}) : function(o, v) {
-    o["default"] = v
-})
-
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = []
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k
-            return ar
-        }
-        return ownKeys(o)
-    }
-    return function (mod) {
-        if (mod && mod.__esModule) return mod
-        var result = {}
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i])
-        __setModuleDefault(result, mod)
-        return result
-    }
-})()
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const libsignal = __importStar(require("@neelegirl/libsignal"))
-const Utils_1 = require("../Utils")
-const WABinary_1 = require("../WABinary")
-const sender_key_name_1 = require("./WASignalGroup/sender-key-name")
-const sender_key_record_1 = require("./WASignalGroup/sender-key-record")
-const Group_1 = require("./WASignalGroup")
-const LIDMappingStore_1 = require("./lid-mapping") 
-
-function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
-	const lidMapping = new LIDMappingStore_1.LIDMappingStore(auth.keys, onWhatsAppFunc, logger)
-    const storage = signalStorage(auth, lidMapping)
-    const parsedKeys = auth.keys
-    
-    function isLikelySyncMessage(addr) {
-        const key = addr.toString()
-        // Only bypass for WhatsApp system addresses, not regular user contacts
-        // Be very specific about sync service patterns
-        return (key.includes('@lid.whatsapp.net') || // WhatsApp system messages
-            key.includes('@broadcast') || // Broadcast messages
-            key.includes('@newsletter'))
-    }
-    
-    const repository = {
-        decryptGroupMessage({ group, authorJid, msg }) {
-            const senderName = jidToSignalSenderKeyName(group, authorJid)
-            const cipher = new Group_1.GroupCipher(storage, senderName)
-            // Use transaction to ensure atomicity
-            return parsedKeys.transaction(async () => {
-                return cipher.decrypt(msg)
-            }, group)
-        },
-        async processSenderKeyDistributionMessage({ item, authorJid }) {
-            const builder = new Group_1.GroupSessionBuilder(storage)
-            if (!item.groupId) {
-                throw new Error('Group ID is required for sender key distribution message')
-            }
-            const senderName = jidToSignalSenderKeyName(item.groupId, authorJid)
-            const senderMsg = new Group_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage)
-            const senderNameStr = senderName.toString()
-            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr])
-            if (!senderKey) {
-                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord())
-            }
-            return parsedKeys.transaction(async () => {
-                const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr])
-                if (!senderKey) {
-                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord())
-                }
-                await builder.process(senderName, senderMsg)
-            }, item.groupId)
-        },
-        async decryptMessage({ jid, type, ciphertext }) {
-            const addr = jidToSignalProtocolAddress(jid)
-            const session = new libsignal.SessionCipher(storage, addr)
-            async function doDecrypt() {
-                let result
-                switch (type) {
-                    case 'pkmsg':
-                        result = await session.decryptPreKeyWhisperMessage(ciphertext)
-                        break
-                    case 'msg':
-                        result = await session.decryptWhisperMessage(ciphertext)
-                        break
-                }
-                return result
-            }
-            if (isLikelySyncMessage(addr)) {
-                // If it's a sync message, we can skip the transaction
-                // as it is likely to be a system message that doesn't require strict atomicity
-                return await doDecrypt()
-            }
-            // If it's not a sync message, we need to ensure atomicity
-            // For regular messages, we use a transaction to ensure atomicity
-            return parsedKeys.transaction(async () => {
-                return await doDecrypt()
-            }, jid)
-        },
-        async encryptMessage({ jid, data }) {
-            // LID SINGLE SOURCE OF TRUTH: Always prefer LID when available
-            let encryptionJid = jid
-            // Check for LID mapping and use it if session exists
-            if (jid.includes('@s.whatsapp.net')) {
-                const lidForPN = await lidMapping.getLIDForPN(jid)
-                if (lidForPN?.includes('@lid')) {
-                    const lidAddr = jidToSignalProtocolAddress(lidForPN)
-                    const { [lidAddr.toString()]: lidSession } = await auth.keys.get('session', [lidAddr.toString()])
-                    if (lidSession) {
-                        // LID session exists, use it
-                        encryptionJid = lidForPN
-                    }
-                    else {
-                        // Try to migrate if PN session exists
-                        const pnAddr = jidToSignalProtocolAddress(jid)
-                        const { [pnAddr.toString()]: pnSession } = await auth.keys.get('session', [pnAddr.toString()])
-                        if (pnSession) {
-                            // Migrate PN to LID
-                            await repository.migrateSession([jid], lidForPN)
-                            encryptionJid = lidForPN
-                        }
-                    }
-                }
-            }
-            const addr = jidToSignalProtocolAddress(encryptionJid)
-            const cipher = new libsignal.SessionCipher(storage, addr)
-            // Use transaction to ensure atomicity
-            return parsedKeys.transaction(async () => {
-                const { type: sigType, body } = await cipher.encrypt(data)
-                const type = sigType === 3 ? 'pkmsg' : 'msg'
-                return { type, ciphertext: Buffer.from(body, 'binary') }
-            }, jid)
-        },
-        async encryptGroupMessage({ group, meId, data }) {
-            const senderName = jidToSignalSenderKeyName(group, meId)
-            const builder = new Group_1.GroupSessionBuilder(storage)
-            const senderNameStr = senderName.toString()
-            return parsedKeys.transaction(async () => {
-                const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr])
-                if (!senderKey) {
-                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord())
-                }
-                const senderKeyDistributionMessage = await builder.create(senderName)
-                const session = new Group_1.GroupCipher(storage, senderName)
-                const ciphertext = await session.encrypt(data)
-                return {
-                    ciphertext,
-                    senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
-                }
-            }, group)
-        }, 
-        async injectE2ESession({ jid, session }) {
-            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid))
-            return parsedKeys.transaction(async () => {
-                await cipher.initOutgoing(session)
-            }, jid)
-        },
-        jidToSignalProtocolAddress(jid) {
-            return jidToSignalProtocolAddress(jid).toString()
-        },
-        // Optimized direct access to LID mapping store
-        lidMapping,
-        async validateSession(jid) {
-            try {
-                const addr = jidToSignalProtocolAddress(jid)
-                const session = await storage.loadSession(addr.toString())
-                if (!session) {
-                    return { exists: false, reason: 'no session' }
-                }
-                if (!session.haveOpenSession()) {
-                    return { exists: false, reason: 'no open session' }
-                }
-                return { exists: true }
-            }
-            catch (error) {
-                return { exists: false, reason: 'validation error' }
-            }
-        },
-        async deleteSession(jids) {
-            if (!jids.length) return
-            
-            // Convert JIDs to signal addresses and prepare for bulk deletion
-            const sessionUpdates = {}
-            
-            jids.forEach(jid => {
-                const addr = jidToSignalProtocolAddress(jid)
-                sessionUpdates[addr.toString()] = null
-            })
-            
-            // Single transaction for all deletions
-            return parsedKeys.transaction(async () => {
-                await auth.keys.set({ session: sessionUpdates })
-            }, `delete-${jids.length}-sessions`)
-        },
-        async migrateSession(fromJids, toJid) {
-            if (!fromJids.length || !toJid.includes('@lid'))
-                return { migrated: 0, skipped: 0, total: 0 }
-                
-            // Filter valid PN JIDs
-            const validJids = fromJids.filter(jid => jid.includes('@s.whatsapp.net'))
-            
-            if (!validJids.length)
-                return { migrated: 0, skipped: 0, total: fromJids.length }
-                
-            // Single optimized transaction for all migrations
-            return parsedKeys.transaction(async () => {
-                // 1. Batch store all LID mappings
-                const mappings = validJids.map(jid => ({
-                    lid: WABinary_1.transferDevice(jid, toJid),
-                    pn: jid
-                }))
-                
-                await lidMapping.storeLIDPNMappings(mappings)
-                
-                // 2. Prepare migration operations
-                const migrationOps = validJids.map(jid => {
-                    const lidWithDevice = WABinary_1.transferDevice(jid, toJid)
-                    const fromDecoded = WABinary_1.jidDecode(jid)
-                    const toDecoded = WABinary_1.jidDecode(lidWithDevice)
-                    
-                    return {
-                        fromJid: jid,
-                        toJid: lidWithDevice,
-                        pnUser: fromDecoded.user,
-                        lidUser: toDecoded.user,
-                        deviceId: fromDecoded.device || 0,
-                        fromAddr: jidToSignalProtocolAddress(jid),
-                        toAddr: jidToSignalProtocolAddress(lidWithDevice)
-                    }
-                })
-                
-                // 3. Batch check which LID sessions already exist
-                const lidAddrs = migrationOps.map(op => op.toAddr.toString())
-                const existingSessions = await auth.keys.get('session', lidAddrs)
-                
-                // 4. Filter out sessions that already have LID sessions
-                const opsToMigrate = migrationOps.filter(op => !existingSessions[op.toAddr.toString()])
-                const skippedCount = migrationOps.length - opsToMigrate.length
-                
-                if (!opsToMigrate.length) {
-                    return { migrated: 0, skipped: skippedCount, total: validJids.length };
-                }
-                
-                // 5. Execute all migrations in parallel
-                await Promise.all(opsToMigrate.map(async (op) => {
-                    const fromSession = await storage.loadSession(op.fromAddr.toString())
-                    
-                    if (fromSession?.haveOpenSession()) {
-                        // Copy session to LID address
-                        const sessionBytes = fromSession.serialize()
-                        const copiedSession = libsignal.SessionRecord.deserialize(sessionBytes)
-                        await storage.storeSession(op.toAddr.toString(), copiedSession)
-                        
-                        // Delete PN session
-                        await auth.keys.set({ session: { [op.fromAddr.toString()]: null } })
-                    }
-                }))
-                
-                return { migrated: opsToMigrate.length, skipped: skippedCount, total: validJids.length }
-            }, `migrate-${validJids.length}-sessions-${WABinary_1.jidDecode(toJid)?.user}`)
-        },
-        async encryptMessageWithWire({ encryptionJid, wireJid, data }) {
-            const result = await repository.encryptMessage({ jid: encryptionJid, data })
-            return { ...result, wireJid }
-        }
-    }
-    return repository
-}
-
-const jidToSignalProtocolAddress = (jid) => {
-    const decoded = WABinary_1.jidDecode(jid)
-    const { user, device, server } = decoded
-    
-    if (!user) {
-        throw new Error(`JID decoded but user is empty: "${jid}" -> user: "${user}", server: "${server}", device: ${device}`)
-    }
-    
-    // LID addresses get _1 suffix for Signal protocol
-    const signalUser = server === 'lid' ? `${user}_1` : user
-    const finalDevice = device || 0
-    
-    return new libsignal.ProtocolAddress(signalUser, finalDevice)
-}
-
-const jidToSignalSenderKeyName = (group, user) => {
-    return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user))
-}
-
-function signalStorage({ creds, keys }, lidMapping) {
-    return {
-        loadSession: async (id) => {
-            try {
-                // LID SINGLE SOURCE OF TRUTH: Auto-redirect PN to LID if mapping exists
-                let actualId = id
-                if (id.includes('.') && !id.includes('_1')) {
-                    // This is a PN signal address format (e.g., "1234567890.0")
-                    // Convert back to JID to check for LID mapping
-                    const parts = id.split('.')
-                    const device = parts[1] || '0'
-                    const pnJid = device === '0' ? `${parts[0]}@s.whatsapp.net` : `${parts[0]}:${device}@s.whatsapp.net`
-                    const lidForPN = await lidMapping.getLIDForPN(pnJid)
-                    if (lidForPN?.includes('@lid')) {
-                        const lidAddr = jidToSignalProtocolAddress(lidForPN)
-                        const lidId = lidAddr.toString()
-                        // Check if LID session exists
-                        const { [lidId]: lidSession } = await keys.get('session', [lidId])
-                        if (lidSession) {
-                            actualId = lidId
-                        }
-                    }
-                }
-                const { [actualId]: sess } = await keys.get('session', [actualId])
-                if (sess) {
-                    return libsignal.SessionRecord.deserialize(sess)
-                }
-            }
-            catch (e) {
-                return null
-            }
-            return null
-        },
-        // TODO: Replace with libsignal.SessionRecord when type exports are added to libsignal
-        storeSession: async (id, session) => {
-            await keys.set({ session: { [id]: session.serialize() } })
-        },
-        isTrustedIdentity: () => {
-            return true
-        },
-        loadPreKey: async (id) => {
-            const keyId = id.toString()
-            const { [keyId]: key } = await keys.get('pre-key', [keyId])
-            if (key) {
-                return {
-                    privKey: Buffer.from(key.private),
-                    pubKey: Buffer.from(key.public)
-                }
-            }
-        },
-        removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
-        loadSignedPreKey: () => {
-            const key = creds.signedPreKey
-            return {
-                privKey: Buffer.from(key.keyPair.private),
-                pubKey: Buffer.from(key.keyPair.public)
-            }
-        },
-        loadSenderKey: async (senderKeyName) => {
-            const keyId = senderKeyName.toString()
-            const { [keyId]: key } = await keys.get('sender-key', [keyId])
-            if (key) {
-                return sender_key_record_1.SenderKeyRecord.deserialize(key)
-            }
-            return new sender_key_record_1.SenderKeyRecord()
-        },
-        storeSenderKey: async (senderKeyName, key) => {
-            const keyId = senderKeyName.toString()
-            const serialized = JSON.stringify(key.serialize())
-            await keys.set({ 'sender-key': { [keyId]: Buffer.from(serialized, 'utf-8') } })
-        },
-        getOurRegistrationId: () => creds.registrationId,
-        getOurIdentity: () => {
-            const { signedIdentityKey } = creds
-            return {
-                privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: Buffer.from(Utils_1.generateSignalPubKey(signedIdentityKey.public)) 
-            }
-        }
-    }
-}
-
-module.exports = {
-  makeLibSignalRepository
-}

package/lib/Signal/lid-mapping.d.ts

@@ -1,28 +0,0 @@
-import { ILogger } from '@neelegirl/baileys/lib/Utils/loggerr'
-import { SignalKeyStoreWithTransaction } from '@neelegirl/baileys/lib/Types'
-
-export declare class LIDMappingStore {
-    private readonly mappingCache
-    private readonly keys
-    private onWhatsAppFunc?
-    constructor(keys: SignalKeyStoreWithTransaction, onWhatsAppFunc?: (...jids: string[], logger: ILogger ) => Promise<{
-        jid: string
-        exists: boolean
-        lid: string
-    }[] | undefined>)
-    /**
-     * Store LID-PN mapping - USER LEVEL
-     */
-    storeLIDPNMappings(pairs: {
-        lid: string;
-        pn: string;
-    }[]): Promise<void>
-    /**
-     * Get LID for PN - Returns device-specific LID based on user mapping
-     */
-    getLIDForPN(pn: string): Promise<string | null>
-    /**
-     * Get PN for LID - USER LEVEL with device construction
-     */
-    getPNForLID(lid: string): Promise<string | null>
-}

package/lib/Signal/lid-mapping.js

@@ -1,184 +0,0 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const lru_cache_1 = require("lru-cache")
-const WABinary_1 = require("../WABinary")
-
-class LIDMappingStore {
-	constructor(keys, onWhatsAppFunc, logger) {
-		this.mappingCache = new lru_cache_1.LRUCache({
-            ttl: 7 * 24 * 60 * 60 * 1000, // 7 days
-            ttlAutopurge: true,
-            updateAgeOnGet: true
-        })
-		this.keys = keys
-		this.logger = logger
-		this.onWhatsAppFunc = onWhatsAppFunc // needed to get LID from PN if not found
-	}
-	/**
-     * Store LID-PN mapping - USER LEVEL
-     */
-    async storeLIDPNMappings(pairs) {
-        // Validate inputs
-        const pairMap = {}
-        const logger = this.logger
-        
-        for (const { lid, pn } of pairs) {
-            if (!((WABinary_1.isLidUser(lid) && WABinary_1.isJidUser(pn)) || (WABinary_1.isJidUser(lid) && WABinary_1.isLidUser(pn)))) {
-                logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`)
-                continue
-            }
-            
-            const [lidJid, pnJid] = WABinary_1.isLidUser(lid) ? [lid, pn] : [pn, lid]
-            const lidDecoded = WABinary_1.jidDecode(lidJid)
-            const pnDecoded = WABinary_1.jidDecode(pnJid)
-            
-            if (!lidDecoded || !pnDecoded) return
-            
-            const pnUser = pnDecoded.user
-            const lidUser = lidDecoded.user
-            
-            // Check if mapping already exists (cache first, then database)
-            let existingLidUser = this.mappingCache.get(`pn:${pnUser}`)
-            
-            if (!existingLidUser) {
-                // Cache miss - check database
-                const stored = await this.keys.get('lid-mapping', [pnUser])
-                
-                existingLidUser = stored[pnUser]
-                
-                if (existingLidUser) {
-                    // Update cache with database value
-                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser)
-                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser)
-                }
-            }
-            
-            if (existingLidUser === lidUser) {
-                logger.debug({ pnUser, lidUser }, 'LID mapping already exists, skipping')
-                continue
-            }
-            
-            pairMap[pnUser] = lidUser
-        }
-        
-        logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`)
-        
-        await this.keys.transaction(async () => {
-            for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-                await this.keys.set({
-                    'lid-mapping': {
-                        [pnUser]: lidUser, // "554396160286" -> "102765716062358"
-                        [`${lidUser}_reverse`]: pnUser // "102765716062358_reverse" -> "554396160286"
-                    }
-                })
-                
-                // Update cache with both directions
-                this.mappingCache.set(`pn:${pnUser}`, lidUser)
-                this.mappingCache.set(`lid:${lidUser}`, pnUser)
-            }
-        }, 'lid-mapping')
-    }
-    /**
-     * Get LID for PN - Returns device-specific LID based on user mapping
-     */
-    async getLIDForPN(pn) {
-        if (!WABinary_1.isJidUser(pn)) return null
-        
-        const logger = this.logger
-        const decoded = WABinary_1.jidDecode(pn)
-        
-        if (!decoded) return null
-        
-        // Check cache first for PN → LID mapping
-        const pnUser = decoded.user
-        
-        let lidUser = this.mappingCache.get(`pn:${pnUser}`)
-        
-        if (!lidUser) {
-            // Cache miss - check database
-            const stored = await this.keys.get('lid-mapping', [pnUser])
-            
-            lidUser = stored[pnUser]
-            
-            if (lidUser) {
-                // Cache the database result
-                this.mappingCache.set(`pn:${pnUser}`, lidUser)
-            }
-            
-            else {
-                // Not in database - try USync
-                logger.trace(`No LID mapping found for PN user ${pnUser}; getting from USync`)
-                
-                const { exists, lid } = (await this.onWhatsAppFunc?.(pn))?.[0] // this function already adds LIDs to mapping
-                
-                if (exists && lid) {
-                    lidUser = WABinary_1.jidDecode(lid)?.user
-                    
-                    if (lidUser) {
-                        // Cache the USync result
-                        this.mappingCache.set(`pn:${pnUser}`, lidUser)
-                    }
-                }
-                
-                else {
-                    return null
-                }
-            }
-        }
-        
-        if (typeof lidUser !== 'string' || !lidUser) {
-            logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`)
-            return null
-        }
-        
-        // Push the PN device ID to the LID to maintain device separation
-        const pnDevice = decoded.device !== undefined ? decoded.device : 0
-        const deviceSpecificLid = `${lidUser}:${pnDevice}@lid`
-        
-        logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`)
-        
-        return deviceSpecificLid
-    }
-    /**
-     * Get PN for LID - USER LEVEL with device construction
-     */
-     async getPNForLID(lid) {
-        if (!WABinary_1.isLidUser(lid)) return null
-        
-        const logger = this.logger
-        const decoded = WABinary_1.jidDecode(lid)
-        
-        if (!decoded) return null
-        
-        // Check cache first for LID → PN mapping
-        const lidUser = decoded.user
-        
-        let pnUser = this.mappingCache.get(`lid:${lidUser}`)
-        
-        if (!pnUser || typeof pnUser !== 'string') {
-            // Cache miss - check database
-            const stored = await this.keys.get('lid-mapping', [`${lidUser}_reverse`]);
-            pnUser = stored[`${lidUser}_reverse`]
-            
-            if (!pnUser || typeof pnUser !== 'string') {
-                logger.trace(`No reverse mapping found for LID user: ${lidUser}`)
-                return null
-            }
-            
-            this.mappingCache.set(`lid:${lidUser}`, pnUser)
-        }
-        
-        // Construct device-specific PN JID
-        const lidDevice = decoded.device !== undefined ? decoded.device : 0
-        const pnJid = `${pnUser}:${lidDevice}@s.whatsapp.net`
-        logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`)
-        
-        return pnJid
-    }
-}
-
-module.exports = {
-  LIDMappingStore
-}

package/lib/Socket/Client/abstract-socket-client.d.ts

@@ -1,15 +0,0 @@
-import { EventEmitter } from 'events';
-import { URL } from 'url';
-import { SocketConfig } from '../../Types';
-export declare abstract class AbstractSocketClient extends EventEmitter {
-    url: URL;
-    config: SocketConfig;
-    abstract get isOpen(): boolean;
-    abstract get isClosed(): boolean;
-    abstract get isClosing(): boolean;
-    abstract get isConnecting(): boolean;
-    constructor(url: URL, config: SocketConfig);
-    abstract connect(): Promise<void>;
-    abstract close(): Promise<void>;
-    abstract send(str: Uint8Array | string, cb?: (err?: Error) => void): boolean;
-}

package/lib/Socket/Client/abstract-socket-client.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractSocketClient = void 0;
-const events_1 = require("events");
-class AbstractSocketClient extends events_1.EventEmitter {
-    constructor(url, config) {
-        super();
-        this.url = url;
-        this.config = config;
-        this.setMaxListeners(0);
-    }
-}
-exports.AbstractSocketClient = AbstractSocketClient;

package/lib/Socket/Client/index.d.ts

@@ -1,2 +0,0 @@
-export * from '@neelegirl/baileys/lib/Socket/Client/types'
-export * from '@neelegirl/baileys/lib/Socket/Client/websocket'

package/lib/Socket/Client/index.js

@@ -1,22 +0,0 @@
-"use strict"
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k
-    var desc = Object.getOwnPropertyDescriptor(m, k)
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k] } }
-    }
-    Object.defineProperty(o, k2, desc)
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k
-    o[k2] = m[k]
-}))
-
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p)
-}
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-__exportStar(require("./types"), exports)
-__exportStar(require("./websocket"), exports)

package/lib/Socket/Client/mobile-socket-client.d.ts

@@ -1,12 +0,0 @@
-import { Socket } from 'net';
-import { AbstractSocketClient } from './abstract-socket-client';
-export declare class MobileSocketClient extends AbstractSocketClient {
-    protected socket: Socket | null;
-    get isOpen(): boolean;
-    get isClosed(): boolean;
-    get isClosing(): boolean;
-    get isConnecting(): boolean;
-    connect(): Promise<void>;
-    close(): Promise<void>;
-    send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean;
-}