sently 0.3.3 → 0.4.1

package/dist/core/dkim.d.ts

@@ -0,0 +1,22 @@
+import type { DKIMConfig } from "./types.js";
+/** Result of DKIM signing — the header line to prepend. */
+export interface DKIMSignResult {
+    /** Complete DKIM-Signature header line (without trailing CRLF). */
+    header: string;
+}
+/**
+ * Canonicalize headers using the relaxed algorithm (RFC 6376 §3.4.2).
+ */
+export declare function canonicalizeHeadersRelaxed(headers: string, fieldNames: string[]): string;
+/**
+ * Canonicalize body using the relaxed algorithm (RFC 6376 §3.4.4).
+ */
+export declare function canonicalizeBodyRelaxed(body: string): string;
+/**
+ * Import a PEM-encoded private key into a Web Crypto CryptoKey.
+ */
+export declare function importPrivateKey(pem: string, algorithm: "rsa-sha256" | "ed25519-sha256"): Promise<CryptoKey>;
+/**
+ * Sign a raw MIME message with DKIM.
+ */
+export declare function signDKIM(rawMessage: Uint8Array, config: DKIMConfig): Promise<DKIMSignResult>;

package/dist/core/mime.d.ts

@@ -0,0 +1,13 @@
+import type { DKIMConfig, Envelope, MailOptions } from "./types.js";
+/** Result of building a complete MIME message. */
+export interface MIMEBuildResult {
+    raw: Uint8Array;
+    envelope: Envelope;
+    messageId: string;
+    size: number;
+}
+/**
+ * Build a complete MIME message as a Uint8Array ready for SMTP DATA.
+ * When `dkim` is provided, signs the message and prepends the DKIM-Signature header.
+ */
+export declare function buildMIME(options: MailOptions, dkim?: DKIMConfig): Promise<MIMEBuildResult>;

package/dist/core/plugin.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module
+ * Plugin pipeline for sently.
+ * Plugins transform MailOptions before message construction.
+ * They run sequentially — each receives the previous plugin's output.
+ *
+ * @example
+ * ```ts
+ * import { runPlugins } from "sently/core/plugin";
+ * const result = await runPlugins(options, [pluginA, pluginB]);
+ * ```
+ */
+import type { MailOptions, MailPlugin } from "./types.js";
+/**
+ * Run a list of plugins sequentially over MailOptions.
+ * If plugins is empty or undefined, returns options unchanged.
+ * Each plugin may be sync or async.
+ *
+ * @param options - the original mail options
+ * @param plugins - ordered list of plugins to apply
+ * @returns transformed mail options after all plugins have run
+ */
+export declare function runPlugins(options: MailOptions, plugins: MailPlugin[] | undefined): Promise<MailOptions>;

package/dist/core/sigv4.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @module
+ * AWS Signature Version 4 signing using Web Crypto (HMAC-SHA256).
+ * Works on Node.js, Bun, Deno, and Cloudflare Workers.
+ * No external dependencies.
+ *
+ * @example
+ * ```ts
+ * import { signRequest } from "sently/core/sigv4";
+ * const signed = await signRequest({
+ *   method: "POST",
+ *   url: "https://email.us-east-1.amazonaws.com/v2/email/outbound-emails",
+ *   headers: { "content-type": "application/json" },
+ *   body: '{"..."}',
+ *   credentials: { accessKeyId, secretAccessKey, region: "us-east-1", service: "ses" },
+ * });
+ * ```
+ */
+/** AWS credentials and signing scope for SigV4. */
+export interface SigV4Credentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    region: string;
+    service: string;
+    sessionToken?: string;
+}
+/** HTTP request to sign with AWS Signature Version 4. */
+export interface SigV4Request {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body: string;
+    credentials: SigV4Credentials;
+    /** Override datetime for testing. Full 'YYYYMMDDTHHMMSSZ' when provided. */
+    _date?: string;
+}
+/** Signed request headers including Authorization. */
+export interface SigV4Result {
+    /** All headers including Authorization, x-amz-date, and x-amz-security-token */
+    headers: Record<string, string>;
+}
+/**
+ * Compute SHA-256 hash of a string using Web Crypto.
+ * Returns lowercase hex string.
+ * @internal
+ */
+export declare function sha256Hex(data: string): Promise<string>;
+/**
+ * Compute HMAC-SHA256 using Web Crypto.
+ * @internal
+ */
+export declare function hmacSHA256(key: Uint8Array | string, data: string): Promise<Uint8Array>;
+/**
+ * Sign an HTTP request with AWS Signature Version 4.
+ * Returns the complete set of headers to include in the request.
+ */
+export declare function signRequest(request: SigV4Request): Promise<SigV4Result>;

