tempmail-sdk 1.2.0 → 1.2.2-dev

package/dist/providers/10minute-one.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEmail = generateEmail;
+exports.getEmails = getEmails;
+const normalize_1 = require("../normalize");
+const retry_1 = require("../retry");
+const CHANNEL = '10minute-one';
+const SITE_ORIGIN = 'https://10minutemail.one';
+const API_BASE = 'https://web.10minutemail.one/api/v1';
+const JWT_RE = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+const DEFAULT_PAGE_HEADERS = {
+    Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+    'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
+    'Cache-Control': 'no-cache',
+    Pragma: 'no-cache',
+    DNT: '1',
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+};
+function extractNuxtDataArray(html) {
+    const m = html.match(/<script[^>]*\bid="__NUXT_DATA__"[^>]*>([\s\S]*?)<\/script>/i);
+    if (!m)
+        throw new Error('10minute-one: __NUXT_DATA__ not found');
+    return JSON.parse(m[1].trim());
+}
+function resolveRef(arr, value, depth = 0) {
+    if (depth > 64)
+        throw new Error('10minute-one: resolveRef too deep');
+    if (value == null)
+        return value;
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 0) {
+        if (value >= arr.length)
+            return undefined;
+        return resolveRef(arr, arr[value], depth + 1);
+    }
+    return value;
+}
+function parseMailServiceTokenFromPayload(arr) {
+    if (!Array.isArray(arr))
+        throw new Error('10minute-one: invalid __NUXT_DATA__');
+    for (let i = 0; i < Math.min(arr.length, 48); i++) {
+        const el = arr[i];
+        if (el && typeof el === 'object' && !Array.isArray(el) && 'mailServiceToken' in el) {
+            const t = resolveRef(arr, el.mailServiceToken);
+            if (typeof t === 'string' && JWT_RE.test(t))
+                return t;
+        }
+    }
+    for (const el of arr) {
+        if (el && typeof el === 'object' && !Array.isArray(el) && 'mailServiceToken' in el) {
+            const t = resolveRef(arr, el.mailServiceToken);
+            if (typeof t === 'string' && JWT_RE.test(t))
+                return t;
+        }
+    }
+    for (const el of arr) {
+        if (typeof el === 'string' && JWT_RE.test(el))
+            return el;
+    }
+    throw new Error('10minute-one: mailServiceToken not found');
+}
+function parseQuotedJsonArrayField(html, field) {
+    const key = `${field}:"`;
+    const start = html.indexOf(key);
+    if (start < 0)
+        return [];
+    const sliceStart = start + key.length;
+    if (html[sliceStart] !== '[')
+        return [];
+    let depth = 0;
+    let j = sliceStart;
+    for (; j < html.length; j++) {
+        const c = html[j];
+        if (c === '[')
+            depth++;
+        else if (c === ']') {
+            depth--;
+            if (depth === 0) {
+                j++;
+                break;
+            }
+        }
+    }
+    const raw = html.slice(sliceStart, j);
+    const unesc = raw.replace(/\\"/g, '"');
+    try {
+        const v = JSON.parse(unesc);
+        return Array.isArray(v) ? v.map(x => String(x)) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function parseEmailDomains(html) {
+    const d = parseQuotedJsonArrayField(html, 'emailDomains');
+    return d.filter(Boolean);
+}
+function parseBlockedUsernames(html) {
+    const list = parseQuotedJsonArrayField(html, 'blockedUsernames');
+    return new Set(list.map(s => s.toLowerCase()));
+}
+function randomRequestId() {
+    const a = new Uint8Array(16);
+    crypto.getRandomValues(a);
+    return [...a].map(b => b.toString(16).padStart(2, '0')).join('');
+}
+function b64DecodeUtf8(b64) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(b64, 'base64').toString('utf8');
+    }
+    const bin = atob(b64);
+    const bytes = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++)
+        bytes[i] = bin.charCodeAt(i);
+    return new TextDecoder('utf-8').decode(bytes);
+}
+function b64UrlPayload(jwt) {
+    const parts = jwt.split('.');
+    if (parts.length < 2)
+        return null;
+    let b = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+    const pad = b.length % 4 ? '='.repeat(4 - (b.length % 4)) : '';
+    b += pad;
+    try {
+        return JSON.parse(b64DecodeUtf8(b));
+    }
+    catch {
+        return null;
+    }
+}
+function jwtExpMs(jwt) {
+    const p = b64UrlPayload(jwt);
+    const exp = p?.exp;
+    if (typeof exp === 'number' && Number.isFinite(exp))
+        return Math.floor(exp * 1000);
+    return undefined;
+}
+function randomLocal(len) {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    const a = new Uint8Array(len);
+    crypto.getRandomValues(a);
+    let s = '';
+    for (let i = 0; i < len; i++)
+        s += chars[a[i] % chars.length];
+    return s;
+}
+function pickLocale(domain) {
+    const s = String(domain ?? '').trim();
+    if (!s)
+        return 'zh';
+    if (s.includes('.') && !s.includes('/'))
+        return 'zh';
+    return s;
+}
+function pickMailboxDomain(domainHint, available) {
+    if (!available.length)
+        throw new Error('10minute-one: no email domains in page');
+    const h = (domainHint ?? '').trim().toLowerCase();
+    if (h.includes('.')) {
+        for (const d of available) {
+            if (d.toLowerCase() === h)
+                return d;
+        }
+    }
+    return available[Math.floor(Math.random() * available.length)];
+}
+function apiHeaders(token, extra) {
+    const ts = String(Math.floor(Date.now() / 1000));
+    return {
+        Accept: '*/*',
+        'Accept-Language': DEFAULT_PAGE_HEADERS['Accept-Language'],
+        Authorization: `Bearer ${token}`,
+        'Cache-Control': 'no-cache',
+        'Content-Type': 'application/json',
+        DNT: '1',
+        Origin: SITE_ORIGIN,
+        Pragma: 'no-cache',
+        Referer: `${SITE_ORIGIN}/`,
+        'Sec-Fetch-Dest': 'empty',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Site': 'same-site',
+        'User-Agent': DEFAULT_PAGE_HEADERS['User-Agent'],
+        'X-Request-ID': randomRequestId(),
+        'X-Timestamp': ts,
+        ...extra,
+    };
+}
+function encMailboxPath(email) {
+    return encodeURIComponent(email);
+}
+function itemNeedsDetail(item) {
+    const id = item.id;
+    if (id == null || String(id).trim() === '')
+        return false;
+    const subj = String(item.subject ?? item.mail_title ?? '').trim();
+    const body = String(item.text ?? item.body ?? item.html ?? item.mail_text ?? '').trim();
+    return subj === '' && body === '';
+}
+async function generateEmail(domain) {
+    const locale = pickLocale(domain ?? undefined);
+    const pageUrl = `${SITE_ORIGIN}/${encodeURIComponent(locale)}`;
+    const res = await (0, retry_1.fetchWithTimeout)(pageUrl, { headers: { ...DEFAULT_PAGE_HEADERS, Referer: pageUrl } });
+    if (!res.ok)
+        throw new Error(`10minute-one generate: ${res.status}`);
+    const html = await res.text();
+    const arr = extractNuxtDataArray(html);
+    const token = parseMailServiceTokenFromPayload(arr);
+    let domains = parseEmailDomains(html);
+    if (domains.length === 0) {
+        domains = ['xghff.com', 'oqqaj.com', 'psovv.com'];
+    }
+    const blocked = parseBlockedUsernames(html);
+    const domainHint = (domain ?? '').trim().includes('.') ? (domain ?? '').trim() : undefined;
+    const mailDomain = pickMailboxDomain(domainHint, domains);
+    let local = '';
+    for (let attempt = 0; attempt < 32; attempt++) {
+        const cand = randomLocal(10);
+        if (!blocked.has(cand.toLowerCase())) {
+            local = cand;
+            break;
+        }
+    }
+    if (!local)
+        throw new Error('10minute-one: could not pick username');
+    const address = `${local}@${mailDomain}`;
+    const expMs = jwtExpMs(token);
+    return {
+        channel: CHANNEL,
+        email: address,
+        token,
+        expiresAt: expMs,
+    };
+}
+async function getEmails(email, token) {
+    const url = `${API_BASE}/mailbox/${encMailboxPath(email)}`;
+    const res = await (0, retry_1.fetchWithTimeout)(url, { headers: apiHeaders(token) });
+    if (!res.ok)
+        throw new Error(`10minute-one inbox: ${res.status}`);
+    const list = (await res.json());
+    if (!Array.isArray(list))
+        throw new Error('10minute-one: invalid inbox JSON');
+    const out = [];
+    for (const raw of list) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        let row = raw;
+        if (itemNeedsDetail(row)) {
+            const id = encodeURIComponent(String(row.id));
+            const du = `${API_BASE}/mailbox/${encMailboxPath(email)}/${id}`;
+            const dr = await (0, retry_1.fetchWithTimeout)(du, { headers: apiHeaders(token) });
+            if (dr.ok) {
+                try {
+                    const detail = (await dr.json());
+                    row = { ...row, ...detail };
+                }
+                catch {
+                    /* keep row */
+                }
+            }
+        }
+        out.push((0, normalize_1.normalizeEmail)(row, email));
+    }
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"10minute-one.js","sourceRoot":"","sources":["../../src/providers/10minute-one.ts"],"names":[],"mappings":"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","sourcesContent":["import { InternalEmailInfo, Email, Channel } from '../types';\nimport { normalizeEmail } from '../normalize';\nimport { fetchWithTimeout } from '../retry';\n\nconst CHANNEL: Channel = '10minute-one';\nconst SITE_ORIGIN = 'https://10minutemail.one';\nconst API_BASE = 'https://web.10minutemail.one/api/v1';\n\nconst JWT_RE = /^[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+$/;\n\nconst DEFAULT_PAGE_HEADERS: Record<string, string> = {\n  Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',\n  'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',\n  'Cache-Control': 'no-cache',\n  Pragma: 'no-cache',\n  DNT: '1',\n  'User-Agent':\n    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',\n};\n\nfunction extractNuxtDataArray(html: string): unknown[] {\n  const m = html.match(/<script[^>]*\\bid=\"__NUXT_DATA__\"[^>]*>([\\s\\S]*?)<\\/script>/i);\n  if (!m) throw new Error('10minute-one: __NUXT_DATA__ not found');\n  return JSON.parse(m[1].trim()) as unknown[];\n}\n\nfunction resolveRef(arr: unknown[], value: unknown, depth = 0): unknown {\n  if (depth > 64) throw new Error('10minute-one: resolveRef too deep');\n  if (value == null) return value;\n  if (typeof value === 'number' && Number.isInteger(value) && value >= 0) {\n    if (value >= arr.length) return undefined;\n    return resolveRef(arr, arr[value], depth + 1);\n  }\n  return value;\n}\n\nfunction parseMailServiceTokenFromPayload(arr: unknown[]): string {\n  if (!Array.isArray(arr)) throw new Error('10minute-one: invalid __NUXT_DATA__');\n\n  for (let i = 0; i < Math.min(arr.length, 48); i++) {\n    const el = arr[i];\n    if (el && typeof el === 'object' && !Array.isArray(el) && 'mailServiceToken' in el) {\n      const t = resolveRef(arr, (el as Record<string, unknown>).mailServiceToken);\n      if (typeof t === 'string' && JWT_RE.test(t)) return t;\n    }\n  }\n  for (const el of arr) {\n    if (el && typeof el === 'object' && !Array.isArray(el) && 'mailServiceToken' in el) {\n      const t = resolveRef(arr, (el as Record<string, unknown>).mailServiceToken);\n      if (typeof t === 'string' && JWT_RE.test(t)) return t;\n    }\n  }\n  for (const el of arr) {\n    if (typeof el === 'string' && JWT_RE.test(el)) return el;\n  }\n  throw new Error('10minute-one: mailServiceToken not found');\n}\n\nfunction parseQuotedJsonArrayField(html: string, field: string): string[] {\n  const key = `${field}:\"`;\n  const start = html.indexOf(key);\n  if (start < 0) return [];\n  const sliceStart = start + key.length;\n  if (html[sliceStart] !== '[') return [];\n  let depth = 0;\n  let j = sliceStart;\n  for (; j < html.length; j++) {\n    const c = html[j];\n    if (c === '[') depth++;\n    else if (c === ']') {\n      depth--;\n      if (depth === 0) {\n        j++;\n        break;\n      }\n    }\n  }\n  const raw = html.slice(sliceStart, j);\n  const unesc = raw.replace(/\\\\\"/g, '\"');\n  try {\n    const v = JSON.parse(unesc);\n    return Array.isArray(v) ? v.map(x => String(x)) : [];\n  } catch {\n    return [];\n  }\n}\n\nfunction parseEmailDomains(html: string): string[] {\n  const d = parseQuotedJsonArrayField(html, 'emailDomains');\n  return d.filter(Boolean);\n}\n\nfunction parseBlockedUsernames(html: string): Set<string> {\n  const list = parseQuotedJsonArrayField(html, 'blockedUsernames');\n  return new Set(list.map(s => s.toLowerCase()));\n}\n\nfunction randomRequestId(): string {\n  const a = new Uint8Array(16);\n  crypto.getRandomValues(a);\n  return [...a].map(b => b.toString(16).padStart(2, '0')).join('');\n}\n\nfunction b64DecodeUtf8(b64: string): string {\n  if (typeof Buffer !== 'undefined') {\n    return Buffer.from(b64, 'base64').toString('utf8');\n  }\n  const bin = atob(b64);\n  const bytes = new Uint8Array(bin.length);\n  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);\n  return new TextDecoder('utf-8').decode(bytes);\n}\n\nfunction b64UrlPayload(jwt: string): Record<string, unknown> | null {\n  const parts = jwt.split('.');\n  if (parts.length < 2) return null;\n  let b = parts[1].replace(/-/g, '+').replace(/_/g, '/');\n  const pad = b.length % 4 ? '='.repeat(4 - (b.length % 4)) : '';\n  b += pad;\n  try {\n    return JSON.parse(b64DecodeUtf8(b)) as Record<string, unknown>;\n  } catch {\n    return null;\n  }\n}\n\nfunction jwtExpMs(jwt: string): number | undefined {\n  const p = b64UrlPayload(jwt);\n  const exp = p?.exp;\n  if (typeof exp === 'number' && Number.isFinite(exp)) return Math.floor(exp * 1000);\n  return undefined;\n}\n\nfunction randomLocal(len: number): string {\n  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';\n  const a = new Uint8Array(len);\n  crypto.getRandomValues(a);\n  let s = '';\n  for (let i = 0; i < len; i++) s += chars[a[i] % chars.length];\n  return s;\n}\n\nfunction pickLocale(domain?: string | null): string {\n  const s = String(domain ?? '').trim();\n  if (!s) return 'zh';\n  if (s.includes('.') && !s.includes('/')) return 'zh';\n  return s;\n}\n\nfunction pickMailboxDomain(domainHint: string | undefined, available: string[]): string {\n  if (!available.length) throw new Error('10minute-one: no email domains in page');\n  const h = (domainHint ?? '').trim().toLowerCase();\n  if (h.includes('.')) {\n    for (const d of available) {\n      if (d.toLowerCase() === h) return d;\n    }\n  }\n  return available[Math.floor(Math.random() * available.length)]!;\n}\n\nfunction apiHeaders(token: string, extra?: Record<string, string>): Record<string, string> {\n  const ts = String(Math.floor(Date.now() / 1000));\n  return {\n    Accept: '*/*',\n    'Accept-Language': DEFAULT_PAGE_HEADERS['Accept-Language']!,\n    Authorization: `Bearer ${token}`,\n    'Cache-Control': 'no-cache',\n    'Content-Type': 'application/json',\n    DNT: '1',\n    Origin: SITE_ORIGIN,\n    Pragma: 'no-cache',\n    Referer: `${SITE_ORIGIN}/`,\n    'Sec-Fetch-Dest': 'empty',\n    'Sec-Fetch-Mode': 'cors',\n    'Sec-Fetch-Site': 'same-site',\n    'User-Agent': DEFAULT_PAGE_HEADERS['User-Agent']!,\n    'X-Request-ID': randomRequestId(),\n    'X-Timestamp': ts,\n    ...extra,\n  };\n}\n\nfunction encMailboxPath(email: string): string {\n  return encodeURIComponent(email);\n}\n\nfunction itemNeedsDetail(item: Record<string, unknown>): boolean {\n  const id = item.id;\n  if (id == null || String(id).trim() === '') return false;\n  const subj = String(item.subject ?? item.mail_title ?? '').trim();\n  const body = String(item.text ?? item.body ?? item.html ?? item.mail_text ?? '').trim();\n  return subj === '' && body === '';\n}\n\nexport async function generateEmail(domain?: string | null): Promise<InternalEmailInfo> {\n  const locale = pickLocale(domain ?? undefined);\n  const pageUrl = `${SITE_ORIGIN}/${encodeURIComponent(locale)}`;\n  const res = await fetchWithTimeout(pageUrl, { headers: { ...DEFAULT_PAGE_HEADERS, Referer: pageUrl } });\n  if (!res.ok) throw new Error(`10minute-one generate: ${res.status}`);\n  const html = await res.text();\n  const arr = extractNuxtDataArray(html);\n  const token = parseMailServiceTokenFromPayload(arr);\n  let domains = parseEmailDomains(html);\n  if (domains.length === 0) {\n    domains = ['xghff.com', 'oqqaj.com', 'psovv.com'];\n  }\n  const blocked = parseBlockedUsernames(html);\n  const domainHint = (domain ?? '').trim().includes('.') ? (domain ?? '').trim() : undefined;\n  const mailDomain = pickMailboxDomain(domainHint, domains);\n\n  let local = '';\n  for (let attempt = 0; attempt < 32; attempt++) {\n    const cand = randomLocal(10);\n    if (!blocked.has(cand.toLowerCase())) {\n      local = cand;\n      break;\n    }\n  }\n  if (!local) throw new Error('10minute-one: could not pick username');\n\n  const address = `${local}@${mailDomain}`;\n  const expMs = jwtExpMs(token);\n  return {\n    channel: CHANNEL,\n    email: address,\n    token,\n    expiresAt: expMs,\n  };\n}\n\nexport async function getEmails(email: string, token: string): Promise<Email[]> {\n  const url = `${API_BASE}/mailbox/${encMailboxPath(email)}`;\n  const res = await fetchWithTimeout(url, { headers: apiHeaders(token) });\n  if (!res.ok) throw new Error(`10minute-one inbox: ${res.status}`);\n  const list = (await res.json()) as unknown;\n  if (!Array.isArray(list)) throw new Error('10minute-one: invalid inbox JSON');\n\n  const out: Email[] = [];\n  for (const raw of list) {\n    if (!raw || typeof raw !== 'object') continue;\n    let row = raw as Record<string, unknown>;\n    if (itemNeedsDetail(row)) {\n      const id = encodeURIComponent(String(row.id));\n      const du = `${API_BASE}/mailbox/${encMailboxPath(email)}/${id}`;\n      const dr = await fetchWithTimeout(du, { headers: apiHeaders(token) });\n      if (dr.ok) {\n        try {\n          const detail = (await dr.json()) as Record<string, unknown>;\n          row = { ...row, ...detail };\n        } catch {\n          /* keep row */\n        }\n      }\n    }\n    out.push(normalizeEmail(row, email));\n  }\n  return out;\n}\n"]}

