index.js

/**
 * @import {Handle} from 'mdast-util-to-markdown'
 * @import {BlockContent, List, PhrasingContent, Root} from 'mdast'
 */

import assert from 'node:assert/strict'
import test from 'node:test'
import {removePosition} from 'unist-util-remove-position'
import {fromMarkdown as from} from 'mdast-util-from-markdown'
import {toMarkdown as to} from 'mdast-util-to-markdown'

test('core', async function (t) {
  await t.test('should expose the public api', async function () {
    assert.deepEqual(
      Object.keys(await import('mdast-util-to-markdown')).sort(),
      ['defaultHandlers', 'toMarkdown']
    )
  })

  await t.test('should support a `root`', async function () {
    assert.equal(
      to({
        type: 'root',
        children: [
          {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
          {type: 'thematicBreak'},
          {type: 'paragraph', children: [{type: 'text', value: 'b'}]}
        ]
      }),
      'a\n\n***\n\nb\n'
    )
  })

  await t.test(
    'should not use blank lines between nodes when given phrasing',
    async function () {
      assert.equal(
        to({
          type: 'root',
          children: [
            {type: 'text', value: 'a'},
            {type: 'break'},
            {type: 'text', value: 'b'}
          ]
        }),
        'a\\\nb\n'
      )
    }
  )

  await t.test('should support adjacent definitions', async function () {
    assert.equal(
      to({
        type: 'root',
        children: [
          {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
          {type: 'definition', identifier: 'b', url: ''},
          {type: 'definition', identifier: 'c', url: ''},
          {type: 'paragraph', children: [{type: 'text', value: 'd'}]}
        ]
      }),
      'a\n\n[b]: <>\n\n[c]: <>\n\nd\n'
    )
  })

  await t.test(
    'should support tight adjacent definitions when `tightDefinitions: true`',
    async function () {
      assert.equal(
        to(
          {
            type: 'root',
            children: [
              {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
              {type: 'definition', identifier: 'b', url: ''},
              {type: 'definition', identifier: 'c', url: ''},
              {type: 'paragraph', children: [{type: 'text', value: 'd'}]}
            ]
          },
          {tightDefinitions: true}
        ),
        'a\n\n[b]: <>\n[c]: <>\n\nd\n'
      )
    }
  )

  await t.test(
    'should use a different marker for adjacent lists',
    async function () {
      assert.equal(
        to({
          type: 'root',
          children: [
            {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
            {type: 'list', children: [{type: 'listItem', children: []}]},
            {type: 'list', children: [{type: 'listItem', children: []}]},
            {
              type: 'list',
              ordered: true,
              children: [{type: 'listItem', children: []}]
            },
            {
              type: 'list',
              ordered: true,
              children: [{type: 'listItem', children: []}]
            },
            {type: 'paragraph', children: [{type: 'text', value: 'd'}]}
          ]
        }),
        'a\n\n*\n\n-\n\n1.\n\n1)\n\nd\n'
      )
    }
  )

  await t.test(
    'should inject HTML comments between lists and an indented code',
    async function () {
      assert.equal(
        to(
          {
            type: 'root',
            children: [
              {type: 'code', value: 'a'},
              {type: 'list', children: [{type: 'listItem', children: []}]},
              {type: 'code', value: 'b'}
            ]
          },
          {fences: false}
        ),
        '    a\n\n*\n\n<!---->\n\n    b\n'
      )
    }
  )

  await t.test(
    'should inject HTML comments between adjacent indented code',
    async function () {
      assert.equal(
        to(
          {
            type: 'root',
            children: [
              {type: 'code', value: 'a'},
              {type: 'code', value: 'b'}
            ]
          },
          {fences: false}
        ),
        '    a\n\n<!---->\n\n    b\n'
      )
    }
  )

  await t.test(
    'should not honour `spread: false` for two paragraphs',
    async function () {
      assert.equal(
        to({
          type: 'listItem',
          spread: false,
          children: [
            {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
            {type: 'paragraph', children: [{type: 'text', value: 'b'}]}
          ]
        }),
        '* a\n\n  b\n'
      )
    }
  )

  await t.test(
    'should not honour `spread: false` for a paragraph and a definition',
    async function () {
      assert.equal(
        to({
          type: 'listItem',
          spread: false,
          children: [
            {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
            {type: 'definition', identifier: 'b', label: 'c', url: 'd'}
          ]
        }),
        '* a\n\n  [c]: d\n'
      )
    }
  )

  await t.test(
    'should honour `spread: false` for a paragraph and a heading',
    async function () {
      assert.equal(
        to({
          type: 'listItem',
          spread: false,
          children: [
            {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
            {type: 'heading', depth: 1, children: [{type: 'text', value: 'b'}]}
          ]
        }),
        '* a\n  # b\n'
      )
    }
  )

  await t.test(
    'should not honour `spread: false` for a paragraph and a setext heading',
    async function () {
      assert.equal(
        to(
          {
            type: 'listItem',
            spread: false,
            children: [
              {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
              {
                type: 'heading',
                depth: 1,
                children: [{type: 'text', value: 'b'}]
              }
            ]
          },
          {setext: true}
        ),
        '* a\n\n  b\n  =\n'
      )
    }
  )

  await t.test('should throw on a non-node', async function () {
    assert.throws(function () {
      // @ts-expect-error: check how the runtime handles a non-object.
      to(false)
    }, /Cannot handle value `false`, expected node/)
  })

  await t.test('should throw on an unknown node', async function () {
    assert.throws(function () {
      // @ts-expect-error: check how the runtime handles an unknown node.
      to({type: 'unknown'})
    }, /Cannot handle unknown node `unknown`/)
  })

  await t.test('should throw on an unknown node in a tree', async function () {
    assert.throws(function () {
      to({
        type: 'paragraph',
        // @ts-expect-error: check how the runtime handles an unknown child.
        children: [{type: 'text', value: 'a'}, {type: 'unknown'}]
      })
    }, /Cannot handle unknown node `unknown`/)
  })
})

test('blockquote', async function (t) {
  await t.test('should support a block quote', async function () {
    // @ts-expect-error: check how the runtime handles `children` missing.
    assert.equal(to({type: 'blockquote'}), '>\n')
  })

  await t.test('should support a block quote w/ a child', async function () {
    assert.equal(
      to({
        type: 'blockquote',
        children: [{type: 'paragraph', children: [{type: 'text', value: 'a'}]}]
      }),
      '> a\n'
    )
  })

  await t.test('should support a block quote w/ children', async function () {
    assert.equal(
      to({
        type: 'blockquote',
        children: [
          {type: 'paragraph', children: [{type: 'text', value: 'a'}]},
          {type: 'thematicBreak'},
          {type: 'paragraph', children: [{type: 'text', value: 'b'}]}
        ]
      }),
      '> a\n>\n> ***\n>\n> b\n'
    )
  })

  await t.test(
    'should support text w/ a line ending in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {type: 'paragraph', children: [{type: 'text', value: 'a\nb'}]}
          ]
        }),
        '> a\n> b\n'
      )
    }
  )

  await t.test(
    'should support adjacent texts in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {
              type: 'paragraph',
              children: [
                {type: 'text', value: 'a'},
                {type: 'text', value: 'b'}
              ]
            }
          ]
        }),
        '> ab\n'
      )
    }
  )

  await t.test(
    'should support a block quote in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {
              type: 'paragraph',
              children: [{type: 'text', value: 'a\nb'}]
            },
            {
              type: 'blockquote',
              children: [
                {
                  type: 'paragraph',
                  children: [
                    {type: 'text', value: 'a\n'},
                    {type: 'inlineCode', value: 'b\nc'},
                    {type: 'text', value: '\nd'}
                  ]
                },
                {
                  type: 'heading',
                  depth: 1,
                  children: [{type: 'text', value: 'a b'}]
                }
              ]
            }
          ]
        }),
        '> a\n> b\n>\n> > a\n> > `b\n> > c`\n> > d\n> >\n> > # a b\n'
      )
    }
  )

  await t.test('should support a break in a block quote', async function () {
    assert.equal(
      to({
        type: 'blockquote',
        children: [
          {
            type: 'paragraph',
            children: [
              {type: 'text', value: 'a'},
              {type: 'break'},
              {type: 'text', value: 'b'}
            ]
          }
        ]
      }),
      '> a\\\n> b\n'
    )
  })

  await t.test(
    'should support code (flow, indented) in a block quote',
    async function () {
      assert.equal(
        to(
          {
            type: 'blockquote',
            children: [{type: 'code', value: 'a\nb\n\nc'}]
          },
          {fences: false}
        ),
        '>     a\n>     b\n>\n>     c\n'
      )
    }
  )

  await t.test(
    'should support code (flow, fenced) in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [{type: 'code', lang: 'a\nb', value: 'c\nd\n\ne'}]
        }),
        '> ```a&#xA;b\n> c\n> d\n>\n> e\n> ```\n'
      )
    }
  )

  await t.test(
    'should support code (text) in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {
              type: 'paragraph',
              children: [
                {type: 'text', value: 'a\n'},
                {type: 'inlineCode', value: 'b\nc'},
                {type: 'text', value: '\nd'}
              ]
            }
          ]
        }),
        '> a\n> `b\n> c`\n> d\n'
      )
    }
  )

  await t.test(
    'should support padded code (text) in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {
              type: 'paragraph',
              children: [
                {type: 'text', value: 'a\n'},
                {type: 'inlineCode', value: ' b\nc '},
                {type: 'text', value: '\nd'}
              ]
            }
          ]
        }),
        '> a\n> `  b\n> c  `\n> d\n'
      )
    }
  )

  await t.test(
    'should support a definition in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {
              type: 'definition',
              identifier: 'a\nb',
              url: 'c\nd',
              title: 'e\nf'
            },
            {
              type: 'paragraph',
              children: [{type: 'text', value: 'a\nb'}]
            }
          ]
        }),
        '> [a\n> b]: <c&#xA;d> "e\n> f"\n>\n> a\n> b\n'
      )
    }
  )

  await t.test(
    'should support an emphasis in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {
              type: 'paragraph',
              children: [
                {type: 'text', value: 'a\n'},
                {type: 'emphasis', children: [{type: 'text', value: 'c\nd'}]},
                {type: 'text', value: '\nd'}
              ]
            }
          ]
        }),
        '> a\n> *c\n> d*\n> d\n'
      )
    }
  )

  await t.test(
    'should support a heading (atx) in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {
              type: 'heading',
              depth: 3,
              children: [{type: 'text', value: 'a\nb'}]
            }
          ]
        }),
        '> ### a&#xA;b\n'
      )
    }
  )

  await t.test(
    'should support a heading (setext) in a block quote',
    async function () {
      assert.equal(
        to(
          {
            type: 'blockquote',
            children: [
              {
                type: 'heading',
                depth: 1,
                children: [{type: 'text', value: 'a\nb'}]
              }
            ]
          },
          {setext: true}
        ),
        '> a\n> b\n> =\n'
      )
    }
  )

  await t.test(
    'should support html (flow) in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [{type: 'html', value: '<div\nhidden>'}]
        }),
        '> <div\n> hidden>\n'
      )
    }
  )

  await t.test(
    'should support html (text) in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {
              type: 'paragraph',
              children: [
                {type: 'text', value: 'a '},
                {type: 'html', value: '<span\nhidden>'},
                {type: 'text', value: '\nb'}
              ]
            }
          ]
        }),
        '> a <span\n> hidden>\n> b\n'
      )
    }
  )

  await t.test(
    'should support an image (resource) in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {
              type: 'paragraph',
              children: [
                {type: 'text', value: 'a\n'},
                {type: 'image', url: 'b\nc', alt: 'd\ne', title: 'f\ng'},
                {type: 'text', value: '\nh'}
              ]
            }
          ]
        }),
        '> a\n> ![d\n> e](<b&#xA;c> "f\n> g")\n> h\n'
      )
    }
  )

  await t.test(
    'should support an image (reference) in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {
              type: 'paragraph',
              children: [
                {type: 'text', value: 'a\n'},
                {
                  type: 'imageReference',
                  alt: 'b\nc',
                  label: 'd\ne',
                  identifier: 'f',
                  referenceType: 'collapsed'
                },
                {type: 'text', value: '\ng'}
              ]
            }
          ]
        }),
        '> a\n> ![b\n> c][d\n> e]\n> g\n'
      )
    }
  )

  await t.test(
    'should support a link (resource) in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {
              type: 'paragraph',
              children: [
                {type: 'text', value: 'a\n'},
                {
                  type: 'link',
                  url: 'b\nc',
                  children: [{type: 'text', value: 'd\ne'}],
                  title: 'f\ng'
                },
                {type: 'text', value: '\nh'}
              ]
            }
          ]
        }),
        '> a\n> [d\n> e](<b&#xA;c> "f\n> g")\n> h\n'
      )
    }
  )

  await t.test(
    'should support a link (reference) in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [
            {
              type: 'paragraph',
              children: [
                {type: 'text', value: 'a\n'},
                {
                  type: 'linkReference',
                  children: [{type: 'text', value: 'b\nc'}],
                  label: 'd\ne',
                  identifier: 'f',
                  referenceType: 'collapsed'
                },
                {type: 'text', value: '\ng'}
              ]
            }
          ]
        }),
        '> a\n> [b\n> c][d\n> e]\n> g\n'
      )
    }
  )

  await t.test('should support a list in a block quote', async function () {
    assert.equal(
      to({
        type: 'blockquote',
        children: [
          {
            type: 'paragraph',
            children: [{type: 'text', value: 'a\nb'}]
          },
          {
            type: 'list',
            children: [
              {
                type: 'listItem',
                children: [
                  {type: 'paragraph', children: [{type: 'text', value: 'c\nd'}]}
                ]
              },
              {
                type: 'listItem',
                children: [{type: 'thematicBreak'}]
              },
              {
                type: 'listItem',
                children: [
                  {type: 'paragraph', children: [{type: 'text', value: 'e\nf'}]}
                ]
              }
            ]
          }
        ]
      }),
      '> a\n> b\n>\n> - c\n>   d\n>\n> - ***\n>\n> - e\n>   f\n'
    )
  })

  await t.test('should support a strong in a block quote', async function () {
    assert.equal(
      to({
        type: 'blockquote',
        children: [
          {
            type: 'paragraph',
            children: [
              {type: 'text', value: 'a\n'},
              {type: 'strong', children: [{type: 'text', value: 'c\nd'}]},
              {type: 'text', value: '\nd'}
            ]
          }
        ]
      }),
      '> a\n> **c\n> d**\n> d\n'
    )
  })

  await t.test(
    'should support a thematic break in a block quote',
    async function () {
      assert.equal(
        to({
          type: 'blockquote',
          children: [{type: 'thematicBreak'}, {type: 'thematicBreak'}]
        }),
        '> ***\n>\n> ***\n'
      )
    }
  )
})

