prosemirror / prosemirror-markdown

ProseMirror Markdown integration

prosemirror

[ WEBSITE | ISSUES | FORUM ]

ProseMirror is a well-behaved rich semantic content editor based on contentEditable, with support for collaborative editing and custom document schemas.

The ProseMirror library consists of a number of separate modules. This repository just serves as a central issue tracker, and holds a script to help easily check out all the core modules for development.

The project page has more information, a number of examples and the documentation.

This code is released under an MIT license. There's a forum for general discussion and support requests, and the Github bug tracker is the place to report issues.

STOP READING HERE IF YOU'RE SIMPLY USING PROSEMIRROR. YOU CAN INSTALL THE SEPARATE NPM MODULES FOR THAT. THE INSTRUCTIONS BELOW ONLY APPLY WHEN DEVELOPING PROSEMIRROR!

Setting up a dev environment

Clone this repository, and make sure you have node and yarn (due to a string of issues with NPM 5, NPM is not currently supported) installed. Next, from the cloned directory run:

bin/pm install

This will fetch the submodules, install their dependencies, and build them.

The bin/pm script in this repository provides functionality for working with the repositories:

• bin/pm build rebuilds all the modules

• bin/pm watch sets up a process that automatically rebuilds the modules when they change

• bin/pm status prints the git status of all submodules

• bin/pm commit <args> runs git commit with the given arguments in all submodules that have pending changes

• bin/pm test runs the (non-browser) tests in all modules

• bin/pm push runs git push in all modules

• bin/pm grep <pattern> greps through the source code for the modules for the given pattern