package/dist/core/smtp.d.ts

@@ -0,0 +1,90 @@
+export { computeCRAMMD5 } from "./cram-md5.js";
+/** SMTP command to send to the server. */
+export type SMTPCommand = {
+    type: "EHLO";
+    domain: string;
+} | {
+    type: "STARTTLS";
+} | {
+    type: "AUTH_LOGIN";
+    user: string;
+    pass: string;
+} | {
+    type: "AUTH_PLAIN";
+    user: string;
+    pass: string;
+} | {
+    type: "AUTH_CRAM_MD5_INIT";
+} | {
+    type: "AUTH_CRAM_MD5_RESPONSE";
+    response: string;
+} | {
+    type: "AUTH_XOAUTH2";
+    xoauth2String: string;
+} | {
+    type: "MAIL_FROM";
+    address: string;
+} | {
+    type: "RCPT_TO";
+    address: string;
+} | {
+    type: "DATA";
+} | {
+    type: "DATA_BODY";
+    content: Uint8Array;
+} | {
+    type: "QUIT";
+} | {
+    type: "RSET";
+} | {
+    type: "NOOP";
+};
+/** Parsed SMTP server response. */
+export interface SMTPResponse {
+    code: number;
+    message: string;
+    isSuccess: boolean;
+    isReady: boolean;
+    isError: boolean;
+}
+/** SMTP protocol error with server response details. */
+export declare class SMTPError extends Error {
+    readonly code: number;
+    readonly command: string;
+    readonly response: string;
+    /** Creates an SMTP protocol error. */
+    constructor(message: string, code: number, command: string, response: string);
+}
+/**
+ * Encode an SMTPCommand into a Uint8Array for sending over the socket.
+ */
+export declare function encodeCommand(cmd: SMTPCommand): Uint8Array;
+/**
+ * Parse raw bytes from the server into an SMTPResponse.
+ */
+export declare function parseResponse(data: Uint8Array): SMTPResponse;
+/**
+ * Accumulate byte chunks until a complete SMTP response is received.
+ */
+export declare function accumulateResponse(chunks: Uint8Array[]): Uint8Array | null;
+/**
+ * Select the best AUTH method from EHLO capability lines.
+ * Priority: XOAUTH2 > CRAM-MD5 > LOGIN > PLAIN.
+ */
+export declare function selectAuthMethod(capabilities: string[]): "LOGIN" | "PLAIN" | "CRAM-MD5" | "OAUTH2";
+/**
+ * Parse an EHLO multi-line response and extract capability keywords.
+ */
+export declare function parseEHLO(response: SMTPResponse): string[];
+/**
+ * Assert that an SMTPResponse code is within the expected set.
+ */
+export declare function assertResponse(response: SMTPResponse, expectedCodes: number[], command: string): void;
+/** Encode AUTH LOGIN password step (second base64 chunk). */
+export declare function encodeAuthLoginPass(pass: string): Uint8Array;
+/** Encode AUTH LOGIN user step when sent separately after 334. */
+export declare function encodeAuthLoginUser(user: string): Uint8Array;
+/** Encode CRAM-MD5 response after challenge. */
+export declare function encodeAuthCramResponse(response: string): Uint8Array;
+/** Encode raw SMTP line with CRLF. */
+export declare function encodeLine(line: string): Uint8Array;

package/dist/core/types.d.ts

