imapkit 4.0.2 → 4.1.0

package/dist/cjs/esearch.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSequenceSet = toSequenceSet;
+exports.toOrderedSet = toOrderedSet;
+exports.selectReturned = selectReturned;
+exports.selectPartial = selectPartial;
+exports.parsePartialRange = parsePartialRange;
+exports.registerPartialOption = registerPartialOption;
+exports.buildCorrelator = buildCorrelator;
+exports.buildEsearchResponse = buildEsearchResponse;
+const search_js_1 = require("./commands/handlers/search.js");
+const numbers_js_1 = require("./numbers.js");
+/**
+ * ESEARCH response helpers (RFC 4731, RFC 4466 section 2.6.2). Used by the ESEARCH, SEARCHRES, PARTIAL,
+ * CONTEXT=SEARCH and MULTISEARCH plugins, and meant to be reused where SEARCH always answers with ESEARCH (IMAP4rev2, RFC 9051).
+ */
+/**
+ * Formats a list of numbers as a compact sequence-set, e.g. [1, 2, 3, 5] becomes "1:3,5"
+ *
+ * @param {Array} numbers List of nz-numbers, in any order
+ * @return {String} sequence-set, empty for an empty list
+ */
+function toSequenceSet(numbers) {
+    return toOrderedSet(Array.from(new Set(numbers)).sort((a, b) => a - b));
+}
+/**
+ * Formats a list of numbers as a sequence-set that keeps their order, for SORT results (RFC 5267
+ * section 3.2): only runs of ascending consecutive numbers become ranges, e.g. [5, 3, 4, 2] becomes "5,3:4,2"
+ *
+ * @param {Array} numbers List of nz-numbers in the requested order
+ * @return {String} sequence-set, empty for an empty list
+ */
+function toOrderedSet(numbers) {
+    const ranges = [];
+    numbers.forEach(nr => {
+        const last = ranges[ranges.length - 1];
+        if (last && last[1] + 1 === nr) {
+            last[1] = nr;
+        }
+        else {
+            ranges.push([nr, nr]);
+        }
+    });
+    return ranges.map(range => (range[0] === range[1] ? String(range[0]) : range[0] + ':' + range[1])).join(',');
+}
+/**
+ * Parses the argument of the PARTIAL search return option (RFC 5267 section 4.4, RFC 9394 section 4):
+ * partial-range-first = nz-number ":" nz-number, partial-range-last = "-" nz-number ":" "-" nz-number.
+ * "*" is not allowed, and 500:400 is the same as 400:500
+ *
+ * @param {Object} item Parsed argument
+ * @param {Boolean} allowLast If true, the partial-range-last form of RFC 9394 is accepted
+ * @return {Object} `{ range, from, to, fromEnd }`, `range` is the argument as the client sent it
+ */
+function parsePartialRange(item, allowLast) {
+    const value = item && ['ATOM', 'SEQUENCE'].includes(item.type) ? String(item.value) : '';
+    const match = value.match(/^(-?)([1-9][0-9]*):(-?)([1-9][0-9]*)$/);
+    if (!match || match[1] !== match[3] || (match[1] && !allowLast)) {
+        throw (0, search_js_1.badError)('PARTIAL expects a range like 1:100' + (allowLast ? ' or -1:-100' : ''));
+    }
+    const first = Number(match[2]);
+    const last = Number(match[4]);
+    if (first > numbers_js_1.MAX_NUMBER || last > numbers_js_1.MAX_NUMBER) {
+        throw (0, search_js_1.badError)('PARTIAL range is out of bounds');
+    }
+    return { range: value, from: Math.min(first, last), to: Math.max(first, last), fromEnd: !!match[1] };
+}
+/**
+ * Picks the results that a PARTIAL range refers to. The first result is 1, and -1 is the last one
+ * (RFC 9394 section 3.1). Results outside the list are left out
+ *
+ * @param {Array} list Results in mailbox order
+ * @param {Object} partial Parsed range, see parsePartialRange
+ * @return {Array} results in the range, in mailbox order
+ */
+function selectPartial(list, partial) {
+    if (!partial.fromEnd) {
+        return list.slice(partial.from - 1, partial.to);
+    }
+    return list.slice(Math.max(list.length - partial.to, 0), Math.max(list.length - partial.from + 1, 0));
+}
+/**
+ * Registers the PARTIAL search return option, shared by the PARTIAL and CONTEXT=SEARCH plugins. The
+ * partial-range-last form (-1:-100) is only valid with the PARTIAL capability (RFC 9394 section 4)
+ *
+ * @param {Object} server IMAP server, with the ESEARCH plugin loaded
+ */
+function registerPartialOption(server) {
+    if (server.searchReturnOptions.has('PARTIAL')) {
+        return;
+    }
+    server.searchReturnOptions.set('PARTIAL', { data: true, once: true, parse: (item) => parsePartialRange(item, !!server.partialRangeLast) });
+    // RFC 5267 section 4.4 and RFC 9394 section 3.1: a command MUST NOT contain more than one PARTIAL or ALL
+    server.searchReturnOptions.set('ALL', Object.assign({}, server.searchReturnOptions.get('ALL'), { once: true }));
+    server.searchReturnChecks.push((options) => options.has('PARTIAL') && options.has('ALL') && 'PARTIAL and ALL can not be used together');
+}
+/**
+ * Picks the messages that the requested result options return. With COUNT or ALL, or without
+ * MIN, MAX and PARTIAL, these are all matching messages, otherwise the lowest and/or the highest
+ * matching message and the ones in the PARTIAL range. This is the set that the MODSEQ result
+ * option describes (RFC 4731 section 3.2) and that SAVE stores (RFC 5182 section 2.4, RFC 9394
+ * section 3.2)
+ *
+ * @param {Array} list Matching messages, in mailbox order
+ * @param {Map} options Upper case result option names to their arguments, an empty map stands for ALL
+ * @return {Array} returned messages, in mailbox order
+ */
+function selectReturned(list, options) {
+    const partial = options.get('PARTIAL');
+    if (!list.length || options.has('ALL') || options.has('COUNT') || (!partial && !options.has('MIN') && !options.has('MAX'))) {
+        return list;
+    }
+    const returned = new Set(partial ? selectPartial(list, partial) : []);
+    if (options.has('MIN')) {
+        returned.add(list[0]);
+    }
+    if (options.has('MAX')) {
+        returned.add(list[list.length - 1]);
+    }
+    return list.filter(message => returned.has(message));
+}
+/**
+ * Builds the search correlator (RFC 4466 section 2.6.2), with the MAILBOX and UIDVALIDITY
+ * correlators of RFC 7377 section 4 if a mailbox is given
+ *
+ * @param {String} tag Tag of the command
+ * @param {Object} [mailbox] Mailbox the response is about
+ * @return {Array} correlator list
+ */
+function buildCorrelator(tag, mailbox) {
+    const correlator = [
+        { type: 'ATOM', value: 'TAG' },
+        { type: 'STRING', value: tag }
+    ];
+    if (mailbox) {
+        correlator.push({ type: 'ATOM', value: 'MAILBOX' }, 
+        // send() puts in the form of the name that the session uses
+        { type: 'MAILBOX', value: mailbox.path }, { type: 'ATOM', value: 'UIDVALIDITY' }, mailbox.uidvalidity);
+    }
+    return correlator;
+}
+/**
+ * Builds an ESEARCH response (RFC 4466 section 2.6.2) with the RFC 4731 section 3.1 return data
+ * and PARTIAL (RFC 5267 section 4.4, RFC 9394 section 3.1)
+ *
+ * @param {String} tag Tag of the command, for the search correlator
+ * @param {Boolean} isUid If true, the response lists UIDs and has the UID indicator
+ * @param {Object} result Search result, `{ list, numbers }` (see src/commands/handlers/search.ts)
+ * @param {Map} options Upper case result option names to their arguments, an empty map stands for ALL (RFC 4731 section 3.1)
+ * @param {Object} [mailbox] Adds the MAILBOX and UIDVALIDITY correlators of RFC 7377 for this mailbox
+ * @param {Array} [sorted] The matching messages in sort order, for an extended SORT (RFC 5267 section 3.1): MIN and MAX are
+ *        the first and the last sorted message, ALL and PARTIAL list the results in sort order
+ * @return {Object} response for connection.send()
+ */
+function buildEsearchResponse(tag, isUid, result, options, mailbox, sorted) {
+    const values = (sorted || result.list).map((message) => (isUid ? message.uid : result.numbers[message.uid]));
+    if (!sorted) {
+        values.sort((a, b) => a - b);
+    }
+    const toSet = sorted ? toOrderedSet : toSequenceSet;
+    const attributes = [buildCorrelator(tag, mailbox)];
+    if (isUid) {
+        attributes.push({ type: 'ATOM', value: 'UID' });
+    }
+    const add = (name, value) => attributes.push({ type: 'ATOM', value: name }, value);
+    // MIN, MAX and ALL are left out when nothing matched, COUNT is always included (RFC 4731 section 3.1)
+    if (values.length && options.has('MIN')) {
+        add('MIN', values[0]);
+    }
+    if (values.length && options.has('MAX')) {
+        add('MAX', values[values.length - 1]);
+    }
+    if (values.length && (options.has('ALL') || !options.size)) {
+        add('ALL', { type: 'SEQUENCE', value: toSet(values) });
+    }
+    if (options.has('PARTIAL')) {
+        // the requested range, and NIL when no results fall in it (RFC 9394 section 3.1)
+        const partial = options.get('PARTIAL');
+        const selected = selectPartial(values, partial);
+        add('PARTIAL', [{ type: 'ATOM', value: partial.range }, selected.length ? { type: 'SEQUENCE', value: toSet(selected) } : null]);
+    }
+    if (options.has('COUNT')) {
+        add('COUNT', values.length);
+    }
+    return {
+        tag: '*',
+        command: 'ESEARCH',
+        attributes
+    };
+}

