imapkit 4.0.2 → 4.1.0

package/dist/esm/plugins/compress.js

@@ -0,0 +1,61 @@
+import { states } from '../command-states.js';
+import DeflateLayer from '../deflate-layer.js';
+/**
+ * @help Adds COMPRESS=DEFLATE [RFC4978] capability
+ * @help Raw DEFLATE in both directions after the tagged OK,
+ * @help every burst of responses ends with a sync flush
+ */
+export default function compressPlugin(server) {
+    server.registerCapability('COMPRESS=DEFLATE');
+    const isActive = (connection) => connection.transport instanceof DeflateLayer && connection.transport.active;
+    // RFC 8437 section 4.1: after UNAUTHENTICATE the server ends its compression after the CRLF of
+    // the OK, and the client after the CRLF of the command, so anything it compressed later is dropped
+    server.resetHandlers.push((connection) => {
+        if (isActive(connection)) {
+            connection.discardInput();
+            connection.transport.endInput();
+            connection.transport.end();
+        }
+    });
+    server.setCommandHandler('COMPRESS', (connection, parsed, data, callback) => {
+        const args = parsed.attributes || [];
+        // RFC 4978 section 5: compress = "COMPRESS" SP algorithm, algorithm = "DEFLATE"
+        if (args.length !== 1 || !args[0] || args[0].type !== 'ATOM') {
+            connection.sendStatus(parsed, data, 'BAD', 'COMPRESS expects a compression mechanism');
+            return callback();
+        }
+        if (args[0].value.toUpperCase() !== 'DEFLATE') {
+            connection.sendStatus(parsed, data, 'BAD', 'Unknown compression mechanism');
+            return callback();
+        }
+        // RFC 4978 section 3: BAD if COMPRESS is already active, NO is for compression by another
+        // layer, such as TLS, which ImapKit never negotiates. Dovecot answers NO here
+        if (isActive(connection)) {
+            connection.sendStatus(parsed, data, 'BAD', 'DEFLATE active via COMPRESS', 'COMPRESSIONACTIVE');
+            return callback();
+        }
+        connection.sendStatus(parsed, data, 'OK', 'DEFLATE active');
+        if (connection.transport) {
+            // the layer of an earlier session, it passes data on as is since UNAUTHENTICATE
+            connection.transport.destroy();
+        }
+        // compression starts right after the CRLF of the tagged OK
+        connection.transport = new DeflateLayer({
+            // the layer writes only Buffers to the server, strings come from the clients that share it
+            writeRaw: (chunk) => connection.writeRaw(chunk),
+            onData: (chunk) => connection.onData(chunk),
+            onError: (err) => {
+                // the input can not be decompressed, so there is nothing left to talk about
+                if (connection.options.debug) {
+                    console.log('COMPRESS error: %s', err.message);
+                }
+                connection.sendStatus({ tag: '*' }, null, 'BYE', 'Invalid compressed data', false, 'COMPRESS ERROR');
+                connection.end();
+            }
+        });
+        return callback();
+    }, 
+    // RFC 4978 section 3: the client MUST NOT send further commands until it has seen the result of COMPRESS.
+    // Those commands would be uncompressed, and after an OK the server expects compressed input
+    { states: states.AUTHENTICATED, noPipelining: true });
+}

package/dist/esm/plugins/condstore.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @help Adds CONDSTORE [RFC7162] capability
+ */
+import type { IMAPServer } from '../types.js';
+export default function condstorePlugin(server: IMAPServer): void;

package/{lib → dist/esm}/plugins/condstore.js

@@ -1,68 +1,51 @@
-'use strict';
-
 /**
  * @help Adds CONDSTORE [RFC7162] capability
  */
