@sixcore/baileys 1.0.0 → 1.0.2

package/src/WABinary/decode.ts

@@ -1,281 +0,0 @@
-import { promisify } from 'util'
-import { inflate } from 'zlib'
-import * as constants from './constants'
-import { jidEncode, type JidServer, WAJIDDomains } from './jid-utils'
-import type { BinaryNode, BinaryNodeCodingOptions } from './types'
-
-const inflatePromise = promisify(inflate)
-
-export const decompressingIfRequired = async (buffer: 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
-}
-
-export const decodeDecompressedBinaryNode = (
-	buffer: Buffer,
-	opts: Pick<BinaryNodeCodingOptions, 'DOUBLE_BYTE_TOKENS' | 'SINGLE_BYTE_TOKENS' | 'TAGS'>,
-	indexRef: { index: number } = { index: 0 }
-): BinaryNode => {
-	const { DOUBLE_BYTE_TOKENS, SINGLE_BYTE_TOKENS, TAGS } = opts
-
-	const checkEOS = (length: number) => {
-		if (indexRef.index + length > buffer.length) {
-			throw new Error('end of stream')
-		}
-	}
-
-	const next = () => {
-		const value = buffer[indexRef.index]
-		indexRef.index += 1
-		return value
-	}
-
-	const readByte = () => {
-		checkEOS(1)
-		return next()
-	}
-
-	const readBytes = (n: number) => {
-		checkEOS(n)
-		const value = buffer.slice(indexRef.index, indexRef.index + n)
-		indexRef.index += n
-		return value
-	}
-
-	const readStringFromChars = (length: number) => {
-		return readBytes(length).toString('utf-8')
-	}
-
-	const readInt = (n: number, littleEndian = false) => {
-		checkEOS(n)
-		let val = 0
-		for (let i = 0; i < n; i++) {
-			const shift = littleEndian ? i : n - 1 - i
-			val |= next()! << (shift * 8)
-		}
-
-		return val
-	}
-
-	const readInt20 = () => {
-		checkEOS(3)
-		return ((next()! & 15) << 16) + (next()! << 8) + next()!
-	}
-
-	const unpackHex = (value: number) => {
-		if (value >= 0 && value < 16) {
-			return value < 10 ? '0'.charCodeAt(0) + value : 'A'.charCodeAt(0) + value - 10
-		}
-
-		throw new Error('invalid hex: ' + value)
-	}
-
-	const unpackNibble = (value: number) => {
-		if (value >= 0 && value <= 9) {
-			return '0'.charCodeAt(0) + value
-		}
-
-		switch (value) {
-			case 10:
-				return '-'.charCodeAt(0)
-			case 11:
-				return '.'.charCodeAt(0)
-			case 15:
-				return '\0'.charCodeAt(0)
-			default:
-				throw new Error('invalid nibble: ' + value)
-		}
-	}
-
-	const unpackByte = (tag: number, value: number) => {
-		if (tag === TAGS.NIBBLE_8) {
-			return unpackNibble(value)
-		} else if (tag === TAGS.HEX_8) {
-			return unpackHex(value)
-		} else {
-			throw new Error('unknown tag: ' + tag)
-		}
-	}
-
-	const readPacked8 = (tag: number) => {
-		const startByte = readByte()!
-		let value = ''
-
-		for (let i = 0; i < (startByte & 127); i++) {
-			const curByte = readByte()!
-
-			value += String.fromCharCode(unpackByte(tag, (curByte & 0xf0) >> 4))
-			value += String.fromCharCode(unpackByte(tag, curByte & 0x0f))
-		}
-
-		if (startByte >> 7 !== 0) {
-			value = value.slice(0, -1)
-		}
-
-		return value
-	}
-
-	const isListTag = (tag: number) => {
-		return tag === TAGS.LIST_EMPTY || tag === TAGS.LIST_8 || tag === TAGS.LIST_16
-	}
-
-	const readListSize = (tag: number) => {
-		switch (tag) {
-			case TAGS.LIST_EMPTY:
-				return 0
-			case TAGS.LIST_8:
-				return readByte()
-			case TAGS.LIST_16:
-				return readInt(2)
-			default:
-				throw new Error('invalid tag for list size: ' + tag)
-		}
-	}
-
-	const readJidPair = () => {
-		const i = readString(readByte()!)
-		const j = readString(readByte()!)
-		if (j) {
-			return (i || '') + '@' + j
-		}
-
-		throw new Error('invalid jid pair: ' + i + ', ' + j)
-	}
-
-	const readAdJid = () => {
-		const rawDomainType = readByte()
-		const domainType = Number(rawDomainType)
-
-		const device = readByte()
-		const user = readString(readByte()!)
-
-		let server: JidServer = 's.whatsapp.net' // default whatsapp server
-		if (domainType === WAJIDDomains.LID) {
-			server = 'lid'
-		} else if (domainType === WAJIDDomains.HOSTED) {
-			server = 'hosted'
-		} else if (domainType === WAJIDDomains.HOSTED_LID) {
-			server = 'hosted.lid'
-		}
-
-		return jidEncode(user, server, device)
-	}
-
-	const readString = (tag: number): string => {
-		if (tag >= 1 && tag < SINGLE_BYTE_TOKENS.length) {
-			return SINGLE_BYTE_TOKENS[tag] || ''
-		}
-
-		switch (tag) {
-			case TAGS.DICTIONARY_0:
-			case TAGS.DICTIONARY_1:
-			case TAGS.DICTIONARY_2:
-			case TAGS.DICTIONARY_3:
-				return getTokenDouble(tag - TAGS.DICTIONARY_0, readByte()!)
-			case TAGS.LIST_EMPTY:
-				return ''
-			case TAGS.BINARY_8:
-				return readStringFromChars(readByte()!)
-			case TAGS.BINARY_20:
-				return readStringFromChars(readInt20())
-			case TAGS.BINARY_32:
-				return readStringFromChars(readInt(4))
-			case TAGS.JID_PAIR:
-				return readJidPair()
-			case TAGS.AD_JID:
-				return readAdJid()
-			case TAGS.HEX_8:
-			case TAGS.NIBBLE_8:
-				return readPacked8(tag)
-			default:
-				throw new Error('invalid string with tag: ' + tag)
-		}
-	}
-
-	const readList = (tag: number) => {
-		const items: BinaryNode[] = []
-		const size = readListSize(tag)!
-		for (let i = 0; i < size; i++) {
-			items.push(decodeDecompressedBinaryNode(buffer, opts, indexRef))
-		}
-
-		return items
-	}
-
-	const getTokenDouble = (index1: number, index2: number) => {
-		const dict = DOUBLE_BYTE_TOKENS[index1]
-		if (!dict) {
-			throw new Error(`Invalid double token dict (${index1})`)
-		}
-
-		const value = dict[index2]
-		if (typeof value === 'undefined') {
-			throw new Error(`Invalid double token (${index2})`)
-		}
-
-		return value
-	}
-
-	const listSize = readListSize(readByte()!)
-	const header = readString(readByte()!)
-	if (!listSize || !header.length) {
-		throw new Error('invalid node')
-	}
-
-	const attrs: BinaryNode['attrs'] = {}
-	let data: BinaryNode['content']
-	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()!)
-		const value = readString(readByte()!)
-
-		attrs[key] = value
-	}
-
-	if (listSize % 2 === 0) {
-		const tag = readByte()!
-		if (isListTag(tag)) {
-			data = readList(tag)
-		} else {
-			let decoded: Buffer | string
-			switch (tag) {
-				case TAGS.BINARY_8:
-					decoded = readBytes(readByte()!)
-					break
-				case TAGS.BINARY_20:
-					decoded = readBytes(readInt20())
-					break
-				case TAGS.BINARY_32:
-					decoded = readBytes(readInt(4))
-					break
-				default:
-					decoded = readString(tag)
-					break
-			}
-
-			data = decoded
-		}
-	}
-
-	return {
-		tag: header,
-		attrs,
-		content: data
-	}
-}
-
-export const decodeBinaryNode = async (buff: Buffer): Promise<BinaryNode> => {
-	const decompBuff = await decompressingIfRequired(buff)
-	return decodeDecompressedBinaryNode(decompBuff, constants)
-}