package/dist/cjs/framing.d.ts

@@ -0,0 +1,66 @@
+/**
+ * IMAP framing helpers shared by the mock client, the test helpers and the compare tool.
+ * Both functions take a Buffer or a binary string (one character per octet).
+ */
+/** A line of a response: `end` excludes the CR before the LF, `lf` is the offset of the LF */
+export interface FrameLine {
+    start: number;
+    end: number;
+    lf: number;
+}
+/** The data of a literal in a response */
+export interface FrameLiteral {
+    start: number;
+    end: number;
+    literal8: boolean;
+}
+/** A complete response, its lines and the literals between them */
+export interface FramedResponse {
+    start: number;
+    end: number;
+    lines: FrameLine[];
+    literals: FrameLiteral[];
+}
+/** An unfinished response at the end of the data, see splitResponses() */
+export interface FrameIncomplete {
+    reason: 'line' | 'literal' | 'response';
+    lines: FrameLine[];
+    /** size of the literal that is cut short */
+    size?: number;
+    /** octets of that literal that were received */
+    available?: number;
+}
+/** Result of splitResponses() */
+export interface SplitResponses {
+    responses: FramedResponse[];
+    end: number;
+    incomplete: FrameIncomplete | false;
+}
+/**
+ * Splits received server data into responses. A response is one line, or a line that ends with a
+ * literal marker `{n}` or `~{n}` (RFC 3516 literal8), followed by n octets and the rest of the
+ * response. Lenient: lines end at LF, a CR before it is not required. Callers that need strict
+ * framing check the line ends themselves.
+ *
+ * @param {Buffer|String} data Received data, possibly ending with an incomplete response
+ * @return {Object} `{ responses, end, incomplete }`. Every response is `{ start, end, lines, literals }`,
+ *         where `lines` lists `{ start, end, lf }` (end excludes the CR before the LF, `lf` is the
+ *         offset of the LF) and `literals` lists `{ start, end, literal8 }`. `end` is the offset right
+ *         after the last complete response. `incomplete` is false when all data was used, otherwise
+ *         `{ reason, lines }` with the complete lines of the unfinished response, where reason is
+ *         'line' for a line without LF, 'literal' for literal data that is cut short (with `size`
+ *         and `available`), or 'response' when the data ends right after literal data.
+ */
+declare function splitResponses(data: Buffer | string): SplitResponses;
+/**
+ * Splits an outgoing command after every synchronizing literal marker, as a client must wait for the
+ * continuation request before it sends the literal data (RFC 3501 section 4.3). The data of every
+ * literal, synchronizing or not ({n+}, RFC 7888), is skipped, so markers inside it are not matched.
+ *
+ * @param {Buffer|String} payload Command, as a Buffer or a binary string
+ * @return {Array} Chunks to send, of the same type as the payload
+ */
+declare function splitAtLiterals(payload: Buffer): Buffer[];
+declare function splitAtLiterals(payload: string): string[];
+declare function splitAtLiterals(payload: Buffer | string): (Buffer | string)[];
+export { splitResponses, splitAtLiterals };

