zapo-js 0.1.0

package/dist/esm/transport/binary/decoder.js

@@ -0,0 +1,275 @@
+import { promisify } from 'node:util';
+import { inflateRaw, unzip } from 'node:zlib';
+import { WA_DEFAULTS } from '../../protocol/constants.js';
+import { BINARY_20, BINARY_32, BINARY_8, DICTIONARY_0, DICTIONARY_3, HEX_8, HEX_ALPHABET, JID_FB, JID_INTEROP, JID_PAIR, JID_U, LIST_16, LIST_8, LIST_EMPTY, NIBBLE_8, NIBBLE_ALPHABET, STREAM_END } from '../binary/constants.js';
+import { DICTIONARIES, SINGLE_BYTE_TOKENS } from '../binary/tokens.js';
+import { TEXT_DECODER, TEXT_ENCODER, toBytesView } from '../../util/bytes.js';
+const unzipAsync = promisify(unzip);
+const inflateRawAsync = promisify(inflateRaw);
+const JID_U_DOMAIN_TYPE_LID = 0x01;
+const JID_U_DOMAIN_TYPE_HOSTED_LID = 0x81;
+const JID_U_DOMAIN_TYPE_HOSTED_MASK = 0x80;
+const JID_U_DOMAIN_TYPE_LID_MASK = 0x01;
+const JID_U_DOMAIN_LID = 'lid';
+const JID_U_DOMAIN_HOSTED = 'hosted';
+const JID_U_DOMAIN_HOSTED_LID = 'hosted.lid';
+class ByteReader {
+    constructor(data) {
+        this.data = data;
+        this.offset = 0;
+    }
+    readUint8() {
+        this.ensure(1);
+        const value = this.data[this.offset];
+        this.offset += 1;
+        return value;
+    }
+    readUint16() {
+        this.ensure(2);
+        const value = (this.data[this.offset] << 8) | this.data[this.offset + 1];
+        this.offset += 2;
+        return value;
+    }
+    readUint32() {
+        this.ensure(4);
+        const value = (this.data[this.offset] << 24) |
+            (this.data[this.offset + 1] << 16) |
+            (this.data[this.offset + 2] << 8) |
+            this.data[this.offset + 3];
+        this.offset += 4;
+        return value >>> 0;
+    }
+    readBytes(length) {
+        this.ensure(length);
+        const value = this.data.subarray(this.offset, this.offset + length);
+        this.offset += length;
+        return value;
+    }
+    getRemaining() {
+        return this.data.length - this.offset;
+    }
+    ensure(length) {
+        if (this.offset + length > this.data.length) {
+            throw new Error('unexpected end of binary node payload');
+        }
+    }
+}
+function parsePacked(reader, alphabet) {
+    const lengthByte = reader.readUint8();
+    const odd = (lengthByte & 0x80) !== 0;
+    const byteCount = lengthByte & 0x7f;
+    const outLength = byteCount * 2 - (odd ? 1 : 0);
+    const chars = new Array(outLength);
+    let outIndex = 0;
+    for (let i = 0; i < byteCount; i += 1) {
+        const packed = reader.readUint8();
+        const high = (packed >>> 4) & 0x0f;
+        const low = packed & 0x0f;
+        if (outIndex < outLength) {
+            chars[outIndex] = alphabet[high];
+            outIndex += 1;
+        }
+        if (outIndex < outLength) {
+            chars[outIndex] = alphabet[low];
+            outIndex += 1;
+        }
+    }
+    return chars.join('');
+}
+function readBinary(reader, token) {
+    if (token === BINARY_8) {
+        return reader.readBytes(reader.readUint8());
+    }
+    if (token === BINARY_20) {
+        const length = ((reader.readUint8() & 0x0f) << 16) | (reader.readUint8() << 8) | reader.readUint8();
+        return reader.readBytes(length);
+    }
+    if (token === BINARY_32) {
+        return reader.readBytes(reader.readUint32());
+    }
+    throw new Error(`invalid binary token ${token}`);
+}
+function decodeTokenString(token, reader) {
+    if (token > 0 && token <= SINGLE_BYTE_TOKENS.length) {
+        return SINGLE_BYTE_TOKENS[token - 1];
+    }
+    if (token >= DICTIONARY_0 && token <= DICTIONARY_3) {
+        const dictionaryIndex = token - DICTIONARY_0;
+        const index = reader.readUint8();
+        const dictionary = DICTIONARIES[dictionaryIndex];
+        if (!dictionary || index >= dictionary.length) {
+            throw new Error(`invalid dictionary token ${dictionaryIndex}:${index}`);
+        }
+        return dictionary[index];
+    }
+    if (token === NIBBLE_8) {
+        return parsePacked(reader, NIBBLE_ALPHABET);
+    }
+    if (token === HEX_8) {
+        return parsePacked(reader, HEX_ALPHABET);
+    }
+    if (token === BINARY_8 || token === BINARY_20 || token === BINARY_32) {
+        return TEXT_DECODER.decode(readBinary(reader, token));
+    }
+    throw new Error(`unsupported string token ${token}`);
+}
+function decodeJidPair(reader) {
+    const userToken = reader.readUint8();
+    const user = userToken === LIST_EMPTY ? '' : decodeTokenString(userToken, reader);
+    const server = decodeTokenString(reader.readUint8(), reader);
+    if (!user) {
+        return server;
+    }
+    return `${user}@${server}`;
+}
+function decodeJidU(reader) {
+    const domainType = reader.readUint8();
+    const device = reader.readUint8();
+    const user = decodeTokenString(reader.readUint8(), reader);
+    let domain = WA_DEFAULTS.HOST_DOMAIN;
+    if (domainType === JID_U_DOMAIN_TYPE_LID) {
+        domain = JID_U_DOMAIN_LID;
+    }
+    else if (domainType === JID_U_DOMAIN_TYPE_HOSTED_LID) {
+        domain = JID_U_DOMAIN_HOSTED_LID;
+    }
+    else if ((domainType & JID_U_DOMAIN_TYPE_HOSTED_MASK) !== 0 &&
+        (domainType & JID_U_DOMAIN_TYPE_LID_MASK) === 0) {
+        domain = JID_U_DOMAIN_HOSTED;
+    }
+    if (device > 0) {
+        return `${user}:${device}@${domain}`;
+    }
+    return `${user}@${domain}`;
+}
+function decodeJidInterop(reader) {
+    const user = decodeTokenString(reader.readUint8(), reader);
+    const device = reader.readUint16();
+    const integrator = reader.readUint16();
+    decodeTokenString(reader.readUint8(), reader);
+    return `${integrator}-${user}:${device}@interop`;
+}
+function decodeJidFb(reader) {
+    const user = decodeTokenString(reader.readUint8(), reader);
+    const device = reader.readUint16();
+    decodeTokenString(reader.readUint8(), reader);
+    return `${user}:${device}@msgr`;
+}
+function decodeValue(reader, token, forAttr) {
+    if (token === LIST_EMPTY) {
+        return null;
+    }
+    if (token === JID_PAIR) {
+        return decodeJidPair(reader);
+    }
+    if (token === JID_U) {
+        return decodeJidU(reader);
+    }
+    if (token === JID_INTEROP) {
+        return decodeJidInterop(reader);
+    }
+    if (token === JID_FB) {
+        return decodeJidFb(reader);
+    }
+    if (token === BINARY_8 || token === BINARY_20 || token === BINARY_32) {
+        const binary = readBinary(reader, token);
+        return forAttr ? TEXT_DECODER.decode(binary) : binary;
+    }
+    const value = decodeTokenString(token, reader);
+    return value;
+}
+function decodeNodeInternal(reader) {
+    const listType = reader.readUint8();
+    let listSize = 0;
+    if (listType === LIST_8) {
+        listSize = reader.readUint8();
+    }
+    else if (listType === LIST_16) {
+        listSize = reader.readUint16();
+    }
+    else {
+        throw new Error(`invalid node list type ${listType}`);
+    }
+    if (listSize === 0) {
+        throw new Error('invalid binary node: empty list');
+    }
+    const tagToken = reader.readUint8();
+    const tagValue = decodeValue(reader, tagToken, true);
+    if (typeof tagValue !== 'string' || tagValue.length === 0) {
+        throw new Error('invalid binary node tag');
+    }
+    const attrs = {};
+    let remaining = listSize - 1;
+    while (remaining > 1) {
+        const keyToken = reader.readUint8();
+        const key = decodeValue(reader, keyToken, true);
+        const valueToken = reader.readUint8();
+        const value = decodeValue(reader, valueToken, true);
+        if (typeof key !== 'string' || typeof value !== 'string') {
+            throw new Error('invalid binary node attribute entry');
+        }
+        attrs[key] = value;
+        remaining -= 2;
+    }
+    let content;
+    if (remaining === 1) {
+        const contentToken = reader.readUint8();
+        if (contentToken === LIST_EMPTY) {
+            content = undefined;
+        }
+        else if (contentToken === LIST_8 || contentToken === LIST_16) {
+            const childrenCount = contentToken === LIST_8 ? reader.readUint8() : reader.readUint16();
+            const children = new Array(childrenCount);
+            for (let i = 0; i < childrenCount; i += 1) {
+                children[i] = decodeNodeInternal(reader);
+            }
+            content = children;
+        }
+        else {
+            const value = decodeValue(reader, contentToken, false);
+            if (value === null) {
+                content = undefined;
+            }
+            else if (typeof value === 'string') {
+                content = TEXT_ENCODER.encode(value);
+            }
+            else {
+                content = value;
+            }
+        }
+    }
+    if (content === null || content === undefined) {
+        return { tag: tagValue, attrs };
+    }
+    return { tag: tagValue, attrs, content };
+}
+export function decodeBinaryNode(data) {
+    const reader = new ByteReader(data);
+    return decodeNodeInternal(reader);
+}
+async function inflateCompressedStanza(data) {
+    try {
+        return toBytesView(await unzipAsync(data));
+    }
+    catch {
+        try {
+            return toBytesView(await inflateRawAsync(data));
+        }
+        catch (rawError) {
+            const message = rawError instanceof Error ? rawError.message : String(rawError);
+            throw new Error(`failed to inflate compressed stanza: ${message}`);
+        }
+    }
+}
+export async function decodeBinaryNodeStanza(stanza) {
+    const reader = new ByteReader(stanza);
+    const flag = reader.readUint8();
+    if (flag === STREAM_END && reader.getRemaining() === 0) {
+        throw new Error('stream end stanza is not a binary node');
+    }
+    let nodeBytes = reader.readBytes(reader.getRemaining());
+    if ((flag & 0x02) !== 0) {
+        nodeBytes = await inflateCompressedStanza(nodeBytes);
+    }
+    return decodeBinaryNode(nodeBytes);
+}