test('break', async function (t) {
  await t.test('should support a break', async function () {
    assert.equal(to({type: 'break'}), '\\\n')
  })

  await t.test(
    'should serialize breaks in heading (atx) as a space',
    async function () {
      assert.equal(
        to({
          type: 'heading',
          depth: 3,
          children: [
            {type: 'text', value: 'a'},
            {type: 'break'},
            {type: 'text', value: 'b'}
          ]
        }),
        '### a b\n'
      )
    }
  )

  await t.test(
    'should serialize breaks in heading (atx) as a space',
    async function () {
      assert.equal(
        to({
          type: 'heading',
          depth: 3,
          children: [
            {type: 'text', value: 'a '},
            {type: 'break'},
            {type: 'text', value: 'b'}
          ]
        }),
        '### a b\n'
      )
    }
  )

  await t.test(
    'should serialize breaks in heading (setext)',
    async function () {
      assert.equal(to(from('a  \nb\n=\n'), {setext: true}), 'a\\\nb\n=\n')
    }
  )
})

test('code (flow)', async function (t) {
  await t.test('should support empty code', async function () {
    // @ts-expect-error: check how the runtime handles `value` missing.
    assert.equal(to({type: 'code'}), '```\n```\n')
  })

  await t.test(
    'should throw on when given an incorrect `fence`',
    async function () {
      assert.throws(function () {
        // @ts-expect-error: check how the runtime handles an incorrect `fence` marker.
        to({type: 'code', value: ''}, {fence: '+'})
      }, /Cannot serialize code with `\+` for `options\.fence`, expected `` ` `` or `~`/)
    }
  )

  await t.test('should support code w/ a value (indent)', async function () {
    assert.equal(to({type: 'code', value: 'a'}, {fences: false}), '    a\n')
  })

  await t.test('should support code w/ a value (fences)', async function () {
    assert.equal(to({type: 'code', value: 'a'}), '```\na\n```\n')
  })

  await t.test('should support code w/ a lang', async function () {
    assert.equal(to({type: 'code', lang: 'a', value: ''}), '```a\n```\n')
  })

  await t.test(
    'should support (ignore) code w/ only a meta',
    async function () {
      assert.equal(to({type: 'code', meta: 'a', value: ''}), '```\n```\n')
    }
  )

  await t.test('should support code w/ lang and meta', async function () {
    assert.equal(
      to({type: 'code', lang: 'a', meta: 'b', value: ''}),
      '```a b\n```\n'
    )
  })

  await t.test('should encode a space in `lang`', async function () {
    assert.equal(
      to({type: 'code', lang: 'a b', value: ''}),
      '```a&#x20;b\n```\n'
    )
  })

  await t.test('should encode a line ending in `lang`', async function () {
    assert.equal(
      to({type: 'code', lang: 'a\nb', value: ''}),
      '```a&#xA;b\n```\n'
    )
  })

  await t.test('should encode a grave accent in `lang`', async function () {
    assert.equal(
      to({type: 'code', lang: 'a`b', value: ''}),
      '```a&#x60;b\n```\n'
    )
  })

  await t.test('should escape a backslash in `lang`', async function () {
    assert.equal(
      to({type: 'code', lang: 'a\\-b', value: ''}),
      '```a\\\\-b\n```\n'
    )
  })

  await t.test('should not encode a space in `meta`', async function () {
    assert.equal(
      to({type: 'code', lang: 'x', meta: 'a b', value: ''}),
      '```x a b\n```\n'
    )
  })

  await t.test('should encode a line ending in `meta`', async function () {
    assert.equal(
      to({type: 'code', lang: 'x', meta: 'a\nb', value: ''}),
      '```x a&#xA;b\n```\n'
    )
  })

  await t.test('should encode a grave accent in `meta`', async function () {
    assert.equal(
      to({type: 'code', lang: 'x', meta: 'a`b', value: ''}),
      '```x a&#x60;b\n```\n'
    )
  })

  await t.test('should escape a backslash in `meta`', async function () {
    assert.equal(
      to({type: 'code', lang: 'x', meta: 'a\\-b', value: ''}),
      '```x a\\\\-b\n```\n'
    )
  })

  await t.test(
    'should support fenced code w/ tildes when `fence: "~"`',
    async function () {
      assert.equal(to({type: 'code', value: ''}, {fence: '~'}), '~~~\n~~~\n')
    }
  )

  await t.test(
    'should not encode a grave accent when using tildes for fences',
    async function () {
      assert.equal(
        to({type: 'code', lang: 'a`b', value: ''}, {fence: '~'}),
        '~~~a`b\n~~~\n'
      )
    }
  )

  await t.test(
    'should use more grave accents for fences if there are streaks of grave accents in the value (fences)',
    async function () {
      assert.equal(
        to({type: 'code', value: '```\nasd\n```'}),
        '````\n```\nasd\n```\n````\n'
      )
    }
  )

  await t.test(
    'should use more tildes for fences if there are streaks of tildes in the value (fences)',
    async function () {
      assert.equal(
        to({type: 'code', value: '~~~\nasd\n~~~'}, {fence: '~'}),
        '~~~~\n~~~\nasd\n~~~\n~~~~\n'
      )
    }
  )

  await t.test('should use a fence if there is an info', async function () {
    assert.equal(to({type: 'code', lang: 'a', value: 'b'}), '```a\nb\n```\n')
  })

  await t.test(
    'should use a fence if there is only whitespace',
    async function () {
      assert.equal(to({type: 'code', value: ' '}), '```\n \n```\n')
    }
  )

  await t.test(
    'should use a fence if there first line is blank (void)',
    async function () {
      assert.equal(to({type: 'code', value: '\na'}), '```\n\na\n```\n')
    }
  )

  await t.test(
    'should use a fence if there first line is blank (filled)',
    async function () {
      assert.equal(to({type: 'code', value: ' \na'}), '```\n \na\n```\n')
    }
  )

  await t.test(
    'should use a fence if there last line is blank (void)',
    async function () {
      assert.equal(to({type: 'code', value: 'a\n'}), '```\na\n\n```\n')
    }
  )

  await t.test(
    'should use a fence if there last line is blank (filled)',
    async function () {
      assert.equal(to({type: 'code', value: 'a\n '}), '```\na\n \n```\n')
    }
  )

  await t.test(
    'should use an indent if the value is indented',
    async function () {
      assert.equal(
        to({type: 'code', value: '  a\n\n b'}, {fences: false}),
        '      a\n\n     b\n'
      )
    }
  )
})

test('definition', async function (t) {
  await t.test('should support a definition w/o label', async function () {
    assert.equal(
      // @ts-expect-error: check how the runtime handles `identifier`, `url` missing.
      to({type: 'definition'}),
      '[]: <>\n'
    )
  })

  await t.test('should support a definition w/ label', async function () {
    assert.equal(
      // @ts-expect-error: check how the runtime handles `identifier` missing.
      to({type: 'definition', label: 'a', url: ''}),
      '[a]: <>\n'
    )
  })

  await t.test('should escape a backslash in `label`', async function () {
    assert.equal(
      // @ts-expect-error: check how the runtime handles `identifier` missing.
      to({type: 'definition', label: '\\', url: ''}),
      '[\\\\]: <>\n'
    )