imapkit 4.0.3 → 4.1.1

package/dist/cjs/commands/delete.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = deleteCommand;
+function deleteCommand(connection, parsed, data, callback) {
+    if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'DELETE expects mailbox name'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    const path = parsed.attributes[0].value;
+    const mailbox = connection.server.getMailbox(path);
+    if (!mailbox) {
+        connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', 'DELETE FAILED');
+        return callback();
+    }
+    try {
+        connection.server.deleteMailbox(path);
+    }
+    catch (err) {
+        const E = err;
+        connection.sendStatus(parsed, data, 'NO', E.message, E.code, 'DELETE FAILED');
+        return callback();
+    }
+    connection.server.mailboxChanged('delete', mailbox.path, { mailbox });
+    // RFC 2180 section 3.3: the other sessions that have the mailbox selected are disconnected with an untagged
+    // BYE (RFC 2683 section 3.1.2), as they can not be told about the deletion in any other way
+    connection.server.connections.forEach(other => {
+        if (other !== connection && other.selectedMailbox === mailbox) {
+            other.bye('Selected mailbox was deleted', 'MAILBOX DELETED');
+        }
+    });
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'DELETE completed'
+            }
+        ]
+    }, 'DELETE', parsed, data);
+    return callback();
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/commands/examine.d.ts

@@ -0,0 +1,2 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function examineCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;

package/dist/cjs/commands/examine.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = examineCommand;
+const select_js_1 = require("./select.js");
+function examineCommand(connection, parsed, data, callback) {
+    return (0, select_js_1.selectMailbox)(connection, parsed, data, callback, true);
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/commands/expunge.d.ts

@@ -0,0 +1,2 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function expungeCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;

package/dist/cjs/commands/expunge.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = expungeCommand;
+function expungeCommand(connection, parsed, data, callback) {
+    if (connection.refuseReadOnly(parsed, data, 'EXPUNGE FAILED')) {
+        return callback();
+    }
+    connection.expungeDeleted(connection.selectedMailbox, false, true);
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'EXPUNGE Completed'
+            }
+        ]
+    }, 'EXPUNGE', parsed, data);
+    callback();
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/commands/fetch.d.ts

