@stacksjs/defaults 0.70.229 → 0.70.231

package/app/Actions/Dashboard/Email/InboxStatsAction.ts

@@ -1,11 +1,7 @@
 import { Action } from '@stacksjs/actions'
 import { emailSDK } from '@stacksjs/email'
-import { config } from '@stacksjs/config'
-
-function defaultMailbox(): string {
-  const domain = (config as any)?.email?.domain || 'stacksjs.com'
-  return `chris@${domain}`
-}
+import { response } from '@stacksjs/router'
+import { defaultMailbox } from './mail-preference'
 
 export default new Action({
   name: 'InboxStatsAction',
@@ -24,13 +20,9 @@ export default new Action({
       }
     }
     catch (err) {
-      return {
-        mailbox: request?.query?.mailbox || defaultMailbox(),
-        total: 0,
-        unread: 0,
-        read: 0,
-        error: err instanceof Error ? err.message : 'unknown error',
-      }
+      return response.json({
+        message: err instanceof Error ? err.message : 'Inbox statistics could not be loaded.',
+      }, 503)
     }
   },
 })

package/app/Actions/Dashboard/Email/captured-mail.test.ts

@@ -0,0 +1,77 @@
+import { afterEach, describe, expect, it } from 'bun:test'
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { log as logDriver } from '@stacksjs/email'
+import { listCapturedMail, showCapturedMail } from './captured-mail'
+
+const { LogEmailDriver } = logDriver
+const temporaryDirectories: string[] = []
+
+async function temporaryDirectory(): Promise<string> {
+  const directory = await mkdtemp(join(tmpdir(), 'stacks-captured-mail-'))
+  temporaryDirectories.push(directory)
+  return directory
+}
+
+afterEach(async () => {
+  LogEmailDriver.reset()
+  await Promise.all(temporaryDirectories.splice(0).map(directory =>
+    rm(directory, { recursive: true, force: true }),
+  ))
+})
+
+describe('captured dashboard mail', () => {
+  it('returns an empty list when the capture directory does not exist', async () => {
+    const root = await temporaryDirectory()
+    expect(await listCapturedMail(join(root, 'missing'))).toEqual([])
+  })
+
+  it('lists and reads a valid disk capture', async () => {
+    const directory = await temporaryDirectory()
+    const filename = '2026-07-29T12-00-00-000Z-Welcome.html'
+    const html = `<!--
+  Captured by @stacksjs/email log driver at 2026-07-29T12:00:00.000Z
+  From:    Stacks <hello@example.com>
+  To:      Chris <chris@example.com>
+  Cc:      teammate@example.com
+  Subject: Welcome
+-->
+<main><h1>Welcome</h1><p>Your account is ready.</p></main>
+`
+    await writeFile(join(directory, filename), html)
+
+    const messages = await listCapturedMail(directory)
+    expect(messages).toHaveLength(1)
+    expect(messages[0]).toMatchObject({
+      id: `disk:${filename}`,
+      source: 'disk',
+      from: 'Stacks <hello@example.com>',
+      to: 'Chris <chris@example.com>',
+      cc: 'teammate@example.com',
+      subject: 'Welcome',
+      preview: 'Welcome Your account is ready.',
+      sentAt: '2026-07-29T12:00:00.000Z',
+      hasHtml: true,
+      hasText: false,
+    })
+    expect(messages[0]?.size).toBe(Buffer.byteLength(html))
+
+    const message = await showCapturedMail(`disk:${filename}`, directory)
+    expect(message?.html).toContain('<h1>Welcome</h1>')
+    expect(message?.text).toBe('')
+  })
+
+  it('rejects malformed capture files instead of fabricating metadata', async () => {
+    const directory = await temporaryDirectory()
+    await writeFile(join(directory, 'broken.html'), '<p>No capture header</p>')
+    await expect(listCapturedMail(directory)).rejects.toThrow('missing its log-driver header')
+  })
+
+  it('rejects disk ids that could escape the capture directory', async () => {
+    const directory = await temporaryDirectory()
+    await mkdir(join(directory, 'nested'))
+    await expect(showCapturedMail('disk:../secret.html', directory))
+      .rejects.toThrow('one HTML filename')
+  })
+})

