diff --git a/AGENTS.md b/AGENTS.md
index de5caaeb8..b360c3b7c 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -762,7 +762,7 @@ Contract: `packages/comark/SPEC/HTML/README.md`. HTML nodes carry
 `$: { html: 1, block: 0 | 1 }`. `block` means the tag outlived the paragraph
 that opened it, not that the tag is a block element. `html({ markdown: false })`
 keeps closed-block text literal; a blank line still nests real markdown under
-the open tag. `<style>`, `<pre>`, `<script>`, `<textarea>`, and block-level `<!-- -->` comments are always verbatim, including newlines and inner tags. All-uppercase tag names are lowercased (`<DIV>` → `div`); any name with a lowercase letter keeps its case (`<Hello>`, `<linearGradient>`). `visit`/`visitAsync` drop nodes nested deeper than `TREE_WALK_MAX_DEPTH` (50). Deferred cases (cross-paragraph inline
+the open tag. `<style>`, `<pre>`, `<script>`, `<textarea>`, and block-level `<!-- -->` comments are always verbatim, including newlines and inner tags. All-uppercase tag names are lowercased (`<DIV>` → `div`); any name with a lowercase letter keeps its case (`<Hello>`, `<linearGradient>`). Attribute names follow the same rule (`normalizeName` in `internal/parse/utils.ts`), so `viewBox` / `someProp` keep their case; the first of case-variant duplicate attributes wins. `visit`/`visitAsync` drop nodes nested deeper than `TREE_WALK_MAX_DEPTH` (50). Deferred cases (cross-paragraph inline
 opener, trailing text after that closer, indented child tag inside a multiline
 `<a>`) are skipped tests in `test/html-block.test.ts` — do not weaken them.
 
diff --git a/docs/content/4.plugins/0.defaults/html.md b/docs/content/4.plugins/0.defaults/html.md
index e5bda45d9..0121bb897 100644
--- a/docs/content/4.plugins/0.defaults/html.md
+++ b/docs/content/4.plugins/0.defaults/html.md
@@ -112,6 +112,8 @@ Hello **World**
 
 All-uppercase tag names are normalized to lowercase (`<DIV>` → `div`). A tag name with any lowercase letter keeps its authored case, so components and SVG elements resolve as written (`<Hello>` → `Hello`, `<linearGradient>` → `linearGradient`).
 
+Attribute names follow the same rule: all-uppercase names are lowercased (`CLASS` → `class`), and any other name keeps its case, so SVG, MathML and component props work as written (`viewBox`, `attributeName`, `someProp`). Security checks compare names case-insensitively, so `onClick` or `Href` are filtered like `onclick` and `href`. When an attribute is repeated with different case (`href` and `HREF`), the first one wins, as in browsers.
+
 Spaces beside a tag are content. `<p>Hello <em>x</em> <a>two</a></p>` keeps the space after `Hello` and the space between `</em>` and `<a>`, including when `markdown` is `false`.
 
 ## Block and inline
diff --git a/docs/content/4.plugins/1.built-in/security.md b/docs/content/4.plugins/1.built-in/security.md
index 33c9cb9f8..7cf3253dd 100644
--- a/docs/content/4.plugins/1.built-in/security.md
+++ b/docs/content/4.plugins/1.built-in/security.md
@@ -96,6 +96,7 @@ Attributes that can be abused regardless of value are always stripped:
 | `srcdoc` | Can contain arbitrary HTML |
 | `formaction` | Can redirect form submissions |
 | `innerHTML` | Injects raw HTML through framework renderers |
+| `outerHTML` | Injects raw HTML through framework renderers |
 | `dangerouslySetInnerHTML` | Injects raw HTML through framework renderers |
 | `textContent` | Overwrites an element's children |
 | `*Html` / `*-html` (`labelHtml`, `description-html`, `v-html`, …) | Component props rendered as raw HTML (for example with `v-html`) |
@@ -104,7 +105,7 @@ Attributes that can be abused regardless of value are always stripped:
 Prop names are normalized before these checks: case, binding prefixes (`:`, `v-bind:`), Vue's `.prop` / `^attr` prefixes (`.innerHTML`, `^onclick`), and `:` / `-` / `_` separators are ignored.
 
 ::note
-Framework renderers (Vue, React, Svelte, Angular) never forward `innerHTML`, `dangerouslySetInnerHTML`, or `textContent` from document attributes, even without this plugin. Raw HTML has its own explicit path through the default `html` plugin.
+Framework renderers (Vue, React, Svelte, Angular) never forward `innerHTML`, `outerHTML`, `dangerouslySetInnerHTML`, or `textContent` from document attributes, even without this plugin. Raw HTML has its own explicit path through the default `html` plugin.
 ::
 
 ### Nested props
diff --git a/packages/comark-vue/test/sink-props.test.ts b/packages/comark-vue/test/sink-props.test.ts
index 688601539..7e89333b0 100644
--- a/packages/comark-vue/test/sink-props.test.ts
+++ b/packages/comark-vue/test/sink-props.test.ts
@@ -27,4 +27,15 @@ describe('HTML sink props', () => {
     expect(html).toContain('safe')
     expect(html).not.toContain('overlay')
   })
+
+  it('never forwards markdown-authored outerHTML to h()', async () => {
+    // On the client, Vue sets outerHTML as a DOM property on HTML elements.
+    // A later patch then parses the value as markup.
+    const document = await parseMarkdown(
+      '[x]{outerHTML="<img src=x onerror=alert(1)>"}\n\n<svg><foreignObject><div outerHTML="<img src=y onerror=alert(2)>"></div></foreignObject></svg>'
+    )
+    const html = await renderDocument(document)
+    expect(html).not.toContain('onerror')
+    expect(html.toLowerCase()).not.toContain('outerhtml')
+  })
 })
