@gera2ld/imap 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,642 +1,539 @@
-import { EventEmitter as S } from "node:events";
-import * as T from "node:net";
-import * as $ from "node:tls";
-const b = "=", w = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-let g;
-function I() {
-  return g ||= O(w), g;
+import { EventEmitter as e } from "node:events";
+import * as t from "node:net";
+import * as n from "node:tls";
+//#region ../../node_modules/.pnpm/@gera2ld+common@file+packages+common/node_modules/@gera2ld/common/dist/index.js
+var r = "=", i = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", a;
+function o() {
+	return a ||= s(i), a;
 }
-function O(r) {
-  const t = new Array(255);
-  for (let e = 0; e < r.length; e += 1)
-    t[r.charCodeAt(e)] = e;
-  return t;
+function s(e) {
+	let t = Array(255);
+	for (let n = 0; n < e.length; n += 1) t[e.charCodeAt(n)] = n;
+	return t;
 }
-function M(r, t) {
-  const e = t[r];
-  if (e == null) throw new Error("Unable to parse base64 string.");
-  return e;
+function c(e, t) {
+	let n = t[e];
+	if (n == null) throw Error("Unable to parse base64 string.");
+	return n;
 }
-function D(r, t, e) {
-  let s = "", n = 0;
-  for (; n < r.length; ) {
-    const o = r[n++], i = r[n++], a = r[n++];
-    if (s += t[o >> 2], s += t[(o & 3) << 4 | (i || 0) >> 4], i == null ? s += b : s += t[(i & 15) << 2 | (a || 0) >> 6], a == null) {
-      s += b;
-      break;
-    }
-    s += t[a & 63];
-  }
-  return s;
+function l(e, t, n) {
+	let i = "", a = 0;
+	for (; a < e.length;) {
+		let o = e[a++], s = e[a++], c = e[a++];
+		if (i += t[o >> 2], i += t[(o & 3) << 4 | (s || 0) >> 4], s == null ? n && (i += r) : i += t[(s & 15) << 2 | (c || 0) >> 6], c == null) {
+			n && (i += r);
+			break;
+		}
+		i += t[c & 63];
+	}
+	return i;
 }
-function v(r, t) {
-  let e = r.length;
-  for (; e > 0 && r[e - 1] === "="; ) e -= 1;
-  const s = Math.ceil(e / 4), n = new Uint8Array(3 * s);
-  let o = 0, i = 0, a = 0;
-  for (i = 0; i < s; i += 1) {
-    let l = 0;
-    for (a = 0; a < 4; a += 1) {
-      o = i * 4 + a;
-      const f = r[o];
-      if (!f || f === b) break;
-      l |= M(r.charCodeAt(o), t) << (3 - a) * 6;
-    }
-    n[i * 3] = l >> 16, n[i * 3 + 1] = l >> 8 & 255, n[i * 3 + 2] = l & 255;
-  }
-  if (o < e - 1 || a === 1) throw new Error("Invalid base64 string");
-  let c = 3 * s;
-  for (; a < 4; a += 1) c -= 1;
-  return n.subarray(0, c);
+function u(e, t) {
+	let n = e.length;
+	for (; n > 0 && e[n - 1] === "=";) --n;
+	let i = Math.ceil(n / 4), a = new Uint8Array(3 * i), o = 0, s = 0, l = 0;
+	for (s = 0; s < i; s += 1) {
+		let n = 0;
+		for (l = 0; l < 4; l += 1) {
+			o = s * 4 + l;
+			let i = e[o];
+			if (!i || i === r) break;
+			n |= c(e.charCodeAt(o), t) << (3 - l) * 6;
+		}
+		a[s * 3] = n >> 16, a[s * 3 + 1] = n >> 8 & 255, a[s * 3 + 2] = n & 255;
+	}
+	if (o < n - 1 || l === 1) throw Error("Invalid base64 string");
+	let u = 3 * i;
+	for (; l < 4; l += 1) --u;
+	return a.subarray(0, u);
 }
-function U(r) {
-  return D(r, w);
+function d(e) {
+	return l(e, i, !0);
 }
-function y(r) {
-  return v(r, I());
+function f(e) {
+	return u(e, o());
 }
-function N(r) {
-  return new TextEncoder().encode(r);
+function p(e) {
+	return new TextEncoder().encode(e);
 }
-function E(r) {
-  return new TextDecoder().decode(r);
+function m(e) {
+	return new TextDecoder().decode(e);
 }
-function m() {
-  const r = {
-    status: "pending"
-  };
-  return r.promise = new Promise((t, e) => {
-    r.resolve = t, r.reject = e;
-  }), r.promise.then(
-    () => {
-      r.status = "resolved";
-    },
-    () => {
-      r.status = "rejected";
-    }
-  ), r;
+function h() {
+	let e = { status: "pending" };
+	return e.promise = new Promise((t, n) => {
+		e.resolve = t, e.reject = n;
+	}), e.promise.then(() => {
+		e.status = "resolved";
+	}, () => {
+		e.status = "rejected";
+	}), e;
 }
-const F = new Uint8Array([13, 10]);
-class L {
-  buffer = new Uint8Array(0);
-  requests = [];
-  isClosed = !1;
-  read(t = 8192) {
-    const e = m();
-    return this.requests.push({
-      deferred: e,
-      handle: () => {
-        const s = Math.min(t, this.buffer.length), n = this.buffer.subarray(0, s);
-        return this.buffer = this.buffer.subarray(s), e.resolve(n), !0;
-      }
-    }), this.processBuffer(), e.promise;
-  }
-  readExact(t) {
-    const e = m();
-    return this.requests.push({
-      deferred: e,
-      handle: () => {
-        if (t > this.buffer.length) return !1;
-        const s = this.buffer.subarray(0, t);
-        return this.buffer = this.buffer.subarray(t), e.resolve(s), !0;
-      }
-    }), this.processBuffer(), e.promise;
-  }
-  readUntil(t = F) {
-    typeof t == "string" && (t = N(t));
-    const e = m();
-    return this.requests.push({
-      deferred: e,
-      handle: () => {
-        const s = P(this.buffer, t);
-        if (s < 0) return !1;
-        const n = s + t.length, o = this.buffer.subarray(0, n);
-        return this.buffer = this.buffer.subarray(n), e.resolve(o), !0;
-      }
-    }), this.processBuffer(), e.promise;
-  }
-  feed(t) {
-    if (this.isClosed) throw new Error("Buffer is closed");
-    this.buffer = B(this.buffer, t), this.processBuffer();
-  }
-  close() {
-    this.isClosed = !0, this.processBuffer();
-  }
-  processBuffer() {
-    for (; this.requests.length; ) {
-      const t = this.requests[0];
-      if (!t.handle())
-        if (this.isClosed)
-          t.deferred.reject(new Error("Buffer is closed"));
-        else break;
-      this.requests.shift();
-    }
-  }
-}
-function B(r, t) {
-  const e = new Uint8Array(r.length + t.length);
-  return e.set(r, 0), e.set(t, r.length), e;
-}
-function P(r, t) {
-  if (!t.length) return 0;
-  for (let e = 0; e <= r.length - t.length; e += 1) {
-    let s;
-    for (s = 0; s < t.length && r[e + s] === t[s]; s += 1)
-      ;
-    if (s === t.length) return e;
-  }
-  return -1;
-}
-class R {
-  options;
-  _socket = null;
-  reader = new L();
-  isConnected = !1;
-  constructor(t) {
-    this.options = t;
-  }
-  async connect(t) {
-    return new Promise((e, s) => {
-      const n = this.options.secure ? $.connect({
-        host: this.options.host,
-        port: this.options.port,
-        rejectUnauthorized: !1
-      }) : T.connect({
-        host: this.options.host,
-        port: this.options.port
-      });
-      this._socket = n, n.on("data", (o) => {
-        this.reader.feed(o);
-      }), n.on("connect", () => {
-        this.isConnected = !0, e();
-      }), n.on("error", (o) => {
-        t?.onError?.(o), s(o);
-      }), n.on("close", () => {
-        this.isConnected = !1, t?.onClose?.();
-      });
-    });
-  }
-  write(t) {
-    if (!this._socket)
-      throw new Error("Not connected");
-    this._socket.write(t);
-  }
-  disconnect() {
-    this._socket && (this._socket.end(), this._socket.destroy(), this._socket = null);
-  }
+var g = new Uint8Array([13, 10]), _ = class {
+	buffer = new Uint8Array();
+	requests = [];
+	isClosed = !1;
+	read(e = 8192) {
+		let t = h();
+		return this.requests.push({
+			deferred: t,
+			handle: () => {
+				let n = Math.min(e, this.buffer.length), r = this.buffer.subarray(0, n);
+				return this.buffer = this.buffer.subarray(n), t.resolve(r), !0;
+			}
+		}), this.processBuffer(), t.promise;
+	}
+	readExact(e) {
+		let t = h();
+		return this.requests.push({
+			deferred: t,
+			handle: () => {
+				if (e > this.buffer.length) return !1;
+				let n = this.buffer.subarray(0, e);
+				return this.buffer = this.buffer.subarray(e), t.resolve(n), !0;
+			}
+		}), this.processBuffer(), t.promise;
+	}
+	readUntil(e = g) {
+		typeof e == "string" && (e = p(e));
+		let t = h();
+		return this.requests.push({
+			deferred: t,
+			handle: () => {
+				let n = y(this.buffer, e);
+				if (n < 0) return !1;
+				let r = n + e.length, i = this.buffer.subarray(0, r);
+				return this.buffer = this.buffer.subarray(r), t.resolve(i), !0;
+			}
+		}), this.processBuffer(), t.promise;
+	}
+	feed(e) {
+		if (this.isClosed) throw Error("Buffer is closed");
+		this.buffer = v(this.buffer, e), this.processBuffer();
+	}
+	close() {
+		this.isClosed = !0, this.processBuffer();
+	}
+	processBuffer() {
+		for (; this.requests.length;) {
+			let e = this.requests[0];
+			if (!e.handle()) if (this.isClosed) e.deferred.reject(/* @__PURE__ */ Error("Buffer is closed"));
+			else break;
+			this.requests.shift();
+		}
+	}
+};
+function v(e, t) {
+	let n = new Uint8Array(e.length + t.length);
+	return n.set(e, 0), n.set(t, e.length), n;
 }
-class j {
-  decode(t) {
-    return new TextDecoder().decode(t);
-  }
-  async *parse(t) {
-    for (; ; ) {
-      const e = await t.readUntil();
-      if (e.length === 0) break;
-      const s = this.decode(e);
-      if (s.startsWith("+ "))
-        yield {
-          symbol: "+",
-          text: s.slice(2)
-        };
-      else {
-        const n = s.split(" ");
-        let o = "", i, a;
-        s.startsWith("* ") ? (o = "*", n.shift(), isNaN(+n[0]) ? a = n.shift() : a = n.splice(1, 1)[0]) : (i = n.shift(), a = n.shift());
-        let c = n.join(" ");
-        const l = {
-          command: a,
-          stack: [[]],
-          brackets: []
-        };
-        for (; c; ) {
-          this.parseAttributes(l, c);
-          const f = l.stack.at(-1), h = f.at(-1), p = typeof h == "string" && h.match(/^\{(\d+)\}\r\n$/);
-          if (p) {
-            const x = +p[1], A = this.decode(await t.readExact(x));
-            f.pop(), f.push(A);
-          }
-          if (!l.brackets.length) break;
-          c = this.decode(await t.readUntil());
-        }
-        yield o ? {
-          symbol: o,
-          command: a,
-          attributes: l.stack[0]
-        } : {
-          symbol: "",
-          tag: i,
-          command: a,
-          attributes: l.stack[0]
-        };
-      }
-    }
-  }
-  parseAttributes(t, e) {
-    let s = !1, n = !0, o = !1, i = "";
-    const a = () => {
-      if (!i) return;
-      let c;
-      isNaN(+i) ? i.toLowerCase() === "nil" ? c = null : c = i : c = +i, t.stack.at(-1).push(c), i = "";
-    };
-    for (let c = 0; c < e.length; c += 1) {
-      const l = e[c];
-      if (s)
-        l === '"' ? (s = !1, a()) : (l === "\\" && (c += 1), i += e[c]);
-      else if (l === '"')
-        s = !0;
-      else if (l === " ")
-        a();
-      else if ((n ? "([" : "(").includes(l)) {
-        t.brackets.push(l);
-        const f = [];
-        t.stack.at(-1).push(f), t.stack.push(f), l === "[" && (o = !0);
-      } else if ((o ? "])" : ")").includes(l)) {
-        const f = t.brackets.pop();
-        if (!["()", "[]"].includes(f + l))
-          throw new Error("Invalid bracket");
-        a(), t.stack.pop(), l === "]" && (o = !1);
-      } else
-        i += e[c];
-      n = !1;
-    }
-    a();
-  }
+function y(e, t) {
+	if (!t.length) return 0;
+	for (let n = 0; n <= e.length - t.length; n += 1) {
+		let r;
+		for (r = 0; r < t.length && e[n + r] === t[r]; r += 1);
+		if (r === t.length) return n;
+	}
+	return -1;
 }
-const k = [
-  "Jan",
-  "Feb",
-  "Mar",
-  "Apr",
-  "May",
-  "Jun",
-  "Jul",
-  "Aug",
-  "Sep",
-  "Oct",
-  "Nov",
-  "Dec"
+//#endregion
+//#region src/connector.ts
+var b = class {
+	options;
+	_socket = null;
+	reader = new _();
+	isConnected = !1;
+	constructor(e) {
+		this.options = e;
+	}
+	async connect(e) {
+		return new Promise((r, i) => {
+			let a = this.options.secure ? n.connect({
+				host: this.options.host,
+				port: this.options.port,
+				rejectUnauthorized: !1
+			}) : t.connect({
+				host: this.options.host,
+				port: this.options.port
+			});
+			this._socket = a, a.on("data", (e) => {
+				this.reader.feed(e);
+			}), a.on("connect", () => {
+				this.isConnected = !0, r();
+			}), a.on("error", (t) => {
+				e?.onError?.(t), i(t);
+			}), a.on("close", () => {
+				this.isConnected = !1, e?.onClose?.();
+			});
+		});
+	}
+	write(e) {
+		if (!this._socket) throw Error("Not connected");
+		this._socket.write(e);
+	}
+	disconnect() {
+		this._socket &&= (this._socket.end(), this._socket.destroy(), null);
+	}
+}, x = class {
+	decode(e) {
+		return new TextDecoder().decode(e);
+	}
+	async *parse(e) {
+		for (;;) {
+			let t = await e.readUntil();
+			if (t.length === 0) break;
+			let n = this.decode(t);
+			if (n.startsWith("+ ")) yield {
+				symbol: "+",
+				text: n.slice(2)
+			};
+			else {
+				let t = n.split(" "), r = "", i, a;
+				n.startsWith("* ") ? (r = "*", t.shift(), a = isNaN(+t[0]) ? t.shift() : t.splice(1, 1)[0]) : (i = t.shift(), a = t.shift());
+				let o = t.join(" "), s = {
+					command: a,
+					stack: [[]],
+					brackets: []
+				};
+				for (; o;) {
+					this.parseAttributes(s, o);
+					let t = s.stack.at(-1), n = t.at(-1), r = typeof n == "string" && n.match(/^\{(\d+)\}\r\n$/);
+					if (r) {
+						let n = +r[1], i = this.decode(await e.readExact(n));
+						t.pop(), t.push(i);
+					}
+					if (!s.brackets.length) break;
+					o = this.decode(await e.readUntil());
+				}
+				yield r ? {
+					symbol: r,
+					command: a,
+					attributes: s.stack[0]
+				} : {
+					symbol: "",
+					tag: i,
+					command: a,
+					attributes: s.stack[0]
+				};
+			}
+		}
+	}
+	parseAttributes(e, t) {
+		let n = !1, r = !0, i = !1, a = "", o = () => {
+			if (!a) return;
+			let t;
+			t = isNaN(+a) ? a.toLowerCase() === "nil" ? null : a : +a, e.stack.at(-1).push(t), a = "";
+		};
+		for (let s = 0; s < t.length; s += 1) {
+			let c = t[s];
+			if (n) c === "\"" ? (n = !1, o()) : (c === "\\" && (s += 1), a += t[s]);
+			else if (c === "\"") n = !0;
+			else if (c === " ") o();
+			else if ((r ? "([" : "(").includes(c)) {
+				e.brackets.push(c);
+				let t = [];
+				e.stack.at(-1).push(t), e.stack.push(t), c === "[" && (i = !0);
+			} else if ((i ? "])" : ")").includes(c)) {
+				let t = e.brackets.pop();
+				if (!["()", "[]"].includes(t + c)) throw Error("Invalid bracket");
+				o(), e.stack.pop(), c === "]" && (i = !1);
+			} else a += t[s];
+			r = !1;
+		}
+		o();
+	}
+}, S = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
 ];
-function H(r) {
-  const t = String(r.getDate()).padStart(2, "0"), e = k[r.getMonth()], s = r.getFullYear();
-  return `${t}-${e}-${s}`;
-}
-function z(r) {
-  const t = String(r.getDate()).padStart(2, "0"), e = k[r.getMonth()], s = r.getFullYear(), n = String(r.getHours()).padStart(2, "0"), o = String(r.getMinutes()).padStart(2, "0"), i = String(r.getSeconds()).padStart(2, "0"), a = -r.getTimezoneOffset(), c = a >= 0 ? "+" : "-", l = Math.abs(a), f = String(Math.floor(l / 60)).padStart(
-    2,
-    "0"
-  ), h = String(l % 60).padStart(2, "0"), p = `${c}${f}${h}`;
-  return `${t}-${e}-${s} ${n}:${o}:${i} ${p}`;
+function C(e) {
+	return `${String(e.getDate()).padStart(2, "0")}-${S[e.getMonth()]}-${e.getFullYear()}`;
 }
-function d(r) {
-  return !Array.isArray(r) || r.length < 4 ? {} : {
-    name: C(r[0] ?? "") || void 0,
-    adl: r[1] ?? void 0,
-    mailbox: r[2] ?? void 0,
-    host: r[3] ?? void 0
-  };
+function w(e) {
+	let t = String(e.getDate()).padStart(2, "0"), n = S[e.getMonth()], r = e.getFullYear(), i = String(e.getHours()).padStart(2, "0"), a = String(e.getMinutes()).padStart(2, "0"), o = String(e.getSeconds()).padStart(2, "0"), s = -e.getTimezoneOffset(), c = s >= 0 ? "+" : "-", l = Math.abs(s);
+	return `${t}-${n}-${r} ${i}:${a}:${o} ${`${c}${String(Math.floor(l / 60)).padStart(2, "0")}${String(l % 60).padStart(2, "0")}`}`;
 }
-function C(r) {
-  return r.split(/\s+/).map((t) => {
-    if (t.startsWith("=?") && t.endsWith("?=")) {
-      const [e, s, n] = t.slice(2, -2).split("?");
-      if (e.toLowerCase() !== "utf-8")
-        throw new Error(`Charset is not supported: ${e}`);
-      let o;
-      if (s === "B")
-        o = y(n);
-      else {
-        const i = [];
-        for (let a = 0; a < n.length; a += 1)
-          if (n[a] === "=") {
-            const c = n.slice(a + 1, a + 3);
-            i.push(parseInt(c, 16)), a += 2;
-          } else
-            i.push(n.charCodeAt(a));
-        o = new Uint8Array(i);
-      }
-      return E(o);
-    }
-    return t;
-  }).join("");
+function T(e) {
+	return !Array.isArray(e) || e.length < 4 ? {} : {
+		name: E(e[0] ?? "") || void 0,
+		adl: e[1] ?? void 0,
+		mailbox: e[2] ?? void 0,
+		host: e[3] ?? void 0
+	};
 }
-const u = { uid: !0 };
-function _(r, t) {
-  const e = `user=${r}
auth=Bearer ${t}

`;
-  return U(new TextEncoder().encode(e));
+function E(e) {
+	return e.split(/\s+/).map((e) => {
+		if (e.startsWith("=?") && e.endsWith("?=")) {
+			let [t, n, r] = e.slice(2, -2).split("?");
+			if (t.toLowerCase() !== "utf-8") throw Error(`Charset is not supported: ${t}`);
+			let i;
+			if (n === "B") i = f(r);
+			else {
+				let e = [];
+				for (let t = 0; t < r.length; t += 1) if (r[t] === "=") {
+					let n = r.slice(t + 1, t + 3);
+					e.push(parseInt(n, 16)), t += 2;
+				} else e.push(r.charCodeAt(t));
+				i = new Uint8Array(e);
+			}
+			return m(i);
+		}
+		return e;
+	}).join("");
 }
-class G extends S {
-  options;
-  connector;
-  parser;
-  tagCounter = 0;
-  tagPrefix = "A";
-  pendingCommand = null;
-  constructor(t) {
-    super(), this.options = t, this.parser = new j(), this.connector = new R({
-      host: t.host,
-      port: t.port,
-      secure: t.secure
-    });
-  }
-  nextTag() {
-    return this.tagPrefix + this.tagCounter++;
-  }
-  /**
-   * Register a pending command and return a promise that resolves when the response arrives.
-   * Throws if another command is already pending.
-   */
-  registerPendingCommand(t, e, s) {
-    if (this.pendingCommand)
-      throw new Error(
-        `Cannot execute ${e} command while another operation ("${this.pendingCommand.command}") is in progress.`
-      );
-    const n = m();
-    return this.pendingCommand = {
-      tag: t,
-      command: e,
-      callback: s,
-      deferred: n
-    }, n.promise.finally(() => {
-      this.pendingCommand = null;
-    }), n.promise;
-  }
-  /**
-   * Send a raw command to the server.
-   */
-  sendCommand(t) {
-    this.emit("send", t), this.connector.write(`${t}\r
-`);
-  }
-  /**
-   * Execute a command and wait for its response.
-   * Processes matching untagged responses as they arrive via onResponse, filters out nulls.
-   * Non-matching responses are emitted as events.
-   *
-   * @param command - The IMAP command to send (e.g., 'LIST "" "*"', 'UID SEARCH ALL')
-   * @param matchCommand - Optional command name to match in responses (e.g., 'LIST', 'SEARCH', 'FETCH'). Required when onResponse is provided.
-   * @param onResponse - Optional function to transform each matching untagged response as it arrives. Return null to skip.
-   * @returns Promise with tagged response and array of transformed items
-   */
-  async executeCommand(t, e) {
-    const s = this.nextTag(), n = t.split(" ");
-    let o = n.shift();
-    if (o === "UID" && (o = n.shift()), !o) throw new Error("Invalid command");
-    const i = this.registerPendingCommand(s, o, e);
-    this.sendCommand(`${s} ${t}`), await i;
-  }
-  /**
-   * Handle incoming data lines from the connector.
-   */
-  handleResponse(t) {
-    this.emit("response", t);
-    const e = this.pendingCommand, s = () => {
-      t.symbol === "*" && this.handleAsyncNotification(t);
-    };
-    if (e) {
-      const n = () => {
-        t.symbol === "" && t.tag === e.tag ? t.command === "OK" ? e.deferred.resolve() : e.deferred.reject(new Error(t.command)) : s();
-      };
-      e.callback ? e.callback({
-        response: t,
-        pending: e,
-        next: s,
-        fallback: n
-      }) : n();
-    } else
-      s();
-  }
-  handleAsyncNotification(t) {
-    switch (t.command) {
-      case "EXISTS":
-        this.emit("newmail", { count: t.attributes[0] });
-        break;
-      case "EXPUNGE":
-        this.emit("expunge", { seq: t.attributes[0] });
-        break;
-      case "RECENT":
-        this.emit("recent", { count: t.attributes[0] });
-        break;
-      case "FLAGS":
-        this.emit("flags", { flags: t.attributes[0] });
-        break;
-    }
-  }
-  parseFetchAttributes(t, e) {
-    const s = { seq: t };
-    if (Array.isArray(e))
-      for (let n = 0; n < e.length; n += 2) {
-        const o = e[n]?.toUpperCase(), i = e[n + 1];
-        switch (o) {
-          case "UID":
-            s.uid = i;
-            break;
-          case "FLAGS":
-            s.flags = Array.isArray(i) ? i : [i];
-            break;
-          case "ENVELOPE":
-            s.envelope = {
-              date: i?.[0],
-              subject: C(i?.[1]),
-              from: i?.[2]?.map(d) ?? [],
-              sender: i?.[3]?.map(d) ?? [],
-              replyTo: i?.[4]?.map(d) ?? [],
-              to: i?.[5]?.map(d) ?? [],
-              cc: i?.[6]?.map(d) ?? [],
-              bcc: i?.[7]?.map(d) ?? [],
-              inReplyTo: i?.[8],
-              messageId: i?.[9]
-            };
-            break;
-          case "INTERNALDATE":
-            s.internalDate = i;
-            break;
-          case "RFC822.SIZE":
-            s.size = i;
-            break;
-          case "BODY[]":
-            s.body = i;
-            break;
-          case "RFC822.TEXT":
-          case "BODY[TEXT]":
-            s.text = i;
-            break;
-          case "BODY[HTML]":
-            s.html = i;
-            break;
-          default:
-            s.attributes ||= {}, s.attributes[o] = i;
-            break;
-        }
-      }
-    return s;
-  }
-  /**
-   * Connect to the IMAP server and authenticate.
-   */
-  async connect() {
-    await this.connector.connect({
-      onError: (t) => this.emit("error", t),
-      onClose: () => this.emit("close")
-    }), this.processResponses(), await this.registerPendingCommand("", "", ({ response: t, pending: e, next: s }) => {
-      t.symbol === "*" && t.command === "OK" ? e.deferred.resolve() : s();
-    }), await this.login();
-  }
-  async processResponses() {
-    for await (const t of this.parser.parse(this.connector.reader))
-      this.handleResponse(t);
-  }
-  /**
-   * Authenticate with the server.
-   */
-  async login() {
-    if (this.options.accessToken) {
-      const t = typeof this.options.accessToken == "function" ? await this.options.accessToken() : this.options.accessToken, e = _(this.options.user, t);
-      await this.executeCommand(
-        `AUTHENTICATE XOAUTH2 ${e}`,
-        ({ response: s, pending: n, fallback: o }) => {
-          s.symbol === "+" ? n.deferred.reject(
-            new Error(E(y(s.text)))
-          ) : o();
-        }
-      );
-    } else if (this.options.password)
-      await this.executeCommand(
-        `LOGIN "${this.options.user}" "${this.options.password}"`
-      );
-    else
-      throw new Error("Either password or accessToken must be provided");
-  }
-  /**
-   * List all mailboxes.
-   */
-  async listMailboxes() {
-    const t = [];
-    return await this.executeCommand('LIST "" "*"', ({ response: e, fallback: s }) => {
-      if (e.symbol === "*" && e.command === "LIST") {
-        const n = {
-          attributes: e.attributes[0],
-          delimiter: e.attributes[1],
-          name: e.attributes[2]
-        };
-        t.push(n);
-      } else
-        s();
-    }), t;
-  }
-  /**
-   * Select a mailbox.
-   */
-  async selectMailbox(t) {
-    await this.executeCommand(`SELECT "${t}"`);
-  }
-  /**
-   * Search messages.
-   */
-  async searchMessages(t, e) {
-    const n = { ...u, ...e }.uid ? "UID " : "";
-    let o = [];
-    return await this.executeCommand(
-      `${n}SEARCH ${t}`,
-      ({ response: i, fallback: a }) => {
-        i.symbol === "*" && i.command === "SEARCH" ? o = [...o, ...i.attributes] : a();
-      }
-    ), o;
-  }
-  /**
-   * Fetch messages.
-   */
-  async fetchMessages(t, e = ["UID", "ENVELOPE", "FLAGS"], s) {
-    const i = `${{ ...u, ...s }.uid ? "UID " : ""}FETCH ${t} (${e.join(" ")})`, a = [];
-    return await this.executeCommand(i, ({ response: c, fallback: l }) => {
-      if (c.symbol === "*" && c.command === "FETCH") {
-        const f = c.attributes[0], h = c.attributes[1];
-        a.push(this.parseFetchAttributes(f, h));
-      } else
-        l();
-    }), a;
-  }
-  /**
-   * Set flags on messages.
-   */
-  async setFlags(t, e, s, n) {
-    const i = { ...u, ...n }.uid ? "UID " : "", a = s.join(" ");
-    await this.executeCommand(
-      `${i}STORE ${t} ${e}FLAGS (${a})`
-    );
-  }
-  /**
-   * Mark messages as seen.
-   */
-  async markAsSeen(t, e) {
-    const s = { ...u, ...e };
-    await this.setFlags(t, "+", ["\\Seen"], s);
-  }
-  /**
-   * Mark messages as unseen.
-   */
-  async markAsUnseen(t, e) {
-    const s = { ...u, ...e };
-    await this.setFlags(t, "-", ["\\Seen"], s);
-  }
-  /**
-   * Delete messages.
-   */
-  async deleteMessages(t, e) {
-    const s = { ...u, ...e };
-    await this.setFlags(t, "+", ["\\Deleted"], s), await this.executeCommand("EXPUNGE");
-  }
-  /**
-   * Move messages to another mailbox.
-   */
-  async moveMessages(t, e, s) {
-    const o = { ...u, ...s }.uid ? "UID " : "";
-    await this.executeCommand(
-      `${o}MOVE ${t} "${e}"`
-    );
-  }
-  /**
-   * Start IDLE mode.
-   */
-  async startIdle() {
-    const t = m();
-    let e = !1;
-    return this.executeCommand("IDLE", ({ response: s, pending: n, fallback: o }) => {
-      if (e)
-        o();
-      else if (s.symbol === "+")
-        e = !0, t.resolve();
-      else {
-        const i = new Error(s.command);
-        t.reject(i), n.deferred.resolve(t.promise);
-      }
-    }), t.promise;
-  }
-  /**
-   * Stop IDLE mode.
-   */
-  async stopIdle() {
-    if (this.pendingCommand?.command !== "IDLE")
-      throw new Error("IDLE mode is not active");
-    return this.sendCommand("DONE"), this.pendingCommand.deferred.promise;
-  }
-  /**
-   * Disconnect from the server.
-   */
-  async disconnect() {
-    if (this.pendingCommand?.command === "IDLE")
-      try {
-        await this.stopIdle();
-      } catch {
-      }
-    this.connector.disconnect();
-  }
+//#endregion
+//#region src/client.ts
+var D = { uid: !0 };
+function O(e, t) {
+	let n = `user=${e}\x01auth=Bearer ${t}\x01\x01`;
+	return d(new TextEncoder().encode(n));
 }
-export {
-  G as ImapClient,
-  j as ImapParser,
-  C as decodeRfc2047,
-  H as formatDateForImap,
-  z as formatDateTimeForImap,
-  d as parseAddress
+var k = class extends e {
+	options;
+	connector;
+	parser;
+	tagCounter = 0;
+	tagPrefix = "A";
+	pendingCommand = null;
+	constructor(e) {
+		super(), this.options = e, this.parser = new x(), this.connector = new b({
+			host: e.host,
+			port: e.port,
+			secure: e.secure
+		});
+	}
+	nextTag() {
+		return this.tagPrefix + this.tagCounter++;
+	}
+	registerPendingCommand(e, t, n) {
+		if (this.pendingCommand) throw Error(`Cannot execute ${t} command while another operation ("${this.pendingCommand.command}") is in progress.`);
+		let r = h();
+		return this.pendingCommand = {
+			tag: e,
+			command: t,
+			callback: n,
+			deferred: r
+		}, r.promise.finally(() => {
+			this.pendingCommand = null;
+		}), r.promise;
+	}
+	sendCommand(e) {
+		this.emit("send", e), this.connector.write(`${e}\r\n`);
+	}
+	async executeCommand(e, t) {
+		let n = this.nextTag(), r = e.split(" "), i = r.shift();
+		if (i === "UID" && (i = r.shift()), !i) throw Error("Invalid command");
+		let a = this.registerPendingCommand(n, i, t);
+		this.sendCommand(`${n} ${e}`), await a;
+	}
+	handleResponse(e) {
+		this.emit("response", e);
+		let t = this.pendingCommand, n = () => {
+			e.symbol === "*" && this.handleAsyncNotification(e);
+		};
+		if (t) {
+			let r = () => {
+				e.symbol === "" && e.tag === t.tag ? e.command === "OK" ? t.deferred.resolve() : t.deferred.reject(Error(e.command)) : n();
+			};
+			t.callback ? t.callback({
+				response: e,
+				pending: t,
+				next: n,
+				fallback: r
+			}) : r();
+		} else n();
+	}
+	handleAsyncNotification(e) {
+		switch (e.command) {
+			case "EXISTS":
+				this.emit("newmail", { count: e.attributes[0] });
+				break;
+			case "EXPUNGE":
+				this.emit("expunge", { seq: e.attributes[0] });
+				break;
+			case "RECENT":
+				this.emit("recent", { count: e.attributes[0] });
+				break;
+			case "FLAGS":
+				this.emit("flags", { flags: e.attributes[0] });
+				break;
+		}
+	}
+	parseFetchAttributes(e, t) {
+		let n = { seq: e };
+		if (Array.isArray(t)) for (let e = 0; e < t.length; e += 2) {
+			let r = t[e]?.toUpperCase(), i = t[e + 1];
+			switch (r) {
+				case "UID":
+					n.uid = i;
+					break;
+				case "FLAGS":
+					n.flags = Array.isArray(i) ? i : [i];
+					break;
+				case "ENVELOPE":
+					n.envelope = {
+						date: i?.[0],
+						subject: E(i?.[1]),
+						from: i?.[2]?.map(T) ?? [],
+						sender: i?.[3]?.map(T) ?? [],
+						replyTo: i?.[4]?.map(T) ?? [],
+						to: i?.[5]?.map(T) ?? [],
+						cc: i?.[6]?.map(T) ?? [],
+						bcc: i?.[7]?.map(T) ?? [],
+						inReplyTo: i?.[8],
+						messageId: i?.[9]
+					};
+					break;
+				case "INTERNALDATE":
+					n.internalDate = i;
+					break;
+				case "RFC822.SIZE":
+					n.size = i;
+					break;
+				case "BODY[]":
+					n.body = i;
+					break;
+				case "RFC822.TEXT":
+				case "BODY[TEXT]":
+					n.text = i;
+					break;
+				case "BODY[HTML]":
+					n.html = i;
+					break;
+				default:
+					n.attributes ||= {}, n.attributes[r] = i;
+					break;
+			}
+		}
+		return n;
+	}
+	async connect() {
+		await this.connector.connect({
+			onError: (e) => this.emit("error", e),
+			onClose: () => this.emit("close")
+		}), this.processResponses(), await this.registerPendingCommand("", "", ({ response: e, pending: t, next: n }) => {
+			e.symbol === "*" && e.command === "OK" ? t.deferred.resolve() : n();
+		}), await this.login();
+	}
+	async processResponses() {
+		for await (let e of this.parser.parse(this.connector.reader)) this.handleResponse(e);
+	}
+	async login() {
+		if (this.options.accessToken) {
+			let e = typeof this.options.accessToken == "function" ? await this.options.accessToken() : this.options.accessToken, t = O(this.options.user, e);
+			await this.executeCommand(`AUTHENTICATE XOAUTH2 ${t}`, ({ response: e, pending: t, fallback: n }) => {
+				e.symbol === "+" ? t.deferred.reject(Error(m(f(e.text)))) : n();
+			});
+		} else if (this.options.password) await this.executeCommand(`LOGIN "${this.options.user}" "${this.options.password}"`);
+		else throw Error("Either password or accessToken must be provided");
+	}
+	async listMailboxes() {
+		let e = [];
+		return await this.executeCommand("LIST \"\" \"*\"", ({ response: t, fallback: n }) => {
+			if (t.symbol === "*" && t.command === "LIST") {
+				let n = {
+					attributes: t.attributes[0],
+					delimiter: t.attributes[1],
+					name: t.attributes[2]
+				};
+				e.push(n);
+			} else n();
+		}), e;
+	}
+	async selectMailbox(e) {
+		await this.executeCommand(`SELECT "${e}"`);
+	}
+	async searchMessages(e, t) {
+		let n = {
+			...D,
+			...t
+		}.uid ? "UID " : "", r = [];
+		return await this.executeCommand(`${n}SEARCH ${e}`, ({ response: e, fallback: t }) => {
+			e.symbol === "*" && e.command === "SEARCH" ? r = [...r, ...e.attributes] : t();
+		}), r;
+	}
+	async fetchMessages(e, t = [
+		"UID",
+		"ENVELOPE",
+		"FLAGS"
+	], n) {
+		let r = `${{
+			...D,
+			...n
+		}.uid ? "UID " : ""}FETCH ${e} (${t.join(" ")})`, i = [];
+		return await this.executeCommand(r, ({ response: e, fallback: t }) => {
+			if (e.symbol === "*" && e.command === "FETCH") {
+				let t = e.attributes[0], n = e.attributes[1];
+				i.push(this.parseFetchAttributes(t, n));
+			} else t();
+		}), i;
+	}
+	async setFlags(e, t, n, r) {
+		let i = {
+			...D,
+			...r
+		}.uid ? "UID " : "", a = n.join(" ");
+		await this.executeCommand(`${i}STORE ${e} ${t}FLAGS (${a})`);
+	}
+	async markAsSeen(e, t) {
+		let n = {
+			...D,
+			...t
+		};
+		await this.setFlags(e, "+", ["\\Seen"], n);
+	}
+	async markAsUnseen(e, t) {
+		let n = {
+			...D,
+			...t
+		};
+		await this.setFlags(e, "-", ["\\Seen"], n);
+	}
+	async deleteMessages(e, t) {
+		let n = {
+			...D,
+			...t
+		};
+		await this.setFlags(e, "+", ["\\Deleted"], n), await this.executeCommand("EXPUNGE");
+	}
+	async moveMessages(e, t, n) {
+		let r = {
+			...D,
+			...n
+		}.uid ? "UID " : "";
+		await this.executeCommand(`${r}MOVE ${e} "${t}"`);
+	}
+	async startIdle() {
+		let e = h(), t = !1;
+		return this.executeCommand("IDLE", ({ response: n, pending: r, fallback: i }) => {
+			if (t) i();
+			else if (n.symbol === "+") t = !0, e.resolve();
+			else {
+				let t = Error(n.command);
+				e.reject(t), r.deferred.resolve(e.promise);
+			}
+		}), e.promise;
+	}
+	async stopIdle() {
+		if (this.pendingCommand?.command !== "IDLE") throw Error("IDLE mode is not active");
+		return this.sendCommand("DONE"), this.pendingCommand.deferred.promise;
+	}
+	async disconnect() {
+		if (this.pendingCommand?.command === "IDLE") try {
+			await this.stopIdle();
+		} catch {}
+		this.connector.disconnect();
+	}
 };
+//#endregion
+export { k as ImapClient, x as ImapParser, E as decodeRfc2047, C as formatDateForImap, w as formatDateTimeForImap, T as parseAddress };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gera2ld/imap",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "exports": {
     ".": {
@@ -20,7 +20,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@gera2ld/common": "^0.0.1"
+    "@gera2ld/common": "^0.0.3"
   },
   "scripts": {
     "clean": "del-cli dist tsconfig.tsbuildinfo",