imapkit 4.0.2 → 4.1.0

package/dist/cjs/commands/subscribe.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = subscribeCommand;
+function subscribeCommand(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: 'SUBSCRIBE expects mailbox name'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    const path = parsed.attributes[0].value;
+    const mailbox = connection.server.getMailbox(path);
+    if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
+        connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', 'SUBSCRIBE FAILED');
+        return callback();
+    }
+    if (!mailbox.subscribed) {
+        mailbox.subscribed = true;
+        connection.server.mailboxChanged('subscribe', mailbox.path);
+    }
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'SUBSCRIBE completed'
+            }
+        ]
+    }, 'SUBSCRIBE', 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/uid-copy.d.ts

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

package/dist/cjs/commands/uid-copy.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = uidCopyCommand;
+const copy_js_1 = require("./copy.js");
+function uidCopyCommand(connection, parsed, data, callback) {
+    return (0, copy_js_1.copyMessages)(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/uid-fetch.d.ts

@@ -0,0 +1,3 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+declare const uidFetchCommand: (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+export default uidFetchCommand;

package/dist/cjs/commands/uid-fetch.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fetch_js_1 = require("./fetch.js");
+const uidFetchCommand = (connection, parsed, data, callback) => (0, fetch_js_1.processFetch)(true, connection, parsed, data, callback);
+exports.default = uidFetchCommand;
+{
+    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/uid-search.d.ts

@@ -0,0 +1,3 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+declare const uidSearchCommand: (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+export default uidSearchCommand;

package/dist/cjs/commands/uid-search.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const search_js_1 = require("./search.js");
+const uidSearchCommand = (connection, parsed, data, callback) => (0, search_js_1.processSearch)(true, connection, parsed, data, callback);
+exports.default = uidSearchCommand;
+{
+    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/uid-store.d.ts

@@ -0,0 +1,3 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+declare const uidStoreCommand: (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+export default uidStoreCommand;

package/dist/cjs/commands/uid-store.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const store_js_1 = require("./store.js");
+const uidStoreCommand = (connection, parsed, data, callback) => (0, store_js_1.processStore)(true, connection, parsed, data, callback);
+exports.default = uidStoreCommand;
+{
+    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/unsubscribe.d.ts

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

package/dist/cjs/commands/unsubscribe.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = unsubscribeCommand;
+function unsubscribeCommand(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: 'UNSUBSCRIBE expects mailbox name'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    let path = parsed.attributes[0].value;
+    if (path.toUpperCase() === 'INBOX') {
+        path = 'INBOX';
+    }
+    // The subscription list holds names, so a name stays removable after its mailbox is deleted
+    // (RFC 3501 section 6.3.6). Removing a name that is not subscribed is not an error (RFC 9051 section 6.3.8)
+    if (connection.server.subscriptions.delete(path)) {
+        connection.server.mailboxChanged('unsubscribe', path);
+    }
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'UNSUBSCRIBE completed'
+            }
+        ]
+    }, 'UNSUBSCRIBE', 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/dates.d.ts

@@ -0,0 +1,64 @@
+declare const MONTHS: string[];
+/** Date and time parts of a parsed date, the time fields are undefined when the value has no time */
+export interface DateParts {
+    day: number;
+    /** month index, 0 for January */
+    month: number;
+    year: number;
+    hours?: number | undefined;
+    minutes?: number | undefined;
+    seconds?: number | undefined;
+    /** `+hhmm` / `-hhmm` or a zone name */
+    zone?: string | undefined;
+}
+/**
+ * Returns the index of a month name, ignoring case like all ABNF strings
+ *
+ * @param {String} name Three letter month name, e.g. "jan"
+ * @return {Number} 0 for January to 11 for December, or -1 for an unknown name
+ */
+declare function monthIndex(name: string | undefined): number;
+/**
+ * Checks if day, month and year make a real date
+ *
+ * @param {Number|String} day Day of the month
+ * @param {Number} month Month index, 0 for January
+ * @param {Number|String} year Full year
+ * @return {Boolean} true if the date exists
+ */
+declare function isRealDate(day: number | string | undefined, month: number, year: number | string | undefined): boolean;
+/**
+ * Converts day, month and year to a comparable YYYY-MM-DD string
+ *
+ * @param {Number|String} day Day of the month
+ * @param {Number} month Month index, 0 for January
+ * @param {Number|String} year Full year
+ * @return {String|Boolean} the date, or false for an impossible date
+ */
+declare function dateKey(day: number | string, month: number, year: number | string): string | false;
+/**
+ * Parses a date-time value of the RFC 3501 section 9 form, like an INTERNALDATE ("14-Sep-2013 21:22:28 -0300").
+ * A value with only the date part is accepted as well, its time fields are left undefined
+ *
+ * @param {String} value Date-time value
+ * @return {Object|null} `{ day, month, year, hours, minutes, seconds, zone }` with the month index, or null
+ */
+declare function parseDateTime(value: unknown): DateParts | null;
+/**
+ * Parses the date-time of a Date header (RFC 5322 section 3.3, with the obsolete forms of section 4.3: comments,
+ * two and three digit years, zone names). SEARCH uses only the date as written (RFC 3501 section 6.4.4), SORT
+ * normalizes date and time to UTC with toTimestamp (RFC 5256 section 2.2), so both read the header with this
+ *
+ * @param {String} header Value of the Date header
+ * @return {Object|null} `{ day, month, year, hours, minutes, seconds, zone }` with the month index, or null if the
+ *   header has no valid date. The time fields are undefined when the header has no time
+ */
+declare function parseHeaderDate(header: string | undefined): DateParts | null;
+/**
+ * Converts date and time parts to milliseconds since the epoch, adjusted by the time zone. An unknown zone is UTC
+ *
+ * @param {Object} date `{ day, month, year, hours, minutes, seconds, zone }`, see parseDateTime and parseHeaderDate
+ * @return {Number} timestamp
+ */
+declare function toTimestamp(date: DateParts): number;
+export { MONTHS, monthIndex, isRealDate, dateKey, parseDateTime, parseHeaderDate, toTimestamp };

package/dist/cjs/dates.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MONTHS = void 0;
+exports.monthIndex = monthIndex;
+exports.isRealDate = isRealDate;
+exports.dateKey = dateKey;
+exports.parseDateTime = parseDateTime;
+exports.parseHeaderDate = parseHeaderDate;
+exports.toTimestamp = toTimestamp;
+// Month names of the RFC 3501 section 9 date-month rule, in the case they are sent in
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+exports.MONTHS = MONTHS;
+/**
+ * Returns the index of a month name, ignoring case like all ABNF strings
+ *
+ * @param {String} name Three letter month name, e.g. "jan"
+ * @return {Number} 0 for January to 11 for December, or -1 for an unknown name
+ */
+function monthIndex(name) {
+    const value = String(name || '').toLowerCase();
+    return MONTHS.findIndex(month => month.toLowerCase() === value);
+}
+/**
+ * Checks if day, month and year make a real date
+ *
+ * @param {Number|String} day Day of the month
+ * @param {Number} month Month index, 0 for January
+ * @param {Number|String} year Full year
+ * @return {Boolean} true if the date exists
+ */
+function isRealDate(day, month, year) {
+    day = Number(day);
+    year = Number(year);
+    if (month < 0 || month > 11 || !Number.isInteger(day) || day < 1) {
+        return false;
+    }
+    return day <= new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+}
+/**
+ * Converts day, month and year to a comparable YYYY-MM-DD string
+ *
+ * @param {Number|String} day Day of the month
+ * @param {Number} month Month index, 0 for January
+ * @param {Number|String} year Full year
+ * @return {String|Boolean} the date, or false for an impossible date
+ */
+function dateKey(day, month, year) {
+    if (!isRealDate(day, month, year)) {
+        return false;
+    }
+    return String(year).padStart(4, '0') + '-' + String(month + 1).padStart(2, '0') + '-' + String(day).padStart(2, '0');
+}
+/**
+ * Parses a date-time value of the RFC 3501 section 9 form, like an INTERNALDATE ("14-Sep-2013 21:22:28 -0300").
+ * A value with only the date part is accepted as well, its time fields are left undefined
+ *
+ * @param {String} value Date-time value
+ * @return {Object|null} `{ day, month, year, hours, minutes, seconds, zone }` with the month index, or null
+ */
+function parseDateTime(value) {
+    const match = String(value || '').match(/^\s*(\d{1,2})-([A-Za-z]{3})-(\d{4})(?: (\d{2}):(\d{2}):(\d{2}) ([+-]\d{4}))?/);
+    if (!match || !isRealDate(match[1], monthIndex(match[2]), match[3])) {
+        return null;
+    }
+    const time = match[4] === undefined ? {} : { hours: Number(match[4]), minutes: Number(match[5]), seconds: Number(match[6]), zone: match[7] };
+    return Object.assign({ day: Number(match[1]), month: monthIndex(match[2]), year: Number(match[3]) }, time);
+}
+/**
+ * Parses the date-time of a Date header (RFC 5322 section 3.3, with the obsolete forms of section 4.3: comments,
+ * two and three digit years, zone names). SEARCH uses only the date as written (RFC 3501 section 6.4.4), SORT
+ * normalizes date and time to UTC with toTimestamp (RFC 5256 section 2.2), so both read the header with this
+ *
+ * @param {String} header Value of the Date header
+ * @return {Object|null} `{ day, month, year, hours, minutes, seconds, zone }` with the month index, or null if the
+ *   header has no valid date. The time fields are undefined when the header has no time
+ */
+function parseHeaderDate(header) {
+    const match = (header || '')
+        .toString()
+        .replace(/\([^()]*\)/g, ' ')
+        .match(/^\s*(?:[A-Za-z]+\s*,)?\s*(\d{1,2})\s+([A-Za-z]{3})\s+(\d{2,4})(?:\s+(\d{1,2})\s*:\s*(\d{2})(?:\s*:\s*(\d{2}))?(?:\s+([+-]\d{4}|[A-Za-z]+))?)?/);
+    if (!match) {
+        return null;
+    }
+    let year = Number(match[3]);
+    // RFC 5322 section 4.3: two digit years below 50 are 20xx, three digit years add 1900
+    if (match[3].length === 2) {
+        year += year < 50 ? 2000 : 1900;
+    }
+    else if (match[3].length === 3) {
+        year += 1900;
+    }
+    const day = Number(match[1]);
+    const month = monthIndex(match[2]);
+    if (!isRealDate(day, month, year)) {
+        return null;
+    }
+    const time = match[4] === undefined ? {} : { hours: Number(match[4]), minutes: Number(match[5]), seconds: Number(match[6] || 0), zone: match[7] };
+    return Object.assign({ day, month, year }, time);
+}
+// RFC 5322 section 4.3 obsolete zones, military zones are treated as "-0000"
+const ZONES = { UT: 0, GMT: 0, EST: -5, EDT: -4, CST: -6, CDT: -5, MST: -7, MDT: -6, PST: -8, PDT: -7 };
+/**
+ * Converts date and time parts to milliseconds since the epoch, adjusted by the time zone. An unknown zone is UTC
+ *
+ * @param {Object} date `{ day, month, year, hours, minutes, seconds, zone }`, see parseDateTime and parseHeaderDate
+ * @return {Number} timestamp
+ */
+function toTimestamp(date) {
+    const zone = date.zone || '';
+    let offset = 0;
+    if (/^[+-]\d{4}$/.test(zone)) {
+        const sign = zone.charAt(0) === '-' ? -1 : 1;
+        const zoneHours = Number(zone.substr(1, 2));
+        const zoneMinutes = Number(zone.substr(3, 2));
+        if (zoneMinutes < 60) {
+            offset = sign * (zoneHours * 60 + zoneMinutes);
+        }
+    }
+    else if (Object.hasOwn(ZONES, zone.toUpperCase())) {
+        offset = ZONES[zone.toUpperCase()] * 60;
+    }
+    return Date.UTC(date.year, date.month, date.day, date.hours || 0, date.minutes || 0, date.seconds || 0) - offset * 60 * 1000;
+}

package/dist/cjs/deflate-layer.d.ts

@@ -0,0 +1,83 @@
+import zlib from 'node:zlib';
+/** Options of a DeflateLayer */
+export interface DeflateLayerOptions {
+    /** sends octets to the peer */
+    writeRaw: (data: Buffer | string) => void;
+    /** gets the input, decompressed while compression is active */
+    onData: (data: Buffer) => void;
+    /** called when the input is not valid DEFLATE data */
+    onError?: ((err: Error) => unknown) | undefined;
+}
+/**
+ * One end of a COMPRESS=DEFLATE layer (RFC 4978): raw DEFLATE (RFC 1951, no zlib header or
+ * checksum) in both directions. The server plugin uses it, and so do the clients of the tests and
+ * the compare tool.
+ *
+ * Either direction can be terminated, which UNAUTHENTICATE requires (RFC 8437 section 4.1). Output
+ * terminates with a final DEFLATE block, data written after that goes out uncompressed once the
+ * compressed data is out. Input terminates where the peer ended its compression: at the end of
+ * its DEFLATE stream if it sent a final block, otherwise at the end of the sync flush that
+ * carried the last compressed data. The input is split at sync flush markers to find that point.
+ */
+declare class DeflateLayer {
+    writeRaw: (data: Buffer | string) => void;
+    onData: (data: Buffer) => void;
+    onError: (err: Error) => unknown;
+    active: boolean;
+    inputActive: boolean;
+    _deflate: zlib.DeflateRaw;
+    _held: (Buffer | string)[] | null;
+    _endCallbacks: (() => void)[];
+    _flushScheduled: boolean;
+    _inflate: zlib.InflateRaw;
+    _pieces: Buffer[];
+    _busy: boolean;
+    _fed: number;
+    _expectFinal: boolean;
+    _idleCallbacks: (() => void)[];
+    /**
+     * @param {Object} options
+     * @param {Function} options.writeRaw `(buffer)` sends octets to the peer
+     * @param {Function} options.onData `(buffer)` gets the input, decompressed while compression is active
+     * @param {Function} [options.onError] `(err)` called when the input is not valid DEFLATE data
+     */
+    constructor(options: DeflateLayerOptions);
+    /**
+     * Sends data to the peer, compressed while compression is active
+     *
+     * @param {Buffer} data Data to send
+     */
+    write(data: Buffer | string): void;
+    /**
+     * Terminates the outgoing compression with a final DEFLATE block. Later writes are sent
+     * uncompressed, after the compressed data.
+     *
+     * @param {Function} [callback] Called once the compressed data is written out
+     */
+    end(callback?: (() => void) | null): void;
+    _runCallbacks(key: '_endCallbacks' | '_idleCallbacks'): void;
+    /**
+     * Handles octets received from the peer
+     *
+     * @param {Buffer} chunk Received data
+     */
+    receive(chunk: Buffer): void;
+    /**
+     * Tells the layer that the peer terminates its compression after the data decompressed so far
+     * (RFC 8437 section 4.1). Call it from onData, the rest of the input is then passed on as is.
+     */
+    endInput(): void;
+    /**
+     * Calls back once all received data is passed on
+     *
+     * @param {Function} callback Function to call
+     */
+    whenIdle(callback: () => void): void;
+    _next(): void;
+    _receivePlain(chunk: Buffer): void;
+    /**
+     * Frees the compressor and the decompressor
+     */
+    destroy(): void;
+}
+export default DeflateLayer;