zapo-js 0.1.0

package/dist/transport/binary/decoder.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBinaryNode = decodeBinaryNode;
+exports.decodeBinaryNodeStanza = decodeBinaryNodeStanza;
+const node_util_1 = require("node:util");
+const node_zlib_1 = require("node:zlib");
+const constants_1 = require("../../protocol/constants");
+const constants_2 = require("../binary/constants");
+const tokens_1 = require("../binary/tokens");
+const bytes_1 = require("../../util/bytes");
+const unzipAsync = (0, node_util_1.promisify)(node_zlib_1.unzip);
+const inflateRawAsync = (0, node_util_1.promisify)(node_zlib_1.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 === constants_2.BINARY_8) {
+        return reader.readBytes(reader.readUint8());
+    }
+    if (token === constants_2.BINARY_20) {
+        const length = ((reader.readUint8() & 0x0f) << 16) | (reader.readUint8() << 8) | reader.readUint8();
+        return reader.readBytes(length);
+    }
+    if (token === constants_2.BINARY_32) {
+        return reader.readBytes(reader.readUint32());
+    }
+    throw new Error(`invalid binary token ${token}`);
+}
+function decodeTokenString(token, reader) {
+    if (token > 0 && token <= tokens_1.SINGLE_BYTE_TOKENS.length) {
+        return tokens_1.SINGLE_BYTE_TOKENS[token - 1];
+    }
+    if (token >= constants_2.DICTIONARY_0 && token <= constants_2.DICTIONARY_3) {
+        const dictionaryIndex = token - constants_2.DICTIONARY_0;
+        const index = reader.readUint8();
+        const dictionary = tokens_1.DICTIONARIES[dictionaryIndex];
+        if (!dictionary || index >= dictionary.length) {
+            throw new Error(`invalid dictionary token ${dictionaryIndex}:${index}`);
+        }
+        return dictionary[index];
+    }
+    if (token === constants_2.NIBBLE_8) {
+        return parsePacked(reader, constants_2.NIBBLE_ALPHABET);
+    }
+    if (token === constants_2.HEX_8) {
+        return parsePacked(reader, constants_2.HEX_ALPHABET);
+    }
+    if (token === constants_2.BINARY_8 || token === constants_2.BINARY_20 || token === constants_2.BINARY_32) {
+        return bytes_1.TEXT_DECODER.decode(readBinary(reader, token));
+    }
+    throw new Error(`unsupported string token ${token}`);
+}
+function decodeJidPair(reader) {
+    const userToken = reader.readUint8();
+    const user = userToken === constants_2.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 = constants_1.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 === constants_2.LIST_EMPTY) {
+        return null;
+    }
+    if (token === constants_2.JID_PAIR) {
+        return decodeJidPair(reader);
+    }
+    if (token === constants_2.JID_U) {
+        return decodeJidU(reader);
+    }
+    if (token === constants_2.JID_INTEROP) {
+        return decodeJidInterop(reader);
+    }
+    if (token === constants_2.JID_FB) {
+        return decodeJidFb(reader);
+    }
+    if (token === constants_2.BINARY_8 || token === constants_2.BINARY_20 || token === constants_2.BINARY_32) {
+        const binary = readBinary(reader, token);
+        return forAttr ? bytes_1.TEXT_DECODER.decode(binary) : binary;
+    }
+    const value = decodeTokenString(token, reader);
+    return value;
+}
+function decodeNodeInternal(reader) {
+    const listType = reader.readUint8();
+    let listSize = 0;
+    if (listType === constants_2.LIST_8) {
+        listSize = reader.readUint8();
+    }
+    else if (listType === constants_2.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 === constants_2.LIST_EMPTY) {
+            content = undefined;
+        }
+        else if (contentToken === constants_2.LIST_8 || contentToken === constants_2.LIST_16) {
+            const childrenCount = contentToken === constants_2.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 = bytes_1.TEXT_ENCODER.encode(value);
+            }
+            else {
+                content = value;
+            }
+        }
+    }
+    if (content === null || content === undefined) {
+        return { tag: tagValue, attrs };
+    }
+    return { tag: tagValue, attrs, content };
+}
+function decodeBinaryNode(data) {
+    const reader = new ByteReader(data);
+    return decodeNodeInternal(reader);
+}
+async function inflateCompressedStanza(data) {
+    try {
+        return (0, bytes_1.toBytesView)(await unzipAsync(data));
+    }
+    catch {
+        try {
+            return (0, bytes_1.toBytesView)(await inflateRawAsync(data));
+        }
+        catch (rawError) {
+            const message = rawError instanceof Error ? rawError.message : String(rawError);
+            throw new Error(`failed to inflate compressed stanza: ${message}`);
+        }
+    }
+}
+async function decodeBinaryNodeStanza(stanza) {
+    const reader = new ByteReader(stanza);
+    const flag = reader.readUint8();
+    if (flag === constants_2.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/transport/binary/encoder.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeBinaryNode = encodeBinaryNode;
+exports.encodeBinaryNodeStanza = encodeBinaryNodeStanza;
+const constants_1 = require("../binary/constants");
+const bytes_1 = require("../../util/bytes");
+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 === constants_1.NIBBLE_8) {
+        if (code === 45) {
+            return 10;
+        }
+        if (code === 46) {
+            return 11;
+        }
+    }
+    if (packedType === constants_1.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(constants_1.BINARY_8);
+        writer.writeUint8(length);
+        return;
+    }
+    if (length < 1 << 20) {
+        writer.writeUint8(constants_1.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(constants_1.BINARY_32);
+    writer.writeUint32(length);
+}
+function writeString(value, writer) {
+    const singleToken = constants_1.SINGLE_BYTE_TOKEN_MAP.get(value);
+    if (singleToken !== undefined) {
+        writer.writeUint8(singleToken);
+        return;
+    }
+    for (let dictionaryIndex = 0; dictionaryIndex < constants_1.DICTIONARY_TOKEN_MAPS.length; dictionaryIndex += 1) {
+        const dictToken = constants_1.DICTIONARY_TOKEN_MAPS[dictionaryIndex].get(value);
+        if (dictToken !== undefined) {
+            writer.writeUint8(constants_1.DICTIONARY_0 + dictionaryIndex);
+            writer.writeUint8(dictToken);
+            return;
+        }
+    }
+    if (value.length < 128 && isNibbleString(value)) {
+        writePackedString(value, constants_1.NIBBLE_8, writer);
+        return;
+    }
+    if (value.length < 128 && isHexString(value)) {
+        writePackedString(value, constants_1.HEX_8, writer);
+        return;
+    }
+    const encoded = bytes_1.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(constants_1.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(constants_1.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 = bytes_1.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);
+    }
+}
+function encodeBinaryNode(node) {
+    const writer = new ByteWriter();
+    writeNodeInternal(node, writer);
+    return writer.toUint8Array();
+}
+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/transport/binary/index.js

@@ -0,0 +1,23 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WapEncodeConstants = exports.WapDecodeConstants = void 0;
+__exportStar(require("../binary/tokens"), exports);
+__exportStar(require("../binary/encoder"), exports);
+__exportStar(require("../binary/decoder"), exports);
+var constants_1 = require("../binary/constants");
+Object.defineProperty(exports, "WapDecodeConstants", { enumerable: true, get: function () { return constants_1.WAP_DECODE_CONSTANTS; } });
+Object.defineProperty(exports, "WapEncodeConstants", { enumerable: true, get: function () { return constants_1.WAP_ENCODE_CONSTANTS; } });