@hcengineering/text-markdown 0.7.1

package/src/serializer.ts

@@ -0,0 +1,833 @@
+//
+// Copyright © 2025 Hardcore Engineering Inc.
+//
+// Licensed under the Eclipse Public License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License. You may
+// obtain a copy of the License at https://www.eclipse.org/legal/epl-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import { MarkupMark, MarkupNode, MarkupNodeType } from '@hcengineering/text-core'
+import { markupToHtml } from '@hcengineering/text-html'
+
+import { isInSet, markEq } from './marks'
+import { nodeContent, nodeAttrs } from './node'
+
+type FirstDelim = (i: number, attrs?: Record<string, any>, parentAttrs?: Record<string, any>) => string
+interface IState {
+  wrapBlock: (delim: string, firstDelim: string | null, node: MarkupNode, f: () => void) => void
+  flushClose: (size: number) => void
+  atBlank: () => void
+  ensureNewLine: () => void
+  write: (content: string) => void
+  closeBlock: (node: any) => void
+  text: (text: string, escape?: boolean) => void
+  render: (node: MarkupNode, parent: MarkupNode, index: number) => void
+  renderContent: (parent: MarkupNode) => void
+  renderInline: (parent: MarkupNode) => void
+  renderList: (node: MarkupNode, delim: string, firstDelim: FirstDelim) => void
+  esc: (str: string, startOfLine?: boolean) => string
+  htmlEsc: (str: string) => string
+  quote: (str: string) => string
+  repeat: (str: string, n: number) => string
+  markString: (mark: MarkupMark, open: boolean, parent: MarkupNode, index: number) => string
+  renderHtml: (node: MarkupNode) => string
+  refUrl: string
+  imageUrl: string
+  inAutolink?: boolean
+  renderAHref?: boolean
+}
+
+type NodeProcessor = (state: IState, node: MarkupNode, parent: MarkupNode, index: number) => void
+
+interface InlineState {
+  active: MarkupMark[]
+  trailing: string
+  parent: MarkupNode
+  node?: MarkupNode
+  marks: MarkupMark[]
+}
+
+// *************************************************************
+
+function backticksFor (side: boolean): string {
+  return side ? '`' : '`'
+}
+
+function isPlainURL (link: MarkupMark, parent: MarkupNode, index: number): boolean {
+  if (link.attrs?.title !== undefined || !/^\w+:/.test(link.attrs?.href)) return false
+  const content = parent.content?.[index]
+  if (content === undefined) {
+    return false
+  }
+  if (
+    content.type !== MarkupNodeType.text ||
+    content.text !== link.attrs?.href ||
+    content.marks?.[content.marks.length - 1] !== link
+  ) {
+    return false
+  }
+  return index === (parent.content?.length ?? 0) - 1 || !isInSet(link, parent.content?.[index + 1]?.marks ?? [])
+}
+
+const formatTodoItem: FirstDelim = (i, attrs, parentAttrs?: Record<string, any>) => {
+  const meta =
+    attrs?.todoid !== undefined && attrs?.userid !== undefined
+      ? `<!-- todoid=${attrs?.todoid},userid=${attrs?.userid} -->`
+      : ''
+
+  const bullet = parentAttrs?.bullet ?? '*'
+  return `${bullet} [${attrs?.checked === true ? 'x' : ' '}] ${meta}`
+}
+
+// *************************************************************
+
+export const storeNodes: Record<string, NodeProcessor> = {
+  blockquote: (state, node) => {
+    state.wrapBlock('> ', null, node, () => {
+      state.renderContent(node)
+    })
+  },
+  codeBlock: (state, node) => {
+    state.write('```' + `${nodeAttrs(node).language ?? ''}` + '\n')
+    // TODO: Check for node.textContent
+    state.renderInline(node)
+    // state.text(node.text ?? '', false)
+    state.ensureNewLine()
+    state.write('```')
+    state.closeBlock(node)
+  },
+  mermaid: (state, node) => {
+    state.write('```mermaid\n')
+    state.renderInline(node)
+    state.ensureNewLine()
+    state.write('```')
+    state.closeBlock(node)
+  },
+  heading: (state, node) => {
+    const attrs = nodeAttrs(node)
+    if (attrs.marker === '=' && attrs.level === 1) {
+      state.renderInline(node)
+      state.ensureNewLine()
+      state.write('===\n')
+    } else if (attrs.marker === '-' && attrs.level === 2) {
+      state.renderInline(node)
+      state.ensureNewLine()
+      state.write('---\n')
+    } else {
+      state.write(state.repeat('#', attrs.level !== undefined ? Number(attrs.level) : 1) + ' ')
+      state.renderInline(node)
+    }
+    state.closeBlock(node)
+  },
+  horizontalRule: (state, node) => {
+    state.write(`${nodeAttrs(node).markup ?? '---'}`)
+    state.closeBlock(node)
+  },
+  bulletList: (state, node) => {
+    state.renderList(node, '  ', () => `${nodeAttrs(node).bullet ?? '*'}` + ' ')
+  },
+  taskList: (state, node) => {
+    state.renderList(node, '  ', () => '* [ ]' + ' ')
+  },
+  todoList: (state, node) => {
+    state.renderList(node, '  ', formatTodoItem)
+  },
+  orderedList: (state, node) => {
+    let start = 1
+    if (nodeAttrs(node).order !== undefined) {
+      start = Number(nodeAttrs(node).order)
+    }
+    const maxW = String(start + nodeContent(node).length - 1).length
+    const space = state.repeat(' ', maxW + 2)
+    state.renderList(node, space, (i: number) => {
+      const nStr = String(start + i)
+      return state.repeat(' ', maxW - nStr.length) + nStr + '. '
+    })
+  },
+  listItem: (state, node) => {
+    state.renderContent(node)
+  },
+  taskItem: (state, node) => {
+    state.renderContent(node)
+  },
+  todoItem: (state, node) => {
+    state.renderContent(node)
+  },
+  paragraph: (state, node) => {
+    state.renderInline(node)
+    state.closeBlock(node)
+  },
+  subLink: (state, node) => {
+    state.write('<sub>')
+    state.renderAHref = true
+    state.renderInline(node)
+    state.renderAHref = false
+    state.write('</sub>')
+  },
+
+  image: (state, node) => {
+    const attrs = nodeAttrs(node)
+    if (attrs.token != null && attrs['file-id'] != null) {
+      // Convert image to token format
+      state.write(
+        '![' +
+          state.esc(`${attrs.alt ?? ''}`) +
+          '](' +
+          (state.imageUrl +
+            `${attrs['file-id']}` +
+            `?file=${attrs['file-id']}` +
+            (attrs.width != null ? '&width=' + state.esc(`${attrs.width}`) : '') +
+            (attrs.height != null ? '&height=' + state.esc(`${attrs.height}`) : '') +
+            (attrs.token != null ? '&token=' + state.esc(`${attrs.token}`) : '')) +
+          (attrs.title != null ? ' ' + state.quote(`${attrs.title}`) : '') +
+          ')'
+      )
+    } else if (attrs['file-id'] != null) {
+      // Convert image to fileid format
+      state.write(
+        '![' +
+          state.esc(`${attrs.alt ?? ''}`) +
+          '](' +
+          (state.imageUrl +
+            `${attrs['file-id']}` +
+            (attrs.width != null ? '&width=' + state.esc(`${attrs.width}`) : '') +
+            (attrs.height != null ? '&height=' + state.esc(`${attrs.height}`) : '')) +
+          (attrs.title != null ? ' ' + state.quote(`${attrs.title}`) : '') +
+          ')'
+      )
+    } else {
+      if (attrs.width != null || attrs.height != null) {
+        state.write(
+          '<img' +
+            (attrs.width != null ? ` width="${state.esc(`${attrs.width}`)}"` : '') +
+            (attrs.height != null ? ` height="${state.esc(`${attrs.height}`)}"` : '') +
+            ` src="${state.esc(`${attrs.src}`)}"` +
+            (attrs.alt != null ? ` alt="${state.esc(`${attrs.alt}`)}"` : '') +
+            (attrs.title != null ? '>' + state.quote(`${attrs.title}`) + '</img>' : '>')
+        )
+      } else {
+        state.write(
+          '![' +
+            state.esc(`${attrs.alt ?? ''}`) +
+            '](' +
+            state.esc(`${attrs.src}`) +
+            (attrs.title != null ? ' ' + state.quote(`${attrs.title}`) : '') +
+            ')'
+        )
+      }
+    }
+  },
+  reference: (state, node) => {
+    const attrs = nodeAttrs(node)
+    let url = state.refUrl
+    if (!url.includes('?')) {
+      url += '?'
+    } else {
+      url += '&'
+    }
+    state.write(
+      '[' +
+        state.esc(`${attrs.label ?? ''}`) +
+        '](' +
+        `${url}${makeQuery({
+          _class: attrs.objectclass,
+          _id: attrs.id,
+          label: attrs.label
+        })}` +
+        (attrs.title !== undefined ? ' ' + state.quote(`${attrs.title}`) : '') +
+        ')'
+    )
+  },
+  markdown: (state, node) => {
+    state.renderInline(node)
+    state.closeBlock(node)
+  },
+  comment: (state, node) => {
+    state.write('<!--')
+    state.renderInline(node)
+    state.write('-->')
+  },
+  hardBreak: (state, node, parent, index) => {
+    const content = nodeContent(parent)
+    for (let i = index + 1; i < content.length; i++) {
+      if (content[i].type !== node.type) {
+        state.write('\\\n')
+        return
+      }
+    }
+  },
+  text: (state, node) => {
+    // Check if test has reference mark, in this case we need to remove [[]]
+    state.text(node.text ?? '')
+  },
+  emoji: (state, node) => {
+    state.text(node.attrs?.emoji as string)
+  },
+  table: (state, node) => {
+    state.write(state.renderHtml(node))
+    state.closeBlock(node)
+  },
+  embed: (state, node) => {
+    const attrs = nodeAttrs(node)
+    const embedUrl = attrs.src as string
+    state.write(`<a href="${encodeURI(embedUrl)}" data-type="embed">`)
+    // Slashes are escaped to prevent autolink creation
+    state.write(state.htmlEsc(embedUrl).replace(/\//g, '&#x2F;'))
+    state.write('</a>')
+  }
+}
+
+interface MarkProcessor {
+  open: ((_state: IState, mark: MarkupMark, parent: MarkupNode, index: number) => string) | string
+  close: ((_state: IState, mark: MarkupMark, parent: MarkupNode, index: number) => string) | string
+  mixable: boolean
+  expelEnclosingWhitespace: boolean
+  escape: boolean
+}
+
+export const storeMarks: Record<string, MarkProcessor> = {
+  em: {
+    open: '*',
+    close: '*',
+    mixable: true,
+    expelEnclosingWhitespace: true,
+    escape: true
+  },
+  italic: {
+    open: '*',
+    close: '*',
+    mixable: true,
+    expelEnclosingWhitespace: true,
+    escape: true
+  },
+  bold: {
+    open: '**',
+    close: '**',
+    mixable: true,
+    expelEnclosingWhitespace: true,
+    escape: true
+  },
+  strong: {
+    open: '**',
+    close: '**',
+    mixable: true,
+    expelEnclosingWhitespace: true,
+    escape: true
+  },
+  strike: {
+    open: '~~',
+    close: '~~',
+    mixable: true,
+    expelEnclosingWhitespace: true,
+    escape: true
+  },
+  underline: {
+    open: '<ins>',
+    close: '</ins>',
+    mixable: true,
+    expelEnclosingWhitespace: true,
+    escape: true
+  },
+  link: {
+    open: (state, mark, parent, index) => {
+      if (state.renderAHref === true) {
+        return `<a href="${encodeURI(mark.attrs?.href)}">`
+      } else {
+        state.inAutolink = isPlainURL(mark, parent, index)
+        return state.inAutolink ? '<' : '['
+      }
+    },
+    close: (state, mark, parent, index) => {
+      if (state.renderAHref === true) {
+        return '</a>'
+      } else {
+        const { inAutolink } = state
+        state.inAutolink = undefined
+
+        const href = (mark.attrs?.href as string) ?? ''
+        // eslint-disable-next-line
+        const url = href.replace(/[\(\)"\\<>]/g, '\\$&')
+        const hasSpaces = url.includes(' ')
+
+        return inAutolink === true
+          ? '>'
+          : '](' +
+              (hasSpaces ? `<${url}>` : url) +
+              (mark.attrs?.title !== undefined ? ` "${(mark.attrs?.title as string).replace(/"/g, '\\"')}"` : '') +
+              ')'
+      }
+    },
+    mixable: false,
+    expelEnclosingWhitespace: false,
+    escape: true
+  },
+  code: {
+    open: (state, mark, parent, index) => {
+      return backticksFor(false)
+    },
+    close: (state, mark, parent, index) => {
+      return backticksFor(true)
+    },
+    mixable: false,
+    expelEnclosingWhitespace: false,
+    escape: false
+  }
+}
+
+export type HtmlWriter = (markup: MarkupNode) => string
+
+export interface StateOptions {
+  tightLists: boolean
+  refUrl: string
+  imageUrl: string
+  htmlWriter?: HtmlWriter
+}
+export class MarkdownState implements IState {
+  nodes: Record<string, NodeProcessor>
+  marks: Record<string, MarkProcessor>
+  delim: string
+  out: string
+  closed: boolean
+  closedNode?: MarkupNode
+  inTightList: boolean
+  options: StateOptions
+  refUrl: string
+  imageUrl: string
+  htmlWriter: HtmlWriter
+
+  constructor (
+    nodes = storeNodes,
+    marks = storeMarks,
+    options: StateOptions = { tightLists: true, refUrl: 'ref://', imageUrl: 'http://' }
+  ) {
+    this.nodes = nodes
+    this.marks = marks
+    this.delim = this.out = ''
+    this.closed = false
+    this.inTightList = false
+    this.refUrl = options.refUrl
+    this.imageUrl = options.imageUrl
+    this.htmlWriter = options.htmlWriter ?? markupToHtml
+
+    this.options = options
+  }
+
+  flushClose (size: number): void {
+    if (this.closed) {
+      if (!this.atBlank()) this.out += '\n'
+      if (size > 1) {
+        this.addDelim(size)
+      }
+      this.closed = false
+    }
+  }
+
+  private addDelim (size: number): void {
+    let delimMin = this.delim
+    const trim = /\s+$/.exec(delimMin)
+    if (trim !== null) {
+      delimMin = delimMin.slice(0, delimMin.length - trim[0].length)
+    }
+    for (let i = 1; i < size; i++) {
+      this.out += delimMin + '\n'
+    }
+  }
+
+  renderHtml (node: MarkupNode): string {
+    return this.htmlWriter(node)
+  }
+
+  wrapBlock (delim: string, firstDelim: string | null, node: MarkupNode, f: () => void): void {
+    const old = this.delim
+    this.write(firstDelim ?? delim)
+    this.delim += delim
+    f()
+    this.delim = old
+    this.closeBlock(node)
+  }
+
+  atBlank (): boolean {
+    return /(^|\n)$/.test(this.out)
+  }
+
+  // :: ()
+  // Ensure the current content ends with a newline.
+  ensureNewLine (): void {
+    if (!this.atBlank()) this.out += '\n'
+  }
+
+  // :: (?string)
+  // Prepare the state for writing output (closing closed paragraphs,
+  // adding delimiters, and so on), and then optionally add content
+  // (unescaped) to the output.
+  write (content: string): void {
+    this.flushClose(2)
+    if (this.delim !== undefined && this.atBlank()) this.out += this.delim
+    if (content.length > 0) this.out += content
+  }
+
+  // :: (Node)
+  // Close the block for the given node.
+  closeBlock (node: MarkupNode): void {
+    this.closedNode = node
+    this.closed = true
+  }
+
+  // :: (string, ?bool)
+  // Add the given text to the document. When escape is not `false`,
+  // it will be escaped.
+  text (text: string, escape = false): void {
+    const lines = text.split('\n')
+    for (let i = 0; i < lines.length; i++) {
+      const startOfLine = this.atBlank() || this.closed
+      this.write('')
+      this.out += escape ? this.esc(lines[i], startOfLine) : lines[i]
+      if (i !== lines.length - 1) this.out += '\n'
+    }
+  }
+
+  // :: (Node)
+  // Render the given node as a block.
+  render (node: MarkupNode, parent: MarkupNode, index: number): void {
+    if (this.nodes[node.type] === undefined) {
+      throw new Error('Token type `' + node.type + '` not supported by Markdown renderer')
+    }
+    this.nodes[node.type](this, node, parent, index)
+  }
+
+  // :: (Node)
+  // Render the contents of `parent` as block nodes.
+  renderContent (parent: MarkupNode): void {
+    nodeContent(parent).forEach((node: MarkupNode, i: number) => {
+      this.render(node, parent, i)
+    })
+  }
+
+  reorderMixableMark (state: InlineState, mark: MarkupMark, i: number, len: number): void {
+    for (let j = 0; j < state.active.length; j++) {
+      const other = state.active[j]
+      if (!this.marks[other.type].mixable || this.checkSwitchMarks(i, j, state, mark, other, len)) {
+        break
+      }
+    }
+  }
+
+  reorderMixableMarks (state: InlineState, len: number): void {
+    // Try to reorder 'mixable' marks, such as em and strong, which
+    // in Markdown may be opened and closed in different order, so
+    // that order of the marks for the token matches the order in
+    // active.
+
+    for (let i = 0; i < len; i++) {
+      const mark = state.marks[i]
+      const mm = this.marks[mark.type]
+      if (mm == null) {
+        break
+      }
+      if (!mm.mixable) break
+      this.reorderMixableMark(state, mark, i, len)
+    }
+  }
+
+  private checkSwitchMarks (
+    i: number,
+    j: number,
+    state: InlineState,
+    mark: MarkupMark,
+    other: MarkupMark,
+    len: number
+  ): boolean {
+    if (!markEq(mark, other) || i === j) {
+      return false
+    }
+    this.switchMarks(i, j, state, mark, len)
+    return true
+  }
+
+  private switchMarks (i: number, j: number, state: InlineState, mark: MarkupMark, len: number): void {
+    if (i > j) {
+      state.marks = state.marks
+        .slice(0, j)
+        .concat(mark)
+        .concat(state.marks.slice(j, i))
+        .concat(state.marks.slice(i + 1, len))
+    }
+    if (j > i) {
+      state.marks = state.marks
+        .slice(0, i)
+        .concat(state.marks.slice(i + 1, j))
+        .concat(mark)
+        .concat(state.marks.slice(j, len))
+    }
+  }
+
+  renderNodeInline (state: InlineState, index: number): void {
+    state.marks = state.node?.marks ?? []
+    this.updateHardBreakMarks(state, index)
+
+    const leading = this.adjustLeading(state)
+
+    const inner: MarkupMark | undefined = state.marks.length > 0 ? state.marks[state.marks.length - 1] : undefined
+    const noEsc = inner !== undefined && !(this.marks[inner.type]?.escape ?? false)
+    const len = state.marks.length - (noEsc ? 1 : 0)
+
+    this.reorderMixableMarks(state, len)
+
+    // Find the prefix of the mark set that didn't change
+    this.checkCloseMarks(state, len, index)
+
+    // Output any previously expelled trailing whitespace outside the marks
+    if (leading !== '') this.text(leading)
+
+    // Open the marks that need to be opened
+    this.checkOpenMarks(state, len, index, inner, noEsc)
+  }
+
+  private checkOpenMarks (
+    state: InlineState,
+    len: number,
+    index: number,
+    inner: MarkupMark | undefined,
+    noEsc: boolean
+  ): void {
+    if (state.node !== undefined) {
+      this.updateActiveMarks(state, len, index)
+
+      // Render the node. Special case code marks, since their content
+      // may not be escaped.
+      if (this.isNoEscapeRequire(state.node, inner, noEsc, state)) {
+        this.renderMarkText(inner as MarkupMark, state, index)
+      } else {
+        this.render(state.node, state.parent, index)
+      }
+    }
+  }
+
+  private isNoEscapeRequire (
+    node: MarkupNode,
+    inner: MarkupMark | undefined,
+    noEsc: boolean,
+    state: InlineState
+  ): boolean {
+    return inner !== undefined && noEsc && node.type === MarkupNodeType.text
+  }
+
+  private renderMarkText (inner: MarkupMark, state: InlineState, index: number): void {
+    this.text(
+      this.markString(inner, true, state.parent, index) +
+        (state.node?.text as string) +
+        this.markString(inner, false, state.parent, index + 1),
+      false
+    )
+  }
+
+  private updateActiveMarks (state: InlineState, len: number, index: number): void {
+    while (state.active.length < len) {
+      const add = state.marks[state.active.length]
+      state.active.push(add)
+      this.text(this.markString(add, true, state.parent, index), false)
+    }
+  }
+
+  private checkCloseMarks (state: InlineState, len: number, index: number): void {
+    let keep = 0
+    while (keep < Math.min(state.active.length, len) && markEq(state.marks[keep], state.active[keep])) {
+      ++keep
+    }
+
+    // Close the marks that need to be closed
+    while (keep < state.active.length) {
+      const mark = state.active.pop()
+      if (mark !== undefined) {
+        this.text(this.markString(mark, false, state.parent, index), false)
+      }
+    }
+  }
+
+  private adjustLeading (state: InlineState): string {
+    let leading = state.trailing
+    state.trailing = ''
+    // If whitespace has to be expelled from the node, adjust
+    // leading and trailing accordingly.
+    const node = state?.node
+    if (this.isText(node) && this.isMarksHasExpelEnclosingWhitespace(state)) {
+      const match = /^(\s*)(.*?)(\s*)$/m.exec(node?.text ?? '')
+      if (match !== null) {
+        const [leadMatch, innerMatch, trailMatch] = [match[1], match[2], match[3]]
+        leading += leadMatch
+        state.trailing = trailMatch
+        this.adjustLeadingTextNode(leadMatch, trailMatch, state, innerMatch, node as MarkupNode)
+      }
+    }
+    return leading
+  }
+
+  private isMarksHasExpelEnclosingWhitespace (state: InlineState): boolean {
+    return state.marks.some((mark) => this.marks[mark.type]?.expelEnclosingWhitespace)
+  }
+
+  private adjustLeadingTextNode (
+    lead: string,
+    trail: string,
+    state: InlineState,
+    inner: string,
+    node: MarkupNode
+  ): void {
+    if (lead !== '' || trail !== '') {
+      state.node = inner !== undefined ? { ...node, text: inner } : undefined
+      if (state.node === undefined) {
+        state.marks = state.active
+      }
+    }
+  }
+
+  private updateHardBreakMarks (state: InlineState, index: number): void {
+    if (state.node !== undefined && state.node.type === MarkupNodeType.hard_break) {
+      state.marks = this.filterHardBreakMarks(state.marks, index, state)
+    }
+  }
+
+  private filterHardBreakMarks (marks: MarkupMark[], index: number, state: InlineState): MarkupMark[] {
+    const content = state.parent.content ?? []
+    const next = content[index + 1]
+    if (!this.isHardbreakText(next)) {
+      return []
+    }
+    return marks.filter((m) => isInSet(m, next.marks ?? []))
+  }
+
+  private isHardbreakText (next?: MarkupNode): boolean {
+    return (
+      next !== undefined && (next.type !== MarkupNodeType.text || (next.text !== undefined && /\S/.test(next.text)))
+    )
+  }
+
+  private isText (node?: MarkupNode): boolean {
+    return node !== undefined && node.type === MarkupNodeType.text && node.text !== undefined
+  }
+
+  // :: (Node)
+  // Render the contents of `parent` as inline content.
+  renderInline (parent: MarkupNode): void {
+    const state: InlineState = { active: [], trailing: '', parent, marks: [] }
+    nodeContent(parent).forEach((nde, index) => {
+      state.node = nde
+      this.renderNodeInline(state, index)
+    })
+    state.node = undefined
+    this.renderNodeInline(state, 0)
+  }
+
+  // :: (Node, string, (number) → string)
+  // Render a node's content as a list. `delim` should be the extra
+  // indentation added to all lines except the first in an item,
+  // `firstDelim` is a function going from an item index to a
+  // delimiter for the first line of the item.
+  renderList (node: MarkupNode, delim: string, firstDelim: FirstDelim): void {
+    this.flushListClose(node)
+
+    const isTight: boolean =
+      typeof node.attrs?.tight !== 'undefined' ? node.attrs.tight === 'true' : this.options.tightLists
+    const prevTight = this.inTightList
+    this.inTightList = isTight
+
+    nodeContent(node).forEach((child, i) => {
+      this.renderListItem(node, child, i, isTight, delim, firstDelim)
+    })
+    this.inTightList = prevTight
+  }
+
+  renderListItem (
+    node: MarkupNode,
+    child: MarkupNode,
+    i: number,
+    isTight: boolean,
+    delim: string,
+    firstDelim: FirstDelim
+  ): void {
+    if (i > 0 && isTight) this.flushClose(1)
+    this.wrapBlock(delim, firstDelim(i, node.content?.[i].attrs, node.attrs), node, () => {
+      this.render(child, node, i)
+    })
+  }
+
+  private flushListClose (node: MarkupNode): void {
+    if (this.closed && this.closedNode?.type === node.type) {
+      this.flushClose(3)
+    } else if (this.inTightList) {
+      this.flushClose(1)
+    }
+  }
+
+  // :: (string, ?bool) → string
+  // Escape the given string so that it can safely appear in Markdown
+  // content. If `startOfLine` is true, also escape characters that
+  // has special meaning only at the start of the line.
+  esc (str: string, startOfLine = false): string {
+    if (str == null) {
+      return ''
+    }
+    str = str.replace(/[`*\\~\[\]]/g, '\\$&') // eslint-disable-line
+    if (startOfLine) {
+      str = str.replace(/^[:#\-*+]/, '\\$&').replace(/^(\d+)\./, '$1\\.')
+    }
+    str = str.replace(/\r?\n/g, '\\\n')
+    return str
+  }
+
+  htmlEsc (str: string): string {
+    if (str == null) {
+      return ''
+    }
+
+    return str
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#039;')
+  }
+
+  quote (str: string): string {
+    const wrap = !(str?.includes('"') ?? false) ? '""' : !(str?.includes("'") ?? false) ? "''" : '()'
+    return wrap[0] + str + wrap[1]
+  }
+
+  // :: (string, number) → string
+  // Repeat the given string `n` times.
+  repeat (str: string, n: number): string {
+    let out = ''
+    for (let i = 0; i < n; i++) out += str
+    return out
+  }
+
+  // : (Mark, bool, string?) → string
+  // Get the markdown string for a given opening or closing mark.
+  markString (mark: MarkupMark, open: boolean, parent: MarkupNode, index: number): string {
+    let value = mark.attrs?.marker
+    if (value === undefined) {
+      const info = this.marks[mark.type]
+      if (info == null) {
+        throw new Error(`No info for mark ${mark.type}`)
+      }
+      value = open ? info.open : info.close
+    }
+    return typeof value === 'string' ? value : (value(this, mark, parent, index) ?? '')
+  }
+}
+
+function makeQuery (obj: Record<string, string | number | boolean | null | undefined>): string {
+  return Object.keys(obj)
+    .filter((it) => it[1] != null)
+    .map(function (k) {
+      return encodeURIComponent(k) + '=' + encodeURIComponent(obj[k] as string | number | boolean)
+    })
+    .join('&')
+}