package/dist/providers/moakt.d.ts

@@ -0,0 +1,3 @@
+import { InternalEmailInfo, Email } from '../types';
+export declare function generateEmail(domain?: string | null): Promise<InternalEmailInfo>;
+export declare function getEmails(email: string, token: string): Promise<Email[]>;

package/dist/providers/moakt.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEmail = generateEmail;
+exports.getEmails = getEmails;
+const normalize_1 = require("../normalize");
+const retry_1 = require("../retry");
+const CHANNEL = 'moakt';
+const ORIGIN = 'https://www.moakt.com';
+const TOK_PREFIX = 'mok1:';
+const EMAIL_DIV_RE = /<div\s+id="email-address"\s*>([^<]+)<\/div>/is;
+const HREF_EMAIL_RE = /href="(\/[^"]+\/email\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})"/gi;
+const TITLE_RE = /<li\s+class="title"\s*>([^<]*)<\/li>/is;
+const DATE_RE = /<li\s+class="date"[^>]*>[\s\S]*?<span[^>]*>([^<]+)<\/span>/is;
+const SENDER_RE = /<li\s+class="sender"[^>]*>[\s\S]*?<span[^>]*>([\s\S]*?)<\/span>\s*<\/li>/is;
+const BODY_RE = /<div\s+class="email-body"\s*>([\s\S]*?)<\/div>/is;
+const FROM_ADDR_RE = /<([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})>/;
+const TAG_RE = /<[^>]+>/g;
+function setCookieLines(headers) {
+    const h = headers;
+    if (typeof h.getSetCookie === 'function') {
+        return h.getSetCookie();
+    }
+    const one = headers.get('set-cookie');
+    return one ? [one] : [];
+}
+function localeFromDomain(domain) {
+    const s = String(domain ?? '').trim();
+    if (!s || /[/?#\\]/.test(s))
+        return 'zh';
+    return s;
+}
+function parseCookieMap(hdr) {
+    const m = new Map();
+    for (const part of hdr.split(';')) {
+        const p = part.trim();
+        if (!p || !p.includes('='))
+            continue;
+        const i = p.indexOf('=');
+        const k = p.slice(0, i).trim();
+        const v = p.slice(i + 1).trim();
+        if (k)
+            m.set(k, v);
+    }
+    return m;
+}
+function mergeCookieHeader(prev, headers) {
+    const m = parseCookieMap(prev);
+    for (const line of setCookieLines(headers)) {
+        const first = line.split(';')[0] ?? '';
+        const i = first.indexOf('=');
+        if (i <= 0)
+            continue;
+        const k = first.slice(0, i).trim();
+        const v = first.slice(i + 1).trim();
+        if (k)
+            m.set(k, v);
+    }
+    return [...m.entries()]
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([k, v]) => `${k}=${v}`)
+        .join('; ');
+}
+function lightUnescape(s) {
+    return s
+        .replace(/&amp;/g, '\u0000')
+        .replace(/&quot;/g, '"')
+        .replace(/&#34;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/\u0000/g, '&');
+}
+function encSess(l, c) {
+    const raw = JSON.stringify({ l, c });
+    return TOK_PREFIX + Buffer.from(raw, 'utf8').toString('base64');
+}
+function decSess(tok) {
+    if (!tok.startsWith(TOK_PREFIX)) {
+        throw new Error('moakt: invalid session token');
+    }
+    let raw;
+    try {
+        raw = Buffer.from(tok.slice(TOK_PREFIX.length), 'base64').toString('utf8');
+    }
+    catch {
+        throw new Error('moakt: invalid session token');
+    }
+    const o = JSON.parse(raw);
+    const l = (o.l ?? '').trim();
+    const c = (o.c ?? '').trim();
+    if (!l || !c)
+        throw new Error('moakt: invalid session token');
+    return { l, c };
+}
+function pageHeaders(referer) {
+    return {
+        Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+        'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6',
+        'Cache-Control': 'no-cache',
+        DNT: '1',
+        Pragma: 'no-cache',
+        Referer: referer,
+        'Upgrade-Insecure-Requests': '1',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0',
+    };
+}
+function parseInboxEmail(html) {
+    const m = EMAIL_DIV_RE.exec(html);
+    if (!m?.[1])
+        throw new Error('moakt: email-address not found');
+    const addr = lightUnescape(m[1].trim());
+    if (!addr)
+        throw new Error('moakt: empty email-address');
+    return addr;
+}
+function stripTags(s) {
+    return s.replace(TAG_RE, ' ').replace(/\s+/g, ' ').trim();
+}
+function listMailIds(html) {
+    const seen = new Set();
+    const out = [];
+    HREF_EMAIL_RE.lastIndex = 0;
+    let cap;
+    while ((cap = HREF_EMAIL_RE.exec(html)) !== null) {
+        const path = cap[1];
+        if (path.includes('/delete'))
+            continue;
+        const id = path.split('/').pop() ?? '';
+        if (id.length === 36 && !seen.has(id)) {
+            seen.add(id);
+            out.push(id);
+        }
+    }
+    return out;
+}
+function parseDetail(page, id, recipient) {
+    let fromS = '';
+    const sm = SENDER_RE.exec(page);
+    if (sm?.[1]) {
+        const inner = lightUnescape(sm[1]);
+        fromS = stripTags(inner);
+        const em = FROM_ADDR_RE.exec(inner);
+        if (em?.[1])
+            fromS = em[1].trim();
+    }
+    let subject = '';
+    const tm = TITLE_RE.exec(page);
+    if (tm?.[1])
+        subject = lightUnescape(tm[1].trim());
+    let date = '';
+    const dm = DATE_RE.exec(page);
+    if (dm?.[1])
+        date = lightUnescape(dm[1].trim());
+    let htmlBody = '';
+    const bm = BODY_RE.exec(page);
+    if (bm?.[1])
+        htmlBody = bm[1].trim();
+    return {
+        id,
+        to: recipient,
+        from: fromS,
+        subject,
+        date,
+        html: htmlBody,
+    };
+}
+async function generateEmail(domain) {
+    const loc = localeFromDomain(domain);
+    const base = `${ORIGIN}/${loc}`;
+    const inbox = `${base}/inbox`;
+    const r1 = await (0, retry_1.fetchWithTimeout)(base, { headers: pageHeaders(base) });
+    if (!r1.ok)
+        throw new Error(`moakt generate: ${r1.status}`);
+    let cookieHdr = mergeCookieHeader('', r1.headers);
+    const r2 = await (0, retry_1.fetchWithTimeout)(inbox, {
+        headers: { ...pageHeaders(base), Cookie: cookieHdr },
+    });
+    if (!r2.ok)
+        throw new Error(`moakt inbox: ${r2.status}`);
+    cookieHdr = mergeCookieHeader(cookieHdr, r2.headers);
+    const html = await r2.text();
+    const email = parseInboxEmail(html);
+    if (!parseCookieMap(cookieHdr).has('tm_session')) {
+        throw new Error('moakt: missing tm_session cookie');
+    }
+    const token = encSess(loc, cookieHdr);
+    return { channel: CHANNEL, email, token };
+}
+async function getEmails(email, token) {
+    const { l: loc, c: cookieHdr } = decSess(token);
+    const inbox = `${ORIGIN}/${loc}/inbox`;
+    const baseRef = `${ORIGIN}/${loc}`;
+    const r = await (0, retry_1.fetchWithTimeout)(inbox, {
+        headers: { ...pageHeaders(baseRef), Cookie: cookieHdr },
+    });
+    if (!r.ok)
+        throw new Error(`moakt inbox: ${r.status}`);
+    const inboxHtml = await r.text();
+    const ids = listMailIds(inboxHtml);
+    const out = [];
+    for (const id of ids) {
+        const detail = `${ORIGIN}/${loc}/email/${id}/html`;
+        const refer = `${ORIGIN}/${loc}/email/${id}`;
+        const rd = await (0, retry_1.fetchWithTimeout)(detail, {
+            headers: { ...pageHeaders(refer), Cookie: cookieHdr },
+        });
+        if (!rd.ok)
+            continue;
+        const page = await rd.text();
+        out.push((0, normalize_1.normalizeEmail)(parseDetail(page, id, email), email));
+    }
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"moakt.js","sourceRoot":"","sources":["../../src/providers/moakt.ts"],"names":[],"mappings":"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","sourcesContent":["import { InternalEmailInfo, Email, Channel } from '../types';\nimport { normalizeEmail } from '../normalize';\nimport { fetchWithTimeout } from '../retry';\n\nconst CHANNEL: Channel = 'moakt';\nconst ORIGIN = 'https://www.moakt.com';\nconst TOK_PREFIX = 'mok1:';\n\nconst EMAIL_DIV_RE = /<div\\s+id=\"email-address\"\\s*>([^<]+)<\\/div>/is;\nconst HREF_EMAIL_RE =\n  /href=\"(\\/[^\"]+\\/email\\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\"/gi;\nconst TITLE_RE = /<li\\s+class=\"title\"\\s*>([^<]*)<\\/li>/is;\nconst DATE_RE = /<li\\s+class=\"date\"[^>]*>[\\s\\S]*?<span[^>]*>([^<]+)<\\/span>/is;\nconst SENDER_RE = /<li\\s+class=\"sender\"[^>]*>[\\s\\S]*?<span[^>]*>([\\s\\S]*?)<\\/span>\\s*<\\/li>/is;\nconst BODY_RE = /<div\\s+class=\"email-body\"\\s*>([\\s\\S]*?)<\\/div>/is;\nconst FROM_ADDR_RE = /<([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,})>/;\nconst TAG_RE = /<[^>]+>/g;\n\nfunction setCookieLines(headers: Headers): string[] {\n  const h = headers as Headers & { getSetCookie?: () => string[] };\n  if (typeof h.getSetCookie === 'function') {\n    return h.getSetCookie();\n  }\n  const one = headers.get('set-cookie');\n  return one ? [one] : [];\n}\n\nfunction localeFromDomain(domain?: string | null): string {\n  const s = String(domain ?? '').trim();\n  if (!s || /[/?#\\\\]/.test(s)) return 'zh';\n  return s;\n}\n\nfunction parseCookieMap(hdr: string): Map<string, string> {\n  const m = new Map<string, string>();\n  for (const part of hdr.split(';')) {\n    const p = part.trim();\n    if (!p || !p.includes('=')) continue;\n    const i = p.indexOf('=');\n    const k = p.slice(0, i).trim();\n    const v = p.slice(i + 1).trim();\n    if (k) m.set(k, v);\n  }\n  return m;\n}\n\nfunction mergeCookieHeader(prev: string, headers: Headers): string {\n  const m = parseCookieMap(prev);\n  for (const line of setCookieLines(headers)) {\n    const first = line.split(';')[0] ?? '';\n    const i = first.indexOf('=');\n    if (i <= 0) continue;\n    const k = first.slice(0, i).trim();\n    const v = first.slice(i + 1).trim();\n    if (k) m.set(k, v);\n  }\n  return [...m.entries()]\n    .sort((a, b) => a[0].localeCompare(b[0]))\n    .map(([k, v]) => `${k}=${v}`)\n    .join('; ');\n}\n\nfunction lightUnescape(s: string): string {\n  return s\n    .replace(/&amp;/g, '\\u0000')\n    .replace(/&quot;/g, '\"')\n    .replace(/&#34;/g, '\"')\n    .replace(/&#39;/g, \"'\")\n    .replace(/&lt;/g, '<')\n    .replace(/&gt;/g, '>')\n    .replace(/\\u0000/g, '&');\n}\n\nfunction encSess(l: string, c: string): string {\n  const raw = JSON.stringify({ l, c });\n  return TOK_PREFIX + Buffer.from(raw, 'utf8').toString('base64');\n}\n\nfunction decSess(tok: string): { l: string; c: string } {\n  if (!tok.startsWith(TOK_PREFIX)) {\n    throw new Error('moakt: invalid session token');\n  }\n  let raw: string;\n  try {\n    raw = Buffer.from(tok.slice(TOK_PREFIX.length), 'base64').toString('utf8');\n  } catch {\n    throw new Error('moakt: invalid session token');\n  }\n  const o = JSON.parse(raw) as { l?: string; c?: string };\n  const l = (o.l ?? '').trim();\n  const c = (o.c ?? '').trim();\n  if (!l || !c) throw new Error('moakt: invalid session token');\n  return { l, c };\n}\n\nfunction pageHeaders(referer: string): Record<string, string> {\n  return {\n    Accept:\n      'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',\n    'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6',\n    'Cache-Control': 'no-cache',\n    DNT: '1',\n    Pragma: 'no-cache',\n    Referer: referer,\n    'Upgrade-Insecure-Requests': '1',\n    'User-Agent':\n      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0',\n  };\n}\n\nfunction parseInboxEmail(html: string): string {\n  const m = EMAIL_DIV_RE.exec(html);\n  if (!m?.[1]) throw new Error('moakt: email-address not found');\n  const addr = lightUnescape(m[1].trim());\n  if (!addr) throw new Error('moakt: empty email-address');\n  return addr;\n}\n\nfunction stripTags(s: string): string {\n  return s.replace(TAG_RE, ' ').replace(/\\s+/g, ' ').trim();\n}\n\nfunction listMailIds(html: string): string[] {\n  const seen = new Set<string>();\n  const out: string[] = [];\n  HREF_EMAIL_RE.lastIndex = 0;\n  let cap: RegExpExecArray | null;\n  while ((cap = HREF_EMAIL_RE.exec(html)) !== null) {\n    const path = cap[1];\n    if (path.includes('/delete')) continue;\n    const id = path.split('/').pop() ?? '';\n    if (id.length === 36 && !seen.has(id)) {\n      seen.add(id);\n      out.push(id);\n    }\n  }\n  return out;\n}\n\nfunction parseDetail(page: string, id: string, recipient: string): Record<string, unknown> {\n  let fromS = '';\n  const sm = SENDER_RE.exec(page);\n  if (sm?.[1]) {\n    const inner = lightUnescape(sm[1]);\n    fromS = stripTags(inner);\n    const em = FROM_ADDR_RE.exec(inner);\n    if (em?.[1]) fromS = em[1].trim();\n  }\n  let subject = '';\n  const tm = TITLE_RE.exec(page);\n  if (tm?.[1]) subject = lightUnescape(tm[1].trim());\n  let date = '';\n  const dm = DATE_RE.exec(page);\n  if (dm?.[1]) date = lightUnescape(dm[1].trim());\n  let htmlBody = '';\n  const bm = BODY_RE.exec(page);\n  if (bm?.[1]) htmlBody = bm[1].trim();\n  return {\n    id,\n    to: recipient,\n    from: fromS,\n    subject,\n    date,\n    html: htmlBody,\n  };\n}\n\nexport async function generateEmail(domain?: string | null): Promise<InternalEmailInfo> {\n  const loc = localeFromDomain(domain);\n  const base = `${ORIGIN}/${loc}`;\n  const inbox = `${base}/inbox`;\n\n  const r1 = await fetchWithTimeout(base, { headers: pageHeaders(base) });\n  if (!r1.ok) throw new Error(`moakt generate: ${r1.status}`);\n  let cookieHdr = mergeCookieHeader('', r1.headers);\n\n  const r2 = await fetchWithTimeout(inbox, {\n    headers: { ...pageHeaders(base), Cookie: cookieHdr },\n  });\n  if (!r2.ok) throw new Error(`moakt inbox: ${r2.status}`);\n  cookieHdr = mergeCookieHeader(cookieHdr, r2.headers);\n  const html = await r2.text();\n\n  const email = parseInboxEmail(html);\n  if (!parseCookieMap(cookieHdr).has('tm_session')) {\n    throw new Error('moakt: missing tm_session cookie');\n  }\n  const token = encSess(loc, cookieHdr);\n  return { channel: CHANNEL, email, token };\n}\n\nexport async function getEmails(email: string, token: string): Promise<Email[]> {\n  const { l: loc, c: cookieHdr } = decSess(token);\n  const inbox = `${ORIGIN}/${loc}/inbox`;\n  const baseRef = `${ORIGIN}/${loc}`;\n\n  const r = await fetchWithTimeout(inbox, {\n    headers: { ...pageHeaders(baseRef), Cookie: cookieHdr },\n  });\n  if (!r.ok) throw new Error(`moakt inbox: ${r.status}`);\n  const inboxHtml = await r.text();\n  const ids = listMailIds(inboxHtml);\n  const out: Email[] = [];\n  for (const id of ids) {\n    const detail = `${ORIGIN}/${loc}/email/${id}/html`;\n    const refer = `${ORIGIN}/${loc}/email/${id}`;\n    const rd = await fetchWithTimeout(detail, {\n      headers: { ...pageHeaders(refer), Cookie: cookieHdr },\n    });\n    if (!rd.ok) continue;\n    const page = await rd.text();\n    out.push(normalizeEmail(parseDetail(page, id, email), email));\n  }\n  return out;\n}\n"]}

package/dist/providers/ta-easy.d.ts

@@ -0,0 +1,5 @@
+import { InternalEmailInfo, Email } from '../types';
+/** POST /temp-email/address/new（空 body） */
+export declare function generateEmail(): Promise<InternalEmailInfo>;
+/** POST /temp-email/inbox/list */
+export declare function getEmails(email: string, token: string): Promise<Email[]>;

package/dist/providers/ta-easy.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEmail = generateEmail;
+exports.getEmails = getEmails;
+const normalize_1 = require("../normalize");
+const retry_1 = require("../retry");
+const CHANNEL = 'ta-easy';
+const API_BASE = 'https://api-endpoint.ta-easy.com';
+const ORIGIN = 'https://www.ta-easy.com';
+function browserHeaders() {
+    return {
+        Accept: 'application/json',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0',
+        origin: ORIGIN,
+        referer: `${ORIGIN}/`,
+    };
+}
+/** POST /temp-email/address/new（空 body） */
+async function generateEmail() {
+    const res = await (0, retry_1.fetchWithTimeout)(`${API_BASE}/temp-email/address/new`, {
+        method: 'POST',
+        headers: { ...browserHeaders(), 'Content-Length': '0' },
+    });
+    if (!res.ok) {
+        throw new Error(`ta-easy generate: ${res.status}`);
+    }
+    const data = await res.json();
+    if (data.status !== 'success' || !data.address || !data.token) {
+        throw new Error(data.message ? `ta-easy: ${data.message}` : 'ta-easy: create failed');
+    }
+    return {
+        channel: CHANNEL,
+        email: data.address,
+        token: data.token,
+        expiresAt: typeof data.expiresAt === 'number' ? data.expiresAt : undefined,
+    };
+}
+/** POST /temp-email/inbox/list */
+async function getEmails(email, token) {
+    const res = await (0, retry_1.fetchWithTimeout)(`${API_BASE}/temp-email/inbox/list`, {
+        method: 'POST',
+        headers: { ...browserHeaders(), 'Content-Type': 'application/json' },
+        body: JSON.stringify({ token, email }),
+    });
+    if (!res.ok) {
+        throw new Error(`ta-easy inbox: ${res.status}`);
+    }
+    const data = await res.json();
+    if (data.status !== 'success') {
+        throw new Error(data.message ? `ta-easy: ${data.message}` : 'ta-easy: inbox failed');
+    }
+    const list = Array.isArray(data.data) ? data.data : [];
+    return list.map((raw) => (0, normalize_1.normalizeEmail)(raw, email));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/tempmailg.d.ts

@@ -0,0 +1,7 @@
+/**
+ * tempmailg.com：无 Cookie 罐 GET /public/{locale} 拿会话，POST /public/get_messages 建邮与收信。
+ * Token 为 tmg1: + base64(JSON{locale,cookieHdr,csrf})。
+ */
+import { InternalEmailInfo, Email } from '../types';
+export declare function generateEmail(domain?: string | null): Promise<InternalEmailInfo>;
+export declare function getEmails(email: string, token: string): Promise<Email[]>;