@badzz88/baileys 8.5.4 → 8.5.6

package/lib/Signal/lid-mapping.js

@@ -1,280 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.LIDMappingStore = void 0
-const lru_cache_1 = require('lru-cache')
-const WABinary_1 = require('../WABinary')
-class LIDMappingStore {
-	constructor(keys, logger, pnToLIDFunc) {
-		this.mappingCache = new lru_cache_1.LRUCache({
-			ttl: 3 * 24 * 60 * 60 * 1000, 
-			ttlAutopurge: true,
-			updateAgeOnGet: true
-		})
-		this.inflightLIDLookups = new Map()
-		this.inflightPNLookups = new Map()
-		this.keys = keys
-		this.pnToLIDFunc = pnToLIDFunc
-		this.logger = logger
-	}
-	async storeLIDPNMappings(pairs) {
-		if (pairs.length === 0) return
-		const validatedPairs = []
-		for (const { lid, pn } of pairs) {
-			if (!(
-				((0, WABinary_1.isLidUser)(lid) && (0, WABinary_1.isPnUser)(pn)) ||
-				((0, WABinary_1.isPnUser)(lid) && (0, WABinary_1.isLidUser)(pn))
-			)) {
-				this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`)
-				continue
-			}
-			const lidDecoded = (0, WABinary_1.jidDecode)(lid)
-			const pnDecoded = (0, WABinary_1.jidDecode)(pn)
-			if (!lidDecoded || !pnDecoded) continue
-			validatedPairs.push({ pnUser: pnDecoded.user, lidUser: lidDecoded.user })
-		}
-		if (validatedPairs.length === 0) 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 > 0) {
-			const cacheMisses = [...cacheMissSet]
-			this.logger.trace(`Batch fetching ${cacheMisses.length} LID mappings from database`)
-			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) {
-				this.logger.debug({ pnUser, lidUser }, 'LID mapping already exists, skipping')
-				continue
-			}
-			pairMap[pnUser] = lidUser
-		}
-		if (Object.keys(pairMap).length === 0) return
-		this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`)
-		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 getStoredLIDForPN(pn) {
-		if (!(0, WABinary_1.isPnUser)(pn) && !(0, WABinary_1.isHostedPnUser)(pn)) return null
-		const decoded = (0, WABinary_1.jidDecode)(pn)
-		if (!decoded) return null
-		const pnUser = decoded.user
-		let lidUser = this.mappingCache.get(`pn:${pnUser}`)
-		if (!lidUser || typeof lidUser !== 'string') {
-			const stored = await this.keys.get('lid-mapping', [pnUser])
-			lidUser = stored[pnUser]
-			if (lidUser && typeof lidUser === 'string') {
-				this.mappingCache.set(`pn:${pnUser}`, lidUser)
-				this.mappingCache.set(`lid:${lidUser}`, pnUser)
-			}
-		}
-		if (!lidUser || typeof lidUser !== 'string') return null
-		const pnDevice = decoded.device !== undefined ? decoded.device : 0
-		return `${lidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`
-	}
-	async getLIDsForPNs(pns) {
-		if (pns.length === 0) return null
-		const sortedPns = [...new Set(pns)].sort()
-		const cacheKey = sortedPns.join(',')
-		const inflight = this.inflightLIDLookups.get(cacheKey)
-		if (inflight) {
-			this.logger.trace(`Coalescing getLIDsForPNs request for ${sortedPns.length} PNs`)
-			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) => {
-			const normalizedLidUser = lidUser.toString()
-			if (!normalizedLidUser) {
-				this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`)
-				return false
-			}
-			
-			const pnDevice = decoded.device !== undefined ? decoded.device : 0
-			const deviceSpecificLid = `${normalizedLidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`
-			this.logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`)
-			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) continue
-			const pnUser = decoded.user
-			const cached = this.mappingCache.get(`pn:${pnUser}`)
-			if (cached && typeof cached === 'string') {
-				if (!addResolvedPair(pn, decoded, cached)) {
-					this.logger.warn(`Invalid entry for ${pn} (pair not resolved)`)
-					continue
-				}
-				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') {
-					if (!addResolvedPair(pn, decoded, cached)) {
-						this.logger.warn(`Invalid entry for ${pn} (pair not resolved)`)
-						continue
-					}
-				} else {
-					this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`)
-					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 > 0) {
-			const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch)) 
-			if (result && result.length > 0) {
-				await this.storeLIDPNMappings(result)
-				for (const pair of result) {
-					const pnDecoded = (0, WABinary_1.jidDecode)(pair.pn)
-					const pnUser = pnDecoded?.user
-					if (!pnUser) continue
-					const lidUser = (0, WABinary_1.jidDecode)(pair.lid)?.user
-					if (!lidUser) continue
-					for (const device of usyncFetch[pair.pn]) {
-						const deviceSpecificLid = `${lidUser}${!!device ? `:${device}` : ``}@${device === 99 ? 'hosted.lid' : 'lid'}`
-						this.logger.trace(
-							`getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`
-						)
-						const deviceSpecificPn = `${pnUser}${!!device ? `:${device}` : ``}@${device === 99 ? 'hosted' : 's.whatsapp.net'}`
-						successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn }
-					}
-				}
-			} else {
-				this.logger.warn('USync fetch yielded no results for pending PNs')
-			}
-		}
-		return Object.values(successfulPairs).length > 0 ? Object.values(successfulPairs) : null
-	}
-	async getPNForLID(lid) {
-		return (await this.getPNsForLIDs([lid]))?.[0]?.pn || null
-	}
-	async getPNsForLIDs(lids) {
-		if (lids.length === 0) return null
-		const sortedLids = [...new Set(lids)].sort()
-		const cacheKey = sortedLids.join(',')
-		const inflight = this.inflightPNLookups.get(cacheKey)
-		if (inflight) {
-			this.logger.trace(`Coalescing getPNsForLIDs request for ${sortedLids.length} LIDs`)
-			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 (!pnUser || typeof pnUser !== 'string') {
-				return false
-			}
-			const lidDevice = decoded.device !== undefined ? decoded.device : 0
-			const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WABinary_1.WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net'}`
-			this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`)
-			successfulPairs[lid] = { lid, pn: pnJid }
-			return true
-		}
-		for (const lid of lids) {
-			if (!(0, WABinary_1.isLidUser)(lid)) continue
-			const decoded = (0, WABinary_1.jidDecode)(lid)
-			if (!decoded) 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)
-				} else {
-					this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`)
-				}
-			}
-		}
-		return Object.values(successfulPairs).length ? Object.values(successfulPairs) : null
-	}
-}
-exports.LIDMappingStore = LIDMappingStore

