imapkit 4.0.3 → 4.1.0

package/dist/esm/esearch.d.ts

@@ -0,0 +1,96 @@
+import type { SearchResult } from './commands/handlers/search.js';
+import type { Attribute, IMAPResponse, IMAPServer, Mailbox, Message } from './types.js';
+/** A parsed PARTIAL range, see parsePartialRange() */
+export interface PartialRange {
+    /** the argument as the client sent it */
+    range: string;
+    from: number;
+    to: number;
+    /** partial-range-last, counted from the last result */
+    fromEnd: boolean;
+}
+/** Upper case result option names to their arguments (`parsed.searchReturn`), PARTIAL has its parsed range */
+export type SearchReturn = Map<string, any>;
+/** The parts of a search result that the ESEARCH response is built from */
+export type EsearchResult = Pick<SearchResult, 'list' | 'numbers'>;
+/**
+ * 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
+ */
+declare function toSequenceSet(numbers: Iterable<number>): string;
+/**
+ * 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
+ */
+declare function toOrderedSet(numbers: number[]): string;
+/**
+ * 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
+ */
+declare function parsePartialRange(item: Attribute, allowLast: boolean): PartialRange;
+/**
+ * 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
+ */
+declare function selectPartial<T>(list: T[], partial: PartialRange): T[];
+/**
+ * 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
+ */
+declare function registerPartialOption(server: IMAPServer): void;
+/**
+ * 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
+ */
+declare function selectReturned<T>(list: T[], options: SearchReturn): T[];
+/**
+ * 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
+ */
+declare function buildCorrelator(tag: string, mailbox?: Mailbox | null): Attribute[];
+/**
+ * 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()
+ */
+declare function buildEsearchResponse(tag: string, isUid: boolean, result: EsearchResult, options: SearchReturn, mailbox?: Mailbox | null, sorted?: Message[] | null): IMAPResponse;
+export { toSequenceSet, toOrderedSet, selectReturned, selectPartial, parsePartialRange, registerPartialOption, buildCorrelator, buildEsearchResponse };

package/{lib → dist/esm}/esearch.js

@@ -1,13 +1,9 @@
-'use strict';
-
-const { badError } = require('./commands/handlers/search');
-const { MAX_NUMBER } = require('./numbers');
-
+import { badError } from './commands/handlers/search.js';
+import { MAX_NUMBER } from './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"
  *
@@ -17,7 +13,6 @@ const { MAX_NUMBER } = require('./numbers');
 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"
@@ -31,13 +26,13 @@ function toOrderedSet(numbers) {
         const last = ranges[ranges.length - 1];
         if (last && last[1] + 1 === nr) {
             last[1] = nr;
-        } else {
+        }
+        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.
@@ -60,7 +55,6 @@ function parsePartialRange(item, allowLast) {
     }
     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
@@ -75,7 +69,6 @@ function selectPartial(list, partial) {
     }
     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)
@@ -86,12 +79,11 @@ function registerPartialOption(server) {
     if (server.searchReturnOptions.has('PARTIAL')) {
         return;
     }
-    server.searchReturnOptions.set('PARTIAL', { data: true, once: true, parse: item => parsePartialRange(item, !!server.partialRangeLast) });
+    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');
+    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
@@ -117,7 +109,6 @@ function selectReturned(list, options) {
     }
     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
@@ -132,24 +123,19 @@ function buildCorrelator(tag, mailbox) {
         { 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
-        );
+        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 lib/commands/handlers/search.js)
+ * @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
@@ -157,17 +143,15 @@ function buildCorrelator(tag, mailbox) {
  * @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]));
+    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')) {
@@ -188,21 +172,10 @@ function buildEsearchResponse(tag, isUid, result, options, mailbox, sorted) {
     if (options.has('COUNT')) {
         add('COUNT', values.length);
     }
-
     return {
         tag: '*',
         command: 'ESEARCH',
         attributes
     };
 }
-
-module.exports = {
-    toSequenceSet,
-    toOrderedSet,
-    selectReturned,
-    selectPartial,
-    parsePartialRange,
-    registerPartialOption,
-    buildCorrelator,
-    buildEsearchResponse
-};
+export { toSequenceSet, toOrderedSet, selectReturned, selectPartial, parsePartialRange, registerPartialOption, buildCorrelator, buildEsearchResponse };

