stratal 0.0.12 → 0.0.14

package/dist/router-context-DlTxpJUG.mjs

@@ -0,0 +1,264 @@
+import { n as RequestContainerNotInitializedError } from "./errors-BRJgVd5-.mjs";
+import { stream, streamSSE, streamText } from "hono/streaming";
+//#region src/router/constants.ts
+/**
+* Type-safe context keys for Hono router variables
+* Using symbols to avoid string collisions
+*/
+const ROUTER_CONTEXT_KEYS = {
+	REQUEST_CONTAINER: "requestContainer",
+	LOCALE: "locale"
+};
+/**
+* Metadata keys for storing route and controller configuration
+* Using symbols to avoid collisions with other decorators
+*/
+const ROUTE_METADATA_KEYS = {
+	CONTROLLER_ROUTE: Symbol.for("stratal:controller:route"),
+	CONTROLLER_OPTIONS: Symbol.for("stratal:controller:options"),
+	CONTROLLER_MIDDLEWARES: Symbol.for("stratal:controller:middlewares"),
+	ROUTE_CONFIG: Symbol.for("stratal:route:config"),
+	DECORATED_METHODS: Symbol.for("stratal:decorated:methods"),
+	HTTP_ROUTE_CONFIG: Symbol.for("stratal:http-route:config"),
+	HTTP_DECORATED_METHODS: Symbol.for("stratal:http-decorated:methods"),
+	AUTH_GUARD: Symbol.for("stratal:auth:guard"),
+	GATEWAY_MARKER: Symbol.for("stratal:gateway:marker"),
+	WS_ON_MESSAGE: Symbol.for("stratal:ws:on-message"),
+	WS_ON_CLOSE: Symbol.for("stratal:ws:on-close"),
+	WS_ON_ERROR: Symbol.for("stratal:ws:on-error")
+};
+/**
+* Security scheme identifiers for OpenAPI
+* These reference the security scheme definitions in security.schemas.ts
+*/
+const SECURITY_SCHEMES = {
+	BEARER_AUTH: "bearerAuth",
+	API_KEY: "apiKey",
+	SESSION_COOKIE: "sessionCookie"
+};
+/**
+* HTTP method mapping for RESTful controller methods
+* Maps controller method names to HTTP verbs and path patterns
+*/
+const HTTP_METHODS = {
+	index: {
+		method: "get",
+		path: ""
+	},
+	show: {
+		method: "get",
+		path: "/:id"
+	},
+	create: {
+		method: "post",
+		path: ""
+	},
+	update: {
+		method: "put",
+		path: "/:id"
+	},
+	patch: {
+		method: "patch",
+		path: "/:id"
+	},
+	destroy: {
+		method: "delete",
+		path: "/:id"
+	}
+};
+/**
+* Default success status codes for RESTful controller methods
+* Used by @Route() decorator to auto-derive response status
+*/
+const METHOD_STATUS_CODES = {
+	index: 200,
+	show: 200,
+	create: 201,
+	update: 200,
+	patch: 200,
+	destroy: 200
+};
+/**
+* Sentinel symbol to opt a controller out of versioning.
+* When used as the version, no prefix is applied even when defaultVersion is set.
+*/
+const VERSION_NEUTRAL = Symbol.for("stratal:version:neutral");
+/**
+* Default content type for request bodies and responses
+*/
+const DEFAULT_CONTENT_TYPE = "application/json";
+//#endregion
+//#region src/router/router-context.ts
+/**
+* Router context wrapper with helper methods
+*
+* Provides convenient access to Hono's context and common request/response operations.
+* The native Hono context is available via the `c` property for advanced use cases.
+*
+* @example
+* ```typescript
+* async index(ctx: RouterContext): Promise<Response> {
+*   // Use helper methods
+*   const users = await this.service.findAll()
+*   return ctx.json(users)
+* }
+*
+* async show(ctx: RouterContext): Promise<Response> {
+*   // Access route params
+*   const id = ctx.param('id')
+*   const user = await this.service.findById(id)
+*   return ctx.json(user)
+* }
+*
+* async create(ctx: RouterContext): Promise<Response> {
+*   // Parse request body
+*   const body = await ctx.body<CreateUserInput>()
+*   const user = await this.service.create(body)
+*   return ctx.json(user, 201)
+* }
+* ```
+*/
+var RouterContext = class {
+	/**
+	* Native Hono context
+	* Access for advanced use cases not covered by helper methods
+	*/
+	constructor(c) {
+		this.c = c;
+	}
+	/**
+	* Get request-scoped DI container
+	* Contains request-specific services and context (AuthContext)
+	*
+	* @throws Error if container not initialized
+	*/
+	getContainer() {
+		const container = this.c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER);
+		if (!container) throw new RequestContainerNotInitializedError();
+		return container;
+	}
+	/**
+	* Set locale for the current request
+	* Locale is determined by X-Locale header or defaults to config
+	*
+	* @param locale - Locale code (e.g., 'en', 'fr')
+	*/
+	setLocale(locale) {
+		this.c.set(ROUTER_CONTEXT_KEYS.LOCALE, locale);
+	}
+	/**
+	* Get locale for the current request
+	*
+	* @returns Current locale code
+	*/
+	getLocale() {
+		return this.c.get(ROUTER_CONTEXT_KEYS.LOCALE) || "en";
+	}
+	/**
+	* Return JSON response
+	*
+	* @param data - Data to serialize as JSON
+	* @param status - HTTP status code (default: 200)
+	*/
+	json(data, status) {
+		return this.c.json(data, status);
+	}
+	/**
+	* Get route parameter value
+	*
+	* @param key - Parameter name (e.g., 'id' for /users/:id)
+	*/
+	param(key) {
+		return this.c.req.valid("param")[key];
+	}
+	/**
+	* Get query parameter value
+	*
+	* @param key - Query parameter name
+	*/
+	query(key) {
+		const validated = this.c.req.valid("query");
+		return key ? validated[key] : validated;
+	}
+	/**
+	* Get request header value
+	*
+	* @param name - Header name (case-insensitive)
+	*/
+	header(name) {
+		return this.c.req.header(name);
+	}
+	/**
+	* Get validated request body from OpenAPI route
+	* Returns pre-validated data that has passed schema validation
+	*
+	* @returns Validated JSON body
+	*/
+	body() {
+		return this.c.req.valid("json");
+	}
+	/**
+	* Return text response
+	*
+	* @param text - Text content
+	* @param status - HTTP status code (default: 200)
+	*/
+	text(text, status) {
+		return this.c.text(text, status);
+	}
+	/**
+	* Return HTML response
+	*
+	* @param html - HTML content
+	* @param status - HTTP status code (default: 200)
+	*/
+	html(html, status) {
+		return this.c.html(html, status);
+	}
+	/**
+	* Redirect to another URL
+	*
+	* @param url - Target URL
+	* @param status - HTTP status code (default: 302)
+	*/
+	redirect(url, status) {
+		return this.c.redirect(url, status);
+	}
+	/**
+	* Return a streaming response (binary/generic)
+	*
+	* @param callback - Async function that writes to the stream
+	* @param onError - Optional error handler called if an error occurs during streaming
+	*/
+	stream(callback, onError) {
+		return stream(this.c, callback, onError);
+	}
+	/**
+	* Return a streaming text response
+	*
+	* Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.
+	*
+	* @param callback - Async function that writes text to the stream
+	* @param onError - Optional error handler called if an error occurs during streaming
+	*/
+	streamText(callback, onError) {
+		this.c.header("Content-Encoding", "Identity");
+		return streamText(this.c, callback, onError);
+	}
+	/**
+	* Return a Server-Sent Events (SSE) streaming response
+	*
+	* Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.
+	*
+	* @param callback - Async function that writes SSE events to the stream
+	* @param onError - Optional error handler called if an error occurs during streaming
+	*/
+	streamSSE(callback, onError) {
+		this.c.header("Content-Encoding", "Identity");
+		return streamSSE(this.c, callback, onError);
+	}
+};
+//#endregion
+export { ROUTER_CONTEXT_KEYS as a, VERSION_NEUTRAL as c, METHOD_STATUS_CODES as i, DEFAULT_CONTENT_TYPE as n, ROUTE_METADATA_KEYS as o, HTTP_METHODS as r, SECURITY_SCHEMES as s, RouterContext as t };
+
+//# sourceMappingURL=router-context-DlTxpJUG.mjs.map

