@milkdown/preset-commonmark 7.5.0 → 7.5.8

package/src/mark/strong.ts

@@ -1,5 +1,11 @@
 import { commandsCtx, remarkStringifyOptionsCtx } from '@milkdown/core'
-import { $command, $inputRule, $markAttr, $markSchema, $useKeymap } from '@milkdown/utils'
+import {
+  $command,
+  $inputRule,
+  $markAttr,
+  $markSchema,
+  $useKeymap,
+} from '@milkdown/utils'
 import { toggleMark } from '@milkdown/prose/commands'
 import { markRule } from '@milkdown/prose'
 import { withMeta } from '../__internal__'
@@ -13,7 +19,7 @@ withMeta(strongAttr, {
 })
 
 /// Strong mark schema.
-export const strongSchema = $markSchema('strong', ctx => ({
+export const strongSchema = $markSchema('strong', (ctx) => ({
   attrs: {
     marker: {
       default: ctx.get(remarkStringifyOptionsCtx).strong || '*',
@@ -22,11 +28,11 @@ export const strongSchema = $markSchema('strong', ctx => ({
   parseDOM: [
     { tag: 'b' },
     { tag: 'strong' },
-    { style: 'font-style', getAttrs: value => (value === 'bold') as false },
+    { style: 'font-style', getAttrs: (value) => (value === 'bold') as false },
   ],
-  toDOM: mark => ['strong', ctx.get(strongAttr.key)(mark)],
+  toDOM: (mark) => ['strong', ctx.get(strongAttr.key)(mark)],
   parseMarkdown: {
-    match: node => node.type === 'strong',
+    match: (node) => node.type === 'strong',
     runner: (state, node, markType) => {
       state.openMark(markType, { marker: node.marker })
       state.next(node.children)
@@ -34,7 +40,7 @@ export const strongSchema = $markSchema('strong', ctx => ({
     },
   },
   toMarkdown: {
-    match: mark => mark.type.name === 'strong',
+    match: (mark) => mark.type.name === 'strong',
     runner: (state, mark) => {
       state.withMark(mark, 'strong', undefined, {
         marker: mark.attrs.marker,
@@ -54,7 +60,7 @@ withMeta(strongSchema.ctx, {
 })
 
 /// A command to toggle the strong mark.
-export const toggleStrongCommand = $command('ToggleStrong', ctx => () => {
+export const toggleStrongCommand = $command('ToggleStrong', (ctx) => () => {
   return toggleMark(strongSchema.type(ctx))
 })
 

package/src/node/blockquote.ts

@@ -2,7 +2,13 @@ import { commandsCtx } from '@milkdown/core'
 import { wrapIn } from '@milkdown/prose/commands'
 import { wrappingInputRule } from '@milkdown/prose/inputrules'
 import type { $NodeSchema } from '@milkdown/utils'
-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 blockquote node.
@@ -14,25 +20,28 @@ withMeta(blockquoteAttr, {
 })
 
 /// Schema for blockquote node.
-export const blockquoteSchema: $NodeSchema<'blockquote'> = $nodeSchema('blockquote', ctx => ({
-  content: 'block+',
-  group: 'block',
-  defining: true,
-  parseDOM: [{ tag: 'blockquote' }],
-  toDOM: node => ['blockquote', ctx.get(blockquoteAttr.key)(node), 0],
-  parseMarkdown: {
-    match: ({ type }) => type === 'blockquote',
-    runner: (state, node, type) => {
-      state.openNode(type).next(node.children).closeNode()
+export const blockquoteSchema: $NodeSchema<'blockquote'> = $nodeSchema(
+  'blockquote',
+  (ctx) => ({
+    content: 'block+',
+    group: 'block',
+    defining: true,
+    parseDOM: [{ tag: 'blockquote' }],
+    toDOM: (node) => ['blockquote', ctx.get(blockquoteAttr.key)(node), 0],
+    parseMarkdown: {
+      match: ({ type }) => type === 'blockquote',
+      runner: (state, node, type) => {
+        state.openNode(type).next(node.children).closeNode()
+      },
     },
-  },
-  toMarkdown: {
-    match: node => node.type.name === 'blockquote',
-    runner: (state, node) => {
-      state.openNode('blockquote').next(node.content).closeNode()
+    toMarkdown: {
+      match: (node) => node.type.name === 'blockquote',
+      runner: (state, node) => {
+        state.openNode('blockquote').next(node.content).closeNode()
+      },
     },
-  },
-}))
+  })
+)
 
 withMeta(blockquoteSchema.node, {
   displayName: 'NodeSchema<blockquote>',
@@ -46,7 +55,9 @@ withMeta(blockquoteSchema.ctx, {
 
 /// This input rule will convert a line that starts with `> ` into a blockquote.
 /// You can type `> ` at the start of a line to create a blockquote.
-export const wrapInBlockquoteInputRule = $inputRule(ctx => wrappingInputRule(/^\s*>\s$/, blockquoteSchema.type(ctx)))
+export const wrapInBlockquoteInputRule = $inputRule((ctx) =>
+  wrappingInputRule(/^\s*>\s$/, blockquoteSchema.type(ctx))
+)
 
 withMeta(wrapInBlockquoteInputRule, {
   displayName: 'InputRule<wrapInBlockquoteInputRule>',
@@ -54,7 +65,10 @@ withMeta(wrapInBlockquoteInputRule, {
 })
 
 /// This command will wrap the current selection in a blockquote.
-export const wrapInBlockquoteCommand = $command('WrapInBlockquote', ctx => () => wrapIn(blockquoteSchema.type(ctx)))
+export const wrapInBlockquoteCommand = $command(
+  'WrapInBlockquote',
+  (ctx) => () => wrapIn(blockquoteSchema.type(ctx))
+)
 
 withMeta(wrapInBlockquoteCommand, {
   displayName: 'Command<wrapInBlockquoteCommand>',

package/src/node/bullet-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 bullet list node.
@@ -27,8 +33,7 @@ export const bulletListSchema = $nodeSchema('bullet_list', (ctx) => {
       {
         tag: 'ul',
         getAttrs: (dom) => {
-          if (!(dom instanceof HTMLElement))
-            throw expectDomTypeError(dom)
+          if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom)
 
           return {
             spread: dom.dataset.spread,
@@ -54,10 +59,13 @@ export const bulletListSchema = $nodeSchema('bullet_list', (ctx) => {
       },
     },
     toMarkdown: {
-      match: node => node.type.name === 'bullet_list',
+      match: (node) => node.type.name === 'bullet_list',
       runner: (state, node) => {
         state
-          .openNode('list', undefined, { ordered: false, spread: node.attrs.spread === 'true' })
+          .openNode('list', undefined, {
+            ordered: false,
+            spread: node.attrs.spread === 'true',
+          })
           .next(node.content)
           .closeNode()
       },
@@ -76,7 +84,9 @@ withMeta(bulletListSchema.ctx, {
 })
 
 /// Input rule for wrapping a block in bullet list node.
-export const wrapInBulletListInputRule = $inputRule(ctx => wrappingInputRule(/^\s*([-+*])\s$/, bulletListSchema.type(ctx)))
+export const wrapInBulletListInputRule = $inputRule((ctx) =>
+  wrappingInputRule(/^\s*([-+*])\s$/, bulletListSchema.type(ctx))
+)
 
 withMeta(wrapInBulletListInputRule, {
   displayName: 'InputRule<wrapInBulletListInputRule>',
@@ -84,7 +94,10 @@ withMeta(wrapInBulletListInputRule, {
 })
 
 /// Command for creating bullet list node.
-export const wrapInBulletListCommand = $command('WrapInBulletList', ctx => () => wrapIn(bulletListSchema.type(ctx)))
+export const wrapInBulletListCommand = $command(
+  'WrapInBulletList',
+  (ctx) => () => wrapIn(bulletListSchema.type(ctx))
+)
 
 withMeta(wrapInBulletListCommand, {
   displayName: 'Command<wrapInBulletListCommand>',

package/src/node/code-block.ts

@@ -2,7 +2,13 @@ import { commandsCtx } from '@milkdown/core'
 import { expectDomTypeError } from '@milkdown/exception'
 import { setBlockType } from '@milkdown/prose/commands'
 import { textblockTypeInputRule } 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 code block node.
@@ -34,8 +40,7 @@ export const codeBlockSchema = $nodeSchema('code_block', (ctx) => {
         tag: 'pre',
         preserveWhitespace: 'full',
         getAttrs: (dom) => {
-          if (!(dom instanceof HTMLElement))
-            throw expectDomTypeError(dom)
+          if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom)
 
           return { language: dom.dataset.language }
         },
@@ -58,14 +63,13 @@ export const codeBlockSchema = $nodeSchema('code_block', (ctx) => {
         const language = node.lang as string
         const value = node.value as string
         state.openNode(type, { language })
-        if (value)
-          state.addText(value)
+        if (value) state.addText(value)
 
         state.closeNode()
       },
     },
     toMarkdown: {
-      match: node => node.type.name === 'code_block',
+      match: (node) => node.type.name === 'code_block',
       runner: (state, node) => {
         state.addNode('code', undefined, node.content.firstChild?.text || '', {
           lang: node.attrs.language,
@@ -87,9 +91,15 @@ withMeta(codeBlockSchema.ctx, {
 
 /// A input rule for creating code block.
 /// For example, ` ```javascript ` will create a code block with language javascript.
-export const createCodeBlockInputRule = $inputRule(ctx => textblockTypeInputRule(/^```(?<language>[a-z]*)?[\s\n]$/, codeBlockSchema.type(ctx), match => ({
-  language: match.groups?.language ?? '',
-})))
+export const createCodeBlockInputRule = $inputRule((ctx) =>
+  textblockTypeInputRule(
+    /^```(?<language>[a-z]*)?[\s\n]$/,
+    codeBlockSchema.type(ctx),
+    (match) => ({
+      language: match.groups?.language ?? '',
+    })
+  )
+)
 
 withMeta(createCodeBlockInputRule, {
   displayName: 'InputRule<createCodeBlockInputRule>',
@@ -98,7 +108,12 @@ withMeta(createCodeBlockInputRule, {
 
 /// A command for creating code block.
 /// You can pass the language of the code block as the parameter.
-export const createCodeBlockCommand = $command('CreateCodeBlock', ctx => (language = '') => setBlockType(codeBlockSchema.type(ctx), { language }))
+export const createCodeBlockCommand = $command(
+  'CreateCodeBlock',
+  (ctx) =>
+    (language = '') =>
+      setBlockType(codeBlockSchema.type(ctx), { language })
+)
 
 withMeta(createCodeBlockCommand, {
   displayName: 'Command<createCodeBlockCommand>',
@@ -106,14 +121,24 @@ withMeta(createCodeBlockCommand, {
 })
 
 /// A command for updating the code block language of the target position.
-export const updateCodeBlockLanguageCommand = $command('UpdateCodeBlockLanguage', () => ({ pos, language }: { pos: number, language: string } = { pos: -1, language: '' }) => (state, dispatch) => {
-  if (pos >= 0) {
-    dispatch?.(state.tr.setNodeAttribute(pos, 'language', language))
-    return true
-  }
-
-  return false
-})
+export const updateCodeBlockLanguageCommand = $command(
+  'UpdateCodeBlockLanguage',
+  () =>
+    (
+      { pos, language }: { pos: number; language: string } = {
+        pos: -1,
+        language: '',
+      }
+    ) =>
+    (state, dispatch) => {
+      if (pos >= 0) {
+        dispatch?.(state.tr.setNodeAttribute(pos, 'language', language))
+        return true
+      }
+
+      return false
+    }
+)
 
 withMeta(updateCodeBlockLanguageCommand, {
   displayName: 'Command<updateCodeBlockLanguageCommand>',

package/src/node/doc.ts

@@ -11,7 +11,7 @@ export const docSchema = $node('doc', () => ({
     },
   },
   toMarkdown: {
-    match: node => node.type.name === 'doc',
+    match: (node) => node.type.name === 'doc',
     runner: (state, node) => {
       state.openNode('root')
       state.next(node.content)

package/src/node/hardbreak.ts

@@ -20,7 +20,7 @@ withMeta(hardbreakAttr, {
 })
 
 /// Hardbreak node schema.
-export const hardbreakSchema = $nodeSchema('hardbreak', ctx => ({
+export const hardbreakSchema = $nodeSchema('hardbreak', (ctx) => ({
   inline: true,
   group: 'inline',
   attrs: {
@@ -29,23 +29,33 @@ export const hardbreakSchema = $nodeSchema('hardbreak', ctx => ({
     },
   },
   selectable: false,
-  parseDOM: [{ tag: 'br' }, { tag: 'span[data-type="hardbreak"]', getAttrs: () => ({ isInline: true }) }],
-  toDOM: node => node.attrs.isInline ? ['span', ctx.get(hardbreakAttr.key)(node), ' '] : ['br', ctx.get(hardbreakAttr.key)(node)],
+  parseDOM: [
+    { tag: 'br' },
+    {
+      tag: 'span[data-type="hardbreak"]',
+      getAttrs: () => ({ isInline: true }),
+    },
+  ],
+  toDOM: (node) =>
+    node.attrs.isInline
+      ? ['span', ctx.get(hardbreakAttr.key)(node), ' ']
+      : ['br', ctx.get(hardbreakAttr.key)(node)],
   parseMarkdown: {
     match: ({ type }) => type === 'break',
     runner: (state, node, type) => {
-      state.addNode(type, { isInline: Boolean((node.data as (undefined | { isInline: boolean }))?.isInline) })
+      state.addNode(type, {
+        isInline: Boolean(
+          (node.data as undefined | { isInline: boolean })?.isInline
+        ),
+      })
     },
   },
   leafText: () => '\n',
   toMarkdown: {
-    match: node => node.type.name === 'hardbreak',
+    match: (node) => node.type.name === 'hardbreak',
     runner: (state, node) => {
-      if (node.attrs.isInline)
-        state.addNode('text', undefined, '\n')
-
-      else
-        state.addNode('break')
+      if (node.attrs.isInline) state.addNode('text', undefined, '\n')
+      else state.addNode('break')
     },
   },
 }))
@@ -61,27 +71,38 @@ withMeta(hardbreakSchema.ctx, {
 })
 
 /// Command to insert a hardbreak.
-export const insertHardbreakCommand = $command('InsertHardbreak', ctx => () => (state, dispatch) => {
-  const { selection, tr } = state
-  if (!(selection instanceof TextSelection))
-    return false
+export const insertHardbreakCommand = $command(
+  'InsertHardbreak',
+  (ctx) => () => (state, dispatch) => {
+    const { selection, tr } = state
+    if (!(selection instanceof TextSelection)) return false
 
-  if (selection.empty) {
-    // Transform two successive hardbreak into a new line
-    const node = selection.$from.node()
-    if (node.childCount > 0 && node.lastChild?.type.name === 'hardbreak') {
-      dispatch?.(
-        tr
-          .replaceRangeWith(selection.to - 1, selection.to, state.schema.node('paragraph'))
-          .setSelection(Selection.near(tr.doc.resolve(selection.to)))
-          .scrollIntoView(),
-      )
-      return true
+    if (selection.empty) {
+      // Transform two successive hardbreak into a new line
+      const node = selection.$from.node()
+      if (node.childCount > 0 && node.lastChild?.type.name === 'hardbreak') {
+        dispatch?.(
+          tr
+            .replaceRangeWith(
+              selection.to - 1,
+              selection.to,
+              state.schema.node('paragraph')
+            )
+            .setSelection(Selection.near(tr.doc.resolve(selection.to)))
+            .scrollIntoView()
+        )
+        return true
+      }
     }
+    dispatch?.(
+      tr
+        .setMeta('hardbreak', true)
+        .replaceSelectionWith(hardbreakSchema.type(ctx).create())
+        .scrollIntoView()
+    )
+    return true
   }
-  dispatch?.(tr.setMeta('hardbreak', true).replaceSelectionWith(hardbreakSchema.type(ctx).create()).scrollIntoView())
-  return true
-})
+)
 
 withMeta(insertHardbreakCommand, {
   displayName: 'Command<insertHardbreakCommand>',

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>',