@@ -0,0 +1,23 @@
+import type { Attribute, Callback, FetchHandler, IMAPConnection, Message, ParsedCommand } from '../types.js';
+declare const macros: Record<string, string[]>;
+/**
+ * Builds the data list of a FETCH response for a message, without any side effects like setting \Seen
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} message Message object
+ * @param {Array} params Fetch items
+ * @param {Array} [handlers] Handlers from getHandlers
+ * @param {Array} [names] Names from responseNames
+ * @return {Array} FETCH data items
+ * @throws {Error} for an unknown item or invalid item arguments
+ */
+declare function fetchResponse(connection: IMAPConnection, message: Message, params: Attribute[], handlers?: FetchHandler[], names?: Attribute[]): Attribute[];
+/**
+ * Shared implementation of FETCH and UID FETCH
+ *
+ * @param {Boolean} isUid If true, the sequence set lists UIDs and UID is always included in the response
+ */
+declare function processFetch(isUid: boolean, connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;
+declare const fetchCommand: (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+export default fetchCommand;
+export { processFetch, macros, fetchResponse };

package/dist/cjs/commands/fetch.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.macros = void 0;
+exports.processFetch = processFetch;
+exports.fetchResponse = fetchResponse;
+const fetch_js_1 = __importDefault(require("./handlers/fetch.js"));
+const macros = {
+    ALL: ['FLAGS', 'INTERNALDATE', 'RFC822.SIZE', 'ENVELOPE'],
+    FAST: ['FLAGS', 'INTERNALDATE', 'RFC822.SIZE'],
+    FULL: ['FLAGS', 'INTERNALDATE', 'RFC822.SIZE', 'ENVELOPE', 'BODY']
+};
+exports.macros = macros;
+/**
+ * Returns the item names as they appear in a FETCH response, without .PEEK and only with the origin
+ * octet of a partial range (RFC 3501 section 7.4.2)
+ *
+ * @param {Array} params Fetch items
+ * @return {Array} names
+ */
+function responseNames(params) {
+    return params.map((param) => {
+        const name = Object.assign({}, param, { value: param.value.replace(/\.PEEK\b/i, '') });
+        if (name.partial) {
+            name.partial = name.partial.slice(0, 1);
+        }
+        return name;
+    });
+}
+/**
+ * Returns the handlers of fetch items
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Array} params Fetch items
+ * @return {Array} handlers
+ * @throws {Error} for an unknown item
+ */
+function getHandlers(connection, params) {
+    return params.map((param, i) => {
+        const key = (param.value || '').toUpperCase();
+        const handler = connection.server.fetchHandlers[key] || fetch_js_1.default[key];
+        if (!handler) {
+            throw new Error('Invalid FETCH argument ' + (key || '#' + (i + 1)));
+        }
+        return handler;
+    });
+}
+/**
+ * Builds the data list of a FETCH response for a message, without any side effects like setting \Seen
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} message Message object
+ * @param {Array} params Fetch items
+ * @param {Array} [handlers] Handlers from getHandlers
+ * @param {Array} [names] Names from responseNames
+ * @return {Array} FETCH data items
+ * @throws {Error} for an unknown item or invalid item arguments
+ */
+function fetchResponse(connection, message, params, handlers, names) {
+    const itemHandlers = handlers || getHandlers(connection, params);
+    const itemNames = names || responseNames(params);
+    const response = [];
+    params.forEach((param, i) => response.push(itemNames[i], itemHandlers[i](connection, message, param)));
+    return response;
+}
+/**
+ * Shared implementation of FETCH and UID FETCH
+ *
+ * @param {Boolean} isUid If true, the sequence set lists UIDs and UID is always included in the response
+ */
+function processFetch(isUid, connection, parsed, data, callback) {
+    const command = isUid ? 'UID FETCH' : 'FETCH';
+    if (!parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        ['ATOM', 'SEQUENCE'].indexOf(parsed.attributes[0].type) < 0 ||
+        !parsed.attributes[1] ||
+        (['ATOM'].indexOf(parsed.attributes[1].type) < 0 && !Array.isArray(parsed.attributes[1]))) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: command + ' expects sequence set and message item names'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    const range = connection.limitRange(parsed, connection.getCommandRange(parsed.attributes[0].value, isUid));
+    let params = [].concat(parsed.attributes[1] || []);
+    if (parsed.attributes[1].type === 'ATOM' && Object.prototype.hasOwnProperty.call(macros, parsed.attributes[1].value.toUpperCase())) {
+        params = macros[parsed.attributes[1].value.toUpperCase()].slice();
+    }
+    // messages that get \Seen set by this FETCH
+    const seen = [];
+    // untagged FETCH responses and their messages
+    const responses = [];
+    const messages = [];
+    try {
+        let uidExist = false;
+        let flagsExist = false;
+        let forceSeen = false;
+        params.forEach((param, i) => {
+            if (!param || (typeof param !== 'string' && param.type !== 'ATOM')) {
+                throw new Error('Invalid FETCH argument #' + (i + 1));
+            }
+            if (typeof param === 'string') {
+                param = params[i] = {
+                    type: 'ATOM',
+                    value: param
+                };
+            }
+            const key = param.value.toUpperCase();
+            if (key === 'FLAGS') {
+                flagsExist = true;
+            }
+            if (key === 'UID') {
+                uidExist = true;
+            }
+            // RFC 3501 6.4.5: BODY[<section>] and items whose handler is marked with setsSeen set \Seen
+            const handler = connection.server.fetchHandlers[key] || fetch_js_1.default[key];
+            if (connection.canSetSeen() && ((key === 'BODY' && param.section) || (handler && handler.setsSeen))) {
+                forceSeen = true;
+            }
+        });
+        if (forceSeen && !flagsExist) {
+            params.push({
+                type: 'ATOM',
+                value: 'FLAGS'
+            });
+        }
+        if (isUid && !uidExist) {
+            params.push({
+                type: 'ATOM',
+                value: 'UID'
+            });
+        }
+        const handlers = getHandlers(connection, params);
+        // item names as they appear in the response
+        const names = responseNames(params);
+        // nothing is sent before every message is done, so a failing item leaves no partial output
+        range.forEach(rangeMessage => {
+            for (let i = 0, len = connection.server.fetchFilters.length; i < len; i++) {
+                if (!connection.server.fetchFilters[i](connection, rangeMessage[1], parsed, rangeMessage[0])) {
+                    return;
+                }
+            }
+            if (forceSeen && rangeMessage[1].flags.indexOf('\\Seen') < 0) {
+                rangeMessage[1].flags.push('\\Seen');
+                seen.push(rangeMessage[1]);
+            }
+            const response = fetchResponse(connection, rangeMessage[1], params, handlers, names);
+            messages.push(rangeMessage[1]);
+            responses.push({
+                tag: '*',
+                attributes: [
+                    rangeMessage[0],
+                    {
+                        type: 'ATOM',
+                        value: 'FETCH'
+                    },
+                    response
+                ]
+            });
+        });
+    }
+    catch (err) {
+        const E = err;
+        // the failed FETCH did not set \Seen after all
+        seen.forEach(message => connection.server.removeFlag(message.flags, '\\Seen'));
+        // a handler can fail with NO and a response code, e.g. NO [UNKNOWN-CTE] (RFC 3516 section 4.3)
+        connection.sendStatus(parsed, data, E.imapResponse === 'NO' ? 'NO' : 'BAD', E.message, E.code, command + ' FAILED');
+        return callback();
+    }
+    // the message goes with its response, for output handlers
+    responses.forEach((response, i) => connection.send(response, command, parsed, data, messages[i]));
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: command + ' Completed'
+            }
+        ]
+    }, command, parsed, data);
+    // other sessions that have the mailbox selected learn about the new flags (RFC 3501 section 5.2)
+    connection.notifyFlagChanges(seen);
+    return callback();
+}
+const fetchCommand = (connection, parsed, data, callback) => processFetch(false, connection, parsed, data, callback);
+exports.default = fetchCommand;
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/commands/handlers/fetch.d.ts