package/app/Actions/Dashboard/Email/captured-mail.ts

@@ -0,0 +1,223 @@
+import { readdir, readFile, stat } from 'node:fs/promises'
+import { basename, join } from 'node:path'
+import { log as logDriver } from '@stacksjs/email'
+import { logsPath } from '@stacksjs/path'
+
+const { LogEmailDriver } = logDriver
+
+export interface CapturedMailSummary {
+  id: string
+  source: 'memory' | 'disk'
+  from: string
+  to: string
+  cc: string
+  bcc: string
+  subject: string
+  preview: string
+  sentAt: string
+  hasHtml: boolean
+  hasText: boolean
+  size: number
+}
+
+export interface CapturedMailMessage extends CapturedMailSummary {
+  html: string
+  text: string
+}
+
+function capturedMailDirectory(): string {
+  return process.env.LOG_MAIL_DIR || logsPath('mail')
+}
+
+function formatAddress(value: unknown): string {
+  if (!value)
+    return ''
+  if (typeof value === 'string')
+    return value
+  if (Array.isArray(value))
+    return value.map(formatAddress).filter(Boolean).join(', ')
+  if (typeof value !== 'object')
+    throw new TypeError('Captured email address data must be a string or address object.')
+
+  const address = (value as { address?: unknown }).address
+  const name = (value as { name?: unknown }).name
+  if (typeof address !== 'string')
+    throw new TypeError('Captured email address objects must contain an address string.')
+  if (name !== undefined && typeof name !== 'string')
+    throw new TypeError('Captured email address names must be strings.')
+  return name ? `${name} <${address}>` : address
+}
+
+function previewFor(input: string): string {
+  return input
+    .replace(/<style[\s\S]*?<\/style>/gi, '')
+    .replace(/<script[\s\S]*?<\/script>/gi, '')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 140)
+}
+
+function validTimestamp(value: string, source: string): string {
+  const time = new Date(value).getTime()
+  if (!Number.isFinite(time))
+    throw new TypeError(`${source} contains an invalid capture timestamp.`)
+  return new Date(time).toISOString()
+}
+
+function headerValue(header: string, label: string): string {
+  const match = header.match(new RegExp(`^\\s*${label}:\\s*(.*)$`, 'im'))
+  return match?.[1]?.trim() || ''
+}
+
+async function diskMessage(name: string, directory: string): Promise<CapturedMailMessage | null> {
+  const safeName = basename(name)
+  if (safeName !== name || !safeName.endsWith('.html'))
+    throw new TypeError('Captured disk email ids must reference one HTML filename.')
+
+  const filePath = join(directory, safeName)
+  let body: string
+  let metadata
+  try {
+    [body, metadata] = await Promise.all([
+      readFile(filePath, 'utf8'),
+      stat(filePath),
+    ])
+  }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT')
+      return null
+    throw error
+  }
+
+  const headerMatch = body.match(/^<!--([\s\S]*?)-->/)
+  if (!headerMatch?.[1])
+    throw new TypeError(`Captured mail file ${safeName} is missing its log-driver header.`)
+  const header = headerMatch[1]
+  const capturedAt = header.match(/Captured by @stacksjs\/email log driver at\s+(\S+)/i)?.[1]
+  if (!capturedAt)
+    throw new TypeError(`Captured mail file ${safeName} is missing its capture timestamp.`)
+
+  const visible = body.slice(headerMatch[0].length).trim()
+  const from = headerValue(header, 'From')
+  const to = headerValue(header, 'To')
+  const subject = headerValue(header, 'Subject')
+  if (!from || !to || !subject)
+    throw new TypeError(`Captured mail file ${safeName} is missing required message headers.`)
+
+  return {
+    id: `disk:${safeName}`,
+    source: 'disk',
+    from,
+    to,
+    cc: headerValue(header, 'Cc'),
+    bcc: headerValue(header, 'Bcc'),
+    subject,
+    preview: previewFor(visible),
+    sentAt: validTimestamp(capturedAt, safeName),
+    hasHtml: /<\w[\s>]/.test(visible),
+    hasText: false,
+    size: metadata.size,
+    html: visible,
+    text: '',
+  }
+}
+
+function memoryMessages(): CapturedMailMessage[] {
+  return LogEmailDriver.captured().map((email, index) => {
+    if (!(email.sentAt instanceof Date) || !Number.isFinite(email.sentAt.getTime()))
+      throw new TypeError('Captured in-memory email contains an invalid timestamp.')
+    if (typeof email.subject !== 'string' || !email.subject.trim())
+      throw new TypeError('Captured in-memory email is missing its subject.')
+
+    const html = email.rendered?.html ?? email.html ?? ''
+    const text = email.rendered?.text ?? email.text ?? ''
+    if (typeof html !== 'string' || typeof text !== 'string')
+      throw new TypeError('Captured in-memory email bodies must be strings.')
+
+    const from = formatAddress(email.from)
+    const to = formatAddress(email.to)
+    if (!from || !to)
+      throw new TypeError('Captured in-memory email is missing its sender or recipient.')
+
+    const sentAt = email.sentAt.toISOString()
+    return {
+      id: `mem:${email.sentAt.getTime()}:${index}`,
+      source: 'memory',
+      from,
+      to,
+      cc: formatAddress(email.cc),
+      bcc: formatAddress(email.bcc),
+      subject: email.subject,
+      preview: previewFor(html || text),
+      sentAt,
+      hasHtml: Boolean(html),
+      hasText: Boolean(text),
+      size: Buffer.byteLength(html, 'utf8') + Buffer.byteLength(text, 'utf8'),
+      html,
+      text,
+    }
+  })
+}
+
+function dedupeKey(message: CapturedMailSummary): string {
+  return `${message.sentAt}|${message.from}|${message.to}|${message.subject}`
+}
+
+export async function listCapturedMail(directory = capturedMailDirectory()): Promise<CapturedMailSummary[]> {
+  let names: string[]
+  try {
+    names = await readdir(directory)
+  }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT')
+      names = []
+    else
+      throw error
+  }
+
+  const disk = await Promise.all(
+    names.filter(name => name.endsWith('.html')).map(name => diskMessage(name, directory)),
+  )
+  const seen = new Set<string>()
+  const messages: CapturedMailSummary[] = []
+  for (const message of [...disk.filter((entry): entry is CapturedMailMessage => entry !== null), ...memoryMessages()]) {
+    const key = dedupeKey(message)
+    if (seen.has(key))
+      continue
+    seen.add(key)
+    messages.push({
+      id: message.id,
+      source: message.source,
+      from: message.from,
+      to: message.to,
+      cc: message.cc,
+      bcc: message.bcc,
+      subject: message.subject,
+      preview: message.preview,
+      sentAt: message.sentAt,
+      hasHtml: message.hasHtml,
+      hasText: message.hasText,
+      size: message.size,
+    })
+  }
+
+  return messages.sort((left, right) =>
+    new Date(right.sentAt).getTime() - new Date(left.sentAt).getTime(),
+  )
+}
+
+export async function showCapturedMail(id: string, directory = capturedMailDirectory()): Promise<CapturedMailMessage | null> {
+  if (id.startsWith('disk:'))
+    return diskMessage(id.slice(5), directory)
+
+  const memoryMatch = id.match(/^mem:(\d+):(\d+)$/)
+  if (memoryMatch) {
+    const timestamp = Number(memoryMatch[1])
+    const index = Number(memoryMatch[2])
+    const message = memoryMessages()[index]
+    return message && message.id === `mem:${timestamp}:${index}` ? message : null
+  }
+
+  throw new TypeError('Captured email id must use the disk or memory format.')
+}