package/dist/esm/transport/binary/encoder.js

@@ -0,0 +1,210 @@
+import { BINARY_20, BINARY_32, BINARY_8, DICTIONARY_0, DICTIONARY_TOKEN_MAPS, HEX_8, LIST_16, LIST_8, NIBBLE_8, SINGLE_BYTE_TOKEN_MAP } from '../binary/constants.js';
+import { TEXT_ENCODER } from '../../util/bytes.js';
+class ByteWriter {
+    constructor(initialCapacity = 256) {
+        this.buffer = new Uint8Array(initialCapacity);
+        this.offset = 0;
+    }
+    writeUint8(value) {
+        this.ensure(1);
+        this.buffer[this.offset] = value & 0xff;
+        this.offset += 1;
+    }
+    writeUint16(value) {
+        this.ensure(2);
+        this.buffer[this.offset] = (value >>> 8) & 0xff;
+        this.buffer[this.offset + 1] = value & 0xff;
+        this.offset += 2;
+    }
+    writeUint32(value) {
+        this.ensure(4);
+        this.buffer[this.offset] = (value >>> 24) & 0xff;
+        this.buffer[this.offset + 1] = (value >>> 16) & 0xff;
+        this.buffer[this.offset + 2] = (value >>> 8) & 0xff;
+        this.buffer[this.offset + 3] = value & 0xff;
+        this.offset += 4;
+    }
+    writeBytes(value) {
+        this.ensure(value.length);
+        this.buffer.set(value, this.offset);
+        this.offset += value.length;
+    }
+    toUint8Array() {
+        return this.buffer.subarray(0, this.offset);
+    }
+    ensure(extra) {
+        const needed = this.offset + extra;
+        if (needed <= this.buffer.length) {
+            return;
+        }
+        let size = this.buffer.length;
+        while (size < needed) {
+            size *= 2;
+        }
+        const next = new Uint8Array(size);
+        next.set(this.buffer);
+        this.buffer = next;
+    }
+}
+function isNibbleString(value) {
+    for (let i = 0; i < value.length; i += 1) {
+        const code = value.charCodeAt(i);
+        const isDigit = code >= 48 && code <= 57;
+        const isSpecial = code === 45 || code === 46;
+        if (!isDigit && !isSpecial) {
+            return false;
+        }
+    }
+    return value.length > 0;
+}
+function isHexString(value) {
+    for (let i = 0; i < value.length; i += 1) {
+        const code = value.charCodeAt(i);
+        const isDigit = code >= 48 && code <= 57;
+        const isHex = code >= 65 && code <= 70;
+        if (!isDigit && !isHex) {
+            return false;
+        }
+    }
+    return value.length > 0;
+}
+function toNibble(value, index, packedType) {
+    const code = value.charCodeAt(index);
+    if (code >= 48 && code <= 57) {
+        return code - 48;
+    }
+    if (packedType === NIBBLE_8) {
+        if (code === 45) {
+            return 10;
+        }
+        if (code === 46) {
+            return 11;
+        }
+    }
+    if (packedType === HEX_8 && code >= 65 && code <= 70) {
+        return code - 55;
+    }
+    throw new Error(`cannot nibble encode char code ${code}`);
+}
+function writePackedString(value, packedType, writer) {
+    const odd = value.length % 2 === 1;
+    writer.writeUint8(packedType);
+    let length = Math.ceil(value.length / 2);
+    if (odd) {
+        length |= 0x80;
+    }
+    writer.writeUint8(length);
+    for (let i = 0; i < value.length; i += 2) {
+        const high = toNibble(value, i, packedType);
+        let low = 0x0f;
+        if (i + 1 < value.length) {
+            low = toNibble(value, i + 1, packedType);
+        }
+        writer.writeUint8((high << 4) | low);
+    }
+}
+function writeBinaryLength(length, writer) {
+    if (!Number.isSafeInteger(length) || length < 0) {
+        throw new Error(`invalid binary length ${length}`);
+    }
+    if (length < 256) {
+        writer.writeUint8(BINARY_8);
+        writer.writeUint8(length);
+        return;
+    }
+    if (length < 1 << 20) {
+        writer.writeUint8(BINARY_20);
+        writer.writeUint8((length >>> 16) & 0xff);
+        writer.writeUint8((length >>> 8) & 0xff);
+        writer.writeUint8(length & 0xff);
+        return;
+    }
+    if (!(length < 4294967296)) {
+        throw new Error(`binary with length ${length} is too big for WAP protocol`);
+    }
+    writer.writeUint8(BINARY_32);
+    writer.writeUint32(length);
+}
+function writeString(value, writer) {
+    const singleToken = SINGLE_BYTE_TOKEN_MAP.get(value);
+    if (singleToken !== undefined) {
+        writer.writeUint8(singleToken);
+        return;
+    }
+    for (let dictionaryIndex = 0; dictionaryIndex < DICTIONARY_TOKEN_MAPS.length; dictionaryIndex += 1) {
+        const dictToken = DICTIONARY_TOKEN_MAPS[dictionaryIndex].get(value);
+        if (dictToken !== undefined) {
+            writer.writeUint8(DICTIONARY_0 + dictionaryIndex);
+            writer.writeUint8(dictToken);
+            return;
+        }
+    }
+    if (value.length < 128 && isNibbleString(value)) {
+        writePackedString(value, NIBBLE_8, writer);
+        return;
+    }
+    if (value.length < 128 && isHexString(value)) {
+        writePackedString(value, HEX_8, writer);
+        return;
+    }
+    const encoded = TEXT_ENCODER.encode(value);
+    writeBinaryLength(encoded.length, writer);
+    writer.writeBytes(encoded);
+}
+function writeListSize(size, writer) {
+    if (!Number.isSafeInteger(size) || size < 0) {
+        throw new Error(`invalid list size ${size}`);
+    }
+    if (size < 256) {
+        writer.writeUint8(LIST_8);
+        writer.writeUint8(size);
+        return;
+    }
+    if (!(size < 1 << 16)) {
+        throw new Error(`list with size ${size} is too large for WAP protocol`);
+    }
+    writer.writeUint8(LIST_16);
+    writer.writeUint16(size);
+}
+function writeNodeInternal(node, writer) {
+    const attrs = Object.entries(node.attrs);
+    const hasContent = node.content !== null && node.content !== undefined;
+    const listSize = 1 + attrs.length * 2 + (hasContent ? 1 : 0);
+    writeListSize(listSize, writer);
+    writeString(node.tag, writer);
+    for (const [key, value] of attrs) {
+        writeString(key, writer);
+        writeString(value, writer);
+    }
+    if (!hasContent) {
+        return;
+    }
+    const content = node.content;
+    if (typeof content === 'string') {
+        const encoded = TEXT_ENCODER.encode(content);
+        writeBinaryLength(encoded.length, writer);
+        writer.writeBytes(encoded);
+        return;
+    }
+    if (content instanceof Uint8Array) {
+        writeBinaryLength(content.length, writer);
+        writer.writeBytes(content);
+        return;
+    }
+    writeListSize(content.length, writer);
+    for (const child of content) {
+        writeNodeInternal(child, writer);
+    }
+}
+export function encodeBinaryNode(node) {
+    const writer = new ByteWriter();
+    writeNodeInternal(node, writer);
+    return writer.toUint8Array();
+}
+export function encodeBinaryNodeStanza(node) {
+    const encoded = encodeBinaryNode(node);
+    const out = new Uint8Array(1 + encoded.length);
+    out[0] = 0;
+    out.set(encoded, 1);
+    return out;
+}

package/dist/esm/transport/binary/index.js

@@ -0,0 +1,4 @@
+export * from '../binary/tokens.js';
+export * from '../binary/encoder.js';
+export * from '../binary/decoder.js';
+export { WAP_DECODE_CONSTANTS as WapDecodeConstants, WAP_ENCODE_CONSTANTS as WapEncodeConstants } from '../binary/constants.js';