@pyreon/document 0.11.4 → 0.11.6

package/src/tests/document.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, it } from "vitest"
+import { afterEach, describe, expect, it } from 'vitest'
 import {
   _resetRenderers,
   Button,
@@ -24,7 +24,7 @@ import {
   Table,
   Text,
   unregisterRenderer,
-} from "../index"
+} from '../index'
 
 afterEach(() => {
   _resetRenderers()
@@ -32,844 +32,844 @@ afterEach(() => {
 
 // ─── Node Construction ──────────────────────────────────────────────────────
 
-describe("node construction", () => {
-  it("Document creates a document node", () => {
-    const doc = Document({ title: "Test", children: "hello" })
-    expect(doc.type).toBe("document")
-    expect(doc.props.title).toBe("Test")
-    expect(doc.children).toEqual(["hello"])
+describe('node construction', () => {
+  it('Document creates a document node', () => {
+    const doc = Document({ title: 'Test', children: 'hello' })
+    expect(doc.type).toBe('document')
+    expect(doc.props.title).toBe('Test')
+    expect(doc.children).toEqual(['hello'])
   })
 
-  it("Page creates a page node", () => {
-    const page = Page({ size: "A4", margin: 40, children: "content" })
-    expect(page.type).toBe("page")
-    expect(page.props.size).toBe("A4")
+  it('Page creates a page node', () => {
+    const page = Page({ size: 'A4', margin: 40, children: 'content' })
+    expect(page.type).toBe('page')
+    expect(page.props.size).toBe('A4')
     expect(page.props.margin).toBe(40)
   })
 
-  it("Section with direction", () => {
-    const section = Section({ direction: "row", gap: 20, children: "a" })
-    expect(section.type).toBe("section")
-    expect(section.props.direction).toBe("row")
+  it('Section with direction', () => {
+    const section = Section({ direction: 'row', gap: 20, children: 'a' })
+    expect(section.type).toBe('section')
+    expect(section.props.direction).toBe('row')
     expect(section.props.gap).toBe(20)
   })
 
-  it("Row and Column", () => {
+  it('Row and Column', () => {
     const row = Row({
       gap: 10,
-      children: [Column({ width: "50%", children: "left" })],
+      children: [Column({ width: '50%', children: 'left' })],
     })
-    expect(row.type).toBe("row")
+    expect(row.type).toBe('row')
     expect(row.children).toHaveLength(1)
     const col = row.children[0]!
-    expect(typeof col).not.toBe("string")
-    if (typeof col !== "string") {
-      expect(col.type).toBe("column")
-      expect(col.props.width).toBe("50%")
+    expect(typeof col).not.toBe('string')
+    if (typeof col !== 'string') {
+      expect(col.type).toBe('column')
+      expect(col.props.width).toBe('50%')
     }
   })
 
-  it("Heading defaults to level 1", () => {
-    const h = Heading({ children: "Title" })
-    expect(h.type).toBe("heading")
+  it('Heading defaults to level 1', () => {
+    const h = Heading({ children: 'Title' })
+    expect(h.type).toBe('heading')
     expect(h.props.level).toBe(1)
   })
 
-  it("Heading with custom level", () => {
-    const h = Heading({ level: 3, children: "Subtitle" })
+  it('Heading with custom level', () => {
+    const h = Heading({ level: 3, children: 'Subtitle' })
     expect(h.props.level).toBe(3)
   })
 
-  it("Text with formatting", () => {
+  it('Text with formatting', () => {
     const t = Text({
       bold: true,
       italic: true,
       size: 14,
-      color: "#333",
-      children: "hello",
+      color: '#333',
+      children: 'hello',
     })
-    expect(t.type).toBe("text")
+    expect(t.type).toBe('text')
     expect(t.props.bold).toBe(true)
     expect(t.props.italic).toBe(true)
     expect(t.props.size).toBe(14)
   })
 
-  it("Link", () => {
-    const l = Link({ href: "https://example.com", children: "click" })
-    expect(l.type).toBe("link")
-    expect(l.props.href).toBe("https://example.com")
+  it('Link', () => {
+    const l = Link({ href: 'https://example.com', children: 'click' })
+    expect(l.type).toBe('link')
+    expect(l.props.href).toBe('https://example.com')
   })
 
-  it("Image with all props", () => {
+  it('Image with all props', () => {
     const img = Image({
-      src: "/logo.png",
+      src: '/logo.png',
       width: 100,
       height: 50,
-      alt: "Logo",
-      caption: "Company logo",
+      alt: 'Logo',
+      caption: 'Company logo',
     })
-    expect(img.type).toBe("image")
-    expect(img.props.src).toBe("/logo.png")
+    expect(img.type).toBe('image')
+    expect(img.props.src).toBe('/logo.png')
     expect(img.props.width).toBe(100)
-    expect(img.props.caption).toBe("Company logo")
+    expect(img.props.caption).toBe('Company logo')
     expect(img.children).toEqual([])
   })
 
-  it("Table with columns and rows", () => {
+  it('Table with columns and rows', () => {
     const t = Table({
-      columns: ["Name", { header: "Price", align: "right" }],
-      rows: [["Widget", "$10"]],
+      columns: ['Name', { header: 'Price', align: 'right' }],
+      rows: [['Widget', '$10']],
       striped: true,
     })
-    expect(t.type).toBe("table")
+    expect(t.type).toBe('table')
     expect(t.props.columns).toHaveLength(2)
     expect(t.props.rows).toHaveLength(1)
     expect(t.props.striped).toBe(true)
   })
 
-  it("List with items", () => {
+  it('List with items', () => {
     const l = List({
       ordered: true,
-      children: [ListItem({ children: "one" }), ListItem({ children: "two" })],
+      children: [ListItem({ children: 'one' }), ListItem({ children: 'two' })],
     })
-    expect(l.type).toBe("list")
+    expect(l.type).toBe('list')
     expect(l.props.ordered).toBe(true)
     expect(l.children).toHaveLength(2)
   })
 
-  it("Code", () => {
-    const c = Code({ language: "typescript", children: "const x = 1" })
-    expect(c.type).toBe("code")
-    expect(c.props.language).toBe("typescript")
+  it('Code', () => {
+    const c = Code({ language: 'typescript', children: 'const x = 1' })
+    expect(c.type).toBe('code')
+    expect(c.props.language).toBe('typescript')
   })
 
-  it("Divider", () => {
-    const d = Divider({ color: "#ccc", thickness: 2 })
-    expect(d.type).toBe("divider")
-    expect(d.props.color).toBe("#ccc")
+  it('Divider', () => {
+    const d = Divider({ color: '#ccc', thickness: 2 })
+    expect(d.type).toBe('divider')
+    expect(d.props.color).toBe('#ccc')
   })
 
-  it("Divider with defaults", () => {
+  it('Divider with defaults', () => {
     const d = Divider()
-    expect(d.type).toBe("divider")
+    expect(d.type).toBe('divider')
   })
 
-  it("Spacer", () => {
+  it('Spacer', () => {
     const s = Spacer({ height: 30 })
-    expect(s.type).toBe("spacer")
+    expect(s.type).toBe('spacer')
     expect(s.props.height).toBe(30)
   })
 
-  it("Button", () => {
-    const b = Button({ href: "/pay", background: "#4f46e5", children: "Pay" })
-    expect(b.type).toBe("button")
-    expect(b.props.href).toBe("/pay")
-    expect(b.props.background).toBe("#4f46e5")
+  it('Button', () => {
+    const b = Button({ href: '/pay', background: '#4f46e5', children: 'Pay' })
+    expect(b.type).toBe('button')
+    expect(b.props.href).toBe('/pay')
+    expect(b.props.background).toBe('#4f46e5')
   })
 
-  it("Quote", () => {
-    const q = Quote({ borderColor: "#blue", children: "wise words" })
-    expect(q.type).toBe("quote")
-    expect(q.props.borderColor).toBe("#blue")
+  it('Quote', () => {
+    const q = Quote({ borderColor: '#blue', children: 'wise words' })
+    expect(q.type).toBe('quote')
+    expect(q.props.borderColor).toBe('#blue')
   })
 
-  it("isDocNode returns true for nodes", () => {
-    expect(isDocNode(Heading({ children: "hi" }))).toBe(true)
+  it('isDocNode returns true for nodes', () => {
+    expect(isDocNode(Heading({ children: 'hi' }))).toBe(true)
   })
 
-  it("isDocNode returns false for non-nodes", () => {
-    expect(isDocNode("string")).toBe(false)
+  it('isDocNode returns false for non-nodes', () => {
+    expect(isDocNode('string')).toBe(false)
     expect(isDocNode(null)).toBe(false)
     expect(isDocNode(42)).toBe(false)
     expect(isDocNode({})).toBe(false)
   })
 
-  it("normalizes nested children", () => {
+  it('normalizes nested children', () => {
     const doc = Document({
-      children: [Heading({ children: "A" }), [Text({ children: "B" }), Text({ children: "C" })]],
+      children: [Heading({ children: 'A' }), [Text({ children: 'B' }), Text({ children: 'C' })]],
     })
     expect(doc.children).toHaveLength(3)
   })
 
-  it("handles null/undefined/false children", () => {
-    const doc = Document({ children: [null, undefined, false, "text"] })
-    expect(doc.children).toEqual(["text"])
+  it('handles null/undefined/false children', () => {
+    const doc = Document({ children: [null, undefined, false, 'text'] })
+    expect(doc.children).toEqual(['text'])
   })
 
-  it("converts numbers to strings in children", () => {
+  it('converts numbers to strings in children', () => {
     const t = Text({ children: 42 as unknown as string })
-    expect(t.children).toEqual(["42"])
+    expect(t.children).toEqual(['42'])
   })
 })
 
 // ─── HTML Renderer ──────────────────────────────────────────────────────────
 
-describe("HTML renderer", () => {
-  it("renders a simple document", async () => {
+describe('HTML renderer', () => {
+  it('renders a simple document', async () => {
     const doc = Document({
-      title: "Test",
-      children: Page({ children: Heading({ children: "Hello" }) }),
+      title: 'Test',
+      children: Page({ children: Heading({ children: 'Hello' }) }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("<!DOCTYPE html>")
-    expect(html).toContain("<title>Test</title>")
-    expect(html).toContain("<h1")
-    expect(html).toContain("Hello")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('<!DOCTYPE html>')
+    expect(html).toContain('<title>Test</title>')
+    expect(html).toContain('<h1')
+    expect(html).toContain('Hello')
   })
 
-  it("renders text with formatting", async () => {
+  it('renders text with formatting', async () => {
     const doc = Document({
       children: Text({
         bold: true,
-        color: "#f00",
+        color: '#f00',
         size: 20,
-        align: "center",
-        children: "Bold Red",
+        align: 'center',
+        children: 'Bold Red',
       }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("font-weight:bold")
-    expect(html).toContain("color:#f00")
-    expect(html).toContain("font-size:20px")
-    expect(html).toContain("text-align:center")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('font-weight:bold')
+    expect(html).toContain('color:#f00')
+    expect(html).toContain('font-size:20px')
+    expect(html).toContain('text-align:center')
   })
 
-  it("renders a table", async () => {
+  it('renders a table', async () => {
     const doc = Document({
       children: Table({
-        columns: ["Name", { header: "Price", align: "right" }],
+        columns: ['Name', { header: 'Price', align: 'right' }],
         rows: [
-          ["Widget", "$10"],
-          ["Gadget", "$20"],
+          ['Widget', '$10'],
+          ['Gadget', '$20'],
         ],
         striped: true,
-        headerStyle: { background: "#000", color: "#fff" },
+        headerStyle: { background: '#000', color: '#fff' },
       }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("<table")
-    expect(html).toContain("Widget")
-    expect(html).toContain("$10")
-    expect(html).toContain("background:#000")
-    expect(html).toContain("color:#fff")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('<table')
+    expect(html).toContain('Widget')
+    expect(html).toContain('$10')
+    expect(html).toContain('background:#000')
+    expect(html).toContain('color:#fff')
   })
 
-  it("renders an image with caption", async () => {
+  it('renders an image with caption', async () => {
     const doc = Document({
       children: Image({
-        src: "/img.png",
+        src: '/img.png',
         width: 200,
-        alt: "Photo",
-        caption: "A photo",
+        alt: 'Photo',
+        caption: 'A photo',
       }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("<img")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('<img')
     expect(html).toContain('src="/img.png"')
-    expect(html).toContain("<figcaption>")
-    expect(html).toContain("A photo")
+    expect(html).toContain('<figcaption>')
+    expect(html).toContain('A photo')
   })
 
-  it("renders a link", async () => {
+  it('renders a link', async () => {
     const doc = Document({
-      children: Link({ href: "https://example.com", children: "Click me" }),
+      children: Link({ href: 'https://example.com', children: 'Click me' }),
     })
-    const html = (await render(doc, "html")) as string
+    const html = (await render(doc, 'html')) as string
     expect(html).toContain('href="https://example.com"')
-    expect(html).toContain("Click me")
+    expect(html).toContain('Click me')
   })
 
-  it("renders a list", async () => {
+  it('renders a list', async () => {
     const doc = Document({
       children: List({
         ordered: true,
-        children: [ListItem({ children: "one" }), ListItem({ children: "two" })],
+        children: [ListItem({ children: 'one' }), ListItem({ children: 'two' })],
       }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("<ol>")
-    expect(html).toContain("<li>one</li>")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('<ol>')
+    expect(html).toContain('<li>one</li>')
   })
 
-  it("renders code blocks", async () => {
-    const doc = Document({ children: Code({ children: "const x = 1" }) })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("<pre")
-    expect(html).toContain("<code>")
-    expect(html).toContain("const x = 1")
+  it('renders code blocks', async () => {
+    const doc = Document({ children: Code({ children: 'const x = 1' }) })
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('<pre')
+    expect(html).toContain('<code>')
+    expect(html).toContain('const x = 1')
   })
 
-  it("renders divider", async () => {
-    const doc = Document({ children: Divider({ color: "#ccc", thickness: 2 }) })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("<hr")
-    expect(html).toContain("2px solid #ccc")
+  it('renders divider', async () => {
+    const doc = Document({ children: Divider({ color: '#ccc', thickness: 2 }) })
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('<hr')
+    expect(html).toContain('2px solid #ccc')
   })
 
-  it("renders spacer", async () => {
+  it('renders spacer', async () => {
     const doc = Document({ children: Spacer({ height: 30 }) })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("height:30px")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('height:30px')
   })
 
-  it("renders button", async () => {
+  it('renders button', async () => {
     const doc = Document({
       children: Button({
-        href: "/pay",
-        background: "#4f46e5",
-        color: "#fff",
-        children: "Pay",
+        href: '/pay',
+        background: '#4f46e5',
+        color: '#fff',
+        children: 'Pay',
       }),
     })
-    const html = (await render(doc, "html")) as string
+    const html = (await render(doc, 'html')) as string
     expect(html).toContain('href="/pay"')
-    expect(html).toContain("background:#4f46e5")
-    expect(html).toContain("Pay")
+    expect(html).toContain('background:#4f46e5')
+    expect(html).toContain('Pay')
   })
 
-  it("renders blockquote", async () => {
-    const doc = Document({ children: Quote({ children: "A wise quote" }) })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("<blockquote")
-    expect(html).toContain("A wise quote")
+  it('renders blockquote', async () => {
+    const doc = Document({ children: Quote({ children: 'A wise quote' }) })
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('<blockquote')
+    expect(html).toContain('A wise quote')
   })
 
-  it("renders section with row direction", async () => {
+  it('renders section with row direction', async () => {
     const doc = Document({
       children: Section({
-        direction: "row",
+        direction: 'row',
         gap: 20,
-        background: "#f5f5f5",
-        children: [Text({ children: "A" }), Text({ children: "B" })],
+        background: '#f5f5f5',
+        children: [Text({ children: 'A' }), Text({ children: 'B' })],
       }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("display:flex")
-    expect(html).toContain("flex-direction:row")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('display:flex')
+    expect(html).toContain('flex-direction:row')
   })
 
-  it("renders image with center alignment", async () => {
+  it('renders image with center alignment', async () => {
     const doc = Document({
-      children: Image({ src: "/img.png", align: "center" }),
+      children: Image({ src: '/img.png', align: 'center' }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("margin:0 auto")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('margin:0 auto')
   })
 
-  it("renders table with bordered option", async () => {
+  it('renders table with bordered option', async () => {
     const doc = Document({
-      children: Table({ columns: ["A"], rows: [["1"]], bordered: true }),
+      children: Table({ columns: ['A'], rows: [['1']], bordered: true }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("border:1px solid #ddd")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('border:1px solid #ddd')
   })
 
-  it("renders table with caption", async () => {
+  it('renders table with caption', async () => {
     const doc = Document({
-      children: Table({ columns: ["A"], rows: [["1"]], caption: "My Table" }),
+      children: Table({ columns: ['A'], rows: [['1']], caption: 'My Table' }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("<caption>My Table</caption>")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('<caption>My Table</caption>')
   })
 
-  it("escapes HTML in text", async () => {
+  it('escapes HTML in text', async () => {
     const doc = Document({
-      children: Text({ children: "<script>alert(1)</script>" }),
+      children: Text({ children: '<script>alert(1)</script>' }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).not.toContain("<script>")
-    expect(html).toContain("&lt;script&gt;")
+    const html = (await render(doc, 'html')) as string
+    expect(html).not.toContain('<script>')
+    expect(html).toContain('&lt;script&gt;')
   })
 
-  it("renders text with underline and strikethrough", async () => {
+  it('renders text with underline and strikethrough', async () => {
     const ul = Document({
-      children: Text({ underline: true, children: "underlined" }),
+      children: Text({ underline: true, children: 'underlined' }),
     })
     const st = Document({
-      children: Text({ strikethrough: true, children: "struck" }),
+      children: Text({ strikethrough: true, children: 'struck' }),
     })
-    expect((await render(ul, "html")) as string).toContain("text-decoration:underline")
-    expect((await render(st, "html")) as string).toContain("text-decoration:line-through")
+    expect((await render(ul, 'html')) as string).toContain('text-decoration:underline')
+    expect((await render(st, 'html')) as string).toContain('text-decoration:line-through')
   })
 
-  it("renders image with right alignment", async () => {
-    const doc = Document({ children: Image({ src: "/x.png", align: "right" }) })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("margin-left:auto")
+  it('renders image with right alignment', async () => {
+    const doc = Document({ children: Image({ src: '/x.png', align: 'right' }) })
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('margin-left:auto')
   })
 })
 
 // ─── Email Renderer ─────────────────────────────────────────────────────────
 
-describe("email renderer", () => {
-  it("renders email-safe HTML", async () => {
+describe('email renderer', () => {
+  it('renders email-safe HTML', async () => {
     const doc = Document({
-      title: "Welcome",
-      children: [Heading({ children: "Hello!" }), Text({ children: "Welcome to our service." })],
+      title: 'Welcome',
+      children: [Heading({ children: 'Hello!' }), Text({ children: 'Welcome to our service.' })],
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("<!DOCTYPE html>")
-    expect(html).toContain("max-width:600px")
-    expect(html).toContain("Hello!")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('<!DOCTYPE html>')
+    expect(html).toContain('max-width:600px')
+    expect(html).toContain('Hello!')
     // Should have Outlook conditional comments
-    expect(html).toContain("<!--[if mso]>")
+    expect(html).toContain('<!--[if mso]>')
   })
 
-  it("renders bulletproof buttons", async () => {
+  it('renders bulletproof buttons', async () => {
     const doc = Document({
       children: Button({
-        href: "/pay",
-        background: "#4f46e5",
-        children: "Pay Now",
+        href: '/pay',
+        background: '#4f46e5',
+        children: 'Pay Now',
       }),
     })
-    const html = (await render(doc, "email")) as string
+    const html = (await render(doc, 'email')) as string
     // VML for Outlook
-    expect(html).toContain("v:roundrect")
+    expect(html).toContain('v:roundrect')
     // CSS for others
-    expect(html).toContain("background-color:#4f46e5")
-    expect(html).toContain("Pay Now")
+    expect(html).toContain('background-color:#4f46e5')
+    expect(html).toContain('Pay Now')
   })
 
-  it("renders table with inline styles", async () => {
+  it('renders table with inline styles', async () => {
     const doc = Document({
       children: Table({
-        columns: ["Name", "Price"],
-        rows: [["Widget", "$10"]],
-        headerStyle: { background: "#000", color: "#fff" },
+        columns: ['Name', 'Price'],
+        rows: [['Widget', '$10']],
+        headerStyle: { background: '#000', color: '#fff' },
       }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("background-color:#000")
-    expect(html).toContain("color:#fff")
-    expect(html).toContain("Widget")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('background-color:#000')
+    expect(html).toContain('color:#fff')
+    expect(html).toContain('Widget')
   })
 
-  it("renders section with row direction using tables", async () => {
+  it('renders section with row direction using tables', async () => {
     const doc = Document({
       children: Section({
-        direction: "row",
-        children: [Text({ children: "Left" }), Text({ children: "Right" })],
+        direction: 'row',
+        children: [Text({ children: 'Left' }), Text({ children: 'Right' })],
       }),
     })
-    const html = (await render(doc, "email")) as string
+    const html = (await render(doc, 'email')) as string
     // Should use table layout, not flexbox
-    expect(html).not.toContain("display:flex")
-    expect(html).toContain("<table")
-    expect(html).toContain("Left")
-    expect(html).toContain("Right")
+    expect(html).not.toContain('display:flex')
+    expect(html).toContain('<table')
+    expect(html).toContain('Left')
+    expect(html).toContain('Right')
   })
 
-  it("renders divider using table", async () => {
+  it('renders divider using table', async () => {
     const doc = Document({ children: Divider() })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("border-top:1px solid")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('border-top:1px solid')
   })
 
-  it("renders quote using table with border-left", async () => {
-    const doc = Document({ children: Quote({ children: "A quote" }) })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("border-left:4px solid")
+  it('renders quote using table with border-left', async () => {
+    const doc = Document({ children: Quote({ children: 'A quote' }) })
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('border-left:4px solid')
   })
 })
 
 // ─── Markdown Renderer ──────────────────────────────────────────────────────
 
-describe("markdown renderer", () => {
-  it("renders headings with # prefix", async () => {
+describe('markdown renderer', () => {
+  it('renders headings with # prefix', async () => {
     const doc = Document({
       children: [
-        Heading({ level: 1, children: "Title" }),
-        Heading({ level: 3, children: "Subtitle" }),
+        Heading({ level: 1, children: 'Title' }),
+        Heading({ level: 3, children: 'Subtitle' }),
       ],
     })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("# Title")
-    expect(md).toContain("### Subtitle")
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('# Title')
+    expect(md).toContain('### Subtitle')
   })
 
-  it("renders bold and italic text", async () => {
+  it('renders bold and italic text', async () => {
     const doc = Document({
       children: [
-        Text({ bold: true, children: "bold" }),
-        Text({ italic: true, children: "italic" }),
-        Text({ strikethrough: true, children: "struck" }),
+        Text({ bold: true, children: 'bold' }),
+        Text({ italic: true, children: 'italic' }),
+        Text({ strikethrough: true, children: 'struck' }),
       ],
     })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("**bold**")
-    expect(md).toContain("*italic*")
-    expect(md).toContain("~~struck~~")
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('**bold**')
+    expect(md).toContain('*italic*')
+    expect(md).toContain('~~struck~~')
   })
 
-  it("renders tables as pipe tables", async () => {
+  it('renders tables as pipe tables', async () => {
     const doc = Document({
       children: Table({
-        columns: ["Name", { header: "Price", align: "right" }],
-        rows: [["Widget", "$10"]],
+        columns: ['Name', { header: 'Price', align: 'right' }],
+        rows: [['Widget', '$10']],
       }),
     })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("| Name | Price |")
-    expect(md).toContain("| --- | ---: |")
-    expect(md).toContain("| Widget | $10 |")
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('| Name | Price |')
+    expect(md).toContain('| --- | ---: |')
+    expect(md).toContain('| Widget | $10 |')
   })
 
-  it("renders links in markdown format", async () => {
+  it('renders links in markdown format', async () => {
     const doc = Document({
-      children: Link({ href: "https://example.com", children: "click" }),
+      children: Link({ href: 'https://example.com', children: 'click' }),
     })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("[click](https://example.com)")
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('[click](https://example.com)')
   })
 
-  it("renders images", async () => {
+  it('renders images', async () => {
     const doc = Document({
-      children: Image({ src: "/img.png", alt: "Photo", caption: "A photo" }),
+      children: Image({ src: '/img.png', alt: 'Photo', caption: 'A photo' }),
     })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("![Photo](/img.png)")
-    expect(md).toContain("*A photo*")
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('![Photo](/img.png)')
+    expect(md).toContain('*A photo*')
   })
 
-  it("renders code blocks with language", async () => {
+  it('renders code blocks with language', async () => {
     const doc = Document({
-      children: Code({ language: "typescript", children: "const x = 1" }),
+      children: Code({ language: 'typescript', children: 'const x = 1' }),
     })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("```typescript")
-    expect(md).toContain("const x = 1")
-    expect(md).toContain("```")
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('```typescript')
+    expect(md).toContain('const x = 1')
+    expect(md).toContain('```')
   })
 
-  it("renders ordered and unordered lists", async () => {
+  it('renders ordered and unordered lists', async () => {
     const ol = Document({
       children: List({
         ordered: true,
-        children: [ListItem({ children: "first" }), ListItem({ children: "second" })],
+        children: [ListItem({ children: 'first' }), ListItem({ children: 'second' })],
       }),
     })
     const ul = Document({
       children: List({
-        children: [ListItem({ children: "a" }), ListItem({ children: "b" })],
+        children: [ListItem({ children: 'a' }), ListItem({ children: 'b' })],
       }),
     })
-    const orderedMd = (await render(ol, "md")) as string
-    const unorderedMd = (await render(ul, "md")) as string
-    expect(orderedMd).toContain("1. first")
-    expect(orderedMd).toContain("2. second")
-    expect(unorderedMd).toContain("- a")
-    expect(unorderedMd).toContain("- b")
+    const orderedMd = (await render(ol, 'md')) as string
+    const unorderedMd = (await render(ul, 'md')) as string
+    expect(orderedMd).toContain('1. first')
+    expect(orderedMd).toContain('2. second')
+    expect(unorderedMd).toContain('- a')
+    expect(unorderedMd).toContain('- b')
   })
 
-  it("renders divider as ---", async () => {
+  it('renders divider as ---', async () => {
     const doc = Document({ children: Divider() })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("---")
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('---')
   })
 
-  it("renders button as link", async () => {
+  it('renders button as link', async () => {
     const doc = Document({
-      children: Button({ href: "/pay", children: "Pay" }),
+      children: Button({ href: '/pay', children: 'Pay' }),
     })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("[Pay](/pay)")
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('[Pay](/pay)')
   })
 
-  it("renders quote with >", async () => {
-    const doc = Document({ children: Quote({ children: "wise" }) })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("> wise")
+  it('renders quote with >', async () => {
+    const doc = Document({ children: Quote({ children: 'wise' }) })
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('> wise')
   })
 
-  it("renders table with caption", async () => {
+  it('renders table with caption', async () => {
     const doc = Document({
-      children: Table({ columns: ["A"], rows: [["1"]], caption: "My Table" }),
+      children: Table({ columns: ['A'], rows: [['1']], caption: 'My Table' }),
     })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("*My Table*")
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('*My Table*')
   })
 })
 
 // ─── Text Renderer ──────────────────────────────────────────────────────────
 
-describe("text renderer", () => {
-  it("renders headings with underlines", async () => {
+describe('text renderer', () => {
+  it('renders headings with underlines', async () => {
     const doc = Document({
-      children: [Heading({ level: 1, children: "Title" }), Heading({ level: 2, children: "Sub" })],
+      children: [Heading({ level: 1, children: 'Title' }), Heading({ level: 2, children: 'Sub' })],
     })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("TITLE")
-    expect(text).toContain("=====")
-    expect(text).toContain("Sub")
-    expect(text).toContain("---")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('TITLE')
+    expect(text).toContain('=====')
+    expect(text).toContain('Sub')
+    expect(text).toContain('---')
   })
 
-  it("renders aligned table columns", async () => {
+  it('renders aligned table columns', async () => {
     const doc = Document({
       children: Table({
         columns: [
-          { header: "Name", align: "left" },
-          { header: "Price", align: "right" },
+          { header: 'Name', align: 'left' },
+          { header: 'Price', align: 'right' },
         ],
-        rows: [["Widget", "$10"]],
+        rows: [['Widget', '$10']],
       }),
     })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("Name")
-    expect(text).toContain("Price")
-    expect(text).toContain("Widget")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('Name')
+    expect(text).toContain('Price')
+    expect(text).toContain('Widget')
   })
 
-  it("renders button as link reference", async () => {
+  it('renders button as link reference', async () => {
     const doc = Document({
-      children: Button({ href: "/pay", children: "Pay" }),
+      children: Button({ href: '/pay', children: 'Pay' }),
     })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("[Pay]")
-    expect(text).toContain("/pay")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('[Pay]')
+    expect(text).toContain('/pay')
   })
 
-  it("renders image as placeholder", async () => {
+  it('renders image as placeholder', async () => {
     const doc = Document({
-      children: Image({ src: "/x.png", alt: "Photo", caption: "Nice" }),
+      children: Image({ src: '/x.png', alt: 'Photo', caption: 'Nice' }),
     })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("[Photo — Nice]")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('[Photo — Nice]')
   })
 })
 
 // ─── CSV Renderer ───────────────────────────────────────────────────────────
 
-describe("CSV renderer", () => {
-  it("extracts tables as CSV", async () => {
+describe('CSV renderer', () => {
+  it('extracts tables as CSV', async () => {
     const doc = Document({
       children: Table({
-        columns: ["Name", "Price"],
+        columns: ['Name', 'Price'],
         rows: [
-          ["Widget", "$10"],
-          ["Gadget", "$20"],
+          ['Widget', '$10'],
+          ['Gadget', '$20'],
         ],
       }),
     })
-    const csv = (await render(doc, "csv")) as string
-    expect(csv).toContain("Name,Price")
-    expect(csv).toContain("Widget,$10")
-    expect(csv).toContain("Gadget,$20")
+    const csv = (await render(doc, 'csv')) as string
+    expect(csv).toContain('Name,Price')
+    expect(csv).toContain('Widget,$10')
+    expect(csv).toContain('Gadget,$20')
   })
 
-  it("escapes commas and quotes", async () => {
+  it('escapes commas and quotes', async () => {
     const doc = Document({
       children: Table({
-        columns: ["Name"],
-        rows: [["Widget, Inc."], ['He said "hello"']],
+        columns: ['Name'],
+        rows: [['Widget, Inc.'], ['He said "hello"']],
       }),
     })
-    const csv = (await render(doc, "csv")) as string
+    const csv = (await render(doc, 'csv')) as string
     expect(csv).toContain('"Widget, Inc."')
     expect(csv).toContain('"He said ""hello"""')
   })
 
-  it("returns message when no tables", async () => {
-    const doc = Document({ children: Text({ children: "no tables here" }) })
-    const csv = (await render(doc, "csv")) as string
-    expect(csv).toContain("No tables found")
+  it('returns message when no tables', async () => {
+    const doc = Document({ children: Text({ children: 'no tables here' }) })
+    const csv = (await render(doc, 'csv')) as string
+    expect(csv).toContain('No tables found')
   })
 
-  it("handles multiple tables", async () => {
+  it('handles multiple tables', async () => {
     const doc = Document({
       children: [
-        Table({ columns: ["A"], rows: [["1"]] }),
-        Table({ columns: ["B"], rows: [["2"]] }),
+        Table({ columns: ['A'], rows: [['1']] }),
+        Table({ columns: ['B'], rows: [['2']] }),
       ],
     })
-    const csv = (await render(doc, "csv")) as string
-    expect(csv).toContain("A")
-    expect(csv).toContain("B")
+    const csv = (await render(doc, 'csv')) as string
+    expect(csv).toContain('A')
+    expect(csv).toContain('B')
   })
 
-  it("adds caption as comment", async () => {
+  it('adds caption as comment', async () => {
     const doc = Document({
-      children: Table({ columns: ["A"], rows: [["1"]], caption: "My Data" }),
+      children: Table({ columns: ['A'], rows: [['1']], caption: 'My Data' }),
     })
-    const csv = (await render(doc, "csv")) as string
-    expect(csv).toContain("# My Data")
+    const csv = (await render(doc, 'csv')) as string
+    expect(csv).toContain('# My Data')
   })
 })
 
 // ─── Builder Pattern ────────────────────────────────────────────────────────
 
-describe("createDocument builder", () => {
-  it("builds a document with heading and text", async () => {
-    const doc = createDocument({ title: "Test" }).heading("Title").text("Hello world")
+describe('createDocument builder', () => {
+  it('builds a document with heading and text', async () => {
+    const doc = createDocument({ title: 'Test' }).heading('Title').text('Hello world')
 
     const node = doc.build()
-    expect(node.type).toBe("document")
-    expect(node.props.title).toBe("Test")
+    expect(node.type).toBe('document')
+    expect(node.props.title).toBe('Test')
   })
 
-  it("renders to HTML", async () => {
+  it('renders to HTML', async () => {
     const doc = createDocument()
-      .heading("Report")
-      .text("Summary text")
+      .heading('Report')
+      .text('Summary text')
       .table({
-        columns: ["Name", "Value"],
-        rows: [["A", "1"]],
+        columns: ['Name', 'Value'],
+        rows: [['A', '1']],
       })
 
     const html = await doc.toHtml()
-    expect(html).toContain("Report")
-    expect(html).toContain("Summary text")
-    expect(html).toContain("<table")
+    expect(html).toContain('Report')
+    expect(html).toContain('Summary text')
+    expect(html).toContain('<table')
   })
 
-  it("renders to markdown", async () => {
+  it('renders to markdown', async () => {
     const doc = createDocument()
-      .heading("Title")
-      .text("Body", { bold: true })
-      .list(["item 1", "item 2"])
+      .heading('Title')
+      .text('Body', { bold: true })
+      .list(['item 1', 'item 2'])
 
     const md = await doc.toMarkdown()
-    expect(md).toContain("# Title")
-    expect(md).toContain("**Body**")
-    expect(md).toContain("- item 1")
+    expect(md).toContain('# Title')
+    expect(md).toContain('**Body**')
+    expect(md).toContain('- item 1')
   })
 
-  it("renders to text", async () => {
-    const doc = createDocument().heading("Title").text("Body")
+  it('renders to text', async () => {
+    const doc = createDocument().heading('Title').text('Body')
 
     const text = await doc.toText()
-    expect(text).toContain("TITLE")
-    expect(text).toContain("Body")
+    expect(text).toContain('TITLE')
+    expect(text).toContain('Body')
   })
 
-  it("renders to CSV", async () => {
-    const doc = createDocument().table({ columns: ["X"], rows: [["1"], ["2"]] })
+  it('renders to CSV', async () => {
+    const doc = createDocument().table({ columns: ['X'], rows: [['1'], ['2']] })
 
     const csv = await doc.toCsv()
-    expect(csv).toContain("X")
-    expect(csv).toContain("1")
+    expect(csv).toContain('X')
+    expect(csv).toContain('1')
   })
 
-  it("supports all builder methods", () => {
+  it('supports all builder methods', () => {
     const doc = createDocument()
-      .heading("H")
-      .text("T")
-      .paragraph("P")
-      .image("/img.png")
-      .table({ columns: ["A"], rows: [["1"]] })
-      .list(["a", "b"])
-      .code("x = 1", { language: "python" })
+      .heading('H')
+      .text('T')
+      .paragraph('P')
+      .image('/img.png')
+      .table({ columns: ['A'], rows: [['1']] })
+      .list(['a', 'b'])
+      .code('x = 1', { language: 'python' })
       .divider()
       .spacer(20)
-      .quote("Q")
-      .button("Click", { href: "/go" })
-      .link("Link", { href: "/link" })
+      .quote('Q')
+      .button('Click', { href: '/go' })
+      .link('Link', { href: '/link' })
 
     const node = doc.build()
-    expect(node.type).toBe("document")
+    expect(node.type).toBe('document')
   })
 
-  it("chart without instance shows placeholder", async () => {
+  it('chart without instance shows placeholder', async () => {
     const doc = createDocument().chart(null)
 
     const html = await doc.toHtml()
-    expect(html).toContain("[Chart]")
+    expect(html).toContain('[Chart]')
   })
 
-  it("flow without instance shows placeholder", async () => {
+  it('flow without instance shows placeholder', async () => {
     const doc = createDocument().flow(null)
 
     const html = await doc.toHtml()
-    expect(html).toContain("[Flow Diagram]")
+    expect(html).toContain('[Flow Diagram]')
   })
 
-  it("chart with getDataURL captures image", async () => {
+  it('chart with getDataURL captures image', async () => {
     const mockChart = {
-      getDataURL: () => "data:image/png;base64,abc123",
+      getDataURL: () => 'data:image/png;base64,abc123',
     }
     const doc = createDocument().chart(mockChart, { width: 400 })
     const html = await doc.toHtml()
-    expect(html).toContain("data:image/png;base64,abc123")
+    expect(html).toContain('data:image/png;base64,abc123')
   })
 
-  it("flow with toSVG captures image", async () => {
+  it('flow with toSVG captures image', async () => {
     const mockFlow = {
-      toSVG: () => "<svg><rect/></svg>",
+      toSVG: () => '<svg><rect/></svg>',
     }
     const doc = createDocument().flow(mockFlow, { width: 500 })
     const html = await doc.toHtml()
-    expect(html).toContain("data:image/svg+xml")
+    expect(html).toContain('data:image/svg+xml')
   })
 })
 
 // ─── Custom Renderers ───────────────────────────────────────────────────────
 
-describe("custom renderers", () => {
-  it("registerRenderer adds a custom format", async () => {
-    registerRenderer("custom", {
+describe('custom renderers', () => {
+  it('registerRenderer adds a custom format', async () => {
+    registerRenderer('custom', {
       async render(node) {
         return `CUSTOM:${node.type}`
       },
     })
 
-    const doc = Document({ children: "hello" })
-    const result = await render(doc, "custom")
-    expect(result).toBe("CUSTOM:document")
+    const doc = Document({ children: 'hello' })
+    const result = await render(doc, 'custom')
+    expect(result).toBe('CUSTOM:document')
   })
 
-  it("unregisterRenderer removes a format", () => {
-    registerRenderer("temp", {
+  it('unregisterRenderer removes a format', () => {
+    registerRenderer('temp', {
       async render() {
-        return "x"
+        return 'x'
       },
     })
-    unregisterRenderer("temp")
-    expect(render(Document({ children: "x" }), "temp")).rejects.toThrow("No renderer registered")
+    unregisterRenderer('temp')
+    expect(render(Document({ children: 'x' }), 'temp')).rejects.toThrow('No renderer registered')
   })
 
-  it("throws for unknown format", () => {
-    expect(render(Document({ children: "x" }), "unknown")).rejects.toThrow("No renderer registered")
+  it('throws for unknown format', () => {
+    expect(render(Document({ children: 'x' }), 'unknown')).rejects.toThrow('No renderer registered')
   })
 
-  it("lazy renderer is cached after first use", async () => {
+  it('lazy renderer is cached after first use', async () => {
     let loadCount = 0
-    registerRenderer("lazy", async () => {
+    registerRenderer('lazy', async () => {
       loadCount++
       return {
         async render() {
-          return "lazy-result"
+          return 'lazy-result'
         },
       }
     })
 
-    await render(Document({ children: "x" }), "lazy")
-    await render(Document({ children: "x" }), "lazy")
+    await render(Document({ children: 'x' }), 'lazy')
+    await render(Document({ children: 'x' }), 'lazy')
     expect(loadCount).toBe(1)
   })
 })
 
 // ─── Real-World Document ────────────────────────────────────────────────────
 
-describe("real-world document", () => {
+describe('real-world document', () => {
   function createInvoice() {
     return Document({
-      title: "Invoice #1234",
-      author: "Acme Corp",
+      title: 'Invoice #1234',
+      author: 'Acme Corp',
       children: Page({
-        size: "A4",
+        size: 'A4',
         margin: 40,
         children: [
           Row({
             gap: 20,
             children: [
               Column({
-                children: Image({ src: "/logo.png", width: 80, alt: "Logo" }),
+                children: Image({ src: '/logo.png', width: 80, alt: 'Logo' }),
               }),
               Column({
                 children: [
-                  Heading({ children: "Invoice #1234" }),
-                  Text({ color: "#666", children: "March 23, 2026" }),
+                  Heading({ children: 'Invoice #1234' }),
+                  Text({ color: '#666', children: 'March 23, 2026' }),
                 ],
               }),
             ],
@@ -877,544 +877,544 @@ describe("real-world document", () => {
           Spacer({ height: 30 }),
           Table({
             columns: [
-              { header: "Item", width: "50%" },
-              { header: "Qty", width: "15%", align: "center" },
-              { header: "Price", width: "15%", align: "right" },
-              { header: "Total", width: "20%", align: "right" },
+              { header: 'Item', width: '50%' },
+              { header: 'Qty', width: '15%', align: 'center' },
+              { header: 'Price', width: '15%', align: 'right' },
+              { header: 'Total', width: '20%', align: 'right' },
             ],
             rows: [
-              ["Widget Pro", "2", "$50", "$100"],
-              ["Gadget Plus", "1", "$75", "$75"],
-              ["Service Fee", "1", "$25", "$25"],
+              ['Widget Pro', '2', '$50', '$100'],
+              ['Gadget Plus', '1', '$75', '$75'],
+              ['Service Fee', '1', '$25', '$25'],
             ],
             striped: true,
-            headerStyle: { background: "#1a1a2e", color: "#fff" },
+            headerStyle: { background: '#1a1a2e', color: '#fff' },
           }),
           Spacer({ height: 20 }),
           Text({
             bold: true,
-            align: "right",
+            align: 'right',
             size: 18,
-            children: "Total: $200",
+            children: 'Total: $200',
           }),
           Divider(),
           Text({
-            color: "#999",
+            color: '#999',
             size: 12,
-            children: "Thank you for your business!",
+            children: 'Thank you for your business!',
           }),
           Button({
-            href: "https://acme.com/pay/1234",
-            background: "#4f46e5",
-            align: "center",
-            children: "Pay Now",
+            href: 'https://acme.com/pay/1234',
+            background: '#4f46e5',
+            align: 'center',
+            children: 'Pay Now',
           }),
         ],
       }),
     })
   }
 
-  it("renders as HTML", async () => {
-    const html = (await render(createInvoice(), "html")) as string
-    expect(html).toContain("Invoice #1234")
-    expect(html).toContain("Widget Pro")
-    expect(html).toContain("Total: $200")
-    expect(html).toContain("Pay Now")
+  it('renders as HTML', async () => {
+    const html = (await render(createInvoice(), 'html')) as string
+    expect(html).toContain('Invoice #1234')
+    expect(html).toContain('Widget Pro')
+    expect(html).toContain('Total: $200')
+    expect(html).toContain('Pay Now')
   })
 
-  it("renders as email", async () => {
-    const html = (await render(createInvoice(), "email")) as string
-    expect(html).toContain("Invoice #1234")
-    expect(html).toContain("max-width:600px")
-    expect(html).toContain("v:roundrect") // Outlook button
+  it('renders as email', async () => {
+    const html = (await render(createInvoice(), 'email')) as string
+    expect(html).toContain('Invoice #1234')
+    expect(html).toContain('max-width:600px')
+    expect(html).toContain('v:roundrect') // Outlook button
   })
 
-  it("renders as markdown", async () => {
-    const md = (await render(createInvoice(), "md")) as string
-    expect(md).toContain("# Invoice #1234")
-    expect(md).toContain("| Widget Pro")
-    expect(md).toContain("**Total: $200**")
+  it('renders as markdown', async () => {
+    const md = (await render(createInvoice(), 'md')) as string
+    expect(md).toContain('# Invoice #1234')
+    expect(md).toContain('| Widget Pro')
+    expect(md).toContain('**Total: $200**')
   })
 
-  it("renders as text", async () => {
-    const text = (await render(createInvoice(), "text")) as string
-    expect(text).toContain("INVOICE #1234")
-    expect(text).toContain("Widget Pro")
-    expect(text).toContain("Total: $200")
+  it('renders as text', async () => {
+    const text = (await render(createInvoice(), 'text')) as string
+    expect(text).toContain('INVOICE #1234')
+    expect(text).toContain('Widget Pro')
+    expect(text).toContain('Total: $200')
   })
 
-  it("renders as CSV", async () => {
-    const csv = (await render(createInvoice(), "csv")) as string
-    expect(csv).toContain("Item,Qty,Price,Total")
-    expect(csv).toContain("Widget Pro,2,$50,$100")
+  it('renders as CSV', async () => {
+    const csv = (await render(createInvoice(), 'csv')) as string
+    expect(csv).toContain('Item,Qty,Price,Total')
+    expect(csv).toContain('Widget Pro,2,$50,$100')
   })
 })
 
 // ─── Text Renderer — additional coverage ────────────────────────────────────
 
-describe("text renderer — additional", () => {
-  it("renders link with URL", async () => {
+describe('text renderer — additional', () => {
+  it('renders link with URL', async () => {
     const doc = Document({
-      children: Link({ href: "https://x.com", children: "Link" }),
+      children: Link({ href: 'https://x.com', children: 'Link' }),
     })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("Link (https://x.com)")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('Link (https://x.com)')
   })
 
-  it("renders table with caption", async () => {
+  it('renders table with caption', async () => {
     const doc = Document({
-      children: Table({ columns: ["A"], rows: [["1"]], caption: "Data" }),
+      children: Table({ columns: ['A'], rows: [['1']], caption: 'Data' }),
     })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("Data")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('Data')
   })
 
-  it("renders ordered list", async () => {
+  it('renders ordered list', async () => {
     const doc = Document({
       children: List({
         ordered: true,
-        children: [ListItem({ children: "one" }), ListItem({ children: "two" })],
+        children: [ListItem({ children: 'one' }), ListItem({ children: 'two' })],
       }),
     })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("1. one")
-    expect(text).toContain("2. two")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('1. one')
+    expect(text).toContain('2. two')
   })
 
-  it("renders unordered list", async () => {
+  it('renders unordered list', async () => {
     const doc = Document({
       children: List({
-        children: [ListItem({ children: "a" }), ListItem({ children: "b" })],
+        children: [ListItem({ children: 'a' }), ListItem({ children: 'b' })],
       }),
     })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("* a")
-    expect(text).toContain("* b")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('* a')
+    expect(text).toContain('* b')
   })
 
-  it("renders code block", async () => {
-    const doc = Document({ children: Code({ children: "x = 1" }) })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("x = 1")
+  it('renders code block', async () => {
+    const doc = Document({ children: Code({ children: 'x = 1' }) })
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('x = 1')
   })
 
-  it("renders divider", async () => {
+  it('renders divider', async () => {
     const doc = Document({ children: Divider() })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("─")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('─')
   })
 
-  it("renders spacer as newline", async () => {
+  it('renders spacer as newline', async () => {
     const doc = Document({
-      children: [Text({ children: "A" }), Spacer({ height: 20 }), Text({ children: "B" })],
+      children: [Text({ children: 'A' }), Spacer({ height: 20 }), Text({ children: 'B' })],
     })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("A")
-    expect(text).toContain("B")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('A')
+    expect(text).toContain('B')
   })
 
-  it("renders quote with indentation", async () => {
-    const doc = Document({ children: Quote({ children: "wise" }) })
-    const text = (await render(doc, "text")) as string
+  it('renders quote with indentation', async () => {
+    const doc = Document({ children: Quote({ children: 'wise' }) })
+    const text = (await render(doc, 'text')) as string
     expect(text).toContain('"wise"')
   })
 
-  it("renders section/row/column", async () => {
+  it('renders section/row/column', async () => {
     const doc = Document({
       children: Section({
         children: Row({
-          children: Column({ children: Text({ children: "nested" }) }),
+          children: Column({ children: Text({ children: 'nested' }) }),
         }),
       }),
     })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("nested")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('nested')
   })
 
-  it("renders heading level 3+", async () => {
-    const doc = Document({ children: Heading({ level: 4, children: "Sub" }) })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("Sub")
+  it('renders heading level 3+', async () => {
+    const doc = Document({ children: Heading({ level: 4, children: 'Sub' }) })
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('Sub')
     // Level 3+ should not have underline
-    expect(text).not.toContain("===")
-    expect(text).not.toContain("---")
+    expect(text).not.toContain('===')
+    expect(text).not.toContain('---')
   })
 
-  it("renders table with center aligned column", async () => {
+  it('renders table with center aligned column', async () => {
     const doc = Document({
       children: Table({
-        columns: [{ header: "Name", align: "center" }],
-        rows: [["X"]],
+        columns: [{ header: 'Name', align: 'center' }],
+        rows: [['X']],
       }),
     })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("Name")
-    expect(text).toContain("X")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('Name')
+    expect(text).toContain('X')
   })
 })
 
 // ─── Builder — additional coverage ───────────────────────────────────────────
 
-describe("builder — additional", () => {
-  it("pageBreak wraps content", () => {
-    const doc = createDocument().heading("Page 1").pageBreak().heading("Page 2")
+describe('builder — additional', () => {
+  it('pageBreak wraps content', () => {
+    const doc = createDocument().heading('Page 1').pageBreak().heading('Page 2')
     const node = doc.build()
-    expect(node.type).toBe("document")
+    expect(node.type).toBe('document')
   })
 
-  it("toEmail renders", async () => {
-    const html = await createDocument().heading("Hi").toEmail()
-    expect(html).toContain("Hi")
-    expect(html).toContain("max-width:600px")
+  it('toEmail renders', async () => {
+    const html = await createDocument().heading('Hi').toEmail()
+    expect(html).toContain('Hi')
+    expect(html).toContain('max-width:600px')
   })
 
-  it("toCsv renders", async () => {
+  it('toCsv renders', async () => {
     const csv = await createDocument()
-      .table({ columns: ["X"], rows: [["1"]] })
+      .table({ columns: ['X'], rows: [['1']] })
       .toCsv()
-    expect(csv).toContain("X")
+    expect(csv).toContain('X')
   })
 
-  it("toText renders", async () => {
-    const text = await createDocument().heading("Hi").toText()
-    expect(text).toContain("HI")
+  it('toText renders', async () => {
+    const text = await createDocument().heading('Hi').toText()
+    expect(text).toContain('HI')
   })
 })
 
 // ─── Markdown — additional branch coverage ──────────────────────────────────
 
-describe("markdown — additional branches", () => {
-  it("renders table with center aligned column", async () => {
+describe('markdown — additional branches', () => {
+  it('renders table with center aligned column', async () => {
     const doc = Document({
       children: Table({
-        columns: [{ header: "X", align: "center" }],
-        rows: [["1"]],
+        columns: [{ header: 'X', align: 'center' }],
+        rows: [['1']],
       }),
     })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain(":---:")
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain(':---:')
   })
 
-  it("renders table with left aligned column (default)", async () => {
+  it('renders table with left aligned column (default)', async () => {
     const doc = Document({
       children: Table({
-        columns: [{ header: "X", align: "left" }],
-        rows: [["1"]],
+        columns: [{ header: 'X', align: 'left' }],
+        rows: [['1']],
       }),
     })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("| --- |")
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('| --- |')
   })
 
-  it("renders empty table gracefully", async () => {
+  it('renders empty table gracefully', async () => {
     const doc = Document({
       children: Table({ columns: [], rows: [] }),
     })
-    const md = (await render(doc, "md")) as string
+    const md = (await render(doc, 'md')) as string
     expect(md).toBeDefined()
   })
 
-  it("renders image without caption", async () => {
-    const doc = Document({ children: Image({ src: "/x.png", alt: "X" }) })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("![X](/x.png)")
-    expect(md).not.toContain("*")
+  it('renders image without caption', async () => {
+    const doc = Document({ children: Image({ src: '/x.png', alt: 'X' }) })
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('![X](/x.png)')
+    expect(md).not.toContain('*')
   })
 
-  it("renders image without alt", async () => {
-    const doc = Document({ children: Image({ src: "/x.png" }) })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("![](/x.png)")
+  it('renders image without alt', async () => {
+    const doc = Document({ children: Image({ src: '/x.png' }) })
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('![](/x.png)')
   })
 
-  it("renders code without language", async () => {
-    const doc = Document({ children: Code({ children: "x = 1" }) })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("```\nx = 1\n```")
+  it('renders code without language', async () => {
+    const doc = Document({ children: Code({ children: 'x = 1' }) })
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('```\nx = 1\n```')
   })
 
-  it("renders spacer as newline", async () => {
+  it('renders spacer as newline', async () => {
     const doc = Document({ children: Spacer({ height: 20 }) })
-    const md = (await render(doc, "md")) as string
+    const md = (await render(doc, 'md')) as string
     expect(md).toBeDefined()
   })
 })
 
 // ─── Email — additional branch coverage ─────────────────────────────────────
 
-describe("email — additional branches", () => {
-  it("renders section with background and padding", async () => {
+describe('email — additional branches', () => {
+  it('renders section with background and padding', async () => {
     const doc = Document({
       children: Section({
-        background: "#f00",
+        background: '#f00',
         padding: [10, 20],
         borderRadius: 8,
-        children: Text({ children: "hi" }),
+        children: Text({ children: 'hi' }),
       }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("background-color:#f00")
-    expect(html).toContain("border-radius:8px")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('background-color:#f00')
+    expect(html).toContain('border-radius:8px')
   })
 
-  it("renders image with right alignment", async () => {
-    const doc = Document({ children: Image({ src: "/x.png", align: "right" }) })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("text-align:right")
+  it('renders image with right alignment', async () => {
+    const doc = Document({ children: Image({ src: '/x.png', align: 'right' }) })
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('text-align:right')
   })
 
-  it("renders striped table", async () => {
+  it('renders striped table', async () => {
     const doc = Document({
       children: Table({
-        columns: ["A"],
-        rows: [["1"], ["2"], ["3"]],
+        columns: ['A'],
+        rows: [['1'], ['2'], ['3']],
         striped: true,
       }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("background-color:#f9f9f9")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('background-color:#f9f9f9')
   })
 
-  it("renders heading level 2", async () => {
-    const doc = Document({ children: Heading({ level: 2, children: "Sub" }) })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("<h2")
-    expect(html).toContain("font-size:24px")
+  it('renders heading level 2', async () => {
+    const doc = Document({ children: Heading({ level: 2, children: 'Sub' }) })
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('<h2')
+    expect(html).toContain('font-size:24px')
   })
 
-  it("renders text with all formatting options", async () => {
+  it('renders text with all formatting options', async () => {
     const doc = Document({
       children: Text({
         size: 16,
         bold: true,
         italic: true,
         underline: true,
-        align: "center",
+        align: 'center',
         lineHeight: 2,
-        children: "styled",
+        children: 'styled',
       }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("font-size:16px")
-    expect(html).toContain("font-weight:bold")
-    expect(html).toContain("font-style:italic")
-    expect(html).toContain("text-decoration:underline")
-    expect(html).toContain("text-align:center")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('font-size:16px')
+    expect(html).toContain('font-weight:bold')
+    expect(html).toContain('font-style:italic')
+    expect(html).toContain('text-decoration:underline')
+    expect(html).toContain('text-align:center')
   })
 
-  it("renders text with strikethrough", async () => {
+  it('renders text with strikethrough', async () => {
     const doc = Document({
-      children: Text({ strikethrough: true, children: "old" }),
+      children: Text({ strikethrough: true, children: 'old' }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("text-decoration:line-through")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('text-decoration:line-through')
   })
 
-  it("renders button with custom alignment", async () => {
+  it('renders button with custom alignment', async () => {
     const doc = Document({
-      children: Button({ href: "/x", align: "center", children: "Go" }),
+      children: Button({ href: '/x', align: 'center', children: 'Go' }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("text-align:center")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('text-align:center')
   })
 
-  it("renders section column direction (default)", async () => {
+  it('renders section column direction (default)', async () => {
     const doc = Document({
-      children: Section({ children: Text({ children: "content" }) }),
+      children: Section({ children: Text({ children: 'content' }) }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("content")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('content')
   })
 
-  it("renders section with gap in row", async () => {
+  it('renders section with gap in row', async () => {
     const doc = Document({
       children: Section({
-        direction: "row",
+        direction: 'row',
         gap: 16,
-        children: [Text({ children: "a" }), Text({ children: "b" })],
+        children: [Text({ children: 'a' }), Text({ children: 'b' })],
       }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("padding:0 8px")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('padding:0 8px')
   })
 })
 
 // ─── HTML — additional branch coverage ──────────────────────────────────────
 
-describe("html — additional branches", () => {
-  it("renders section column direction (default)", async () => {
+describe('html — additional branches', () => {
+  it('renders section column direction (default)', async () => {
     const doc = Document({
-      children: Section({ children: Text({ children: "x" }) }),
+      children: Section({ children: Text({ children: 'x' }) }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).not.toContain("display:flex")
+    const html = (await render(doc, 'html')) as string
+    expect(html).not.toContain('display:flex')
   })
 
-  it("renders page with margin as array", async () => {
+  it('renders page with margin as array', async () => {
     const doc = Document({
-      children: Page({ margin: [10, 20], children: Text({ children: "hi" }) }),
+      children: Page({ margin: [10, 20], children: Text({ children: 'hi' }) }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("10px 20px")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('10px 20px')
   })
 
-  it("renders page with 4-value margin", async () => {
+  it('renders page with 4-value margin', async () => {
     const doc = Document({
       children: Page({
         margin: [10, 20, 30, 40],
-        children: Text({ children: "hi" }),
+        children: Text({ children: 'hi' }),
       }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("10px 20px 30px 40px")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('10px 20px 30px 40px')
   })
 
-  it("renders text with lineHeight", async () => {
+  it('renders text with lineHeight', async () => {
     const doc = Document({
-      children: Text({ lineHeight: 1.8, children: "text" }),
+      children: Text({ lineHeight: 1.8, children: 'text' }),
     })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("line-height:1.8")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('line-height:1.8')
   })
 })
 
 // ─── CSV — additional branch coverage ───────────────────────────────────────
 
-describe("csv — additional branches", () => {
-  it("finds tables nested in pages", async () => {
+describe('csv — additional branches', () => {
+  it('finds tables nested in pages', async () => {
     const doc = Document({
       children: Page({
         children: Section({
-          children: Table({ columns: ["Nested"], rows: [["val"]] }),
+          children: Table({ columns: ['Nested'], rows: [['val']] }),
         }),
       }),
     })
-    const csv = (await render(doc, "csv")) as string
-    expect(csv).toContain("Nested")
-    expect(csv).toContain("val")
+    const csv = (await render(doc, 'csv')) as string
+    expect(csv).toContain('Nested')
+    expect(csv).toContain('val')
   })
 })
 
 // ─── Render Dispatcher — additional coverage ────────────────────────────────
 
-describe("render dispatcher — additional", () => {
-  it("error message includes available formats", async () => {
+describe('render dispatcher — additional', () => {
+  it('error message includes available formats', async () => {
     try {
-      await render(Document({ children: "x" }), "nonexistent")
+      await render(Document({ children: 'x' }), 'nonexistent')
     } catch (e) {
-      expect((e as Error).message).toContain("No renderer registered")
-      expect((e as Error).message).toContain("Available:")
-      expect((e as Error).message).toContain("html")
+      expect((e as Error).message).toContain('No renderer registered')
+      expect((e as Error).message).toContain('Available:')
+      expect((e as Error).message).toContain('html')
     }
   })
 })
 
 // ─── Email Renderer — additional coverage ───────────────────────────────────
 
-describe("email renderer — additional", () => {
-  it("renders image with caption", async () => {
+describe('email renderer — additional', () => {
+  it('renders image with caption', async () => {
     const doc = Document({
-      children: Image({ src: "/x.png", alt: "Photo", caption: "Nice" }),
+      children: Image({ src: '/x.png', alt: 'Photo', caption: 'Nice' }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("Nice")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('Nice')
   })
 
-  it("renders image with center alignment", async () => {
+  it('renders image with center alignment', async () => {
     const doc = Document({
-      children: Image({ src: "/x.png", align: "center" }),
+      children: Image({ src: '/x.png', align: 'center' }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("text-align:center")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('text-align:center')
   })
 
-  it("renders code block", async () => {
-    const doc = Document({ children: Code({ children: "const x = 1" }) })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("Courier New")
-    expect(html).toContain("const x = 1")
+  it('renders code block', async () => {
+    const doc = Document({ children: Code({ children: 'const x = 1' }) })
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('Courier New')
+    expect(html).toContain('const x = 1')
   })
 
-  it("renders spacer with line-height trick", async () => {
+  it('renders spacer with line-height trick', async () => {
     const doc = Document({ children: Spacer({ height: 20 }) })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("height:20px")
-    expect(html).toContain("line-height:20px")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('height:20px')
+    expect(html).toContain('line-height:20px')
   })
 
-  it("renders list", async () => {
+  it('renders list', async () => {
     const doc = Document({
       children: List({
-        children: [ListItem({ children: "one" }), ListItem({ children: "two" })],
+        children: [ListItem({ children: 'one' }), ListItem({ children: 'two' })],
       }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("<ul")
-    expect(html).toContain("<li")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('<ul')
+    expect(html).toContain('<li')
   })
 
-  it("renders table caption", async () => {
+  it('renders table caption', async () => {
     const doc = Document({
-      children: Table({ columns: ["A"], rows: [["1"]], caption: "Data" }),
+      children: Table({ columns: ['A'], rows: [['1']], caption: 'Data' }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("Data")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('Data')
   })
 
-  it("renders link with target _blank", async () => {
+  it('renders link with target _blank', async () => {
     const doc = Document({
-      children: Link({ href: "https://x.com", children: "X" }),
+      children: Link({ href: 'https://x.com', children: 'X' }),
     })
-    const html = (await render(doc, "email")) as string
+    const html = (await render(doc, 'email')) as string
     expect(html).toContain('target="_blank"')
   })
 
-  it("renders row layout using tables", async () => {
+  it('renders row layout using tables', async () => {
     const doc = Document({
       children: Row({
         gap: 10,
-        children: [Text({ children: "L" }), Text({ children: "R" })],
+        children: [Text({ children: 'L' }), Text({ children: 'R' })],
       }),
     })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("<table")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('<table')
     expect(html).toContain('valign="top"')
   })
 })
 
 // ─── DOCX Renderer (integration) ────────────────────────────────────────────
 
-describe("DOCX renderer", () => {
-  it("renders a document with heading, text, table, list, code, divider to a valid Uint8Array", async () => {
+describe('DOCX renderer', () => {
+  it('renders a document with heading, text, table, list, code, divider to a valid Uint8Array', async () => {
     const doc = Document({
-      title: "DOCX Test",
-      author: "Test Suite",
+      title: 'DOCX Test',
+      author: 'Test Suite',
       children: Page({
-        size: "A4",
+        size: 'A4',
         margin: 40,
         children: [
-          Heading({ children: "DOCX Integration Test" }),
-          Text({ children: "A test paragraph.", bold: true }),
+          Heading({ children: 'DOCX Integration Test' }),
+          Text({ children: 'A test paragraph.', bold: true }),
           Table({
-            columns: ["Name", "Value"],
+            columns: ['Name', 'Value'],
             rows: [
-              ["Alpha", "100"],
-              ["Beta", "200"],
+              ['Alpha', '100'],
+              ['Beta', '200'],
             ],
             striped: true,
-            headerStyle: { background: "#333333", color: "#ffffff" },
+            headerStyle: { background: '#333333', color: '#ffffff' },
           }),
           List({
             ordered: true,
-            children: [ListItem({ children: "First" }), ListItem({ children: "Second" })],
+            children: [ListItem({ children: 'First' }), ListItem({ children: 'Second' })],
           }),
-          Code({ children: "const x = 42" }),
+          Code({ children: 'const x = 42' }),
           Divider(),
         ],
       }),
     })
 
-    const result = await render(doc, "docx")
+    const result = await render(doc, 'docx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
     // DOCX files are ZIP archives — first two bytes are PK (0x50, 0x4B)
@@ -1422,76 +1422,76 @@ describe("DOCX renderer", () => {
     expect((result as Uint8Array)[1]).toBe(0x4b)
   }, 15000)
 
-  it("embeds base64 images via ImageRun", async () => {
+  it('embeds base64 images via ImageRun', async () => {
     // 1x1 red pixel PNG as base64
     const redPixel =
-      "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=="
+      'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=='
 
     const doc = Document({
       children: Page({
-        children: [Image({ src: redPixel, width: 50, height: 50, caption: "Red pixel" })],
+        children: [Image({ src: redPixel, width: 50, height: 50, caption: 'Red pixel' })],
       }),
     })
 
-    const result = await render(doc, "docx")
+    const result = await render(doc, 'docx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
 
-  it("renders external URL images as placeholders", async () => {
+  it('renders external URL images as placeholders', async () => {
     const doc = Document({
       children: Image({
-        src: "https://example.com/logo.png",
-        alt: "Logo",
-        caption: "Company",
+        src: 'https://example.com/logo.png',
+        alt: 'Logo',
+        caption: 'Company',
       }),
     })
 
-    const result = await render(doc, "docx")
+    const result = await render(doc, 'docx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
 
-  it("renders page with header and footer", async () => {
+  it('renders page with header and footer', async () => {
     const doc = Document({
       children: Page({
-        header: Text({ children: "My Header" }),
-        footer: Text({ children: "Page Footer" }),
-        children: [Heading({ children: "Content" }), Text({ children: "Body text." })],
+        header: Text({ children: 'My Header' }),
+        footer: Text({ children: 'Page Footer' }),
+        children: [Heading({ children: 'Content' }), Text({ children: 'Body text.' })],
       }),
     })
 
-    const result = await render(doc, "docx")
+    const result = await render(doc, 'docx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
 
-  it("renders table with bordered option and column widths", async () => {
+  it('renders table with bordered option and column widths', async () => {
     const doc = Document({
       children: Table({
         columns: [
-          { header: "Name", width: "60%" },
-          { header: "Price", width: "40%", align: "right" },
+          { header: 'Name', width: '60%' },
+          { header: 'Price', width: '40%', align: 'right' },
         ],
-        rows: [["Widget", "$10"]],
+        rows: [['Widget', '$10']],
         bordered: true,
       }),
     })
 
-    const result = await render(doc, "docx")
+    const result = await render(doc, 'docx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
 
-  it("renders nested lists", async () => {
+  it('renders nested lists', async () => {
     const doc = Document({
       children: List({
         children: [
           ListItem({
             children: [
-              "Parent item",
+              'Parent item',
               List({
-                children: [ListItem({ children: "Child item" })],
+                children: [ListItem({ children: 'Child item' })],
               }),
             ],
           }),
@@ -1499,7 +1499,7 @@ describe("DOCX renderer", () => {
       }),
     })
 
-    const result = await render(doc, "docx")
+    const result = await render(doc, 'docx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
@@ -1507,28 +1507,28 @@ describe("DOCX renderer", () => {
 
 // ─── XLSX Renderer (integration) ────────────────────────────────────────────
 
-describe("XLSX renderer", () => {
-  it("renders a document with tables to a valid Uint8Array", async () => {
+describe('XLSX renderer', () => {
+  it('renders a document with tables to a valid Uint8Array', async () => {
     const doc = Document({
-      title: "XLSX Test",
-      author: "Test Suite",
+      title: 'XLSX Test',
+      author: 'Test Suite',
       children: Page({
         children: [
-          Heading({ children: "Sales Data" }),
+          Heading({ children: 'Sales Data' }),
           Table({
-            columns: ["Product", "Revenue", "Margin"],
+            columns: ['Product', 'Revenue', 'Margin'],
             rows: [
-              ["Widget", "$1,234.56", "15%"],
-              ["Gadget", "$2,500.00", "22.5%"],
+              ['Widget', '$1,234.56', '15%'],
+              ['Gadget', '$2,500.00', '22.5%'],
             ],
             striped: true,
-            headerStyle: { background: "#1a1a2e", color: "#ffffff" },
+            headerStyle: { background: '#1a1a2e', color: '#ffffff' },
           }),
         ],
       }),
     })
 
-    const result = await render(doc, "xlsx")
+    const result = await render(doc, 'xlsx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
     // XLSX files are ZIP archives — first two bytes are PK (0x50, 0x4B)
@@ -1536,75 +1536,75 @@ describe("XLSX renderer", () => {
     expect((result as Uint8Array)[1]).toBe(0x4b)
   }, 15000)
 
-  it("parses currency values as numbers", async () => {
+  it('parses currency values as numbers', async () => {
     const doc = Document({
       children: Table({
-        columns: ["Amount"],
-        rows: [["$1,234.56"], ["$500"], ["-$100.50"]],
+        columns: ['Amount'],
+        rows: [['$1,234.56'], ['$500'], ['-$100.50']],
       }),
     })
 
-    const result = await render(doc, "xlsx")
+    const result = await render(doc, 'xlsx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
 
-  it("parses percentage values", async () => {
+  it('parses percentage values', async () => {
     const doc = Document({
       children: Table({
-        columns: ["Rate"],
-        rows: [["45%"], ["12.5%"], ["-3%"]],
+        columns: ['Rate'],
+        rows: [['45%'], ['12.5%'], ['-3%']],
       }),
     })
 
-    const result = await render(doc, "xlsx")
+    const result = await render(doc, 'xlsx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
 
-  it("renders multiple tables on the same sheet with spacing", async () => {
+  it('renders multiple tables on the same sheet with spacing', async () => {
     const doc = Document({
       children: [
-        Heading({ children: "Report" }),
+        Heading({ children: 'Report' }),
         Table({
-          columns: ["A", "B"],
+          columns: ['A', 'B'],
           rows: [
-            ["1", "2"],
-            ["3", "4"],
+            ['1', '2'],
+            ['3', '4'],
           ],
-          caption: "First Table",
+          caption: 'First Table',
         }),
         Table({
-          columns: ["X", "Y"],
-          rows: [["a", "b"]],
-          caption: "Second Table",
+          columns: ['X', 'Y'],
+          rows: [['a', 'b']],
+          caption: 'Second Table',
         }),
       ],
     })
 
-    const result = await render(doc, "xlsx")
+    const result = await render(doc, 'xlsx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
 
-  it("renders bordered tables", async () => {
+  it('renders bordered tables', async () => {
     const doc = Document({
       children: Table({
-        columns: ["Name", "Value"],
-        rows: [["Alpha", "100"]],
+        columns: ['Name', 'Value'],
+        rows: [['Alpha', '100']],
         bordered: true,
       }),
     })
 
-    const result = await render(doc, "xlsx")
+    const result = await render(doc, 'xlsx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
 
-  it("renders empty document with default sheet", async () => {
-    const doc = Document({ children: Text({ children: "no tables" }) })
+  it('renders empty document with default sheet', async () => {
+    const doc = Document({ children: Text({ children: 'no tables' }) })
 
-    const result = await render(doc, "xlsx")
+    const result = await render(doc, 'xlsx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
@@ -1612,76 +1612,76 @@ describe("XLSX renderer", () => {
 
 // ─── PDF Renderer (integration) ─────────────────────────────────────────────
 
-describe("PDF renderer", () => {
-  it("renders a document with heading, text, table, and data: image to a valid Uint8Array", async () => {
+describe('PDF renderer', () => {
+  it('renders a document with heading, text, table, and data: image to a valid Uint8Array', async () => {
     // 1x1 red pixel PNG as base64
     const redPixel =
-      "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=="
+      'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=='
 
     const doc = Document({
-      title: "PDF Test",
-      author: "Test Suite",
+      title: 'PDF Test',
+      author: 'Test Suite',
       children: Page({
-        size: "A4",
+        size: 'A4',
         margin: 40,
         children: [
-          Heading({ children: "PDF Integration Test" }),
-          Text({ children: "This is a test paragraph.", bold: true }),
+          Heading({ children: 'PDF Integration Test' }),
+          Text({ children: 'This is a test paragraph.', bold: true }),
           Table({
-            columns: ["Name", "Value"],
+            columns: ['Name', 'Value'],
             rows: [
-              ["Alpha", "100"],
-              ["Beta", "200"],
+              ['Alpha', '100'],
+              ['Beta', '200'],
             ],
             striped: true,
-            headerStyle: { background: "#333333", color: "#ffffff" },
+            headerStyle: { background: '#333333', color: '#ffffff' },
           }),
           Image({ src: redPixel, width: 50, height: 50 }),
           List({
             ordered: true,
-            children: [ListItem({ children: "First" }), ListItem({ children: "Second" })],
+            children: [ListItem({ children: 'First' }), ListItem({ children: 'Second' })],
           }),
           Divider(),
-          Quote({ children: "A wise quote." }),
+          Quote({ children: 'A wise quote.' }),
         ],
       }),
     })
 
-    const result = await render(doc, "pdf")
+    const result = await render(doc, 'pdf')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
     // PDF files start with %PDF
     const header = String.fromCharCode(...(result as Uint8Array).slice(0, 5))
-    expect(header).toBe("%PDF-")
+    expect(header).toBe('%PDF-')
   }, 15000)
 
-  it("renders images with HTTP URLs as placeholder text", async () => {
+  it('renders images with HTTP URLs as placeholder text', async () => {
     const doc = Document({
-      title: "HTTP Image Test",
+      title: 'HTTP Image Test',
       children: Page({
         children: [
-          Heading({ children: "Test" }),
-          Image({ src: "https://example.com/image.png", width: 100 }),
+          Heading({ children: 'Test' }),
+          Image({ src: 'https://example.com/image.png', width: 100 }),
         ],
       }),
     })
 
-    const result = await render(doc, "pdf")
+    const result = await render(doc, 'pdf')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
 
-  it("renders page with header and footer", async () => {
+  it('renders page with header and footer', async () => {
     const doc = Document({
-      title: "Header/Footer Test",
+      title: 'Header/Footer Test',
       children: Page({
-        header: Text({ children: "Page Header", bold: true }),
-        footer: Text({ children: "Page Footer", size: 10 }),
-        children: [Heading({ children: "Content" }), Text({ children: "Body text." })],
+        header: Text({ children: 'Page Header', bold: true }),
+        footer: Text({ children: 'Page Footer', size: 10 }),
+        children: [Heading({ children: 'Content' }), Text({ children: 'Body text.' })],
       }),
     })
 
-    const result = await render(doc, "pdf")
+    const result = await render(doc, 'pdf')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
@@ -1689,31 +1689,31 @@ describe("PDF renderer", () => {
 
 // ─── PPTX Renderer (integration) ────────────────────────────────────────────
 
-describe("PPTX renderer", () => {
-  it("renders a document with pages, headings, text, and tables to a valid Uint8Array", async () => {
+describe('PPTX renderer', () => {
+  it('renders a document with pages, headings, text, and tables to a valid Uint8Array', async () => {
     const doc = Document({
-      title: "PPTX Test",
-      author: "Test Suite",
+      title: 'PPTX Test',
+      author: 'Test Suite',
       children: [
         Page({
           children: [
-            Heading({ children: "Slide 1 Title" }),
-            Text({ children: "Introduction text.", bold: true }),
+            Heading({ children: 'Slide 1 Title' }),
+            Text({ children: 'Introduction text.', bold: true }),
             List({
-              children: [ListItem({ children: "Point A" }), ListItem({ children: "Point B" })],
+              children: [ListItem({ children: 'Point A' }), ListItem({ children: 'Point B' })],
             }),
           ],
         }),
         Page({
           children: [
-            Heading({ level: 2, children: "Slide 2 Data" }),
+            Heading({ level: 2, children: 'Slide 2 Data' }),
             Table({
-              columns: ["Metric", "Value"],
+              columns: ['Metric', 'Value'],
               rows: [
-                ["Revenue", "$1M"],
-                ["Profit", "$300K"],
+                ['Revenue', '$1M'],
+                ['Profit', '$300K'],
               ],
-              headerStyle: { background: "#1a1a2e", color: "#ffffff" },
+              headerStyle: { background: '#1a1a2e', color: '#ffffff' },
               striped: true,
             }),
           ],
@@ -1721,7 +1721,7 @@ describe("PPTX renderer", () => {
       ],
     })
 
-    const result = await render(doc, "pptx")
+    const result = await render(doc, 'pptx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
     // PPTX files are ZIP archives — first two bytes are PK (0x50, 0x4B)
@@ -1729,44 +1729,44 @@ describe("PPTX renderer", () => {
     expect((result as Uint8Array)[1]).toBe(0x4b)
   }, 15000)
 
-  it("renders a document without explicit pages as a single slide", async () => {
+  it('renders a document without explicit pages as a single slide', async () => {
     const doc = Document({
-      title: "Single Slide",
+      title: 'Single Slide',
       children: [
-        Heading({ children: "Auto Slide" }),
-        Text({ children: "No explicit page wrapper." }),
+        Heading({ children: 'Auto Slide' }),
+        Text({ children: 'No explicit page wrapper.' }),
       ],
     })
 
-    const result = await render(doc, "pptx")
+    const result = await render(doc, 'pptx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
 
-  it("renders all node types without errors", async () => {
+  it('renders all node types without errors', async () => {
     // 1x1 red pixel PNG as base64
     const redPixel =
-      "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=="
+      'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=='
 
     const doc = Document({
       children: Page({
         children: [
-          Heading({ children: "Title" }),
-          Text({ children: "Body", bold: true, italic: true }),
+          Heading({ children: 'Title' }),
+          Text({ children: 'Body', bold: true, italic: true }),
           Image({ src: redPixel, width: 50, height: 50 }),
-          Code({ children: "const x = 1" }),
-          Quote({ children: "A quote" }),
-          Link({ href: "https://example.com", children: "Link text" }),
-          Button({ href: "/action", background: "#4f46e5", children: "Click" }),
+          Code({ children: 'const x = 1' }),
+          Quote({ children: 'A quote' }),
+          Link({ href: 'https://example.com', children: 'Link text' }),
+          Button({ href: '/action', background: '#4f46e5', children: 'Click' }),
           Divider(),
           Spacer({ height: 20 }),
-          List({ ordered: true, children: [ListItem({ children: "one" })] }),
-          Section({ children: Text({ children: "nested" }) }),
+          List({ ordered: true, children: [ListItem({ children: 'one' })] }),
+          Section({ children: Text({ children: 'nested' }) }),
         ],
       }),
     })
 
-    const result = await render(doc, "pptx")
+    const result = await render(doc, 'pptx')
     expect(result).toBeInstanceOf(Uint8Array)
     expect((result as Uint8Array).length).toBeGreaterThan(0)
   }, 15000)
@@ -1774,224 +1774,224 @@ describe("PPTX renderer", () => {
 
 // ─── Slack Renderer ─────────────────────────────────────────────────────────
 
-describe("Slack renderer", () => {
-  it("renders heading as header block", async () => {
-    const doc = Document({ children: Heading({ children: "Hello" }) })
-    const json = (await render(doc, "slack")) as string
+describe('Slack renderer', () => {
+  it('renders heading as header block', async () => {
+    const doc = Document({ children: Heading({ children: 'Hello' }) })
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
     expect(parsed.blocks).toHaveLength(1)
-    expect(parsed.blocks[0].type).toBe("header")
+    expect(parsed.blocks[0].type).toBe('header')
   })
 
-  it("renders text with bold as mrkdwn", async () => {
+  it('renders text with bold as mrkdwn', async () => {
     const doc = Document({
-      children: Text({ bold: true, children: "Bold text" }),
+      children: Text({ bold: true, children: 'Bold text' }),
     })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].text.text).toContain("*Bold text*")
+    expect(parsed.blocks[0].text.text).toContain('*Bold text*')
   })
 
-  it("renders button as actions block", async () => {
+  it('renders button as actions block', async () => {
     const doc = Document({
-      children: Button({ href: "/go", children: "Click" }),
+      children: Button({ href: '/go', children: 'Click' }),
     })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].type).toBe("actions")
-    expect(parsed.blocks[0].elements[0].type).toBe("button")
+    expect(parsed.blocks[0].type).toBe('actions')
+    expect(parsed.blocks[0].elements[0].type).toBe('button')
   })
 
-  it("renders table as code block", async () => {
+  it('renders table as code block', async () => {
     const doc = Document({
-      children: Table({ columns: ["A", "B"], rows: [["1", "2"]] }),
+      children: Table({ columns: ['A', 'B'], rows: [['1', '2']] }),
     })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].text.text).toContain("*A*")
-    expect(parsed.blocks[0].text.text).toContain("1 | 2")
+    expect(parsed.blocks[0].text.text).toContain('*A*')
+    expect(parsed.blocks[0].text.text).toContain('1 | 2')
   })
 
-  it("renders divider", async () => {
+  it('renders divider', async () => {
     const doc = Document({ children: Divider() })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].type).toBe("divider")
+    expect(parsed.blocks[0].type).toBe('divider')
   })
 
-  it("renders list as bullet points", async () => {
+  it('renders list as bullet points', async () => {
     const doc = Document({
       children: List({
-        children: [ListItem({ children: "one" }), ListItem({ children: "two" })],
+        children: [ListItem({ children: 'one' }), ListItem({ children: 'two' })],
       }),
     })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].text.text).toContain("• one")
-    expect(parsed.blocks[0].text.text).toContain("• two")
+    expect(parsed.blocks[0].text.text).toContain('• one')
+    expect(parsed.blocks[0].text.text).toContain('• two')
   })
 
-  it("renders ordered list", async () => {
+  it('renders ordered list', async () => {
     const doc = Document({
       children: List({
         ordered: true,
-        children: [ListItem({ children: "a" }), ListItem({ children: "b" })],
+        children: [ListItem({ children: 'a' }), ListItem({ children: 'b' })],
       }),
     })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].text.text).toContain("1. a")
-    expect(parsed.blocks[0].text.text).toContain("2. b")
+    expect(parsed.blocks[0].text.text).toContain('1. a')
+    expect(parsed.blocks[0].text.text).toContain('2. b')
   })
 
-  it("renders link in mrkdwn format", async () => {
+  it('renders link in mrkdwn format', async () => {
     const doc = Document({
-      children: Link({ href: "https://x.com", children: "X" }),
+      children: Link({ href: 'https://x.com', children: 'X' }),
     })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].text.text).toContain("<https://x.com|X>")
+    expect(parsed.blocks[0].text.text).toContain('<https://x.com|X>')
   })
 
-  it("renders code block", async () => {
+  it('renders code block', async () => {
     const doc = Document({
-      children: Code({ language: "js", children: "const x = 1" }),
+      children: Code({ language: 'js', children: 'const x = 1' }),
     })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].text.text).toContain("```js")
-    expect(parsed.blocks[0].text.text).toContain("const x = 1")
+    expect(parsed.blocks[0].text.text).toContain('```js')
+    expect(parsed.blocks[0].text.text).toContain('const x = 1')
   })
 
-  it("renders quote with >", async () => {
-    const doc = Document({ children: Quote({ children: "wise" }) })
-    const json = (await render(doc, "slack")) as string
+  it('renders quote with >', async () => {
+    const doc = Document({ children: Quote({ children: 'wise' }) })
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].text.text).toContain("> wise")
+    expect(parsed.blocks[0].text.text).toContain('> wise')
   })
 
-  it("renders image with URL", async () => {
+  it('renders image with URL', async () => {
     const doc = Document({
-      children: Image({ src: "https://x.com/img.png", alt: "Photo" }),
+      children: Image({ src: 'https://x.com/img.png', alt: 'Photo' }),
     })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].type).toBe("image")
-    expect(parsed.blocks[0].image_url).toBe("https://x.com/img.png")
+    expect(parsed.blocks[0].type).toBe('image')
+    expect(parsed.blocks[0].image_url).toBe('https://x.com/img.png')
   })
 
-  it("skips non-URL images", async () => {
+  it('skips non-URL images', async () => {
     const doc = Document({
-      children: Image({ src: "data:image/png;base64,abc" }),
+      children: Image({ src: 'data:image/png;base64,abc' }),
     })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
     expect(parsed.blocks).toHaveLength(0)
   })
 
-  it("renders page-break as divider", async () => {
+  it('renders page-break as divider', async () => {
     const doc = Document({ children: PageBreak() })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].type).toBe("divider")
+    expect(parsed.blocks[0].type).toBe('divider')
   })
 
-  it("renders text with italic and strikethrough", async () => {
+  it('renders text with italic and strikethrough', async () => {
     const doc = Document({
       children: [
-        Text({ italic: true, children: "italic" }),
-        Text({ strikethrough: true, children: "struck" }),
+        Text({ italic: true, children: 'italic' }),
+        Text({ strikethrough: true, children: 'struck' }),
       ],
     })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].text.text).toContain("_italic_")
-    expect(parsed.blocks[1].text.text).toContain("~struck~")
+    expect(parsed.blocks[0].text.text).toContain('_italic_')
+    expect(parsed.blocks[1].text.text).toContain('~struck~')
   })
 
-  it("renders image with caption", async () => {
+  it('renders image with caption', async () => {
     const doc = Document({
-      children: Image({ src: "https://x.com/img.png", caption: "Nice" }),
+      children: Image({ src: 'https://x.com/img.png', caption: 'Nice' }),
     })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].title.text).toBe("Nice")
+    expect(parsed.blocks[0].title.text).toBe('Nice')
   })
 
-  it("renders table with caption", async () => {
+  it('renders table with caption', async () => {
     const doc = Document({
-      children: Table({ columns: ["X"], rows: [["1"]], caption: "My Table" }),
+      children: Table({ columns: ['X'], rows: [['1']], caption: 'My Table' }),
     })
-    const json = (await render(doc, "slack")) as string
+    const json = (await render(doc, 'slack')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.blocks[0].text.text).toContain("_My Table_")
+    expect(parsed.blocks[0].text.text).toContain('_My Table_')
   })
 })
 
 // ─── PageBreak ──────────────────────────────────────────────────────────────
 
-describe("PageBreak", () => {
-  it("creates a page-break node", () => {
+describe('PageBreak', () => {
+  it('creates a page-break node', () => {
     const pb = PageBreak()
-    expect(pb.type).toBe("page-break")
+    expect(pb.type).toBe('page-break')
     expect(pb.children).toEqual([])
   })
 
-  it("renders as CSS page-break in HTML", async () => {
+  it('renders as CSS page-break in HTML', async () => {
     const doc = Document({ children: PageBreak() })
-    const html = (await render(doc, "html")) as string
-    expect(html).toContain("page-break-after:always")
+    const html = (await render(doc, 'html')) as string
+    expect(html).toContain('page-break-after:always')
   })
 
-  it("renders as separator in email", async () => {
+  it('renders as separator in email', async () => {
     const doc = Document({ children: PageBreak() })
-    const html = (await render(doc, "email")) as string
-    expect(html).toContain("border-top:2px solid")
+    const html = (await render(doc, 'email')) as string
+    expect(html).toContain('border-top:2px solid')
   })
 
-  it("renders as --- in markdown", async () => {
+  it('renders as --- in markdown', async () => {
     const doc = Document({ children: PageBreak() })
-    const md = (await render(doc, "md")) as string
-    expect(md).toContain("---")
+    const md = (await render(doc, 'md')) as string
+    expect(md).toContain('---')
   })
 
-  it("renders as separator in text", async () => {
+  it('renders as separator in text', async () => {
     const doc = Document({ children: PageBreak() })
-    const text = (await render(doc, "text")) as string
-    expect(text).toContain("═")
+    const text = (await render(doc, 'text')) as string
+    expect(text).toContain('═')
   })
 
-  it("builder pageBreak inserts page-break node", async () => {
-    const doc = createDocument().heading("Page 1").pageBreak().heading("Page 2")
+  it('builder pageBreak inserts page-break node', async () => {
+    const doc = createDocument().heading('Page 1').pageBreak().heading('Page 2')
     const html = await doc.toHtml()
-    expect(html).toContain("page-break-after:always")
-    expect(html).toContain("Page 1")
-    expect(html).toContain("Page 2")
+    expect(html).toContain('page-break-after:always')
+    expect(html).toContain('Page 1')
+    expect(html).toContain('Page 2')
   })
 })
 
 // ─── RTL Support ────────────────────────────────────────────────────────────
 
-describe("RTL support", () => {
-  it("adds dir=rtl to HTML body", async () => {
-    const doc = Document({ children: Text({ children: "مرحبا" }) })
-    const html = (await render(doc, "html", { direction: "rtl" })) as string
+describe('RTL support', () => {
+  it('adds dir=rtl to HTML body', async () => {
+    const doc = Document({ children: Text({ children: 'مرحبا' }) })
+    const html = (await render(doc, 'html', { direction: 'rtl' })) as string
     expect(html).toContain('dir="rtl"')
-    expect(html).toContain("direction:rtl")
+    expect(html).toContain('direction:rtl')
   })
 
-  it("does not add dir for ltr (default)", async () => {
-    const doc = Document({ children: Text({ children: "Hello" }) })
-    const html = (await render(doc, "html")) as string
+  it('does not add dir for ltr (default)', async () => {
+    const doc = Document({ children: Text({ children: 'Hello' }) })
+    const html = (await render(doc, 'html')) as string
     expect(html).not.toContain('dir="rtl"')
   })
 })
 
 // ─── keepTogether ───────────────────────────────────────────────────────────
 
-describe("keepTogether", () => {
-  it("table accepts keepTogether prop", () => {
-    const t = Table({ columns: ["A"], rows: [["1"]], keepTogether: true })
+describe('keepTogether', () => {
+  it('table accepts keepTogether prop', () => {
+    const t = Table({ columns: ['A'], rows: [['1']], keepTogether: true })
     expect(t.props.keepTogether).toBe(true)
   })
 })
@@ -2000,358 +2000,358 @@ describe("keepTogether", () => {
 
 // ─── SVG Renderer ───────────────────────────────────────────────────────────
 
-describe("SVG renderer", () => {
-  it("renders a valid SVG document", async () => {
-    const doc = Document({ children: Heading({ children: "Title" }) })
-    const svg = (await render(doc, "svg")) as string
+describe('SVG renderer', () => {
+  it('renders a valid SVG document', async () => {
+    const doc = Document({ children: Heading({ children: 'Title' }) })
+    const svg = (await render(doc, 'svg')) as string
     expect(svg).toContain('<svg xmlns="http://www.w3.org/2000/svg"')
-    expect(svg).toContain("</svg>")
-    expect(svg).toContain("Title")
+    expect(svg).toContain('</svg>')
+    expect(svg).toContain('Title')
   })
 
-  it("renders heading with correct font size", async () => {
-    const doc = Document({ children: Heading({ level: 2, children: "Sub" }) })
-    const svg = (await render(doc, "svg")) as string
+  it('renders heading with correct font size', async () => {
+    const doc = Document({ children: Heading({ level: 2, children: 'Sub' }) })
+    const svg = (await render(doc, 'svg')) as string
     expect(svg).toContain('font-size="24"')
     expect(svg).toContain('font-weight="bold"')
   })
 
-  it("renders text with bold and italic", async () => {
+  it('renders text with bold and italic', async () => {
     const doc = Document({
       children: [
-        Text({ bold: true, children: "Bold" }),
-        Text({ italic: true, children: "Italic" }),
+        Text({ bold: true, children: 'Bold' }),
+        Text({ italic: true, children: 'Italic' }),
       ],
     })
-    const svg = (await render(doc, "svg")) as string
+    const svg = (await render(doc, 'svg')) as string
     expect(svg).toContain('font-weight="bold"')
     expect(svg).toContain('font-style="italic"')
   })
 
-  it("renders table with header and rows", async () => {
+  it('renders table with header and rows', async () => {
     const doc = Document({
       children: Table({
-        columns: ["Name", "Price"],
-        rows: [["Widget", "$10"]],
-        headerStyle: { background: "#000", color: "#fff" },
+        columns: ['Name', 'Price'],
+        rows: [['Widget', '$10']],
+        headerStyle: { background: '#000', color: '#fff' },
         striped: true,
       }),
     })
-    const svg = (await render(doc, "svg")) as string
-    expect(svg).toContain("Name")
-    expect(svg).toContain("Widget")
+    const svg = (await render(doc, 'svg')) as string
+    expect(svg).toContain('Name')
+    expect(svg).toContain('Widget')
     expect(svg).toContain('fill="#000"')
   })
 
-  it("renders image from data URL", async () => {
+  it('renders image from data URL', async () => {
     const doc = Document({
       children: Image({
-        src: "data:image/png;base64,abc",
+        src: 'data:image/png;base64,abc',
         width: 200,
         height: 100,
-        caption: "Photo",
+        caption: 'Photo',
       }),
     })
-    const svg = (await render(doc, "svg")) as string
-    expect(svg).toContain("<image")
-    expect(svg).toContain("data:image/png;base64,abc")
-    expect(svg).toContain("Photo")
+    const svg = (await render(doc, 'svg')) as string
+    expect(svg).toContain('<image')
+    expect(svg).toContain('data:image/png;base64,abc')
+    expect(svg).toContain('Photo')
   })
 
-  it("renders image placeholder for local paths", async () => {
+  it('renders image placeholder for local paths', async () => {
     const doc = Document({
-      children: Image({ src: "/local.png", alt: "Local" }),
+      children: Image({ src: '/local.png', alt: 'Local' }),
     })
-    const svg = (await render(doc, "svg")) as string
-    expect(svg).toContain("Local")
+    const svg = (await render(doc, 'svg')) as string
+    expect(svg).toContain('Local')
     expect(svg).toContain('fill="#f0f0f0"')
   })
 
-  it("renders list", async () => {
+  it('renders list', async () => {
     const doc = Document({
       children: List({
         ordered: true,
-        children: [ListItem({ children: "one" }), ListItem({ children: "two" })],
+        children: [ListItem({ children: 'one' }), ListItem({ children: 'two' })],
       }),
     })
-    const svg = (await render(doc, "svg")) as string
-    expect(svg).toContain("1. one")
-    expect(svg).toContain("2. two")
+    const svg = (await render(doc, 'svg')) as string
+    expect(svg).toContain('1. one')
+    expect(svg).toContain('2. two')
   })
 
-  it("renders unordered list", async () => {
+  it('renders unordered list', async () => {
     const doc = Document({
       children: List({
-        children: [ListItem({ children: "a" }), ListItem({ children: "b" })],
+        children: [ListItem({ children: 'a' }), ListItem({ children: 'b' })],
       }),
     })
-    const svg = (await render(doc, "svg")) as string
-    expect(svg).toContain("• a")
-    expect(svg).toContain("• b")
+    const svg = (await render(doc, 'svg')) as string
+    expect(svg).toContain('• a')
+    expect(svg).toContain('• b')
   })
 
-  it("renders code block", async () => {
-    const doc = Document({ children: Code({ children: "const x = 1" }) })
-    const svg = (await render(doc, "svg")) as string
-    expect(svg).toContain("const x = 1")
+  it('renders code block', async () => {
+    const doc = Document({ children: Code({ children: 'const x = 1' }) })
+    const svg = (await render(doc, 'svg')) as string
+    expect(svg).toContain('const x = 1')
     expect(svg).toContain('font-family="monospace"')
     expect(svg).toContain('fill="#f5f5f5"') // background
   })
 
-  it("renders divider", async () => {
-    const doc = Document({ children: Divider({ color: "#ccc", thickness: 2 }) })
-    const svg = (await render(doc, "svg")) as string
+  it('renders divider', async () => {
+    const doc = Document({ children: Divider({ color: '#ccc', thickness: 2 }) })
+    const svg = (await render(doc, 'svg')) as string
     expect(svg).toContain('stroke="#ccc"')
     expect(svg).toContain('stroke-width="2"')
   })
 
-  it("renders button", async () => {
+  it('renders button', async () => {
     const doc = Document({
       children: Button({
-        href: "/pay",
-        background: "#4f46e5",
-        children: "Pay",
+        href: '/pay',
+        background: '#4f46e5',
+        children: 'Pay',
       }),
     })
-    const svg = (await render(doc, "svg")) as string
+    const svg = (await render(doc, 'svg')) as string
     expect(svg).toContain('fill="#4f46e5"')
-    expect(svg).toContain("Pay")
+    expect(svg).toContain('Pay')
   })
 
-  it("renders quote", async () => {
-    const doc = Document({ children: Quote({ children: "wise words" }) })
-    const svg = (await render(doc, "svg")) as string
-    expect(svg).toContain("wise words")
+  it('renders quote', async () => {
+    const doc = Document({ children: Quote({ children: 'wise words' }) })
+    const svg = (await render(doc, 'svg')) as string
+    expect(svg).toContain('wise words')
     expect(svg).toContain('font-style="italic"')
   })
 
-  it("renders link", async () => {
+  it('renders link', async () => {
     const doc = Document({
-      children: Link({ href: "https://x.com", children: "X" }),
+      children: Link({ href: 'https://x.com', children: 'X' }),
     })
-    const svg = (await render(doc, "svg")) as string
+    const svg = (await render(doc, 'svg')) as string
     expect(svg).toContain('<a href="https://x.com">')
-    expect(svg).toContain("X")
+    expect(svg).toContain('X')
   })
 
-  it("renders spacer", async () => {
+  it('renders spacer', async () => {
     const doc = Document({
-      children: [Text({ children: "A" }), Spacer({ height: 50 }), Text({ children: "B" })],
+      children: [Text({ children: 'A' }), Spacer({ height: 50 }), Text({ children: 'B' })],
     })
-    const svg = (await render(doc, "svg")) as string
-    expect(svg).toContain("A")
-    expect(svg).toContain("B")
+    const svg = (await render(doc, 'svg')) as string
+    expect(svg).toContain('A')
+    expect(svg).toContain('B')
   })
 
-  it("renders page-break as dashed line", async () => {
+  it('renders page-break as dashed line', async () => {
     const doc = Document({ children: PageBreak() })
-    const svg = (await render(doc, "svg")) as string
-    expect(svg).toContain("stroke-dasharray")
+    const svg = (await render(doc, 'svg')) as string
+    expect(svg).toContain('stroke-dasharray')
   })
 
-  it("supports RTL direction", async () => {
-    const doc = Document({ children: Text({ children: "مرحبا" }) })
-    const svg = (await render(doc, "svg", { direction: "rtl" })) as string
+  it('supports RTL direction', async () => {
+    const doc = Document({ children: Text({ children: 'مرحبا' }) })
+    const svg = (await render(doc, 'svg', { direction: 'rtl' })) as string
     expect(svg).toContain('direction="rtl"')
   })
 
-  it("auto-calculates height from content", async () => {
+  it('auto-calculates height from content', async () => {
     const doc = Document({
-      children: [Heading({ children: "A" }), Text({ children: "B" }), Text({ children: "C" })],
+      children: [Heading({ children: 'A' }), Text({ children: 'B' }), Text({ children: 'C' })],
     })
-    const svg = (await render(doc, "svg")) as string
+    const svg = (await render(doc, 'svg')) as string
     const match = svg.match(/height="(\d+)"/)
     expect(match).toBeTruthy()
     expect(Number(match![1])).toBeGreaterThan(80)
   })
 
-  it("renders image from HTTP URL", async () => {
+  it('renders image from HTTP URL', async () => {
     const doc = Document({
-      children: Image({ src: "https://x.com/img.png", width: 300 }),
+      children: Image({ src: 'https://x.com/img.png', width: 300 }),
     })
-    const svg = (await render(doc, "svg")) as string
-    expect(svg).toContain("<image")
-    expect(svg).toContain("https://x.com/img.png")
+    const svg = (await render(doc, 'svg')) as string
+    expect(svg).toContain('<image')
+    expect(svg).toContain('https://x.com/img.png')
   })
 
-  it("builder toSvg works", async () => {
-    const svg = await createDocument().heading("Hi").text("World").toSvg()
-    expect(svg).toContain("<svg")
-    expect(svg).toContain("Hi")
-    expect(svg).toContain("World")
+  it('builder toSvg works', async () => {
+    const svg = await createDocument().heading('Hi').text('World').toSvg()
+    expect(svg).toContain('<svg')
+    expect(svg).toContain('Hi')
+    expect(svg).toContain('World')
   })
 })
 
 // ─── Teams Renderer ─────────────────────────────────────────────────────────
 
-describe("Teams renderer", () => {
-  it("renders heading as TextBlock", async () => {
-    const doc = Document({ children: Heading({ children: "Hello" }) })
-    const json = (await render(doc, "teams")) as string
+describe('Teams renderer', () => {
+  it('renders heading as TextBlock', async () => {
+    const doc = Document({ children: Heading({ children: 'Hello' }) })
+    const json = (await render(doc, 'teams')) as string
     const card = JSON.parse(json)
-    expect(card.type).toBe("AdaptiveCard")
-    expect(card.body[0].type).toBe("TextBlock")
-    expect(card.body[0].text).toBe("Hello")
-    expect(card.body[0].weight).toBe("bolder")
+    expect(card.type).toBe('AdaptiveCard')
+    expect(card.body[0].type).toBe('TextBlock')
+    expect(card.body[0].text).toBe('Hello')
+    expect(card.body[0].weight).toBe('bolder')
   })
 
-  it("renders bold text", async () => {
-    const doc = Document({ children: Text({ bold: true, children: "Bold" }) })
-    const json = (await render(doc, "teams")) as string
+  it('renders bold text', async () => {
+    const doc = Document({ children: Text({ bold: true, children: 'Bold' }) })
+    const json = (await render(doc, 'teams')) as string
     const card = JSON.parse(json)
-    expect(card.body[0].text).toContain("**Bold**")
+    expect(card.body[0].text).toContain('**Bold**')
   })
 
-  it("renders button as Action.OpenUrl", async () => {
+  it('renders button as Action.OpenUrl', async () => {
     const doc = Document({
-      children: Button({ href: "/go", children: "Click" }),
+      children: Button({ href: '/go', children: 'Click' }),
     })
-    const json = (await render(doc, "teams")) as string
+    const json = (await render(doc, 'teams')) as string
     const card = JSON.parse(json)
-    expect(card.body[0].type).toBe("ActionSet")
-    expect(card.body[0].actions[0].type).toBe("Action.OpenUrl")
+    expect(card.body[0].type).toBe('ActionSet')
+    expect(card.body[0].actions[0].type).toBe('Action.OpenUrl')
   })
 
-  it("renders table as ColumnSet", async () => {
+  it('renders table as ColumnSet', async () => {
     const doc = Document({
-      children: Table({ columns: ["A", "B"], rows: [["1", "2"]] }),
+      children: Table({ columns: ['A', 'B'], rows: [['1', '2']] }),
     })
-    const json = (await render(doc, "teams")) as string
+    const json = (await render(doc, 'teams')) as string
     const card = JSON.parse(json)
-    expect(card.body[0].type).toBe("ColumnSet")
+    expect(card.body[0].type).toBe('ColumnSet')
   })
 
-  it("renders list", async () => {
+  it('renders list', async () => {
     const doc = Document({
       children: List({
-        children: [ListItem({ children: "one" }), ListItem({ children: "two" })],
+        children: [ListItem({ children: 'one' }), ListItem({ children: 'two' })],
       }),
     })
-    const json = (await render(doc, "teams")) as string
+    const json = (await render(doc, 'teams')) as string
     const card = JSON.parse(json)
-    expect(card.body[0].text).toContain("• one")
+    expect(card.body[0].text).toContain('• one')
   })
 
-  it("renders code as monospace", async () => {
-    const doc = Document({ children: Code({ children: "x = 1" }) })
-    const json = (await render(doc, "teams")) as string
+  it('renders code as monospace', async () => {
+    const doc = Document({ children: Code({ children: 'x = 1' }) })
+    const json = (await render(doc, 'teams')) as string
     const card = JSON.parse(json)
-    expect(card.body[0].fontType).toBe("monospace")
+    expect(card.body[0].fontType).toBe('monospace')
   })
 
-  it("renders divider as separator", async () => {
+  it('renders divider as separator', async () => {
     const doc = Document({ children: Divider() })
-    const json = (await render(doc, "teams")) as string
+    const json = (await render(doc, 'teams')) as string
     const card = JSON.parse(json)
     expect(card.body[0].separator).toBe(true)
   })
 
-  it("renders image with URL", async () => {
+  it('renders image with URL', async () => {
     const doc = Document({
-      children: Image({ src: "https://x.com/img.png", alt: "Photo" }),
+      children: Image({ src: 'https://x.com/img.png', alt: 'Photo' }),
     })
-    const json = (await render(doc, "teams")) as string
+    const json = (await render(doc, 'teams')) as string
     const card = JSON.parse(json)
-    expect(card.body[0].type).toBe("Image")
+    expect(card.body[0].type).toBe('Image')
   })
 
-  it("renders quote as Container", async () => {
-    const doc = Document({ children: Quote({ children: "wise" }) })
-    const json = (await render(doc, "teams")) as string
+  it('renders quote as Container', async () => {
+    const doc = Document({ children: Quote({ children: 'wise' }) })
+    const json = (await render(doc, 'teams')) as string
     const card = JSON.parse(json)
-    expect(card.body[0].type).toBe("Container")
-    expect(card.body[0].style).toBe("emphasis")
+    expect(card.body[0].type).toBe('Container')
+    expect(card.body[0].style).toBe('emphasis')
   })
 
-  it("renders link as markdown", async () => {
+  it('renders link as markdown', async () => {
     const doc = Document({
-      children: Link({ href: "https://x.com", children: "X" }),
+      children: Link({ href: 'https://x.com', children: 'X' }),
     })
-    const json = (await render(doc, "teams")) as string
+    const json = (await render(doc, 'teams')) as string
     const card = JSON.parse(json)
-    expect(card.body[0].text).toContain("[X](https://x.com)")
+    expect(card.body[0].text).toContain('[X](https://x.com)')
   })
 
-  it("builder toTeams works", async () => {
-    const json = await createDocument().heading("Hi").toTeams()
+  it('builder toTeams works', async () => {
+    const json = await createDocument().heading('Hi').toTeams()
     const card = JSON.parse(json)
-    expect(card.type).toBe("AdaptiveCard")
+    expect(card.type).toBe('AdaptiveCard')
   })
 })
 
 // ─── Discord Renderer ───────────────────────────────────────────────────────
 
-describe("Discord renderer", () => {
-  it("renders heading as embed title", async () => {
-    const doc = Document({ children: Heading({ children: "Title" }) })
-    const json = (await render(doc, "discord")) as string
+describe('Discord renderer', () => {
+  it('renders heading as embed title', async () => {
+    const doc = Document({ children: Heading({ children: 'Title' }) })
+    const json = (await render(doc, 'discord')) as string
     const payload = JSON.parse(json)
-    expect(payload.embeds[0].title).toBe("Title")
+    expect(payload.embeds[0].title).toBe('Title')
   })
 
-  it("renders text in description", async () => {
+  it('renders text in description', async () => {
     const doc = Document({
-      children: [Heading({ children: "T" }), Text({ children: "Body" })],
+      children: [Heading({ children: 'T' }), Text({ children: 'Body' })],
     })
-    const json = (await render(doc, "discord")) as string
+    const json = (await render(doc, 'discord')) as string
     const payload = JSON.parse(json)
-    expect(payload.embeds[0].description).toContain("Body")
+    expect(payload.embeds[0].description).toContain('Body')
   })
 
-  it("renders small table as fields", async () => {
+  it('renders small table as fields', async () => {
     const doc = Document({
       children: Table({
-        columns: ["A", "B"],
+        columns: ['A', 'B'],
         rows: [
-          ["1", "2"],
-          ["3", "4"],
+          ['1', '2'],
+          ['3', '4'],
         ],
       }),
     })
-    const json = (await render(doc, "discord")) as string
+    const json = (await render(doc, 'discord')) as string
     const payload = JSON.parse(json)
     expect(payload.embeds[0].fields).toHaveLength(2)
-    expect(payload.embeds[0].fields[0].name).toBe("A")
+    expect(payload.embeds[0].fields[0].name).toBe('A')
     expect(payload.embeds[0].fields[0].inline).toBe(true)
   })
 
-  it("renders image as embed image", async () => {
-    const doc = Document({ children: Image({ src: "https://x.com/img.png" }) })
-    const json = (await render(doc, "discord")) as string
+  it('renders image as embed image', async () => {
+    const doc = Document({ children: Image({ src: 'https://x.com/img.png' }) })
+    const json = (await render(doc, 'discord')) as string
     const payload = JSON.parse(json)
-    expect(payload.embeds[0].image.url).toBe("https://x.com/img.png")
+    expect(payload.embeds[0].image.url).toBe('https://x.com/img.png')
   })
 
-  it("renders quote with >", async () => {
-    const doc = Document({ children: Quote({ children: "wise" }) })
-    const json = (await render(doc, "discord")) as string
+  it('renders quote with >', async () => {
+    const doc = Document({ children: Quote({ children: 'wise' }) })
+    const json = (await render(doc, 'discord')) as string
     const payload = JSON.parse(json)
-    expect(payload.embeds[0].description).toContain("> wise")
+    expect(payload.embeds[0].description).toContain('> wise')
   })
 
-  it("renders code block", async () => {
+  it('renders code block', async () => {
     const doc = Document({
-      children: Code({ language: "js", children: "x()" }),
+      children: Code({ language: 'js', children: 'x()' }),
     })
-    const json = (await render(doc, "discord")) as string
+    const json = (await render(doc, 'discord')) as string
     const payload = JSON.parse(json)
-    expect(payload.embeds[0].description).toContain("```js")
+    expect(payload.embeds[0].description).toContain('```js')
   })
 
-  it("renders list", async () => {
+  it('renders list', async () => {
     const doc = Document({
       children: List({
         ordered: true,
-        children: [ListItem({ children: "a" })],
+        children: [ListItem({ children: 'a' })],
       }),
     })
-    const json = (await render(doc, "discord")) as string
+    const json = (await render(doc, 'discord')) as string
     const payload = JSON.parse(json)
-    expect(payload.embeds[0].description).toContain("1. a")
+    expect(payload.embeds[0].description).toContain('1. a')
   })
 
-  it("builder toDiscord works", async () => {
-    const json = await createDocument().heading("Hi").text("World").toDiscord()
+  it('builder toDiscord works', async () => {
+    const json = await createDocument().heading('Hi').text('World').toDiscord()
     const payload = JSON.parse(json)
     expect(payload.embeds).toHaveLength(1)
   })
@@ -2359,214 +2359,214 @@ describe("Discord renderer", () => {
 
 // ─── Telegram Renderer ──────────────────────────────────────────────────────
 
-describe("Telegram renderer", () => {
-  it("renders heading as bold", async () => {
-    const doc = Document({ children: Heading({ children: "Title" }) })
-    const html = (await render(doc, "telegram")) as string
-    expect(html).toContain("<b>Title</b>")
+describe('Telegram renderer', () => {
+  it('renders heading as bold', async () => {
+    const doc = Document({ children: Heading({ children: 'Title' }) })
+    const html = (await render(doc, 'telegram')) as string
+    expect(html).toContain('<b>Title</b>')
   })
 
-  it("renders text with formatting", async () => {
+  it('renders text with formatting', async () => {
     const doc = Document({
       children: [
-        Text({ bold: true, children: "Bold" }),
-        Text({ italic: true, children: "Italic" }),
-        Text({ underline: true, children: "Under" }),
-        Text({ strikethrough: true, children: "Struck" }),
+        Text({ bold: true, children: 'Bold' }),
+        Text({ italic: true, children: 'Italic' }),
+        Text({ underline: true, children: 'Under' }),
+        Text({ strikethrough: true, children: 'Struck' }),
       ],
     })
-    const html = (await render(doc, "telegram")) as string
-    expect(html).toContain("<b>Bold</b>")
-    expect(html).toContain("<i>Italic</i>")
-    expect(html).toContain("<u>Under</u>")
-    expect(html).toContain("<s>Struck</s>")
+    const html = (await render(doc, 'telegram')) as string
+    expect(html).toContain('<b>Bold</b>')
+    expect(html).toContain('<i>Italic</i>')
+    expect(html).toContain('<u>Under</u>')
+    expect(html).toContain('<s>Struck</s>')
   })
 
-  it("renders link as <a>", async () => {
+  it('renders link as <a>', async () => {
     const doc = Document({
-      children: Link({ href: "https://x.com", children: "X" }),
+      children: Link({ href: 'https://x.com', children: 'X' }),
     })
-    const html = (await render(doc, "telegram")) as string
+    const html = (await render(doc, 'telegram')) as string
     expect(html).toContain('<a href="https://x.com">X</a>')
   })
 
-  it("renders table as pre-formatted text", async () => {
+  it('renders table as pre-formatted text', async () => {
     const doc = Document({
-      children: Table({ columns: ["A", "B"], rows: [["1", "2"]] }),
+      children: Table({ columns: ['A', 'B'], rows: [['1', '2']] }),
     })
-    const html = (await render(doc, "telegram")) as string
-    expect(html).toContain("<pre>")
-    expect(html).toContain("A | B")
-    expect(html).toContain("1 | 2")
+    const html = (await render(doc, 'telegram')) as string
+    expect(html).toContain('<pre>')
+    expect(html).toContain('A | B')
+    expect(html).toContain('1 | 2')
   })
 
-  it("renders code with language", async () => {
+  it('renders code with language', async () => {
     const doc = Document({
-      children: Code({ language: "python", children: "x = 1" }),
+      children: Code({ language: 'python', children: 'x = 1' }),
     })
-    const html = (await render(doc, "telegram")) as string
-    expect(html).toContain("language-python")
-    expect(html).toContain("x = 1")
+    const html = (await render(doc, 'telegram')) as string
+    expect(html).toContain('language-python')
+    expect(html).toContain('x = 1')
   })
 
-  it("renders code without language", async () => {
-    const doc = Document({ children: Code({ children: "x = 1" }) })
-    const html = (await render(doc, "telegram")) as string
-    expect(html).toContain("<pre>x = 1</pre>")
+  it('renders code without language', async () => {
+    const doc = Document({ children: Code({ children: 'x = 1' }) })
+    const html = (await render(doc, 'telegram')) as string
+    expect(html).toContain('<pre>x = 1</pre>')
   })
 
-  it("renders quote as blockquote", async () => {
-    const doc = Document({ children: Quote({ children: "wise" }) })
-    const html = (await render(doc, "telegram")) as string
-    expect(html).toContain("<blockquote>wise</blockquote>")
+  it('renders quote as blockquote', async () => {
+    const doc = Document({ children: Quote({ children: 'wise' }) })
+    const html = (await render(doc, 'telegram')) as string
+    expect(html).toContain('<blockquote>wise</blockquote>')
   })
 
-  it("renders list", async () => {
+  it('renders list', async () => {
     const doc = Document({
       children: List({
-        children: [ListItem({ children: "one" }), ListItem({ children: "two" })],
+        children: [ListItem({ children: 'one' }), ListItem({ children: 'two' })],
       }),
     })
-    const html = (await render(doc, "telegram")) as string
-    expect(html).toContain("• one")
-    expect(html).toContain("• two")
+    const html = (await render(doc, 'telegram')) as string
+    expect(html).toContain('• one')
+    expect(html).toContain('• two')
   })
 
-  it("renders button as link", async () => {
+  it('renders button as link', async () => {
     const doc = Document({
-      children: Button({ href: "/pay", children: "Pay" }),
+      children: Button({ href: '/pay', children: 'Pay' }),
     })
-    const html = (await render(doc, "telegram")) as string
+    const html = (await render(doc, 'telegram')) as string
     expect(html).toContain('<a href="/pay">Pay</a>')
   })
 
-  it("skips images (sent separately in Telegram)", async () => {
-    const doc = Document({ children: Image({ src: "https://x.com/img.png" }) })
-    const html = (await render(doc, "telegram")) as string
-    expect(html).toBe("")
+  it('skips images (sent separately in Telegram)', async () => {
+    const doc = Document({ children: Image({ src: 'https://x.com/img.png' }) })
+    const html = (await render(doc, 'telegram')) as string
+    expect(html).toBe('')
   })
 
-  it("escapes HTML entities", async () => {
+  it('escapes HTML entities', async () => {
     const doc = Document({
-      children: Text({ children: "<script>alert(1)</script>" }),
+      children: Text({ children: '<script>alert(1)</script>' }),
     })
-    const html = (await render(doc, "telegram")) as string
-    expect(html).not.toContain("<script>")
-    expect(html).toContain("&lt;script&gt;")
+    const html = (await render(doc, 'telegram')) as string
+    expect(html).not.toContain('<script>')
+    expect(html).toContain('&lt;script&gt;')
   })
 
-  it("builder toTelegram works", async () => {
-    const html = await createDocument().heading("Hi").text("World").toTelegram()
-    expect(html).toContain("<b>Hi</b>")
-    expect(html).toContain("World")
+  it('builder toTelegram works', async () => {
+    const html = await createDocument().heading('Hi').text('World').toTelegram()
+    expect(html).toContain('<b>Hi</b>')
+    expect(html).toContain('World')
   })
 })
 
 // ─── Notion Renderer ────────────────────────────────────────────────────────
 
-describe("Notion renderer", () => {
-  it("renders heading as heading block", async () => {
-    const doc = Document({ children: Heading({ children: "Title" }) })
-    const json = (await render(doc, "notion")) as string
+describe('Notion renderer', () => {
+  it('renders heading as heading block', async () => {
+    const doc = Document({ children: Heading({ children: 'Title' }) })
+    const json = (await render(doc, 'notion')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.children[0].type).toBe("heading_1")
+    expect(parsed.children[0].type).toBe('heading_1')
   })
 
-  it("renders h2 as heading_2", async () => {
-    const doc = Document({ children: Heading({ level: 2, children: "Sub" }) })
-    const json = (await render(doc, "notion")) as string
+  it('renders h2 as heading_2', async () => {
+    const doc = Document({ children: Heading({ level: 2, children: 'Sub' }) })
+    const json = (await render(doc, 'notion')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.children[0].type).toBe("heading_2")
+    expect(parsed.children[0].type).toBe('heading_2')
   })
 
-  it("renders h3+ as heading_3", async () => {
-    const doc = Document({ children: Heading({ level: 4, children: "Sub" }) })
-    const json = (await render(doc, "notion")) as string
+  it('renders h3+ as heading_3', async () => {
+    const doc = Document({ children: Heading({ level: 4, children: 'Sub' }) })
+    const json = (await render(doc, 'notion')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.children[0].type).toBe("heading_3")
+    expect(parsed.children[0].type).toBe('heading_3')
   })
 
-  it("renders text as paragraph", async () => {
-    const doc = Document({ children: Text({ bold: true, children: "Bold" }) })
-    const json = (await render(doc, "notion")) as string
+  it('renders text as paragraph', async () => {
+    const doc = Document({ children: Text({ bold: true, children: 'Bold' }) })
+    const json = (await render(doc, 'notion')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.children[0].type).toBe("paragraph")
+    expect(parsed.children[0].type).toBe('paragraph')
     expect(parsed.children[0].paragraph.rich_text[0].annotations.bold).toBe(true)
   })
 
-  it("renders table with header row", async () => {
+  it('renders table with header row', async () => {
     const doc = Document({
-      children: Table({ columns: ["A", "B"], rows: [["1", "2"]] }),
+      children: Table({ columns: ['A', 'B'], rows: [['1', '2']] }),
     })
-    const json = (await render(doc, "notion")) as string
+    const json = (await render(doc, 'notion')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.children[0].type).toBe("table")
+    expect(parsed.children[0].type).toBe('table')
     expect(parsed.children[0].table.has_column_header).toBe(true)
   })
 
-  it("renders bulleted list", async () => {
+  it('renders bulleted list', async () => {
     const doc = Document({
-      children: List({ children: [ListItem({ children: "a" })] }),
+      children: List({ children: [ListItem({ children: 'a' })] }),
     })
-    const json = (await render(doc, "notion")) as string
+    const json = (await render(doc, 'notion')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.children[0].type).toBe("bulleted_list_item")
+    expect(parsed.children[0].type).toBe('bulleted_list_item')
   })
 
-  it("renders numbered list", async () => {
+  it('renders numbered list', async () => {
     const doc = Document({
       children: List({
         ordered: true,
-        children: [ListItem({ children: "a" })],
+        children: [ListItem({ children: 'a' })],
       }),
     })
-    const json = (await render(doc, "notion")) as string
+    const json = (await render(doc, 'notion')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.children[0].type).toBe("numbered_list_item")
+    expect(parsed.children[0].type).toBe('numbered_list_item')
   })
 
-  it("renders code block", async () => {
+  it('renders code block', async () => {
     const doc = Document({
-      children: Code({ language: "python", children: "x = 1" }),
+      children: Code({ language: 'python', children: 'x = 1' }),
     })
-    const json = (await render(doc, "notion")) as string
+    const json = (await render(doc, 'notion')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.children[0].type).toBe("code")
-    expect(parsed.children[0].code.language).toBe("python")
+    expect(parsed.children[0].type).toBe('code')
+    expect(parsed.children[0].code.language).toBe('python')
   })
 
-  it("renders quote", async () => {
-    const doc = Document({ children: Quote({ children: "wise" }) })
-    const json = (await render(doc, "notion")) as string
+  it('renders quote', async () => {
+    const doc = Document({ children: Quote({ children: 'wise' }) })
+    const json = (await render(doc, 'notion')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.children[0].type).toBe("quote")
+    expect(parsed.children[0].type).toBe('quote')
   })
 
-  it("renders divider", async () => {
+  it('renders divider', async () => {
     const doc = Document({ children: Divider() })
-    const json = (await render(doc, "notion")) as string
+    const json = (await render(doc, 'notion')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.children[0].type).toBe("divider")
+    expect(parsed.children[0].type).toBe('divider')
   })
 
-  it("renders image with URL", async () => {
-    const doc = Document({ children: Image({ src: "https://x.com/img.png" }) })
-    const json = (await render(doc, "notion")) as string
+  it('renders image with URL', async () => {
+    const doc = Document({ children: Image({ src: 'https://x.com/img.png' }) })
+    const json = (await render(doc, 'notion')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.children[0].type).toBe("image")
+    expect(parsed.children[0].type).toBe('image')
   })
 
-  it("renders link as paragraph with link", async () => {
+  it('renders link as paragraph with link', async () => {
     const doc = Document({
-      children: Link({ href: "https://x.com", children: "X" }),
+      children: Link({ href: 'https://x.com', children: 'X' }),
     })
-    const json = (await render(doc, "notion")) as string
+    const json = (await render(doc, 'notion')) as string
     const parsed = JSON.parse(json)
-    expect(parsed.children[0].paragraph.rich_text[0].text.link.url).toBe("https://x.com")
+    expect(parsed.children[0].paragraph.rich_text[0].text.link.url).toBe('https://x.com')
   })
 
-  it("builder toNotion works", async () => {
-    const json = await createDocument().heading("Hi").toNotion()
+  it('builder toNotion works', async () => {
+    const json = await createDocument().heading('Hi').toNotion()
     const parsed = JSON.parse(json)
     expect(parsed.children.length).toBeGreaterThan(0)
   })
@@ -2574,298 +2574,298 @@ describe("Notion renderer", () => {
 
 // ─── Confluence/Jira Renderer ───────────────────────────────────────────────
 
-describe("Confluence renderer", () => {
-  it("renders ADF document", async () => {
-    const doc = Document({ children: Heading({ children: "Title" }) })
-    const json = (await render(doc, "confluence")) as string
+describe('Confluence renderer', () => {
+  it('renders ADF document', async () => {
+    const doc = Document({ children: Heading({ children: 'Title' }) })
+    const json = (await render(doc, 'confluence')) as string
     const adf = JSON.parse(json)
     expect(adf.version).toBe(1)
-    expect(adf.type).toBe("doc")
-    expect(adf.content[0].type).toBe("heading")
+    expect(adf.type).toBe('doc')
+    expect(adf.content[0].type).toBe('heading')
   })
 
-  it("renders text with marks", async () => {
+  it('renders text with marks', async () => {
     const doc = Document({
-      children: Text({ bold: true, italic: true, children: "styled" }),
+      children: Text({ bold: true, italic: true, children: 'styled' }),
     })
-    const json = (await render(doc, "confluence")) as string
+    const json = (await render(doc, 'confluence')) as string
     const adf = JSON.parse(json)
     const marks = adf.content[0].content[0].marks
-    expect(marks.some((m: any) => m.type === "strong")).toBe(true)
-    expect(marks.some((m: any) => m.type === "em")).toBe(true)
+    expect(marks.some((m: any) => m.type === 'strong')).toBe(true)
+    expect(marks.some((m: any) => m.type === 'em')).toBe(true)
   })
 
-  it("renders table", async () => {
+  it('renders table', async () => {
     const doc = Document({
-      children: Table({ columns: ["A"], rows: [["1"]] }),
+      children: Table({ columns: ['A'], rows: [['1']] }),
     })
-    const json = (await render(doc, "confluence")) as string
+    const json = (await render(doc, 'confluence')) as string
     const adf = JSON.parse(json)
-    expect(adf.content[0].type).toBe("table")
-    expect(adf.content[0].content[0].content[0].type).toBe("tableHeader")
+    expect(adf.content[0].type).toBe('table')
+    expect(adf.content[0].content[0].content[0].type).toBe('tableHeader')
   })
 
-  it("renders ordered list", async () => {
+  it('renders ordered list', async () => {
     const doc = Document({
       children: List({
         ordered: true,
-        children: [ListItem({ children: "a" })],
+        children: [ListItem({ children: 'a' })],
       }),
     })
-    const json = (await render(doc, "confluence")) as string
+    const json = (await render(doc, 'confluence')) as string
     const adf = JSON.parse(json)
-    expect(adf.content[0].type).toBe("orderedList")
+    expect(adf.content[0].type).toBe('orderedList')
   })
 
-  it("renders code block", async () => {
+  it('renders code block', async () => {
     const doc = Document({
-      children: Code({ language: "java", children: "int x = 1;" }),
+      children: Code({ language: 'java', children: 'int x = 1;' }),
     })
-    const json = (await render(doc, "confluence")) as string
+    const json = (await render(doc, 'confluence')) as string
     const adf = JSON.parse(json)
-    expect(adf.content[0].type).toBe("codeBlock")
-    expect(adf.content[0].attrs.language).toBe("java")
+    expect(adf.content[0].type).toBe('codeBlock')
+    expect(adf.content[0].attrs.language).toBe('java')
   })
 
-  it("renders blockquote", async () => {
-    const doc = Document({ children: Quote({ children: "wise" }) })
-    const json = (await render(doc, "confluence")) as string
+  it('renders blockquote', async () => {
+    const doc = Document({ children: Quote({ children: 'wise' }) })
+    const json = (await render(doc, 'confluence')) as string
     const adf = JSON.parse(json)
-    expect(adf.content[0].type).toBe("blockquote")
+    expect(adf.content[0].type).toBe('blockquote')
   })
 
-  it("renders rule (divider)", async () => {
+  it('renders rule (divider)', async () => {
     const doc = Document({ children: Divider() })
-    const json = (await render(doc, "confluence")) as string
+    const json = (await render(doc, 'confluence')) as string
     const adf = JSON.parse(json)
-    expect(adf.content[0].type).toBe("rule")
+    expect(adf.content[0].type).toBe('rule')
   })
 
-  it("renders link with href", async () => {
+  it('renders link with href', async () => {
     const doc = Document({
-      children: Link({ href: "https://x.com", children: "X" }),
+      children: Link({ href: 'https://x.com', children: 'X' }),
     })
-    const json = (await render(doc, "confluence")) as string
+    const json = (await render(doc, 'confluence')) as string
     const adf = JSON.parse(json)
-    expect(adf.content[0].content[0].marks[0].attrs.href).toBe("https://x.com")
+    expect(adf.content[0].content[0].marks[0].attrs.href).toBe('https://x.com')
   })
 
-  it("builder toConfluence works", async () => {
-    const json = await createDocument().heading("Hi").toConfluence()
+  it('builder toConfluence works', async () => {
+    const json = await createDocument().heading('Hi').toConfluence()
     const adf = JSON.parse(json)
-    expect(adf.type).toBe("doc")
+    expect(adf.type).toBe('doc')
   })
 })
 
 // ─── WhatsApp Renderer ──────────────────────────────────────────────────────
 
-describe("WhatsApp renderer", () => {
-  it("renders heading as bold", async () => {
-    const doc = Document({ children: Heading({ children: "Title" }) })
-    const text = (await render(doc, "whatsapp")) as string
-    expect(text).toContain("*Title*")
+describe('WhatsApp renderer', () => {
+  it('renders heading as bold', async () => {
+    const doc = Document({ children: Heading({ children: 'Title' }) })
+    const text = (await render(doc, 'whatsapp')) as string
+    expect(text).toContain('*Title*')
   })
 
-  it("renders bold, italic, strikethrough", async () => {
+  it('renders bold, italic, strikethrough', async () => {
     const doc = Document({
       children: [
-        Text({ bold: true, children: "Bold" }),
-        Text({ italic: true, children: "Italic" }),
-        Text({ strikethrough: true, children: "Struck" }),
+        Text({ bold: true, children: 'Bold' }),
+        Text({ italic: true, children: 'Italic' }),
+        Text({ strikethrough: true, children: 'Struck' }),
       ],
     })
-    const text = (await render(doc, "whatsapp")) as string
-    expect(text).toContain("*Bold*")
-    expect(text).toContain("_Italic_")
-    expect(text).toContain("~Struck~")
+    const text = (await render(doc, 'whatsapp')) as string
+    expect(text).toContain('*Bold*')
+    expect(text).toContain('_Italic_')
+    expect(text).toContain('~Struck~')
   })
 
-  it("renders code as triple backticks", async () => {
-    const doc = Document({ children: Code({ children: "x = 1" }) })
-    const text = (await render(doc, "whatsapp")) as string
-    expect(text).toContain("```x = 1```")
+  it('renders code as triple backticks', async () => {
+    const doc = Document({ children: Code({ children: 'x = 1' }) })
+    const text = (await render(doc, 'whatsapp')) as string
+    expect(text).toContain('```x = 1```')
   })
 
-  it("renders quote with >", async () => {
-    const doc = Document({ children: Quote({ children: "wise" }) })
-    const text = (await render(doc, "whatsapp")) as string
-    expect(text).toContain("> wise")
+  it('renders quote with >', async () => {
+    const doc = Document({ children: Quote({ children: 'wise' }) })
+    const text = (await render(doc, 'whatsapp')) as string
+    expect(text).toContain('> wise')
   })
 
-  it("renders link as text + URL", async () => {
+  it('renders link as text + URL', async () => {
     const doc = Document({
-      children: Link({ href: "https://x.com", children: "X" }),
+      children: Link({ href: 'https://x.com', children: 'X' }),
     })
-    const text = (await render(doc, "whatsapp")) as string
-    expect(text).toContain("X: https://x.com")
+    const text = (await render(doc, 'whatsapp')) as string
+    expect(text).toContain('X: https://x.com')
   })
 
-  it("renders table", async () => {
+  it('renders table', async () => {
     const doc = Document({
-      children: Table({ columns: ["A", "B"], rows: [["1", "2"]] }),
+      children: Table({ columns: ['A', 'B'], rows: [['1', '2']] }),
     })
-    const text = (await render(doc, "whatsapp")) as string
-    expect(text).toContain("*A* | *B*")
-    expect(text).toContain("1 | 2")
+    const text = (await render(doc, 'whatsapp')) as string
+    expect(text).toContain('*A* | *B*')
+    expect(text).toContain('1 | 2')
   })
 
-  it("renders list", async () => {
+  it('renders list', async () => {
     const doc = Document({
-      children: List({ children: [ListItem({ children: "one" })] }),
+      children: List({ children: [ListItem({ children: 'one' })] }),
     })
-    const text = (await render(doc, "whatsapp")) as string
-    expect(text).toContain("• one")
+    const text = (await render(doc, 'whatsapp')) as string
+    expect(text).toContain('• one')
   })
 
-  it("skips images", async () => {
-    const doc = Document({ children: Image({ src: "https://x.com/img.png" }) })
-    const text = (await render(doc, "whatsapp")) as string
-    expect(text).toBe("")
+  it('skips images', async () => {
+    const doc = Document({ children: Image({ src: 'https://x.com/img.png' }) })
+    const text = (await render(doc, 'whatsapp')) as string
+    expect(text).toBe('')
   })
 
-  it("builder toWhatsApp works", async () => {
-    const text = await createDocument().heading("Hi").text("World").toWhatsApp()
-    expect(text).toContain("*Hi*")
-    expect(text).toContain("World")
+  it('builder toWhatsApp works', async () => {
+    const text = await createDocument().heading('Hi').text('World').toWhatsApp()
+    expect(text).toContain('*Hi*')
+    expect(text).toContain('World')
   })
 })
 
 // ─── Google Chat Renderer ───────────────────────────────────────────────────
 
-describe("Google Chat renderer", () => {
-  it("renders card with header", async () => {
+describe('Google Chat renderer', () => {
+  it('renders card with header', async () => {
     const doc = Document({
-      title: "Report",
-      children: Text({ children: "Body" }),
+      title: 'Report',
+      children: Text({ children: 'Body' }),
     })
-    const json = (await render(doc, "google-chat")) as string
+    const json = (await render(doc, 'google-chat')) as string
     const card = JSON.parse(json)
-    expect(card.cardsV2[0].card.header.title).toBe("Report")
+    expect(card.cardsV2[0].card.header.title).toBe('Report')
   })
 
-  it("renders heading as decorated text", async () => {
-    const doc = Document({ children: Heading({ children: "Title" }) })
-    const json = (await render(doc, "google-chat")) as string
+  it('renders heading as decorated text', async () => {
+    const doc = Document({ children: Heading({ children: 'Title' }) })
+    const json = (await render(doc, 'google-chat')) as string
     const card = JSON.parse(json)
-    expect(card.cardsV2[0].card.sections[0].widgets[0].decoratedText.text).toContain("<b>Title</b>")
+    expect(card.cardsV2[0].card.sections[0].widgets[0].decoratedText.text).toContain('<b>Title</b>')
   })
 
-  it("renders text paragraph", async () => {
-    const doc = Document({ children: Text({ bold: true, children: "Bold" }) })
-    const json = (await render(doc, "google-chat")) as string
+  it('renders text paragraph', async () => {
+    const doc = Document({ children: Text({ bold: true, children: 'Bold' }) })
+    const json = (await render(doc, 'google-chat')) as string
     const card = JSON.parse(json)
-    expect(card.cardsV2[0].card.sections[0].widgets[0].textParagraph.text).toContain("<b>Bold</b>")
+    expect(card.cardsV2[0].card.sections[0].widgets[0].textParagraph.text).toContain('<b>Bold</b>')
   })
 
-  it("renders button", async () => {
+  it('renders button', async () => {
     const doc = Document({
-      children: Button({ href: "/go", children: "Click" }),
+      children: Button({ href: '/go', children: 'Click' }),
     })
-    const json = (await render(doc, "google-chat")) as string
+    const json = (await render(doc, 'google-chat')) as string
     const card = JSON.parse(json)
-    expect(card.cardsV2[0].card.sections[0].widgets[0].buttonList.buttons[0].text).toBe("Click")
+    expect(card.cardsV2[0].card.sections[0].widgets[0].buttonList.buttons[0].text).toBe('Click')
   })
 
-  it("renders divider", async () => {
+  it('renders divider', async () => {
     const doc = Document({ children: Divider() })
-    const json = (await render(doc, "google-chat")) as string
+    const json = (await render(doc, 'google-chat')) as string
     const card = JSON.parse(json)
     expect(card.cardsV2[0].card.sections[0].widgets[0].divider).toBeDefined()
   })
 
-  it("renders image", async () => {
+  it('renders image', async () => {
     const doc = Document({
-      children: Image({ src: "https://x.com/img.png", alt: "Photo" }),
+      children: Image({ src: 'https://x.com/img.png', alt: 'Photo' }),
     })
-    const json = (await render(doc, "google-chat")) as string
+    const json = (await render(doc, 'google-chat')) as string
     const card = JSON.parse(json)
-    expect(card.cardsV2[0].card.sections[0].widgets[0].image.imageUrl).toBe("https://x.com/img.png")
+    expect(card.cardsV2[0].card.sections[0].widgets[0].image.imageUrl).toBe('https://x.com/img.png')
   })
 
-  it("renders link", async () => {
+  it('renders link', async () => {
     const doc = Document({
-      children: Link({ href: "https://x.com", children: "X" }),
+      children: Link({ href: 'https://x.com', children: 'X' }),
     })
-    const json = (await render(doc, "google-chat")) as string
+    const json = (await render(doc, 'google-chat')) as string
     const card = JSON.parse(json)
     expect(card.cardsV2[0].card.sections[0].widgets[0].textParagraph.text).toContain(
       'href="https://x.com"',
     )
   })
 
-  it("renders list", async () => {
+  it('renders list', async () => {
     const doc = Document({
-      children: List({ children: [ListItem({ children: "one" })] }),
+      children: List({ children: [ListItem({ children: 'one' })] }),
     })
-    const json = (await render(doc, "google-chat")) as string
+    const json = (await render(doc, 'google-chat')) as string
     const card = JSON.parse(json)
-    expect(card.cardsV2[0].card.sections[0].widgets[0].textParagraph.text).toContain("• one")
+    expect(card.cardsV2[0].card.sections[0].widgets[0].textParagraph.text).toContain('• one')
   })
 
-  it("uses first heading as title when no title prop", async () => {
+  it('uses first heading as title when no title prop', async () => {
     const doc = Document({
-      children: [Heading({ children: "Auto Title" }), Text({ children: "body" })],
+      children: [Heading({ children: 'Auto Title' }), Text({ children: 'body' })],
     })
-    const json = (await render(doc, "google-chat")) as string
+    const json = (await render(doc, 'google-chat')) as string
     const card = JSON.parse(json)
-    expect(card.cardsV2[0].card.header.title).toBe("Auto Title")
+    expect(card.cardsV2[0].card.header.title).toBe('Auto Title')
   })
 
-  it("builder toGoogleChat works", async () => {
-    const json = await createDocument({ title: "Hi" }).text("World").toGoogleChat()
+  it('builder toGoogleChat works', async () => {
+    const json = await createDocument({ title: 'Hi' }).text('World').toGoogleChat()
     const card = JSON.parse(json)
-    expect(card.cardsV2[0].card.header.title).toBe("Hi")
+    expect(card.cardsV2[0].card.header.title).toBe('Hi')
   })
 })
 
-describe("builder toSlack", () => {
-  it("renders to Slack JSON", async () => {
-    const result = await createDocument().heading("Hi").text("World").toSlack()
+describe('builder toSlack', () => {
+  it('renders to Slack JSON', async () => {
+    const result = await createDocument().heading('Hi').text('World').toSlack()
     const parsed = JSON.parse(result)
     expect(parsed.blocks).toHaveLength(2)
-    expect(parsed.blocks[0].type).toBe("header")
-    expect(parsed.blocks[1].type).toBe("section")
+    expect(parsed.blocks[0].type).toBe('header')
+    expect(parsed.blocks[1].type).toBe('section')
   })
 })
 
 // ─── Builder .add() and .section() ──────────────────────────────────────────
 
-describe("builder .add() and .section()", () => {
+describe('builder .add() and .section()', () => {
   // build() wraps sections in Document({ children: [Page({ children: sections })] })
   // so actual content nodes are inside the page's children
   function getPageChildren(doc: ReturnType<typeof createDocument>) {
     const node = doc.build()
-    expect(node.type).toBe("document")
+    expect(node.type).toBe('document')
     const page = node.children[0]!
-    expect(typeof page !== "string" && page.type).toBe("page")
-    return typeof page !== "string" ? page.children : []
+    expect(typeof page !== 'string' && page.type).toBe('page')
+    return typeof page !== 'string' ? page.children : []
   }
 
-  it("add() with a single node adds it to the document", () => {
-    const doc = createDocument().add(Text({ children: "hello" }))
+  it('add() with a single node adds it to the document', () => {
+    const doc = createDocument().add(Text({ children: 'hello' }))
     const children = getPageChildren(doc)
     expect(children).toHaveLength(1)
     const child = children[0]!
-    expect(typeof child !== "string" && child.type).toBe("text")
+    expect(typeof child !== 'string' && child.type).toBe('text')
   })
 
-  it("add() with an array adds multiple nodes", () => {
-    const doc = createDocument().add([Heading({ children: "a" }), Text({ children: "b" })])
+  it('add() with an array adds multiple nodes', () => {
+    const doc = createDocument().add([Heading({ children: 'a' }), Text({ children: 'b' })])
     const children = getPageChildren(doc)
     expect(children).toHaveLength(2)
     const first = children[0]!
     const second = children[1]!
-    expect(typeof first !== "string" && first.type).toBe("heading")
-    expect(typeof second !== "string" && second.type).toBe("text")
+    expect(typeof first !== 'string' && first.type).toBe('heading')
+    expect(typeof second !== 'string' && second.type).toBe('text')
   })
 
-  it("section() wraps children in a Section node", () => {
-    const doc = createDocument().section([Text({ children: "a" }), Text({ children: "b" })])
+  it('section() wraps children in a Section node', () => {
+    const doc = createDocument().section([Text({ children: 'a' }), Text({ children: 'b' })])
     const children = getPageChildren(doc)
     expect(children).toHaveLength(1)
     const section = children[0]!
-    expect(typeof section !== "string" && section.type).toBe("section")
-    if (typeof section !== "string") {
+    expect(typeof section !== 'string' && section.type).toBe('section')
+    if (typeof section !== 'string') {
       expect(section.children).toHaveLength(2)
     }
   })