package/app/Actions/Dashboard/Email/mail-preference.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  defaultMailPreference,
+  defaultMailbox,
+  mailPreferenceAttributes,
+  normalizeStringList,
+  serializeMailPreference,
+} from './mail-preference'
+
+describe('dashboard mail preferences', () => {
+  test('returns the configured mailbox as a complete address', () => {
+    expect(defaultMailbox()).toMatch(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)
+  })
+
+  test('normalizes valid string lists without concealing invalid input', () => {
+    expect(normalizeStringList('[" Priority ","Priority",""]')).toBe('["Priority"]')
+    expect(() => normalizeStringList('invalid')).toThrow('must contain valid JSON')
+    expect(() => normalizeStringList('{"label":"Priority"}')).toThrow('must be a JSON array')
+    expect(() => normalizeStringList('["Priority",4]')).toThrow('may contain only strings')
+  })
+
+  test('maps transport fields to model attributes', () => {
+    const input = {
+      ...defaultMailPreference('qa@stacksjs.com'),
+      filters: '[" from:qa@example.com ","from:qa@example.com"]',
+      blockedSenders: '[]',
+    }
+
+    expect(mailPreferenceAttributes(input)).toMatchObject({
+      mailbox: 'qa@stacksjs.com',
+      account_name: 'Stacks',
+      filters: '["from:qa@example.com"]',
+      blocked_senders: '[]',
+      display_density: 'default',
+      send_and_archive: true,
+    })
+  })
+
+  test('rejects corrupted persisted preference fields', () => {
+    const values: Record<string, unknown> = {
+      id: 1,
+      mailbox: 'qa@stacksjs.com',
+      account_name: 'QA',
+      signature: null,
+      display_density: 'wide',
+      theme: 'system',
+      language: 'en',
+      default_reply_behavior: 'replyAll',
+      send_and_archive: 1,
+      auto_advance: 'newer',
+      desktop_notifications: 1,
+      notification_sound: 'default',
+      notification_preview: 1,
+      filters: '[]',
+      blocked_senders: '[]',
+      labels: '[]',
+      load_remote_images: 0,
+      show_external_content: 0,
+      vacation_enabled: 0,
+      vacation_start_date: null,
+      vacation_end_date: null,
+      vacation_subject: null,
+      vacation_message: null,
+    }
+    const record = { get: (key: string) => values[key] }
+
+    expect(() => serializeMailPreference(record)).toThrow('display_density contains an unsupported value')
+    values.display_density = 'default'
+    values.filters = 'not-json'
+    expect(() => serializeMailPreference(record)).toThrow('MailPreference.filters must contain valid JSON')
+  })
+})