@@ -0,0 +1,12 @@
+import type { FetchHandler } from '../../types.js';
+declare const fetchHandlers: Record<string, FetchHandler>;
+export default fetchHandlers;
+/**
+ * Applies the partial range of a BODY[]<start.length> or BINARY[]<start.length> item
+ *
+ * @param {String} value Section contents
+ * @param {Array} [partial] Parsed partial range
+ * @return {String} The requested slice, or the whole value without a range
+ */
+declare function applyPartial(value: string, partial: number[] | null | undefined): string;
+export { applyPartial };

package/dist/cjs/commands/handlers/fetch.js

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPartial = applyPartial;
+const mimeparser_js_1 = require("../../mimeparser.js");
+const bodystructure_js_1 = __importDefault(require("../../bodystructure.js"));
+const envelope_js_1 = __importDefault(require("../../envelope.js"));
+const fetchHandlers = {};
+exports.default = fetchHandlers;
+// not an IMAP item, so not enumerable among the handlers
+Object.defineProperty(fetchHandlers, 'applyPartial', { value: applyPartial });
+fetchHandlers.UID = function (connection, message) {
+    return message.uid;
+};
+fetchHandlers.FLAGS = function (connection, message) {
+    return connection.getFlags(message).map(flag => {
+        return {
+            type: 'ATOM',
+            value: flag
+        };
+    });
+};
+fetchHandlers.BODYSTRUCTURE = function (connection, message) {
+    return (0, bodystructure_js_1.default)((0, mimeparser_js_1.getMessageData)(message).tree, {
+        upperCaseKeys: true,
+        skipContentLocation: true,
+        messageGlobal: connection.messageGlobal
+    });
+};
+fetchHandlers.ENVELOPE = function (connection, message) {
+    return (0, envelope_js_1.default)((0, mimeparser_js_1.getMessageData)(message).tree.parsedHeader);
+};
+fetchHandlers['BODY.PEEK'] = function (connection, message, query) {
+    if (!query.section) {
+        throw new Error('BODY.PEEK requires ans argument list');
+    }
+    return fetchHandlers.BODY(connection, message, query);
+};
+/**
+ * Lists the header field names of a HEADER.FIELDS or HEADER.FIELDS.NOT section
+ */
+function getFieldNames(query, key) {
+    if (query.section.length !== 2 || !Array.isArray(query.section[1]) || !query.section[1].length) {
+        throw new Error(key + ' expects a list of header fields');
+    }
+    return query.section[1].map((queryKey) => {
+        if (['ATOM', 'STRING', 'LITERAL'].indexOf(queryKey.type) < 0) {
+            throw new Error('Invalid header field name in list');
+        }
+        queryKey.type = 'ATOM'; // ensure that literals are not passed back in the response
+        return queryKey.value.toUpperCase();
+    });
+}
+/**
+ * Returns the contents of a BODY[<section>]
+ *
+ * @param {Object} data Message data from getMessageData()
+ * @param {Object} query Parsed fetch item
+ * @param {Boolean} [global] message/global parts encapsulate a message, see IMAPConnection#messageGlobal
+ * @return {String} Section contents
+ */
+function getSection(data, query, global) {
+    if (!query.section.length) {
+        return data.raw;
+    }
+    if (query.section[0].type !== 'ATOM') {
+        throw new Error('Invalid BODY[<section>] identifier' + (query.section[0].value ? ' ' + query.section[0].type : ''));
+    }
+    // RFC 3501 9: section-part = nz-number *("." nz-number), optionally followed by a section-msgtext
+    // (or MIME for a part)
+    const match = (query.section[0].value || '')
+        .toUpperCase()
+        .match(/^((?:[1-9]\d*)(?:\.[1-9]\d*)*)?(?:(?:^|\.)(HEADER|HEADER\.FIELDS|HEADER\.FIELDS\.NOT|TEXT|MIME))?$/);
+    if (!match || (match[2] === 'MIME' && !match[1])) {
+        throw new Error('Invalid BODY[<section>] identifier ' + query.section[0].value);
+    }
+    const path = match[1] || '';
+    const key = match[2] || '';
+    let fields = [];
+    if (['HEADER.FIELDS', 'HEADER.FIELDS.NOT'].indexOf(key) >= 0) {
+        fields = getFieldNames(query, key);
+    }
+    else if (query.section.length > 1) {
+        throw new Error((key || 'Part number') + ' does not take any arguments');
+    }
+    // RFC 3501 6.4.5: a part that does not exist is returned as an empty string
+    const node = path ? (0, mimeparser_js_1.resolveNode)(data.tree, path, global) : data.tree;
+    if (!node) {
+        return '';
+    }
+    // HEADER and TEXT with a part number refer to the encapsulated message of a message/rfc822 part
+    // (and message/global in IMAP4rev2, RFC 9051 section 6.4.5.1), not to the part itself
+    const message = path ? (0, mimeparser_js_1.embeddedMessage)(node, global) : node;
+    switch (key) {
+        case '':
+            // BODY[1.2.3] is a part without its MIME header
+            return (0, mimeparser_js_1.render)(node, true);
+        case 'MIME':
+            return (0, mimeparser_js_1.headerSection)(node);
+        case 'TEXT':
+            return message ? (0, mimeparser_js_1.render)(message, true) : '';
+        case 'HEADER':
+            return message ? (0, mimeparser_js_1.headerSection)(message) : '';
+        default: {
+            // HEADER.FIELDS and HEADER.FIELDS.NOT
+            if (!message) {
+                return '';
+            }
+            const wanted = key === 'HEADER.FIELDS';
+            let value = '';
+            (message.header || []).forEach((line) => {
+                const name = line.split(':')[0].toUpperCase().trim();
+                if (fields.indexOf(name) >= 0 === wanted) {
+                    value += line + '\r\n';
+                }
+            });
+            return value + '\r\n';
+        }
+    }
+}
+/**
+ * Applies the partial range of a BODY[]<start.length> or BINARY[]<start.length> item
+ *
+ * @param {String} value Section contents
+ * @param {Array} [partial] Parsed partial range
+ * @return {String} The requested slice, or the whole value without a range
+ */
+function applyPartial(value, partial) {
+    if (!partial) {
+        return value;
+    }
+    // RFC 3501 9: partial = "<" number "." nz-number ">"
+    if (partial.length !== 2 || !(partial[1] > 0)) {
+        throw new Error('Invalid partial range, expecting <start.length>');
+    }
+    return value.substr(partial[0], partial[1]);
+}
+fetchHandlers.BODY = function (connection, message, query) {
+    const data = (0, mimeparser_js_1.getMessageData)(message);
+    if (!query.section) {
+        if (query.partial) {
+            throw new Error('BODY without a section does not take a partial range');
+        }
+        return (0, bodystructure_js_1.default)(data.tree, {
+            body: true,
+            upperCaseKeys: true,
+            messageGlobal: connection.messageGlobal
+        });
+    }
+    return {
+        type: 'LITERAL',
+        value: applyPartial(getSection(data, query, connection.messageGlobal), query.partial)
+    };
+};
+fetchHandlers.INTERNALDATE = function (connection, message) {
+    return message.internaldate;
+};
+fetchHandlers.RFC822 = function (connection, message) {
+    return {
+        type: 'LITERAL',
+        value: (0, mimeparser_js_1.getMessageData)(message).raw
+    };
+};
+// RFC 3501 6.4.5: RFC822 and RFC822.TEXT set \Seen, RFC822.HEADER is BODY.PEEK[HEADER] and does not
+fetchHandlers.RFC822.setsSeen = true;
+fetchHandlers['RFC822.SIZE'] = function (connection, message) {
+    return (0, mimeparser_js_1.getMessageData)(message).raw.length;
+};
+fetchHandlers['RFC822.HEADER'] = function (connection, message) {
+    return {
+        type: 'LITERAL',
+        value: (0, mimeparser_js_1.headerSection)((0, mimeparser_js_1.getMessageData)(message).tree)
+    };
+};
+fetchHandlers['RFC822.TEXT'] = function (connection, message) {
+    return {
+        type: 'LITERAL',
+        value: (0, mimeparser_js_1.render)((0, mimeparser_js_1.getMessageData)(message).tree, true)
+    };
+};
+fetchHandlers['RFC822.TEXT'].setsSeen = true;
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/commands/handlers/flags.d.ts

