@usebridger/transport-baileys 0.0.0-stage → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1184 @@
+import { Browsers, BufferJSON, DisconnectReason, WAMessageStubType, decryptPollVote, downloadMediaMessage, fetchLatestBaileysVersion, initAuthCreds, isJidGroup, isJidStatusBroadcast, isLidUser, isPnUser, jidDecode, jidNormalizedUser, makeCacheableSignalKeyStore, makeWASocket, proto, toNumber } from "baileys";
+import { Readable } from "node:stream";
+import { TypedEmitter, createMessage } from "@usebridger/core/adapter";
+import { UnsupportedError } from "@usebridger/core";
+import { createHash } from "node:crypto";
+//#region src/auth-state.ts
+/**
+* Monta o auth state de uma tentativa de conexão. As chaves passam por um cache em memória
+* (o do Baileys, 5 min por chave): o Signal lê a sessão do remetente a cada mensagem, e sem ele
+* cada leitura iria ao storage e repetiria a conversão do `BufferJSON`. O cache vive só nesta
+* tentativa: depois de um `clear()` do bot, a próxima começa vazia e não ressuscita chave
+* apagada. Ele não vê gravações de outro processo, o que não acontece porque a mesma sessão
+* não roda em dois (ADR 0036).
+*/
+async function loadAuthState(store, logger) {
+	const stored = await store.getCreds();
+	const creds = stored === void 0 ? initAuthCreds() : fromJson(stored);
+	const cached = makeCacheableSignalKeyStore({
+		get: async (type, ids) => {
+			const raw = await store.getKeys(type, ids);
+			const keys = {};
+			for (const [id, value] of Object.entries(raw)) keys[id] = type === "app-state-sync-key" ? toSyncKeyInstance(fromJson(value)) : fromJson(value);
+			return keys;
+		},
+		set: (data) => store.setKeys(toKeyData(data))
+	}, logger);
+	return {
+		state: {
+			creds,
+			keys: {
+				get: async (type, ids) => {
+					const found = await cached.get(type, ids);
+					for (const id of Object.keys(found)) if (found[id] === null || found[id] === void 0) delete found[id];
+					return found;
+				},
+				set: (data) => cached.set(withSyncKeyInstances(data))
+			}
+		},
+		saveCreds: () => store.setCreds(toJson(creds))
+	};
+}
+function toSyncKeyInstance(value) {
+	return value instanceof proto.Message.AppStateSyncKeyData ? value : proto.Message.AppStateSyncKeyData.fromObject(value);
+}
+function withSyncKeyInstances(data) {
+	const syncKeys = data["app-state-sync-key"];
+	if (syncKeys === void 0) return data;
+	const converted = {};
+	for (const [id, value] of Object.entries(syncKeys)) converted[id] = value ? toSyncKeyInstance(value) : value;
+	return {
+		...data,
+		"app-state-sync-key": converted
+	};
+}
+function toKeyData(data) {
+	const out = {};
+	for (const [type, entries] of Object.entries(data)) {
+		const converted = {};
+		for (const [id, value] of Object.entries(entries ?? {})) converted[id] = value === null || value === void 0 ? null : toJson(value);
+		out[type] = converted;
+	}
+	return out;
+}
+function toJson(value) {
+	return JSON.parse(JSON.stringify(value, BufferJSON.replacer));
+}
+function fromJson(value) {
+	return JSON.parse(JSON.stringify(value), BufferJSON.reviver);
+}
+//#endregion
+//#region src/disconnect-reason.ts
+function toDisconnectReason(error, { pairing }) {
+	switch (statusCode(error)) {
+		case DisconnectReason.loggedOut: return "logged-out";
+		case DisconnectReason.forbidden:
+		case DisconnectReason.multideviceMismatch: return "auth-failed";
+		case DisconnectReason.connectionReplaced: return "replaced";
+		case DisconnectReason.timedOut: return pairing ? "qr-timeout" : "connection-lost";
+		case DisconnectReason.connectionClosed:
+		case DisconnectReason.restartRequired: return "connection-lost";
+		case DisconnectReason.badSession:
+		case DisconnectReason.unavailableService:
+		case 405: return "server-error";
+		default: return "unknown";
+	}
+}
+/** O Baileys encerra com um `Boom`, que traz o código em `output.statusCode`. */
+function statusCode(error) {
+	if (typeof error !== "object" || error === null || !("output" in error)) return void 0;
+	const { output } = error;
+	if (typeof output !== "object" || output === null || !("statusCode" in output)) return void 0;
+	return typeof output.statusCode === "number" ? output.statusCode : void 0;
+}
+//#endregion
+//#region src/normalize.ts
+/** Envelopes que só embrulham o conteúdo de verdade. */
+const ENVELOPES = [
+	"ephemeralMessage",
+	"viewOnceMessage",
+	"viewOnceMessageV2",
+	"viewOnceMessageV2Extension",
+	"documentWithCaptionMessage",
+	"pollCreationMessageV4"
+];
+const VIEW_ONCE = /* @__PURE__ */ new Set([
+	"viewOnceMessage",
+	"viewOnceMessageV2",
+	"viewOnceMessageV2Extension"
+]);
+/**
+* Campos que não são o conteúdo da mensagem. Edição, apagamento e reação chegam por eventos
+* próprios do Baileys (`events.ts`); o resto é metadado do protocolo.
+*/
+const CONTROL = /* @__PURE__ */ new Set([
+	"protocolMessage",
+	"reactionMessage",
+	"encReactionMessage",
+	"pollUpdateMessage",
+	"keepInChatMessage",
+	"pinInChatMessage",
+	"senderKeyDistributionMessage",
+	"fastRatchetKeySenderKeyDistributionMessage",
+	"messageContextInfo"
+]);
+/**
+* Tira os envelopes, em qualquer ordem e aninhados (ephemeral com viewOnce dentro, por exemplo).
+* O limite só protege de um proto malformado.
+*/
+function unwrap(content) {
+	let current = content;
+	let viewOnce = false;
+	for (let depth = 0; depth < 10; depth++) {
+		const envelope = ENVELOPES.find((name) => current[name]?.message);
+		if (envelope === void 0) break;
+		if (VIEW_ONCE.has(envelope)) viewOnce = true;
+		current = current[envelope]?.message ?? current;
+	}
+	return {
+		content: current,
+		viewOnce
+	};
+}
+/** Campo que define o tipo: o primeiro preenchido que não é de controle. */
+function contentKey(content) {
+	return Object.keys(content).find((key) => content[key] != null && !CONTROL.has(key));
+}
+/**
+* Converte uma mensagem do Baileys. `null` quando não há o que entregar: sem conteúdo (aviso de
+* grupo, mensagem que não deu para decifrar) ou só controle (edição, reação, apagamento).
+*/
+function toMessage(raw, env) {
+	return build(raw, env, toNumber(raw.messageTimestamp) * 1e3, false);
+}
+/**
+* Nova versão de uma mensagem editada, com `isEdited: true`. `raw` é a chave da original com o
+* conteúdo novo; o Baileys não manda o `pushName` na edição, então o nome vem de quem chama.
+*/
+function toEditedMessage(raw, env) {
+	return build(raw, env, toNumber(raw.messageTimestamp) * 1e3, true);
+}
+async function build(raw, env, timestamp, isEdited) {
+	const chatId = raw.key.remoteJid;
+	const id = raw.key.id;
+	if (!raw.message || !chatId || !id) return null;
+	const { content, viewOnce } = unwrap(raw.message);
+	const key = contentKey(content);
+	if (key === void 0) return null;
+	const isGroup = isJidGroup(chatId) === true;
+	const fromMe = raw.key.fromMe === true;
+	const node = content[key];
+	const context = contextOf(node);
+	const base = {
+		id,
+		chat: {
+			id: chatId,
+			isGroup
+		},
+		sender: await authorOf(raw.key, chatId, env, raw.pushName ?? null),
+		timestamp,
+		fromMe,
+		quoted: context ? await quoted(context, chatId, env, timestamp) : null,
+		mentions: await Promise.all((context?.mentionedJid ?? []).map((jid) => resolveContact(env, jid, void 0, null))),
+		isForwarded: context?.isForwarded === true,
+		isViewOnce: viewOnce || raw.key.isViewOnce === true || flag(node, "viewOnce"),
+		isEdited
+	};
+	const unwrapped = {
+		...raw,
+		message: content
+	};
+	const media = (m) => ({
+		mimetype: m.mimetype ?? "application/octet-stream",
+		size: m.fileLength == null ? null : toNumber(m.fileLength) || null,
+		download: () => env.download(unwrapped),
+		stream: () => env.stream(unwrapped)
+	});
+	const message = createMessage(init(key, content, base, media));
+	natives.set(message, raw);
+	return message;
+}
+/**
+* Mensagem do Baileys de onde cada `Message` saiu. Citar no envio precisa do proto original
+* (`quoted` do `sendMessage`); o `WeakMap` some com a `Message`, sem cache para limpar.
+*/
+const natives = /* @__PURE__ */ new WeakMap();
+/** O `WAMessage` que originou a mensagem, se ela foi normalizada por este transport. */
+function nativeOf(message) {
+	return natives.get(message);
+}
+function init(key, c, base, media) {
+	switch (key) {
+		case "conversation": return {
+			...base,
+			type: "text",
+			text: c.conversation ?? ""
+		};
+		case "extendedTextMessage": return {
+			...base,
+			type: "text",
+			text: c.extendedTextMessage?.text ?? ""
+		};
+		case "imageMessage": {
+			const m = c.imageMessage ?? {};
+			return {
+				...base,
+				type: "image",
+				text: m.caption ?? null,
+				media: media(m)
+			};
+		}
+		case "videoMessage":
+		case "ptvMessage": {
+			const m = c[key] ?? {};
+			return {
+				...base,
+				type: "video",
+				text: m.caption ?? null,
+				media: media(m)
+			};
+		}
+		case "audioMessage": {
+			const m = c.audioMessage ?? {};
+			return {
+				...base,
+				type: m.ptt ? "voice" : "audio",
+				text: null,
+				media: media(m)
+			};
+		}
+		case "stickerMessage": return {
+			...base,
+			type: "sticker",
+			text: null,
+			media: media(c.stickerMessage ?? {})
+		};
+		case "documentMessage": {
+			const m = c.documentMessage ?? {};
+			return {
+				...base,
+				type: "document",
+				text: m.caption ?? null,
+				fileName: m.fileName ?? null,
+				media: media(m)
+			};
+		}
+		case "locationMessage": {
+			const m = c.locationMessage ?? {};
+			return {
+				...base,
+				type: "location",
+				text: m.comment ?? null,
+				location: {
+					latitude: m.degreesLatitude ?? 0,
+					longitude: m.degreesLongitude ?? 0,
+					name: m.name ?? m.address ?? null,
+					...m.address ? { address: m.address } : {}
+				}
+			};
+		}
+		case "liveLocationMessage": {
+			const m = c.liveLocationMessage ?? {};
+			return {
+				...base,
+				type: "location",
+				text: m.caption ?? null,
+				location: {
+					latitude: m.degreesLatitude ?? 0,
+					longitude: m.degreesLongitude ?? 0,
+					name: null
+				}
+			};
+		}
+		case "contactMessage":
+		case "contactsArrayMessage": {
+			const list = key === "contactMessage" ? [c.contactMessage ?? {}] : c.contactsArrayMessage?.contacts ?? [];
+			return {
+				...base,
+				type: "contact",
+				text: null,
+				contacts: list.map((m) => ({
+					name: m.displayName ?? "",
+					vcard: m.vcard ?? ""
+				}))
+			};
+		}
+		case "pollCreationMessage":
+		case "pollCreationMessageV2":
+		case "pollCreationMessageV3":
+		case "pollCreationMessageV5": {
+			const m = c[key] ?? {};
+			return {
+				...base,
+				type: "poll",
+				text: null,
+				poll: {
+					name: m.name ?? "",
+					options: (m.options ?? []).map((o) => o.optionName ?? "")
+				}
+			};
+		}
+		default: return {
+			...base,
+			type: "unknown",
+			text: null
+		};
+	}
+}
+function contextOf(node) {
+	if (typeof node !== "object" || node === null || !("contextInfo" in node)) return null;
+	return node.contextInfo ?? null;
+}
+function flag(node, name) {
+	return typeof node === "object" && node !== null && name in node && Reflect.get(node, name) === true;
+}
+/**
+* A citada vem só com id, autor e conteúdo: sem horário (vale o da mensagem que cita) e sem nome
+* do autor.
+*/
+function quoted(context, chatId, env, timestamp) {
+	if (!context.quotedMessage || !context.stanzaId) return Promise.resolve(null);
+	const author = context.participant ? jidNormalizedUser(context.participant) : void 0;
+	return build({
+		key: {
+			remoteJid: context.remoteJid ?? chatId,
+			id: context.stanzaId,
+			fromMe: author !== void 0 && env.selfIds.includes(author),
+			participant: author
+		},
+		message: context.quotedMessage
+	}, env, timestamp, false);
+}
+/**
+* Autor de uma mensagem pela chave. Grupo, status e citada o trazem em `participant`. Sem ele
+* (conversa privada), o autor é o próprio chat, ou a sessão quando foi ela que mandou.
+*/
+function authorOf(key, chatId, env, name) {
+	const alt = key.participant ? key.participantAlt : key.fromMe ? void 0 : key.remoteJidAlt;
+	return resolveContact(env, authorJid(key, chatId, env.selfIds), alt, name);
+}
+/** O JID do autor pela chave, sem resolver o telefone (ver `authorOf`). */
+function authorJid(key, chatId, selfIds) {
+	if (key.participant) return key.participant;
+	return key.fromMe ? selfIds[0] ?? chatId : chatId;
+}
+/**
+* Contato com o telefone resolvido: do próprio JID de telefone, do JID alternativo que o
+* Baileys manda junto com um LID ou do mapeamento LID ↔ telefone da sessão.
+*/
+async function resolveContact(env, jid, alt, name) {
+	const id = jidNormalizedUser(jid) || jid;
+	return {
+		id,
+		name,
+		phone: await phoneOf(env, id, alt)
+	};
+}
+async function phoneOf(env, id, alt) {
+	if (isPnUser(id)) return jidDecode(id)?.user ?? null;
+	if (alt && isPnUser(alt)) return jidDecode(alt)?.user ?? null;
+	if (!isLidUser(id)) return null;
+	const pn = await env.pnForLid(id);
+	return pn ? jidDecode(pn)?.user ?? null : null;
+}
+//#endregion
+//#region src/events.ts
+/**
+* Nome e telefone já vistos de cada contato. Decide quando sai o `contact.updated` e dá nome a
+* quem aparece sem `pushName` (reação, edição, apagamento, grupo). Vive enquanto o transport
+* vive: depois de reiniciar o processo, cada contato conta de novo como visto pela primeira vez.
+*/
+var ContactBook = class {
+	#known = /* @__PURE__ */ new Map();
+	/**
+	* Registra um remetente. Devolve o `contact.updated` quando há o que contar: na primeira vez
+	* que o contato aparece (ADR 0049) ou quando o nome ou o telefone mudou. Campo desconhecido
+	* (`null`) não apaga o que já se sabia.
+	*/
+	observe(contact) {
+		const known = this.#known.get(contact.id);
+		const name = contact.name ?? known?.name ?? null;
+		const phone = contact.phone ?? known?.phone ?? null;
+		this.#known.set(contact.id, {
+			name,
+			phone
+		});
+		const update = { id: contact.id };
+		if (name !== null && name !== known?.name) update.name = name;
+		if (phone !== null && phone !== known?.phone) update.phone = phone;
+		return update.name === void 0 && update.phone === void 0 ? null : update;
+	}
+	nameOf(id) {
+		return this.#known.get(id)?.name ?? null;
+	}
+	/** O contato com o nome já visto, quando o evento não trouxe nenhum. */
+	named(contact) {
+		return contact.name === null ? {
+			...contact,
+			name: this.nameOf(contact.id)
+		} : contact;
+	}
+};
+/** O `Chat` de um JID; os eventos de grupo também o usam (ADR 0059). */
+function chatOf(id) {
+	return {
+		id,
+		isGroup: isJidGroup(id) === true
+	};
+}
+/**
+* `reaction` a partir do `messages.reaction`: `key` é a mensagem reagida e `reaction.key` a
+* mensagem de reação, que diz quem reagiu. Texto vazio é reação removida.
+*/
+async function toReaction({ key, reaction }, env, contacts) {
+	const from = reaction.key;
+	const chatId = from?.remoteJid ?? key.remoteJid;
+	if (!from || !chatId || !key.id || isJidStatusBroadcast(chatId)) return null;
+	return {
+		chat: chatOf(chatId),
+		messageId: key.id,
+		sender: contacts.named(await authorOf(from, chatId, env, null)),
+		emoji: reaction.text || null,
+		fromMe: from.fromMe === true
+	};
+}
+/**
+* `message.edited` a partir do `messages.update` de edição. A chave é a da original com o autor
+* da edição, e o conteúdo novo vem em `editedMessage`.
+*/
+function toEdited({ key, update }, env, contacts) {
+	const content = update.message?.editedMessage?.message;
+	const chatId = key.remoteJid;
+	if (!content || !chatId || isJidStatusBroadcast(chatId)) return Promise.resolve(null);
+	return toEditedMessage({
+		key,
+		message: content,
+		messageTimestamp: update.messageTimestamp ?? Math.floor(Date.now() / 1e3),
+		pushName: contacts.nameOf(jidNormalizedUser(authorJid(key, chatId, env.selfIds)))
+	}, env);
+}
+/**
+* `message.deleted` a partir do `messages.update` de apagamento (`REVOKE`). `key` é a apagada;
+* `update.key` é a mensagem que apagou, que diz quem apagou (o autor ou um admin do grupo).
+*/
+async function toDeleted({ key, update }, env, contacts) {
+	const chatId = key.remoteJid;
+	if (!chatId || !key.id || isJidStatusBroadcast(chatId)) return null;
+	const by = update.key;
+	return {
+		chat: chatOf(chatId),
+		messageId: key.id,
+		deletedBy: by ? contacts.named(await authorOf(by, chatId, env, null)) : null,
+		fromMe: (by ?? key).fromMe === true
+	};
+}
+/**
+* Converte a alteração de participantes. Entrada e saída da própria sessão viram
+* `group.joined`/`group.left` e saem da lista; promovida ou rebaixada, ela segue em
+* `group.participants`. Troca de número (`modify`) não tem evento no core.
+*/
+async function toParticipantEvents({ id, author, authorPn, participants, action }, env, contacts) {
+	if (action === "modify") return {
+		self: null,
+		others: null
+	};
+	const isSelf = (p) => [
+		p.id,
+		p.phoneNumber,
+		p.lid
+	].some((jid) => jid && env.selfIds.includes(jidNormalizedUser(jid)));
+	const self = !participants.some(isSelf) ? null : action === "add" ? "group.joined" : action === "remove" ? "group.left" : null;
+	const rest = self === null ? participants : participants.filter((p) => !isSelf(p));
+	if (rest.length === 0) return {
+		self,
+		others: null
+	};
+	const contact = async (jid, alt, name) => contacts.named(await resolveContact(env, jid, alt, name));
+	return {
+		self,
+		others: {
+			chat: chatOf(id),
+			action,
+			participants: await Promise.all(rest.map((p) => contact(p.id, p.phoneNumber, p.notify ?? p.name ?? null))),
+			actor: author ? await contact(author, authorPn, null) : null
+		}
+	};
+}
+/**
+* `group.updated` com só os campos que mudaram. O Baileys também emite `groups.update` com os
+* metadados completos de cada grupo ao sincronizar (`groupFetchAllParticipating`); esse traz
+* `participants` e não é uma alteração, então fica de fora.
+*/
+function toGroupUpdated(update) {
+	if (!update.id || update.participants) return null;
+	const changed = { chat: chatOf(update.id) };
+	if (update.subject !== void 0) changed.title = update.subject;
+	if ("desc" in update) changed.description = update.desc || null;
+	if (update.announce !== void 0) changed.announce = update.announce;
+	if (update.restrict !== void 0) changed.restrict = update.restrict;
+	return Object.keys(changed).length > 1 ? changed : null;
+}
+//#endregion
+//#region src/format.ts
+/**
+* Renderiza a árvore. O WhatsApp não tem escape: um `*` literal do texto pode casar com outro e
+* virar negrito, como já acontece no app. Por isso o texto literal vai como está.
+*/
+function renderWhatsApp(text) {
+	const mentions = /* @__PURE__ */ new Set();
+	const render = (nodes) => {
+		let out = "";
+		for (const node of nodes) {
+			if (typeof node === "string") {
+				out += node;
+				continue;
+			}
+			switch (node.type) {
+				case "bold":
+				case "italic":
+					out += wrap(node.type === "bold" ? "*" : "_", render(node.children));
+					break;
+				case "code":
+					out += wrap("`", node.text);
+					break;
+				case "link": {
+					const label = render(node.children);
+					out += label === node.url ? node.url : `${label} (${node.url})`;
+					break;
+				}
+				case "mention":
+					mentions.add(node.contact.id);
+					out += `@${jidDecode(node.contact.id)?.user ?? node.contact.id}`;
+			}
+		}
+		return out;
+	};
+	return {
+		text: render(text.nodes),
+		mentions: [...mentions]
+	};
+}
+/**
+* O marcador só vale colado no texto (`* a *` sai literal): o espaço das pontas fica do lado de
+* fora.
+*/
+function wrap(marker, inner) {
+	const [, lead = "", core = "", trail = ""] = /^(\s*)([\s\S]*?)(\s*)$/.exec(inner) ?? [];
+	if (core === "") return inner;
+	return `${lead}${marker}${core}${marker}${trail}`;
+}
+//#endregion
+//#region src/logger.ts
+function toBaileysLogger(log) {
+	const write = (method) => (obj, msg) => {
+		if (typeof obj === "string") log[method](obj);
+		else log[method](msg ?? "", toFields(obj));
+	};
+	return {
+		get level() {
+			return log.level;
+		},
+		child: (bindings) => toBaileysLogger(log.child(bindings)),
+		trace: write("trace"),
+		debug: write("debug"),
+		info: write("info"),
+		warn: write("warn"),
+		error: write("error")
+	};
+}
+function toFields(obj) {
+	if (obj instanceof Error) return { err: obj };
+	if (typeof obj === "object" && obj !== null) return obj;
+	return obj === void 0 ? void 0 : { value: obj };
+}
+//#endregion
+//#region src/outgoing.ts
+/**
+* Conteúdo do `sendMessage`, com as menções que o Baileys põe no `contextInfo` de qualquer tipo.
+* A árvore neutra (`formatted`, `formattedCaption`) vira a marcação do WhatsApp, e as menções
+* dela se juntam às de `options.mentions` (ADR 0061).
+*/
+function toContent(content, options) {
+	const ids = new Set(options?.mentions);
+	let text;
+	let caption;
+	if (content.type === "text") {
+		text = content.text;
+		if (content.formatted) {
+			const rendered = renderWhatsApp(content.formatted);
+			text = rendered.text;
+			for (const id of rendered.mentions) ids.add(id);
+		}
+	} else if ("caption" in content || "formattedCaption" in content) {
+		caption = content.caption;
+		if (content.formattedCaption) {
+			const rendered = renderWhatsApp(content.formattedCaption);
+			caption = rendered.text;
+			for (const id of rendered.mentions) ids.add(id);
+		}
+	}
+	const mentions = ids.size > 0 ? { mentions: [...ids] } : {};
+	switch (content.type) {
+		case "text": return {
+			text: text ?? content.text,
+			...mentions
+		};
+		case "image": return {
+			image: content.media,
+			caption,
+			mimetype: content.mimetype,
+			...mentions
+		};
+		case "video": return {
+			video: content.media,
+			caption,
+			mimetype: content.mimetype,
+			...mentions
+		};
+		case "audio":
+		case "voice": return {
+			audio: content.media,
+			ptt: content.type === "voice",
+			mimetype: content.mimetype,
+			...mentions
+		};
+		case "sticker": return {
+			sticker: content.media,
+			...mentions
+		};
+		case "document": return {
+			document: content.media,
+			fileName: content.fileName,
+			mimetype: content.mimetype,
+			caption,
+			...mentions
+		};
+		case "album": throw new UnsupportedError("send.album", "baileys");
+		case "poll": return {
+			poll: {
+				name: content.name,
+				values: [...content.options],
+				selectableCount: content.multiple === true ? 0 : 1
+			},
+			...mentions
+		};
+	}
+}
+function toWAKey(key) {
+	return {
+		remoteJid: key.chatId,
+		id: key.id,
+		fromMe: key.fromMe,
+		participant: key.senderId ?? void 0
+	};
+}
+/**
+* A mensagem a citar como o Baileys a quer. Recebida por este transport, vai o proto original
+* (a citada mostra mídia e legenda); montada fora dele (testes, storage), vai só o texto.
+*/
+function toQuoted(message) {
+	return nativeOf(message) ?? {
+		key: toWAKey(message.key),
+		message: { conversation: message.text ?? "" }
+	};
+}
+/** Metadados do grupo com o telefone de cada participante resolvido, inclusive com LID. */
+async function toGroupMetadata(native, env) {
+	const participants = await Promise.all(native.participants.map(async (p) => {
+		return {
+			...await resolveContact(env, p.id, p.phoneNumber, p.name ?? p.notify ?? null),
+			isAdmin: p.admin === "admin" || p.admin === "superadmin",
+			isSuperAdmin: p.admin === "superadmin"
+		};
+	}));
+	return {
+		id: native.id,
+		title: native.subject,
+		description: native.desc ?? null,
+		ownerId: native.owner ? jidNormalizedUser(native.owner) || native.owner : null,
+		participants
+	};
+}
+//#endregion
+//#region src/polls.ts
+/** Enquetes guardadas por padrão; a mais antiga sai primeiro. */
+const DEFAULT_MAX_POLLS = 1e3;
+/**
+* Enquetes que a sessão enviou ou recebeu enquanto conectada, pelo ID da mensagem. O ID basta: o
+* mesmo chat privado aparece ora como LID, ora como telefone, e o ID do WhatsApp é aleatório. Vive
+* até o `disconnect()`: voto de enquete anterior não se decifra e é descartado.
+*/
+var PollBook = class {
+	#polls = /* @__PURE__ */ new Map();
+	#max;
+	constructor(max = DEFAULT_MAX_POLLS) {
+		this.#max = max;
+	}
+	/** Guarda a enquete, se a mensagem for uma e trouxer o segredo; o resto é ignorado. */
+	remember(raw) {
+		const id = raw.key.id;
+		if (!id || !raw.message) return;
+		const { content } = unwrap(raw.message);
+		const poll = content.pollCreationMessage ?? content.pollCreationMessageV2 ?? content.pollCreationMessageV3 ?? content.pollCreationMessageV5;
+		const secret = raw.message.messageContextInfo?.messageSecret ?? content.messageContextInfo?.messageSecret;
+		if (!poll || !secret) return;
+		this.#polls.delete(id);
+		this.#polls.set(id, {
+			key: raw.key,
+			secret,
+			hashes: (poll.options ?? []).map((o) => sha256Hex(o.optionName ?? ""))
+		});
+		if (this.#polls.size > this.#max) {
+			const oldest = this.#polls.keys().next().value;
+			if (oldest !== void 0) this.#polls.delete(oldest);
+		}
+	}
+	get(id) {
+		return this.#polls.get(id);
+	}
+	clear() {
+		this.#polls.clear();
+	}
+};
+/** O `pollUpdateMessage` da mensagem, se ela for um voto. */
+function pollUpdateOf(raw) {
+	return raw.message ? unwrap(raw.message).content.pollUpdateMessage ?? null : null;
+}
+/**
+* `poll.vote` a partir do `pollUpdateMessage`. Devolve `null` quando a enquete não está no
+* `PollBook` (enviada antes da conexão atual, por exemplo) e lança quando ela está, mas o voto não
+* decifra.
+*/
+async function toPollVote(raw, polls, env, contacts) {
+	const update = pollUpdateOf(raw);
+	const pollKey = update?.pollCreationMessageKey;
+	const chatId = raw.key.remoteJid;
+	if (!update?.vote || !pollKey?.id || !chatId) return null;
+	const poll = polls.get(pollKey.id);
+	if (poll === void 0) return null;
+	const vote = decrypt(update.vote, poll, pollKey, raw.key, env.selfIds);
+	if (vote === null) throw new Error("baileys: o voto da enquete não decifrou");
+	const options = /* @__PURE__ */ new Set();
+	for (const hash of vote.selectedOptions ?? []) {
+		const index = poll.hashes.indexOf(Buffer.from(hash).toString("hex"));
+		if (index >= 0) options.add(index);
+	}
+	return {
+		chat: chatOf(chatId),
+		messageId: pollKey.id,
+		sender: contacts.named(await authorOf(raw.key, chatId, env, raw.pushName ?? null)),
+		options: [...options].sort((a, b) => a - b),
+		fromMe: raw.key.fromMe === true
+	};
+}
+/**
+* Decifra o voto. A chave sai do JID de quem criou e de quem votou, como o aparelho do votante os
+* viu, e com o LID ele pode ter usado o telefone ou o LID: tenta cada par conhecido.
+*/
+function decrypt(vote, poll, pollKey, voteKey, selfIds) {
+	const creators = unique([...jidsOf(poll.key, selfIds), ...jidsOf(pollKey, selfIds)]);
+	const voters = unique(jidsOf(voteKey, selfIds));
+	const pollMsgId = pollKey.id ?? "";
+	for (const pollCreatorJid of creators) for (const voterJid of voters) {
+		const decrypted = tryDecrypt(vote, {
+			pollCreatorJid,
+			pollMsgId,
+			pollEncKey: poll.secret,
+			voterJid
+		});
+		if (decrypted !== null) return decrypted;
+	}
+	return null;
+}
+function tryDecrypt(vote, context) {
+	try {
+		return decryptPollVote(vote, context);
+	} catch {
+		return null;
+	}
+}
+/** JIDs possíveis do autor de uma chave: o da sessão, o do participante ou o do chat privado. */
+function jidsOf(key, selfIds) {
+	if (key.fromMe) return [...selfIds];
+	return (key.participant ? [key.participant, key.participantAlt] : [key.remoteJid, key.remoteJidAlt]).flatMap((jid) => jid ? [jidNormalizedUser(jid) || jid] : []);
+}
+function unique(values) {
+	return [...new Set(values)];
+}
+function sha256Hex(text) {
+	return createHash("sha256").update(text).digest("hex");
+}
+//#endregion
+//#region src/transport.ts
+var BaileysTransport = class {
+	name = "baileys";
+	/**
+	* Todas as capabilities do core, menos `actions`: o WhatsApp pelo Baileys não tem botões
+	* confiáveis, e o kernel envia o menu em texto numerado (ADR 0062).
+	*/
+	capabilities = /* @__PURE__ */ new Set([
+		"groups",
+		"groups.add",
+		"groups.remove",
+		"groups.promote",
+		"mentions",
+		"reactions",
+		"typing",
+		"send.text",
+		"send.image",
+		"send.video",
+		"send.audio",
+		"send.voice",
+		"send.sticker",
+		"send.document",
+		"media.download",
+		"message.edit",
+		"message.delete",
+		"polls",
+		"quoted",
+		"pairing"
+	]);
+	#pairing;
+	#driver;
+	#deps;
+	#events;
+	#socket = null;
+	#self = null;
+	/** Sobe a cada `connect()`/`disconnect()`: invalida a tentativa que ainda estava começando. */
+	#attempt = 0;
+	/**
+	* Metadados por grupo (ADR 0046): o kernel os pede a cada comando `group-admin`. Invalidado
+	* pelos eventos de grupo do Baileys e a cada conexão, porque a queda pode ter perdido algum.
+	*/
+	#groups = /* @__PURE__ */ new Map();
+	/** Contatos já vistos, entre conexões: o `contact.updated` sai só no que é novo. */
+	#contacts = new ContactBook();
+	/** Enquetes vistas, para decifrar os votos (ADR 0071); o `disconnect()` as esquece. */
+	#polls = new PollBook();
+	constructor(options, deps) {
+		this.#pairing = options.pairing;
+		this.#driver = options.driver;
+		this.#deps = deps;
+		this.#events = new TypedEmitter((error, event) => this.#log.error("handler de evento do transport falhou", {
+			err: error,
+			event
+		}));
+	}
+	get self() {
+		return this.#self;
+	}
+	/** O socket do Baileys (`WASocket`) da tentativa atual, ou `null` sem conexão. */
+	get native() {
+		return this.#socket;
+	}
+	/**
+	* O `WAMessage` de onde a mensagem saiu (ADR 0066), o mesmo que o envio usa para citar. A citada
+	* devolve o proto montado do `contextInfo`, sem `pushName` nem horário. O Baileys não emite
+	* `interaction`: para ela, e para mensagem que não veio daqui, `undefined`.
+	*/
+	raw(source) {
+		return "key" in source ? nativeOf(source) : void 0;
+	}
+	get #log() {
+		return this.#deps.log;
+	}
+	on(event, handler) {
+		return this.#events.on(event, handler);
+	}
+	async connect() {
+		const attempt = ++this.#attempt;
+		this.#endSocket();
+		const version = await this.#driver.version();
+		const logger = toBaileysLogger(this.#log.child({ lib: "baileys" }));
+		const { state, saveCreds } = await loadAuthState(this.#deps.auth, logger);
+		if (attempt !== this.#attempt) return;
+		this.#groups.clear();
+		const socket = this.#driver.makeSocket({
+			auth: state,
+			logger,
+			version,
+			cachedGroupMetadata: (jid) => this.#cachedGroup(jid)
+		});
+		this.#socket = socket;
+		const current = () => this.#socket === socket;
+		let saving = Promise.resolve();
+		let pairing = false;
+		let codeRequested = false;
+		socket.ev.on("creds.update", () => {
+			if (!current()) return;
+			saving = saving.then(saveCreds).catch((error) => {
+				this.#log.error("falha ao gravar as credenciais da sessão", { err: error });
+			});
+		});
+		let inbound = Promise.resolve();
+		const enqueue = (work, failure, messageId) => {
+			inbound = inbound.then(work).catch((error) => {
+				this.#log.error(failure, {
+					err: error,
+					messageId
+				});
+			});
+		};
+		const env = this.#normalizeEnv(socket, state, logger);
+		const contacts = this.#contacts;
+		const polls = this.#polls;
+		socket.ev.on("messages.upsert", ({ messages, type }) => {
+			if (!current()) return;
+			if (type !== "notify") return;
+			for (const raw of messages) {
+				if (raw.key.remoteJid && isJidStatusBroadcast(raw.key.remoteJid)) continue;
+				enqueue(async () => {
+					polls.remember(raw);
+					if (pollUpdateOf(raw) !== null) {
+						const vote = await toPollVote(raw, polls, env, contacts);
+						if (vote === null) this.#log.debug("voto de enquete desconhecida; descartado", { messageId: raw.key.id });
+						else if (current()) this.#events.emit("poll.vote", vote);
+						return;
+					}
+					const message = await toMessage(raw, env);
+					if (message === null || !current()) return;
+					const contact = message.fromMe ? null : contacts.observe(message.sender);
+					if (contact !== null) this.#events.emit("contact.updated", contact);
+					this.#events.emit("message", message);
+				}, "falha ao normalizar mensagem do Baileys; descartada", raw.key.id);
+			}
+		});
+		socket.ev.on("messages.reaction", (reactions) => {
+			if (!current()) return;
+			for (const item of reactions) enqueue(async () => {
+				const reaction = await toReaction(item, env, contacts);
+				if (reaction !== null && current()) this.#events.emit("reaction", reaction);
+			}, "falha ao converter reação do Baileys; descartada", item.key.id);
+		});
+		socket.ev.on("messages.update", (updates) => {
+			if (!current()) return;
+			for (const item of updates) if (item.update.message?.editedMessage) enqueue(async () => {
+				const message = await toEdited(item, env, contacts);
+				if (message !== null && current()) this.#events.emit("message.edited", message);
+			}, "falha ao converter edição do Baileys; descartada", item.key.id);
+			else if (item.update.messageStubType === WAMessageStubType.REVOKE) enqueue(async () => {
+				const deleted = await toDeleted(item, env, contacts);
+				if (deleted !== null && current()) this.#events.emit("message.deleted", deleted);
+			}, "falha ao converter apagamento do Baileys; descartado", item.key.id);
+		});
+		socket.ev.on("groups.upsert", (groups) => {
+			if (!current()) return;
+			for (const { id } of groups) enqueue(async () => {
+				if (current()) this.#events.emit("group.joined", { chat: chatOf(id) });
+			}, "falha ao repassar grupo novo");
+		});
+		socket.ev.on("groups.update", (updates) => {
+			if (!current()) return;
+			for (const update of updates) {
+				if (update.id) this.#groups.delete(update.id);
+				const changed = toGroupUpdated(update);
+				if (changed === null) continue;
+				enqueue(async () => {
+					if (current()) this.#events.emit("group.updated", changed);
+				}, "falha ao repassar alteração de grupo");
+			}
+		});
+		socket.ev.on("group-participants.update", (update) => {
+			if (!current()) return;
+			this.#groups.delete(update.id);
+			enqueue(async () => {
+				const { self, others } = await toParticipantEvents(update, env, contacts);
+				if (!current()) return;
+				if (self !== null) this.#events.emit(self, { chat: chatOf(update.id) });
+				if (others !== null) this.#events.emit("group.participants", others);
+			}, "falha ao converter alteração de participantes do Baileys; descartada");
+		});
+		socket.ev.on("connection.update", ({ connection, lastDisconnect, qr }) => {
+			if (!current()) return;
+			if (qr !== void 0) {
+				pairing = true;
+				if (this.#pairing === "qr") this.#events.emit("connection.qr", { qr });
+				else if (!codeRequested && !state.creds.registered) {
+					codeRequested = true;
+					this.#requestPairingCode(socket, this.#pairing.phone);
+				}
+			}
+			switch (connection) {
+				case "connecting":
+					this.#events.emit("connection.status", { status: "connecting" });
+					return;
+				case "open":
+					pairing = false;
+					this.#self = socket.user ? toContact(socket.user) : null;
+					this.#events.emit("connection.status", { status: "open" });
+					return;
+				case "close": {
+					this.#socket = null;
+					const error = lastDisconnect?.error;
+					const reason = toDisconnectReason(error, { pairing });
+					this.#events.emit("connection.status", {
+						status: "closed",
+						reason,
+						error
+					});
+					return;
+				}
+			}
+		});
+	}
+	async disconnect() {
+		this.#attempt++;
+		this.#endSocket();
+		this.#polls.clear();
+	}
+	/** Encerra o socket atual sem emitir nada: quem chamou já sabe que a conexão acabou. */
+	#endSocket() {
+		const socket = this.#socket;
+		if (socket === null) return;
+		this.#socket = null;
+		socket.end(void 0).catch((error) => {
+			this.#log.warn("falha ao encerrar o socket do Baileys", { err: error });
+		});
+	}
+	#normalizeEnv(socket, state, logger) {
+		const media = {
+			reuploadRequest: (m) => socket.updateMediaMessage(m),
+			logger
+		};
+		return {
+			get selfIds() {
+				const me = state.creds.me;
+				return [me?.id, me?.lid].flatMap((id) => id ? [jidNormalizedUser(id)] : []);
+			},
+			pnForLid: (lid) => this.#pnForLid(socket, lid),
+			download: (raw) => downloadMediaMessage(raw, "buffer", {}, media),
+			stream: async (raw) => Readable.toWeb(await downloadMediaMessage(raw, "stream", {}, media))
+		};
+	}
+	#pnForLid(socket, lid) {
+		return socket.signalRepository.lidMapping.getPNForLID(lid).catch((error) => {
+			this.#log.warn("falha ao resolver o telefone de um LID", {
+				err: error,
+				lid
+			});
+			return null;
+		});
+	}
+	#requestPairingCode(socket, phone) {
+		socket.requestPairingCode(phone).then((code) => {
+			if (this.#socket === socket) this.#events.emit("connection.pairing-code", { code });
+		}, (error) => {
+			this.#log.error("falha ao pedir o código de pareamento", { err: error });
+		});
+	}
+	async send(chatId, content, options) {
+		const sent = await this.#connected().sendMessage(chatId, toContent(content, options), options?.quoted ? { quoted: toQuoted(options.quoted) } : void 0);
+		const id = sent?.key.id;
+		if (!id) throw new Error("baileys: o envio não devolveu a chave da mensagem");
+		if (content.type === "poll" && sent) this.#polls.remember(sent);
+		return {
+			chatId,
+			id,
+			fromMe: true,
+			senderId: isJidGroup(chatId) ? this.#self?.id ?? null : null
+		};
+	}
+	async react(key, emoji) {
+		await this.#connected().sendMessage(key.chatId, { react: {
+			text: emoji ?? "",
+			key: toWAKey(key)
+		} });
+	}
+	async edit(key, text, formatted) {
+		if (!formatted) {
+			await this.#connected().sendMessage(key.chatId, {
+				text,
+				edit: toWAKey(key)
+			});
+			return;
+		}
+		const rendered = renderWhatsApp(formatted);
+		await this.#connected().sendMessage(key.chatId, {
+			text: rendered.text,
+			edit: toWAKey(key),
+			...rendered.mentions.length > 0 && { mentions: [...rendered.mentions] }
+		});
+	}
+	async delete(key) {
+		await this.#connected().sendMessage(key.chatId, { delete: toWAKey(key) });
+	}
+	async sendTyping(chatId, kind) {
+		await this.#connected().sendPresenceUpdate(kind === "voice" ? "recording" : "composing", chatId);
+	}
+	async getGroupMetadata(groupId) {
+		const socket = this.#connected();
+		let native = this.#groups.get(groupId);
+		if (native === void 0) {
+			const fetching = socket.groupMetadata(groupId);
+			native = fetching;
+			this.#groups.set(groupId, fetching);
+			fetching.catch(() => {
+				if (this.#groups.get(groupId) === fetching) this.#groups.delete(groupId);
+			});
+		}
+		return toGroupMetadata(await native, { pnForLid: (lid) => this.#pnForLid(socket, lid) });
+	}
+	async updateGroupParticipants(groupId, participantIds, action) {
+		const results = await this.#connected().groupParticipantsUpdate(groupId, [...participantIds], action);
+		this.#groups.delete(groupId);
+		const failed = results.filter((r) => r.status !== "200");
+		if (failed.length > 0) {
+			const list = failed.map((r) => `${r.jid ?? "?"} (${r.status})`).join(", ");
+			throw new Error(`baileys: ${action} recusado para ${list}`);
+		}
+	}
+	/** Socket da conexão atual; sem ele, a ação falha na hora em vez de esperar. */
+	#connected() {
+		if (this.#socket === null) throw new Error("baileys: sem conexão");
+		return this.#socket;
+	}
+	/** Para o envio em grupo: usa a consulta que já existe, sem disparar outra. */
+	async #cachedGroup(jid) {
+		return this.#groups.get(jid)?.catch(() => void 0);
+	}
+};
+/** A própria sessão: o `id` do Baileys traz o aparelho (`5511…:12@s.whatsapp.net`). */
+function toContact(user) {
+	const id = jidNormalizedUser(user.id);
+	const jid = jidDecode(id);
+	const phone = jid?.server === "s.whatsapp.net" ? jid.user : jidDecode(user.phoneNumber)?.user ?? null;
+	return {
+		id,
+		name: user.name ?? user.notify ?? null,
+		phone
+	};
+}
+//#endregion
+//#region src/index.ts
+function baileys(options = {}) {
+	const pairing = options.pairing ?? "qr";
+	if (pairing !== "qr" && !/^\d{8,15}$/.test(pairing.phone)) throw new TypeError(`baileys: pairing.phone deve ter só dígitos, com DDI (ex.: 5511999999999); recebido "${pairing.phone}"`);
+	return (deps) => new BaileysTransport({
+		pairing,
+		driver: driver(options.version, deps)
+	}, deps);
+}
+function driver(fixed, deps) {
+	let latest;
+	return {
+		makeSocket: ({ auth, logger, version, cachedGroupMetadata }) => makeWASocket({
+			auth,
+			logger,
+			version,
+			cachedGroupMetadata,
+			browser: Browsers.ubuntu("Chrome")
+		}),
+		version: () => {
+			if (fixed) return Promise.resolve(fixed);
+			latest ??= fetchLatestBaileysVersion().then(({ version, error }) => {
+				if (error !== void 0) deps.log.warn("não deu para buscar a versão do WhatsApp Web; usando a do Baileys", { err: error });
+				return version;
+			});
+			return latest;
+		}
+	};
+}
+//#endregion
+export { baileys };
+
+//# sourceMappingURL=index.mjs.map