package/app/Actions/Dashboard/Email/mail-preference.ts

@@ -0,0 +1,185 @@
+import { config } from '@stacksjs/config'
+
+export interface MailPreferenceInput {
+  mailbox: string
+  accountName: string
+  signature: string
+  displayDensity: 'comfortable' | 'default' | 'compact'
+  theme: 'light' | 'dark' | 'system'
+  language: 'en' | 'fr' | 'de' | 'es' | 'ja'
+  defaultReplyBehavior: 'reply' | 'replyAll'
+  sendAndArchive: boolean
+  autoAdvance: 'newer' | 'older' | 'back'
+  desktopNotifications: boolean
+  notificationSound: 'default' | 'subtle' | 'none'
+  notificationPreview: boolean
+  filters: string
+  blockedSenders: string
+  labels: string
+  loadRemoteImages: boolean
+  showExternalContent: boolean
+  vacationEnabled: boolean
+  vacationStartDate: string
+  vacationEndDate: string
+  vacationSubject: string
+  vacationMessage: string
+}
+
+export function defaultMailbox(): string {
+  const email = (config as any)?.email || {}
+  const domain = String(email.domain || 'stacksjs.com')
+  const configured = Array.isArray(email.mailboxes) ? email.mailboxes[0] : undefined
+  const mailbox = typeof configured === 'string' ? configured : configured?.email
+  if (mailbox)
+    return String(mailbox).includes('@') ? String(mailbox) : `${mailbox}@${domain}`
+
+  const fromAddress = String(email.from?.address || '').trim()
+  if (fromAddress)
+    return fromAddress
+
+  return `hello@${domain}`
+}
+
+export function normalizeStringList(value: string, field = 'list'): string {
+  if (typeof value !== 'string')
+    throw new TypeError(`${field} must be a JSON string array.`)
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(value)
+  }
+  catch (error) {
+    throw new TypeError(`${field} must contain valid JSON.`, { cause: error })
+  }
+
+  if (!Array.isArray(parsed))
+    throw new TypeError(`${field} must be a JSON array.`)
+  if (parsed.length > 100)
+    throw new RangeError(`${field} may contain at most 100 entries.`)
+  if (parsed.some(item => typeof item !== 'string'))
+    throw new TypeError(`${field} may contain only strings.`)
+
+  const entries = parsed
+    .map(item => item.trim())
+    .filter(Boolean)
+
+  return JSON.stringify([...new Set(entries)])
+}
+
+export function defaultMailPreference(mailbox = defaultMailbox()): MailPreferenceInput {
+  return {
+    mailbox,
+    accountName: 'Stacks',
+    signature: '',
+    displayDensity: 'default',
+    theme: 'system',
+    language: 'en',
+    defaultReplyBehavior: 'replyAll',
+    sendAndArchive: true,
+    autoAdvance: 'newer',
+    desktopNotifications: true,
+    notificationSound: 'default',
+    notificationPreview: true,
+    filters: '[]',
+    blockedSenders: '[]',
+    labels: '[]',
+    loadRemoteImages: false,
+    showExternalContent: false,
+    vacationEnabled: false,
+    vacationStartDate: '',
+    vacationEndDate: '',
+    vacationSubject: '',
+    vacationMessage: '',
+  }
+}
+
+export function mailPreferenceAttributes(input: MailPreferenceInput): Record<string, unknown> {
+  return {
+    mailbox: input.mailbox,
+    account_name: input.accountName,
+    signature: input.signature,
+    display_density: input.displayDensity,
+    theme: input.theme,
+    language: input.language,
+    default_reply_behavior: input.defaultReplyBehavior,
+    send_and_archive: input.sendAndArchive,
+    auto_advance: input.autoAdvance,
+    desktop_notifications: input.desktopNotifications,
+    notification_sound: input.notificationSound,
+    notification_preview: input.notificationPreview,
+    filters: normalizeStringList(input.filters, 'filters'),
+    blocked_senders: normalizeStringList(input.blockedSenders, 'blockedSenders'),
+    labels: normalizeStringList(input.labels, 'labels'),
+    load_remote_images: input.loadRemoteImages,
+    show_external_content: input.showExternalContent,
+    vacation_enabled: input.vacationEnabled,
+    vacation_start_date: input.vacationStartDate || null,
+    vacation_end_date: input.vacationEndDate || null,
+    vacation_subject: input.vacationSubject || null,
+    vacation_message: input.vacationMessage || null,
+  }
+}
+
+export function serializeMailPreference(record: any, mailbox = defaultMailbox()): MailPreferenceInput & { id: number | null } {
+  const defaults = defaultMailPreference(mailbox)
+  if (!record)
+    return { id: null, ...defaults }
+
+  const requiredString = (key: string): string => {
+    const value = record.get(key)
+    if (typeof value !== 'string')
+      throw new TypeError(`MailPreference.${key} must be a string.`)
+    return value
+  }
+  const optionalString = (key: string): string => {
+    const value = record.get(key)
+    if (value === null || value === undefined)
+      return ''
+    if (typeof value !== 'string')
+      throw new TypeError(`MailPreference.${key} must be a string or null.`)
+    return value
+  }
+  const enumValue = <T extends string>(key: string, allowed: readonly T[]): T => {
+    const value = requiredString(key)
+    if (!allowed.includes(value as T))
+      throw new TypeError(`MailPreference.${key} contains an unsupported value.`)
+    return value as T
+  }
+  const booleanValue = (key: string): boolean => {
+    const value = record.get(key)
+    if (value === true || value === 1 || value === '1' || value === 'true')
+      return true
+    if (value === false || value === 0 || value === '0' || value === 'false')
+      return false
+    throw new TypeError(`MailPreference.${key} must be a boolean.`)
+  }
+  const id = Number(record.get('id'))
+  if (!Number.isInteger(id) || id < 1)
+    throw new TypeError('MailPreference.id must be a positive integer.')
+
+  return {
+    id,
+    mailbox: requiredString('mailbox'),
+    accountName: requiredString('account_name'),
+    signature: optionalString('signature'),
+    displayDensity: enumValue('display_density', ['comfortable', 'default', 'compact']),
+    theme: enumValue('theme', ['light', 'dark', 'system']),
+    language: enumValue('language', ['en', 'fr', 'de', 'es', 'ja']),
+    defaultReplyBehavior: enumValue('default_reply_behavior', ['reply', 'replyAll']),
+    sendAndArchive: booleanValue('send_and_archive'),
+    autoAdvance: enumValue('auto_advance', ['newer', 'older', 'back']),
+    desktopNotifications: booleanValue('desktop_notifications'),
+    notificationSound: enumValue('notification_sound', ['default', 'subtle', 'none']),
+    notificationPreview: booleanValue('notification_preview'),
+    filters: normalizeStringList(requiredString('filters'), 'MailPreference.filters'),
+    blockedSenders: normalizeStringList(requiredString('blocked_senders'), 'MailPreference.blocked_senders'),
+    labels: normalizeStringList(requiredString('labels'), 'MailPreference.labels'),
+    loadRemoteImages: booleanValue('load_remote_images'),
+    showExternalContent: booleanValue('show_external_content'),
+    vacationEnabled: booleanValue('vacation_enabled'),
+    vacationStartDate: optionalString('vacation_start_date'),
+    vacationEndDate: optionalString('vacation_end_date'),
+    vacationSubject: optionalString('vacation_subject'),
+    vacationMessage: optionalString('vacation_message'),
+  }
+}