package/{lib → dist/cjs}/framing.js

@@ -1,13 +1,13 @@
-'use strict';
-
+"use strict";
 /**
  * IMAP framing helpers shared by the mock client, the test helpers and the compare tool.
  * Both functions take a Buffer or a binary string (one character per octet).
  */
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitResponses = splitResponses;
+exports.splitAtLiterals = splitAtLiterals;
 const LF = 0x0a;
 const CR = 0x0d;
-
 /**
  * Splits received server data into responses. A response is one line, or a line that ends with a
  * literal marker `{n}` or `~{n}` (RFC 3516 literal8), followed by n octets and the rest of the
@@ -26,20 +26,19 @@ const CR = 0x0d;
 function splitResponses(data) {
     const isBuffer = Buffer.isBuffer(data);
     const length = data.length;
-    const charAt = isBuffer ? i => data[i] : i => data.charCodeAt(i);
-    const slice = isBuffer ? (start, end) => data.toString('binary', start, end) : (start, end) => data.slice(start, end);
-
+    const charAt = isBuffer ? (i) => data[i] : (i) => data.charCodeAt(i);
+    const slice = isBuffer
+        ? (start, end) => data.toString('binary', start, end)
+        : (start, end) => data.slice(start, end);
     const responses = [];
     let pos = 0;
     let end = 0;
     let current = null;
-
     while (pos < length) {
-        const lf = data.indexOf(isBuffer ? LF : '\n', pos);
+        const lf = isBuffer ? data.indexOf(LF, pos) : data.indexOf('\n', pos);
         if (lf < 0) {
             return { responses, end, incomplete: { reason: 'line', lines: current ? current.lines : [] } };
         }
-
         const lineStart = pos;
         const lineEnd = lf > pos && charAt(lf - 1) === CR ? lf - 1 : lf;
         if (!current) {
@@ -47,7 +46,6 @@ function splitResponses(data) {
         }
         current.lines.push({ start: lineStart, end: lineEnd, lf });
         pos = lf + 1;
-
         // only lines that end with "}" can carry a literal marker, so most lines are not sliced
         const marker = lineEnd > lineStart && charAt(lineEnd - 1) === 0x7d && slice(Math.max(lineEnd - 32, lineStart), lineEnd).match(/(~?)\{(\d+)\}$/);
         if (marker) {
@@ -59,24 +57,13 @@ function splitResponses(data) {
             pos += size;
             continue;
         }
-
         current.end = end = pos;
         responses.push(current);
         current = null;
     }
-
     // the data ended right after a literal, the rest of the response is missing
     return { responses, end, incomplete: current ? { reason: 'response', lines: current.lines } : false };
 }
-
-/**
- * Splits an outgoing command after every synchronizing literal marker, as a client must wait for the
- * continuation request before it sends the literal data (RFC 3501 section 4.3). The data of every
- * literal, synchronizing or not ({n+}, RFC 7888), is skipped, so markers inside it are not matched.
- *
- * @param {Buffer|String} payload Command, as a Buffer or a binary string
- * @return {Array} Chunks to send, of the same type as the payload
- */
 function splitAtLiterals(payload) {
     const isBuffer = Buffer.isBuffer(payload);
     const str = isBuffer ? payload.toString('binary') : String(payload);
@@ -85,7 +72,6 @@ function splitAtLiterals(payload) {
     const re = /~?\{(\d+)(\+?)\}\r\n/g;
     let start = 0;
     let match;
-
     while ((match = re.exec(str))) {
         const end = match.index + match[0].length;
         if (!match[2]) {
@@ -95,8 +81,5 @@ function splitAtLiterals(payload) {
         re.lastIndex = end + Number(match[1]);
     }
     chunks.push(cut(start));
-
     return chunks.filter(chunk => chunk.length);
 }
-
-module.exports = { splitResponses, splitAtLiterals };

package/dist/cjs/index.d.ts

@@ -0,0 +1,9 @@
+import createServer, { TAG_REGEX, IMAPServer, IMAPConnection } from './server.js';
+export { TAG_REGEX, IMAPServer, IMAPConnection };
+export type { Attribute, ParsedCommand, IMAPResponse, Notification, Callback, CommandHandler, CommandOptions, Plugin, IMAPError, Message, Mailbox, StorageNamespace, UserData, IMAPServerOptions } from './types.js';
+declare const imapkit: typeof createServer & {
+    TAG_REGEX: RegExp;
+    IMAPServer: typeof IMAPServer;
+    IMAPConnection: typeof IMAPConnection;
+};
+export default imapkit;

package/dist/cjs/index.js

@@ -0,0 +1,56 @@
+"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.IMAPConnection = exports.IMAPServer = exports.TAG_REGEX = void 0;
+const server_js_1 = __importStar(require("./server.js"));
+Object.defineProperty(exports, "TAG_REGEX", { enumerable: true, get: function () { return server_js_1.TAG_REGEX; } });
+Object.defineProperty(exports, "IMAPServer", { enumerable: true, get: function () { return server_js_1.IMAPServer; } });
+Object.defineProperty(exports, "IMAPConnection", { enumerable: true, get: function () { return server_js_1.IMAPConnection; } });
+// `imapkit(options)` creates a server. TAG_REGEX was a property of the CommonJS export, it and the
+// classes are properties of the factory with both module formats
+const imapkit = Object.assign(server_js_1.default, { TAG_REGEX: server_js_1.TAG_REGEX, IMAPServer: server_js_1.IMAPServer, IMAPConnection: server_js_1.IMAPConnection });
+exports.default = imapkit;
+{
+    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/list-extensions.d.ts

@@ -0,0 +1,50 @@
+import type { Attribute, IMAPConnection, IMAPServer, Mailbox, ParsedCommand } from './types.js';
+/** An extended LIST selection option, see getListExtensions() */
+export interface ListSelectionOption {
+    type: 'base' | 'independent' | 'modifier';
+    returnOption?: string;
+    includeNonExistent?: boolean;
+    match?: (folder: Mailbox, connection: IMAPConnection) => boolean;
+}
+/** What onItem() of a return option learns about a listed mailbox */
+export interface ListItemInfo {
+    /** the mailbox matched the selection criteria */
+    matched: boolean;
+    /** the mailbox is not \NonExistent */
+    exists: boolean;
+}
+/** An extended LIST return option, see getListExtensions() */
+export interface ListReturnOption {
+    parse?: (list: Attribute, connection: IMAPConnection) => any;
+    onItem?: (connection: IMAPConnection, folder: Mailbox, value: any, info: ListItemInfo, parsed: ParsedCommand, data: string) => void;
+}
+/** The registry of extended LIST options */
+export interface ListExtensions {
+    enabled: boolean;
+    selectionOptions: Record<string, ListSelectionOption>;
+    returnOptions: Record<string, ListReturnOption>;
+}
+/**
+ * Returns the registry of extended LIST options (RFC 5258 section 3), shared by the LIST-EXTENDED
+ * plugin and the plugins that add their own options (SPECIAL-USE, LIST-STATUS). These can be loaded
+ * in any order, so whichever comes first creates the registry. Options are only accepted when the
+ * LIST-EXTENDED plugin is loaded (`enabled`).
+ *
+ * Selection options: `{ type, returnOption, includeNonExistent, match(folder, connection) }`
+ *   - `type` is "base", "independent" or "modifier" (list-select-base-opt, list-select-independent-opt
+ *     and list-select-mod-opt in the RFC 5258 section 6 grammar)
+ *   - `returnOption` is the return option the selection option implies
+ *   - `match` is the filter the mailboxes must pass, `includeNonExistent` if it can select mailbox
+ *     names that do not exist (like SUBSCRIBED)
+ *
+ * Return options: `{ parse(list, connection), onItem(connection, folder, value, info, parsed, data) }`
+ *   - `parse` is set for options that take a value (option-value), it returns the parsed value or
+ *     throws an Error with a message for the BAD response
+ *   - `onItem` runs after the LIST response of every listed mailbox. `info.matched` is true if the
+ *     mailbox matched the selection criteria, `info.exists` if it is not \NonExistent
+ *
+ * @param {Object} server IMAPServer instance
+ * @return {Object} `{ enabled, selectionOptions, returnOptions }`
+ */
+declare function getListExtensions(server: IMAPServer): ListExtensions;
+export { getListExtensions };

package/dist/cjs/list-extensions.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getListExtensions = getListExtensions;
+/**
+ * Returns the registry of extended LIST options (RFC 5258 section 3), shared by the LIST-EXTENDED
+ * plugin and the plugins that add their own options (SPECIAL-USE, LIST-STATUS). These can be loaded
+ * in any order, so whichever comes first creates the registry. Options are only accepted when the
+ * LIST-EXTENDED plugin is loaded (`enabled`).
+ *
+ * Selection options: `{ type, returnOption, includeNonExistent, match(folder, connection) }`
+ *   - `type` is "base", "independent" or "modifier" (list-select-base-opt, list-select-independent-opt
+ *     and list-select-mod-opt in the RFC 5258 section 6 grammar)
+ *   - `returnOption` is the return option the selection option implies
+ *   - `match` is the filter the mailboxes must pass, `includeNonExistent` if it can select mailbox
+ *     names that do not exist (like SUBSCRIBED)
+ *
+ * Return options: `{ parse(list, connection), onItem(connection, folder, value, info, parsed, data) }`
+ *   - `parse` is set for options that take a value (option-value), it returns the parsed value or
+ *     throws an Error with a message for the BAD response
+ *   - `onItem` runs after the LIST response of every listed mailbox. `info.matched` is true if the
+ *     mailbox matched the selection criteria, `info.exists` if it is not \NonExistent
+ *
+ * @param {Object} server IMAPServer instance
+ * @return {Object} `{ enabled, selectionOptions, returnOptions }`
+ */
+function getListExtensions(server) {
+    if (!server.listExtensions) {
+        server.listExtensions = {
+            enabled: false,
+            selectionOptions: Object.create(null),
+            returnOptions: Object.create(null)
+        };
+    }
+    return server.listExtensions;
+}

package/dist/cjs/load-plugins.d.ts

@@ -0,0 +1,21 @@
+import type { IMAPServer, Plugin } from './types.js';
+/**
+ * Lists the names of the built-in plugins (file names without extension)
+ *
+ * @return {Array} plugin names
+ */
+declare function listPlugins(): string[];
+/**
+ * Loads plugins for a server instance. Built-in plugins are referenced by name,
+ * custom plugins are functions. Unknown names throw, repeated plugins are loaded only once.
+ * A plugin that needs another plugin lists its name in `plugin.requires`, the required
+ * plugin is then loaded first. Once every plugin is loaded, the server emits `pluginsLoaded`: a plugin
+ * that has to wrap what other plugins set up (commands, output handlers), whatever the load order,
+ * does that in a `server.once('pluginsLoaded', ...)` listener. Listeners run in plugin load order.
+ *
+ * @param {Object} server IMAPServer instance
+ * @param {Array|String|Function} plugins List of plugins to load
+ */
+declare function loadPlugins(server: IMAPServer, plugins: (string | Plugin)[] | string | Plugin | null | undefined): void;
+export default loadPlugins;
+export { listPlugins };

package/dist/cjs/load-plugins.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listPlugins = listPlugins;
+const index_js_1 = require("./plugins/index.js");
+// Capability spellings that do not match a plugin file name
+const ALIASES = {
+    'literal+': 'literalplus',
+    'literal-': 'literalminus',
+    'compress=deflate': 'compress',
+    'auth=plain': 'auth-plain',
+    'auth=xoauth2': 'xoauth2',
+    'status=size': 'status-size',
+    'sort=display': 'sort-display',
+    'thread=orderedsubject': 'thread-orderedsubject',
+    'thread=references': 'thread-references',
+    'auth=oauthbearer': 'oauthbearer',
+    'utf8=accept': 'utf8-accept',
+    'context=search': 'context-search',
+    'context=sort': 'context-sort'
+};
+/**
+ * Lists the names of the built-in plugins (file names without extension)
+ *
+ * @return {Array} plugin names
+ */
+function listPlugins() {
+    return Object.keys(index_js_1.plugins);
+}
+/**
+ * Resolves a plugin name, as given in options.plugins, to a built-in plugin
+ *
+ * @param {String} name Plugin name, eg. "IDLE" or "LITERAL+"
+ * @return {String|false} Resolved plugin name or false if no such plugin exists
+ */
+function resolvePlugin(name) {
+    let key = String(name).trim().toLowerCase();
+    if (Object.hasOwn(ALIASES, key)) {
+        key = ALIASES[key];
+    }
+    return Object.hasOwn(index_js_1.plugins, key) ? key : false;
+}
+/**
+ * Loads plugins for a server instance. Built-in plugins are referenced by name,
+ * custom plugins are functions. Unknown names throw, repeated plugins are loaded only once.
+ * A plugin that needs another plugin lists its name in `plugin.requires`, the required
+ * plugin is then loaded first. Once every plugin is loaded, the server emits `pluginsLoaded`: a plugin
+ * that has to wrap what other plugins set up (commands, output handlers), whatever the load order,
+ * does that in a `server.once('pluginsLoaded', ...)` listener. Listeners run in plugin load order.
+ *
+ * @param {Object} server IMAPServer instance
+ * @param {Array|String|Function} plugins List of plugins to load
+ */
+function loadPlugins(server, plugins) {
+    const loaded = new Set();
+    const load = (entry) => {
+        let plugin = entry;
+        if (typeof plugin === 'string') {
+            const name = resolvePlugin(plugin);
+            if (!name) {
+                throw new Error('Unknown plugin "' + plugin + '". Available plugins: ' + listPlugins().join(', '));
+            }
+            plugin = index_js_1.plugins[name];
+        }
+        if (typeof plugin !== 'function') {
+            throw new TypeError('Invalid plugin, expecting a plugin name or a function');
+        }
+        if (loaded.has(plugin)) {
+            return;
+        }
+        loaded.add(plugin);
+        [].concat(plugin.requires || []).forEach(load);
+        plugin(server);
+    };
+    [].concat(plugins || []).forEach(load);
+    server.emit('pluginsLoaded');
+}
+exports.default = loadPlugins;
+{
+    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/mailbox-name.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Checks a mailbox name against the modified UTF-7 rules of RFC 3501 section 5.1.3:
+ * printable US-ASCII represents itself, "&" is written as "&-", everything else
+ * is encoded in modified BASE64 between "&" and "-", without superfluous shifts
+ * and without encoding printable US-ASCII.
+ *
+ * @param {String} name Mailbox name as a binary string
+ * @return {String|Boolean} Description of the problem, or false if the name is valid
+ */
+declare function validateMailboxName(name: unknown): string | false;
+/**
+ * Encodes a mailbox name in modified UTF-7 (RFC 3501 section 5.1.3)
+ *
+ * @param {String} name Mailbox name as a unicode string
+ * @return {String} Modified UTF-7 name
+ */
+declare function encodeMailboxName(name: string): string;
+/**
+ * Decodes a modified UTF-7 mailbox name (RFC 3501 section 5.1.3)
+ *
+ * @param {String} name Mailbox name as a binary string
+ * @return {String|Boolean} Mailbox name as a unicode string, or false if the name is not valid modified UTF-7
+ */
+declare function decodeMailboxName(name: string): string | false;
+export default validateMailboxName;
+export { encodeMailboxName as encode, decodeMailboxName as decode, encodeMailboxName };