package/dist/router-context-DlTxpJUG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"router-context-DlTxpJUG.mjs","names":["honoStream","honoStreamText","honoStreamSSE"],"sources":["../src/router/constants.ts","../src/router/router-context.ts"],"sourcesContent":["/**\n * Type-safe context keys for Hono router variables\n * Using symbols to avoid string collisions\n */\nexport const ROUTER_CONTEXT_KEYS = {\n  REQUEST_CONTAINER: 'requestContainer',\n  LOCALE: 'locale'\n} as const satisfies Record<string, string>\n\n/**\n * Metadata keys for storing route and controller configuration\n * Using symbols to avoid collisions with other decorators\n */\nexport const ROUTE_METADATA_KEYS = {\n  CONTROLLER_ROUTE: Symbol.for('stratal:controller:route'),\n  CONTROLLER_OPTIONS: Symbol.for('stratal:controller:options'),\n  CONTROLLER_MIDDLEWARES: Symbol.for('stratal:controller:middlewares'),\n  ROUTE_CONFIG: Symbol.for('stratal:route:config'),\n  DECORATED_METHODS: Symbol.for('stratal:decorated:methods'),\n  HTTP_ROUTE_CONFIG: Symbol.for('stratal:http-route:config'),\n  HTTP_DECORATED_METHODS: Symbol.for('stratal:http-decorated:methods'),\n  AUTH_GUARD: Symbol.for('stratal:auth:guard'),\n  GATEWAY_MARKER: Symbol.for('stratal:gateway:marker'),\n  WS_ON_MESSAGE: Symbol.for('stratal:ws:on-message'),\n  WS_ON_CLOSE: Symbol.for('stratal:ws:on-close'),\n  WS_ON_ERROR: Symbol.for('stratal:ws:on-error'),\n} as const\n\n/**\n * Security scheme identifiers for OpenAPI\n * These reference the security scheme definitions in security.schemas.ts\n */\nexport const SECURITY_SCHEMES = {\n  BEARER_AUTH: 'bearerAuth',\n  API_KEY: 'apiKey',\n  SESSION_COOKIE: 'sessionCookie'\n} as const\n\n/**\n * HTTP method mapping for RESTful controller methods\n * Maps controller method names to HTTP verbs and path patterns\n */\nexport const HTTP_METHODS = {\n  index: { method: 'get', path: '' } as const,\n  show: { method: 'get', path: '/:id' } as const,\n  create: { method: 'post', path: '' } as const,\n  update: { method: 'put', path: '/:id' } as const,\n  patch: { method: 'patch', path: '/:id' } as const,\n  destroy: { method: 'delete', path: '/:id' } as const\n} as const\n\n/**\n * Default success status codes for RESTful controller methods\n * Used by @Route() decorator to auto-derive response status\n */\nexport const METHOD_STATUS_CODES = {\n  index: 200,\n  show: 200,\n  create: 201,\n  update: 200,\n  patch: 200,\n  destroy: 200\n} as const\n\n/**\n * Sentinel symbol to opt a controller out of versioning.\n * When used as the version, no prefix is applied even when defaultVersion is set.\n */\nexport const VERSION_NEUTRAL = Symbol.for('stratal:version:neutral')\n\n/**\n * Default content type for request bodies and responses\n */\nexport const DEFAULT_CONTENT_TYPE = 'application/json'\n","import type { Context } from 'hono'\nimport type { SSEStreamingApi } from 'hono/streaming'\nimport { stream as honoStream, streamSSE as honoStreamSSE, streamText as honoStreamText } from 'hono/streaming'\nimport type { ContentfulStatusCode, RedirectStatusCode } from 'hono/utils/http-status'\nimport type { StreamingApi } from 'hono/utils/stream'\nimport type { Container } from '../di/container'\nimport { RequestContainerNotInitializedError } from '../errors'\nimport { ROUTER_CONTEXT_KEYS } from './constants'\nimport type { RouterEnv } from './types'\n\nexport type ContextQueryResult<R extends Record<string, unknown> | undefined, K extends string | undefined> = K extends string ? string : R extends undefined ? Record<string, unknown> : R\n\n/**\n * Router context wrapper with helper methods\n *\n * Provides convenient access to Hono's context and common request/response operations.\n * The native Hono context is available via the `c` property for advanced use cases.\n *\n * @example\n * ```typescript\n * async index(ctx: RouterContext): Promise<Response> {\n *   // Use helper methods\n *   const users = await this.service.findAll()\n *   return ctx.json(users)\n * }\n *\n * async show(ctx: RouterContext): Promise<Response> {\n *   // Access route params\n *   const id = ctx.param('id')\n *   const user = await this.service.findById(id)\n *   return ctx.json(user)\n * }\n *\n * async create(ctx: RouterContext): Promise<Response> {\n *   // Parse request body\n *   const body = await ctx.body<CreateUserInput>()\n *   const user = await this.service.create(body)\n *   return ctx.json(user, 201)\n * }\n * ```\n */\nexport class RouterContext<T extends RouterEnv = RouterEnv> {\n  /**\n   * Native Hono context\n   * Access for advanced use cases not covered by helper methods\n   */\n  constructor(\n    public readonly c: Context<T>\n  ) { }\n\n  /**\n   * Get request-scoped DI container\n   * Contains request-specific services and context (AuthContext)\n   *\n   * @throws Error if container not initialized\n   */\n  getContainer(): Container {\n    const container = this.c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER)\n    if (!container) {\n      throw new RequestContainerNotInitializedError()\n    }\n    return container as Container\n  }\n\n  /**\n   * Set locale for the current request\n   * Locale is determined by X-Locale header or defaults to config\n   *\n   * @param locale - Locale code (e.g., 'en', 'fr')\n   */\n  setLocale(locale: string): void {\n    this.c.set(ROUTER_CONTEXT_KEYS.LOCALE, locale)\n  }\n\n  /**\n   * Get locale for the current request\n   *\n   * @returns Current locale code\n   */\n  getLocale(): string {\n    const locale = this.c.get(ROUTER_CONTEXT_KEYS.LOCALE)\n    return (locale as string) || 'en'\n  }\n\n  /**\n   * Return JSON response\n   *\n   * @param data - Data to serialize as JSON\n   * @param status - HTTP status code (default: 200)\n   */\n  json(data: object, status?: ContentfulStatusCode): Response {\n    return this.c.json(data, status)\n  }\n\n  /**\n   * Get route parameter value\n   *\n   * @param key - Parameter name (e.g., 'id' for /users/:id)\n   */\n  param(key: string): string {\n    return (this.c.req as unknown as { valid(target: 'param'): Record<string, string> }).valid('param')[key]\n  }\n\n  /**\n   * Get query parameter value\n   *\n   * @param key - Query parameter name\n   */\n  query<R extends Record<string, unknown> | undefined = undefined, K extends string | undefined = undefined>(key?: K): ContextQueryResult<R, K> {\n    const validated = (this.c.req as unknown as { valid(target: 'query'): Record<string, unknown> }).valid('query')\n    return key ? validated[key] as ContextQueryResult<R, K> : validated as ContextQueryResult<R, K>\n  }\n\n  /**\n   * Get request header value\n   *\n   * @param name - Header name (case-insensitive)\n   */\n  header(name: string): string | undefined {\n    return this.c.req.header(name)\n  }\n\n  /**\n   * Get validated request body from OpenAPI route\n   * Returns pre-validated data that has passed schema validation\n   *\n   * @returns Validated JSON body\n   */\n  body<T>(): Promise<T> {\n    // Type assertion needed because req.valid() is type-safe per route\n    // but this is a generic helper method that works across all routes\n    return (this.c.req as unknown as { valid(target: 'json'): Promise<T> }).valid('json')\n  }\n\n  /**\n   * Return text response\n   *\n   * @param text - Text content\n   * @param status - HTTP status code (default: 200)\n   */\n  text(text: string, status?: ContentfulStatusCode): Response {\n    return this.c.text(text, status)\n  }\n\n  /**\n   * Return HTML response\n   *\n   * @param html - HTML content\n   * @param status - HTTP status code (default: 200)\n   */\n  html(html: string, status?: ContentfulStatusCode): Response {\n    return this.c.html(html, status)\n  }\n\n  /**\n   * Redirect to another URL\n   *\n   * @param url - Target URL\n   * @param status - HTTP status code (default: 302)\n   */\n  redirect(url: string, status?: RedirectStatusCode): Response {\n    return this.c.redirect(url, status)\n  }\n\n  /**\n   * Return a streaming response (binary/generic)\n   *\n   * @param callback - Async function that writes to the stream\n   * @param onError - Optional error handler called if an error occurs during streaming\n   */\n  stream(callback: (stream: StreamingApi) => Promise<void>, onError?: (err: Error, stream: StreamingApi) => Promise<void>): Response {\n    return honoStream(this.c, callback, onError)\n  }\n\n  /**\n   * Return a streaming text response\n   *\n   * Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.\n   *\n   * @param callback - Async function that writes text to the stream\n   * @param onError - Optional error handler called if an error occurs during streaming\n   */\n  streamText(callback: (stream: StreamingApi) => Promise<void>, onError?: (err: Error, stream: StreamingApi) => Promise<void>): Response {\n    this.c.header('Content-Encoding', 'Identity')\n    return honoStreamText(this.c, callback, onError)\n  }\n\n  /**\n   * Return a Server-Sent Events (SSE) streaming response\n   *\n   * Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.\n   *\n   * @param callback - Async function that writes SSE events to the stream\n   * @param onError - Optional error handler called if an error occurs during streaming\n   */\n  streamSSE(callback: (stream: SSEStreamingApi) => Promise<void>, onError?: (err: Error, stream: SSEStreamingApi) => Promise<void>): Response {\n    this.c.header('Content-Encoding', 'Identity')\n    return honoStreamSSE(this.c, callback, onError)\n  }\n}\n"],"mappings":"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"}