package/app/Actions/Dashboard/Email/sanitize-inbox-html.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'bun:test'
+import { sanitizeInboxHtml } from './sanitize-inbox-html'
+
+describe('sanitizeInboxHtml', () => {
+  it('preserves safe email formatting and secures links', () => {
+    const html = '<div><strong>Hello</strong><a href="https://example.com">Open</a></div>'
+    const result = sanitizeInboxHtml(html)
+
+    expect(result).toContain('<strong>Hello</strong>')
+    expect(result).toContain('href="https://example.com"')
+    expect(result).toContain('target="_blank"')
+    expect(result).toContain('rel="noopener noreferrer"')
+  })
+
+  it('removes executable markup, handlers, remote images, and unsafe URLs', () => {
+    const html = [
+      '<script>alert("script")</script>',
+      '<style>body { display: none }</style>',
+      '<img src="https://tracker.example/pixel">',
+      '<p onclick="alert(1)">Message</p>',
+      '<a href="javascript:alert(1)">Unsafe</a>',
+    ].join('')
+    const result = sanitizeInboxHtml(html)
+
+    expect(result).not.toContain('<script')
+    expect(result).not.toContain('<style')
+    expect(result).not.toContain('<img')
+    expect(result).not.toContain('onclick')
+    expect(result).not.toContain('javascript:')
+    expect(result).toContain('<p>Message</p>')
+  })
+})

