@wacando/agent 2.0.1 → 2.1.0

package/packages/wacando/chunks/chunk-OI3RF7TS.mjs

@@ -0,0 +1,421 @@
+// Embedded from lbframe/wacando@9f82881d4ee6cfd655727a08883877230917c955 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
+import {
+  DomainError
+} from "./chunk-EIGFLZ2Y.mjs";
+
+// packages/omemo/src/ns.ts
+var NS_OMEMO = "eu.siacs.conversations.axolotl";
+var NS_DEVICELIST = `${NS_OMEMO}.devicelist`;
+var NS_EME = "urn:xmpp:eme:0";
+var NS_HINTS = "urn:xmpp:hints";
+var NS_SCE = "urn:xmpp:sce:1";
+var NS_WACANDO_OMEMO = "urn:wacando:omemo:1";
+function bundleNode(deviceId) {
+  return `${NS_OMEMO}.bundles:${deviceId}`;
+}
+var PEP_ITEM_ID = "current";
+var BODY_MARKER = "WACANDO_OMEMO_V1";
+var MESSAGE_KEY_BYTES = 32;
+var GCM_IV_BYTES = 12;
+var GCM_TAG_BYTES = 16;
+
+// packages/omemo/src/errors.ts
+var OmemoError = class extends DomainError {
+  constructor(message) {
+    super("SECURE_MESSAGING_UNAVAILABLE", message);
+    this.name = "OmemoError";
+  }
+};
+var UnsupportedSignalFormatError = class extends OmemoError {
+};
+var OmemoReceiveError = class extends OmemoError {
+  failure;
+  constructor(message, failure) {
+    super(message);
+    this.failure = failure;
+  }
+};
+
+// packages/omemo/src/sce.ts
+import { escapeXMLText } from "@xmpp/xml";
+import ltxParse from "ltx/lib/parse.js";
+function buildSceEnvelope(bodyText) {
+  return `<content xmlns="${NS_SCE}"><payload><body xmlns="jabber:client">${escapeXMLText(bodyText)}</body></payload></content>`;
+}
+function parseXmlDocument(xmlText) {
+  let root;
+  try {
+    root = ltxParse(xmlText);
+  } catch (err) {
+    throw new OmemoError(`XML parse failed: ${err.message}`);
+  }
+  if (!root || typeof root.getName !== "function") {
+    throw new OmemoError("empty XML document");
+  }
+  return root;
+}
+function parseSceEnvelope(xmlText) {
+  const root = parseXmlDocument(xmlText);
+  if (root.getName() !== "content" || root.getNS() !== NS_SCE) {
+    throw new OmemoError("decrypted payload is not a SCE content envelope");
+  }
+  const payload = root.getChild("payload");
+  const body = payload?.getChild("body", "jabber:client");
+  if (!body) {
+    throw new OmemoError("SCE payload has no <body>");
+  }
+  return body.text();
+}
+
+// packages/omemo/src/wire.ts
+import xml from "@xmpp/xml";
+
+// packages/omemo/src/bytes.ts
+import { fromByteArray, toByteArray } from "base64-js";
+function b64encode(bytes) {
+  return fromByteArray(bytes);
+}
+function b64decode(s) {
+  return new Uint8Array(toByteArray(s));
+}
+function randomBytes(length) {
+  const out = new Uint8Array(length);
+  globalThis.crypto.getRandomValues(out);
+  return out;
+}
+function utf8Encode(s) {
+  return new Uint8Array(new TextEncoder().encode(s));
+}
+function utf8Decode(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+
+// packages/omemo/src/wire.ts
+function buildEncryptedMessageEl(parts) {
+  const headerChildren = [
+    ...parts.keys.map(
+      (k) => xml(
+        "key",
+        { rid: String(k.rid), jid: k.jid, ...k.isPreKey ? { prekey: "1" } : {} },
+        k.ciphertextB64
+      )
+    ),
+    xml("iv", {}, parts.ivB64)
+  ];
+  return xml(
+    "message",
+    { to: parts.roomJid, type: "groupchat", id: parts.stanzaId ?? newStanzaId() },
+    xml(
+      "encrypted",
+      { xmlns: NS_OMEMO },
+      xml("header", { sid: String(parts.senderDeviceId) }, ...headerChildren),
+      xml("payload", {}, parts.payloadB64)
+    ),
+    xml("sender", { xmlns: NS_WACANDO_OMEMO, jid: parts.senderBareJid }),
+    xml("encryption", { xmlns: NS_EME, namespace: NS_OMEMO, name: "OMEMO" }),
+    xml("store", { xmlns: NS_HINTS }),
+    xml("body", {}, BODY_MARKER)
+  );
+}
+function newStanzaId() {
+  return `om-${[...randomBytes(8)].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+function parseEncrypted(stanza) {
+  const encrypted = findDescendant(stanza, "encrypted", NS_OMEMO);
+  if (!encrypted) return null;
+  const header = encrypted.getChild("header");
+  const payload = encrypted.getChild("payload");
+  const sender = findDescendant(stanza, "sender", NS_WACANDO_OMEMO);
+  const sid = Number(header?.getAttr("sid"));
+  const senderJid = sender?.getAttr("jid");
+  const ivB64 = header?.getChild("iv")?.text();
+  const payloadB64 = payload?.text();
+  if (!Number.isInteger(sid) || !senderJid || !ivB64 || !payloadB64) {
+    return null;
+  }
+  const keys = [];
+  for (const k of header?.getChildren("key") ?? []) {
+    const rid = Number(k.getAttr("rid"));
+    if (!Number.isInteger(rid)) continue;
+    const jid = k.getAttr("jid");
+    keys.push({
+      rid,
+      jid: typeof jid === "string" ? jid : void 0,
+      ciphertextB64: k.text(),
+      isPreKey: k.getAttr("prekey") === "1" || k.getAttr("prekey") === "true"
+    });
+  }
+  if (keys.length === 0) return null;
+  return { senderDeviceId: sid, senderBareJid: senderJid, keys, ivB64, payloadB64 };
+}
+function findDescendant(el, name, ns) {
+  for (const child of el.getChildren(name)) {
+    if (child.getNS() === ns) return child;
+  }
+  for (const child of el.children) {
+    if (typeof child === "string") continue;
+    const found = findDescendant(child, name, ns);
+    if (found) return found;
+  }
+  return void 0;
+}
+
+// packages/omemo/src/recovery-wire.ts
+import xml2 from "@xmpp/xml";
+var NS_RECOVERY = "urn:wacando:omemo:recovery:1";
+var RECOVERY_DOMAIN = "wacando-omemo-session-recovery-v1";
+var RECOVERY_VERSION = "1";
+var RECOVERY_PHASES = ["OFFER", "INIT", "CONFIRM", "COMMIT", "COMMITTED"];
+var MAX_RECORD_BYTES = 4096;
+var MAX_CTL_BYTES = 2048;
+var SIGNATURE_BYTES = 64;
+var FIELD_COUNT = 21;
+var BARE_JID = /^[a-z0-9][a-z0-9._-]{0,127}@[a-z0-9][a-z0-9.-]{0,253}$/;
+var CONVERSATION_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+var DECIMAL = /^(0|[1-9][0-9]{0,15})$/;
+var POSITIVE = /^[1-9][0-9]{0,9}$/;
+var HEX64 = /^[0-9a-f]{64}$/;
+var STANZA_ID = /^[A-Za-z0-9_.:-]{1,64}$/;
+var B64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+function signerRole(phase) {
+  return phase === "INIT" || phase === "COMMIT" ? "A" : "B";
+}
+function signerJid(record) {
+  return signerRole(record.phase) === "A" ? record.aJid : record.bJid;
+}
+function targetJid(record) {
+  return signerRole(record.phase) === "A" ? record.bJid : record.aJid;
+}
+function positive(value, max = 4294967295) {
+  if (!POSITIVE.test(value)) return null;
+  const n = Number(value);
+  return n >= 1 && n <= max ? n : null;
+}
+function encodeRecord(r) {
+  const fields = [
+    RECOVERY_DOMAIN,
+    r.phase,
+    r.conversationId,
+    r.roomJid,
+    r.aJid,
+    String(r.aDevice),
+    r.aFingerprint,
+    r.bJid,
+    String(r.bDevice),
+    r.bFingerprint,
+    r.nonce,
+    String(r.createdAt),
+    String(r.expiresAt),
+    String(r.consumedPreKeyId),
+    r.stanzaId,
+    r.keyDigest,
+    String(r.generation),
+    r.bundleDigest,
+    r.prevDigest,
+    r.ctlDigest,
+    r.selectedPreKeyId === null ? "" : String(r.selectedPreKeyId)
+  ];
+  return utf8Encode(JSON.stringify(fields));
+}
+function parseRecord(bytes) {
+  if (bytes.length === 0 || bytes.length > MAX_RECORD_BYTES)
+    return { ok: false, reason: "oversized" };
+  let raw;
+  try {
+    raw = JSON.parse(utf8Decode(bytes));
+  } catch {
+    return { ok: false, reason: "malformed" };
+  }
+  if (!Array.isArray(raw) || raw.length !== FIELD_COUNT || !raw.every((f2) => typeof f2 === "string"))
+    return { ok: false, reason: "malformed" };
+  const f = raw;
+  const [
+    domain,
+    phase,
+    conversationId,
+    roomJid,
+    aJid,
+    aDevice,
+    aFingerprint,
+    bJid,
+    bDevice,
+    bFingerprint,
+    nonce,
+    createdAt,
+    expiresAt,
+    consumedPreKeyId,
+    stanzaId,
+    keyDigest,
+    generation,
+    bundleDigest,
+    prevDigest,
+    ctlDigest,
+    selected
+  ] = f;
+  if (domain !== RECOVERY_DOMAIN) return { ok: false, reason: "malformed" };
+  if (!RECOVERY_PHASES.includes(phase))
+    return { ok: false, reason: "malformed" };
+  const p = phase;
+  const aDev = positive(aDevice);
+  const bDev = positive(bDevice);
+  const consumed = positive(consumedPreKeyId, 16777215);
+  const selectedId = selected === "" ? null : positive(selected, 16777215);
+  const roomLocal = roomJid.split("@")[0];
+  const valid = CONVERSATION_ID.test(conversationId) && BARE_JID.test(roomJid) && roomLocal === `c_${conversationId}` && BARE_JID.test(aJid) && BARE_JID.test(bJid) && aDev !== null && bDev !== null && HEX64.test(aFingerprint) && HEX64.test(bFingerprint) && HEX64.test(nonce) && DECIMAL.test(createdAt) && DECIMAL.test(expiresAt) && Number(expiresAt) > Number(createdAt) && consumed !== null && STANZA_ID.test(stanzaId) && HEX64.test(keyDigest) && DECIMAL.test(generation) && HEX64.test(bundleDigest) && (p === "OFFER" ? prevDigest === "" : HEX64.test(prevDigest)) && (p === "OFFER" ? ctlDigest === "" : HEX64.test(ctlDigest)) && (p === "OFFER" ? selected === "" : selectedId !== null && selectedId !== consumed) && !(aJid === bJid && aDev === bDev);
+  if (!valid) return { ok: false, reason: "malformed" };
+  const record = {
+    phase: p,
+    conversationId,
+    roomJid,
+    aJid,
+    aDevice: aDev,
+    aFingerprint,
+    bJid,
+    bDevice: bDev,
+    bFingerprint,
+    nonce,
+    createdAt: Number(createdAt),
+    expiresAt: Number(expiresAt),
+    consumedPreKeyId: consumed,
+    stanzaId,
+    keyDigest,
+    generation: Number(generation),
+    bundleDigest,
+    prevDigest,
+    ctlDigest,
+    selectedPreKeyId: selectedId
+  };
+  const again = encodeRecord(record);
+  if (again.length !== bytes.length || again.some((b, i) => b !== bytes[i]))
+    return { ok: false, reason: "noncanonical" };
+  return { ok: true, record };
+}
+function canonicalB64(text, maxBytes) {
+  if (text.length > Math.ceil(maxBytes / 3) * 4 + 4) return "oversized";
+  if (text.length === 0 || !B64.test(text)) return null;
+  let bytes;
+  try {
+    bytes = b64decode(text);
+  } catch {
+    return null;
+  }
+  if (bytes.length > maxBytes) return "oversized";
+  if (bytes.length === 0 || b64encode(bytes) !== text) return null;
+  return bytes;
+}
+var FULL_JID = /^[a-z0-9][a-z0-9._-]{0,127}@[a-z0-9][a-z0-9.-]{0,253}\/[^\s/]{1,256}$/;
+function parseRecoveryEl(el, withOrigin) {
+  if (!el.is("recovery", NS_RECOVERY)) return { ok: false, reason: "malformed" };
+  const attrs = Object.keys(el.attrs).filter((k) => k !== "xmlns");
+  if (attrs.length !== 1 || el.attrs.v !== RECOVERY_VERSION)
+    return { ok: false, reason: "malformed" };
+  let recordB64 = null;
+  let sigB64 = null;
+  let ctlB64 = null;
+  let origin = null;
+  let originSeen = false;
+  for (const child of el.children) {
+    if (typeof child === "string") {
+      if (child.trim() !== "") return { ok: false, reason: "malformed" };
+      continue;
+    }
+    const name = child.getName();
+    if (child.getNS() !== NS_RECOVERY) return { ok: false, reason: "malformed" };
+    if (name === "origin") {
+      if (!withOrigin) return { ok: false, reason: "unexpected-origin" };
+      if (originSeen || child.children.length !== 0) return { ok: false, reason: "malformed" };
+      const keys = Object.keys(child.attrs).filter((k) => k !== "xmlns");
+      const jid = child.attrs.jid;
+      if (keys.length !== 1 || typeof jid !== "string" || !FULL_JID.test(jid))
+        return { ok: false, reason: "malformed" };
+      origin = jid;
+      originSeen = true;
+      continue;
+    }
+    const text = (() => {
+      const plain = { ...child.attrs };
+      delete plain.xmlns;
+      if (Object.keys(plain).length !== 0) return null;
+      return child.children.every((c) => typeof c === "string") ? child.children.join("") : null;
+    })();
+    if (text === null) return { ok: false, reason: "malformed" };
+    if (name === "record" && recordB64 === null) recordB64 = text;
+    else if (name === "sig" && sigB64 === null) sigB64 = text;
+    else if (name === "ctl" && ctlB64 === null) ctlB64 = text;
+    else return { ok: false, reason: "malformed" };
+  }
+  if (withOrigin && origin === null) return { ok: false, reason: "missing-origin" };
+  if (recordB64 === null || sigB64 === null) return { ok: false, reason: "malformed" };
+  const recordBytes = canonicalB64(recordB64, MAX_RECORD_BYTES);
+  const signature = canonicalB64(sigB64, SIGNATURE_BYTES);
+  const ctl = ctlB64 === null ? null : canonicalB64(ctlB64, MAX_CTL_BYTES);
+  if (recordBytes === "oversized" || ctl === "oversized") return { ok: false, reason: "oversized" };
+  if (!recordBytes || !signature || signature === "oversized" || signature.length !== SIGNATURE_BYTES || ctlB64 !== null && !ctl)
+    return { ok: false, reason: "malformed" };
+  const parsed = parseRecord(recordBytes);
+  if (!parsed.ok) return parsed;
+  if (parsed.record.phase === "OFFER" !== (ctl === null))
+    return { ok: false, reason: "malformed" };
+  return {
+    ok: true,
+    control: {
+      packet: { recordB64, sigB64, ...ctlB64 !== null ? { ctlB64 } : {} },
+      record: parsed.record,
+      recordBytes,
+      signature,
+      ctl,
+      originJid: origin
+    }
+  };
+}
+function buildRecoveryEl(packet, originJid) {
+  return xml2(
+    "recovery",
+    { xmlns: NS_RECOVERY, v: RECOVERY_VERSION },
+    xml2("record", {}, packet.recordB64),
+    xml2("sig", {}, packet.sigB64),
+    ...packet.ctlB64 !== void 0 ? [xml2("ctl", {}, packet.ctlB64)] : [],
+    ...originJid !== void 0 ? [xml2("origin", { jid: originJid })] : []
+  );
+}
+
+export {
+  NS_OMEMO,
+  NS_DEVICELIST,
+  NS_EME,
+  NS_HINTS,
+  NS_SCE,
+  NS_WACANDO_OMEMO,
+  bundleNode,
+  PEP_ITEM_ID,
+  BODY_MARKER,
+  MESSAGE_KEY_BYTES,
+  GCM_IV_BYTES,
+  GCM_TAG_BYTES,
+  OmemoError,
+  UnsupportedSignalFormatError,
+  OmemoReceiveError,
+  b64encode,
+  b64decode,
+  randomBytes,
+  utf8Encode,
+  buildSceEnvelope,
+  parseXmlDocument,
+  parseSceEnvelope,
+  buildEncryptedMessageEl,
+  parseEncrypted,
+  NS_RECOVERY,
+  RECOVERY_DOMAIN,
+  RECOVERY_VERSION,
+  RECOVERY_PHASES,
+  MAX_RECORD_BYTES,
+  MAX_CTL_BYTES,
+  SIGNATURE_BYTES,
+  signerRole,
+  signerJid,
+  targetJid,
+  encodeRecord,
+  parseRecord,
+  parseRecoveryEl,
+  buildRecoveryEl
+};

package/packages/wacando/omemo-wire.mjs

@@ -0,0 +1,192 @@
+// Embedded from lbframe/wacando@9f82881d4ee6cfd655727a08883877230917c955 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
+import {
+  BODY_MARKER,
+  GCM_IV_BYTES,
+  GCM_TAG_BYTES,
+  MAX_CTL_BYTES,
+  MAX_RECORD_BYTES,
+  MESSAGE_KEY_BYTES,
+  NS_DEVICELIST,
+  NS_EME,
+  NS_HINTS,
+  NS_OMEMO,
+  NS_RECOVERY,
+  NS_SCE,
+  NS_WACANDO_OMEMO,
+  PEP_ITEM_ID,
+  RECOVERY_DOMAIN,
+  RECOVERY_PHASES,
+  RECOVERY_VERSION,
+  SIGNATURE_BYTES,
+  buildEncryptedMessageEl,
+  buildRecoveryEl,
+  bundleNode,
+  encodeRecord,
+  parseEncrypted,
+  parseRecord,
+  parseRecoveryEl,
+  parseXmlDocument,
+  signerJid,
+  signerRole,
+  targetJid
+} from "./chunks/chunk-OI3RF7TS.mjs";
+import "./chunks/chunk-EIGFLZ2Y.mjs";
+
+// packages/omemo/src/policy-wire.ts
+import xml from "@xmpp/xml";
+var NS_WACANDO_POLICY = "urn:wacando:policy:0";
+var DIGEST_VERSION = "wacando-omemo-digest-v1";
+var STANZA_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+var BARE_JID_RE = /^[^\s|/@]{1,1023}@[^\s|/@]{1,1023}$/;
+var B64_RE = /^[A-Za-z0-9+/]*={0,2}$/;
+function isCanonicalBareJid(value) {
+  return typeof value === "string" && BARE_JID_RE.test(value);
+}
+function parseBoundEncrypted(stanza) {
+  const parsed = parseEncrypted(stanza);
+  if (!parsed) return null;
+  if (!isCanonicalBareJid(parsed.senderBareJid)) return null;
+  if (!B64_RE.test(parsed.ivB64.trim()) || !B64_RE.test(parsed.payloadB64.trim())) return null;
+  for (const k of parsed.keys) {
+    if (!isCanonicalBareJid(k.jid) || !B64_RE.test(k.ciphertextB64.trim())) return null;
+  }
+  return parsed;
+}
+function canonicalCiphertext(parsed) {
+  const lines = [
+    DIGEST_VERSION,
+    `sender=${parsed.senderBareJid}`,
+    `sid=${parsed.senderDeviceId}`,
+    ...parsed.keys.map(
+      (k) => `key=${k.jid}|${k.rid}|${k.isPreKey ? 1 : 0}|${k.ciphertextB64.trim()}`
+    ),
+    `iv=${parsed.ivB64.trim()}`,
+    `payload=${parsed.payloadB64.trim()}`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+async function sha256Hex(text) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function ciphertextDigest(stanza) {
+  const parsed = parseBoundEncrypted(stanza);
+  return parsed ? sha256Hex(canonicalCiphertext(parsed)) : null;
+}
+function digestOfParsed(parsed) {
+  return sha256Hex(canonicalCiphertext(parsed));
+}
+function isValidStanzaId(id) {
+  return typeof id === "string" && STANZA_ID_RE.test(id);
+}
+function toPolicySubmission(groupchat, componentJid) {
+  const room = groupchat.getAttr("to");
+  const id = groupchat.getAttr("id");
+  const parsed = parseBoundEncrypted(groupchat);
+  if (typeof room !== "string" || !isValidStanzaId(id) || !parsed) {
+    throw new Error("not an encrypted groupchat stanza");
+  }
+  const canonical = buildHeldGroupchat(room, id, parsed);
+  const encrypted = canonical.getChild("encrypted", NS_OMEMO);
+  const sender = canonical.getChild("sender", NS_WACANDO_OMEMO);
+  if (!encrypted || !sender) throw new Error("not an encrypted groupchat stanza");
+  return xml(
+    "message",
+    { to: componentJid, id },
+    xml("submit", { xmlns: NS_WACANDO_POLICY, room }),
+    encrypted,
+    sender
+  );
+}
+function parsePolicySubmission(stanza) {
+  if (!stanza.is("message") || stanza.getAttr("type") === "error") {
+    return { ok: false, reason: "malformed" };
+  }
+  const submit = stanza.getChild("submit", NS_WACANDO_POLICY);
+  const id = stanza.getAttr("id");
+  const from = stanza.getAttr("from");
+  const room = submit?.getAttr("room");
+  if (!submit || !isValidStanzaId(id) || typeof from !== "string" || typeof room !== "string") {
+    return { ok: false, reason: "malformed", ...isValidStanzaId(id) ? { stanzaId: id } : {} };
+  }
+  const parsed = parseBoundEncrypted(stanza);
+  if (!parsed) return { ok: false, reason: "not-encrypted", stanzaId: id };
+  const fromBareJid = from.split("/")[0] ?? "";
+  if (parsed.senderBareJid !== fromBareJid) {
+    return { ok: false, reason: "sender-mismatch", stanzaId: id };
+  }
+  return { ok: true, roomJid: room, stanzaId: id, fromBareJid, parsed };
+}
+function buildHeldGroupchat(roomJid, stanzaId, parsed) {
+  return buildEncryptedMessageEl({
+    roomJid,
+    senderBareJid: parsed.senderBareJid,
+    senderDeviceId: parsed.senderDeviceId,
+    keys: parsed.keys,
+    ivB64: parsed.ivB64,
+    payloadB64: parsed.payloadB64,
+    stanzaId
+  });
+}
+function buildRelayEl(roomJid, stanzaId, parsed, digest) {
+  const el = buildHeldGroupchat(roomJid, stanzaId, parsed);
+  el.append(xml("relay", { xmlns: NS_WACANDO_POLICY, jid: parsed.senderBareJid, digest }));
+  return el;
+}
+function submissionStatusEl(to, stanzaId, state, extra = {}) {
+  return xml(
+    "message",
+    { to, type: "normal" },
+    xml("submission", {
+      xmlns: NS_WACANDO_POLICY,
+      id: stanzaId,
+      state,
+      ...extra.reason ? { reason: extra.reason } : {},
+      ...extra.digest ? { digest: extra.digest } : {}
+    })
+  );
+}
+export {
+  BODY_MARKER,
+  GCM_IV_BYTES,
+  GCM_TAG_BYTES,
+  MAX_CTL_BYTES,
+  MAX_RECORD_BYTES,
+  MESSAGE_KEY_BYTES,
+  NS_DEVICELIST,
+  NS_EME,
+  NS_HINTS,
+  NS_OMEMO,
+  NS_RECOVERY,
+  NS_SCE,
+  NS_WACANDO_OMEMO,
+  NS_WACANDO_POLICY,
+  PEP_ITEM_ID,
+  RECOVERY_DOMAIN,
+  RECOVERY_PHASES,
+  RECOVERY_VERSION,
+  SIGNATURE_BYTES,
+  buildEncryptedMessageEl,
+  buildHeldGroupchat,
+  buildRecoveryEl,
+  buildRelayEl,
+  bundleNode,
+  canonicalCiphertext,
+  ciphertextDigest,
+  digestOfParsed,
+  encodeRecord,
+  isCanonicalBareJid,
+  isValidStanzaId,
+  parseBoundEncrypted,
+  parseEncrypted,
+  parsePolicySubmission,
+  parseRecord,
+  parseRecoveryEl,
+  parseXmlDocument,
+  signerJid,
+  signerRole,
+  submissionStatusEl,
+  targetJid,
+  toPolicySubmission
+};