@milkdown/preset-commonmark 7.4.0 → 7.5.8

package/src/node/heading.ts

@@ -3,7 +3,14 @@ import { expectDomTypeError } from '@milkdown/exception'
 import { setBlockType } from '@milkdown/prose/commands'
 import { textblockTypeInputRule } from '@milkdown/prose/inputrules'
 import type { Node } from '@milkdown/prose/model'
-import { $command, $ctx, $inputRule, $nodeAttr, $nodeSchema, $useKeymap } from '@milkdown/utils'
+import {
+  $command,
+  $ctx,
+  $inputRule,
+  $nodeAttr,
+  $nodeSchema,
+  $useKeymap,
+} from '@milkdown/utils'
 import slugify from '@sindresorhus/slugify'
 import { serializeText, withMeta } from '../__internal__'
 import { paragraphSchema } from './paragraph'
@@ -18,7 +25,10 @@ function defaultHeadingIdGenerator(node: Node) {
 
 /// This is a slice contains a function to generate heading id.
 /// You can configure it to generate id in your own way.
-export const headingIdGenerator = $ctx(defaultHeadingIdGenerator, 'headingIdGenerator')
+export const headingIdGenerator = $ctx(
+  defaultHeadingIdGenerator,
+  'headingIdGenerator'
+)
 
 withMeta(headingIdGenerator, {
   displayName: 'Ctx<HeadingIdGenerator>',
@@ -48,11 +58,10 @@ export const headingSchema = $nodeSchema('heading', (ctx) => {
         default: 1,
       },
     },
-    parseDOM: headingIndex.map(x => ({
+    parseDOM: headingIndex.map((x) => ({
       tag: `h${x}`,
       getAttrs: (node) => {
-        if (!(node instanceof HTMLElement))
-          throw expectDomTypeError(node)
+        if (!(node instanceof HTMLElement)) throw expectDomTypeError(node)
 
         return { level: x, id: node.id }
       },
@@ -77,7 +86,7 @@ export const headingSchema = $nodeSchema('heading', (ctx) => {
       },
     },
     toMarkdown: {
-      match: node => node.type.name === 'heading',
+      match: (node) => node.type.name === 'heading',
       runner: (state, node) => {
         state.openNode('heading', undefined, { depth: node.attrs.level })
         serializeText(state, node)
@@ -100,21 +109,24 @@ withMeta(headingSchema.ctx, {
 /// This input rule can turn the selected block into heading.
 /// You can input numbers of `#` and a `space` to create heading.
 export const wrapInHeadingInputRule = $inputRule((ctx) => {
-  return textblockTypeInputRule(/^(?<hashes>#+)\s$/, headingSchema.type(ctx), (match) => {
-    const x = match.groups?.hashes?.length || 0
-
-    const view = ctx.get(editorViewCtx)
-    const { $from } = view.state.selection
-    const node = $from.node()
-    if (node.type.name === 'heading') {
-      let level = Number(node.attrs.level) + Number(x)
-      if (level > 6)
-        level = 6
-
-      return { level }
+  return textblockTypeInputRule(
+    /^(?<hashes>#+)\s$/,
+    headingSchema.type(ctx),
+    (match) => {
+      const x = match.groups?.hashes?.length || 0
+
+      const view = ctx.get(editorViewCtx)
+      const { $from } = view.state.selection
+      const node = $from.node()
+      if (node.type.name === 'heading') {
+        let level = Number(node.attrs.level) + Number(x)
+        if (level > 6) level = 6
+
+        return { level }
+      }
+      return { level: x }
     }
-    return { level: x }
-  })
+  )
 })
 
 withMeta(wrapInHeadingInputRule, {
@@ -129,8 +141,7 @@ export const wrapInHeadingCommand = $command('WrapInHeading', (ctx) => {
   return (level?: number) => {
     level ??= 1
 
-    if (level < 1)
-      return setBlockType(paragraphSchema.type(ctx))
+    if (level < 1) return setBlockType(paragraphSchema.type(ctx))
 
     return setBlockType(headingSchema.type(ctx), { level })
   }
@@ -144,11 +155,16 @@ withMeta(wrapInHeadingCommand, {
 /// This command can downgrade the selected heading.
 /// For example, if you have a `h2` element, and you call this command, you will get a `h1` element.
 /// If the element is already a `h1` element, it will turn it into a `p` element.
-export const downgradeHeadingCommand = $command('DowngradeHeading', ctx => () =>
-  (state, dispatch, view) => {
+export const downgradeHeadingCommand = $command(
+  'DowngradeHeading',
+  (ctx) => () => (state, dispatch, view) => {
     const { $from } = state.selection
     const node = $from.node()
-    if (node.type !== headingSchema.type(ctx) || !state.selection.empty || $from.parentOffset !== 0)
+    if (
+      node.type !== headingSchema.type(ctx) ||
+      !state.selection.empty ||
+      $from.parentOffset !== 0
+    )
       return false
 
     const level = node.attrs.level - 1
@@ -159,10 +175,11 @@ export const downgradeHeadingCommand = $command('DowngradeHeading', ctx => () =>
       state.tr.setNodeMarkup(state.selection.$from.before(), undefined, {
         ...node.attrs,
         level,
-      }),
+      })
     )
     return true
-  })
+  }
+)
 
 withMeta(downgradeHeadingCommand, {
   displayName: 'Command<downgradeHeadingCommand>',

package/src/node/hr.ts

@@ -13,10 +13,10 @@ withMeta(hrAttr, {
 })
 
 /// Hr node schema.
-export const hrSchema = $nodeSchema('hr', ctx => ({
+export const hrSchema = $nodeSchema('hr', (ctx) => ({
   group: 'block',
   parseDOM: [{ tag: 'hr' }],
-  toDOM: node => ['hr', ctx.get(hrAttr.key)(node)],
+  toDOM: (node) => ['hr', ctx.get(hrAttr.key)(node)],
   parseMarkdown: {
     match: ({ type }) => type === 'thematicBreak',
     runner: (state, _, type) => {
@@ -24,7 +24,7 @@ export const hrSchema = $nodeSchema('hr', ctx => ({
     },
   },
   toMarkdown: {
-    match: node => node.type.name === 'hr',
+    match: (node) => node.type.name === 'hr',
     runner: (state) => {
       state.addNode('thematicBreak')
     },
@@ -43,17 +43,16 @@ withMeta(hrSchema.ctx, {
 
 /// Input rule to insert a hr.
 /// For example, `---` will be converted to a hr.
-export const insertHrInputRule = $inputRule(ctx => new InputRule(
-  /^(?:---|___\s|\*\*\*\s)$/,
-  (state, match, start, end) => {
-    const { tr } = state
+export const insertHrInputRule = $inputRule(
+  (ctx) =>
+    new InputRule(/^(?:---|___\s|\*\*\*\s)$/, (state, match, start, end) => {
+      const { tr } = state
 
-    if (match[0])
-      tr.replaceWith(start - 1, end, hrSchema.type(ctx).create())
+      if (match[0]) tr.replaceWith(start - 1, end, hrSchema.type(ctx).create())
 
-    return tr
-  },
-))
+      return tr
+    })
+)
 
 withMeta(insertHrInputRule, {
   displayName: 'InputRule<insertHrInputRule>',
@@ -61,25 +60,25 @@ withMeta(insertHrInputRule, {
 })
 
 /// Command to insert a hr.
-export const insertHrCommand = $command('InsertHr', ctx => () => (state, dispatch) => {
-  if (!dispatch)
-    return true
+export const insertHrCommand = $command(
+  'InsertHr',
+  (ctx) => () => (state, dispatch) => {
+    if (!dispatch) return true
 
-  const paragraph = paragraphSchema.node.type(ctx).create()
-  const { tr, selection } = state
-  const { from } = selection
-  const node = hrSchema.type(ctx).create()
-  if (!node)
-    return true
+    const paragraph = paragraphSchema.node.type(ctx).create()
+    const { tr, selection } = state
+    const { from } = selection
+    const node = hrSchema.type(ctx).create()
+    if (!node) return true
 
-  const _tr = tr.replaceSelectionWith(node).insert(from, paragraph)
-  const sel = Selection.findFrom(_tr.doc.resolve(from), 1, true)
-  if (!sel)
-    return true
+    const _tr = tr.replaceSelectionWith(node).insert(from, paragraph)
+    const sel = Selection.findFrom(_tr.doc.resolve(from), 1, true)
+    if (!sel) return true
 
-  dispatch(_tr.setSelection(sel).scrollIntoView())
-  return true
-})
+    dispatch(_tr.setSelection(sel).scrollIntoView())
+    return true
+  }
+)
 
 withMeta(insertHrCommand, {
   displayName: 'Command<insertHrCommand>',

package/src/node/html.ts

@@ -28,14 +28,16 @@ export const htmlSchema = $nodeSchema('html', (ctx) => {
       span.textContent = node.attrs.value
       return ['span', attr, node.attrs.value]
     },
-    parseDOM: [{
-      tag: 'span[data-type="html"]',
-      getAttrs: (dom) => {
-        return {
-          value: (dom as HTMLElement).dataset.value ?? '',
-        }
+    parseDOM: [
+      {
+        tag: 'span[data-type="html"]',
+        getAttrs: (dom) => {
+          return {
+            value: dom.dataset.value ?? '',
+          }
+        },
       },
-    }],
+    ],
     parseMarkdown: {
       match: ({ type }) => Boolean(type === 'html'),
       runner: (state, node, type) => {
@@ -43,7 +45,7 @@ export const htmlSchema = $nodeSchema('html', (ctx) => {
       },
     },
     toMarkdown: {
-      match: node => node.type.name === 'html',
+      match: (node) => node.type.name === 'html',
       runner: (state, node) => {
         state.addNode('html', undefined, node.attrs.value)
       },

package/src/node/image.ts

@@ -32,8 +32,7 @@ export const imageSchema = $nodeSchema('image', (ctx) => {
       {
         tag: 'img[src]',
         getAttrs: (dom) => {
-          if (!(dom instanceof HTMLElement))
-            throw expectDomTypeError(dom)
+          if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom)
 
           return {
             src: dom.getAttribute('src') || '',
@@ -60,7 +59,7 @@ export const imageSchema = $nodeSchema('image', (ctx) => {
       },
     },
     toMarkdown: {
-      match: node => node.type.name === 'image',
+      match: (node) => node.type.name === 'image',
       runner: (state, node) => {
         state.addNode('image', undefined, undefined, {
           title: node.attrs.title,
@@ -91,20 +90,22 @@ export interface UpdateImageCommandPayload {
 
 /// This command will insert a image node.
 /// You can pass a payload to set `src`, `alt` and `title` for the image node.
-export const insertImageCommand = $command('InsertImage', ctx => (payload: UpdateImageCommandPayload = {}) =>
-  (state, dispatch) => {
-    if (!dispatch)
-      return true
+export const insertImageCommand = $command(
+  'InsertImage',
+  (ctx) =>
+    (payload: UpdateImageCommandPayload = {}) =>
+    (state, dispatch) => {
+      if (!dispatch) return true
 
-    const { src = '', alt = '', title = '' } = payload
+      const { src = '', alt = '', title = '' } = payload
 
-    const node = imageSchema.type(ctx).create({ src, alt, title })
-    if (!node)
-      return true
+      const node = imageSchema.type(ctx).create({ src, alt, title })
+      if (!node) return true
 
-    dispatch(state.tr.replaceSelectionWith(node).scrollIntoView())
-    return true
-  })
+      dispatch(state.tr.replaceSelectionWith(node).scrollIntoView())
+      return true
+    }
+)
 
 withMeta(insertImageCommand, {
   displayName: 'Command<insertImageCommand>',
@@ -113,25 +114,31 @@ withMeta(insertImageCommand, {
 
 /// This command will update the selected image node.
 /// You can pass a payload to update `src`, `alt` and `title` for the image node.
-export const updateImageCommand = $command('UpdateImage', ctx => (payload: UpdateImageCommandPayload = {}) => (state, dispatch) => {
-  const nodeWithPos = findSelectedNodeOfType(state.selection, imageSchema.type(ctx))
-  if (!nodeWithPos)
-    return false
-
-  const { node, pos } = nodeWithPos
-
-  const newAttrs = { ...node.attrs }
-  const { src, alt, title } = payload
-  if (src !== undefined)
-    newAttrs.src = src
-  if (alt !== undefined)
-    newAttrs.alt = alt
-  if (title !== undefined)
-    newAttrs.title = title
-
-  dispatch?.(state.tr.setNodeMarkup(pos, undefined, newAttrs).scrollIntoView())
-  return true
-})
+export const updateImageCommand = $command(
+  'UpdateImage',
+  (ctx) =>
+    (payload: UpdateImageCommandPayload = {}) =>
+    (state, dispatch) => {
+      const nodeWithPos = findSelectedNodeOfType(
+        state.selection,
+        imageSchema.type(ctx)
+      )
+      if (!nodeWithPos) return false
+
+      const { node, pos } = nodeWithPos
+
+      const newAttrs = { ...node.attrs }
+      const { src, alt, title } = payload
+      if (src !== undefined) newAttrs.src = src
+      if (alt !== undefined) newAttrs.alt = alt
+      if (title !== undefined) newAttrs.title = title
+
+      dispatch?.(
+        state.tr.setNodeMarkup(pos, undefined, newAttrs).scrollIntoView()
+      )
+      return true
+    }
+)
 
 withMeta(updateImageCommand, {
   displayName: 'Command<updateImageCommand>',
@@ -141,16 +148,23 @@ withMeta(updateImageCommand, {
 /// This input rule will insert a image node.
 /// You can input `![alt](src "title")` to insert a image node.
 /// The `title` is optional.
-export const insertImageInputRule = $inputRule(ctx => new InputRule(
-  /!\[(?<alt>.*?)]\((?<filename>.*?)\s*(?="|\))"?(?<title>[^"]+)?"?\)/,
-  (state, match, start, end) => {
-    const [matched, alt, src = '', title] = match
-    if (matched)
-      return state.tr.replaceWith(start, end, imageSchema.type(ctx).create({ src, alt, title }))
-
-    return null
-  },
-))
+export const insertImageInputRule = $inputRule(
+  (ctx) =>
+    new InputRule(
+      /!\[(?<alt>.*?)]\((?<filename>.*?)\s*(?="|\))"?(?<title>[^"]+)?"?\)/,
+      (state, match, start, end) => {
+        const [matched, alt, src = '', title] = match
+        if (matched)
+          return state.tr.replaceWith(
+            start,
+            end,
+            imageSchema.type(ctx).create({ src, alt, title })
+          )
+
+        return null
+      }
+    )
+)
 
 withMeta(insertImageInputRule, {
   displayName: 'InputRule<insertImageInputRule>',

package/src/node/list-item.ts

@@ -1,6 +1,10 @@
 import { commandsCtx } from '@milkdown/core'
 import { expectDomTypeError } from '@milkdown/exception'
-import { liftListItem, sinkListItem, splitListItem } from '@milkdown/prose/schema-list'
+import {
+  liftListItem,
+  sinkListItem,
+  splitListItem,
+} from '@milkdown/prose/schema-list'
 import { $command, $nodeAttr, $nodeSchema, $useKeymap } from '@milkdown/utils'
 import { type Command, TextSelection } from '@milkdown/prose/state'
 import type { Ctx } from '@milkdown/ctx'
@@ -15,7 +19,7 @@ withMeta(listItemAttr, {
 })
 
 /// Schema for list item node.
-export const listItemSchema = $nodeSchema('list_item', ctx => ({
+export const listItemSchema = $nodeSchema('list_item', (ctx) => ({
   group: 'listItem',
   content: '(paragraph|blockquote) block*',
   attrs: {
@@ -34,8 +38,7 @@ export const listItemSchema = $nodeSchema('list_item', ctx => ({
     {
       tag: 'li',
       getAttrs: (dom) => {
-        if (!(dom instanceof HTMLElement))
-          throw expectDomTypeError(dom)
+        if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom)
 
         return {
           label: dom.dataset.label,
@@ -45,7 +48,7 @@ export const listItemSchema = $nodeSchema('list_item', ctx => ({
       },
     },
   ],
-  toDOM: node => [
+  toDOM: (node) => [
     'li',
     {
       ...ctx.get(listItemAttr.key)(node),
@@ -67,9 +70,11 @@ export const listItemSchema = $nodeSchema('list_item', ctx => ({
     },
   },
   toMarkdown: {
-    match: node => node.type.name === 'list_item',
+    match: (node) => node.type.name === 'list_item',
     runner: (state, node) => {
-      state.openNode('listItem', undefined, { spread: node.attrs.spread === 'true' })
+      state.openNode('listItem', undefined, {
+        spread: node.attrs.spread === 'true',
+      })
       state.next(node.content)
       state.closeNode()
     },
@@ -98,7 +103,10 @@ withMeta(listItemSchema.ctx, {
 /// * List item 1
 ///   * List item 2
 /// ```
-export const sinkListItemCommand = $command('SinkListItem', ctx => () => sinkListItem(listItemSchema.type(ctx)))
+export const sinkListItemCommand = $command(
+  'SinkListItem',
+  (ctx) => () => sinkListItem(listItemSchema.type(ctx))
+)
 
 withMeta(sinkListItemCommand, {
   displayName: 'Command<sinkListItemCommand>',
@@ -117,7 +125,10 @@ withMeta(sinkListItemCommand, {
 /// * List item 1
 /// * List item 2
 /// ```
-export const liftListItemCommand = $command('LiftListItem', ctx => () => liftListItem(listItemSchema.type(ctx)))
+export const liftListItemCommand = $command(
+  'LiftListItem',
+  (ctx) => () => liftListItem(listItemSchema.type(ctx))
+)
 
 withMeta(liftListItemCommand, {
   displayName: 'Command<liftListItemCommand>',
@@ -137,7 +148,10 @@ withMeta(liftListItemCommand, {
 /// * List item 2
 /// * <- cursor here
 /// ```
-export const splitListItemCommand = $command('SplitListItem', ctx => () => splitListItem(listItemSchema.type(ctx)))
+export const splitListItemCommand = $command(
+  'SplitListItem',
+  (ctx) => () => splitListItem(listItemSchema.type(ctx))
+)
 
 withMeta(splitListItemCommand, {
   displayName: 'Command<splitListItemCommand>',
@@ -147,24 +161,24 @@ withMeta(splitListItemCommand, {
 function liftFirstListItem(ctx: Ctx): Command {
   return (state, dispatch, view) => {
     const { selection } = state
-    if (!(selection instanceof TextSelection))
-      return false
+    if (!(selection instanceof TextSelection)) return false
 
     const { empty, $from } = selection
 
     // selection should be empty and at the start of the node
-    if (!empty || $from.parentOffset !== 0)
-      return false
+    if (!empty || $from.parentOffset !== 0) return false
 
     const parentItem = $from.node(-1)
     // selection should be in list item and list item should be the first child of the list
-    if (parentItem.type !== listItemSchema.type(ctx) || parentItem.firstChild !== $from.node())
+    if (
+      parentItem.type !== listItemSchema.type(ctx) ||
+      parentItem.firstChild !== $from.node()
+    )
       return false
 
     const list = $from.node(-2)
     // list should have only one list item
-    if (list.childCount > 1)
-      return false
+    if (list.childCount > 1) return false
 
     return liftListItem(listItemSchema.type(ctx))(state, dispatch, view)
   }
@@ -176,7 +190,10 @@ function liftFirstListItem(ctx: Ctx): Command {
 /// - List item is the only child of the list.
 ///
 /// Most of the time, you shouldn't use this command directly.
-export const liftFirstListItemCommand = $command('LiftFirstListItem', ctx => () => liftFirstListItem(ctx))
+export const liftFirstListItemCommand = $command(
+  'LiftFirstListItem',
+  (ctx) => () => liftFirstListItem(ctx)
+)
 
 withMeta(liftFirstListItemCommand, {
   displayName: 'Command<liftFirstListItemCommand>',

package/src/node/ordered-list.ts

@@ -2,7 +2,13 @@ import { commandsCtx } from '@milkdown/core'
 import { expectDomTypeError } from '@milkdown/exception'
 import { wrapIn } from '@milkdown/prose/commands'
 import { wrappingInputRule } from '@milkdown/prose/inputrules'
-import { $command, $inputRule, $nodeAttr, $nodeSchema, $useKeymap } from '@milkdown/utils'
+import {
+  $command,
+  $inputRule,
+  $nodeAttr,
+  $nodeSchema,
+  $useKeymap,
+} from '@milkdown/utils'
 import { withMeta } from '../__internal__'
 
 /// HTML attributes for ordered list node.
@@ -14,7 +20,7 @@ withMeta(orderedListAttr, {
 })
 
 /// Schema for ordered list node.
-export const orderedListSchema = $nodeSchema('ordered_list', ctx => ({
+export const orderedListSchema = $nodeSchema('ordered_list', (ctx) => ({
   content: 'listItem+',
   group: 'block',
   attrs: {
@@ -29,17 +35,18 @@ export const orderedListSchema = $nodeSchema('ordered_list', ctx => ({
     {
       tag: 'ol',
       getAttrs: (dom) => {
-        if (!(dom instanceof HTMLElement))
-          throw expectDomTypeError(dom)
+        if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom)
 
         return {
           spread: dom.dataset.spread,
-          order: dom.hasAttribute('start') ? Number(dom.getAttribute('start')) : 1,
+          order: dom.hasAttribute('start')
+            ? Number(dom.getAttribute('start'))
+            : 1,
         }
       },
     },
   ],
-  toDOM: node => [
+  toDOM: (node) => [
     'ol',
     {
       ...ctx.get(orderedListAttr.key)(node),
@@ -56,9 +63,13 @@ export const orderedListSchema = $nodeSchema('ordered_list', ctx => ({
     },
   },
   toMarkdown: {
-    match: node => node.type.name === 'ordered_list',
+    match: (node) => node.type.name === 'ordered_list',
     runner: (state, node) => {
-      state.openNode('list', undefined, { ordered: true, start: 1, spread: node.attrs.spread === 'true' })
+      state.openNode('list', undefined, {
+        ordered: true,
+        start: 1,
+        spread: node.attrs.spread === 'true',
+      })
       state.next(node.content)
       state.closeNode()
     },
@@ -76,12 +87,14 @@ withMeta(orderedListSchema.ctx, {
 })
 
 /// Input rule for wrapping a block in ordered list node.
-export const wrapInOrderedListInputRule = $inputRule(ctx => wrappingInputRule(
-  /^\s*(\d+)\.\s$/,
-  orderedListSchema.type(ctx),
-  match => ({ order: Number(match[1]) }),
-  (match, node) => node.childCount + node.attrs.order === Number(match[1]),
-))
+export const wrapInOrderedListInputRule = $inputRule((ctx) =>
+  wrappingInputRule(
+    /^\s*(\d+)\.\s$/,
+    orderedListSchema.type(ctx),
+    (match) => ({ order: Number(match[1]) }),
+    (match, node) => node.childCount + node.attrs.order === Number(match[1])
+  )
+)
 
 withMeta(wrapInOrderedListInputRule, {
   displayName: 'InputRule<wrapInOrderedListInputRule>',
@@ -89,7 +102,10 @@ withMeta(wrapInOrderedListInputRule, {
 })
 
 /// Command for wrapping a block in ordered list node.
-export const wrapInOrderedListCommand = $command('WrapInOrderedList', ctx => () => wrapIn(orderedListSchema.type(ctx)))
+export const wrapInOrderedListCommand = $command(
+  'WrapInOrderedList',
+  (ctx) => () => wrapIn(orderedListSchema.type(ctx))
+)
 
 withMeta(wrapInOrderedListCommand, {
   displayName: 'Command<wrapInOrderedListCommand>',

package/src/node/paragraph.ts

@@ -12,26 +12,23 @@ withMeta(paragraphAttr, {
 })
 
 /// Schema for paragraph node.
-export const paragraphSchema = $nodeSchema('paragraph', ctx => ({
+export const paragraphSchema = $nodeSchema('paragraph', (ctx) => ({
   content: 'inline*',
   group: 'block',
   parseDOM: [{ tag: 'p' }],
-  toDOM: node => ['p', ctx.get(paragraphAttr.key)(node), 0],
+  toDOM: (node) => ['p', ctx.get(paragraphAttr.key)(node), 0],
   parseMarkdown: {
-    match: node => node.type === 'paragraph',
+    match: (node) => node.type === 'paragraph',
     runner: (state, node, type) => {
       state.openNode(type)
-      if (node.children)
-        state.next(node.children)
-
-      else
-        state.addText((node.value || '') as string)
+      if (node.children) state.next(node.children)
+      else state.addText((node.value || '') as string)
 
       state.closeNode()
     },
   },
   toMarkdown: {
-    match: node => node.type.name === 'paragraph',
+    match: (node) => node.type.name === 'paragraph',
     runner: (state, node) => {
       state.openNode('paragraph')
       serializeText(state, node)
@@ -50,7 +47,10 @@ withMeta(paragraphSchema.ctx, {
 })
 
 /// This command can turn the selected block into paragraph.
-export const turnIntoTextCommand = $command('TurnIntoText', ctx => () => setBlockType(paragraphSchema.type(ctx)))
+export const turnIntoTextCommand = $command(
+  'TurnIntoText',
+  (ctx) => () => setBlockType(paragraphSchema.type(ctx))
+)
 
 withMeta(turnIntoTextCommand, {
   displayName: 'Command<turnIntoTextCommand>',

package/src/node/text.ts

@@ -11,7 +11,7 @@ export const textSchema = $node('text', () => ({
     },
   },
   toMarkdown: {
-    match: node => node.type.name === 'text',
+    match: (node) => node.type.name === 'text',
     runner: (state, node) => {
       state.addNode('text', undefined, node.text as string)
     },