@badzz88/baileys 8.5.4 → 8.5.5

package/lib/Utils/validate-connection.js

@@ -7,48 +7,24 @@ exports.encodeSignedDeviceIdentity =
 		void 0
 const boom_1 = require('@hapi/boom')
 const crypto_1 = require('crypto')
-const rb = require('whatsapp-rust-bridge')
+const Crypto_1 = require('./crypto')
 const index_js_1 = require('../../WAProto/index.js')
 const Defaults_1 = require('../Defaults')
 const WABinary_1 = require('../WABinary')
 const crypto_2 = require('./crypto')
 const generics_1 = require('./generics')
 const signal_1 = require('./signal')
-const MOBILE_PLATFORMS = new Set(['Android', 'iOS'])
 const getUserAgent = config => {
-	const os = config.browser[0]
-	let platform, device, osVersion
-	if (os === 'Android') {
-		platform = index_js_1.proto.ClientPayload.UserAgent.Platform.ANDROID
-		device = 'Android'
-		osVersion = config.browser[2] || '15.0.0'
-	} else if (os === 'iOS') {
-		platform = index_js_1.proto.ClientPayload.UserAgent.Platform.IOS
-		device = 'iPhone'
-		osVersion = config.browser[2] || '18.0'
-	} else if (config.syncFullHistory && os === 'Mac OS' && config.browser[1] === 'Desktop') {
-		
-		
-		platform = index_js_1.proto.ClientPayload.UserAgent.Platform.MACOS
-		device = 'Desktop'
-		osVersion = '0.1'
-	} else {
-		platform = index_js_1.proto.ClientPayload.UserAgent.Platform.WEB
-		device = 'Desktop'
-		osVersion = '0.1'
-	}
 	return {
 		appVersion: {
 			primary: config.version[0],
 			secondary: config.version[1],
 			tertiary: config.version[2]
 		},
-		platform,
-		
-		
+		platform: index_js_1.proto.ClientPayload.UserAgent.Platform.WEB,
 		releaseChannel: index_js_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
-		osVersion,
-		device,
+		osVersion: '0.1',
+		device: 'Desktop',
 		osBuildNumber: '0.1',
 		localeLanguageIso6391: 'en',
 		mnc: '000',
@@ -58,9 +34,7 @@ const getUserAgent = config => {
 }
 const PLATFORM_MAP = {
 	'Mac OS': index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-	Windows: index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN_HYBRID,
-	Android: index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER,
-	iOS: index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER
+	Windows: index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
 }
 const getWebInfo = config => {
 	let webSubPlatform = index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER
@@ -75,16 +49,14 @@ const getClientPayload = config => {
 		connectReason: index_js_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
 		userAgent: getUserAgent(config)
 	}
-	if (!MOBILE_PLATFORMS.has(config.browser[0])) {
-		payload.webInfo = getWebInfo(config)
-	}
+	payload.webInfo = getWebInfo(config)
 	return payload
 }
 const generateLoginNode = (userJid, config, creds) => {
 	const { user, device } = (0, WABinary_1.jidDecode)(userJid)
-	
-	
-	
+	// masqueradeAsPrimary: connect as device 0 so the WA server (and interop bridges)
+	// route primary-device traffic — including interop messages — to this session.
+	// Trade-off: the real phone (device 0 on TCP) may be kicked or see a conflict.
 	const effectiveDevice = config.masqueradeAsPrimary ? 0 : device
 	const payload = {
 		...getClientPayload(config),
@@ -94,8 +66,8 @@ const generateLoginNode = (userJid, config, creds) => {
 		device: effectiveDevice,
 		lidDbMigrated: false
 	}
-	
-	
+	// InteropData is required for Meta/FB-linked accounts (AccountType = HOSTED).
+	// Populated from creds when present so the server routes interop traffic correctly.
 	if (creds?.interopData?.accountId) {
 		payload.interopData = {
 			accountId: creds.interopData.accountId,
@@ -111,23 +83,18 @@ const getPlatformType = platform => {
 	return index_js_1.proto.DeviceProps.PlatformType[platformType] || index_js_1.proto.DeviceProps.PlatformType.CHROME
 }
 const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
-	
-	
-	const appVersionBuf = Buffer.from(rb.md5(Buffer.from(config.version.join('.'))))
+	// the app version needs to be md5 hashed
+	// and passed in
+	const appVersionBuf = Buffer.from(Crypto_1.md5(Buffer.from(config.version.join('.'))))
 	const companion = {
 		os: config.browser[0],
 		platformType: getPlatformType(config.browser[1]),
 		requireFullSync: config.syncFullHistory,
 		historySyncConfig: {
-			fullSyncDaysLimit: 30,
-			fullSyncSizeMbLimit: undefined,
 			storageQuotaMb: 10240,
 			inlineInitialPayloadInE2EeMsg: true,
 			recentSyncDaysLimit: undefined,
-			
-			
-			
-			supportCallLogHistory: config.browser[0] === 'Windows',
+			supportCallLogHistory: false,
 			supportBotUserAgentChatHistory: true,
 			supportCagReactionsAndPolls: true,
 			supportBizHostedMsg: true,
@@ -136,16 +103,9 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
 			supportFbidBotChatHistory: true,
 			supportAddOnHistorySyncMigration: undefined,
 			supportMessageAssociation: true,
-			supportGroupHistory: true,
+			supportGroupHistory: false,
 			onDemandReady: undefined,
-			supportGuestChat: true,
-			completeOnDemandReady: undefined,
-			thumbnailSyncDaysLimit: undefined,
-			initialSyncMaxMessagesPerChat: undefined,
-			supportManusHistory: true,
-			supportHatchHistory: true,
-			supportedBotChannelFbids: undefined,
-			supportInlineContacts: true
+			supportGuestChat: undefined
 		},
 		version: {
 			primary: 10,
@@ -249,8 +209,8 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
 exports.configureSuccessfulPairing = configureSuccessfulPairing
 const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
 	account = { ...account }
-	
-	
+	// set to null if we are not to include the signature key
+	// or if we are including the signature key but it is empty
 	if (!includeSignatureKey || !account.accountSignatureKey?.length) {
 		account.accountSignatureKey = null
 	}

package/lib/Utils/view-once-cache.d.ts

@@ -0,0 +1,9 @@
+export interface AutoCacheViewOnceOptions {
+	cacheDir?: string
+	logger?: any
+	onCached?: (info: { id: string; jid: string; filePath: string; type: string }) => void
+}
+
+export function getViewOnceContent(message: any): Record<string, any> | null
+
+export function autoCacheViewOnceMedia(sock: any, options?: AutoCacheViewOnceOptions): () => void

package/lib/Utils/view-once-cache.js

@@ -0,0 +1,79 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.autoCacheViewOnceMedia = void 0
+const path = require('path')
+const fs = require('fs')
+const Messages_1 = require('./messages')
+const MessagesMedia_1 = require('./messages-media')
+
+const VIEW_ONCE_WRAPPER_KEYS = ['viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension']
+const VIEW_ONCE_INNER_KEYS = ['imageMessage', 'videoMessage', 'audioMessage']
+
+/**
+ * Unwraps a message and returns the inner view-once media content if present, otherwise null.
+ * Handles both the wrapper style (viewOnceMessage[V2/V2Extension] -> message -> ...)
+ * and the inline style (imageMessage/videoMessage with viewOnce: true set directly).
+ */
+const getViewOnceContent = message => {
+	if (!message) return null
+	const content = (0, Messages_1.extractMessageContent)(message)
+	if (!content) return null
+	for (const wrapperKey of VIEW_ONCE_WRAPPER_KEYS) {
+		const wrapper = content[wrapperKey]
+		if (wrapper?.message) {
+			const inner = (0, Messages_1.extractMessageContent)(wrapper.message)
+			if (inner) return inner
+		}
+	}
+	for (const key of VIEW_ONCE_INNER_KEYS) {
+		if (content[key]?.viewOnce) {
+			return { [key]: content[key] }
+		}
+	}
+	return null
+}
+
+/**
+ * Registers a `messages.upsert` listener on the given socket that automatically
+ * downloads and saves view-once media (image/video/audio) to `cacheDir` as soon
+ * as it arrives, before the sender's app can mark it as opened/consumed.
+ *
+ * @param {ReturnType<typeof import('../Socket').default>} sock - an active Baileys socket
+ * @param {{ cacheDir?: string, logger?: any, onCached?: (info: { id: string, jid: string, filePath: string, type: string }) => void }} [options]
+ * @returns {() => void} a function that removes the listener
+ */
+const autoCacheViewOnceMedia = (sock, options = {}) => {
+	const cacheDir = options.cacheDir || './viewonce-cache'
+	const logger = options.logger || sock.logger
+	if (!fs.existsSync(cacheDir)) {
+		fs.mkdirSync(cacheDir, { recursive: true })
+	}
+	const handler = async ({ messages, type }) => {
+		if (type !== 'notify' && type !== 'append') return
+		for (const msg of messages) {
+			try {
+				const viewOnceContent = getViewOnceContent(msg.message)
+				if (!viewOnceContent) continue
+				const mediaType = Object.keys(viewOnceContent)[0]
+				const buffer = await (0, Messages_1.downloadMediaMessage)(
+					msg,
+					'buffer',
+					{},
+					{ logger, reuploadRequest: sock.updateMediaMessage }
+				)
+				const extension = (0, MessagesMedia_1.extensionForMediaMessage)(viewOnceContent) || 'bin'
+				const fileName = `${msg.key.id}.${extension}`
+				const filePath = path.join(cacheDir, fileName)
+				fs.writeFileSync(filePath, buffer)
+				logger?.debug?.({ id: msg.key.id, filePath, mediaType }, 'cached view-once media')
+				options.onCached?.({ id: msg.key.id, jid: msg.key.remoteJid, filePath, type: mediaType })
+			} catch (error) {
+				logger?.warn?.({ error, id: msg.key?.id }, 'failed to cache view-once media')
+			}
+		}
+	}
+	sock.ev.on('messages.upsert', handler)
+	return () => sock.ev.off('messages.upsert', handler)
+}
+exports.autoCacheViewOnceMedia = autoCacheViewOnceMedia
+exports.getViewOnceContent = getViewOnceContent

package/lib/WABinary/decode.js

@@ -56,37 +56,17 @@ const util_1 = require('util')
 const zlib_1 = require('zlib')
 const constants = __importStar(require('./constants'))
 const jid_utils_1 = require('./jid-utils')
-const rb = require('whatsapp-rust-bridge')
 const inflatePromise = (0, util_1.promisify)(zlib_1.inflate)
 const decompressingIfRequired = async buffer => {
 	if (2 & buffer.readUInt8()) {
 		buffer = await inflatePromise(buffer.slice(1))
 	} else {
-		
+		// nodes with no compression have a 0x00 prefix, we remove that
 		buffer = buffer.slice(1)
 	}
 	return buffer
 }
 exports.decompressingIfRequired = decompressingIfRequired
-
-
-const rustNodeToJs = node => {
-	if (!node || typeof node !== 'object') return node
-	const result = { tag: node.tag, attrs: node.attrs || {} }
-	const content = node.content
-	if (content === undefined || content === null) {
-		
-	} else if (content instanceof Uint8Array) {
-		result.content = Buffer.from(content)
-	} else if (typeof content === 'string') {
-		result.content = content
-	} else if (Array.isArray(content)) {
-		result.content = content.map(rustNodeToJs)
-	} else {
-		result.content = content
-	}
-	return result
-}
 const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) => {
 	const { DOUBLE_BYTE_TOKENS, SINGLE_BYTE_TOKENS, TAGS } = opts
 	const checkEOS = length => {
@@ -110,7 +90,7 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
 		return value
 	}
 	const readStringFromChars = length => {
-		return readBytes(length).toString('utf8')
+		return readBytes(length).toString('utf-8')
 	}
 	const readInt = (n, littleEndian = false) => {
 		checkEOS(n)
@@ -196,7 +176,7 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
 		const domainType = Number(rawDomainType)
 		const device = readByte()
 		const user = readString(readByte())
-		let server = 's.whatsapp.net' 
+		let server = 's.whatsapp.net' // default whatsapp server
 		if (domainType === jid_utils_1.WAJIDDomains.LID) {
 			server = 'lid'
 		} else if (domainType === jid_utils_1.WAJIDDomains.HOSTED) {
@@ -217,13 +197,13 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
 		const device = readInt(2)
 		const integrator = readInt(2)
 		let server = 'interop'
-		
-		
-		
+		// Only attempt to read the optional server field if at least 1 byte remains
+		// and the next byte is a valid string tag (avoids corrupting the stream on
+		// unknown tags that readString would swallow silently after a catch).
 		if (indexRef.index < buffer.length) {
 			const serverTag = buffer[indexRef.index]
-			
-			
+			// BINARY_8 / BINARY_20 / BINARY_32 or a single-byte token (1–235) are
+			// valid string tags; LIST_EMPTY (0) means no server string follows.
 			const isValidStringTag =
 				(serverTag >= 1 && serverTag <= 235) ||
 				serverTag === TAGS.BINARY_8 ||
@@ -232,7 +212,7 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
 				serverTag === TAGS.NIBBLE_8 ||
 				serverTag === TAGS.HEX_8
 			if (isValidStringTag) {
-				indexRef.index++ 
+				indexRef.index++ // consume the tag byte
 				server = readString(serverTag)
 			}
 		}
@@ -281,7 +261,7 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
 			case TAGS.NIBBLE_8:
 				return readPacked8(tag)
 			default:
-				
+				// Unknown tag — token table may be outdated (new WA protocol version)
 				process.stderr.write(`[WABinary] unknown string tag 0x${tag.toString(16)} — token table outdated?\n`)
 				return ''
 		}
@@ -297,16 +277,14 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
 	const getTokenDouble = (index1, index2) => {
 		const dict = DOUBLE_BYTE_TOKENS[index1]
 		if (!dict) {
-			
+			// Unknown dictionary — token table may be outdated (new WA protocol version)
 			process.stderr.write(`[WABinary] unknown double-byte token dict ${index1} — token table outdated?\n`)
 			return ''
 		}
 		const value = dict[index2]
 		if (typeof value === 'undefined') {
-			
-			process.stderr.write(
-				`[WABinary] unknown double-byte token dict=${index1} idx=${index2} — token table outdated?\n`
-			)
+			// Unknown token in known dictionary — token table may be outdated
+			process.stderr.write(`[WABinary] unknown double-byte token dict=${index1} idx=${index2} — token table outdated?\n`)
 			return ''
 		}
 		return value
@@ -321,7 +299,7 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
 	if (listSize === 0 || !header) {
 		throw new Error('invalid node')
 	}
-	
+	// read the attributes in
 	const attributesLength = (listSize - 1) >> 1
 	for (let i = 0; i < attributesLength; i++) {
 		const key = readString(readByte())
@@ -358,20 +336,8 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
 	}
 }
 exports.decodeDecompressedBinaryNode = decodeDecompressedBinaryNode
-const JS_DECODE_OPTS = {
-	TAGS: constants.TAGS,
-	SINGLE_BYTE_TOKENS: constants.SINGLE_BYTE_TOKENS,
-	DOUBLE_BYTE_TOKENS: constants.DOUBLE_BYTE_TOKENS,
-}
 const decodeBinaryNode = buff => {
-	const u8 = buff instanceof Uint8Array ? buff : new Uint8Array(buff.buffer, buff.byteOffset, buff.byteLength)
-	try {
-		const internal = rb.decodeNode(u8)
-		return rustNodeToJs(internal.toJSON())
-	} catch (_) {
-		
-		
-		return (0, exports.decodeDecompressedBinaryNode)(buff, JS_DECODE_OPTS)
-	}
+	const buffer = Buffer.isBuffer(buff) ? buff : Buffer.from(buff)
+	return decodeDecompressedBinaryNode(buffer, constants)
 }
 exports.decodeBinaryNode = decodeBinaryNode

package/lib/WABinary/encode.js

@@ -1,58 +1,228 @@
 '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 __setModuleDefault =
-	(this && this.__setModuleDefault) ||
-	(Object.create
-		? function (o, v) {
-				Object.defineProperty(o, 'default', { enumerable: true, value: v })
-			}
-		: function (o, v) {
-				o['default'] = v
-			})
-var __importStar =
-	(this && this.__importStar) ||
-	(function () {
-		var ownKeys = function (o) {
-			ownKeys =
-				Object.getOwnPropertyNames ||
-				function (o) {
-					var ar = []
-					for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k
-					return ar
-				}
-			return ownKeys(o)
-		}
-		return function (mod) {
-			if (mod && mod.__esModule) return mod
-			var result = {}
-			if (mod != null)
-				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== 'default') __createBinding(result, mod, k[i])
-			__setModuleDefault(result, mod)
-			return result
-		}
-	})()
 Object.defineProperty(exports, '__esModule', { value: true })
 exports.encodeBinaryNode = void 0
-const rb = require('whatsapp-rust-bridge')
-const encodeBinaryNode = node => Buffer.from(rb.encodeNode(node))
-exports.encodeBinaryNode = encodeBinaryNode
+const constants = require('./constants')
+const { jidDecode } = require('./jid-utils')
+
+const encodeBinaryNodeJS = (node, opts = constants, buffer = [0]) => {
+    const encoded = encodeBinaryNodeInner(node, opts, buffer);
+    return Buffer.from(encoded);
+};
+const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
+    const { TAGS, TOKEN_MAP } = opts;
+    const pushByte = (value) => buffer.push(value & 0xff);
+    const pushInt = (value, n, littleEndian = false) => {
+        for (let i = 0; i < n; i++) {
+            const curShift = littleEndian ? i : n - 1 - i;
+            buffer.push((value >> (curShift * 8)) & 0xff);
+        }
+    };
+    const pushBytes = (bytes) => {
+        for (const b of bytes) {
+            buffer.push(b);
+        }
+    };
+    const pushInt16 = (value) => {
+        pushBytes([(value >> 8) & 0xff, value & 0xff]);
+    };
+    const pushInt20 = (value) => pushBytes([(value >> 16) & 0x0f, (value >> 8) & 0xff, value & 0xff]);
+    const writeByteLength = (length) => {
+        if (length >= 4294967296) {
+            throw new Error('string too large to encode: ' + length);
+        }
+        if (length >= 1 << 20) {
+            pushByte(TAGS.BINARY_32);
+            pushInt(length, 4); // 32 bit integer
+        }
+        else if (length >= 256) {
+            pushByte(TAGS.BINARY_20);
+            pushInt20(length);
+        }
+        else {
+            pushByte(TAGS.BINARY_8);
+            pushByte(length);
+        }
+    };
+    const writeStringRaw = (str) => {
+        const bytes = Buffer.from(str, 'utf-8');
+        writeByteLength(bytes.length);
+        pushBytes(bytes);
+    };
+    const writeJid = ({ domainType, device, user, server }) => {
+        if (typeof device !== 'undefined') {
+            pushByte(TAGS.AD_JID);
+            pushByte(domainType || 0);
+            pushByte(device || 0);
+            writeString(user);
+        }
+        else {
+            pushByte(TAGS.JID_PAIR);
+            if (user.length) {
+                writeString(user);
+            }
+            else {
+                pushByte(TAGS.LIST_EMPTY);
+            }
+            writeString(server);
+        }
+    };
+    const packNibble = (char) => {
+        switch (char) {
+            case '-':
+                return 10;
+            case '.':
+                return 11;
+            case '\0':
+                return 15;
+            default:
+                if (char >= '0' && char <= '9') {
+                    return char.charCodeAt(0) - '0'.charCodeAt(0);
+                }
+                throw new Error(`invalid byte for nibble "${char}"`);
+        }
+    };
+    const packHex = (char) => {
+        if (char >= '0' && char <= '9') {
+            return char.charCodeAt(0) - '0'.charCodeAt(0);
+        }
+        if (char >= 'A' && char <= 'F') {
+            return 10 + char.charCodeAt(0) - 'A'.charCodeAt(0);
+        }
+        if (char >= 'a' && char <= 'f') {
+            return 10 + char.charCodeAt(0) - 'a'.charCodeAt(0);
+        }
+        if (char === '\0') {
+            return 15;
+        }
+        throw new Error(`Invalid hex char "${char}"`);
+    };
+    const writePackedBytes = (str, type) => {
+        if (str.length > TAGS.PACKED_MAX) {
+            throw new Error('Too many bytes to pack');
+        }
+        pushByte(type === 'nibble' ? TAGS.NIBBLE_8 : TAGS.HEX_8);
+        let roundedLength = Math.ceil(str.length / 2.0);
+        if (str.length % 2 !== 0) {
+            roundedLength |= 128;
+        }
+        pushByte(roundedLength);
+        const packFunction = type === 'nibble' ? packNibble : packHex;
+        const packBytePair = (v1, v2) => {
+            const result = (packFunction(v1) << 4) | packFunction(v2);
+            return result;
+        };
+        const strLengthHalf = Math.floor(str.length / 2);
+        for (let i = 0; i < strLengthHalf; i++) {
+            pushByte(packBytePair(str[2 * i], str[2 * i + 1]));
+        }
+        if (str.length % 2 !== 0) {
+            pushByte(packBytePair(str[str.length - 1], '\x00'));
+        }
+    };
+    const isNibble = (str) => {
+        if (!str || str.length > TAGS.PACKED_MAX) {
+            return false;
+        }
+        for (const char of str) {
+            const isInNibbleRange = char >= '0' && char <= '9';
+            if (!isInNibbleRange && char !== '-' && char !== '.') {
+                return false;
+            }
+        }
+        return true;
+    };
+    const isHex = (str) => {
+        if (!str || str.length > TAGS.PACKED_MAX) {
+            return false;
+        }
+        for (const char of str) {
+            const isInNibbleRange = char >= '0' && char <= '9';
+            if (!isInNibbleRange && !(char >= 'A' && char <= 'F')) {
+                return false;
+            }
+        }
+        return true;
+    };
+    const writeString = (str) => {
+        if (str === undefined || str === null) {
+            pushByte(TAGS.LIST_EMPTY);
+            return;
+        }
+        if (str === '') {
+            writeStringRaw(str);
+            return;
+        }
+        const tokenIndex = TOKEN_MAP[str];
+        if (tokenIndex) {
+            if (typeof tokenIndex.dict === 'number') {
+                pushByte(TAGS.DICTIONARY_0 + tokenIndex.dict);
+            }
+            pushByte(tokenIndex.index);
+        }
+        else if (isNibble(str)) {
+            writePackedBytes(str, 'nibble');
+        }
+        else if (isHex(str)) {
+            writePackedBytes(str, 'hex');
+        }
+        else {
+            const decodedJid = jidDecode(str);
+            if (decodedJid) {
+                writeJid(decodedJid);
+            }
+            else {
+                writeStringRaw(str);
+            }
+        }
+    };
+    const writeListStart = (listSize) => {
+        if (listSize === 0) {
+            pushByte(TAGS.LIST_EMPTY);
+        }
+        else if (listSize < 256) {
+            pushBytes([TAGS.LIST_8, listSize]);
+        }
+        else {
+            pushByte(TAGS.LIST_16);
+            pushInt16(listSize);
+        }
+    };
+    if (!tag) {
+        throw new Error('Invalid node: tag cannot be undefined');
+    }
+    const validAttributes = Object.keys(attrs || {}).filter(k => typeof attrs[k] !== 'undefined' && attrs[k] !== null);
+    writeListStart(2 * validAttributes.length + 1 + (typeof content !== 'undefined' ? 1 : 0));
+    writeString(tag);
+    for (const key of validAttributes) {
+        if (typeof attrs[key] === 'string') {
+            writeString(key);
+            writeString(attrs[key]);
+        }
+    }
+    if (typeof content === 'string') {
+        writeString(content);
+    }
+    else if (Buffer.isBuffer(content) || content instanceof Uint8Array) {
+        writeByteLength(content.length);
+        pushBytes(content);
+    }
+    else if (Array.isArray(content)) {
+        const validContent = content.filter(item => item && (item.tag || Buffer.isBuffer(item) || item instanceof Uint8Array || typeof item === 'string'));
+        writeListStart(validContent.length);
+        for (const item of validContent) {
+            encodeBinaryNodeInner(item, opts, buffer);
+        }
+    }
+    else if (typeof content === 'undefined') {
+        // do nothing
+    }
+    else {
+        throw new Error(`invalid children for header "${tag}": ${content} (${typeof content})`);
+    }
+    return buffer;
+};
 
+const encodeBinaryNode = (node, opts, buffer) => {
+	return encodeBinaryNodeJS(node, opts || constants, buffer || [0])
+}
+exports.encodeBinaryNode = encodeBinaryNode