zapo-js 0.1.2 → 0.3.0

package/dist/transport/node/builders/profile.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGetProfilePictureIq = buildGetProfilePictureIq;
+exports.buildSetProfilePictureIq = buildSetProfilePictureIq;
+exports.buildDeleteProfilePictureIq = buildDeleteProfilePictureIq;
+exports.buildSetStatusIq = buildSetStatusIq;
+exports.buildGetDisappearingModeUsyncQueryNode = buildGetDisappearingModeUsyncQueryNode;
+exports.buildGetStatusUsyncQueryNodes = buildGetStatusUsyncQueryNodes;
+const constants_1 = require("../../../protocol/constants");
+const query_1 = require("../../node/query");
+function buildGetProfilePictureIq(targetJid, type = 'preview', existingId) {
+    const pictureAttrs = {
+        type,
+        query: 'url'
+    };
+    if (existingId) {
+        pictureAttrs.id = existingId;
+    }
+    return (0, query_1.buildIqNode)('get', constants_1.WA_DEFAULTS.HOST_DOMAIN, constants_1.WA_XMLNS.PROFILE_PICTURE, [
+        {
+            tag: constants_1.WA_NODE_TAGS.PICTURE,
+            attrs: pictureAttrs
+        }
+    ], {
+        target: targetJid
+    });
+}
+function buildSetProfilePictureIq(imageBytes, targetJid) {
+    const attrs = {};
+    if (targetJid) {
+        attrs.target = targetJid;
+    }
+    return (0, query_1.buildIqNode)('set', constants_1.WA_DEFAULTS.HOST_DOMAIN, constants_1.WA_XMLNS.PROFILE_PICTURE, [
+        {
+            tag: constants_1.WA_NODE_TAGS.PICTURE,
+            attrs: { type: 'image' },
+            content: imageBytes
+        }
+    ], attrs);
+}
+function buildDeleteProfilePictureIq(targetJid) {
+    const attrs = {};
+    if (targetJid) {
+        attrs.target = targetJid;
+    }
+    return (0, query_1.buildIqNode)('set', constants_1.WA_DEFAULTS.HOST_DOMAIN, constants_1.WA_XMLNS.PROFILE_PICTURE, undefined, attrs);
+}
+function buildSetStatusIq(text) {
+    return (0, query_1.buildIqNode)('set', constants_1.WA_DEFAULTS.HOST_DOMAIN, constants_1.WA_XMLNS.STATUS, [
+        {
+            tag: 'status',
+            attrs: {},
+            content: text
+        }
+    ]);
+}
+function buildGetDisappearingModeUsyncQueryNode() {
+    return {
+        tag: 'disappearing_mode',
+        attrs: {}
+    };
+}
+function buildGetStatusUsyncQueryNodes() {
+    return [
+        {
+            tag: constants_1.WA_NODE_TAGS.CONTACT,
+            attrs: {}
+        },
+        {
+            tag: 'status',
+            attrs: {}
+        },
+        {
+            tag: constants_1.WA_NODE_TAGS.PICTURE,
+            attrs: {}
+        }
+    ];
+}

package/dist/transport/node/builders/retry.js

@@ -4,6 +4,7 @@ exports.buildRetryReceiptNode = buildRetryReceiptNode;
 const constants_1 = require("../../../protocol/constants");
 const constants_2 = require("../../../retry/constants");
 const constants_3 = require("../../../signal/api/constants");
