@depup/prosemirror-markdown 1.13.4-depup.0

package/src/to_markdown.ts

@@ -0,0 +1,483 @@
+import {Node, Mark} from "prosemirror-model"
+
+type MarkSerializerSpec = {
+  /// The string that should appear before a piece of content marked
+  /// by this mark, either directly or as a function that returns an
+  /// appropriate string.
+  open: string | ((state: MarkdownSerializerState, mark: Mark, parent: Node, index: number) => string),
+  /// The string that should appear after a piece of content marked by
+  /// this mark.
+  close: string | ((state: MarkdownSerializerState, mark: Mark, parent: Node, index: number) => string),
+  /// When `true`, this indicates that the order in which the mark's
+  /// opening and closing syntax appears relative to other mixable
+  /// marks can be varied. (For example, you can say `**a *b***` and
+  /// `*a **b***`, but not `` `a *b*` ``.)
+  mixable?: boolean,
+  /// When enabled, causes the serializer to move enclosing whitespace
+  /// from inside the marks to outside the marks. This is necessary
+  /// for emphasis marks as CommonMark does not permit enclosing
+  /// whitespace inside emphasis marks, see:
+  /// http:///spec.commonmark.org/0.26/#example-330
+  expelEnclosingWhitespace?: boolean,
+  /// Can be set to `false` to disable character escaping in a mark. A
+  /// non-escaping mark has to have the highest precedence (must
+  /// always be the innermost mark).
+  escape?: boolean
+}
+
+const blankMark: MarkSerializerSpec = {open: "", close: "", mixable: true}
+
+/// A specification for serializing a ProseMirror document as
+/// Markdown/CommonMark text.
+export class MarkdownSerializer {
+  /// Construct a serializer with the given configuration. The `nodes`
+  /// object should map node names in a given schema to function that
+  /// take a serializer state and such a node, and serialize the node.
+  constructor(
+    /// The node serializer functions for this serializer.
+    readonly nodes: {[node: string]: (state: MarkdownSerializerState, node: Node, parent: Node, index: number) => void},
+    /// The mark serializer info.
+    readonly marks: {[mark: string]: MarkSerializerSpec},
+    readonly options: {
+      /// Extra characters can be added for escaping. This is passed
+      /// directly to String.replace(), and the matching characters are
+      /// preceded by a backslash.
+      escapeExtraCharacters?: RegExp,
+      /// Specify the node name of hard breaks.
+      /// Defaults to "hard_break"
+      hardBreakNodeName?: string,
+      /// By default, the serializer raises an error when it finds a
+      /// node or mark type for which no serializer is defined. Set
+      /// this to `false` to make it just ignore such elements,
+      /// rendering only their content.
+      strict?: boolean
+    } = {}
+  ) {}
+
+  /// Serialize the content of the given node to
+  /// [CommonMark](http://commonmark.org/).
+  serialize(content: Node, options: {
+    /// Whether to render lists in a tight style. This can be overridden
+    /// on a node level by specifying a tight attribute on the node.
+    /// Defaults to false.
+    tightLists?: boolean
+  } = {}) {
+    options = Object.assign({}, this.options, options)
+    let state = new MarkdownSerializerState(this.nodes, this.marks, options)
+    state.renderContent(content)
+    return state.out
+  }
+}
+
+/// A serializer for the [basic schema](#schema).
+export const defaultMarkdownSerializer = new MarkdownSerializer({
+  blockquote(state, node) {
+    state.wrapBlock("> ", null, node, () => state.renderContent(node))
+  },
+  code_block(state, node) {
+    // Make sure the front matter fences are longer than any dash sequence within it
+    const backticks = node.textContent.match(/`{3,}/gm)
+    const fence = backticks ? (backticks.sort().slice(-1)[0] + "`") : "```"
+
+    state.write(fence + (node.attrs.params || "") + "\n")
+    state.text(node.textContent, false)
+    // Add a newline to the current content before adding closing marker
+    state.write("\n")
+    state.write(fence)
+    state.closeBlock(node)
+  },
+  heading(state, node) {
+    state.write(state.repeat("#", node.attrs.level) + " ")
+    state.renderInline(node, false)
+    state.closeBlock(node)
+  },
+  horizontal_rule(state, node) {
+    state.write(node.attrs.markup || "---")
+    state.closeBlock(node)
+  },
+  bullet_list(state, node) {
+    state.renderList(node, "  ", () => (node.attrs.bullet || "*") + " ")
+  },
+  ordered_list(state, node) {
+    let start = node.attrs.order || 1
+    let maxW = String(start + node.childCount - 1).length
+    let space = state.repeat(" ", maxW + 2)
+    state.renderList(node, space, i => {
+      let nStr = String(start + i)
+      return state.repeat(" ", maxW - nStr.length) + nStr + ". "
+    })
+  },
+  list_item(state, node) {
+    state.renderContent(node)
+  },
+  paragraph(state, node) {
+    state.renderInline(node)
+    state.closeBlock(node)
+  },
+
+  image(state, node) {
+    state.write("![" + state.esc(node.attrs.alt || "") + "](" + node.attrs.src.replace(/[\(\)]/g, "\\$&") +
+                (node.attrs.title ? ' "' + node.attrs.title.replace(/"/g, '\\"') + '"' : "") + ")")
+  },
+  hard_break(state, node, parent, index) {
+    for (let i = index + 1; i < parent.childCount; i++)
+      if (parent.child(i).type != node.type) {
+        state.write("\\\n")
+        return
+      }
+  },
+  text(state, node) {
+    state.text(node.text!, !state.inAutolink)
+  }
+}, {
+  em: {open: "*", close: "*", mixable: true, expelEnclosingWhitespace: true},
+  strong: {open: "**", close: "**", mixable: true, expelEnclosingWhitespace: true},
+  link: {
+    open(state, mark, parent, index) {
+      state.inAutolink = isPlainURL(mark, parent, index)
+      return state.inAutolink ? "<" : "["
+    },
+    close(state, mark, parent, index) {
+      let {inAutolink} = state
+      state.inAutolink = undefined
+      return inAutolink ? ">"
+        : "](" + mark.attrs.href.replace(/[\(\)"]/g, "\\$&") + (mark.attrs.title ? ` "${mark.attrs.title.replace(/"/g, '\\"')}"` : "") + ")"
+    },
+    mixable: true
+  },
+  code: {open(_state, _mark, parent, index) { return backticksFor(parent.child(index), -1) },
+         close(_state, _mark, parent, index) { return backticksFor(parent.child(index - 1), 1) },
+         escape: false}
+})
+
+function backticksFor(node: Node, side: number) {
+  let ticks = /`+/g, m: RegExpExecArray | null, len = 0
+  if (node.isText) while (m = ticks.exec(node.text!)) len = Math.max(len, m[0].length)
+  let result = len > 0 && side > 0 ? " `" : "`"
+  for (let i = 0; i < len; i++) result += "`"
+  if (len > 0 && side < 0) result += " "
+  return result
+}
+
+function isPlainURL(link: Mark, parent: Node, index: number) {
+  if (link.attrs.title || !/^\w+:/.test(link.attrs.href)) return false
+  let content = parent.child(index)
+  if (!content.isText || content.text != link.attrs.href || content.marks[content.marks.length - 1] != link) return false
+  return index == parent.childCount - 1 || !link.isInSet(parent.child(index + 1).marks)
+}
+
+/// This is an object used to track state and expose
+/// methods related to markdown serialization. Instances are passed to
+/// node and mark serialization methods (see `toMarkdown`).
+export class MarkdownSerializerState {
+  /// @internal
+  delim: string = ""
+  /// @internal
+  out: string = ""
+  /// @internal
+  closed: Node | null = null
+  /// @internal
+  inAutolink: boolean | undefined = undefined
+  /// @internal
+  atBlockStart: boolean = false
+  /// @internal
+  inTightList: boolean = false
+
+  /// @internal
+  constructor(
+    /// @internal
+    readonly nodes: {[node: string]: (state: MarkdownSerializerState, node: Node, parent: Node, index: number) => void},
+    /// @internal
+    readonly marks: {[mark: string]: MarkSerializerSpec},
+    /// The options passed to the serializer.
+    readonly options: {tightLists?: boolean, escapeExtraCharacters?: RegExp, hardBreakNodeName?: string, strict?: boolean}
+  ) {
+    if (typeof this.options.tightLists == "undefined")
+      this.options.tightLists = false
+    if (typeof this.options.hardBreakNodeName == "undefined")
+      this.options.hardBreakNodeName = "hard_break"
+  }
+
+  /// @internal
+  flushClose(size: number = 2) {
+    if (this.closed) {
+      if (!this.atBlank()) this.out += "\n"
+      if (size > 1) {
+        let delimMin = this.delim
+        let trim = /\s+$/.exec(delimMin)
+        if (trim) delimMin = delimMin.slice(0, delimMin.length - trim[0].length)
+        for (let i = 1; i < size; i++)
+          this.out += delimMin + "\n"
+      }
+      this.closed = null
+    }
+  }
+
+  /// @internal
+  getMark(name: string) {
+    let info = this.marks[name]
+    if (!info) {
+      if (this.options.strict !== false)
+        throw new Error(`Mark type \`${name}\` not supported by Markdown renderer`)
+      info = blankMark
+    }
+    return info
+  }
+
+  /// Render a block, prefixing each line with `delim`, and the first
+  /// line in `firstDelim`. `node` should be the node that is closed at
+  /// the end of the block, and `f` is a function that renders the
+  /// content of the block.
+  wrapBlock(delim: string, firstDelim: string | null, node: Node, f: () => void) {
+    let old = this.delim
+    this.write(firstDelim != null ? firstDelim : delim)
+    this.delim += delim
+    f()
+    this.delim = old
+    this.closeBlock(node)
+  }
+
+  /// @internal
+  atBlank() {
+    return /(^|\n)$/.test(this.out)
+  }
+
+  /// Ensure the current content ends with a newline.
+  ensureNewLine() {
+    if (!this.atBlank()) this.out += "\n"
+  }
+
+  /// 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) {
+    this.flushClose()
+    if (this.delim && this.atBlank())
+      this.out += this.delim
+    if (content) this.out += content
+  }
+
+  /// Close the block for the given node.
+  closeBlock(node: Node) {
+    this.closed = node
+  }
+
+  /// Add the given text to the document. When escape is not `false`,
+  /// it will be escaped.
+  text(text: string, escape = true) {
+    let lines = text.split("\n")
+    for (let i = 0; i < lines.length; i++) {
+      this.write()
+      // Escape exclamation marks in front of links
+      if (!escape && lines[i][0] == "[" && /(^|[^\\])\!$/.test(this.out))
+        this.out = this.out.slice(0, this.out.length - 1) + "\\!"
+      this.out += escape ? this.esc(lines[i], this.atBlockStart) : lines[i]
+      if (i != lines.length - 1) this.out += "\n"
+    }
+  }
+
+  /// Render the given node as a block.
+  render(node: Node, parent: Node, index: number) {
+    if (this.nodes[node.type.name]) {
+      this.nodes[node.type.name](this, node, parent, index)
+    } else {
+      if (this.options.strict !== false) {
+        throw new Error("Token type `" + node.type.name + "` not supported by Markdown renderer")
+      } else if (!node.type.isLeaf) {
+        if (node.type.inlineContent) this.renderInline(node)
+        else this.renderContent(node)
+        if (node.isBlock) this.closeBlock(node)
+      }
+    }
+  }
+
+  /// Render the contents of `parent` as block nodes.
+  renderContent(parent: Node) {
+    parent.forEach((node, _, i) => this.render(node, parent, i))
+  }
+
+  /// Render the contents of `parent` as inline content.
+  renderInline(parent: Node, fromBlockStart = true) {
+    this.atBlockStart = fromBlockStart
+    let active: Mark[] = [], trailing = ""
+    let progress = (node: Node | null, offset: number, index: number) => {
+      let marks = node ? node.marks : []
+
+      // Remove marks from `hard_break` that are the last node inside
+      // that mark to prevent parser edge cases with new lines just
+      // before closing marks.
+      if (node && node.type.name === this.options.hardBreakNodeName)
+        marks = marks.filter(m => {
+          if (index + 1 == parent.childCount) return false
+          let next = parent.child(index + 1)
+          return m.isInSet(next.marks) && (!next.isText || /\S/.test(next.text!))
+        })
+
+      let leading = trailing
+      trailing = ""
+      // If whitespace has to be expelled from the node, adjust
+      // leading and trailing accordingly.
+      if (node && node.isText && marks.some(mark => {
+        let info = this.getMark(mark.type.name)
+        return info && info.expelEnclosingWhitespace && !mark.isInSet(active)
+      })) {
+        let [_, lead, rest] = /^(\s*)(.*)$/m.exec(node.text!)!
+        if (lead) {
+          leading += lead
+          node = rest ? (node as any).withText(rest) : null
+          if (!node) marks = active
+        }
+      }
+      if (node && node.isText && marks.some(mark => {
+        let info = this.getMark(mark.type.name)
+        return info && info.expelEnclosingWhitespace && !this.isMarkAhead(parent, index + 1, mark)
+      })) {
+        let [_, rest, trail] = /^(.*?)(\s*)$/m.exec(node.text!)!
+        if (trail) {
+          trailing = trail
+          node = rest ? (node as any).withText(rest) : null
+          if (!node) marks = active
+        }
+      }
+      let inner = marks.length ? marks[marks.length - 1] : null
+      let noEsc = inner && this.getMark(inner.type.name).escape === false
+      let len = marks.length - (noEsc ? 1 : 0)
+
+      // 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.
+      outer: for (let i = 0; i < len; i++) {
+        let mark = marks[i]
+        if (!this.getMark(mark.type.name).mixable) break
+        for (let j = 0; j < active.length; j++) {
+          let other = active[j]
+          if (!this.getMark(other.type.name).mixable) break
+          if (mark.eq(other)) {
+            if (i > j)
+              marks = marks.slice(0, j).concat(mark).concat(marks.slice(j, i)).concat(marks.slice(i + 1, len))
+            else if (j > i)
+              marks = marks.slice(0, i).concat(marks.slice(i + 1, j)).concat(mark).concat(marks.slice(j, len))
+            continue outer
+          }
+        }
+      }
+
+      // Find the prefix of the mark set that didn't change
+      let keep = 0
+      while (keep < Math.min(active.length, len) && marks[keep].eq(active[keep])) ++keep
+
+      // Close the marks that need to be closed
+      while (keep < active.length)
+        this.text(this.markString(active.pop()!, false, parent, index), false)
+
+      // Output any previously expelled trailing whitespace outside the marks
+      if (leading) this.text(leading)
+
+      // Open the marks that need to be opened
+      if (node) {
+        while (active.length < len) {
+          let add = marks[active.length]
+          active.push(add)
+          this.text(this.markString(add, true, parent, index), false)
+          this.atBlockStart = false
+        }
+
+        // Render the node. Special case code marks, since their content
+        // may not be escaped.
+        if (noEsc && node.isText)
+          this.text(this.markString(inner!, true, parent, index) + node.text +
+                    this.markString(inner!, false, parent, index + 1), false)
+        else
+          this.render(node, parent, index)
+        this.atBlockStart = false
+      }
+
+      // After the first non-empty text node is rendered, the end of output
+      // is no longer at block start.
+      //
+      // FIXME: If a non-text node writes something to the output for this
+      // block, the end of output is also no longer at block start. But how
+      // can we detect that?
+      if (node?.isText && node.nodeSize > 0) {
+        this.atBlockStart = false
+      }
+    }
+    parent.forEach(progress)
+    progress(null, 0, parent.childCount)
+    this.atBlockStart = false
+  }
+
+  /// 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: Node, delim: string, firstDelim: (index: number) => string) {
+    if (this.closed && this.closed.type == node.type)
+      this.flushClose(3)
+    else if (this.inTightList)
+      this.flushClose(1)
+
+    let isTight = typeof node.attrs.tight != "undefined" ? node.attrs.tight : this.options.tightLists
+    let prevTight = this.inTightList
+    this.inTightList = isTight
+    node.forEach((child, _, i) => {
+      if (i && isTight) this.flushClose(1)
+      this.wrapBlock(delim, firstDelim(i), node, () => this.render(child, node, i))
+    })
+    this.inTightList = prevTight
+  }
+
+  /// Escape the given string so that it can safely appear in Markdown
+  /// content. If `startOfLine` is true, also escape characters that
+  /// have special meaning only at the start of the line.
+  esc(str: string, startOfLine = false) {
+    str = str.replace(
+      /[`*\\~\[\]_]/g,
+      (m, i) => m == "_" && i > 0 && i + 1 < str.length && str[i-1].match(/\w/) && str[i+1].match(/\w/) ?  m : "\\" + m
+    )
+    if (startOfLine) str = str.replace(/^(\+[ ]|[\-*>])/, "\\$&").replace(/^(\s*)(#{1,6})(\s|$)/, '$1\\$2$3').replace(/^(\s*\d+)\.\s/, "$1\\. ")
+    if (this.options.escapeExtraCharacters) str = str.replace(this.options.escapeExtraCharacters, "\\$&")
+    return str
+  }
+
+  /// @internal
+  quote(str: string) {
+    let wrap = str.indexOf('"') == -1 ? '""' : str.indexOf("'") == -1 ? "''" : "()"
+    return wrap[0] + str + wrap[1]
+  }
+
+  /// Repeat the given string `n` times.
+  repeat(str: string, n: number) {
+    let out = ""
+    for (let i = 0; i < n; i++) out += str
+    return out
+  }
+
+  /// Get the markdown string for a given opening or closing mark.
+  markString(mark: Mark, open: boolean, parent: Node, index: number) {
+    let info = this.getMark(mark.type.name)
+    let value = open ? info.open : info.close
+    return typeof value == "string" ? value : value(this, mark, parent, index)
+  }
+
+  /// Get leading and trailing whitespace from a string. Values of
+  /// leading or trailing property of the return object will be undefined
+  /// if there is no match.
+  getEnclosingWhitespace(text: string): {leading?: string, trailing?: string} {
+    return {
+      leading: (text.match(/^(\s+)/) || [undefined])[0],
+      trailing: (text.match(/(\s+)$/) || [undefined])[0]
+    }
+  }
+
+  /// @internal
+  isMarkAhead(parent: Node, index: number, mark: Mark) {
+    for (;; index++) {
+      if (index >= parent.childCount) return false
+      let next = parent.child(index)
+      if (next.type.name != this.options.hardBreakNodeName) return mark.isInSet(next.marks)
+      index++
+    }
+  }
+}