• bin/pm dev-start starts a server that rebuilds the packages whenever their sources change, and exposes the demo (demo/*) under a webserver on port 8080

(Functionality for managing releases will be added in the future.)

Community

Development of ProseMirror happens in the various repositories exposed under the ProseMirror organization on GitHub. Bugs for core packages are tracked in the bug tracker for the meta repository.

We aim to be an inclusive, welcoming community. To make that explicit, we have a code of conduct that applies to communication around the project.

prosemirror-markdown's Issues

Markdown parser does not correctly handle marks around inline nodes

I expanded the schema and markdown-it with a new type of node with markup that looks like this: $$[text]. This is an inline node and NOT a mark because these nodes need to be able to be placed next to each other (e.g. $$[textOne]$$[textTwo]).

If I then try to use a mark, such as strong, in a paragraph surrounding my new node, the parser stops the mark after my custom node.

For example, this markdown: **here is some text $$[exampleText] some more text**

Becomes incorrectly parsed and rendered into something like this: <strong>here is some text </strong><span class="myCustomClass"><strong>exampleText</strong></span> some more text

I am using parsemirror-markdown version 1.8.0 according to npm.

Unneeded escaping of colons at the start of a line

From: nextcloud/text#969

The common mark specs only have a special usage for colons used after a link mark for Link reference and they are only used by extended markdown for definition lists, not part of the specification.
But currently colons at the start of a line are escaped even if there is no reason for it.
This leads to problems if you use extended markdown (e.g. vimwiki) where tags start with a colon.

A better solution would be to allow configure escaping : or not (e.g. remove the escaping so if you need it you could add it to escapeExtraCharacters).

Support for restricted HTML

Many Markdown renderers such as GitHub, or VS Code, allow a restricted subset of HTML syntax in the Markdown they support. Besides allowing for a few formatting options and tags that are missing from basic Markdown, this also makes markdown-it properly identify stuff like HTML comments, as otherwise they are passed though as text into the editor.

I think they do so by running an HTML sanitizer on rendered HTML of the Markdown, rather than doing something at the parser/tokens level.

For parity with such Markdown files, is there any reasonable way to support such things using prosemirror-markdown? While remaining safe from any XSS of course.

Markdown-It dependency

Hello! I've got a couple of questions.

Is there any reason to have ^6.0.4 instead of latest version of markdown-it?

And if there is no reasons why not update the dependency?

Escaping underscore breaks link URLs that contain this character

Version

1.6.1

What is the problem?

When serializing a document, Prosemirror-markdown breaks links with URLs that that contain underscore characters. The change was introduced in: 9915597

How to reproduce

The following sandbox contains a reproducible script: https://codesandbox.io/s/broken-links-prosemirror-markdown-r9ez0

Serializer does not escape '>' at start of line

Details

Markdown serializer currently does not escape a greater-than character > occurring at start of line.

Version

prosemirror-markdown 1.5.1
Can be reproduced with markdown example.

Steps to reprocude

1. Insert line starting with > in WYSIWYM mode.
2. Switch mode to markdown.
3. > character is not escaped.
4. Switch back to WYSIWYM.
5. Line is now unintentionally quoted.

Expected result:

> character at start of line is escaped as \> during markdown serialization.

Hard line breaks always also add newline

I noticed that hard line breaks always add a newline character, which breaks stuff when set `preserveWhitespaces: 'full'´ for paragraphs.

Consider this:

*foo\
bar*

will result in

<p><em>foo<br \>
bar</em></p>

And then serialized as:

*foo \

 bar*

which results in this:

<p>*foo \</p>
<p>bar*</p>

---

My use case:
keep differences of markdown files after editing as small as possible, especially custom formatting (from external editors). E.g.:

foo
bar

without preserveWhitespaces: 'full' this would result in

foo bar

The rendered version would look the same, but the source file is different and may be harder to read.

Extend `noOpenClose`

When extending this library with other markdown-it extensions, I am having to extend the function noOpenClose(type) here:
https://github.com/ProseMirror/prosemirror-markdown/blob/master/src/from_markdown.js#L94

For example, in markdown-it-texmath the following blocks are needed:

type == 'math_inline' || type == 'math_inline_double' || type == 'math_block' || type == 'math_block_eqno'

I was wondering if it is worth passing an options into MarkdownParser that then goes to tokenHandlers, so that this can be done without forking the library?

Let me know if this would be wanted and I can put together a PR.

Empty paragraph is added before custom node

I 'm parsing git hub todo list (- [x]) to be replaced by a custom node. I've written a plugin to replace paragraphs with my custom node by just switching type on open and close tag:
tokens[i - 1].type = "app_todo_open"

That doesn't seem to be a problem since the output from Markdown-it looks correct. But when running through MarkdownParser it generates an extra paragraph node before every app_todo node.

So without the custom node I get:

<ul>
  <li>
    <p>[ ] Not done</p>
  </li>
</ul>

And with the custom node:

<ul>
  <li>
    <p><br/></p>
    <p class="todo">Not done</p>
  </li>
</ul>

Breaks are set to false and when running it through only the markdown-it renderer I get the expected result:

<ul>
  <li>Not done</li>
</ul>

Any ideas what can cause this?

HTML entity unescaping on parse can lead to unexpected results on serialize

markdown-it currently parses HTML entities into text, this leads to weird side effects on a parse/serialize cycle.

1. <b>Not Bold<b> will parse into <b>Not Bold</b> and serialize as <b>Not Bold</b>, which leads to it being bold in Markdown parsers that do honor HTML (Or a subset thereof).
2. &nbsp&nbspFoo parses as Foo and serializes as Foo, but will parse back as Foo, as Markdown trims normal spaces. The same applies to trailing &nbsp, which might be further confused as an hard break.
3. Typing < into prosemirror, serializes as < but parses as <.

All of these behaviors can be seen here https://prosemirror.net/examples/markdown/ and switching between Markdown and WYSIWYM.

Wrong parsing of emphasis and strong emphasis formatting

From CommonMark example 431:

**foo *bar **baz**
bim* bop**

should be parsed as:

<p><strong>foo <em>bar <strong>baz</strong>
bim</em> bop</strong></p>

Using just markdown-it this works as expected but the defaultMarkdownParser creates this incorrect representation:

<p><strong>foo </strong><em><strong>bar baz</strong>
bim</em> bop</p>

Click to view line markdown source

Like https://laobubu.net/HyperMD/#README.md

Can this be achieved in prosemirror?

Editor removes line breaks when line starts with \ (backslash)

Issue details

Editor removes line breaks when line starts with \ (backslash)

Steps to reproduce

1. Open http://prosemirror.net/examples/markdown/
2. Select markdown mode
3. Type this text in textarea:

**Text** line 1
\- text line 2
\- text line 3
\- text line 4
\- text line 5
- text line 6

4. Switch to WYSIWYM
5. Try to edit text (e.g. try to add a space at line 2)
6. Now editor removed all linebreak for lines, that starts with \

ProseMirror version

ProseMirror example at http://prosemirror.net/examples/markdown/ (as of 27th July 2020)

Affected platforms

• Chrome
• Firefox
• Internet Explorer
• Other

Screenshots / Screencast (Optional)

) in URL is not escaped

From commonmark spec example 499:

This markdown:

[link](foo\)\:)

Results in this HTML:

<p><a href="foo):">link</a></p>

But it is then serialized to this invalid (different) markdown:

[link](foo):)

Note the not escaped ) character

Tight lists are not correctly rendered in the editor

I ran into a list-rendering-related inconsistency in ProseMirror. After digging around, I found #51 (TIL about "list tightness" in Markdown!), and the fix does seem to correctly detect the "hidden" attributes in Markdown-it's tokens and correctly attaches them on lists, but the then the (default) list rendering does not take these into account:

In the above screenshot, the left-hand side is plain Markdown-it, the right-hand side is ProseMirror. As evidenced by the data-tight="true" in the list DOM, the tightness is correctly detected but ignored on render.

This behavior can also be reproduced by the Friendly Markdown example on the website.

I tried looking into where this gets rendered (is it prosemirror-schema-list?) but arguably I'm still a bit new to ProseMirror's internals and couldn't quite get to it, would be happy to help to have this fixed.

Code Block in MarkDown

The Code block ``` is created right after the last back-tick. As it should convert after the space is entered. Thus if the user wants they can use ```js for getting syntax highlighting.

Escape of dots in list items

When there are dots, following a number, as text in list items they must be escaped.
Found by an user of the nextcloud text app: nextcloud/text#2480

---

E.g. consider this text:

Hello

• 1. world
• 2. world
• 3. world

which is based on this source code:

Hello
* 1\. world
* 2\. world
* 3\. world

But using the WYSIWYG editor it emits this markdown:

Hello
* 1. world
* 2. world
* 3. world

which results in:

Hello

• 1. world
• 2. world
• 3. world

See also this example:

markdown-it update to actual version (v12)

Hi!
Please upgrade markdown-it to the latest version.
Our project uses markdown-it version 12 and we have to use yarn resolutions

   "resolutions": {
     "markdown-it": "^12.3.0"
   }

Unnecessary escaping of plus sign?

The serializer currently escapes all plus signs, not just at the beginning of a line. Is this intentional, or an oversight? I can find no evidence in the spec that a plus sign is meaningful except as a bullet point list indicator. Other bullet point symbols (*,-) are already treated differently. Relevant lines:

https://github.com/eloquence/prosemirror-markdown/blob/master/src/to_markdown.js#L299-L300

One-word relative links are serialized as <autolinks>

Description

1. Have a one-word relative link in a document, where link text (relative) equals link destination (relative)
2. Serialize it into markdown
   Expected markdown: [relative](relative)
   Actual markdown: "<relative>", which is not valid CommonMark (see reference example https://spec.commonmark.org/dingus/?text=%3Crelative%3E)

Test case (via prosemirror-test-builders):

  it('should serialize relative links', () => {
    const {a} = builders(schema, {
      a: {markType: 'link', href: 'relative'}
    });

    const node = doc(paragraph(a('relative')));

    expect(markdownSerializer.serialize(node))
      .toEqual('[relative](relative)');
  });

Issue with hard breaks in headline

When adding a hard break Ctrl+Enter within a headline the markdown result is:

## asdf\
asdf

Which will be rendered as:

My workaround was to use the splitBlock command in the Ctrl+Enter keymap if the selection resides within a headline.

Handling of `softbreak` is weird

Currently prosemirror-markdown converts a softbreak to a \n in the text node, this seems to render as a line break when initially viewed, but is stripped away on the first edit of that text node. I think this is weird and unintuitive. How should this be handled better?

Serialization of code blocks introduce 'null' or 'undefined' textual content

Repro

http://prosemirror.net/demo/markdown.html

Copy/Paste content wrapped in a code blocks into the WYSIWYG editor.

Switch between WYSIWYG and Markdown mode.

Result

My HTML test content :

<pre><code>Text wrapped in code</code></pre>

Origin

https://github.com/ProseMirror/prosemirror-markdown/blob/master/src/to_markdown.js#L55

state.write("```" + node.attrs.params + "\n");

node.attrs.params may be null or undefined.

Add support for passing an extra env dictionary to the `MarkdownSerializer`

This is useful for serialization rules that need additional data or configuration that isn't part of the document.

Support passing in markdown-it `env`

markdown-it can receive an env object in its parse call that can be used to retrieve and pass in some information into the parser for some plugins and token types. It would be nice to be able to pass it in.

How to handle tables?

markdown-it doesn't output a paragraph_{open,close} token around a table cell's contents which causes it to be dropped with just:

  table: { block: "table" },
  tr: { block: "tableRow" },
  th: { block: "tableHeader" },
  td: { block: "tableCell" },
  thead: { ignore: true },
  tbody: { ignore: true },

As there is only an inline inside the th and td but the schema I have specifies block+ for them, which means it should have a paragraph... Or is that invalid in Markdown and I should reconfigure the schema?

Backslash escapes are duplicated during serialization in some cases

Via ProseMirror/prosemirror#562:

It sounds like a feature, but it's a bug 🥇

Repro

http://prosemirror.net/demo/markdown.html

Type this into the Markdown editor

`~`

Switch between WYSIWYG and Markdown mode

Result

Escape ! character next to a link

! should be escaped if followed by a link, consider this:

Markdown: [Hello](https://example.com)
and then type a ! just before the link inside the WYSIWYG editor.

Expected result:
\![Hello](https://example.com)

Actual result:
![Hello](https://example.com)
(results in parsing as image -> invalid)

I try to visualize the problem:

From: nextcloud/text#931

Schema definition has duplicate entries

There are duplicate entries for ordered_list, bullet_list and list_item.

I also noticed that code_block serializing / deserializing deals with data attributes.

Escaping on serialization but not unescaping on parsing

defaultMarkdownSerializer escapes text, however there is no mention of unescaping in from_markdown.js.

If defaultMarkdownSerializer is given the input [ for example, it outputs \[.
If this is later fed into defaultMarkdownParser, the output is \[ when it should be [

Content is escaped but never unescaped resulting in documents accumulating more and more backslashes.
Surely this is not correct default behaviour?

bug in lists

In the demo, clear the plain textbox and type:

* item
* another item

Then switch to WYSIWYM, then switch back, and you'll see

* item

* another item

This means something completely different in markdown -- it's a list with lots of space between each entry.

As far as I can tell, there isn't a way to even make a bulleted list without lots of space between entries using the WYSIWYM mode.

---

View the difference via Github's Markdown Renderer:

• item
• another item

VERSUS

• item

• another item

Underscores are not escaped during serialization

Description

Underscores are not escaped by the MarkdownSerializer.

Steps to Reproduce

1. Enter "_test_" in the WYSIWYM view under https://prosemirror.net/examples/markdown/
2. Switch to markdown view.

Expected Behavior

The text in markdown view is "\_test\_". When we switch back to WYSIWYM view, the text there is still "_test_".

Actual Behavior

The text in markdown view is "_test_". When we switch back to WYSIWYM view, this is parsed to "test".

Further Notes

As far as I can tell, this line would merely have to be expanded so that the RegEx also matches _ characters.

Prosemirror Markdown example does weird things with code blocks

A video will show it better than words...

As you can see in the GIF, switching between code and no-code is very tricky. I kind-of understand why it happens (all has to do with the paragraphs in markdown), but actually is pretty confusing.

Problems are:

• If I have no text after a code block, I can't leave it without losing format in all lines.
• After returning to a paragraph block the different lines in the previous code block are shown separate, if I write anything else, the contiguous lines are put together in a single line.
• If I select various paragraphs, and set them to code block, it creates one code block per paragraph.

Solutions might be:

• If I press backspace in an empty codeblock line, transform the current line into a paragraph.
• If I transform a codeblock into a paragraph, put contiguous lines together immediately. If I do select a single line, transform that line into a paragraph and leave the rest as a codeblock.
• If I select various paragraphs, and transform them into a codeblock, create a single codeblock with them.

Option to set tight list style on document level

Currently one can set a tight attribute on a list node to control how it gets serialized. I have a use case where my nodes do not have such an attribute, but I would like to serialize all list nodes of the document using the tight style.
I haven't seen a way to control this on the document level. One way to allow this, would be to support an optional tightLists serializer option, which would be used as the default style if no tight attribute is set on a list node.

Code blocks after a list parsed as continuation of the list item

Originally submitted by @amkgo as ProseMirror/prosemirror#732

In the markdown example, the first line of the code block after list will change to a list when add a paragraph after list. See screen cast below.

Andrew

Improve markdown implementation for italic/bold handling (edge cases)

(Originally reported by @Mobiletainment as ProseMirror/prosemirror#730)

Issue details

When putting italic and bold text directly next to each other, there's a good chance that it gets interpreted wrongly due to weaknesses in markdown's italic and bold formatting.

Steps to reproduce

Take the following markdown for example:

*italic text directly next to ***bold text**

• Expected output: italic text directly next to bold text
• Actual output: *italic text directly next to *bold text

Please specify which version of ProseMirror you're running

ProseMirror v0.10.1
ProseMirror example at http://prosemirror.net/examples/markdown/ (as of 28th November 2017)

Affected platforms

• all

Screenshots / Screencast (Optional)

I tested this behavior with other markdown implementations and saw that this edge case is properly handled by some, e.g. pandoc: http://johnmacfarlane.net/babelmark2/?text=*italic+text+directly+next+to+***bold+text**

Wrongly escaped $ at the start of a line

We were investigating why a single line like

$50

was being serialized into the following markdown:

\$50

We discovered in to_markdown.js there's an esc() method which uses a regex to escape certain characters that could have special meaning at the start of a line, but the offending regex /^[:#-*+]/ contains a range #-* which provokes that $%&'() also be matched, which we assume wasn't your intention.

A simple fix would be move the - to the end or start or end of the character class, such as /^[-:#*+]/.

This commit appears to be where the bug was introduced.

Trailing/leading whitespace in emphasis/strong spans isn't serialized correctly

I.e. you'll end up with Markdown like foo * bar* which the Markdown parser won't actually recognize as emphasis because there's whitespace after the asterisk.

Originally reported here

Task list support

It would be useful to support the task list extension in the library (used by GitHUB and others). Happy to sponsor the time on the work if this is a feature the library would accept.

Here's the specification.

https://docs.github.com/en/github/managing-your-work-on-github/about-task-lists

- [x] Finish my changes
- [ ] Push my commits to GitHub
- [ ] Open a pull request

Link is split into multiple ones

From commonmark spec example 515:

[link *foo **bar** `#`*](/uri)

Which correctly results in:

<p><a href="/uri">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>

But the serialization of it using prosemirror-markdown results in this markdown which is definitely a different markdown:

[link ](/uri)*[foo](/uri) **[bar ](/uri)**[`#`](/uri)*

Ordered lists forced to start from "1" even if they have other numeration

Dear Contributors, thank you so much for mantaining this brilliant library.

I faced a small issue with it that I hope can be fixed relatively simple:

1. Have markdown like that (without "" symbols):

4. asdfasdf
5. asdfasdf

2. Check how it is interpreted by canonical markdown implementation
   

3. Check how it parses by prosemirror-markdown in this usage example:
   

markdown-it also respects this numeration as far as I see.

Thank you very much for investigating this!

Error: Package subpath './package.json' is not defined by "exports" in node_modules/w3c-keyname/package.json

rollup v2.22.1
bundles src/main.js → public/build/bundle.js...
[!] (plugin svelte) Error: Package subpath './package.json' is not defined by "exports" in /Users/user1/github/pm/frontend/svelte/prosermarkdown-editor/node_modules/w3c-keyname/package.json
Error [ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath './package.json' is not defined by "exports" in /Users/user1/github/pm/frontend/svelte/prosermarkdown-editor/node_modules/w3c-keyname/package.json
    at applyExports (internal/modules/cjs/loader.js:498:9)
    at resolveExports (internal/modules/cjs/loader.js:514:23)
    at Function.Module._findPath (internal/modules/cjs/loader.js:642:31)
    at Function.Module._resolveFilename (internal/modules/cjs/loader.js:1017:27)
    at Function.requireRelative.resolve (/Users/user1/github/pm/frontend/svelte/prosermarkdown-editor/node_modules/require-relative/index.js:30:17)
    at tryResolve (/Users/user1/github/pm/frontend/svelte/prosermarkdown-editor/node_modules/rollup-plugin-svelte/index.js:50:19)
    at Object.resolveId (/Users/user1/github/pm/frontend/svelte/prosermarkdown-editor/node_modules/rollup-plugin-svelte/index.js:177:21)
    at /Users/user1/github/pm/frontend/svelte/prosermarkdown-editor/node_modules/rollup/dist/shared/rollup.js:18264:25

node -v
v14.5.0

Adding images after spaces wraps image markdown in code block

When adding spaces before an image in the wysiwyg the image markdown will be wrapped in a code block. How could we escape such a case?

Escaping special markdown characters causes problems with links

Users are occasionally pasting links directly in the editor.

During serialization, the underscore character is escaped into \_. This causes problems later on when markdown is converted to HTML.

For example, https://miro.com/app/board/abc_def

becomes

https://miro.com/app/board/abc\_def

which later becomes an unusable link:

<a href="https://miro.com/app/board/abc\_def">https://miro.com/app/board/abc\_def</a> .

What would be the best way to handle this issue? Should links be detected before escaping text or maybe there is some other way?

Wrong argument type

Base on the document, Node.copy() method should accept a Fragment object, but maybeMerge gives it a string.

prosemirror-markdown/src/from_markdown.js

Lines 5 to 8 in 6e9b03a

	function maybeMerge(a, b) {
	if (a.isText && b.isText && Mark.sameSet(a.marks, b.marks))
	return a.copy(a.text + b.text)
	}

Serialize autolinks as <url> rather than [url](url)

• Original Markdown: <https://github.com/ProseMirror/prosemirror-markdown>
• Rendered HTML: <a href="https://github.com/ProseMirror/prosemirror-markdown">https://github.com/ProseMirror/prosemirror-markdown</a>
• Expected serialized Markdown: <https://github.com/ProseMirror/prosemirror-markdown>
• Actual serialized Markdown: [https://github.com/ProseMirror/prosemirror-markdown](https://github.com/ProseMirror/prosemirror-markdown)

I made an attempt at writing generic support for dynamic mark delimiters in an early iteration of #29, which would have made it relatively easy to fix this serialization as well, but that PR was ultimately replaced by 0448d32 which was specific to code marks but was much less complex.

in parser, allow spec to to read child info

A tag like <table> has an attribute, columns, which can only be known after child nodes have been parsed.

The following patch supports a handleClose function in a parser spec which could be used to add or update attrs to the node when its close tag has been reached. I'm posting here for feedback before submitting as a PR; this works for me but I'm not sure if there would be a better/preferred approach.

Patch:
https://github.com/mhuebert/prosemirror-markdown/tree/patch-1

Example usage:

{ // ...in token map...
  table: 
  { block: "table",
    handleClose: function (node) {
      // copy attrs from first child, which will be `thead`
      node.attrs = node.content[0].attrs
    }
  },
  thead: 
  { block: "table_header",
    handleClose: function (node) {
      // copy attrs from first child, which will be `tr`
      node.attrs = node.content[0].attrs
    }
  },
  tr: 
  { block: "table_row",
    handleClose: function (node) {
      // column count is equal to number of child nodes
      node.attrs = {columns: node.content.length}
    }
  }
 // ...
}

In the case of a table, we want the column attribute to 'bubble up' from tr elements, up to thead or tbody elements, and then finally the table itself. Copying the attr to the intermediate parents seems necessary so that we can enforce content constraints, eg. for a table body, "table_row[columns=.columns]+".

(Note that to support Github-style markdown tables, a different schema is required than what prosemirror-schema-table specifies, as table headers are required - it's not possible to have a table without <thead> and <th> elements.)

Whitespace at the start of paragraphs is stripped out by the parser

I noticed that whitespace is stripped out sometimes by the parser which is causing inconsistencies in our collaborative editor sessions.

I pulled down the latest version of prosemirror-markdown to my machine and added a unit test to showcase the issue.

master...sunsama:test/precedding-whitespace

I am not sure if there is some legacy markdown reasons for this or if this is a legit bug. Any guidance would be highly appreciated.

ProseMirror-Markdown Documents

Where can I find the prosemirror-markdown document/Reference manual?

Thanks,
Andrew

Fenced code blocks does not check for backticks

Fenced code blocks should check the content for any sequence of backticks, as CommonMark defines a code block to end with a sequence of backticks of at least the number it started.

Meaning this is perfectly valid markdown:

````
```
code
```
````

But currently prosemirror-markdown will serialize this:

<pre><code>
```
code
```
</code></pre>

to this markdown:

```
```
code
```
```

which is a code block followed by a paragraph "code" and a second code block.