zapo-js 0.1.2 → 0.2.0

package/dist/esm/message/icdc.js

@@ -0,0 +1,76 @@
+import { sha256, toRawPubKey } from '../crypto/index.js';
+import { parseSignalAddressFromJid } from '../protocol/jid.js';
+import { concatBytes } from '../util/bytes.js';
+const ICDC_HASH_LENGTH = 8;
+const ICDC_FRESHNESS_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1000;
+const DEVICE_LIST_METADATA_VERSION = 2;
+const EMPTY_KEY_HASH = new Uint8Array(ICDC_HASH_LENGTH);
+export async function computeDeviceKeyHash(identityKeys) {
+    if (identityKeys.length === 0) {
+        return EMPTY_KEY_HASH;
+    }
+    const rawKeys = new Array(identityKeys.length);
+    for (let i = 0; i < identityKeys.length; i += 1) {
+        rawKeys[i] =
+            identityKeys[i].byteLength === 33 ? toRawPubKey(identityKeys[i]) : identityKeys[i];
+    }
+    const combined = concatBytes(rawKeys);
+    const hash = await sha256(combined);
+    return hash.subarray(0, ICDC_HASH_LENGTH);
+}
+export async function resolveIcdcMeta(deviceJids, signalStore, updatedAtMs, localIdentity) {
+    if (deviceJids.length === 0) {
+        return null;
+    }
+    const addresses = new Array(deviceJids.length);
+    for (let i = 0; i < deviceJids.length; i += 1) {
+        addresses[i] = parseSignalAddressFromJid(deviceJids[i]);
+    }
+    const remoteKeys = await signalStore.getRemoteIdentities(addresses);
+    const keys = [];
+    for (let i = 0; i < addresses.length; i += 1) {
+        const key = remoteKeys[i];
+        if (key) {
+            keys.push(key);
+        }
+        else if (localIdentity &&
+            addresses[i].user === localIdentity.address.user &&
+            addresses[i].device === localIdentity.address.device) {
+            keys.push(localIdentity.pubKey);
+        }
+    }
+    if (keys.length === 0) {
+        return null;
+    }
+    const keyHash = await computeDeviceKeyHash(keys);
+    const timestamp = updatedAtMs !== undefined && Date.now() - updatedAtMs < ICDC_FRESHNESS_THRESHOLD_MS
+        ? Math.floor(updatedAtMs / 1000)
+        : undefined;
+    return { keyHash, timestamp };
+}
+export function injectDeviceListMetadata(message, senderIcdc, recipientIcdc) {
+    if (!senderIcdc && !recipientIcdc) {
+        return message;
+    }
+    const deviceListMetadata = {};
+    if (senderIcdc) {
+        deviceListMetadata.senderKeyHash = senderIcdc.keyHash;
+        if (senderIcdc.timestamp !== undefined) {
+            deviceListMetadata.senderTimestamp = senderIcdc.timestamp;
+        }
+    }
+    if (recipientIcdc) {
+        deviceListMetadata.recipientKeyHash = recipientIcdc.keyHash;
+        if (recipientIcdc.timestamp !== undefined) {
+            deviceListMetadata.recipientTimestamp = recipientIcdc.timestamp;
+        }
+    }
+    return {
+        ...message,
+        messageContextInfo: {
+            ...message.messageContextInfo,
+            deviceListMetadata,
+            deviceListMetadataVersion: DEVICE_LIST_METADATA_VERSION
+        }
+    };
+}

package/dist/esm/message/incoming.js

@@ -3,12 +3,9 @@ import { unpadPkcs7 } from './padding.js';
 import { proto } from '../proto.js';
 import { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES } from '../protocol/constants.js';
 import { isBroadcastJid, isGroupJid, parseSignalAddressFromJid } from '../protocol/jid.js';
-import { buildInboundDeliveryReceiptNode, buildInboundMessageAckNode, buildInboundRetryReceiptNode } from '../transport/node/builders/message.js';
+import { buildAckNode, buildReceiptNode } from '../transport/node/builders/global.js';
 import { decodeNodeContentBase64OrBytes, findNodeChild } from '../transport/node/helpers.js';
 import { parseOptionalInt, toError } from '../util/primitives.js';