@@ -0,0 +1,291 @@
+/** A single email address with optional display name. */
+export interface Address {
+    name?: string;
+    address: string;
+}
+/** Flexible address input accepted by mail APIs. */
+export type AddressInput = string | Address | (string | Address)[];
+/** Email attachment (in-memory or file path on supported runtimes). */
+export interface Attachment {
+    filename: string;
+    content?: Uint8Array | string;
+    path?: string;
+    contentType?: string;
+    encoding?: "base64" | "7bit" | "8bit" | "binary" | "quoted-printable";
+    contentId?: string;
+    inline?: boolean;
+    headers?: Record<string, string>;
+}
+/** Options for composing and sending an email message. */
+export interface MailOptions {
+    from: AddressInput;
+    to: AddressInput;
+    cc?: AddressInput;
+    bcc?: AddressInput;
+    replyTo?: AddressInput;
+    subject: string;
+    text?: string;
+    html?: string;
+    attachments?: Attachment[];
+    headers?: Record<string, string>;
+    messageId?: string;
+    date?: Date;
+    priority?: "high" | "normal" | "low";
+    encoding?: "utf-8" | "ascii";
+    /** Template name registered with templatePlugin */
+    template?: string;
+    /** Template variables passed to the rendering engine */
+    data?: Record<string, unknown>;
+}
+/** Result returned after a message is accepted for delivery. */
+export interface SendResult {
+    messageId: string;
+    accepted: string[];
+    rejected: string[];
+    response: string;
+    envelope: Envelope;
+}
+/** SMTP envelope addresses (MAIL FROM / RCPT TO). */
+export interface Envelope {
+    from: string;
+    to: string[];
+}
+/** Runtime-specific TCP/TLS socket abstraction for SMTP. */
+export interface SocketAdapter {
+    connect(host: string, port: number): Promise<void>;
+    startTLS(options?: TLSOptions): Promise<void>;
+    write(data: Uint8Array): Promise<void>;
+    read(): AsyncIterable<Uint8Array>;
+    close(): Promise<void>;
+    readonly secure: boolean;
+    readonly connected: boolean;
+}
+/** TLS connection options for STARTTLS and direct TLS. */
+export interface TLSOptions {
+    rejectUnauthorized?: boolean;
+    servername?: string;
+    /** Minimum TLS version. Useful for legacy SMTP servers still on TLS 1.1. */
+    minVersion?: "TLSv1" | "TLSv1.1" | "TLSv1.2" | "TLSv1.3";
+}
+/** Result returned by transport and mailer verify() calls. */
+export interface VerifyResult {
+    ok: boolean;
+    provider: string;
+    /** Human-readable status message from the provider */
+    message?: string;
+    /** Raw provider response (provider-specific) */
+    raw?: unknown;
+}
+/** Pluggable mail delivery backend (SMTP, HTTP API, etc.). */
+export interface Transport {
+    send(options: MailOptions): Promise<SendResult>;
+    verify?(): Promise<VerifyResult>;
+    close?(): Promise<void>;
+}
+/** DKIM signing configuration for outbound messages. */
+export interface DKIMConfig {
+    /** Your domain name. e.g. "example.com" */
+    domainName: string;
+    /** Key selector. e.g. "2024" → looks up 2024._domainkey.example.com */
+    keySelector: string;
+    /**
+     * DKIM private key in PEM format.
+     * Supports RSA (minimum 1024-bit, 2048 recommended) and Ed25519.
+     */
+    privateKey: string;
+    /** Algorithm. Default: "rsa-sha256". Use "ed25519-sha256" for Ed25519 keys. */
+    algorithm?: "rsa-sha256" | "ed25519-sha256";
+    /**
+     * Header fields to sign (colon-separated).
+     * Default follows RFC 6376 §5.4 recommendations.
+     */
+    headerFieldNames?: string;
+    /**
+     * Skip signing these header fields even if listed in headerFieldNames.
+     * Useful to exclude "message-id" and "date" for privacy.
+     */
+    skipFields?: string;
+}
+/** OAuth2 credentials for XOAUTH2 SMTP authentication. */
+export interface OAuth2Config {
+    /** The authenticated user's email address */
+    user: string;
+    /** OAuth2 client ID */
+    clientId: string;
+    /** OAuth2 client secret */
+    clientSecret: string;
+    /** Refresh token for automatic access token renewal */
+    refreshToken: string;
+    /** Current access token (optional — will be fetched if absent) */
+    accessToken?: string;
+    /** Token endpoint URL. Default: Google's token endpoint */
+    tokenUrl?: string;
+    /**
+     * Custom token provider function.
+     * If provided, clientId / clientSecret / refreshToken are ignored.
+     * The function must return a valid access token string.
+     */
+    getToken?: () => Promise<string>;
+}
+/** Connection pool and rate limiting options for SMTP. */
+export interface PoolConfig {
+    /** Use connection pooling. Default: false */
+    pool?: boolean;
+    /** Maximum number of simultaneous SMTP connections. Default: 5 */
+    maxConnections?: number;
+    /**
+     * Maximum number of messages per connection before it is recycled.
+     * Default: 100
+     */
+    maxMessages?: number;
+    /**
+     * Maximum send rate in messages per second across all connections.
+     * Default: unlimited
+     */
+    rateDelta?: number;
+    /**
+     * The time window in milliseconds for rate limiting.
+     * Default: 1000 (1 second)
+     */
+    rateLimit?: number;
+}
+/** Configuration for SMTP transport and relay connections. */
+export interface SMTPConfig extends PoolConfig {
+    host: string;
+    port?: number;
+    secure?: boolean;
+    auth?: SMTPAuth;
+    tls?: TLSOptions;
+    connectionTimeout?: number;
+    greetingTimeout?: number;
+    socketTimeout?: number;
+    direct?: boolean;
+    adapter?: SocketAdapter;
+    dkim?: DKIMConfig;
+    /** Plugins run sequentially before message construction. */
+    plugins?: MailPlugin[];
+}
+/** SMTP authentication credentials and method hint. */
+export interface SMTPAuth {
+    user: string;
+    pass?: string;
+    type?: "LOGIN" | "PLAIN" | "CRAM-MD5" | "OAUTH2";
+    oauth2?: OAuth2Config;
+}
+/** High-level mailer API wrapping a transport. */
+export interface Mailer {
+    send(options: MailOptions): Promise<SendResult>;
+    sendBulk(messages: MailOptions[], options?: BulkSendOptions): Promise<BulkSendResult>;
+    verify(): Promise<VerifyResult>;
+    close(): Promise<void>;
+}
+/** Options for batch sending multiple messages. */
+export interface BulkSendOptions {
+    /** Callback fired after each successful send */
+    onSuccess?: (message: MailOptions, index: number, result: SendResult) => void;
+    /** Callback fired after each failed send (does not throw) */
+    onError?: (message: MailOptions, index: number, error: unknown) => void;
+    /** Max concurrent sends. Defaults to pool maxConnections or 1 */
+    concurrency?: number;
+}
+/** Result of a batch send operation. */
+export interface BulkSendResult {
+    /** Total messages attempted */
+    total: number;
+    /** Number of successful sends */
+    sent: number;
+    /** Number of failed sends */
+    failed: number;
+    /** Per-message results in input order */
+    results: Array<{
+        status: "sent";
+        result: SendResult;
+    } | {
+        status: "failed";
+        error: unknown;
+    }>;
+}
+/** Configuration for RetryTransport backoff and retry rules. */
+export interface RetryConfig {
+    /** Maximum number of total attempts (including first). Default: 3 */
+    maxAttempts?: number;
+    /** Backoff strategy. Default: 'exponential' */
+    backoff?: "exponential" | "linear" | "fixed";
+    /** Base delay in ms. Default: 1000 */
+    baseDelay?: number;
+    /**
+     * HTTP status codes to retry on (for HTTP transports).
+     * Default: [429, 500, 502, 503, 504]
+     */
+    retryOn?: number[];
+    /** Optional callback called before each retry */
+    onRetry?: (attempt: number, error: unknown) => void;
+}
+/** Configuration for PreviewTransport disk output. */
+export interface PreviewConfig {
+    /**
+     * Directory to write .eml files.
+     * Default: './.emails'
+     */
+    outDir?: string;
+    /**
+     * Open the email in the default browser after writing.
+     * Uses 'open' on macOS, 'xdg-open' on Linux, 'start' on Windows.
+     * Default: false
+     */
+    open?: boolean;
+    /**
+     * File format to write.
+     * 'eml' = raw MIME, 'html' = HTML body only (for quick preview)
+     * Default: 'eml'
+     */
+    format?: "eml" | "html";
+}
+/** Options for {@link createMailer} — custom transport or SMTP config. */
+export type CreateMailerOptions = ({
+    transport: Transport;
+    plugins?: MailPlugin[];
+} & Partial<SMTPConfig>) | SMTPConfig;
+/**
+ * A mail plugin transforms MailOptions before the message is built.
+ * Plugins run sequentially. Each receives the output of the previous.
+ * Return a new MailOptions object — do not mutate the input.
+ *
+ * @example
+ * ```ts
+ * const addFooter = (options: MailOptions): MailOptions => ({
+ *   ...options,
+ *   html: options.html + '<p>Unsubscribe</p>',
+ * })
+ * ```
+ */
+export type MailPlugin = ((options: MailOptions) => MailOptions) | ((options: MailOptions) => Promise<MailOptions>);
+/** Mailgun HTTP API configuration. */
+export interface MailgunConfig {
+    /** Mailgun API key (starts with "key-") */
+    apiKey: string;
+    /** Your Mailgun sending domain (e.g. "mg.example.com") */
+    domain: string;
+    /** API region. Default: 'us' (api.mailgun.net). Use 'eu' for api.eu.mailgun.net */
+    region?: "us" | "eu";
+}
+/** AWS SES v2 HTTP API configuration. */
+export interface SESConfig {
+    /** AWS Access Key ID */
+    accessKeyId: string;
+    /** AWS Secret Access Key */
+    secretAccessKey: string;
+    /** AWS Region. Default: 'us-east-1' */
+    region?: string;
+    /** Optional session token for temporary credentials */
+    sessionToken?: string;
+    /** DKIM signing for raw MIME messages (attachment sends) */
+    dkim?: DKIMConfig;
+}
+/** Brevo (formerly Sendinblue) HTTP API configuration. */
+export interface BrevoConfig {
+    /** Brevo (formerly Sendinblue) API key */
+    apiKey: string;
+}
+/** Detected JavaScript runtime environment. */
+export type Runtime = "node" | "bun" | "deno" | "cf-workers" | "browser" | "unknown";