diff --git a/packages/comark/SPEC/HTML/svg-block.md b/packages/comark/SPEC/HTML/svg-block.md
new file mode 100644
index 000000000..178c0d2a5
--- /dev/null
+++ b/packages/comark/SPEC/HTML/svg-block.md
@@ -0,0 +1,54 @@
+## Input
+
+```md
+<svg viewBox="0 0 10 10">
+  <linearGradient id="g"></linearGradient>
+</svg>
+```
+
+## AST
+
+```json
+{
+  "frontmatter": {},
+  "meta": {},
+  "nodes": [
+    [
+      "svg",
+      {
+        "$": {
+          "html": 1,
+          "block": 1
+        },
+        "viewBox": "0 0 10 10"
+      },
+      [
+        "linearGradient",
+        {
+          "$": {
+            "html": 1,
+            "block": 0
+          },
+          "id": "g"
+        }
+      ]
+    ]
+  ]
+}
+```
+
+## HTML
+
+```html
+<svg viewBox="0 0 10 10">
+  <linearGradient id="g"></linearGradient>
+</svg>
+```
+
+## Markdown
+
+```md
+<svg viewBox="0 0 10 10">
+<linearGradient id="g"></linearGradient>
+</svg>
+```
diff --git a/packages/comark/SPEC/HTML/svg.md b/packages/comark/SPEC/HTML/svg.md
new file mode 100644
index 000000000..606902f83
--- /dev/null
+++ b/packages/comark/SPEC/HTML/svg.md
@@ -0,0 +1,55 @@
+## Input
+
+```md
+An icon: <svg viewBox="0 0 10 10"><linearGradient id="g"></linearGradient></svg>
+```
+
+## AST
+
+```json
+{
+  "frontmatter": {},
+  "meta": {},
+  "nodes": [
+    [
+      "p",
+      {},
+      "An icon: ",
+      [
+        "svg",
+        {
+          "$": {
+            "html": 1,
+            "block": 0
+          },
+          "viewBox": "0 0 10 10"
+        },
+        [
+          "linearGradient",
+          {
+            "$": {
+              "html": 1,
+              "block": 0
+            },
+            "id": "g"
+          }
+        ]
+      ]
+    ]
+  ]
+}
+```
+
+## HTML
+
+```html
+<p>
+  An icon: <svg viewBox="0 0 10 10"><linearGradient id="g"></linearGradient></svg>
+</p>
+```
+
+## Markdown
+
+```md
+An icon: <svg viewBox="0 0 10 10"><linearGradient id="g"></linearGradient></svg>
+```
diff --git a/packages/comark/src/internal/parse/utils.ts b/packages/comark/src/internal/parse/utils.ts
index 8bcc6a825..1f1fe4d2a 100644
--- a/packages/comark/src/internal/parse/utils.ts
+++ b/packages/comark/src/internal/parse/utils.ts
@@ -135,12 +135,12 @@ export function extractReusableNodes(markdown: string, lastOutput: MarkdownDocum
 }
 
 /**
- * Lowercase an all-uppercase tag name (`DIV` → `div`, `H1` → `h1`). HTML tag names are
- * case-insensitive, and renderers / plugins match the lowercase form. A name with any
- * lowercase letter keeps its authored case (`Hello`, `linearGradient`, `my-el`) so
- * component lookup still works.
+ * Lowercase an all-uppercase tag or attribute name (`DIV` → `div`, `HREF` → `href`).
+ * HTML names are case-insensitive, and renderers / plugins match the lowercase form. A
+ * name with any lowercase letter keeps its authored case, so component lookup and
+ * case-sensitive names still work: `Hello`, `linearGradient`, `viewBox`, `someProp`.
  */