-function parseMessageTimestamp(value) {
-    return parseOptionalInt(value);
-}
 function pickNextRetryCount(node) {
     const retryNode = findNodeChild(node, 'retry');
     const parsed = parseOptionalInt(retryNode?.attrs.count);
@@ -125,7 +122,13 @@ async function sendRetryReceiptForDecryptFailure(node, options, error, encType)
     if (options.onDecryptFailure) {
         return options.onDecryptFailure(retryContext, error);
     }
-    const retryReceiptNode = buildInboundRetryReceiptNode(node, stanzaId, from, options.getMeJid?.(), pickNextRetryCount(node));
+    const retryReceiptNode = buildReceiptNode({
+        kind: 'retry',
+        node,
+        id: stanzaId,
+        to: from,
+        retryCount: pickNextRetryCount(node)
+    });
     try {
         await options.sendNode(retryReceiptNode);
         options.logger.debug('sent retry receipt for undecryptable incoming message', {
@@ -152,7 +155,8 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
         const senderAddress = parseSignalAddressFromJid(senderJid);
         const decryptedPayload = await decrypt(decodeNodeContentBase64OrBytes(encNode.content, 'message.enc'), senderAddress);
         const unpaddedPlaintext = unpadPkcs7(decryptedPayload);
-        const message = normalizeIncomingDecryptedMessage(proto.Message.decode(unpaddedPlaintext));
+        const decodedMessage = proto.Message.decode(unpaddedPlaintext);
+        const message = unwrapDeviceSentMessage(decodedMessage) ?? decodedMessage;
         const senderKeyDistribution = pickSenderKeyDistributionPayload(message);
         if (senderKeyDistribution && options.senderKeyManager) {
             try {
@@ -178,7 +182,7 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
             const chatJid = node.attrs.from;
             options.emitIncomingMessage?.({
                 ...buildBaseIncomingEvent(node),
-                timestampSeconds: parseMessageTimestamp(node.attrs.t),
+                timestampSeconds: parseOptionalInt(node.attrs.t),
                 senderJid,
                 encryptionType: encType,
                 isGroupChat: chatJid ? isGroupJid(chatJid) : false,
@@ -285,7 +289,13 @@ export async function handleIncomingMessageAck(node, options) {
         return true;
     }
     if (node.attrs.type === WA_MESSAGE_TYPES.MEDIA_NOTIFY) {
-        const ackNode = buildInboundMessageAckNode(node, id, from, options.getMeJid?.());
+        const ackNode = buildAckNode({
+            kind: 'message',
+            node,
+            id,
+            to: from,
+            from: options.getMeJid?.()
+        });
         options.logger.debug('sending inbound message ack', {
             id,
             to: from,
@@ -298,7 +308,12 @@ export async function handleIncomingMessageAck(node, options) {
     if (!shouldSendStandardReceipt) {
         return true;
     }
-    const receiptNode = buildInboundDeliveryReceiptNode(node, id, from);
+    const receiptNode = buildReceiptNode({
+        kind: 'delivery',
+        node,
+        id,
+        to: from
+    });
     options.logger.debug('sending inbound message receipt', {
         id,
         to: from,
@@ -308,6 +323,3 @@ export async function handleIncomingMessageAck(node, options) {
     await options.sendNode(receiptNode);
     return true;
 }
-function normalizeIncomingDecryptedMessage(message) {
-    return unwrapDeviceSentMessage(message) ?? message;
-}

package/dist/esm/message/phash.js

@@ -5,7 +5,9 @@ export async function computePhashV2(participants) {
     if (participants.length === 0) {
         return '2:';
     }
-    const canonical = participants.map((participant) => toPhashCanonicalWid(participant));
+    const canonical = new Array(participants.length);
+    for (let i = 0; i < participants.length; i += 1)
+        canonical[i] = toPhashCanonicalWid(participants[i]);
     const joined = canonical.sort().join('');
     const digest = await sha256(TEXT_ENCODER.encode(joined));
     return `2:${bytesToBase64(digest.subarray(0, 6))}`;

package/dist/esm/message/reporting-token.js

@@ -9,10 +9,6 @@ const WA_REPORTING_TOKEN_CONFIG_BYTES = base64ToBytesChecked(WA_REPORTING_TOKEN_
 export const WA_REPORTING_TOKEN_VERSION = 2;
 let reportingTokenConfigSpec = null;
 const reportingTokenConfigCache = new Map();
-export async function buildReportingTokenNode(input) {
-    const artifacts = await buildReportingTokenArtifacts(input);
-    return artifacts?.node ?? null;
-}
 export async function buildReportingTokenArtifacts(input) {
     const stanzaId = input.stanzaId.trim();
     if (!stanzaId || !isMessageReportingTokenCompatible(input.message)) {
@@ -26,12 +22,7 @@ export async function buildReportingTokenArtifacts(input) {
     if (reportingTokenContent.byteLength === 0) {
         return null;
     }
-    const secretInfo = concatBytes([
-        TEXT_ENCODER.encode(stanzaId),
-        TEXT_ENCODER.encode(input.senderUserJid),
-        TEXT_ENCODER.encode(input.remoteJid),
-        TEXT_ENCODER.encode(WA_REPORTING_TOKEN_USE_CASE)
-    ]);
+    const secretInfo = TEXT_ENCODER.encode(stanzaId + input.senderUserJid + input.remoteJid + WA_REPORTING_TOKEN_USE_CASE);
     const reportingTokenKey = await hkdf(toBytesView(messageSecret), null, secretInfo, WA_REPORTING_TOKEN_KEY_BYTES);
     const hmacKey = await importHmacKey(reportingTokenKey);
     const reportingToken = (await hmacSign(hmacKey, reportingTokenContent)).subarray(0, WA_REPORTING_TOKEN_BYTES);
@@ -68,13 +59,11 @@ function computeReportingTokenContent(messageBytes, version) {
     if (extracted.totalSize === 0) {
         return EMPTY_BYTES;
     }
-    const output = new Uint8Array(extracted.totalSize);
-    let offset = 0;
-    for (const part of extracted.parts) {
-        output.set(part.bytes, offset);
-        offset += part.bytes.length;
+    const parts = new Array(extracted.parts.length);
+    for (let index = 0; index < extracted.parts.length; index += 1) {
+        parts[index] = extracted.parts[index].bytes;
     }
-    return output;
+    return concatBytes(parts);
 }
 function getReportingTokenConfig(version) {
     const cached = reportingTokenConfigCache.get(version);
@@ -251,7 +240,8 @@ function extractProtobufFieldParts(bytes, start, end, config, rootConfig) {
         if (!configuredField) {
             continue;
         }
-        if (!configuredField.isMessage && isExtractWholeField(configuredField)) {
+        if (!configuredField.isMessage &&
+            (!configuredField.subfields || configuredField.subfields.fields.size === 0)) {
             const fieldBytes = bytes.subarray(parsedField.start, parsedField.next);
             parts.push({
                 fieldNumber: parsedField.fieldNumber,
@@ -293,9 +283,6 @@ function extractProtobufFieldParts(bytes, start, end, config, rootConfig) {
         totalSize
     };
 }
-function isExtractWholeField(field) {
-    return !field.subfields || field.subfields.fields.size === 0;
-}
 function parseProtobufField(bytes, start, end) {
     const tag = readVarint(bytes, start, end);
     const tagValue = tag.value;
@@ -424,15 +411,15 @@ function encodeVarint(value) {
     if (!Number.isSafeInteger(value) || value < 0) {
         throw new Error(`invalid varint value: ${value}`);
     }
-    if (value === 0) {
-        return new Uint8Array([0]);
-    }
-    const bytes = [];
+    const bytes = new Uint8Array(10);
+    let length = 0;
     let current = value;
     while (current >= 128) {
-        bytes.push((current % 128) + 128);
+        bytes[length] = (current % 128) + 128;
+        length += 1;
         current = Math.floor(current / 128);
     }
-    bytes.push(current);
-    return new Uint8Array(bytes);
+    bytes[length] = current;
+    length += 1;
+    return bytes.subarray(0, length);
 }

package/dist/esm/protocol/appstate.js

@@ -32,61 +32,30 @@ export const WA_APP_STATE_KDF_INFO = Object.freeze({
     MUTATION_KEYS: 'WhatsApp Mutation Keys',
     PATCH_INTEGRITY: 'WhatsApp Patch Integrity'
 });
-export const WA_APP_STATE_CHAT_MUTATION_ACTIONS = Object.freeze({
-    STAR: 'star',
-    MUTE: 'mute',
-    PIN: 'pin_v1',
-    ARCHIVE: 'archive',
-    DELETE_MESSAGE_FOR_ME: 'deleteMessageForMe',
-    MARK_CHAT_AS_READ: 'markChatAsRead',
-    CLEAR_CHAT: 'clearChat',
-    DELETE_CHAT: 'deleteChat',
-    LOCK_CHAT: 'lock'
-});
 export const WA_APP_STATE_CHAT_MUTATION_SPECS = Object.freeze({
-    STAR: {
-        collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
-        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.STAR,
-        version: 2
-    },
-    MUTE: {
-        collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
-        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.MUTE,
-        version: 2
-    },
-    PIN: {
-        collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW,
-        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.PIN,
-        version: 5
-    },
-    ARCHIVE: {
-        collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW,
-        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.ARCHIVE,
-        version: 3
-    },
+    STAR: { collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH, action: 'star', version: 2 },
+    MUTE: { collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH, action: 'mute', version: 2 },
+    PIN: { collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW, action: 'pin_v1', version: 5 },
+    ARCHIVE: { collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW, action: 'archive', version: 3 },
     DELETE_MESSAGE_FOR_ME: {
         collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
-        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.DELETE_MESSAGE_FOR_ME,
+        action: 'deleteMessageForMe',
         version: 3
     },
     MARK_CHAT_AS_READ: {
         collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW,
-        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.MARK_CHAT_AS_READ,
+        action: 'markChatAsRead',
         version: 3
     },
     CLEAR_CHAT: {
         collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
-        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.CLEAR_CHAT,
+        action: 'clearChat',
         version: 6
     },
     DELETE_CHAT: {
         collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
-        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.DELETE_CHAT,
+        action: 'deleteChat',
         version: 6
     },
-    LOCK_CHAT: {
-        collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW,
-        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.LOCK_CHAT,
-        version: 7
-    }
+    LOCK_CHAT: { collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW, action: 'lock', version: 7 }
 });

package/dist/esm/protocol/browser.js

@@ -19,23 +19,15 @@ export const WA_COMPANION_PLATFORM_IDS = Object.freeze({
     UWP: '8',
     OTHER_WEB_CLIENT: '9'
 });
+const BROWSER_TO_PLATFORM_ID = {
+    [WA_BROWSERS.CHROME]: WA_COMPANION_PLATFORM_IDS.CHROME,
+    [WA_BROWSERS.FIREFOX]: WA_COMPANION_PLATFORM_IDS.FIREFOX,
+    [WA_BROWSERS.IE]: WA_COMPANION_PLATFORM_IDS.IE,
+    [WA_BROWSERS.OPERA]: WA_COMPANION_PLATFORM_IDS.OPERA,
+    [WA_BROWSERS.SAFARI]: WA_COMPANION_PLATFORM_IDS.SAFARI,
+    [WA_BROWSERS.EDGE]: WA_COMPANION_PLATFORM_IDS.EDGE
+};
 export function getWaCompanionPlatformId(browser) {
-    const normalized = browser.trim().toLowerCase();
-    switch (normalized) {
-        case WA_BROWSERS.CHROME:
-            return WA_COMPANION_PLATFORM_IDS.CHROME;
-        case WA_BROWSERS.FIREFOX:
-            return WA_COMPANION_PLATFORM_IDS.FIREFOX;
-        case WA_BROWSERS.IE:
-            return WA_COMPANION_PLATFORM_IDS.IE;
-        case WA_BROWSERS.OPERA:
-            return WA_COMPANION_PLATFORM_IDS.OPERA;
-        case WA_BROWSERS.SAFARI:
-            return WA_COMPANION_PLATFORM_IDS.SAFARI;
-        case WA_BROWSERS.EDGE:
-            return WA_COMPANION_PLATFORM_IDS.EDGE;
-        case WA_BROWSERS.CHROMIUM:
-        default:
-            return WA_COMPANION_PLATFORM_IDS.OTHER_WEB_CLIENT;
-    }
+    return (BROWSER_TO_PLATFORM_ID[browser.trim().toLowerCase()] ??
+        WA_COMPANION_PLATFORM_IDS.OTHER_WEB_CLIENT);
 }

package/dist/esm/protocol/constants.js

@@ -1,12 +1,14 @@
 export { getWaCompanionPlatformId, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS } from './browser.js';
 export { WA_SIGNALING, WA_PAIRING_KDF_INFO } from './auth.js';
-export { WA_DISCONNECT_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream.js';
+export { WA_CONNECTION_REASONS, WA_DISCONNECT_REASONS, WA_FAILURE_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream.js';
 export { WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from './nodes.js';
-export { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from './message.js';
-export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_CHAT_MUTATION_ACTIONS, WA_APP_STATE_CHAT_MUTATION_SPECS, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate.js';
+export { WA_EDIT_ATTRS, WA_ENC_MEDIA_TYPES, WA_EVENT_META_TYPES, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_POLL_META_TYPES, WA_RETRYABLE_ACK_CODES, WA_STANZA_MSG_TYPES } from './message.js';
+export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_CHAT_MUTATION_SPECS, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate.js';
 export { getWaMediaHkdfInfo, WA_MEDIA_HKDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO } from './media.js';
 export { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_SUPPORTED_DIRTY_TYPES } from './dirty.js';
 export { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from './notification.js';
+export { WA_PRIVACY_TOKEN_NOTIFICATION_TYPE, WA_PRIVACY_TOKEN_TAGS, WA_PRIVACY_TOKEN_TYPES, WA_TC_TOKEN_DEFAULTS } from './privacy-token.js';
+export { WA_PRIVACY_CATEGORIES, WA_PRIVACY_CATEGORY_TO_SETTING, WA_PRIVACY_DISALLOWED_LIST_CATEGORIES, WA_PRIVACY_SETTING_TO_CATEGORY, WA_PRIVACY_TAGS, WA_PRIVACY_VALUES } from './privacy.js';
 export { WA_DEFAULTS } from './defaults.js';
 export { WA_GROUP_PARTICIPANT_TYPES } from './group.js';
 export { WA_USYNC_CONTEXTS, WA_USYNC_DEFAULTS, WA_USYNC_MODES } from './usync.js';

package/dist/esm/protocol/defaults.js

@@ -3,6 +3,12 @@ export const WA_DEFAULTS = Object.freeze({
     HOST_DOMAIN: 's.whatsapp.net',
     GROUP_SERVER: 'g.us',
     BROADCAST_SERVER: 'broadcast',
+    LID_SERVER: 'lid',
+    HOSTED_SERVER: 'hosted',
+    HOSTED_LID_SERVER: 'hosted.lid',
+    HOSTED_DEVICE_ID: 99,
+    MSGR_SERVER: 'msgr',
+    INTEROP_SERVER: 'interop',
     DEVICE_BROWSER: WA_BROWSERS.FIREFOX,
     DEVICE_PLATFORM: getWaCompanionPlatformId(WA_BROWSERS.FIREFOX),
     CHAT_SOCKET_URLS: ['wss://web.whatsapp.com/ws/chat', 'wss://web.whatsapp.com:5222/ws/chat'],

package/dist/esm/protocol/index.js

@@ -1,3 +1,2 @@
 export * from './constants.js';
-export { getLoginIdentity, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, toUserJid } from './jid.js';
-export { WA_USYNC_CONTEXTS, WA_USYNC_DEFAULTS, WA_USYNC_MODES } from './usync.js';
+export { buildDeviceJid, canonicalizeSignalJid, canonicalizeSignalServer, getLoginIdentity, isHostedDeviceId, isHostedDeviceJid, isHostedServer, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, signalAddressKey, toUserJid } from './jid.js';

package/dist/esm/protocol/jid.js

@@ -1,51 +1,62 @@
 import { WA_DEFAULTS } from './constants.js';
-function scanJid(jid) {
-    let atIndex = -1;
-    let colonIndex = -1;
-    let dotIndex = -1;
-    for (let index = 0; index < jid.length; index++) {
-        const code = jid.charCodeAt(index);
-        if (code === 64) {
-            atIndex = index;
-            break;
-        }
-        if (code === 58 && colonIndex === -1)
-            colonIndex = index;
-        else if (code === 46 && dotIndex === -1 && colonIndex === -1)
-            dotIndex = index;
+const KNOWN_SERVERS = {
+    [WA_DEFAULTS.HOST_DOMAIN]: WA_DEFAULTS.HOST_DOMAIN,
+    [WA_DEFAULTS.GROUP_SERVER]: WA_DEFAULTS.GROUP_SERVER,
+    [WA_DEFAULTS.BROADCAST_SERVER]: WA_DEFAULTS.BROADCAST_SERVER,
+    [WA_DEFAULTS.LID_SERVER]: WA_DEFAULTS.LID_SERVER,
+    [WA_DEFAULTS.HOSTED_SERVER]: WA_DEFAULTS.HOSTED_SERVER,
+    [WA_DEFAULTS.HOSTED_LID_SERVER]: WA_DEFAULTS.HOSTED_LID_SERVER,
+    [WA_DEFAULTS.MSGR_SERVER]: WA_DEFAULTS.MSGR_SERVER,
+    [WA_DEFAULTS.INTEROP_SERVER]: WA_DEFAULTS.INTEROP_SERVER
+};
+/**
+ * Returns the canonical reference for known server strings, avoiding
+ * thousands of duplicate sliced copies (e.g. "lid", "s.whatsapp.net")
+ * that would otherwise be created by repeated JID parsing.
+ */
+function internServer(server) {
+    return KNOWN_SERVERS[server] ?? server;
+}
+function extractDigits(input) {
+    let digits = '';
+    for (let index = 0; index < input.length; index += 1) {
+        const code = input.charCodeAt(index);
+        if (code >= 48 && code <= 57)
+            digits += input[index];
     }
+    return digits;
+}
+function findAtIndex(jid) {
+    const atIndex = jid.indexOf('@');
     if (atIndex < 1 || atIndex >= jid.length - 1)
         throw new Error(`invalid jid: ${jid}`);
-    return { atIndex, colonIndex, dotIndex };
+    return atIndex;
 }
 export function splitJid(jid) {
-    const { atIndex } = scanJid(jid);
-    return { user: jid.slice(0, atIndex), server: jid.slice(atIndex + 1) };
+    const atIndex = findAtIndex(jid);
+    return { user: jid.slice(0, atIndex), server: internServer(jid.slice(atIndex + 1)) };
 }
 export function normalizeRecipientJid(to) {
     const input = to.trim();
     if (input.length === 0)
         throw new Error('recipient cannot be empty');
     let hasDash = false;
-    let digits = '';
     for (let index = 0; index < input.length; index += 1) {
         const code = input.charCodeAt(index);
         if (code === 64)
             return input;
         if (code === 45) {
             hasDash = true;
-            continue;
         }
-        if (code >= 48 && code <= 57)
-            digits += input[index];
     }
+    const digits = extractDigits(input);
     if (hasDash)
         return `${input}@${WA_DEFAULTS.GROUP_SERVER}`;
     if (digits.length === 0)
         throw new Error(`invalid recipient: ${to}`);
     return `${digits}@${WA_DEFAULTS.HOST_DOMAIN}`;
 }
-export function isJidType(jid, type) {
+function isJidType(jid, type) {
     const atIndex = jid.length - type.length - 1;
     return atIndex >= 1 && jid.charCodeAt(atIndex) === 64 && jid.endsWith(type);
 }
@@ -59,18 +70,43 @@ export function isGroupOrBroadcastJid(jid) {
     return isGroupJid(jid) || isBroadcastJid(jid);
 }
 export function parseSignalAddressFromJid(jid) {
-    const { atIndex, colonIndex } = scanJid(jid);
-    const server = jid.slice(atIndex + 1);
-    if (colonIndex === -1)
+    const atIndex = findAtIndex(jid);
+    const colonIndex = jid.indexOf(':', 0);
+    const server = internServer(jid.slice(atIndex + 1));
+    if (colonIndex === -1 || colonIndex > atIndex) {
         return { user: jid.slice(0, atIndex), server, device: 0 };
+    }
     const device = Number.parseInt(jid.slice(colonIndex + 1, atIndex), 10);
     if (!Number.isFinite(device) || device < 0)
         throw new Error(`invalid jid device: ${jid}`);
     return { user: jid.slice(0, colonIndex), server, device };
 }
-export function toUserJid(jid) {
+export function parseJidFull(jid) {
+    const address = parseSignalAddressFromJid(jid);
+    const userJid = `${address.user}@${address.server}`;
+    const normalizedJid = address.device === 0 ? userJid : `${address.user}:${address.device}@${address.server}`;
+    return { address, userJid, normalizedJid };
+}
+export function canonicalizeSignalServer(server, hostDomain = WA_DEFAULTS.HOST_DOMAIN) {
+    if (server === WA_DEFAULTS.HOSTED_SERVER)
+        return hostDomain;
+    if (server === WA_DEFAULTS.HOSTED_LID_SERVER)
+        return WA_DEFAULTS.LID_SERVER;
+    return server;
+}
+export function canonicalizeSignalJid(jid, hostDomain = WA_DEFAULTS.HOST_DOMAIN) {
     const address = parseSignalAddressFromJid(jid);
-    return `${address.user}@${address.server}`;
+    const server = canonicalizeSignalServer(address.server ?? WA_DEFAULTS.HOST_DOMAIN, hostDomain);
+    if (address.device === 0)
+        return `${address.user}@${server}`;
+    return `${address.user}:${address.device}@${server}`;
+}
+export function toUserJid(jid, options = {}) {
+    const address = parseSignalAddressFromJid(jid);
+    const server = options.canonicalizeSignalServer === true
+        ? canonicalizeSignalServer(address.server ?? WA_DEFAULTS.HOST_DOMAIN, options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN)
+        : address.server;
+    return `${address.user}@${server}`;
 }
 export function normalizeDeviceJid(jid) {
     const address = parseSignalAddressFromJid(jid);
@@ -78,11 +114,49 @@ export function normalizeDeviceJid(jid) {
         return `${address.user}@${address.server}`;
     return `${address.user}:${address.device}@${address.server}`;
 }
+export function isHostedDeviceId(deviceId) {
+    return deviceId === WA_DEFAULTS.HOSTED_DEVICE_ID;
+}
+export function isHostedServer(server) {
+    return server === WA_DEFAULTS.HOSTED_SERVER || server === WA_DEFAULTS.HOSTED_LID_SERVER;
+}
+export function isHostedDeviceJid(jid) {
+    const { user, server } = splitJid(jid);
+    if (isHostedServer(server)) {
+        return true;
+    }
+    const colonIndex = user.indexOf(':');
+    if (colonIndex < 0) {
+        return false;
+    }
+    const deviceId = Number.parseInt(user.slice(colonIndex + 1), 10);
+    return Number.isSafeInteger(deviceId) && isHostedDeviceId(deviceId);
+}
+export function buildDeviceJid(user, normalizedServer, deviceId, options = {}) {
+    if (options.isHosted === true) {
+        if (!isHostedDeviceId(deviceId)) {
+            return `${user}:${deviceId}@${normalizedServer}`;
+        }
+        const hostedServer = options.rawServer === WA_DEFAULTS.HOSTED_LID_SERVER ||
+            normalizedServer === WA_DEFAULTS.LID_SERVER
+            ? WA_DEFAULTS.HOSTED_LID_SERVER
+            : WA_DEFAULTS.HOSTED_SERVER;
+        return `${user}:${WA_DEFAULTS.HOSTED_DEVICE_ID}@${hostedServer}`;
+    }
+    if (deviceId === 0) {
+        return `${user}@${normalizedServer}`;
+    }
+    return `${user}:${deviceId}@${normalizedServer}`;
+}
 export function getLoginIdentity(meJid) {
-    const { atIndex, colonIndex, dotIndex } = scanJid(meJid);
-    const userEndIndex = dotIndex === -1 ? (colonIndex === -1 ? atIndex : colonIndex) : dotIndex;
+    const atIndex = findAtIndex(meJid);
+    const colonIndex = meJid.indexOf(':', 0);
+    const dotIndex = meJid.indexOf('.', 0);
+    const hasColon = colonIndex !== -1 && colonIndex < atIndex;
+    const hasDot = dotIndex !== -1 && dotIndex < atIndex && (colonIndex === -1 || dotIndex < colonIndex);
+    const userEndIndex = hasDot ? dotIndex : hasColon ? colonIndex : atIndex;
     const username = Number.parseInt(meJid.slice(0, userEndIndex), 10);
-    const device = colonIndex === -1 ? 0 : Number.parseInt(meJid.slice(colonIndex + 1, atIndex), 10);
+    const device = hasColon ? Number.parseInt(meJid.slice(colonIndex + 1, atIndex), 10) : 0;
     if (!Number.isSafeInteger(username) || username <= 0)
         throw new Error(`invalid numeric username from ${meJid}`);
     if (!Number.isSafeInteger(device) || device < 0)
@@ -90,12 +164,7 @@ export function getLoginIdentity(meJid) {
     return { username, device };
 }
 export function parsePhoneJid(input) {
-    let digits = '';
-    for (let index = 0; index < input.length; index += 1) {
-        const code = input.charCodeAt(index);
-        if (code >= 48 && code <= 57)
-            digits += input[index];
-    }
+    const digits = extractDigits(input);
     if (!digits)
         throw new Error('phone number is empty after normalization');
     return `${digits}@${WA_DEFAULTS.HOST_DOMAIN}`;