package/app/Actions/Dashboard/Email/sanitize-inbox-html.ts

@@ -0,0 +1,70 @@
+import type { SanitizerOptions } from '@stacksjs/sanitizer'
+import { sanitize } from '@stacksjs/sanitizer'
+
+const inboxHtmlOptions: SanitizerOptions = {
+  allowedTags: [
+    'p',
+    'br',
+    'strong',
+    'b',
+    'em',
+    'i',
+    'u',
+    's',
+    'strike',
+    'span',
+    'div',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'ul',
+    'ol',
+    'li',
+    'a',
+    'code',
+    'pre',
+    'blockquote',
+    'table',
+    'thead',
+    'tbody',
+    'tfoot',
+    'tr',
+    'th',
+    'td',
+    'caption',
+    'hr',
+    'sub',
+    'sup',
+    'small',
+  ],
+  allowedAttributes: {
+    a: ['href', 'title', 'target', 'rel'],
+    td: ['colspan', 'rowspan'],
+    th: ['colspan', 'rowspan', 'scope'],
+  },
+  allowedSchemes: ['http', 'https', 'mailto'],
+  allowDataAttributes: false,
+  allowAriaAttributes: false,
+  allowComments: false,
+  stripTags: true,
+  transformTag(tagName, attributes) {
+    if (tagName !== 'a')
+      return { tagName, attributes }
+
+    return {
+      tagName,
+      attributes: {
+        ...attributes,
+        target: '_blank',
+        rel: 'noopener noreferrer',
+      },
+    }
+  },
+}
+
+export function sanitizeInboxHtml(html: string): string {
+  return sanitize(html, inboxHtmlOptions)
+}