package/lib/Socket/Client/index.js

@@ -1,30 +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/types.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/websocket.js

@@ -1,62 +0,0 @@
-'use strict'
-var __importDefault =
-	(this && this.__importDefault) ||
-	function (mod) {
-		return mod && mod.__esModule ? mod : { default: mod }
-	}
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.WebSocketClient = void 0
-const ws_1 = __importDefault(require('ws'))
-const Defaults_1 = require('../../Defaults')
-const types_1 = require('./types')
-class WebSocketClient extends types_1.AbstractSocketClient {
-	constructor() {
-		super(...arguments)
-		this.socket = null
-	}
-	get isOpen() {
-		return this.socket?.readyState === ws_1.default.OPEN
-	}
-	get isClosed() {
-		return this.socket === null || this.socket?.readyState === ws_1.default.CLOSED
-	}
-	get isClosing() {
-		return this.socket === null || this.socket?.readyState === ws_1.default.CLOSING
-	}
-	get isConnecting() {
-		return this.socket?.readyState === ws_1.default.CONNECTING
-	}
-	connect() {
-		if (this.socket) {
-			return
-		}
-		this.socket = new ws_1.default(this.url, {
-			origin: Defaults_1.DEFAULT_ORIGIN,
-			headers: this.config.options?.headers,
-			handshakeTimeout: this.config.connectTimeoutMs,
-			timeout: this.config.connectTimeoutMs,
-			agent: this.config.agent
-		})
-		this.socket.setMaxListeners(0)
-		const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response']
-		for (const event of events) {
-			this.socket?.on(event, (...args) => this.emit(event, ...args))
-		}
-	}
-	async close() {
-		if (!this.socket) {
-			return
-		}
-		const closePromise = new Promise(resolve => {
-			this.socket?.once('close', resolve)
-		})
-		this.socket.close()
-		await closePromise
-		this.socket = null
-	}
-	send(str, cb) {
-		this.socket?.send(str, cb)
-		return Boolean(this.socket)
-	}
-}
-exports.WebSocketClient = WebSocketClient

package/lib/Socket/aigroups.js