-
-const { macros: FETCH_MACROS } = require('../commands/fetch');
-const { badError } = require('../commands/handlers/search');
-const { INVALID_KEYWORD_CHAR } = require('../commands/handlers/flags');
-const { MAX_NUMBER64, isNumber } = require('../numbers');
-const { registerEnable, isEnabled: isExtensionEnabled } = require('./enable');
-
-module.exports = function (server) {
+import { macros as FETCH_MACROS } from '../commands/fetch.js';
+import { badError } from '../commands/handlers/search.js';
+import { INVALID_KEYWORD_CHAR } from '../commands/handlers/flags.js';
+import { MAX_NUMBER64, isNumber } from '../numbers.js';
+import { registerEnable, isEnabled as isExtensionEnabled } from './enable.js';
+export default function condstorePlugin(server) {
     // Register capability, always usable
     server.registerCapability('CONDSTORE');
-
     registerEnable(server, 'CONDSTORE');
-
     // HIGHESTMODSEQ must be a positive number, even for an empty mailbox
-    const getHighestModseq = mailbox => Math.max(Number(mailbox.HIGHESTMODSEQ) || 0, 1);
-
-    const bumpModseq = mailbox => {
+    const getHighestModseq = (mailbox) => Math.max(Number(mailbox.HIGHESTMODSEQ) || 0, 1);
+    const bumpModseq = (mailbox) => {
         mailbox.HIGHESTMODSEQ = getHighestModseq(mailbox) + 1;
         return mailbox.HIGHESTMODSEQ;
     };
-
     // RFC 8437 section 4.1: after UNAUTHENTICATE the session behaves as if no CONDSTORE enabling command was issued
-    server.resetHandlers.push(connection => {
+    server.resetHandlers.push((connection) => {
         connection.condstoreEnabled = false;
     });
-
     // ENABLE QRESYNC is a CONDSTORE enabling command as well (RFC 7162 section 3.2.3)
-    const isEnabled = connection => !!connection.condstoreEnabled || isExtensionEnabled(connection, 'CONDSTORE') || isExtensionEnabled(connection, 'QRESYNC');
-
+    const isEnabled = (connection) => !!connection.condstoreEnabled || isExtensionEnabled(connection, 'CONDSTORE') || isExtensionEnabled(connection, 'QRESYNC');
     // shared with QRESYNC, which builds on CONDSTORE
     server.condstore = { isEnabled, getHighestModseq };
-
     const sendHighestModseq = (connection, mailbox, parsed, data) => {
-        connection.send(
-            {
-                tag: '*',
-                command: 'OK',
-                attributes: [
-                    {
-                        type: 'SECTION',
-                        section: [
-                            {
-                                type: 'ATOM',
-                                value: 'HIGHESTMODSEQ'
-                            },
-                            getHighestModseq(mailbox)
-                        ]
-                    },
-                    {
-                        type: 'TEXT',
-                        value: 'Highest'
-                    }
-                ]
-            },
-            'CONDSTORE INFO',
-            parsed,
-            data
-        );
+        connection.send({
+            tag: '*',
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'SECTION',
+                    section: [
+                        {
+                            type: 'ATOM',
+                            value: 'HIGHESTMODSEQ'
+                        },
+                        getHighestModseq(mailbox)
+                    ]
+                },
+                {
+                    type: 'TEXT',
+                    value: 'Highest'
+                }
+            ]
+        }, 'CONDSTORE INFO', parsed, data);
     };
-
     // Marks the session as CONDSTORE aware. The first CONDSTORE enabling command
     // issued with a mailbox selected reports HIGHESTMODSEQ for that mailbox
     const enableCondstore = (connection, parsed, data) => {
@@ -75,7 +58,6 @@ module.exports = function (server) {
             sendHighestModseq(connection, connection.selectedMailbox, parsed, data);
         }
     };
-
     // Set modseq values when a message is created or initialized
     server.messageHandlers.push((server, message, mailbox) => {
         const modseq = Number(message.MODSEQ);
@@ -83,24 +65,21 @@ module.exports = function (server) {
             // keep the value from storage
             message.MODSEQ = modseq;
             mailbox.HIGHESTMODSEQ = Math.max(getHighestModseq(mailbox), modseq);
-        } else {
+        }
+        else {
             message.MODSEQ = bumpModseq(mailbox);
         }
     });
-
     // Expunging messages (EXPUNGE, UID EXPUNGE, CLOSE, MOVE) changes the mailbox, all messages removed
     // at once share the incremented mod-sequence (RFC 7162 section 3.2)
     server.on('expunge', mailbox => {
         bumpModseq(mailbox);
     });
-
     // RFC 7162 section 3.2.11: SELECT or EXAMINE closes the selected mailbox, a CONDSTORE server marks
     // where the responses for the new mailbox start
     server.closedChecks.push(() => true);
-
     server.allowedStatus.push('HIGHESTMODSEQ');
     server.statusHandlers.HIGHESTMODSEQ = (connection, mailbox) => getHighestModseq(mailbox);
-
     // Wraps an existing command handler. Commands that are not available are left alone
     const wrapHandler = (command, wrapper) => {
         const prevHandler = server.getCommandHandler(command);
@@ -109,17 +88,13 @@ module.exports = function (server) {
         }
         server.setCommandHandler(command, (connection, parsed, data, callback) => wrapper(prevHandler, connection, parsed, data, callback));
     };
-
     const sendBad = (connection, parsed, data, callback, message) => {
         connection.sendStatus(parsed, data, 'BAD', message, false, 'CONDSTORE FAILED');
         return callback();
     };
-
     // RFC 7162 section 7: chgsince-fetch-mod = "CHANGEDSINCE" SP mod-sequence-value (1 or more), store-modifier =/
     // "UNCHANGEDSINCE" SP mod-sequence-valzer (0 or more). Both are 1*DIGIT, so not a quoted string, up to 63 bits
-    const isValidModseq = (value, allowZero) =>
-        !!value && value.type === 'ATOM' && isNumber(value.value, MAX_NUMBER64) && (allowZero || BigInt(value.value) > 0n);
-
+    const isValidModseq = (value, allowZero) => !!value && value.type === 'ATOM' && isNumber(value.value, MAX_NUMBER64) && (allowZero || BigInt(value.value) > 0n);
     const selectWrapper = (prevHandler, connection, parsed, data, callback) => {
         if (hasCondstoreOption(parsed.attributes && parsed.attributes[1], parsed.attributes, 1)) {
             // SELECT and EXAMINE always report HIGHESTMODSEQ, so no need to send it here
@@ -128,10 +103,8 @@ module.exports = function (server) {
         }
         prevHandler(connection, parsed, data, callback);
     };
-
     wrapHandler('SELECT', selectWrapper);
     wrapHandler('EXAMINE', selectWrapper);
-
     wrapHandler('STATUS', (prevHandler, connection, parsed, data, callback) => {
         const items = parsed.attributes && parsed.attributes[1];
         if (Array.isArray(items) && items.some(item => item && item.type === 'ATOM' && String(item.value).toUpperCase() === 'HIGHESTMODSEQ')) {
@@ -139,13 +112,11 @@ module.exports = function (server) {
         }
         prevHandler(connection, parsed, data, callback);
     });
-
     const fetchWrapper = (prevHandler, connection, parsed, data, callback) => {
         // RFC 4466 2.4: fetch-modifiers are the last argument, a single fetch-att may take arguments of its own
         const attributes = parsed.attributes || [];
         const index = Math.max(attributes.length - 1, 2);
         const changedsince = getCondstoreValue(attributes[index], 'CHANGEDSINCE', attributes, index);
-
         if (changedsince) {
             if (!isValidModseq(changedsince)) {
                 return sendBad(connection, parsed, data, callback, 'Invalid syntax for CHANGEDSINCE, number expected');
@@ -154,20 +125,15 @@ module.exports = function (server) {
             // CHANGEDSINCE implicitly adds the MODSEQ data item
             addModseqItem(parsed);
         }
-
         if (changedsince || hasModseqItem(parsed)) {
             enableCondstore(connection, parsed, data);
         }
-
         prevHandler(connection, parsed, data, callback);
     };
-
     wrapHandler('FETCH', fetchWrapper);
     wrapHandler('UID FETCH', fetchWrapper);
-
     const storeWrapper = (prevHandler, connection, parsed, data, callback) => {
         const unchangedsince = getCondstoreValue(parsed.attributes && parsed.attributes[1], 'UNCHANGEDSINCE', parsed.attributes, 1);
-
         if (unchangedsince) {
             if (!isValidModseq(unchangedsince, true)) {
                 return sendBad(connection, parsed, data, callback, 'Invalid syntax for UNCHANGEDSINCE, number expected');
@@ -175,7 +141,6 @@ module.exports = function (server) {
             parsed.unchangedsince = Number(unchangedsince.value);
             enableCondstore(connection, parsed, data);
         }
-
         // Per command state for tracking changed messages
         parsed.condstoreStore = {
             isUid: (parsed.command || '').toUpperCase() === 'UID STORE',
@@ -183,32 +148,24 @@ module.exports = function (server) {
             modified: [],
             done: false
         };
-
         prevHandler(connection, parsed, data, callback);
     };
-
     wrapHandler('STORE', storeWrapper);
     wrapHandler('UID STORE', storeWrapper);
-
     // RFC 7162 section 3.1.5: MODSEQ [<entry-name> <entry-type-req>] <mod-sequence-valzer>. Mod-sequences
     // are not stored per flag, so the entry name and type are checked but otherwise ignored
     const searchModseq = (connection, message, index, ...args) => message.MODSEQ >= args[args.length - 1];
-    searchModseq.argumentTypes = list =>
-        typeof list[0] === 'string' && /^\d+$/.test(list[0]) ? [parseModseqValzer] : [parseEntryName, parseEntryType, parseModseqValzer];
+    searchModseq.argumentTypes = (list) => typeof list[0] === 'string' && /^\d+$/.test(list[0]) ? [parseModseqValzer] : [parseEntryName, parseEntryType, parseModseqValzer];
     server.searchHandlers.MODSEQ = searchModseq;
-
     // highest mod-sequence of a list of messages
-    const highestModseq = messages => messages.reduce((highest, message) => Math.max(highest, message.MODSEQ), 0);
-
+    const highestModseq = (messages) => messages.reduce((highest, message) => Math.max(highest, message.MODSEQ), 0);
     server.fetchHandlers.MODSEQ = function (connection, message) {
         return [message.MODSEQ]; // Must be a list
     };
-
     server.fetchFilters.push((connection, message, parsed, index) => {
         if ('changedsince' in parsed && !(parsed.changedsince < message.MODSEQ)) {
             return false;
         }
-
         // remember \Seen state, FETCH might set it implicitly
         if (!parsed.condstoreFetch) {
             parsed.condstoreFetch = new Map();
@@ -217,51 +174,43 @@ module.exports = function (server) {
             message,
             seen: message.flags.indexOf('\\Seen') >= 0
         });
-
         return true;
     });
-
     server.storeFilters.push((connection, message, parsed, index) => {
         const state = parsed.condstoreStore;
         if (!state) {
             return true;
         }
-
         if ('unchangedsince' in parsed && message.MODSEQ > parsed.unchangedsince) {
             // failed the UNCHANGEDSINCE test, reported with the MODIFIED response code
             state.modified.push(state.isUid ? message.uid : index);
             return false;
         }
-
         state.messages.set(message, {
             index,
             before: snapshot(message),
             bumped: false,
             reported: false
         });
-
         return true;
     });
-
     // Bumps MODSEQ if the message metadata was changed by the current STORE
     const checkStored = (connection, message, entry) => {
         if (!entry.bumped && snapshot(message) !== entry.before) {
             entry.bumped = true;
+            // STORE runs in the Selected state
             message.MODSEQ = bumpModseq(connection.selectedMailbox);
         }
     };
-
     server.outputHandlers.push((connection, response, description, parsed, data, extra) => {
         // Flag changes made by another session (RFC 7162 section 3.1), these are not responses to a command
         if (description === 'FLAG NOTIFICATION' && response && extra && isEnabled(connection)) {
             setModseqValue(response.attributes[2], extra.MODSEQ);
             return;
         }
-
         if (!parsed || !response) {
             return;
         }
-
         // Untagged FETCH responses caused by STORE
         if (description === 'FLAG UPDATE' && parsed.condstoreStore && extra && parsed.condstoreStore.messages.has(extra)) {
             const entry = parsed.condstoreStore.messages.get(extra);
@@ -273,10 +222,10 @@ module.exports = function (server) {
             }
             return;
         }
-
         // SEARCH, ESEARCH, SORT or THREAD with the MODSEQ search key, a CONDSTORE enabling command (RFC 7162 section 3.1).
         // `extra.list` holds the messages the response is about
-        const isSearch = ['SEARCH', 'SORT', 'THREAD'].includes(response.command) && [response.command, 'UID ' + response.command].includes(description);
+        const isSearch = ['SEARCH', 'SORT', 'THREAD'].includes(response.command) &&
+            [response.command, 'UID ' + response.command].includes(description);
         if ((isSearch || description === 'ESEARCH') && response.tag === '*' && extra && extra.keys && extra.keys.has('MODSEQ')) {
             enableCondstore(connection, parsed, data);
             // RFC 7162 section 3.1.9: THREAD responses are unchanged
@@ -288,16 +237,13 @@ module.exports = function (server) {
             }
             return;
         }
-
         // Untagged FETCH responses of FETCH, check for implicitly set \Seen
-        if (
-            response.tag === '*' &&
+        if (response.tag === '*' &&
             parsed.condstoreFetch &&
             response.attributes &&
             response.attributes[1] &&
             response.attributes[1].value === 'FETCH' &&
-            parsed.condstoreFetch.has(response.attributes[0])
-        ) {
+            parsed.condstoreFetch.has(response.attributes[0])) {
             const entry = parsed.condstoreFetch.get(response.attributes[0]);
             const message = entry.message;
             let changed = false;
@@ -316,12 +262,10 @@ module.exports = function (server) {
             }
             return;
         }
-
         // Tagged response of STORE
         if (response.tag === parsed.tag && parsed.condstoreStore && !parsed.condstoreStore.done) {
             const state = parsed.condstoreStore;
             state.done = true;
-
             state.messages.forEach((entry, message) => {
                 checkStored(connection, message, entry);
                 // .SILENT stores send no FETCH responses, CONDSTORE aware clients still need the new MODSEQ values
@@ -335,26 +279,19 @@ module.exports = function (server) {
                     ];
                     // RFC 7162 section 3.1: UID and MODSEQ in every untagged FETCH caused by STORE
                     attributes.unshift({ type: 'ATOM', value: 'UID' }, message.uid);
-                    connection.send(
-                        {
-                            tag: '*',
-                            attributes: [
-                                entry.index,
-                                {
-                                    type: 'ATOM',
-                                    value: 'FETCH'
-                                },
-                                attributes
-                            ]
-                        },
-                        'CONDSTORE MODSEQ UPDATE',
-                        parsed,
-                        data,
-                        message
-                    );
+                    connection.send({
+                        tag: '*',
+                        attributes: [
+                            entry.index,
+                            {
+                                type: 'ATOM',
+                                value: 'FETCH'
+                            },
+                            attributes
+                        ]
+                    }, 'CONDSTORE MODSEQ UPDATE', parsed, data, message);
                 }
             });
-
             // RFC 7162 section 3.1.3 example 11: MODIFIED can also go with the tagged NO of a STORE on expunged messages
             // (RFC 2180 section 4.2.3), it replaces EXPUNGEISSUED there since a response has only one response code
             if ((response.command === 'OK' || response.command === 'NO') && state.modified.length) {
@@ -372,11 +309,10 @@ module.exports = function (server) {
                             }
                         ]
                     }
-                ].concat((response.attributes || []).filter(attr => response.command === 'OK' || !attr || attr.type !== 'SECTION'));
+                ].concat((response.attributes || []).filter((attr) => response.command === 'OK' || !attr || attr.type !== 'SECTION'));
             }
             return;
         }
-
         if (description === 'ENABLED' && Array.isArray(extra) && extra.indexOf('CONDSTORE') >= 0) {
             // ENABLE CONDSTORE was issued
             if (!connection.condstoreEnabled) {
@@ -387,13 +323,11 @@ module.exports = function (server) {
             }
             return;
         }
-
         if (description === 'ENABLE' && parsed.condstoreReportHighest && connection.selectedMailbox) {
             parsed.condstoreReportHighest = false;
             sendHighestModseq(connection, connection.selectedMailbox, parsed, data);
             return;
         }
-
         // Add CONDSTORE info to SELECT and EXAMINE
         if ((description === 'EXAMINE' || description === 'SELECT') && response.tag === parsed.tag && connection.selectedMailbox) {
             // (CONDSTORE) option was used, show notice
@@ -404,17 +338,16 @@ module.exports = function (server) {
                         type: 'TEXT',
                         value: 'CONDSTORE is now enabled'
                     });
-                } else {
+                }
+                else {
                     last.value += ', CONDSTORE is now enabled';
                 }
             }
-
             // Send untagged info about highest modseq
             sendHighestModseq(connection, connection.selectedMailbox, parsed, data);
         }
     });
-};
-
+}
 // RFC 7162 section 7: mod-sequence-valzer = "0" / mod-sequence-value. Dovecot also accepts values above 63 bits
 function parseModseqValzer(value) {
     if (!isNumber(value, MAX_NUMBER64)) {
@@ -422,7 +355,6 @@ function parseModseqValzer(value) {
     }
     return Number(value);
 }
-
 // RFC 7162 section 7: entry-flag-name = DQUOTE "/flags/" attr-flag DQUOTE, attr-flag is a flag without "\Recent"
 function parseEntryName(value) {
     const match = value.match(/^\/flags\/(\\?)(.+)$/i);
@@ -431,7 +363,6 @@ function parseEntryName(value) {
     }
     return value;
 }
-
 // RFC 7162 section 7: entry-type-req = "priv" / "shared" / "all"
 function parseEntryType(value) {
     if (!['PRIV', 'SHARED', 'ALL'].includes(value.toUpperCase())) {
@@ -439,12 +370,10 @@ function parseEntryType(value) {
     }
     return value;
 }
-
 // Serialized message metadata, used to detect changes
 function snapshot(message) {
     return JSON.stringify([message.flags || [], message['X-GM-LABELS'] || []]);
 }
-
 function findItem(list, name) {
     if (!Array.isArray(list)) {
         return -1;
@@ -456,7 +385,6 @@ function findItem(list, name) {
     }
     return -1;
 }
-
 // Sets or adds the MODSEQ value in a FETCH response attribute list
 function setModseqValue(list, modseq) {
     if (!Array.isArray(list)) {
@@ -465,39 +393,30 @@ function setModseqValue(list, modseq) {
     const pos = findItem(list, 'MODSEQ');
     if (pos >= 0) {
         list[pos + 1] = [modseq];
-    } else {
-        list.push(
-            {
-                type: 'ATOM',
-                value: 'MODSEQ'
-            },
-            [modseq]
-        );
+    }
+    else {
+        list.push({
+            type: 'ATOM',
+            value: 'MODSEQ'
+        }, [modseq]);
     }
 }
-
 // Adds the UID to a FETCH response attribute list unless it is there already
 function setUidValue(list, uid) {
     if (Array.isArray(list) && findItem(list, 'UID') < 0) {
-        list.push(
-            {
-                type: 'ATOM',
-                value: 'UID'
-            },
-            uid
-        );
+        list.push({
+            type: 'ATOM',
+            value: 'UID'
+        }, uid);
     }
 }
-
 function isModseqAtom(item) {
     return !!item && item.type === 'ATOM' && String(item.value).toUpperCase() === 'MODSEQ';
 }
-
 function hasModseqItem(parsed) {
     const items = parsed.attributes && parsed.attributes[1];
     return Array.isArray(items) ? items.some(isModseqAtom) : isModseqAtom(items);
 }
-
 // Adds MODSEQ to the list of FETCH data items, unless it is already there
 function addModseqItem(parsed) {
     if (!parsed.attributes || !parsed.attributes[1] || hasModseqItem(parsed)) {
@@ -508,14 +427,13 @@ function addModseqItem(parsed) {
         const name = String(items.value).toUpperCase();
         const macro = items.type === 'ATOM' && Object.hasOwn(FETCH_MACROS, name) && FETCH_MACROS[name];
         // a single fetch-att keeps the arguments that follow it, eg. RFC 8970 PREVIEW (LAZY)
-        items = macro ? macro.map(value => ({ type: 'ATOM', value })) : [items].concat(parsed.attributes.splice(2));
+        items = macro ? macro.map((value) => ({ type: 'ATOM', value })) : [items].concat(parsed.attributes.splice(2));
     }
     parsed.attributes[1] = items.concat({
         type: 'ATOM',
         value: 'MODSEQ'
     });
 }
-
 function hasCondstoreOption(attributes, parent, index) {
     if (!attributes) {
         return false;
@@ -529,7 +447,6 @@ function hasCondstoreOption(attributes, parent, index) {
                 break;
             }
         }
-
         // remove parameter if no other memebers were left
         if (!attributes.length) {
             parent.splice(index, 1);
@@ -537,7 +454,6 @@ function hasCondstoreOption(attributes, parent, index) {
     }
     return !!condstoreOption;
 }
-
 function getCondstoreValue(attributes, name, parent, index) {
     if (!attributes) {
         return false;
@@ -552,12 +468,10 @@ function getCondstoreValue(attributes, name, parent, index) {
                 break;
             }
         }
-
         // remove parameter if no other memebers were left
         if (!attributes.length) {
             parent.splice(index, 1);
         }
     }
-
     return condstoreValue;
 }

package/dist/esm/plugins/context-search.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @help Adds CONTEXT=SEARCH [RFC5267] capability, loads ESEARCH as well
+ * @help SEARCH RETURN (UPDATE) sends ADDTO and REMOVEFROM updates as the result changes, until CANCELUPDATE or the mailbox is closed
+ * @help SEARCH RETURN (PARTIAL 1:100) returns a window of the results, the CONTEXT hint is accepted and ignored
+ * @help Server option "maxSearchContexts" (default 10) limits the updating contexts of a session, above it NOUPDATE is sent
+ */
+import type { IMAPServer } from '../types.js';
+export default function contextSearchPlugin(server: IMAPServer): void;