+const global_1 = require("../../node/builders/global");
 const bytes_1 = require("../../../util/bytes");
 function buildRetryKeysNode(keys) {
     const content = [
@@ -71,30 +72,13 @@ function buildRetryKeysNode(keys) {
     };
 }
 function buildRetryReceiptNode(input) {
-    const attrs = {
-        id: input.stanzaId,
-        to: input.to,
-        type: 'retry'
-    };
-    if (input.participant) {
-        attrs.participant = input.participant;
-    }
-    if (input.recipient) {
-        attrs.recipient = input.recipient;
-    }
-    if (input.from) {
-        attrs.from = input.from;
-    }
-    if (input.categoryPeer) {
-        attrs.category = 'peer';
-    }
     const retryAttrs = {
         v: constants_2.RETRY_RECEIPT_VERSION,
         count: String(input.retryCount),
         id: input.originalMsgId,
         t: input.t
     };
-    if (input.error !== undefined) {
+    if (input.error !== undefined && input.error !== 0) {
         retryAttrs.error = String(input.error);
     }
     const content = [
@@ -111,9 +95,13 @@ function buildRetryReceiptNode(input) {
     if (input.keys) {
         content.push(buildRetryKeysNode(input.keys));
     }
-    return {
-        tag: constants_1.WA_MESSAGE_TAGS.RECEIPT,
-        attrs,
+    return (0, global_1.buildReceiptNode)({
+        kind: 'retry_custom',
+        id: input.stanzaId,
+        to: input.to,
+        participant: input.participant,
+        recipient: input.recipient,
+        categoryPeer: input.categoryPeer,
         content
-    };
+    });
 }

package/dist/transport/node/builders/usync.js

@@ -18,6 +18,10 @@ function buildUsyncIq(input) {
     if (input.queryProtocolNodes.length === 0) {
         throw new Error('usync query must include at least one protocol node');
     }
+    const users = new Array(input.users.length);
+    for (let index = 0; index < input.users.length; index += 1) {
+        users[index] = buildUsyncUserNode(input.users[index]);
+    }
     return (0, query_1.buildIqNode)('get', input.hostDomain ?? constants_1.WA_DEFAULTS.HOST_DOMAIN, constants_1.WA_XMLNS.USYNC, [
         {
             tag: constants_1.WA_NODE_TAGS.USYNC,
@@ -32,12 +36,12 @@ function buildUsyncIq(input) {
                 {
                     tag: constants_1.WA_NODE_TAGS.QUERY,
                     attrs: {},
-                    content: [...input.queryProtocolNodes]
+                    content: input.queryProtocolNodes
                 },
                 {
                     tag: constants_1.WA_NODE_TAGS.LIST,
                     attrs: {},
-                    content: input.users.map((user) => buildUsyncUserNode(user))
+                    content: users
                 }
             ]
         }

package/dist/transport/node/helpers.js

@@ -11,12 +11,17 @@ exports.getNodeChildrenNonEmptyUtf8ByTag = getNodeChildrenNonEmptyUtf8ByTag;
 exports.findNodeChildrenByTags = findNodeChildrenByTags;
 exports.hasNodeChild = hasNodeChild;
 exports.decodeNodeContentUtf8OrBytes = decodeNodeContentUtf8OrBytes;
+exports.getNodeTextContent = getNodeTextContent;
 exports.decodeNodeContentBase64OrBytes = decodeNodeContentBase64OrBytes;
 exports.formatNodeIdPrefixFromSeed = formatNodeIdPrefixFromSeed;
+exports.createNodeIdGenerator = createNodeIdGenerator;
+exports.createMobileNodeIdGenerator = createMobileNodeIdGenerator;
+const _crypto_1 = require("../../crypto/index.js");
 const bytes_1 = require("../../util/bytes");
 const EMPTY_NODE_CHILDREN = Object.freeze([]);
 const EMPTY_NODE_TAGS = Object.freeze([]);
 const EMPTY_NODE_VALUES = Object.freeze([]);
+const NODE_ID_PREFIX_SEED = new Uint8Array(4);
 function getNodeChildren(node) {
     return Array.isArray(node.content) ? node.content : EMPTY_NODE_CHILDREN;
 }
@@ -69,7 +74,11 @@ function getNodeChildrenTags(node) {
     const content = node.content;
     if (!Array.isArray(content) || content.length === 0)
         return EMPTY_NODE_TAGS;
-    return content.map((c) => c.tag);
+    const tags = new Array(content.length);
+    for (let i = 0; i < content.length; i += 1) {
+        tags[i] = content[i].tag;
+    }
+    return tags;
 }
 function getNodeChildrenNonEmptyAttrValuesByTag(node, tag, attr) {
     let values = null;
@@ -135,6 +144,14 @@ function decodeNodeContentUtf8OrBytes(value, field) {
     }
     throw new Error(`node ${field} has no binary content`);
 }
+function getNodeTextContent(node) {
+    const content = node.content;
+    if (content instanceof Uint8Array)
+        return bytes_1.TEXT_DECODER.decode(content);
+    if (typeof content === 'string')
+        return content;
+    return undefined;
+}
 function decodeNodeContentBase64OrBytes(value, field) {
     if (value === null || value === undefined) {
         throw new Error(`missing binary node content for ${field}`);
@@ -152,3 +169,31 @@ function formatNodeIdPrefixFromSeed(seed) {
     const right = ((seed[2] << 8) | seed[3]) >>> 0;
     return `${left}.${right}-`;
 }
+async function createNodeIdGenerator() {
+    await (0, _crypto_1.randomFillAsync)(NODE_ID_PREFIX_SEED);
+    const prefix = formatNodeIdPrefixFromSeed(NODE_ID_PREFIX_SEED);
+    let counter = 0;
+    return {
+        prefix,
+        next() {
+            counter += 1;
+            return `${prefix}${counter}`;
+        }
+    };
+}
+function createMobileNodeIdGenerator() {
+    let featureCounter = 0;
+    let systemCounter = 0;
+    return {
+        prefix: '0',
+        next() {
+            const id = `0${featureCounter.toString(16)}`;
+            featureCounter = (featureCounter + 1) & 0xffff;
+            return id;
+        },
+        nextSystem() {
+            systemCounter = (systemCounter + 1) & 0xffff;
+            return systemCounter.toString(16);
+        }
+    };
+}

package/dist/transport/node/mex/argo-decoder.js

@@ -0,0 +1,189 @@
+"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.isMexArgoDecoderAvailable = isMexArgoDecoderAvailable;
+exports.decodeMexArgoResponse = decodeMexArgoResponse;
+const bytes_1 = require("../../../util/bytes");
+let cachedArgo;
+async function loadArgo() {
+    if (cachedArgo !== undefined)
+        return cachedArgo;
+    try {
+        cachedArgo = (await Promise.resolve().then(() => __importStar(require('argo-codec'))));
+    }
+    catch {
+        cachedArgo = null;
+    }
+    return cachedArgo;
+}
+async function isMexArgoDecoderAvailable() {
+    return (await loadArgo()) !== null;
+}
+const LABEL_NULL = -1;
+const LABEL_ABSENT = -2;
+const BACKREF_BASE = -4;
+const DESC_NULL = -1;
+const DESC_FALSE = 0;
+const DESC_TRUE = 1;
+const DESC_OBJECT = 2;
+const DESC_LIST = 3;
+const DESC_STRING = 4;
+const DESC_BYTES = 5;
+const DESC_INT = 6;
+const DESC_FLOAT = 7;
+const FLAG_INLINE_EVERYTHING = 1 << 0;
+const FLAG_HAS_USER_FLAGS = 1 << 6;
+async function decodeMexArgoResponse(bytes) {
+    const argo = await loadArgo();
+    if (!argo)
+        throw new Error('argo-codec not installed');
+    const r = new argo.Reader(bytes);
+    const flags = r.bitset();
+    const inline = (flags & FLAG_INLINE_EVERYTHING) !== 0;
+    if (flags & FLAG_HAS_USER_FLAGS)
+        r.bitset();
+    const segments = [];
+    if (!inline) {
+        while (r.pos < r.end) {
+            const len = r.label();
+            segments.push(new argo.Reader(r.bytes(len)));
+        }
+        if (segments.length === 0)
+            throw new Error('mex argo: missing core segment');
+    }
+    else {
+        segments.push(r);
+    }
+    const core = segments[segments.length - 1];
+    const blocks = inline ? new Map() : indexBlocks(segments.slice(0, -1));
+    const ctx = { core, blocks, stringSeen: [] };
+    const data = readDesc(ctx);
+    const errors = [];
+    if (core.pos < core.end) {
+        const errCount = core.label();
+        for (let i = 0; i < errCount; i++)
+            errors.push(readError(ctx));
+    }
+    return { data, errors };
+}
+function indexBlocks(slices) {
+    const m = new Map();
+    const keys = ['String', 'Int', 'Float', 'Bytes'];
+    for (let i = 0; i < slices.length && i < keys.length; i++)
+        m.set(keys[i], slices[i]);
+    return m;
+}
+function getBlock(ctx, key) {
+    const b = ctx.blocks.get(key);
+    if (!b)
+        throw new Error(`mex argo: block '${key}' missing`);
+    return b;
+}
+function readStringFromBlock(ctx) {
+    const lab = ctx.core.label();
+    if (lab < BACKREF_BASE + 1) {
+        const idx = -lab + BACKREF_BASE;
+        return ctx.stringSeen[idx];
+    }
+    const block = getBlock(ctx, 'String');
+    const s = bytes_1.TEXT_DECODER.decode(block.bytes(lab));
+    ctx.stringSeen.push(s);
+    return s;
+}
+function readDesc(ctx) {
+    const m = ctx.core.label();
+    switch (m) {
+        case DESC_NULL:
+            return null;
+        case DESC_FALSE:
+            return false;
+        case DESC_TRUE:
+            return true;
+        case DESC_STRING:
+            return readStringFromBlock(ctx);
+        case DESC_INT:
+            return getBlock(ctx, 'Int').label();
+        case DESC_FLOAT:
+            throw new Error('mex argo: DESC_FLOAT not implemented');
+        case DESC_BYTES:
+            throw new Error('mex argo: DESC_BYTES not implemented');
+        case DESC_LIST: {
+            const n = ctx.core.label();
+            const out = [];
+            for (let i = 0; i < n; i++)
+                out.push(readDesc(ctx));
+            return out;
+        }
+        case DESC_OBJECT: {
+            const n = ctx.core.label();
+            const out = {};
+            for (let i = 0; i < n; i++) {
+                const key = readStringFromBlock(ctx);
+                out[key] = readDesc(ctx);
+            }
+            return out;
+        }
+        default:
+            throw new Error(`mex argo: unknown DESC marker ${m}`);
+    }
+}
+function readError(ctx) {
+    const message = readStringFromBlock(ctx);
+    skipOptional(ctx); // location — never observed in MEX errors so far
+    const path = readPath(ctx);
+    const extensions = readOptionalDesc(ctx);
+    return { message, path, extensions };
+}
+function skipOptional(ctx) {
+    const lab = ctx.core.label();
+    if (lab !== LABEL_ABSENT && lab !== LABEL_NULL) {
+        // Present but not yet structurally decoded; would need a typed inner read here.
+        // For locations specifically we have no observed sample; bail loudly if hit.
+        throw new Error(`mex argo: unexpected optional present (lab=${lab}); add support`);
+    }
+}
+function readPath(ctx) {
+    const lab = ctx.core.label();
+    if (lab === LABEL_ABSENT || lab === LABEL_NULL)
+        return null;
+    return lab;
+}
+function readOptionalDesc(ctx) {
+    const lab = ctx.core.label();
+    if (lab === LABEL_ABSENT || lab === LABEL_NULL)
+        return null;
+    const v = readDesc(ctx);
+    return typeof v === 'object' && v !== null ? v : null;
+}

package/dist/transport/node/mex/client.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchMexQuery = dispatchMexQuery;
+const constants_1 = require("../../../protocol/constants");
+const helpers_1 = require("../../node/helpers");
+const argo_decoder_1 = require("../../node/mex/argo-decoder");
+const query_1 = require("../../node/query");
+const bytes_1 = require("../../../util/bytes");
+const primitives_1 = require("../../../util/primitives");
+const MEX_DEFAULT_TIMEOUT_MS = 32000;
+async function dispatchMexQuery(socket, args) {
+    const body = JSON.stringify({
+        queryId: args.clientDocId,
+        variables: args.variables
+    });
+    const node = {
+        tag: constants_1.WA_NODE_TAGS.IQ,
+        attrs: {
+            ...(args.iqId ? { id: args.iqId } : {}),
+            to: constants_1.WA_DEFAULTS.HOST_DOMAIN,
+            type: constants_1.WA_IQ_TYPES.GET,
+            xmlns: constants_1.WA_XMLNS.MEX
+        },
+        content: [
+            {
+                tag: 'query',
+                attrs: { query_id: args.docId },
+                content: body
+            }
+        ]
+    };
+    const response = await socket.query(node, args.timeoutMs ?? MEX_DEFAULT_TIMEOUT_MS);
+    (0, query_1.assertIqResult)(response, `mex/${args.opName}`);
+    const data = await parseMexResultPayload(response, args.opName);
+    return { raw: response, data };
+}
+async function parseMexResultPayload(node, opName) {
+    const result = (0, helpers_1.findNodeChild)(node, 'result');
+    if (!result) {
+        throw new Error(`mex/${opName} response missing <result>`);
+    }
+    const format = result.attrs.format ?? 'json';
+    const rawBytes = (0, helpers_1.decodeNodeContentUtf8OrBytes)(result.content, `mex/${opName}/result`);
+    if (format === 'argo') {
+        if (!(await (0, argo_decoder_1.isMexArgoDecoderAvailable)())) {
+            throw new Error(`mex/${opName} argo response received but 'argo-codec' not installed; ${rawBytes.length}B; ` +
+                `strings: ${extractVisibleStrings(rawBytes)}`);
+        }
+        let decoded;
+        try {
+            decoded = await (0, argo_decoder_1.decodeMexArgoResponse)(rawBytes);
+        }
+        catch (error) {
+            throw new Error(`mex/${opName} argo decode failed: ${(0, primitives_1.toError)(error).message}; ` +
+                `${rawBytes.length}B; strings: ${extractVisibleStrings(rawBytes)}`);
+        }
+        if (decoded.errors.length > 0) {
+            const summary = decoded.errors
+                .map((e) => {
+                const code = e.extensions?.error_code ?? e.extensions?.code ?? '?';
+                const sev = e.extensions?.severity;
+                return `${code}${sev ? `/${String(sev)}` : ''}: ${e.message} @${e.path ?? ''}`;
+            })
+                .join('; ');
+            throw new Error(`mex/${opName} errors: ${summary}`);
+        }
+        return decoded.data;
+    }
+    return extractGraphQlData(JSON.parse(bytes_1.TEXT_DECODER.decode(rawBytes)), opName);
+}
+function extractVisibleStrings(bytes) {
+    return bytes_1.TEXT_DECODER.decode(bytes)
+        .replace(/[\x00-\x1f\x7f-\xff]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function extractGraphQlData(payload, opName) {
+    const json = (payload ?? {});
+    if (json.errors && json.errors.length > 0) {
+        const summary = json.errors
+            .map((e) => `${e.extensions?.error_code ?? '?'}: ${e.message ?? '?'} @${(e.path ?? []).join('.')}`)
+            .join('; ');
+        throw new Error(`mex/${opName} errors: ${summary}`);
+    }
+    return json.data ?? null;
+}

package/dist/transport/node/mex/persist-ids.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WA_MEX_PERSIST_IDS = void 0;
+exports.WA_MEX_PERSIST_IDS = Object.freeze({
+    WWWGetCertificates: Object.freeze({
+        docId: '25094190163544446',
+        clientDocId: '16428758503015954638431529919'
+    }),
+    WWWCreateUser: Object.freeze({
+        docId: '8548056818544135',
+        clientDocId: '25777518041400352865446016972'
+    })
+});

package/dist/transport/node/usync.js

@@ -1,38 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUsyncSidGenerator = createUsyncSidGenerator;
-const _crypto_1 = require("../../crypto/index.js");
 const helpers_1 = require("./helpers");
 function createUsyncSidGenerator() {
-    const state = {
-        prefix: null,
-        prefixPromise: null,
-        counter: 1
-    };
-    return async () => {
-        const prefix = await getUsyncPrefix(state);
-        const sid = `${prefix}${state.counter}`;
-        state.counter += 1;
-        return sid;
-    };
-}
-async function getUsyncPrefix(state) {
-    if (state.prefix) {
-        return state.prefix;
-    }
-    if (!state.prefixPromise) {
-        state.prefixPromise = buildUsyncPrefix()
-            .then((prefix) => {
-            state.prefix = prefix;
-            return prefix;
-        })
-            .finally(() => {
-            state.prefixPromise = null;
-        });
-    }
-    return state.prefixPromise;
-}
-async function buildUsyncPrefix() {
-    const seed = await (0, _crypto_1.randomBytesAsync)(4);
-    return (0, helpers_1.formatNodeIdPrefixFromSeed)(seed);
+    const generatorPromise = (0, helpers_1.createNodeIdGenerator)();
+    return async () => (await generatorPromise).next();
 }

package/dist/transport/node/xml.js

@@ -4,23 +4,41 @@ exports.formatBinaryNodeAsXml = formatBinaryNodeAsXml;
 const bytes_1 = require("../../util/bytes");
 const XML_INDENT = '    ';
 function escapeXml(value) {
-    return value
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-function renderAttrs(attrs) {
-    const entries = Object.entries(attrs);
-    if (entries.length === 0) {
-        return '';
+    let out = '';
+    let last = 0;
+    for (let i = 0; i < value.length; i++) {
+        let esc;
+        switch (value.charCodeAt(i)) {
+            case 38:
+                esc = '&amp;';
+                break;
+            case 60:
+                esc = '&lt;';
+                break;
+            case 62:
+                esc = '&gt;';
+                break;
+            case 34:
+                esc = '&quot;';
+                break;
+            case 39:
+                esc = '&apos;';
+                break;
+        }
+        if (esc) {
+            out += value.slice(last, i) + esc;
+            last = i + 1;
+        }
     }
-    return entries.map(([key, value]) => ` ${key}='${escapeXml(value)}'`).join('');
+    return last === 0 ? value : out + value.slice(last);
 }
 function renderNode(node, depth) {
     const indent = XML_INDENT.repeat(depth);
-    const attrs = renderAttrs(node.attrs);
+    const keys = Object.keys(node.attrs);
+    let attrs = '';
+    for (let i = 0; i < keys.length; i++) {
+        attrs += ` ${keys[i]}='${escapeXml(node.attrs[keys[i]])}'`;
+    }
     const content = node.content;
     if (content === undefined) {
         return `${indent}<${node.tag}${attrs}/>`;
@@ -34,7 +52,10 @@ function renderNode(node, depth) {
     if (content.length === 0) {
         return `${indent}<${node.tag}${attrs}/>`;
     }
-    const children = content.map((child) => renderNode(child, depth + 1)).join('\n');
+    let children = renderNode(content[0], depth + 1);
+    for (let i = 1; i < content.length; i++) {
+        children += '\n' + renderNode(content[i], depth + 1);
+    }
     return `${indent}<${node.tag}${attrs}>\n${children}\n${indent}</${node.tag}>`;
 }
 function formatBinaryNodeAsXml(node) {