package/src/WABinary/encode.ts

@@ -1,253 +0,0 @@
-import * as constants from './constants'
-import { type FullJid, jidDecode } from './jid-utils'
-import type { BinaryNode, BinaryNodeCodingOptions } from './types'
-
-export const encodeBinaryNode = (
-	node: BinaryNode,
-	opts: Pick<BinaryNodeCodingOptions, 'TAGS' | 'TOKEN_MAP'> = constants,
-	buffer: number[] = [0]
-): Buffer => {
-	const encoded = encodeBinaryNodeInner(node, opts, buffer)
-	return Buffer.from(encoded)
-}
-
-const encodeBinaryNodeInner = (
-	{ tag, attrs, content }: BinaryNode,
-	opts: Pick<BinaryNodeCodingOptions, 'TAGS' | 'TOKEN_MAP'>,
-	buffer: number[]
-): number[] => {
-	const { TAGS, TOKEN_MAP } = opts
-
-	const pushByte = (value: number) => buffer.push(value & 0xff)
-
-	const pushInt = (value: number, n: number, 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: Uint8Array | Buffer | number[]) => {
-		for (const b of bytes) {
-			buffer.push(b)
-		}
-	}
-
-	const pushInt16 = (value: number) => {
-		pushBytes([(value >> 8) & 0xff, value & 0xff])
-	}
-
-	const pushInt20 = (value: number) => pushBytes([(value >> 16) & 0x0f, (value >> 8) & 0xff, value & 0xff])
-	const writeByteLength = (length: number) => {
-		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: string) => {
-		const bytes = Buffer.from(str, 'utf-8')
-		writeByteLength(bytes.length)
-		pushBytes(bytes)
-	}
-
-	const writeJid = ({ domainType, device, user, server }: FullJid) => {
-		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: string) => {
-		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: string) => {
-		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: string, type: 'nibble' | 'hex') => {
-		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: string, v2: string) => {
-			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?: string) => {
-		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?: string) => {
-		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?: string) => {
-		if (str === undefined || str === null) {
-			pushByte(TAGS.LIST_EMPTY)
-			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 if (str) {
-			const decodedJid = jidDecode(str)
-			if (decodedJid) {
-				writeJid(decodedJid)
-			} else {
-				writeStringRaw(str)
-			}
-		}
-	}
-
-	const writeListStart = (listSize: number) => {
-		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
-}

package/src/WABinary/generic-utils.ts

@@ -1,127 +0,0 @@
-import { Boom } from '@hapi/boom'
-import { proto } from '../../WAProto/index.js'
-import { type BinaryNode } from './types'
-
-// some extra useful utilities
-
-export const getBinaryNodeChildren = (node: BinaryNode | undefined, childTag: string) => {
-	if (Array.isArray(node?.content)) {
-		return node.content.filter(item => item.tag === childTag)
-	}
-
-	return []
-}
-
-export const getAllBinaryNodeChildren = ({ content }: BinaryNode) => {
-	if (Array.isArray(content)) {
-		return content
-	}
-
-	return []
-}
-
-export const getBinaryNodeChild = (node: BinaryNode | undefined, childTag: string) => {
-	if (Array.isArray(node?.content)) {
-		return node?.content.find(item => item.tag === childTag)
-	}
-}
-
-export const getBinaryNodeChildBuffer = (node: BinaryNode | undefined, childTag: string) => {
-	const child = getBinaryNodeChild(node, childTag)?.content
-	if (Buffer.isBuffer(child) || child instanceof Uint8Array) {
-		return child
-	}
-}
-
-export const getBinaryNodeChildString = (node: BinaryNode | undefined, childTag: string) => {
-	const child = getBinaryNodeChild(node, childTag)?.content
-	if (Buffer.isBuffer(child) || child instanceof Uint8Array) {
-		return Buffer.from(child).toString('utf-8')
-	} else if (typeof child === 'string') {
-		return child
-	}
-}
-
-export const getBinaryNodeChildUInt = (node: BinaryNode, childTag: string, length: number) => {
-	const buff = getBinaryNodeChildBuffer(node, childTag)
-	if (buff) {
-		return bufferToUInt(buff, length)
-	}
-}
-
-export const assertNodeErrorFree = (node: BinaryNode) => {
-	const errNode = getBinaryNodeChild(node, 'error')
-	if (errNode) {
-		throw new Boom(errNode.attrs.text || 'Unknown error', { data: +errNode.attrs.code! })
-	}
-}
-
-export const reduceBinaryNodeToDictionary = (node: BinaryNode, tag: string) => {
-	const nodes = getBinaryNodeChildren(node, tag)
-	const dict = nodes.reduce(
-		(dict, { attrs }) => {
-			if (typeof attrs.name === 'string') {
-				dict[attrs.name] = attrs.value! || attrs.config_value!
-			} else {
-				dict[attrs.config_code!] = attrs.value! || attrs.config_value!
-			}
-
-			return dict
-		},
-		{} as { [_: string]: string }
-	)
-	return dict
-}
-
-export const getBinaryNodeMessages = ({ content }: BinaryNode) => {
-	const msgs: proto.WebMessageInfo[] = []
-	if (Array.isArray(content)) {
-		for (const item of content) {
-			if (item.tag === 'message') {
-				msgs.push(proto.WebMessageInfo.decode(item.content as Buffer).toJSON() as proto.WebMessageInfo)
-			}
-		}
-	}
-
-	return msgs
-}
-
-function bufferToUInt(e: Uint8Array | Buffer, t: number) {
-	let a = 0
-	for (let i = 0; i < t; i++) {
-		a = 256 * a + e[i]!
-	}
-
-	return a
-}
-
-const tabs = (n: number) => '\t'.repeat(n)
-
-export function binaryNodeToString(node: BinaryNode | BinaryNode['content'], i = 0): string {
-	if (!node) {
-		return node!
-	}
-
-	if (typeof node === 'string') {
-		return tabs(i) + node
-	}
-
-	if (node instanceof Uint8Array) {
-		return tabs(i) + Buffer.from(node).toString('hex')
-	}
-
-	if (Array.isArray(node)) {
-		return node.map(x => tabs(i + 1) + binaryNodeToString(x, i + 1)).join('\n')
-	}
-
-	const children = binaryNodeToString(node.content, i + 1)
-
-	const tag = `<${node.tag} ${Object.entries(node.attrs || {})
-		.filter(([, v]) => v !== undefined)
-		.map(([k, v]) => `${k}='${v}'`)
-		.join(' ')}`
-
-	const content: string = children ? `>\n${children}\n${tabs(i)}</${node.tag}>` : '/>'
-
-	return tag + content
-}

package/src/WABinary/index.ts

@@ -1,5 +0,0 @@
-export * from './encode'
-export * from './decode'
-export * from './generic-utils'
-export * from './jid-utils'
-export * from './types'