-function normalizeTagName(tag: string): string {
+function normalizeName(tag: string): string {
   for (let i = 0; i < tag.length; i++) {
     const c = tag.charCodeAt(i)
     if (c >= 0x61 /* a */ && c <= 0x7a /* z */) return tag
@@ -161,12 +161,12 @@ export function parseHtmlInline(content: string): ParsedHtmlTag {
 
   const closeMatch = trimmed.match(/^<\/\s*([A-Za-z][\w:-]*)\s*>$/)
   if (closeMatch) {
-    return { kind: 'close', tag: normalizeTagName(closeMatch[1]) }
+    return { kind: 'close', tag: normalizeName(closeMatch[1]) }
   }
 
   const openMatch = trimmed.match(/^<\s*([A-Za-z][\w:-]*)((?:\s+[\s\S]*?)?)\s*(\/?)>$/)
   if (openMatch) {
-    const tag = normalizeTagName(openMatch[1])
+    const tag = normalizeName(openMatch[1])
     const attrsStr = openMatch[2] || ''
     const slash = openMatch[3] === '/'
     const selfClosing = slash || isHtmlVoidElement(tag)
@@ -184,16 +184,22 @@ export function parseHtmlInline(content: string): ParsedHtmlTag {
 /**
  * Parse HTML attribute string into a key/value map.
  * Supports `key="value"`, `key='value'`, bare `key=value`, and boolean attributes.
- * Names are lowercased, as HTML attribute names are case-insensitive.
+ * Names follow {@link normalizeName}: all-uppercase names are lowercased, others keep
+ * their case (SVG `viewBox`, component `someProp`, #467). Like the HTML tokenizer,
+ * the first of case-variant duplicates (`href` / `HREF`) wins.
  */
 export function parseHtmlAttributes(attrsStr: string): Record<string, unknown> {
   const attrs: Record<string, unknown> = {}
   if (!attrsStr || !attrsStr.trim()) return attrs
 
+  const seen = new Set<string>()
   const re = /([:\w.-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g
   let match: RegExpExecArray | null
   while ((match = re.exec(attrsStr)) !== null) {
-    const key = match[1].toLowerCase()
+    const lower = match[1].toLowerCase()
+    if (seen.has(lower)) continue
+    seen.add(lower)
+    const key = normalizeName(match[1])
     const value = match[2] ?? match[3] ?? match[4]
     attrs[key] = value === undefined ? true : decodeHTML(value)
   }
diff --git a/packages/comark/src/internal/props-validation.ts b/packages/comark/src/internal/props-validation.ts
index bbe64dcf1..9ccf701c8 100644
--- a/packages/comark/src/internal/props-validation.ts
+++ b/packages/comark/src/internal/props-validation.ts
@@ -7,12 +7,19 @@ export const REJECTED_PROP = Symbol('comark:rejected-prop')
 
 export const unsafeTags = ['object']
 
-// `innerHTML` / `dangerouslySetInnerHTML` / `textContent` are DOM sinks that
-// turn a string prop into raw markup or overwrite an element's children.
-// Framework renderers receive resolved props verbatim, so markdown-authored
-// values would otherwise bypass tag filtering (raw HTML has its own explicit
-// path via the `html` plugin and does not need these).
-export const unsafeAttributes = ['srcdoc', 'formaction', 'innerhtml', 'dangerouslysetinnerhtml', 'textcontent']
+// `innerHTML` / `outerHTML` / `dangerouslySetInnerHTML` / `textContent` are DOM
+// sinks that turn a string prop into raw markup or overwrite an element's
+// children. Framework renderers receive resolved props verbatim, so
+// markdown-authored values would otherwise bypass tag filtering (raw HTML has
+// its own explicit path via the `html` plugin and does not need these).
+export const unsafeAttributes = [
+  'srcdoc',
+  'formaction',
+  'innerhtml',
+  'outerhtml',
+  'dangerouslysetinnerhtml',
+  'textcontent',
+]
 
 export const unsafeLinkPrefix = [
   'javascript:',
diff --git a/packages/comark/src/internal/stringify/attributes.ts b/packages/comark/src/internal/stringify/attributes.ts
index 2ed7472f5..c9689e1f5 100644
--- a/packages/comark/src/internal/stringify/attributes.ts
+++ b/packages/comark/src/internal/stringify/attributes.ts
@@ -21,11 +21,11 @@ export interface ResolveAttributesOptions {
 }
 
 // DOM sinks that turn a string/object prop into raw markup (`innerHTML`,
-// `dangerouslySetInnerHTML`) or overwrite an element's children
+// `outerHTML`, `dangerouslySetInnerHTML`) or overwrite an element's children
 // (`textContent`). Framework renderers hand resolved attributes to
 // `h()`/`createElement`/spreads verbatim, so these keys are never forwarded
 // from document attributes — raw HTML has its own explicit path.
-const HTML_SINK_PROPS = new Set(['innerhtml', 'dangerouslysetinnerhtml', 'textcontent'])
+const HTML_SINK_PROPS = new Set(['innerhtml', 'outerhtml', 'dangerouslysetinnerhtml', 'textcontent'])
 
 /**
  * Resolve `:prefixed` attributes against the render context.
diff --git a/packages/comark/test/plugins/security.test.ts b/packages/comark/test/plugins/security.test.ts
index c6f6c2e96..a0bfcb8e4 100644
--- a/packages/comark/test/plugins/security.test.ts
+++ b/packages/comark/test/plugins/security.test.ts
@@ -437,7 +437,7 @@ describe('security plugin — component props beyond href/src', () => {
     const [img] = collectElements(tree.nodes).filter((node) => node[0] === 'img')
     expect(img![1].src).toBe('data:image/png;base64,abc')
     const [animate] = collectElements(tree.nodes).filter((node) => node[0] === 'animate')
-    expect(animate![1]).toMatchObject({ attributename: 'opacity', values: '0;1' })
+    expect(animate![1]).toMatchObject({ attributeName: 'opacity', values: '0;1' })
   })
 })
 
diff --git a/packages/comark/test/props-validation.test.ts b/packages/comark/test/props-validation.test.ts
index c33c140ed..fc01e74a5 100644
--- a/packages/comark/test/props-validation.test.ts
+++ b/packages/comark/test/props-validation.test.ts
@@ -42,6 +42,12 @@ describe('validateProp', () => {
     it('blocks textContent', () => {
       expect(validateProp('textContent', 'overlay')).toBe(REJECTED_PROP)
     })
+
+    it('blocks outerHTML (any case)', () => {
+      expect(validateProp('outerHTML', '<img src=x onerror=alert(1)>')).toBe(REJECTED_PROP)
+      expect(validateProp('OUTERHTML', '<img src=x onerror=alert(1)>')).toBe(REJECTED_PROP)
+      expect(validateProp(':outerHTML', '"<img src=x onerror=alert(1)>"')).toBe(REJECTED_PROP)
+    })
   })
 
   describe('href safety', () => {
diff --git a/packages/comark/test/resolve-attributes.test.ts b/packages/comark/test/resolve-attributes.test.ts
index e234dd123..8a3dc2877 100644
--- a/packages/comark/test/resolve-attributes.test.ts
+++ b/packages/comark/test/resolve-attributes.test.ts
@@ -129,6 +129,21 @@ describe('HTML sink props', () => {
     expect(result).toEqual({ id: 'keep' })
   })
 
+  it('drops outerHTML with any casing and with the :binding prefix', () => {
+    // Vue sets `outerHTML` as a DOM property on HTML elements, which parses
+    // the value as markup once the element is attached.
+    const result = resolveAttributes(
+      {
+        outerHTML: '<img src=x onerror=alert(1)>',
+        ':OuterHtml': '"<img src=x onerror=alert(1)>"',
+        title: 'safe',
+      },
+      makeRenderData(),
+      { parseJson: true }
+    )
+    expect(result).toEqual({ title: 'safe' })
+  })
+
   it('drops sink props behind Vue `.prop` / `^attr` prefixes', () => {
     const result = resolveAttributes(
       { '.innerHTML': '<img src=x>', '^textContent': 'overlay', ':.innerHTML': '"<img src=x>"', '.title': 'keep' },
diff --git a/packages/comark/test/svg-case.test.ts b/packages/comark/test/svg-case.test.ts
new file mode 100644
index 000000000..68c1d556f
--- /dev/null
+++ b/packages/comark/test/svg-case.test.ts
@@ -0,0 +1,149 @@
+import { describe, expect, it } from 'vitest'
+import { parseMarkdown } from '../src/parse'
+import security from '../src/plugins/security'
+import { renderMarkdown, resolveAttributes } from '../src/render'
+import type { ElementNode, Node } from '../src/types'
+
+/**
+ * Tag and attribute names share one rule: an all-uppercase name is lowercased
+ * (`DIV`, `HREF`), any other name keeps the author's case. That keeps SVG and
+ * MathML names (`viewBox`, `linearGradient`) and component props (`someProp`)
+ * intact (#467).
+ *
+ * `stripMeta` drops the `$` metadata and `findElement` skips paragraph
+ * wrappers, so these tests check names and attributes, not tree layout.
+ */
+
+function stripMeta(node: Node): unknown {
+  if (!Array.isArray(node) || node[0] === null) return node
+  const [tag, attrs, ...children] = node as ElementNode
+  const { $: _meta, ...rest } = attrs as Record<string, unknown>
+  return [tag, rest, ...children.map(stripMeta)]
+}
+
+function findElement(nodes: Node[], tag: string): ElementNode | undefined {
+  for (const node of nodes) {
+    if (!Array.isArray(node) || node[0] === null) continue
+    if (node[0] === tag) return node as ElementNode
+    const found = findElement(node.slice(2) as Node[], tag)
+    if (found) return found
+  }
+  return undefined
+}
+
+async function parseElement(markdown: string, tag: string): Promise<unknown> {
+  const { nodes } = await parseMarkdown(markdown)
+  const element = findElement(nodes, tag)
+  expect(element, `expected a <${tag}> element in ${JSON.stringify(nodes)}`).toBeDefined()
+  return stripMeta(element!)
+}
+
+describe('HTML name case', () => {
+  it.each([
+    ['inline', 'x <svg viewBox="0 0 10 10"><linearGradient id="g"></linearGradient></svg>'],
+    ['block', '<svg viewBox="0 0 10 10">\n  <linearGradient id="g"></linearGradient>\n</svg>'],
+  ])('keeps SVG element and attribute names (%s)', async (_, markdown) => {
+    expect(await parseElement(markdown, 'svg')).toEqual([
+      'svg',
+      { viewBox: '0 0 10 10' },
+      ['linearGradient', { id: 'g' }],
+    ])
+  })
+
+  it('keeps SVG animation attribute names', async () => {
+    expect(
+      await parseElement('<svg><animate attributeName="opacity" repeatCount="indefinite"/></svg>', 'animate')
+    ).toEqual(['animate', { attributeName: 'opacity', repeatCount: 'indefinite' }])
+  })
+
+  it('keeps MathML attribute names', async () => {
+    expect(await parseElement('<math displayStyle="true"><mrow></mrow></math>', 'math')).toEqual([
+      'math',
+      { displayStyle: 'true' },
+      ['mrow', {}],
+    ])
+  })
+
+  it('keeps camelCase props on components', async () => {
+    expect(await parseElement('<MyCard someProp="x" CLASS="c">hi</MyCard>', 'MyCard')).toEqual([
+      'MyCard',
+      { someProp: 'x', class: 'c' },
+      'hi',
+    ])
+  })
+
+  it.each([
+    ['inline', 'x <DIV CLASS="x" DATA-FOO="1">World</DIV>'],
+    ['block', '<DIV CLASS="x" DATA-FOO="1">\nWorld\n</DIV>'],
+  ])('lowercases all-uppercase names (%s)', async (_, markdown) => {
+    expect(await parseElement(markdown, 'div')).toEqual(['div', { class: 'x', 'data-foo': '1' }, 'World'])
+  })
+
+  it('lowercases an all-uppercase SVG name (no SVG name table)', async () => {
+    expect(await parseElement('<SVG VIEWBOX="0 0 1 1"><LINEARGRADIENT></LINEARGRADIENT></SVG>', 'svg')).toEqual([
+      'svg',
+      { viewbox: '0 0 1 1' },
+      ['lineargradient', {}],
+    ])
+  })
+
+  it('matches the closing tag of a camelCase element case-insensitively', async () => {
+    // A mismatched close would leave <circle/> inside <linearGradient>.
+    expect(await parseElement('<svg><linearGradient id="g"></LINEARGRADIENT><circle r="1"/></svg>', 'svg')).toEqual([
+      'svg',
+      {},
+      ['linearGradient', { id: 'g' }],
+      ['circle', { r: '1' }],
+    ])
+  })
+
+  it.each([
+    ['inline HTML', 'x <a href="/safe" HREF="javascript:alert(1)">x</a>', 'a', { href: '/safe' }],
+    ['HTML block', '<div title="first" TITLE="second">\nx\n</div>', 'div', { title: 'first' }],
+    ['SVG', '<svg viewBox="0 0 1 1" viewbox="9 9 9 9"></svg>', 'svg', { viewBox: '0 0 1 1' }],
+  ])('keeps the first of case-variant duplicate attributes (%s)', async (_, markdown, tag, attrs) => {
+    // Browsers keep the first one. If the last won, a later `HREF` could
+    // replace a value that a sanitizer already checked.
+    expect(((await parseElement(markdown, tag)) as ElementNode)[1]).toEqual(attrs)
+  })
+})
+
+describe('security with case-preserved names', () => {
+  it('does not forward DOM property sinks to renderers', async () => {
+    // Vue sets `outerHTML` as a DOM property, so the renderer floor drops it
+    // whatever its case.
+    const { nodes } = await parseMarkdown('<svg outerHTML="<img src=x onerror=alert(1)>" title="t"></svg>')
+    const svg = findElement(nodes, 'svg')!
+    expect(svg[1].outerHTML).toBeDefined()
+    const renderData = { frontmatter: {}, meta: {}, data: {}, props: {} }
+    expect(resolveAttributes(svg[1], renderData, { parseJson: true })).toEqual({ title: 't' })
+  })
+
+  it.each([
+    ['outerHTML', '<svg outerHTML="<img src=x onerror=alert(1)>" viewBox="0 0 1 1"></svg>'],
+    ['onLoad', '<svg onLoad="alert(1)" viewBox="0 0 1 1"></svg>'],
+    ['onClick on a child', '<svg viewBox="0 0 1 1"><circle onClick="alert(1)"/></svg>'],
+    ['Href with javascript:', '<svg viewBox="0 0 1 1"><a Href="javascript:alert(1)"></a></svg>'],
+  ])('drops case-preserved %s with the security plugin', async (_, markdown) => {
+    const { nodes } = await parseMarkdown(markdown, { plugins: [security()] })
+    const svg = stripMeta(findElement(nodes, 'svg')!) as ElementNode
+    expect(svg[1]).toEqual({ viewBox: '0 0 1 1' })
+    if (svg[2]) expect((svg[2] as ElementNode)[1]).toEqual({})
+  })
+})
+
+describe('round trip', () => {
+  it.each([
+    ['inline', 'x <svg viewBox="0 0 10 10"><linearGradient id="g"></linearGradient></svg>'],
+    ['block', '<svg viewBox="0 0 10 10">\n<linearGradient id="g"></linearGradient>\n</svg>'],
+  ])('keeps SVG casing through renderMarkdown (%s)', async (_, markdown) => {
+    const document = await parseMarkdown(markdown)
+    const output = await renderMarkdown(document)
+    // Check the text: a fixed-point check alone also passes when both
+    // parses lowercase the names.
+    expect(output).toContain('viewBox="0 0 10 10"')
+    expect(output).toContain('<linearGradient id="g"></linearGradient>')
+    const reparsed = await parseMarkdown(output)
+    expect(reparsed.nodes).toEqual(document.nodes)
+  })
+})