@@ -0,0 +1,17 @@
+import type { IMAPConnection } from '../../types.js';
+declare const INVALID_KEYWORD_CHAR: RegExp;
+/**
+ * System flags are case-insensitive, so "\seen" becomes "\Seen"
+ *
+ * @param {String} flag Flag value
+ * @return {String} Normalized flag
+ */
+declare function normalizeSystemFlag(flag: string): string;
+/**
+ * Throws if a flag can not be stored: an unknown system flag (including \Recent) or an invalid keyword
+ *
+ * @param {Object} connection IMAP connection
+ * @param {String} flag Normalized flag value
+ */
+declare function checkSystemFlags(connection: IMAPConnection, flag: string): void;
+export { INVALID_KEYWORD_CHAR, normalizeSystemFlag, checkSystemFlags };

package/dist/cjs/commands/handlers/flags.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVALID_KEYWORD_CHAR = void 0;
+exports.normalizeSystemFlag = normalizeSystemFlag;
+exports.checkSystemFlags = checkSystemFlags;
+// RFC 3501 9: flag-keyword = atom = 1*ATOM-CHAR, so a keyword can not contain atom-specials:
+// "(" / ")" / "{" / SP / CTL / list-wildcards / quoted-specials / resp-specials. 8-bit octets are
+// allowed, the parser accepts them in atoms as well
+// eslint-disable-next-line no-control-regex
+const INVALID_KEYWORD_CHAR = /[\x00-\x1f\x7f (){%*"\\\]]/;
+exports.INVALID_KEYWORD_CHAR = INVALID_KEYWORD_CHAR;
+/**
+ * System flags are case-insensitive, so "\seen" becomes "\Seen"
+ *
+ * @param {String} flag Flag value
+ * @return {String} Normalized flag
+ */
+function normalizeSystemFlag(flag) {
+    if (flag.charAt(0) === '\\') {
+        flag = flag.charAt(0) + flag.charAt(1).toUpperCase() + flag.substr(2).toLowerCase();
+    }
+    return flag;
+}
+/**
+ * Throws if a flag can not be stored: an unknown system flag (including \Recent) or an invalid keyword
+ *
+ * @param {Object} connection IMAP connection
+ * @param {String} flag Normalized flag value
+ */
+function checkSystemFlags(connection, flag) {
+    if (flag.charAt(0) === '\\') {
+        if (connection.server.systemFlags.indexOf(flag) < 0) {
+            throw new Error('Invalid system flag ' + flag);
+        }
+    }
+    else if (!flag || INVALID_KEYWORD_CHAR.test(flag)) {
+        throw new Error('Invalid flag keyword ' + JSON.stringify(flag));
+    }
+}