imapflow 1.0.90 → 1.0.93

package/.gitattributes

@@ -0,0 +1 @@
+*.js text eol=lf

package/.github/workflows/test.yml

@@ -0,0 +1,21 @@
+name: Run tests
+
+on:
+    push:
+    pull_request:
+
+jobs:
+    test:
+        strategy:
+            matrix:
+                node: [16.x, 18.x]
+                os: [ubuntu-latest]
+        runs-on: ${{ matrix.os }}
+        steps:
+            - uses: actions/checkout@v2
+            - name: Use Node.js ${{ matrix.node }}
+              uses: actions/setup-node@v1
+              with:
+                  node-version: ${{ matrix.node }}
+            - run: npm install
+            - run: npm test

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # CHANGELOG
 
+-   1.0.93 - 2022-05-03
+
+    -   Fixed missing unicode encoding for APPEND, COPY, MOVE
+
+-   1.0.92 - 2022-05-03
+
+    -   Added support for IMAP BINARY extension (rfc3516)
+    -   Logging improvements
+
+-   1.0.91 - 2022-05-02
+
+    -   Do not throw if literal includes a null byte
+    -   Use UTF8 path names by default
+    -   Overrides '\*' range query with the EXISTS value
+
 -   1.0.90 - 2022-04-04
 
     -   Added new configuration option `maxIdleTime`

