@neelegirl/baileys 2.1.8 → 2.2.0

package/lib/WABinary/jid-utils.d.ts

@@ -10,14 +10,7 @@ export declare const STORIES_JID = "status@broadcast"
 
 export declare const META_AI_JID = '13135550002@c.us'
 
-export type JidServer = 'c.us' | 'g.us' | 'broadcast' | 's.whatsapp.net' | 'call' | 'lid' | 'newsletter' | 'bot' | 'hosted' | 'hosted.lid'
-
-export declare enum WAJIDDomains {
-    WHATSAPP = 0,
-    LID = 1,
-    HOSTED = 128,
-    HOSTED_LID = 129
-}
+export type JidServer = 'c.us' | 'g.us' | 'broadcast' | 's.whatsapp.net' | 'call' | 'lid' | 'newsletter' | 'bot'
 
 export type JidWithDevice = {
     user: string
@@ -33,21 +26,13 @@ export declare const jidEncode: (user: string | number | null, server: JidServer
 
 export declare const jidDecode: (jid: string | undefined) => FullJid | undefined
 
-export declare const getServerFromDomainType: (initialServer: string, domainType?: WAJIDDomains) => JidServer
-
 /** is the jid a user */
 export declare const areJidsSameUser: (jid1: string | undefined, jid2: string | undefined) => boolean
 
-/** is the jid Meta AI */
-export declare const isJidMetaAI: (jid: string | undefined) => boolean | undefined
-
-/** is the jid a PN user */
-export declare const isPnUser: (jid: string | undefined) => boolean | undefined
-
-/** backward-compatible alias */
+/** is the lid a user */
 export declare const isJidUser: (jid: string | undefined) => boolean | undefined
 
-/** is the lid a user */
+/** is the jid a group */
 export declare const isLidUser: (jid: string | undefined) => boolean | undefined
 
 /** is the jid a broadcast */
@@ -71,6 +56,4 @@ export declare const isHostedLidUser: (jid: string | undefined) => boolean | und
 /** is the jid a bot */
 export declare const isJidBot: (jid: string | undefined) => boolean | undefined
 
-export declare const jidNormalizedUser: (jid: string | undefined) => string
-
-export declare const transferDevice: (fromJid: string, toJid: string) => string
+export declare const jidNormalizedUser: (jid: string | undefined) => string

package/lib/WABinary/jid-utils.js

@@ -14,27 +14,6 @@ const STORIES_JID = 'status@broadcast'
 
 const META_AI_JID = '13135550002@c.us'
 
-const WAJIDDomains = {
-    WHATSAPP: 0,
-    LID: 1,
-    HOSTED: 128,
-    HOSTED_LID: 129
-}
-
-const getServerFromDomainType = (initialServer, domainType = WAJIDDomains.WHATSAPP) => {
-    switch (domainType) {
-        case WAJIDDomains.LID:
-            return 'lid'
-        case WAJIDDomains.HOSTED:
-            return 'hosted'
-        case WAJIDDomains.HOSTED_LID:
-            return 'hosted.lid'
-        case WAJIDDomains.WHATSAPP:
-        default:
-            return initialServer
-    }
-}
-
 const jidEncode = (user, server, device, agent) => {
     return `${user || ''}${!!agent ? `_${agent}` : ''}${!!device ? `:${device}` : ''}@${server}`
 }
@@ -48,10 +27,10 @@ const jidDecode = (jid) => {
     const userCombined = jid.slice(0, sepIdx)
     const [userAgent, device] = userCombined.split(':')
     const [user, agent] = (userAgent || '').split('_')
-    let domainType = WAJIDDomains.WHATSAPP
-    if (server === 'lid') domainType = WAJIDDomains.LID
-    else if (server === 'hosted') domainType = WAJIDDomains.HOSTED
-    else if (server === 'hosted.lid') domainType = WAJIDDomains.HOSTED_LID
+    let domainType = 0
+    if (server === 'lid') domainType = 1
+    else if (server === 'hosted') domainType = 128
+    else if (server === 'hosted.lid') domainType = 129
     else if (agent) domainType = parseInt(agent, 10)
     return {
         server,
@@ -66,14 +45,8 @@ const areJidsSameUser = (jid1, jid2) => {
     return jidDecode(jid1)?.user === jidDecode(jid2)?.user
 }
 
-/** is the jid Meta AI */
-const isJidMetaAI = (jid) => jid?.endsWith('@bot')
-
-/** is the jid a PN user */
-const isPnUser = (jid) => jid?.endsWith('@s.whatsapp.net')
-
-/** backward-compatible alias */
-const isJidUser = isPnUser
+/** is the jid a user */
+const isJidUser = (jid) => jid?.endsWith('@s.whatsapp.net')
 
 /** is the lid a user */
 const isLidUser = (jid) => jid?.endsWith('@lid')
@@ -109,16 +82,6 @@ const jidNormalizedUser = (jid) => {
     return jidEncode(user, server === 'c.us' ? 's.whatsapp.net' : server)
 }
 
-const transferDevice = (fromJid, toJid) => {
-    const fromDecoded = jidDecode(fromJid)
-    const deviceId = fromDecoded?.device || 0
-    const toDecoded = jidDecode(toJid)
-    if (!toDecoded) {
-        throw new Error(`invalid jid for device transfer: ${toJid}`)
-    }
-    return jidEncode(toDecoded.user, toDecoded.server, deviceId)
-}
-
 module.exports = {
   S_WHATSAPP_NET,
   OFFICIAL_BIZ_JID,
@@ -126,13 +89,9 @@ module.exports = {
   PSA_WID,
   STORIES_JID,
   META_AI_JID,
-  WAJIDDomains,
-  getServerFromDomainType,
   jidEncode,
   jidDecode,
   areJidsSameUser,
-  isJidMetaAI,
-  isPnUser,
   isJidUser,
   isLidUser,
   isJidBroadcast,
@@ -142,6 +101,5 @@ module.exports = {
   isHostedPnUser,
   isHostedLidUser,
   isJidBot,
-  jidNormalizedUser,
-  transferDevice
-}
+  jidNormalizedUser
+}

package/package.json

@@ -1,57 +1,77 @@
 {
   "name": "@neelegirl/baileys",
-  "version": "2.1.8",
-  "description": "CommonJS Neelegirl Baileys fork with preserved QR/NEELE logic and selective WhiskeySockets/Baileys compatibility updates",
+  "version": "2.2.0",
+  "description": "Conservative Neelegirl-maintained CommonJS WhatsApp Web client based on WhiskeySockets/Baileys with preserved QR, NEELE message IDs and device/LID handling.",
   "keywords": [
     "whatsapp",
+    "baileys",
+    "neelegirl",
     "js-whatsapp",
     "whatsapp-api",
     "whatsapp-web",
     "whatsapp-chat",
     "whatsapp-group",
     "automation",
-    "multi-device",
-    "commonjs",
-    "lid",
-    "neelegirl",
-    "baileys"
+    "multi-device"
   ],
-  "homepage": "https://github.com/neelegirl/baileys",
+  "homepage": "https://www.npmjs.com/package/@neelegirl/baileys",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/neelegirl/baileys.git"
-  },
-  "bugs": {
-    "url": "https://github.com/neelegirl/baileys/issues"
+    "url": "git+https://github.com/WhiskeySockets/Baileys.git"
   },
   "license": "MIT",
   "author": "Neele",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js"
+    },
+    "./lib": {
+      "types": "./lib/index.d.ts",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js"
+    },
+    "./lib/*": {
+      "types": "./lib/*.d.ts",
+      "require": "./lib/*.js",
+      "default": "./lib/*.js"
+    },
+    "./WAProto": {
+      "types": "./WAProto/index.d.ts",
+      "require": "./WAProto/index.js",
+      "default": "./WAProto/index.js"
+    },
+    "./WAProto/*": {
+      "types": "./WAProto/*.d.ts",
+      "require": "./WAProto/*.js",
+      "default": "./WAProto/*.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "lib/**/*",
     "WAProto/**/*",
-    "engine-requirements.js"
+    "LICENSE",
+    "README.md"
   ],
   "scripts": {
-    "build:all": "tsc && typedoc",
-    "build:docs": "typedoc",
-    "build:tsc": "tsc",
-    "preinstall": "node ./engine-requirements.js",
-    "test": "node -e \"console.log('No tests configured')\""
+    "smoke": "node -e \"require('./lib/index.js')\"",
+    "test": "node -e \"require('./lib/index.js')\""
   },
   "dependencies": {
     "@adiwajshing/keyed-db": "^0.2.4",
     "@cacheable/node-cache": "^1.5.4",
     "@hapi/boom": "^9.1.3",
-    "@neelegirl/libsignal": "^1.0.12",
+    "@neelegirl/libsignal": "^1.0.2",
     "async-mutex": "^0.5.0",
     "audio-decode": "^2.1.3",
     "axios": "^1.3.3",
     "cache-manager": "4.0.1",
     "futoin-hkdf": "^1.5.1",
     "libphonenumber-js": "^1.10.20",
-    "lru-cache": "^11.1.0",
     "music-metadata": "^7.12.3",
     "node-cache": "^5.1.2",
     "pino": "^7.0.0",
@@ -69,7 +89,7 @@
     "conventional-changelog-cli": "^2.2.2",
     "eslint": "^8.0.0",
     "jest": "^27.0.6",
-    "jimp": "^0.16.13",
+ "jimp": "^0.16.13",
     "json": "^11.0.0",
     "link-preview-js": "^3.0.5",
     "open": "^8.4.2",
@@ -82,16 +102,12 @@
     "typescript": "^4.6.4"
   },
   "peerDependencies": {
-    "audio-decode": "^2.1.3",
     "jimp": "^0.22.12",
     "link-preview-js": "^3.0.0",
     "qrcode-terminal": "^0.12.0",
     "sharp": "^0.32.6"
   },
   "peerDependenciesMeta": {
-    "audio-decode": {
-      "optional": true
-    },
     "jimp": {
       "optional": true
     },
@@ -105,8 +121,8 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@1.22.19",
   "engines": {
-    "node": ">=20.0.0"
-  }
+    "node": ">=16.0.0"
+  },
+  "packageManager": "yarn@1.22.19"
 }

package/WAProto/GenerateStatics.sh

@@ -1,3 +0,0 @@
-yarn pbjs -t static-module --no-beautify -w es6 --no-bundle --no-delimited --no-verify --no-comments -o ./index.js ./WAProto.proto;
-yarn pbjs -t static-module --no-beautify -w es6 --no-bundle --no-delimited --no-verify ./WAProto.proto | yarn pbts --no-comments -o ./index.d.ts -;
-node ./fix-imports.js

package/WAProto/fix-imports.js

@@ -1,81 +0,0 @@
-import { readFileSync, writeFileSync } from 'fs';
-import { exit } from 'process';
-
-const filePath = './index.js'
-
-try {
-  let content = readFileSync(filePath, 'utf8')
-
-  content = content.replace(/import \* as (\$protobuf) from/g, 'import $1 from')
-  content = content.replace(/(['"])protobufjs\/minimal(['"])/g, '$1protobufjs/minimal.js$2')
-
-  const marker = 'const $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});\n\n'
-  const longToStringHelper =
-    'function longToString(value, unsigned) {\n' +
-    '\tif (typeof value === "string") {\n' +
-    '\t\treturn value;\n' +
-    '\t}\n' +
-    '\tif (typeof value === "number") {\n' +
-    '\t\treturn String(value);\n' +
-    '\t}\n' +
-    '\tif (!$util.Long) {\n' +
-    '\t\treturn String(value);\n' +
-    '\t}\n' +
-    '\tconst normalized = $util.Long.fromValue(value);\n' +
-    '\tconst prepared = unsigned && normalized && typeof normalized.toUnsigned === "function"\n' +
-    '\t\t? normalized.toUnsigned()\n' +
-    '\t\t: normalized;\n' +
-    '\treturn prepared.toString();\n' +
-    '}\n\n'
-  const longToNumberHelper =
-    'function longToNumber(value, unsigned) {\n' +
-    '\tif (typeof value === "number") {\n' +
-    '\t\treturn value;\n' +
-    '\t}\n' +
-    '\tif (typeof value === "string") {\n' +
-    '\t\tconst numeric = Number(value);\n' +
-    '\t\treturn numeric;\n' +
-    '\t}\n' +
-    '\tif (!$util.Long) {\n' +
-    '\t\treturn Number(value);\n' +
-    '\t}\n' +
-    '\tconst normalized = $util.Long.fromValue(value);\n' +
-    '\tconst prepared = unsigned && normalized && typeof normalized.toUnsigned === "function"\n' +
-    '\t\t? normalized.toUnsigned()\n' +
-    '\t\t: typeof normalized.toSigned === "function"\n' +
-    '\t\t\t? normalized.toSigned()\n' +
-    '\t\t\t: normalized;\n' +
-    '\treturn prepared.toNumber();\n' +
-    '}\n\n'
-
-  if (!content.includes('function longToString(')) {
-    const markerIndex = content.indexOf(marker)
-    if (markerIndex === -1) {
-      throw new Error('Unable to inject Long helpers: marker not found in WAProto index output')
-    }
-
-    content = content.replace(marker, `${marker}${longToStringHelper}${longToNumberHelper}`)
-  } else {
-    const longToStringRegex = /function longToString\(value, unsigned\) {\n[\s\S]*?\n}\n\n/
-    const longToNumberRegex = /function longToNumber\(value, unsigned\) {\n[\s\S]*?\n}\n\n/
-
-    if (!longToStringRegex.test(content) || !longToNumberRegex.test(content)) {
-      throw new Error('Unable to update Long helpers: existing definitions not found')
-    }
-
-    content = content.replace(longToStringRegex, longToStringHelper)
-    content = content.replace(longToNumberRegex, longToNumberHelper)
-  }
-
-  const longPattern = /([ \t]+d\.(\w+) = )o\.longs === String \? \$util\.Long\.prototype\.toString\.call\(m\.\2\) : o\.longs === Number \? new \$util\.LongBits\(m\.\2\.low >>> 0, m\.\2\.high >>> 0\)\.toNumber\((true)?\) : m\.\2;/g
-  content = content.replace(longPattern, (_match, prefix, field, unsignedFlag) => {
-    const unsignedArg = unsignedFlag ? ', true' : ''
-    return `${prefix}o.longs === String ? longToString(m.${field}${unsignedArg}) : o.longs === Number ? longToNumber(m.${field}${unsignedArg}) : m.${field};`
-  })
-
-  writeFileSync(filePath, content, 'utf8')
-  console.log(`✅ Fixed imports in ${filePath}`)
-} catch (error) {
-  console.error(`❌ Error fixing imports: ${error.message}`)
-  exit(1)
-}

package/engine-requirements.js

@@ -1,10 +0,0 @@
-const major = parseInt(process.versions.node.split('.')[0], 10);
-
-if (major < 20) {
-  console.error(
-    `\n❌ This package requires Node.js 20+ to run reliably.\n` +
-    `   You are using Node.js ${process.versions.node}.\n` +
-    `   Please upgrade to Node.js 20+ to proceed.\n`
-  );
-  process.exit(1);
-}

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

@@ -1,23 +0,0 @@
-import type { LIDMapping, SignalKeyStoreWithTransaction } from '../Types'
-import type { ILogger } from '../Utils/logger'
-
-export declare class LIDMappingStore {
-    private readonly mappingCache
-    private readonly keys
-    private readonly logger
-    private readonly inflightLIDLookups
-    private readonly inflightPNLookups
-    private pnToLIDFunc?
-    constructor(
-        keys: SignalKeyStoreWithTransaction,
-        logger: ILogger,
-        pnToLIDFunc?: (jids: string[]) => Promise<LIDMapping[] | undefined>
-    )
-    storeLIDPNMappings(pairs: LIDMapping[]): Promise<void>
-    getLIDForPN(pn: string): Promise<string | null>
-    getLIDsForPNs(pns: string[]): Promise<LIDMapping[] | null>
-    getPNForLID(lid: string): Promise<string | null>
-    getPNsForLIDs(lids: string[]): Promise<LIDMapping[] | null>
-    private _getLIDsForPNsImpl
-    private _getPNsForLIDsImpl
-}

package/lib/Signal/lid-mapping.js

@@ -1,278 +0,0 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const LRUCacheModule = require("lru-cache")
-const LRUCache = LRUCacheModule.LRUCache || LRUCacheModule
-const WABinary_1 = require("../WABinary")
-
-class LIDMappingStore {
-    constructor(keys, logger, pnToLIDFunc) {
-        this.mappingCache = new LRUCache({
-            ttl: 3 * 24 * 60 * 60 * 1000,
-            ttlAutopurge: true,
-            updateAgeOnGet: true
-        })
-        this.inflightLIDLookups = new Map()
-        this.inflightPNLookups = new Map()
-        this.keys = keys
-        this.logger = logger
-        this.pnToLIDFunc = pnToLIDFunc
-    }
-    async storeLIDPNMappings(pairs) {
-        if (!pairs?.length) {
-            return
-        }
-        const validatedPairs = []
-        for (const { lid, pn } of pairs) {
-            const validDirection = ((0, WABinary_1.isLidUser)(lid) || (0, WABinary_1.isHostedLidUser)(lid))
-                && ((0, WABinary_1.isPnUser)(pn) || (0, WABinary_1.isHostedPnUser)(pn))
-            const reverseDirection = ((0, WABinary_1.isPnUser)(lid) || (0, WABinary_1.isHostedPnUser)(lid))
-                && ((0, WABinary_1.isLidUser)(pn) || (0, WABinary_1.isHostedLidUser)(pn))
-            if (!validDirection && !reverseDirection) {
-                this.logger?.warn?.({ lid, pn }, 'invalid LID-PN mapping')
-                continue
-            }
-            const lidJid = validDirection ? lid : pn
-            const pnJid = validDirection ? pn : lid
-            const lidDecoded = (0, WABinary_1.jidDecode)(lidJid)
-            const pnDecoded = (0, WABinary_1.jidDecode)(pnJid)
-            if (!lidDecoded?.user || !pnDecoded?.user) {
-                continue
-            }
-            validatedPairs.push({
-                pnUser: pnDecoded.user,
-                lidUser: lidDecoded.user
-            })
-        }
-        if (!validatedPairs.length) {
-            return
-        }
-        const cacheMissSet = new Set()
-        const existingMappings = new Map()
-        for (const { pnUser } of validatedPairs) {
-            const cached = this.mappingCache.get(`pn:${pnUser}`)
-            if (cached) {
-                existingMappings.set(pnUser, cached)
-            }
-            else {
-                cacheMissSet.add(pnUser)
-            }
-        }
-        if (cacheMissSet.size) {
-            const cacheMisses = [...cacheMissSet]
-            this.logger?.trace?.({ count: cacheMisses.length }, 'loading LID mappings from store')
-            const stored = await this.keys.get('lid-mapping', cacheMisses)
-            for (const pnUser of cacheMisses) {
-                const existingLidUser = stored[pnUser]
-                if (existingLidUser) {
-                    existingMappings.set(pnUser, existingLidUser)
-                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser)
-                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser)
-                }
-            }
-        }
-        const pairMap = {}
-        for (const { pnUser, lidUser } of validatedPairs) {
-            const existingLidUser = existingMappings.get(pnUser)
-            if (existingLidUser === lidUser) {
-                continue
-            }
-            pairMap[pnUser] = lidUser
-        }
-        if (!Object.keys(pairMap).length) {
-            return
-        }
-        const batchData = {}
-        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-            batchData[pnUser] = lidUser
-            batchData[`${lidUser}_reverse`] = pnUser
-        }
-        await this.keys.transaction(async () => {
-            await this.keys.set({ 'lid-mapping': batchData })
-        }, 'lid-mapping')
-        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-            this.mappingCache.set(`pn:${pnUser}`, lidUser)
-            this.mappingCache.set(`lid:${lidUser}`, pnUser)
-        }
-    }
-    async getLIDForPN(pn) {
-        return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null
-    }
-    async getLIDsForPNs(pns) {
-        if (!pns?.length) {
-            return null
-        }
-        const sortedPns = [...new Set(pns)].sort()
-        const cacheKey = sortedPns.join(',')
-        const inflight = this.inflightLIDLookups.get(cacheKey)
-        if (inflight) {
-            return inflight
-        }
-        const promise = this._getLIDsForPNsImpl(pns)
-        this.inflightLIDLookups.set(cacheKey, promise)
-        try {
-            return await promise
-        }
-        finally {
-            this.inflightLIDLookups.delete(cacheKey)
-        }
-    }
-    async _getLIDsForPNsImpl(pns) {
-        const usyncFetch = {}
-        const successfulPairs = {}
-        const pending = []
-        const addResolvedPair = (pn, decoded, lidUser) => {
-            if (!decoded || !lidUser) {
-                return false
-            }
-            const pnDevice = decoded.device !== undefined ? decoded.device : 0
-            const deviceSpecificLid = `${lidUser}${pnDevice ? `:${pnDevice}` : ''}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`
-            successfulPairs[pn] = { lid: deviceSpecificLid, pn }
-            return true
-        }
-        for (const pn of pns) {
-            if (!(0, WABinary_1.isPnUser)(pn) && !(0, WABinary_1.isHostedPnUser)(pn)) {
-                continue
-            }
-            const decoded = (0, WABinary_1.jidDecode)(pn)
-            if (!decoded?.user) {
-                continue
-            }
-            const pnUser = decoded.user
-            const cached = this.mappingCache.get(`pn:${pnUser}`)
-            if (cached && typeof cached === 'string') {
-                addResolvedPair(pn, decoded, cached)
-                continue
-            }
-            pending.push({ pn, pnUser, decoded })
-        }
-        if (pending.length) {
-            const pnUsers = [...new Set(pending.map(item => item.pnUser))]
-            const stored = await this.keys.get('lid-mapping', pnUsers)
-            for (const pnUser of pnUsers) {
-                const lidUser = stored[pnUser]
-                if (lidUser && typeof lidUser === 'string') {
-                    this.mappingCache.set(`pn:${pnUser}`, lidUser)
-                    this.mappingCache.set(`lid:${lidUser}`, pnUser)
-                }
-            }
-            for (const { pn, pnUser, decoded } of pending) {
-                const cached = this.mappingCache.get(`pn:${pnUser}`)
-                if (cached && typeof cached === 'string') {
-                    addResolvedPair(pn, decoded, cached)
-                    continue
-                }
-                const device = decoded.device || 0
-                let normalizedPn = (0, WABinary_1.jidNormalizedUser)(pn)
-                if ((0, WABinary_1.isHostedPnUser)(normalizedPn)) {
-                    normalizedPn = `${pnUser}@s.whatsapp.net`
-                }
-                if (!usyncFetch[normalizedPn]) {
-                    usyncFetch[normalizedPn] = [device]
-                }
-                else {
-                    usyncFetch[normalizedPn].push(device)
-                }
-            }
-        }
-        if (Object.keys(usyncFetch).length) {
-            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch))
-            if (result?.length) {
-                await this.storeLIDPNMappings(result)
-                for (const pair of result) {
-                    const pnDecoded = (0, WABinary_1.jidDecode)(pair.pn)
-                    const lidUser = (0, WABinary_1.jidDecode)(pair.lid)?.user
-                    const pnUser = pnDecoded?.user
-                    if (!pnUser || !lidUser) {
-                        continue
-                    }
-                    for (const device of usyncFetch[pair.pn] || []) {
-                        const deviceSpecificLid = `${lidUser}${device ? `:${device}` : ''}@${device === 99 ? 'hosted.lid' : 'lid'}`
-                        const deviceSpecificPn = `${pnUser}${device ? `:${device}` : ''}@${device === 99 ? 'hosted' : 's.whatsapp.net'}`
-                        successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn }
-                    }
-                }
-            }
-            else {
-                this.logger?.warn?.('USync did not return LID mappings for pending PN users')
-            }
-        }
-        const values = Object.values(successfulPairs)
-        return values.length ? values : null
-    }
-    async getPNForLID(lid) {
-        return (await this.getPNsForLIDs([lid]))?.[0]?.pn || null
-    }
-    async getPNsForLIDs(lids) {
-        if (!lids?.length) {
-            return null
-        }
-        const sortedLids = [...new Set(lids)].sort()
-        const cacheKey = sortedLids.join(',')
-        const inflight = this.inflightPNLookups.get(cacheKey)
-        if (inflight) {
-            return inflight
-        }
-        const promise = this._getPNsForLIDsImpl(lids)
-        this.inflightPNLookups.set(cacheKey, promise)
-        try {
-            return await promise
-        }
-        finally {
-            this.inflightPNLookups.delete(cacheKey)
-        }
-    }
-    async _getPNsForLIDsImpl(lids) {
-        const successfulPairs = {}
-        const pending = []
-        const addResolvedPair = (lid, decoded, pnUser) => {
-            if (!decoded || !pnUser || typeof pnUser !== 'string') {
-                return false
-            }
-            const lidDevice = decoded.device !== undefined ? decoded.device : 0
-            const pnJid = `${pnUser}${lidDevice ? `:${lidDevice}` : ''}@${decoded.domainType === WABinary_1.WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net'}`
-            successfulPairs[lid] = { lid, pn: pnJid }
-            return true
-        }
-        for (const lid of lids) {
-            if (!(0, WABinary_1.isLidUser)(lid) && !(0, WABinary_1.isHostedLidUser)(lid)) {
-                continue
-            }
-            const decoded = (0, WABinary_1.jidDecode)(lid)
-            if (!decoded?.user) {
-                continue
-            }
-            const lidUser = decoded.user
-            const cached = this.mappingCache.get(`lid:${lidUser}`)
-            if (cached && typeof cached === 'string') {
-                addResolvedPair(lid, decoded, cached)
-                continue
-            }
-            pending.push({ lid, lidUser, decoded })
-        }
-        if (pending.length) {
-            const reverseKeys = [...new Set(pending.map(item => `${item.lidUser}_reverse`))]
-            const stored = await this.keys.get('lid-mapping', reverseKeys)
-            for (const { lid, lidUser, decoded } of pending) {
-                let pnUser = this.mappingCache.get(`lid:${lidUser}`)
-                if (!pnUser || typeof pnUser !== 'string') {
-                    pnUser = stored[`${lidUser}_reverse`]
-                    if (pnUser && typeof pnUser === 'string') {
-                        this.mappingCache.set(`lid:${lidUser}`, pnUser)
-                        this.mappingCache.set(`pn:${pnUser}`, lidUser)
-                    }
-                }
-                if (pnUser && typeof pnUser === 'string') {
-                    addResolvedPair(lid, decoded, pnUser)
-                }
-            }
-        }
-        const values = Object.values(successfulPairs)
-        return values.length ? values : null
-    }
-}
-
-module.exports = {
-    LIDMappingStore
-}

package/lib/Utils/browser-utils.d.ts

@@ -1 +0,0 @@
-export { Browsers, getPlatformId } from './generics'