package/dist/esm/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/dist/esm/framing.js

@@ -0,0 +1,82 @@
+/**
+ * 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).
+ */
+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
+ * 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.
+ */
+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 responses = [];
+    let pos = 0;
+    let end = 0;
+    let current = null;
+    while (pos < length) {
+        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) {
+            current = { start: pos, end: 0, lines: [], literals: [] };
+        }
+        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) {
+            const size = Number(marker[2]);
+            if (pos + size > length) {
+                return { responses, end, incomplete: { reason: 'literal', size, available: length - pos, lines: current.lines } };
+            }
+            current.literals.push({ start: pos, end: pos + size, literal8: !!marker[1] });
+            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 };
+}
+function splitAtLiterals(payload) {
+    const isBuffer = Buffer.isBuffer(payload);
+    const str = isBuffer ? payload.toString('binary') : String(payload);
+    const cut = (start, end) => (isBuffer ? payload.subarray(start, end) : str.slice(start, end));
+    const chunks = [];
+    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]) {
+            chunks.push(cut(start, end));
+            start = end;
+        }
+        re.lastIndex = end + Number(match[1]);
+    }
+    chunks.push(cut(start));
+    return chunks.filter(chunk => chunk.length);
+}
+export { splitResponses, splitAtLiterals };

package/dist/esm/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/esm/index.js

@@ -0,0 +1,6 @@
+import createServer, { TAG_REGEX, IMAPServer, IMAPConnection } from './server.js';
+export { TAG_REGEX, IMAPServer, 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(createServer, { TAG_REGEX, IMAPServer, IMAPConnection });
+export default imapkit;

package/dist/esm/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/{lib → dist/esm}/list-extensions.js

@@ -1,5 +1,3 @@
-'use strict';
-
 /**
  * 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
@@ -32,5 +30,4 @@ function getListExtensions(server) {
     }
     return server.listExtensions;
 }
-
-module.exports = { getListExtensions };
+export { getListExtensions };

package/dist/esm/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/{lib → dist/esm}/load-plugins.js

@@ -1,10 +1,4 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const PLUGINS_DIR = path.join(__dirname, 'plugins');
-
+import { plugins as builtinPlugins } from './plugins/index.js';
 // Capability spellings that do not match a plugin file name
 const ALIASES = {
     'literal+': 'literalplus',
@@ -21,34 +15,14 @@ const ALIASES = {
     'context=search': 'context-search',
     'context=sort': 'context-sort'
 };
-
-let available = null;
-
-/**
- * Lists the modules of a directory (file names without the .js extension)
- *
- * @param {String} dir Directory path
- * @return {Array} module names
- */
-function listModules(dir) {
-    return fs
-        .readdirSync(dir)
-        .filter(fileName => /\.js$/.test(fileName))
-        .map(fileName => fileName.replace(/\.js$/, ''));
-}
-
 /**
  * Lists the names of the built-in plugins (file names without extension)
  *
  * @return {Array} plugin names
  */
 function listPlugins() {
-    if (!available) {
-        available = listModules(PLUGINS_DIR);
-    }
-    return available;
+    return Object.keys(builtinPlugins);
 }
-
 /**
  * Resolves a plugin name, as given in options.plugins, to a built-in plugin
  *
@@ -57,12 +31,11 @@ function listPlugins() {
  */
 function resolvePlugin(name) {
     let key = String(name).trim().toLowerCase();
-    if (Object.prototype.hasOwnProperty.call(ALIASES, key)) {
+    if (Object.hasOwn(ALIASES, key)) {
         key = ALIASES[key];
     }
-    return listPlugins().includes(key) ? key : false;
+    return Object.hasOwn(builtinPlugins, 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.
@@ -76,34 +49,27 @@ function resolvePlugin(name) {
  */
 function loadPlugins(server, plugins) {
     const loaded = new Set();
-
-    const load = plugin => {
+    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 = require(path.join(PLUGINS_DIR, name));
+            plugin = builtinPlugins[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');
 }
-
-module.exports = loadPlugins;
-module.exports.listModules = listModules;
+export default loadPlugins;
+export { listPlugins };

package/dist/esm/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 };