package/lib/commands/append.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getStatusCode, formatFlag, canUseFlag, formatDateTime, normalizePath, comparePaths, getErrorText } = require('../tools.js');
+const { getStatusCode, formatFlag, canUseFlag, formatDateTime, normalizePath, encodePath, comparePaths, getErrorText } = require('../tools.js');
 
 // Appends a message to a mailbox
 module.exports = async (connection, destination, content, flags, idate) => {
@@ -26,7 +26,7 @@ module.exports = async (connection, destination, content, flags, idate) => {
         .map(flag => flag && formatFlag(flag.toString()))
         .filter(flag => flag && canUseFlag(connection.mailbox, flag));
 
-    let attributes = [{ type: 'ATOM', value: destination }];
+    let attributes = [{ type: 'ATOM', value: encodePath(connection, destination) }];
 
     idate = idate ? formatDateTime(idate) : false;
 
@@ -38,7 +38,17 @@ module.exports = async (connection, destination, content, flags, idate) => {
         attributes.push({ type: 'STRING', value: idate }); // force quotes as required by date-time
     }
 
-    attributes.push({ type: 'LITERAL', value: content });
+    let isLiteral8 = false;
+    if (connection.capabilities.has('BINARY') && !connection.disableBinary) {
+        if (typeof content === 'string') {
+            content = Buffer.from(content);
+        }
+        // Value is literal8 if it contains NULL bytes. The server must support the BINARY extension
+        // and if it does not then send the value as a regular literal and hope for the best
+        isLiteral8 = content.indexOf(Buffer.from([0])) >= 0;
+    }
+
+    attributes.push({ type: 'LITERAL', value: content, isLiteral8 });
 
     let map = { destination };
     if (connection.mailbox && connection.mailbox.path) {

package/lib/commands/authenticate.js

@@ -39,7 +39,7 @@ module.exports = async (connection, username, accessToken) => {
                             try {
                                 errorResponse = JSON.parse(Buffer.from(resp.attributes[0].value, 'base64').toString());
                             } catch (err) {
-                                connection.log.debug({ data: resp.attributes[0].value, err });
+                                connection.log.debug({ errorResponse: resp.attributes[0].value, err });
                             }
                         }
 

package/lib/commands/copy.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getStatusCode, normalizePath, expandRange, getErrorText } = require('../tools.js');
+const { getStatusCode, normalizePath, encodePath, expandRange, getErrorText } = require('../tools.js');
 
 // Copies messages from current mailbox to some other mailbox
 module.exports = async (connection, range, destination, options) => {
@@ -14,7 +14,7 @@ module.exports = async (connection, range, destination, options) => {
 
     let attributes = [
         { type: 'SEQUENCE', value: range },
-        { type: 'ATOM', value: destination }
+        { type: 'ATOM', value: encodePath(connection, destination) }
     ];
 
     let response;

package/lib/commands/create.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath, getStatusCode, getErrorText } = require('../tools.js');
+const { encodePath, normalizePath, getStatusCode, getErrorText } = require('../tools.js');
 
 // Creates a new mailbox
 module.exports = async (connection, path) => {
@@ -16,7 +16,7 @@ module.exports = async (connection, path) => {
         let map = {
             path
         };
-        response = await connection.exec('CREATE', [{ type: 'ATOM', value: path }]);
+        response = await connection.exec('CREATE', [{ type: 'ATOM', value: encodePath(connection, path) }]);
 
         let section =
             response.response.attributes &&

package/lib/commands/delete.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath, getStatusCode, getErrorText } = require('../tools.js');
+const { encodePath, normalizePath, getStatusCode, getErrorText } = require('../tools.js');
 
 // Deletes an existing mailbox
 module.exports = async (connection, path) => {
@@ -20,7 +20,7 @@ module.exports = async (connection, path) => {
         let map = {
             path
         };
-        response = await connection.exec('DELETE', [{ type: 'ATOM', value: path }]);
+        response = await connection.exec('DELETE', [{ type: 'ATOM', value: encodePath(connection, path) }]);
         response.next();
         return map;
     } catch (err) {

package/lib/commands/fetch.js

@@ -18,6 +18,8 @@ module.exports = async (connection, range, query, options) => {
         list: []
     };
 
+    const commandKey = connection.capabilities.has('BINARY') && !connection.disableBinary ? 'BINARY' : 'BODY';
+
     let response;
     try {
         let attributes = [{ type: 'SEQUENCE', value: (range || '*').toString() }];
@@ -27,7 +29,7 @@ module.exports = async (connection, range, query, options) => {
         let setBodyPeek = (attributes, partial) => {
             let bodyPeek = {
                 type: 'ATOM',
-                value: 'BODY.PEEK',
+                value: `${commandKey}.PEEK`,
                 section: [],
                 partial
             };
@@ -61,7 +63,7 @@ module.exports = async (connection, range, query, options) => {
                     partial.push(Number(query.source.maxLength));
                 }
             }
-            queryStructure.push({ type: 'ATOM', value: 'BODY.PEEK', section: [], partial });
+            queryStructure.push({ type: 'ATOM', value: `${commandKey}.PEEK`, section: [], partial });
         }
 
         // if possible, always request for unique email id

package/lib/commands/list.js

@@ -1,8 +1,7 @@
 'use strict';
 
-const { normalizePath } = require('../tools.js');
+const { decodePath, encodePath, normalizePath } = require('../tools.js');
 const { specialUse } = require('../special-use');
-const iconv = require('iconv-lite');
 
 // Lists mailboxes from server
 module.exports = async (connection, reference, mailbox) => {
@@ -14,7 +13,7 @@ module.exports = async (connection, reference, mailbox) => {
         let entries = [];
 
         let runList = async (reference, mailbox) => {
-            response = await connection.exec(listCommand, [reference, mailbox], {
+            response = await connection.exec(listCommand, [encodePath(connection, reference), encodePath(connection, mailbox)], {
                 untagged: {
                     [listCommand]: async untagged => {
                         if (!untagged.attributes || !untagged.attributes.length) {
@@ -22,7 +21,8 @@ module.exports = async (connection, reference, mailbox) => {
                         }
 
                         let entry = {
-                            path: (untagged.attributes[2] && untagged.attributes[2].value) || '',
+                            path: normalizePath(connection, decodePath(connection, (untagged.attributes[2] && untagged.attributes[2].value) || '')),
+                            pathAsListed: (untagged.attributes[2] && untagged.attributes[2].value) || '',
                             flags: new Set(untagged.attributes[0].map(entry => entry.value)),
                             delimiter: untagged.attributes[1] && untagged.attributes[1].value,
                             listed: true
@@ -45,19 +45,8 @@ module.exports = async (connection, reference, mailbox) => {
                             entry.path = entry.path.slice(1);
                         }
 
-                        entry.parent = (entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path]).map(folder => {
-                            if (!connection.enabled.has('UTF8=ACCEPT')) {
-                                try {
-                                    return iconv.decode(Buffer.from(folder), 'utf-7-imap').toString();
-                                } catch (err) {
-                                    return folder; // keep as is
-                                }
-                            } else {
-                                return folder; // keep as is
-                            }
-                        });
-
-                        entry.path = normalizePath(connection, entry.path);
+                        entry.parentPath = entry.delimiter && entry.path ? entry.path.substr(0, entry.path.lastIndexOf(entry.delimiter)) : '';
+                        entry.parent = entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path];
                         entry.name = entry.parent.pop();
 
                         let specialUseFlag = specialUse(connection.capabilities.has('XLIST') || connection.capabilities.has('SPECIAL-USE'), entry);
@@ -80,59 +69,54 @@ module.exports = async (connection, reference, mailbox) => {
             await runList('', 'INBOX');
         }
 
-        response = await connection.exec('LSUB', [normalizePath(connection, reference || ''), normalizePath(connection, mailbox || '', true)], {
-            untagged: {
-                LSUB: async untagged => {
-                    if (!untagged.attributes || !untagged.attributes.length) {
-                        return;
-                    }
-
-                    let entry = {
-                        flags: new Set(untagged.attributes[0].map(entry => entry.value)),
-                        delimiter: untagged.attributes[1] && untagged.attributes[1].value,
-                        path: (untagged.attributes[2] && untagged.attributes[2].value) || '',
-                        subscribed: true
-                    };
+        response = await connection.exec(
+            'LSUB',
+            [encodePath(connection, normalizePath(connection, reference || '')), encodePath(connection, normalizePath(connection, mailbox || '', true))],
+            {
+                untagged: {
+                    LSUB: async untagged => {
+                        if (!untagged.attributes || !untagged.attributes.length) {
+                            return;
+                        }
 
-                    if (entry.path.toUpperCase() === 'INBOX') {
-                        entry.specialUse = '\\Inbox';
-                    }
+                        let entry = {
+                            path: normalizePath(connection, decodePath(connection, (untagged.attributes[2] && untagged.attributes[2].value) || '')),
+                            pathAsListed: (untagged.attributes[2] && untagged.attributes[2].value) || '',
+                            flags: new Set(untagged.attributes[0].map(entry => entry.value)),
+                            delimiter: untagged.attributes[1] && untagged.attributes[1].value,
+                            subscribed: true
+                        };
 
-                    if (entry.delimiter && entry.path.charAt(0) === entry.delimiter) {
-                        entry.path = entry.path.slice(1);
-                    }
+                        if (entry.path.toUpperCase() === 'INBOX') {
+                            entry.specialUse = '\\Inbox';
+                        }
 
-                    entry.parent = (entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path]).map(folder => {
-                        if (!connection.enabled.has('UTF8=ACCEPT')) {
-                            try {
-                                return iconv.decode(Buffer.from(folder), 'utf-7-imap').toString();
-                            } catch (err) {
-                                return folder; // keep as is
-                            }
-                        } else {
-                            return folder; // keep as is
+                        if (entry.delimiter && entry.path.charAt(0) === entry.delimiter) {
+                            entry.path = entry.path.slice(1);
                         }
-                    });
 
-                    entry.name = entry.parent.pop();
+                        entry.parentPath = entry.delimiter && entry.path ? entry.path.substr(0, entry.path.lastIndexOf(entry.delimiter)) : '';
+                        entry.parent = entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path];
+                        entry.name = entry.parent.pop();
 
-                    let existing = entries.find(existing => existing.path === entry.path);
-                    if (existing) {
-                        existing.subscribed = true;
-                        entry.flags.forEach(flag => existing.flags.add(flag));
-                    } else {
-                        // ignore non-listed folders
-                        /*
-                        let specialUseFlag = specialUse(connection.capabilities.has('XLIST') || connection.capabilities.has('SPECIAL-USE'), entry);
-                        if (specialUseFlag && !flagsSeen.has(specialUseFlag)) {
-                            entry.specialUse = specialUseFlag;
+                        let existing = entries.find(existing => existing.path === entry.path);
+                        if (existing) {
+                            existing.subscribed = true;
+                            entry.flags.forEach(flag => existing.flags.add(flag));
+                        } else {
+                            // ignore non-listed folders
+                            /*
+                            let specialUseFlag = specialUse(connection.capabilities.has('XLIST') || connection.capabilities.has('SPECIAL-USE'), entry);
+                            if (specialUseFlag && !flagsSeen.has(specialUseFlag)) {
+                                entry.specialUse = specialUseFlag;
+                            }
+                            entries.push(entry);
+                            */
                         }
-                        entries.push(entry);
-                        */
                     }
                 }
             }
-        });
+        );
         response.next();
 
         let inboxEntry = entries.find(entry => entry.specialUse === '\\Inbox');

package/lib/commands/move.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getStatusCode, normalizePath, expandRange, getErrorText } = require('../tools.js');
+const { getStatusCode, normalizePath, encodePath, expandRange, getErrorText } = require('../tools.js');
 
 // Moves messages from current mailbox to some other mailbox
 module.exports = async (connection, range, destination, options) => {
@@ -14,7 +14,7 @@ module.exports = async (connection, range, destination, options) => {
 
     let attributes = [
         { type: 'SEQUENCE', value: range },
-        { type: 'ATOM', value: destination }
+        { type: 'ATOM', value: encodePath(connection, destination) }
     ];
 
     let map = { path: connection.mailbox.path, destination };

package/lib/commands/quota.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getStatusCode, normalizePath, getErrorText } = require('../tools.js');
+const { encodePath, getStatusCode, normalizePath, getErrorText } = require('../tools.js');
 
 // Requests quota information for a mailbox
 module.exports = async (connection, path) => {
@@ -63,7 +63,7 @@ module.exports = async (connection, path) => {
     let quotaFound = false;
     let response;
     try {
-        response = await connection.exec('GETQUOTAROOT', [{ type: 'ATOM', value: path }], {
+        response = await connection.exec('GETQUOTAROOT', [{ type: 'ATOM', value: encodePath(connection, path) }], {
             untagged: {
                 QUOTAROOT: async untagged => {
                     let quotaRoot =

package/lib/commands/rename.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath, getStatusCode, getErrorText } = require('../tools.js');
+const { encodePath, normalizePath, getStatusCode, getErrorText } = require('../tools.js');
 
 // Renames existing mailbox
 module.exports = async (connection, path, newPath) => {
@@ -23,8 +23,8 @@ module.exports = async (connection, path, newPath) => {
             newPath
         };
         response = await connection.exec('RENAME', [
-            { type: 'ATOM', value: path },
-            { type: 'ATOM', value: newPath }
+            { type: 'ATOM', value: encodePath(connection, path) },
+            { type: 'ATOM', value: encodePath(connection, newPath) }
         ]);
         response.next();
         return map;

package/lib/commands/select.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath, getStatusCode, getErrorText } = require('../tools.js');
+const { encodePath, normalizePath, getStatusCode, getErrorText } = require('../tools.js');
 
 // Selects a mailbox
 module.exports = async (connection, path, options) => {
@@ -47,101 +47,105 @@ module.exports = async (connection, path, options) => {
             map.qresync = true;
         }
 
-        response = await connection.exec(!options.readOnly ? 'SELECT' : 'EXAMINE', [{ type: 'ATOM', value: path }].concat(extraArgs || []), {
-            untagged: {
-                OK: async untagged => {
-                    if (!untagged.attributes || !untagged.attributes.length) {
-                        return;
-                    }
-                    let section = !untagged.attributes[0].value && untagged.attributes[0].section;
-                    if (section && section.length > 1 && section[0].type === 'ATOM' && typeof section[0].value === 'string') {
-                        let key = section[0].value.toLowerCase();
-                        let value;
-
-                        if (typeof section[1].value === 'string') {
-                            value = section[1].value;
-                        } else if (Array.isArray(section[1])) {
-                            value = section[1].map(entry => (typeof entry.value === 'string' ? entry.value : false)).filter(entry => entry);
+        response = await connection.exec(
+            !options.readOnly ? 'SELECT' : 'EXAMINE',
+            [{ type: 'ATOM', value: encodePath(connection, path) }].concat(extraArgs || []),
+            {
+                untagged: {
+                    OK: async untagged => {
+                        if (!untagged.attributes || !untagged.attributes.length) {
+                            return;
                         }
-
-                        switch (key) {
-                            case 'highestmodseq':
-                                key = 'highestModseq';
-                                if (/^[0-9]+$/.test(value)) {
-                                    value = BigInt(value);
-                                }
-                                break;
-
-                            case 'mailboxid':
-                                key = 'mailboxId';
-                                if (Array.isArray(value) && value.length) {
-                                    value = value[0];
-                                }
-                                break;
-
-                            case 'permanentflags':
-                                key = 'permanentFlags';
-                                value = new Set(value);
-                                break;
-
-                            case 'uidnext':
-                                key = 'uidNext';
-                                value = Number(value);
-                                break;
-
-                            case 'uidvalidity':
-                                key = 'uidValidity';
-                                if (/^[0-9]+$/.test(value)) {
-                                    value = BigInt(value);
-                                }
-                                break;
+                        let section = !untagged.attributes[0].value && untagged.attributes[0].section;
+                        if (section && section.length > 1 && section[0].type === 'ATOM' && typeof section[0].value === 'string') {
+                            let key = section[0].value.toLowerCase();
+                            let value;
+
+                            if (typeof section[1].value === 'string') {
+                                value = section[1].value;
+                            } else if (Array.isArray(section[1])) {
+                                value = section[1].map(entry => (typeof entry.value === 'string' ? entry.value : false)).filter(entry => entry);
+                            }
+
+                            switch (key) {
+                                case 'highestmodseq':
+                                    key = 'highestModseq';
+                                    if (/^[0-9]+$/.test(value)) {
+                                        value = BigInt(value);
+                                    }
+                                    break;
+
+                                case 'mailboxid':
+                                    key = 'mailboxId';
+                                    if (Array.isArray(value) && value.length) {
+                                        value = value[0];
+                                    }
+                                    break;
+
+                                case 'permanentflags':
+                                    key = 'permanentFlags';
+                                    value = new Set(value);
+                                    break;
+
+                                case 'uidnext':
+                                    key = 'uidNext';
+                                    value = Number(value);
+                                    break;
+
+                                case 'uidvalidity':
+                                    key = 'uidValidity';
+                                    if (/^[0-9]+$/.test(value)) {
+                                        value = BigInt(value);
+                                    }
+                                    break;
+                            }
+
+                            map[key] = value;
                         }
 
-                        map[key] = value;
-                    }
-
-                    if (section && section.length === 1 && section[0].type === 'ATOM' && typeof section[0].value === 'string') {
-                        let key = section[0].value.toLowerCase();
-                        switch (key) {
-                            case 'nomodseq':
-                                key = 'noModseq';
-                                map[key] = true;
-                                break;
+                        if (section && section.length === 1 && section[0].type === 'ATOM' && typeof section[0].value === 'string') {
+                            let key = section[0].value.toLowerCase();
+                            switch (key) {
+                                case 'nomodseq':
+                                    key = 'noModseq';
+                                    map[key] = true;
+                                    break;
+                            }
+                        }
+                    },
+                    FLAGS: async untagged => {
+                        if (!untagged.attributes || (!untagged.attributes.length && Array.isArray(untagged.attributes[0]))) {
+                            return;
+                        }
+                        let flags = untagged.attributes[0].map(flag => (typeof flag.value === 'string' ? flag.value : false)).filter(flag => flag);
+                        map.flags = new Set(flags);
+                    },
+                    EXISTS: async untagged => {
+                        let num = Number(untagged.command);
+                        if (isNaN(num)) {
+                            return false;
                         }
-                    }
-                },
-                FLAGS: async untagged => {
-                    if (!untagged.attributes || (!untagged.attributes.length && Array.isArray(untagged.attributes[0]))) {
-                        return;
-                    }
-                    let flags = untagged.attributes[0].map(flag => (typeof flag.value === 'string' ? flag.value : false)).filter(flag => flag);
-                    map.flags = new Set(flags);
-                },
-                EXISTS: async untagged => {
-                    let num = Number(untagged.command);
-                    if (isNaN(num)) {
-                        return false;
-                    }
 
-                    map.exists = num;
-                },
-                VANISHED: async untagged => {
-                    await connection.untaggedVanished(
-                        untagged,
-                        // mailbox is not yet open, so use a dummy mailbox object
-                        { path, uidNext: false, uidValidity: false }
-                    );
-                },
-                // we should only get an untagged FETCH for a SELECT/EXAMINE if QRESYNC was asked for
-                FETCH: async untagged => {
-                    await connection.untaggedFetch(
-                        untagged,
-                        // mailbox is not yet open, so use a dummy mailbox object
-                        { path, uidNext: false, uidValidity: false }
-                    );
+                        map.exists = num;
+                    },
+                    VANISHED: async untagged => {
+                        await connection.untaggedVanished(
+                            untagged,
+                            // mailbox is not yet open, so use a dummy mailbox object
+                            { path, uidNext: false, uidValidity: false }
+                        );
+                    },
+                    // we should only get an untagged FETCH for a SELECT/EXAMINE if QRESYNC was asked for
+                    FETCH: async untagged => {
+                        await connection.untaggedFetch(
+                            untagged,
+                            // mailbox is not yet open, so use a dummy mailbox object
+                            { path, uidNext: false, uidValidity: false }
+                        );
+                    }
                 }
             }
-        });
+        );
 
         let section = !response.response.attributes[0].value && response.response.attributes[0].section;
         if (section && section.length && section[0].type === 'ATOM' && typeof section[0].value === 'string') {

package/lib/commands/status.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath } = require('../tools.js');
+const { encodePath, normalizePath } = require('../tools.js');
 
 // Requests info about a mailbox
 module.exports = async (connection, path, query) => {
@@ -11,7 +11,7 @@ module.exports = async (connection, path, query) => {
 
     path = normalizePath(connection, path);
 
-    let attributes = [{ type: 'ATOM', value: path }];
+    let attributes = [{ type: 'ATOM', value: encodePath(connection, path) }];
 
     let queryAttributes = [];
     Object.keys(query || {}).forEach(key => {

package/lib/commands/subscribe.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath, getStatusCode, getErrorText } = require('../tools.js');
+const { encodePath, normalizePath, getStatusCode, getErrorText } = require('../tools.js');
 
 // Subscribes to a mailbox
 module.exports = async (connection, path) => {
@@ -13,7 +13,7 @@ module.exports = async (connection, path) => {
 
     let response;
     try {
-        response = await connection.exec('SUBSCRIBE', [{ type: 'ATOM', value: path }]);
+        response = await connection.exec('SUBSCRIBE', [{ type: 'ATOM', value: encodePath(connection, path) }]);
         response.next();
         return true;
     } catch (err) {

package/lib/commands/unsubscribe.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath, getStatusCode, getErrorText } = require('../tools.js');
+const { encodePath, normalizePath, getStatusCode, getErrorText } = require('../tools.js');
 
 // Unsubscribes from a mailbox
 module.exports = async (connection, path) => {
@@ -13,7 +13,7 @@ module.exports = async (connection, path) => {
 
     let response;
     try {
-        response = await connection.exec('UNSUBSCRIBE', [{ type: 'ATOM', value: path }]);
+        response = await connection.exec('UNSUBSCRIBE', [{ type: 'ATOM', value: encodePath(connection, path) }]);
         response.next();
         return true;
     } catch (err) {

package/lib/handler/imap-compiler.js

@@ -85,7 +85,7 @@ module.exports = async (response, options) => {
                     let canAppend = !asArray || literalPlus || (literalMinus && literalLength <= 4096);
                     let usePlus = canAppend && (literalMinus || literalPlus);
 
-                    resp += `{${literalLength}${usePlus ? '+' : ''}}\r\n`;
+                    resp += `${node.isLiteral8 ? '~' : ''}{${literalLength}${usePlus ? '+' : ''}}\r\n`;
 
                     if (canAppend) {
                         resp += (node.value || '').toString('binary');