@upyo/mailtrap 0.6.0-dev.0

package/dist/index.cjs

@@ -0,0 +1,656 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __upyo_core = __toESM(require("@upyo/core"));
+
+//#region src/config.ts
+const DEFAULT_SEND_BASE_URL = "https://send.api.mailtrap.io";
+const DEFAULT_SANDBOX_BASE_URL = "https://sandbox.api.mailtrap.io";
+const DEFAULT_CATEGORY = "transactional";
+const DEFAULT_USER_AGENT = "@upyo/mailtrap";
+/**
+* Creates a resolved Mailtrap configuration by applying default values.
+*
+* @param config The Mailtrap configuration with optional fields.
+* @returns A resolved configuration with all defaults applied.
+* @throws {RangeError} If `sandbox` is `true` and `inboxId` is missing.
+* @since 0.6.0
+*/
+function createMailtrapConfig(config) {
+	const sandbox = config.sandbox ?? false;
+	if (sandbox && !isValidInboxId(config.inboxId)) throw new RangeError("`inboxId` is required when Mailtrap sandbox mode is enabled.");
+	return {
+		apiToken: config.apiToken,
+		sandbox,
+		inboxId: config.inboxId,
+		sendBaseUrl: normalizeBaseUrl(config.sendBaseUrl ?? DEFAULT_SEND_BASE_URL),
+		sandboxBaseUrl: normalizeBaseUrl(config.sandboxBaseUrl ?? DEFAULT_SANDBOX_BASE_URL),
+		defaultCategory: config.defaultCategory ?? DEFAULT_CATEGORY,
+		metadata: config.metadata == null ? void 0 : { ...config.metadata },
+		userAgent: config.userAgent ?? DEFAULT_USER_AGENT,
+		timeout: config.timeout ?? 3e4,
+		retries: config.retries ?? 3,
+		validateSsl: config.validateSsl ?? true,
+		headers: config.headers == null ? {} : { ...config.headers }
+	};
+}
+function isValidInboxId(inboxId) {
+	if (inboxId === void 0 || inboxId === null) return false;
+	if (typeof inboxId === "number") return Number.isFinite(inboxId);
+	return inboxId.trim().length > 0;
+}
+function normalizeBaseUrl(baseUrl) {
+	return baseUrl.replace(/\/+$/, "");
+}
+
+//#endregion
+//#region src/http-client.ts
+const maxErrorMessageLength = 500;
+const sandboxRateLimitWindowMilliseconds = 1e4;
+const sandboxRateLimitMessage = "too many emails per second";
+/**
+* Mailtrap API error class for API-specific failures.
+*
+* @since 0.6.0
+*/
+var MailtrapApiError = class extends Error {
+	statusCode;
+	retryAfterMilliseconds;
+	attempts;
+	/**
+	* Creates a Mailtrap API error.
+	*
+	* @param message Error message.
+	* @param statusCode HTTP status code.
+	* @param retryAfterMilliseconds Retry delay from the response or Mailtrap's
+	* known sandbox rate-limit window.
+	* @param attempts Number of attempts made before this error.
+	*/
+	constructor(message, statusCode, retryAfterMilliseconds, attempts) {
+		super(message);
+		this.name = "MailtrapApiError";
+		this.statusCode = statusCode;
+		this.retryAfterMilliseconds = retryAfterMilliseconds;
+		this.attempts = attempts;
+	}
+};
+/**
+* Mailtrap request timeout error.
+*
+* @since 0.6.0
+*/
+var MailtrapTimeoutError = class extends Error {
+	/**
+	* Request timeout in milliseconds.
+	*
+	* @since 0.6.0
+	*/
+	timeout;
+	/**
+	* Number of attempts made before this error was produced.
+	*
+	* @since 0.6.0
+	*/
+	attempts;
+	/**
+	* Creates a Mailtrap request timeout error.
+	*
+	* @param timeout Request timeout in milliseconds.
+	* @param attempts Number of attempts made before this error.
+	*/
+	constructor(timeout, attempts) {
+		super(`Mailtrap API request timed out after ${timeout} ms.`);
+		this.name = "MailtrapTimeoutError";
+		this.timeout = timeout;
+		this.attempts = attempts;
+	}
+};
+/**
+* HTTP client wrapper for Mailtrap API requests.
+*
+* @since 0.6.0
+*/
+var MailtrapHttpClient = class {
+	config;
+	/**
+	* Creates a new Mailtrap HTTP client.
+	*
+	* @param config Resolved Mailtrap configuration.
+	*/
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Sends a single message via Mailtrap API.
+	*
+	* @param messageData The JSON data to send to Mailtrap.
+	* @param signal Optional AbortSignal for cancellation.
+	* @returns Promise that resolves to the Mailtrap response.
+	*/
+	sendMessage(messageData, signal) {
+		const url = this.resolveUrl("send");
+		return this.makeRequest(url, messageData, signal);
+	}
+	/**
+	* Sends multiple messages via Mailtrap batch API.
+	*
+	* @param requests The messages to send to Mailtrap.
+	* @param signal Optional AbortSignal for cancellation.
+	* @returns Promise that resolves to the Mailtrap batch response.
+	*/
+	sendBatch(requests, signal) {
+		const url = this.resolveUrl("batch");
+		return this.makeRequest(url, { requests }, signal);
+	}
+	resolveUrl(kind) {
+		const baseUrl = this.config.sandbox ? this.config.sandboxBaseUrl : this.config.sendBaseUrl;
+		const suffix = this.config.sandbox && this.config.inboxId != null ? `/${this.config.inboxId}` : "";
+		return `${baseUrl}/api/${kind}${suffix}`;
+	}
+	async makeRequest(url, body, signal) {
+		let lastError = null;
+		for (let attempt = 0; attempt <= this.config.retries; attempt++) {
+			signal?.throwIfAborted();
+			let responseText;
+			try {
+				const { response, text } = await this.fetchWithAuth(url, body, signal);
+				responseText = text;
+				if (!response.ok) {
+					const message = parseErrorMessage(responseText, response.status);
+					throw new MailtrapApiError(message, response.status, parseRetryAfter(response.headers.get("Retry-After")) ?? inferSandboxRetryAfter(message, response.status, this.config.sandbox), attempt + 1);
+				}
+			} catch (error) {
+				lastError = error instanceof Error ? error : new Error(String(error));
+				if (error instanceof MailtrapApiError && !isRetryable(error)) throw error;
+				if (error instanceof Error && error.name === "AbortError" && signal?.aborted) throw error;
+				if (attempt === this.config.retries) throw withAttempts(lastError, attempt + 1);
+				await sleep(calculateRetryDelay(attempt, lastError), signal);
+				continue;
+			}
+			try {
+				return JSON.parse(responseText);
+			} catch (error) {
+				throw new SyntaxError(`Invalid JSON response from Mailtrap API: ${error instanceof Error ? error.message : String(error)}.`);
+			}
+		}
+		throw lastError ?? /* @__PURE__ */ new Error("Request failed after all retry attempts.");
+	}
+	async fetchWithAuth(url, body, signal) {
+		const headers = new Headers({
+			"Content-Type": "application/json",
+			"Api-Token": this.config.apiToken,
+			"User-Agent": this.config.userAgent
+		});
+		for (const [key, value] of Object.entries(this.config.headers)) headers.set(key, value);
+		const timeoutController = new AbortController();
+		const timeoutId = this.config.timeout > 0 ? setTimeout(() => timeoutController.abort(), this.config.timeout) : void 0;
+		const requestSignal = (0, __upyo_core.combineSignals)(timeoutController.signal, signal);
+		try {
+			const response = await globalThis.fetch(url, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(body),
+				signal: requestSignal.signal
+			});
+			const text = await response.text();
+			return {
+				response,
+				text
+			};
+		} catch (error) {
+			if (error instanceof Error && error.name === "AbortError" && timeoutController.signal.aborted && !signal?.aborted) throw new MailtrapTimeoutError(this.config.timeout);
+			throw error;
+		} finally {
+			requestSignal.cleanup();
+			if (timeoutId !== void 0) clearTimeout(timeoutId);
+		}
+	}
+};
+function isRetryable(error) {
+	return error.statusCode === 408 || error.statusCode === 429 || error.statusCode >= 500;
+}
+function calculateRetryDelay(attempt, error) {
+	const baseDelay = Math.min(1e3 * Math.pow(2, attempt), 1e4);
+	const backoffDelay = Math.round(baseDelay / 2 + Math.random() * (baseDelay / 2));
+	if (error instanceof MailtrapApiError) return Math.max(backoffDelay, error.retryAfterMilliseconds ?? 0);
+	return backoffDelay;
+}
+function withAttempts(error, attempts) {
+	if (error instanceof MailtrapTimeoutError) return new MailtrapTimeoutError(error.timeout, attempts);
+	if (error instanceof MailtrapApiError) return new MailtrapApiError(error.message, error.statusCode, error.retryAfterMilliseconds, attempts);
+	return Object.assign(error, { attempts });
+}
+function parseRetryAfter(header) {
+	if (header == null || header === "") return void 0;
+	const asSeconds = Number(header);
+	if (Number.isFinite(asSeconds) && asSeconds >= 0) return Math.round(asSeconds * 1e3);
+	const asDate = Date.parse(header);
+	if (Number.isNaN(asDate)) return void 0;
+	return Math.max(0, asDate - Date.now());
+}
+function inferSandboxRetryAfter(message, statusCode, sandbox) {
+	if (sandbox && statusCode === 429 && message.toLowerCase().includes(sandboxRateLimitMessage)) return sandboxRateLimitWindowMilliseconds;
+	return void 0;
+}
+function parseErrorMessage(text, statusCode) {
+	try {
+		const errorBody = JSON.parse(text);
+		if (typeof errorBody.message === "string" && errorBody.message !== "") return truncateErrorMessage(errorBody.message);
+		if (Array.isArray(errorBody.errors) && errorBody.errors.length > 0) return truncateErrorMessage(errorBody.errors.join("; "));
+	} catch {}
+	return truncateErrorMessage(text) || `HTTP ${statusCode}`;
+}
+function truncateErrorMessage(message) {
+	return message.length > maxErrorMessageLength ? `${message.slice(0, maxErrorMessageLength)}...` : message;
+}
+function abortReason$1(signal) {
+	return signal?.reason ?? new DOMException("The operation was aborted.", "AbortError");
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(abortReason$1(signal));
+			return;
+		}
+		const timeoutState = {};
+		const onAbort = () => {
+			if (timeoutState.id !== void 0) clearTimeout(timeoutState.id);
+			signal?.removeEventListener("abort", onAbort);
+			reject(abortReason$1(signal));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		if (signal?.aborted) {
+			onAbort();
+			return;
+		}
+		timeoutState.id = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+	});
+}
+
+//#endregion
+//#region src/message-converter.ts
+const STANDARD_HEADERS = new Set([
+	"from",
+	"to",
+	"cc",
+	"bcc",
+	"reply-to",
+	"subject",
+	"date",
+	"message-id",
+	"content-type",
+	"content-transfer-encoding",
+	"mime-version",
+	"x-priority"
+]);
+/**
+* Converts an Upyo message to Mailtrap API JSON format.
+*
+* @param message The Upyo message to convert.
+* @param config The resolved Mailtrap configuration.
+* @param signal Optional abort signal for cancellation.
+* @returns JSON object ready for Mailtrap API submission.
+* @throws {RangeError} If the message has no text or HTML content.
+* @throws {Error} If the caller aborts the operation.
+* @since 0.6.0
+*/
+async function convertMessage(message, config, signal) {
+	signal?.throwIfAborted();
+	const emailData = {
+		from: formatAddress(message.sender),
+		to: message.recipients.map(formatAddress),
+		subject: message.subject,
+		category: resolveCategory(message.tags, config.defaultCategory)
+	};
+	if (message.ccRecipients.length > 0) emailData.cc = message.ccRecipients.map(formatAddress);
+	if (message.bccRecipients.length > 0) emailData.bcc = message.bccRecipients.map(formatAddress);
+	if (message.replyRecipients.length > 0) emailData.reply_to = formatAddress(message.replyRecipients[0]);
+	if ("html" in message.content) {
+		emailData.html = message.content.html;
+		if (message.content.text) emailData.text = message.content.text;
+	} else emailData.text = message.content.text;
+	if (!emailData.text && !emailData.html) throw new RangeError("Mailtrap requires at least one of text or HTML content.");
+	const customVariables = buildCustomVariables(message.tags, config.metadata);
+	if (Object.keys(customVariables).length > 0) emailData.custom_variables = customVariables;
+	const headers = {};
+	if (message.priority !== "normal") {
+		const priorityMap = {
+			"high": "1",
+			"normal": "3",
+			"low": "5"
+		};
+		headers["X-Priority"] = priorityMap[message.priority];
+	}
+	for (const [key, value] of message.headers.entries()) if (!isStandardHeader(key)) headers[key] = value;
+	if (Object.keys(headers).length > 0) emailData.headers = headers;
+	if (message.attachments.length > 0) emailData.attachments = await Promise.all(message.attachments.map((attachment) => convertAttachment(attachment, signal)));
+	signal?.throwIfAborted();
+	return emailData;
+}
+function resolveCategory(tags, fallback) {
+	return tags[0] ?? fallback;
+}
+function buildCustomVariables(tags, metadata) {
+	const customVariables = {};
+	if (metadata != null) for (const [key, value] of Object.entries(metadata)) customVariables[key] = value;
+	for (const tag of tags.slice(1)) customVariables[`tag_${tag}`] = tag;
+	return customVariables;
+}
+function formatAddress(address) {
+	if (address.name) return {
+		email: address.address,
+		name: address.name
+	};
+	return { email: address.address };
+}
+async function convertAttachment(attachment, signal) {
+	signal?.throwIfAborted();
+	const contentBytes = await waitForAttachmentContent(attachment.content, signal);
+	signal?.throwIfAborted();
+	const converted = {
+		content: uint8ArrayToBase64(contentBytes),
+		filename: attachment.filename
+	};
+	if (attachment.contentType) converted.type = attachment.contentType;
+	if (attachment.inline && attachment.contentId) {
+		converted.disposition = "inline";
+		converted.content_id = attachment.contentId;
+	} else converted.disposition = "attachment";
+	return converted;
+}
+function waitForAttachmentContent(content, signal) {
+	if (content instanceof Uint8Array) return signal?.aborted ? Promise.reject(abortReason(signal)) : Promise.resolve(content);
+	if (signal == null) return content;
+	if (signal.aborted) return Promise.reject(abortReason(signal));
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			signal.removeEventListener("abort", onAbort);
+			reject(abortReason(signal));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		content.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+function abortReason(signal) {
+	return signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+}
+function uint8ArrayToBase64(bytes) {
+	const nativeToBase64 = getNativeToBase64(bytes);
+	if (nativeToBase64 != null) return nativeToBase64();
+	const bufferBase64 = getBufferBase64(bytes);
+	if (bufferBase64 != null) return bufferBase64;
+	const chunkSize = 32768;
+	const chunks = [];
+	for (let offset = 0; offset < bytes.length; offset += chunkSize) chunks.push(String.fromCharCode(...bytes.subarray(offset, offset + chunkSize)));
+	return btoa(chunks.join(""));
+}
+function getNativeToBase64(bytes) {
+	const candidate = bytes;
+	const toBase64 = candidate.toBase64;
+	if (typeof toBase64 !== "function") return void 0;
+	return () => toBase64.call(bytes);
+}
+function getBufferBase64(bytes) {
+	const candidate = globalThis.Buffer;
+	if (typeof candidate?.from !== "function") return void 0;
+	try {
+		const buffer = candidate.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+		if (buffer == null || typeof buffer.toString !== "function") return void 0;
+		const base64 = buffer.toString("base64");
+		return typeof base64 === "string" ? base64 : void 0;
+	} catch {
+		return void 0;
+	}
+}
+function isStandardHeader(headerName) {
+	return STANDARD_HEADERS.has(headerName.toLowerCase());
+}
+
+//#endregion
+//#region src/mailtrap-transport.ts
+const MAX_BATCH_SIZE = 500;
+/**
+* Mailtrap transport implementation for sending emails via Mailtrap API.
+*
+* @example
+* ```typescript
+* import { createMessage } from "@upyo/core";
+* import { MailtrapTransport } from "@upyo/mailtrap";
+*
+* const transport = new MailtrapTransport({
+*   apiToken: "your-api-token",
+*   sandbox: true,
+*   inboxId: 12345,
+* });
+*
+* const receipt = await transport.send(createMessage({
+*   from: "sender@example.com",
+*   to: "recipient@example.com",
+*   subject: "Hello from Mailtrap",
+*   content: { text: "Hello!" },
+* }));
+* ```
+*
+* @since 0.6.0
+*/
+var MailtrapTransport = class {
+	id = "mailtrap";
+	/**
+	* The resolved Mailtrap configuration used by this transport.
+	*/
+	config;
+	httpClient;
+	/**
+	* Creates a new Mailtrap transport instance.
+	*
+	* @param config Mailtrap configuration including API token and options.
+	*/
+	constructor(config) {
+		this.config = createMailtrapConfig(config);
+		this.httpClient = new MailtrapHttpClient(this.config);
+	}
+	/**
+	* Sends a single email message via Mailtrap API.
+	*
+	* @param message The email message to send.
+	* @param options Optional transport options including `AbortSignal`.
+	* @returns A receipt indicating success or failure.
+	* @throws {Error} If the caller aborts the operation.
+	*/
+	async send(message, options) {
+		try {
+			options?.signal?.throwIfAborted();
+			const emailData = await convertMessage(message, this.config, options?.signal);
+			options?.signal?.throwIfAborted();
+			const response = await this.httpClient.sendMessage(emailData, options?.signal);
+			return responseToReceipt(response);
+		} catch (error) {
+			if (isCallerAbort(error, options?.signal)) throw error;
+			return createMailtrapFailure(error instanceof Error ? error.message : String(error), error);
+		}
+	}
+	/**
+	* Sends multiple email messages via Mailtrap batch API.
+	*
+	* Messages are chunked into Mailtrap's maximum batch size of 500 messages.
+	*
+	* @param messages An iterable or async iterable of messages to send.
+	* @param options Optional transport options including `AbortSignal`.
+	* @returns An async iterable of receipts, one for each message.
+	*/
+	async *sendMany(messages, options) {
+		options?.signal?.throwIfAborted();
+		let chunk = [];
+		for await (const message of messages) {
+			options?.signal?.throwIfAborted();
+			chunk.push(message);
+			if (chunk.length === MAX_BATCH_SIZE) {
+				yield* this.sendBatch(chunk, options);
+				chunk = [];
+			}
+		}
+		yield* this.sendBatch(chunk, options);
+	}
+	async *sendBatch(messages, options) {
+		if (messages.length === 0) return;
+		const batchData = [];
+		const receipts = [];
+		for (const message of messages) try {
+			batchData.push(await convertMessage(message, this.config, options?.signal));
+			receipts.push(void 0);
+		} catch (error) {
+			if (isCallerAbort(error, options?.signal)) throw error;
+			receipts.push(createMailtrapFailure(error instanceof Error ? error.message : String(error), error));
+		}
+		if (batchData.length === 0) {
+			for (const receipt of receipts) if (receipt !== void 0) yield receipt;
+			return;
+		}
+		try {
+			options?.signal?.throwIfAborted();
+			const response = await this.httpClient.sendBatch(batchData, options?.signal);
+			if (response.success === false) {
+				const errorMessage = formatErrors(response.errors) ?? "Mailtrap batch request failed.";
+				for (const receipt of receipts) {
+					if (receipt !== void 0) {
+						yield receipt;
+						continue;
+					}
+					yield (0, __upyo_core.createFailedReceipt)(errorMessage, {
+						provider: "mailtrap",
+						category: "rejected",
+						code: "mailtrap.batch_failed",
+						retryable: false,
+						providerDetails: response
+					});
+				}
+				return;
+			}
+			const itemResponses = response.responses ?? [];
+			let responseIndex = 0;
+			for (const receipt of receipts) {
+				if (receipt !== void 0) {
+					yield receipt;
+					continue;
+				}
+				const item = itemResponses[responseIndex++];
+				yield itemResponseToReceipt(item);
+			}
+		} catch (error) {
+			if (isCallerAbort(error, options?.signal)) throw error;
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			for (const receipt of receipts) {
+				if (receipt !== void 0) {
+					yield receipt;
+					continue;
+				}
+				yield createMailtrapFailure(errorMessage, error);
+			}
+		}
+	}
+};
+function responseToReceipt(response) {
+	return toReceipt(response, {
+		unsuccessfulMessage: "Mailtrap reported send failure.",
+		unsuccessfulCode: "mailtrap.unsuccessful",
+		missingMessageIdMessage: "Mailtrap response is missing a message ID."
+	});
+}
+function itemResponseToReceipt(response) {
+	return toReceipt(response, {
+		unsuccessfulMessage: "Mailtrap reported batch item failure.",
+		unsuccessfulCode: "mailtrap.batch_item_failed",
+		missingMessageIdMessage: "Mailtrap batch response is missing a message ID."
+	});
+}
+function toReceipt(response, options) {
+	if (response?.success === false) return (0, __upyo_core.createFailedReceipt)(formatErrors(response.errors) ?? options.unsuccessfulMessage, {
+		provider: "mailtrap",
+		category: "rejected",
+		code: options.unsuccessfulCode,
+		retryable: false,
+		providerDetails: response
+	});
+	const messageId = response?.message_ids?.[0];
+	if (messageId == null || messageId === "") return (0, __upyo_core.createFailedReceipt)(options.missingMessageIdMessage, {
+		provider: "mailtrap",
+		category: "unknown",
+		code: "mailtrap.missing_message_id",
+		retryable: false,
+		providerDetails: response
+	});
+	return {
+		successful: true,
+		messageId,
+		provider: "mailtrap"
+	};
+}
+function createMailtrapFailure(message, error) {
+	if (error instanceof MailtrapApiError) return (0, __upyo_core.createFailedReceipt)(message, {
+		provider: "mailtrap",
+		statusCode: error.statusCode,
+		retryAfterMilliseconds: error.retryAfterMilliseconds,
+		attempts: error.attempts
+	});
+	if (error instanceof MailtrapTimeoutError) return (0, __upyo_core.createFailedReceipt)(message, {
+		provider: "mailtrap",
+		category: "timeout",
+		code: "timeout",
+		retryable: true,
+		attempts: error.attempts
+	});
+	return (0, __upyo_core.createFailedReceipt)(message, {
+		provider: "mailtrap",
+		attempts: getErrorAttempts(error)
+	});
+}
+function formatErrors(errors) {
+	if (errors == null || errors.length === 0) return void 0;
+	return errors.join("; ");
+}
+function getErrorAttempts(error) {
+	if (typeof error !== "object" || error == null || !("attempts" in error)) return void 0;
+	const attempts = error.attempts;
+	return typeof attempts === "number" ? attempts : void 0;
+}
+function isAbortError(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
+function isCallerAbort(error, signal) {
+	return signal?.aborted === true && (isAbortError(error) || error === signal.reason);
+}
+
+//#endregion
+exports.MailtrapApiError = MailtrapApiError;
+exports.MailtrapTimeoutError = MailtrapTimeoutError;
+exports.MailtrapTransport = MailtrapTransport;
+exports.createMailtrapConfig = createMailtrapConfig;