package/dist/detect.d.ts

@@ -0,0 +1,15 @@
+import type { CreateMailerOptions, Mailer, Runtime, SocketAdapter, TLSOptions } from "./core/types.js";
+/** Detect the current JavaScript runtime. */
+export declare function detectRuntime(): Runtime;
+/**
+ * Dynamically import and instantiate the correct adapter for the current runtime.
+ */
+export declare function createDefaultAdapter(options?: {
+    secure?: boolean;
+    connectionTimeout?: number;
+    tls?: TLSOptions;
+}): Promise<SocketAdapter>;
+/**
+ * Create a ready-to-use Mailer instance.
+ */
+export declare function createMailer(options: CreateMailerOptions): Promise<Mailer>;

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @module
+ * Main sently entrypoint — runtime detection, mailer factory, and shared types.
+ *
+ * @example
+ * ```ts
+ * import { createMailer } from "sently";
+ *
+ * const mailer = await createMailer({
+ *   host: "smtp.example.com",
+ *   auth: { user: "you@example.com", pass: "secret" },
+ * });
+ *
+ * await mailer.send({
+ *   from: "you@example.com",
+ *   to: "recipient@example.com",
+ *   subject: "Hello",
+ *   text: "Plain text body",
+ * });
+ * ```
+ */
+export { GOOGLE_TOKEN_URL, MICROSOFT_TOKEN_URL, OAuth2Client } from "./auth/oauth2.js";
+export { SMTPError } from "./core/smtp.js";
+export type { Address, AddressInput, Attachment, BrevoConfig, BulkSendOptions, BulkSendResult, CreateMailerOptions, DKIMConfig, Envelope, Mailer, MailgunConfig, MailOptions, MailPlugin, OAuth2Config, PoolConfig, PreviewConfig, RetryConfig, Runtime, SESConfig, SendResult, SMTPAuth, SMTPConfig, SocketAdapter, TLSOptions, Transport, VerifyResult, } from "./core/types.js";
+export { createMailer, detectRuntime } from "./detect.js";
+export type { TemplateEngine, TemplatePluginConfig } from "./plugins/template.js";
+export { simpleEngine, templatePlugin } from "./plugins/template.js";
+export { SMTPPool } from "./pool/pool.js";
+export { BrevoError, BrevoTransport } from "./transports/brevo.js";
+export { MailgunError, MailgunTransport } from "./transports/mailgun.js";
+export { PostmarkError, PostmarkTransport } from "./transports/postmark.js";
+export { PreviewTransport } from "./transports/preview.js";
+export { ResendError, ResendTransport } from "./transports/resend.js";
+export { RetryTransport } from "./transports/retry.js";
+export { SendGridError, SendGridTransport } from "./transports/sendgrid.js";
+export { SESError, SESTransport } from "./transports/ses.js";
+export { SMTPTransport } from "./transports/smtp.js";

