@milkdown/preset-commonmark 7.5.0 → 7.5.9

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.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)
     },

package/src/plugin/hardbreak-clear-mark-plugin.ts

@@ -9,31 +9,38 @@ export const hardbreakClearMarkPlugin = $prose((ctx) => {
   return new Plugin({
     key: new PluginKey('MILKDOWN_HARDBREAK_MARKS'),
     appendTransaction: (trs, _oldState, newState) => {
-      if (!trs.length)
-        return
+      if (!trs.length) return
 
       const [tr] = trs
-      if (!tr)
-        return
+      if (!tr) return
 
       const [step] = tr.steps
 
       const isInsertHr = tr.getMeta('hardbreak')
       if (isInsertHr) {
-        if (!(step instanceof ReplaceStep))
-          return
+        if (!(step instanceof ReplaceStep)) return
 
         const { from } = step as unknown as { from: number }
-        return newState.tr.setNodeMarkup(from, hardbreakSchema.type(ctx), undefined, [])
+        return newState.tr.setNodeMarkup(
+          from,
+          hardbreakSchema.type(ctx),
+          undefined,
+          []
+        )
       }
 
       const isAddMarkStep = step instanceof AddMarkStep
       if (isAddMarkStep) {
         let _tr = newState.tr
-        const { from, to } = step as unknown as { from: number, to: number }
+        const { from, to } = step as unknown as { from: number; to: number }
         newState.doc.nodesBetween(from, to, (node, pos) => {
           if (node.type === hardbreakSchema.type(ctx))
-            _tr = _tr.setNodeMarkup(pos, hardbreakSchema.type(ctx), undefined, [])
+            _tr = _tr.setNodeMarkup(
+              pos,
+              hardbreakSchema.type(ctx),
+              undefined,
+              []
+            )
         })
 
         return _tr

package/src/plugin/hardbreak-filter-plugin.ts

@@ -3,7 +3,10 @@ import { $ctx, $prose } from '@milkdown/utils'
 import { withMeta } from '../__internal__'
 
 /// This slice contains the nodes that within which the hardbreak will be ignored.
-export const hardbreakFilterNodes = $ctx(['table', 'code_block'], 'hardbreakFilterNodes')
+export const hardbreakFilterNodes = $ctx(
+  ['table', 'code_block'],
+  'hardbreakFilterNodes'
+)
 
 withMeta(hardbreakFilterNodes, {
   displayName: 'Ctx<hardbreakFilterNodes>',
@@ -25,8 +28,7 @@ export const hardbreakFilterPlugin = $prose((ctx) => {
         let curDepth = $from.depth
         let canApply = true
         while (curDepth > 0) {
-          if (notIn.includes($from.node(curDepth).type.name))
-            canApply = false
+          if (notIn.includes($from.node(curDepth).type.name)) canApply = false
 
           curDepth--
         }

package/src/plugin/inline-nodes-cursor-plugin.ts

@@ -6,7 +6,9 @@ import { withMeta } from '../__internal__'
 /// This plugin is to solve the [chrome 98 bug](https://discuss.prosemirror.net/t/cursor-jumps-at-the-end-of-line-when-it-betweens-two-inline-nodes/4641).
 export const inlineNodesCursorPlugin = $prose(() => {
   let lock = false
-  const inlineNodesCursorPluginKey = new PluginKey('MILKDOWN_INLINE_NODES_CURSOR')
+  const inlineNodesCursorPluginKey = new PluginKey(
+    'MILKDOWN_INLINE_NODES_CURSOR'
+  )
   const inlineNodesCursorPlugin: Plugin = new Plugin({
     key: inlineNodesCursorPluginKey,
     state: {
@@ -14,13 +16,19 @@ export const inlineNodesCursorPlugin = $prose(() => {
         return false
       },
       apply(tr) {
-        if (!tr.selection.empty)
-          return false
+        if (!tr.selection.empty) return false
 
         const pos = tr.selection.$from
         const left = pos.nodeBefore
         const right = pos.nodeAfter
-        if (left && right && left.isInline && !left.isText && right.isInline && !right.isText)
+        if (
+          left &&
+          right &&
+          left.isInline &&
+          !left.isText &&
+          right.isInline &&
+          !right.isText
+        )
           return true
 
         return false
@@ -46,8 +54,7 @@ export const inlineNodesCursorPlugin = $prose(() => {
         },
         compositionstart: (view) => {
           const active = inlineNodesCursorPlugin.getState(view.state)
-          if (active)
-            lock = true
+          if (active) lock = true
 
           return false
         },

package/src/plugin/remark-add-order-in-list-plugin.ts

@@ -3,16 +3,19 @@ import { visit } from 'unist-util-visit'
 import { withMeta } from '../__internal__'
 
 /// This plugin is used to add order in list for remark AST.
-export const remarkAddOrderInListPlugin = $remark('remarkAddOrderInList', () => () => (tree) => {
-  visit(tree, 'list', (node) => {
-    if (node.ordered) {
-      const start = node.start ?? 1
-      node.children.forEach((child, index) => {
-        (child as unknown as Record<string, number>).label = index + start
-      })
-    }
-  })
-})
+export const remarkAddOrderInListPlugin = $remark(
+  'remarkAddOrderInList',
+  () => () => (tree) => {
+    visit(tree, 'list', (node) => {
+      if (node.ordered) {
+        const start = node.start ?? 1
+        node.children.forEach((child, index) => {
+          ;(child as unknown as Record<string, number>).label = index + start
+        })
+      }
+    })
+  }
+)
 
 withMeta(remarkAddOrderInListPlugin.plugin, {
   displayName: 'Remark<remarkAddOrderInListPlugin>',

package/src/plugin/remark-html-transformer.ts

@@ -2,10 +2,16 @@ import { $remark } from '@milkdown/utils'
 import type { Node } from '@milkdown/transformer'
 import { withMeta } from '../__internal__'
 
-const isParent = (node: Node): node is Node & { children: Node[] } => !!(node as Node & { children: Node[] }).children
-const isHTML = (node: Node): node is Node & { children: Node[], value: unknown } => node.type === 'html'
+const isParent = (node: Node): node is Node & { children: Node[] } =>
+  !!(node as Node & { children: Node[] }).children
+const isHTML = (
+  node: Node
+): node is Node & { children: Node[]; value: unknown } => node.type === 'html'
 
-function flatMapWithDepth(ast: Node, fn: (node: Node, index: number, parent: Node | null) => Node[]) {
+function flatMapWithDepth(
+  ast: Node,
+  fn: (node: Node, index: number, parent: Node | null) => Node[]
+) {
   return transform(ast, 0, null)[0]
 
   function transform(node: Node, index: number, parent: Node | null) {
@@ -18,8 +24,7 @@ function flatMapWithDepth(ast: Node, fn: (node: Node, index: number, parent: Nod
           if (xs) {
             for (let j = 0, m = xs.length; j < m; j++) {
               const item = xs[j]
-              if (item)
-                out.push(item)
+              if (item) out.push(item)
             }
           }
         }
@@ -33,20 +38,22 @@ function flatMapWithDepth(ast: Node, fn: (node: Node, index: number, parent: Nod
 
 /// @internal
 /// This plugin should be deprecated after we support HTML.
-export const remarkHtmlTransformer = $remark('remarkHTMLTransformer', () => () => (tree: Node) => {
-  flatMapWithDepth(tree, (node, _index, parent) => {
-    if (!isHTML(node))
-      return [node]
+export const remarkHtmlTransformer = $remark(
+  'remarkHTMLTransformer',
+  () => () => (tree: Node) => {
+    flatMapWithDepth(tree, (node, _index, parent) => {
+      if (!isHTML(node)) return [node]
 
-    if (parent?.type === 'root') {
-      node.children = [{ ...node }]
-      delete node.value;
-      (node as { type: string }).type = 'paragraph'
-    }
+      if (parent?.type === 'root') {
+        node.children = [{ ...node }]
+        delete node.value
+        ;(node as { type: string }).type = 'paragraph'
+      }
 
-    return [node]
-  })
-})
+      return [node]
+    })
+  }
+)
 
 withMeta(remarkHtmlTransformer.plugin, {
   displayName: 'Remark<remarkHtmlTransformer>',