@@ -1,240 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.extractAIGroupMetadata = exports.makeAIGroupsSocket = void 0
-const Types_1 = require('../Types')
-const Utils_1 = require('../Utils')
-const WABinary_1 = require('../WABinary')
-const groups_1 = require('./groups')
-
-const makeAIGroupsSocket = config => {
-	const sock = (0, groups_1.makeGroupsSocket)(config)
-	const { ev, query } = sock
-
-	
-	const aiGroupQuery = async (jid, type, content) =>
-		query({
-			tag: 'iq',
-			attrs: {
-				type,
-				xmlns: 'w:g2',
-				to: jid
-			},
-			content
-		})
-
-	const aiGroupMetadata = async jid => {
-		const result = await aiGroupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }])
-		return (0, exports.extractAIGroupMetadata)(result)
-	}
-
-	
-	sock.ws.on('CB:notification,w:gp2', async node => {
-		const { attrs, content } = node
-		if (!Array.isArray(content) || content.length === 0) return
-
-		const inner = content[0]
-		const tag = inner.tag
-		const groupId =
-			typeof attrs.from === 'string'
-				? attrs.from
-				: attrs.from?.$1?.user
-					? (0, WABinary_1.jidEncode)(attrs.from.$1.user, 'g.us')
-					: undefined
-
-		if (!groupId) return
-
-		if (tag === 'create') {
-			
-			try {
-				const meta = await aiGroupMetadata(groupId)
-				ev.emit('groups.upsert', [meta])
-			} catch {
-				
-				ev.emit('groups.upsert', [{ id: groupId }])
-			}
-		} else if (tag === 'promote' || tag === 'demote' || tag === 'remove' || tag === 'add') {
-			const participants = (0, WABinary_1.getBinaryNodeChildren)(inner, 'participant')
-				.map(p => {
-					const jid = p.attrs.jid
-					if (typeof jid === 'string') return jid
-					if (jid?.$1) {
-						return (0, WABinary_1.jidEncode)(jid.$1.user, jid.$1.server || 's.whatsapp.net')
-					}
-					return undefined
-				})
-				.filter(Boolean)
-
-			ev.emit('group-participants.update', {
-				id: groupId,
-				participants,
-				action: tag
-			})
-		} else if (tag === 'subject') {
-			ev.emit('groups.update', [{ id: groupId, subject: inner.attrs?.subject }])
-		}
-
-		await sock.sendMessageAck(node)
-	})
-
-	return {
-		...sock,
-		aiGroupMetadata,
-		aiGroupCreate: async (subject, participants = [], options = {}) => {
-			if (!Array.isArray(participants)) participants = []
-			const key = (0, Utils_1.generateMessageIDV2)()
-			const {
-				ephemeralExpiration = 86400,
-				memberAddMode = 'all_member_add',
-				memberShareGroupHistoryMode = 'all_member_share',
-				memberLinkMode = 'all_member_link'
-			} = options
-			const result = await aiGroupQuery('@g.us', 'set', [
-				{
-					tag: 'create',
-					attrs: {
-						subject,
-						key
-					},
-					content: participants.map(jid => ({
-						tag: 'participant',
-						attrs: { jid }
-					}))
-				}
-			])
-			return (0, exports.extractAIGroupMetadata)(result)
-		},
-		aiGroupAddBot: async (jid, botUser = '867051314767696') => {
-			const result = await aiGroupQuery(jid, 'set', [
-				{
-					tag: 'add',
-					attrs: {},
-					content: [
-						{
-							tag: 'participant',
-							attrs: { jid: `${botUser}@bot` }
-						}
-					]
-				}
-			])
-			const node = (0, WABinary_1.getBinaryNodeChild)(result, 'add')
-			const participantsAffected = (0, WABinary_1.getBinaryNodeChildren)(node, 'participant')
-			return participantsAffected.map(p => ({
-				status: p.attrs.error || '200',
-				jid: p.attrs.jid
-			}))
-		},
-		aiGroupLeave: async id => {
-			await aiGroupQuery('@g.us', 'set', [
-				{
-					tag: 'leave',
-					attrs: {},
-					content: [{ tag: 'group', attrs: { id } }]
-				}
-			])
-		},
-		aiGroupParticipantsUpdate: async (jid, participants, action) => {
-			const result = await aiGroupQuery(jid, 'set', [
-				{
-					tag: action,
-					attrs: {},
-					content: participants.map(jid => ({
-						tag: 'participant',
-						attrs: { jid }
-					}))
-				}
-			])
-			const node = (0, WABinary_1.getBinaryNodeChild)(result, action)
-			const participantsAffected = (0, WABinary_1.getBinaryNodeChildren)(node, 'participant')
-			return participantsAffected.map(p => ({
-				status: p.attrs.error || '200',
-				jid: p.attrs.jid,
-				content: p
-			}))
-		},
-		aiGroupUpdateSubject: async (jid, subject) => {
-			await aiGroupQuery(jid, 'set', [
-				{
-					tag: 'subject',
-					attrs: {},
-					content: Buffer.from(subject, 'utf-8')
-				}
-			])
-		},
-		aiGroupInviteCode: async jid => {
-			const result = await aiGroupQuery(jid, 'get', [{ tag: 'invite', attrs: {} }])
-			const inviteNode = (0, WABinary_1.getBinaryNodeChild)(result, 'invite')
-			return inviteNode?.attrs.code
-		},
-		aiGroupRevokeInvite: async jid => {
-			const result = await aiGroupQuery(jid, 'set', [{ tag: 'invite', attrs: {} }])
-			const inviteNode = (0, WABinary_1.getBinaryNodeChild)(result, 'invite')
-			return inviteNode?.attrs.code
-		},
-		aiGroupAcceptInvite: async code => {
-			const results = await aiGroupQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }])
-			const result = (0, WABinary_1.getBinaryNodeChild)(results, 'group')
-			return result?.attrs.jid
-		},
-		aiGroupSettingUpdate: async (jid, setting) => {
-			await aiGroupQuery(jid, 'set', [{ tag: setting, attrs: {} }])
-		},
-		aiGroupToggleEphemeral: async (jid, ephemeralExpiration) => {
-			const content = ephemeralExpiration
-				? { tag: 'ephemeral', attrs: { expiration: ephemeralExpiration.toString() } }
-				: { tag: 'not_ephemeral', attrs: {} }
-			await aiGroupQuery(jid, 'set', [content])
-		}
-	}
-}
-exports.makeAIGroupsSocket = makeAIGroupsSocket
-
-const extractAIGroupMetadata = result => {
-	
-	const createNode = (0, WABinary_1.getBinaryNodeChild)(result, 'create')
-	const group =
-		(0, WABinary_1.getBinaryNodeChild)(createNode || result, 'group') ||
-		(0, WABinary_1.getBinaryNodeChild)(result, 'group')
-	const descChild = (0, WABinary_1.getBinaryNodeChild)(group, 'description')
-	let desc, descId, descOwner, descOwnerPn, descTime
-	if (descChild) {
-		desc = (0, WABinary_1.getBinaryNodeChildString)(descChild, 'body')
-		descOwner = descChild.attrs.participant ? (0, WABinary_1.jidNormalizedUser)(descChild.attrs.participant) : undefined
-		descOwnerPn = descChild.attrs.participant_pn
-			? (0, WABinary_1.jidNormalizedUser)(descChild.attrs.participant_pn)
-			: undefined
-		descTime = +descChild.attrs.t
-		descId = descChild.attrs.id
-	}
-	const groupId = group.attrs.id.includes('@') ? group.attrs.id : (0, WABinary_1.jidEncode)(group.attrs.id, 'g.us')
-	const eph = (0, WABinary_1.getBinaryNodeChild)(group, 'ephemeral')?.attrs.expiration
-	const metadata = {
-		id: groupId,
-		subject: group.attrs.subject,
-		subjectTime: +group.attrs.s_t,
-		creation: +group.attrs.creation,
-		owner: group.attrs.creator ? (0, WABinary_1.jidNormalizedUser)(group.attrs.creator) : undefined,
-		ownerPn: group.attrs.creator_pn ? (0, WABinary_1.jidNormalizedUser)(group.attrs.creator_pn) : undefined,
-		owner_country_code: group.attrs.creator_country_code,
-		size: group.attrs.size ? +group.attrs.size : (0, WABinary_1.getBinaryNodeChildren)(group, 'participant').length,
-		desc,
-		descId,
-		descOwner,
-		descOwnerPn,
-		descTime,
-		isAIGroup: true,
-		addressingMode:
-			group.attrs.addressing_mode === 'lid' ? Types_1.WAMessageAddressingMode.LID : Types_1.WAMessageAddressingMode.PN,
-		participants: (0, WABinary_1.getBinaryNodeChildren)(group, 'participant').map(({ attrs }) => ({
-			id: attrs.jid,
-			phoneNumber:
-				(0, WABinary_1.isLidUser)(attrs.jid) && (0, WABinary_1.isPnUser)(attrs.phone_number)
-					? attrs.phone_number
-					: undefined,
-			lid: (0, WABinary_1.isPnUser)(attrs.jid) && (0, WABinary_1.isLidUser)(attrs.lid) ? attrs.lid : undefined,
-			admin: attrs.type || null
-		})),
-		ephemeralDuration: eph ? +eph : undefined
-	}
-	return metadata
-}
-exports.extractAIGroupMetadata = extractAIGroupMetadata