package/dist/index.js

@@ -0,0 +1,29 @@
+import"./chunk-v0bahtg2.js";
+export {
+  templatePlugin,
+  simpleEngine,
+  detectRuntime,
+  createMailer,
+  SendGridTransport,
+  SendGridError,
+  SMTPTransport,
+  SMTPPool,
+  SMTPError,
+  SESTransport,
+  SESError,
+  RetryTransport,
+  ResendTransport,
+  ResendError,
+  PreviewTransport,
+  PostmarkTransport,
+  PostmarkError,
+  OAuth2Client,
+  MailgunTransport,
+  MailgunError,
+  MICROSOFT_TOKEN_URL,
+  GOOGLE_TOKEN_URL,
+  BrevoTransport,
+  BrevoError
+};
+
+//# debugId=5A145E20F9DF002A64756E2164756E21

package/dist/{src/index.js.map → index.js.map}

@@ -4,6 +4,6 @@
   "sourcesContent": [
   ],
   "mappings": "",
-  "debugId": "51809D75143CBC6864756E2164756E21",
+  "debugId": "5A145E20F9DF002A64756E2164756E21",
   "names": []
 }

package/dist/plugins/template.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @module
+ * Template plugin for sently.
+ * Renders HTML email templates using a pluggable engine.
+ * Built-in: simple {{variable}} interpolation (zero dependencies).
+ * Bring your own engine: pass any render function.
+ *
+ * @example
+ * ```ts
+ * import { templatePlugin, simpleEngine } from 'sently/plugins/template'
+ *
+ * const mailer = await createMailer({
+ *   transport: new ResendTransport({ apiKey }),
+ *   plugins: [
+ *     templatePlugin({
+ *       engine: simpleEngine,
+ *       templates: {
+ *         welcome: '<h1>Hello, {{name}}!</h1>',
+ *         reset:   '<p>Reset link: {{link}}</p>',
+ *       },
+ *     }),
+ *   ],
+ * })
+ *
+ * await mailer.send({
+ *   from: '...',
+ *   to: '...',
+ *   subject: 'Welcome!',
+ *   template: 'welcome',
+ *   data: { name: 'Ali' },
+ * })
+ * ```
+ */
+import type { MailPlugin } from "../core/types.js";
+/** Renders a template string with the given data object. */
+export type TemplateEngine = (template: string, data: Record<string, unknown>) => string;
+/** Configuration for the template plugin. */
+export interface TemplatePluginConfig {
+    /**
+     * Rendering function. Use `simpleEngine` for zero-dep {{var}} interpolation,
+     * or pass any function: (template, data) => string.
+     */
+    engine: TemplateEngine;
+    /**
+     * Map of template names to HTML strings.
+     * Templates are loaded once at plugin creation time.
+     */
+    templates: Record<string, string>;
+}
+/**
+ * Built-in zero-dependency template engine.
+ * Replaces {{variable}} with the matching value from data.
+ * Unknown variables are replaced with an empty string.
+ */
+export declare function simpleEngine(template: string, data: Record<string, unknown>): string;
+/**
+ * Create a template plugin from the given config.
+ * The plugin reads options.template and options.data, renders the HTML,
+ * sets options.html, and removes template/data before passing to the next plugin.
+ */
+export declare function templatePlugin(config: TemplatePluginConfig): MailPlugin;

package/dist/plugins/template.js

@@ -0,0 +1,29 @@
+import"../chunk-v0bahtg2.js";
+
+// src/plugins/template.ts
+function simpleEngine(template, data) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    const val = data[key];
+    return val !== undefined && val !== null ? String(val) : "";
+  });
+}
+function templatePlugin(config) {
+  return (options) => {
+    if (!options.template) {
+      return options;
+    }
+    const tmpl = config.templates[options.template];
+    if (!tmpl) {
+      throw new Error(`sently: template "${options.template}" not found`);
+    }
+    const html = config.engine(tmpl, options.data ?? {});
+    const { template: _template, data: _data, ...rest } = options;
+    return { ...rest, html };
+  };
+}
+export {
+  templatePlugin,
+  simpleEngine
+};
+
+//# debugId=BF4AF728A3AA093064756E2164756E21