package/dist/smtp.provider-BYY-AdmU.mjs

@@ -0,0 +1,77 @@
+import "./errors-BRJgVd5-.mjs";
+import "./logger-Bg-CuidS.mjs";
+import { EmailSmtpConnectionFailedError, SmtpConfigurationMissingError, SmtpHostMissingError } from "./email/index.mjs";
+import { t as BaseEmailProvider } from "./base-email.provider-bzdAYp8Z.mjs";
+import * as nodemailer from "nodemailer";
+import { Readable } from "stream";
+//#region src/email/providers/smtp.provider.ts
+/**
+* SMTP Email Provider
+*
+* Implementation of IEmailProvider using SMTP/nodemailer
+* Supports any SMTP server configured via SMTP_URL
+*/
+var SmtpProvider = class extends BaseEmailProvider {
+	transporter;
+	defaultFrom;
+	constructor(options) {
+		super();
+		this.options = options;
+		if (!this.options.smtp) throw new SmtpConfigurationMissingError();
+		if (!this.options.smtp.host) throw new SmtpHostMissingError();
+		this.transporter = nodemailer.createTransport({
+			host: this.options.smtp.host,
+			port: this.options.smtp.port,
+			secure: this.options.smtp.secure,
+			auth: this.options.smtp.username && this.options.smtp.password ? {
+				user: this.options.smtp.username,
+				pass: this.options.smtp.password
+			} : void 0
+		});
+		this.defaultFrom = this.options.from;
+	}
+	async send(message) {
+		try {
+			const from = message.from ? `${message.from.name} <${message.from.email}>` : `${this.defaultFrom.name} <${this.defaultFrom.email}>`;
+			const info = await this.transporter.sendMail({
+				from,
+				to: Array.isArray(message.to) ? message.to.join(", ") : message.to,
+				subject: message.subject,
+				html: message.html,
+				text: message.text,
+				replyTo: message.replyTo,
+				cc: message.cc?.join(", "),
+				bcc: message.bcc?.join(", "),
+				attachments: message.attachments?.map((attachment) => ({
+					filename: attachment.filename,
+					content: this.toNodeStream(attachment.content),
+					contentType: attachment.contentType
+				}))
+			});
+			return {
+				messageId: info.messageId,
+				accepted: true,
+				metadata: {
+					provider: "smtp",
+					response: info.response
+				}
+			};
+		} catch {
+			throw new EmailSmtpConnectionFailedError(this.options.smtp?.host ?? "", this.options.smtp?.port ?? 587);
+		}
+	}
+	/**
+	* Convert attachment content to Node.js stream format
+	*
+	* Nodemailer expects Node.js Readable streams, not web ReadableStream.
+	* Buffer is passed through as-is since nodemailer supports it directly.
+	*/
+	toNodeStream(content) {
+		if (Buffer.isBuffer(content)) return content;
+		return Readable.fromWeb(content);
+	}
+};
+//#endregion
+export { SmtpProvider };
+
+//# sourceMappingURL=smtp.provider-BYY-AdmU.mjs.map

package/dist/smtp.provider-BYY-AdmU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"smtp.provider-BYY-AdmU.mjs","names":[],"sources":["../src/email/providers/smtp.provider.ts"],"sourcesContent":["import type { Transporter } from 'nodemailer'\nimport * as nodemailer from 'nodemailer'\nimport type SMTPTransport from 'nodemailer/lib/smtp-transport'\nimport { Readable } from 'stream'\nimport type { ResolvedEmailAttachment, ResolvedEmailMessage } from '../contracts'\nimport type { EmailModuleOptions } from '../email.module'\nimport { EmailSmtpConnectionFailedError, SmtpConfigurationMissingError, SmtpHostMissingError } from '../errors'\nimport { BaseEmailProvider } from './base-email.provider'\nimport type { EmailSendResult } from './email-provider.interface'\n\n/**\n * SMTP Email Provider\n *\n * Implementation of IEmailProvider using SMTP/nodemailer\n * Supports any SMTP server configured via SMTP_URL\n */\nexport class SmtpProvider extends BaseEmailProvider {\n  private readonly transporter: Transporter<SMTPTransport.SentMessageInfo>\n  private readonly defaultFrom: { name: string; email: string }\n\n  constructor(\n    private readonly options: EmailModuleOptions\n  ) {\n    super()\n\n    // Validate SMTP configuration\n    if (!this.options.smtp) {\n      throw new SmtpConfigurationMissingError()\n    }\n\n    if (!this.options.smtp.host) {\n      throw new SmtpHostMissingError()\n    }\n\n    // Create nodemailer transporter\n    this.transporter = nodemailer.createTransport({\n      host: this.options.smtp.host,\n      port: this.options.smtp.port,\n      secure: this.options.smtp.secure,\n      auth: this.options.smtp.username && this.options.smtp.password\n        ? {\n          user: this.options.smtp.username,\n          pass: this.options.smtp.password,\n        }\n        : undefined,\n    })\n\n    this.defaultFrom = this.options.from\n  }\n\n  async send(message: ResolvedEmailMessage): Promise<EmailSendResult> {\n    try {\n      const from = message.from\n        ? `${message.from.name} <${message.from.email}>`\n        : `${this.defaultFrom.name} <${this.defaultFrom.email}>`\n\n      const info = await this.transporter.sendMail({\n        from,\n        to: Array.isArray(message.to) ? message.to.join(', ') : message.to,\n        subject: message.subject,\n        html: message.html,\n        text: message.text,\n        replyTo: message.replyTo,\n        cc: message.cc?.join(', '),\n        bcc: message.bcc?.join(', '),\n        attachments: message.attachments?.map(attachment => ({\n          filename: attachment.filename,\n          content: this.toNodeStream(attachment.content),\n          contentType: attachment.contentType,\n        })),\n      })\n\n      return {\n        messageId: info.messageId,\n        accepted: true,\n        metadata: {\n          provider: 'smtp',\n          response: info.response,\n        },\n      }\n    } catch {\n      throw new EmailSmtpConnectionFailedError(\n        this.options.smtp?.host ?? '',\n        this.options.smtp?.port ?? 587\n      )\n    }\n  }\n\n  /**\n   * Convert attachment content to Node.js stream format\n   *\n   * Nodemailer expects Node.js Readable streams, not web ReadableStream.\n   * Buffer is passed through as-is since nodemailer supports it directly.\n   */\n  private toNodeStream(content: ResolvedEmailAttachment['content']): Buffer | Readable {\n    if (Buffer.isBuffer(content)) {\n      return content\n    }\n    // Convert web ReadableStream to Node.js Readable\n    return Readable.fromWeb(content as Parameters<typeof Readable.fromWeb>[0])\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAgBA,IAAa,eAAb,cAAkC,kBAAkB;CAClD;CACA;CAEA,YACE,SACA;AACA,SAAO;AAFU,OAAA,UAAA;AAKjB,MAAI,CAAC,KAAK,QAAQ,KAChB,OAAM,IAAI,+BAA+B;AAG3C,MAAI,CAAC,KAAK,QAAQ,KAAK,KACrB,OAAM,IAAI,sBAAsB;AAIlC,OAAK,cAAc,WAAW,gBAAgB;GAC5C,MAAM,KAAK,QAAQ,KAAK;GACxB,MAAM,KAAK,QAAQ,KAAK;GACxB,QAAQ,KAAK,QAAQ,KAAK;GAC1B,MAAM,KAAK,QAAQ,KAAK,YAAY,KAAK,QAAQ,KAAK,WAClD;IACA,MAAM,KAAK,QAAQ,KAAK;IACxB,MAAM,KAAK,QAAQ,KAAK;IACzB,GACC,KAAA;GACL,CAAC;AAEF,OAAK,cAAc,KAAK,QAAQ;;CAGlC,MAAM,KAAK,SAAyD;AAClE,MAAI;GACF,MAAM,OAAO,QAAQ,OACjB,GAAG,QAAQ,KAAK,KAAK,IAAI,QAAQ,KAAK,MAAM,KAC5C,GAAG,KAAK,YAAY,KAAK,IAAI,KAAK,YAAY,MAAM;GAExD,MAAM,OAAO,MAAM,KAAK,YAAY,SAAS;IAC3C;IACA,IAAI,MAAM,QAAQ,QAAQ,GAAG,GAAG,QAAQ,GAAG,KAAK,KAAK,GAAG,QAAQ;IAChE,SAAS,QAAQ;IACjB,MAAM,QAAQ;IACd,MAAM,QAAQ;IACd,SAAS,QAAQ;IACjB,IAAI,QAAQ,IAAI,KAAK,KAAK;IAC1B,KAAK,QAAQ,KAAK,KAAK,KAAK;IAC5B,aAAa,QAAQ,aAAa,KAAI,gBAAe;KACnD,UAAU,WAAW;KACrB,SAAS,KAAK,aAAa,WAAW,QAAQ;KAC9C,aAAa,WAAW;KACzB,EAAE;IACJ,CAAC;AAEF,UAAO;IACL,WAAW,KAAK;IAChB,UAAU;IACV,UAAU;KACR,UAAU;KACV,UAAU,KAAK;KAChB;IACF;UACK;AACN,SAAM,IAAI,+BACR,KAAK,QAAQ,MAAM,QAAQ,IAC3B,KAAK,QAAQ,MAAM,QAAQ,IAC5B;;;;;;;;;CAUL,aAAqB,SAAgE;AACnF,MAAI,OAAO,SAAS,QAAQ,CAC1B,QAAO;AAGT,SAAO,SAAS,QAAQ,QAAkD"}