如何编写 markdown-it 插件

- a

const MarkdownIt = require('markdown-it')
const md = new MarkdownIt()

const proxy = (tokens, idx, options, env, self) => self.renderToken(tokens, idx, options)
const defaultRenderer = md.renderer.rules.bullet_list_open || proxy

md.renderer.rules.bullet_list_open = (tokens, idx, options, env, self) => {
  // Make your changes here ...
  tokens[idx].attrJoin('class', 'lorem_ipsum')
  // ... then render it using the existing logic
  return defaultRenderer(tokens, idx, options, env, self)
}

console.log(md.render('- Hello World'))

const md = new MarkdownIt()
console.dir(md, { depth: 0 })

console.log('inline =', md.inline.ruler.__rules__.map(i => i.name))
inline = [
  'text', 'linkify',
  'newline', 'escape',
  'backticks', 'strikethrough',
  'emphasis', 'link',
  'image', 'autolink',
  'html_inline', 'entity'
]

console.log('block =', md.block.ruler.__rules__.map(i => i.name))
block = [
  'table', 'code',
  'fence', 'blockquote',
  'hr', 'list',
  'reference', 'html_block',
  'heading', 'lheading',
  'paragraph'
]

console.log('renderer =', Object.keys(md.renderer.rules))
renderer = [
  'code_inline', 'code_block',
  'fence', 'image',
  'hardbreak', 'softbreak',
  'text', 'html_block',
  'html_inline'
]

const MarkdownItShiki: MarkdownIt.PluginWithOptions<Options>
  = (markdownit, options = {}) => {
  // ... preprocessors
    markdownit.options.highlight = (code, lang, attrs) => {
      return highlightCode(
        code,
        lang || 'text',
      )
    }
  }

const defaultRenderer = md.renderer.rules.fence!.bind(md.renderer.rules)

md.renderer.rules.fence = (tokens, index, options, env, slf) => {
  const token = tokens[index]
  if (token.info.trim() === 'mermaid') {
    const code = token.content.trim()
    return renderMermaid(code)
  }
  return defaultRenderer(tokens, index, options, env, slf)
}

md.inline.ruler.after('escape', 'math_inline', math_inline)
md.renderer.rules.math_inline = inlineRenderer

const MarkdownItKaTeX: MarkdownIt.PluginSimple = (md) => {
  md.inline.ruler.after('escape', 'math_inline', math_inline)
  md.renderer.rules.math_inline = inlineRenderer
}

function math_inline(state: StateInline, silent: boolean) {
  // 如果不符合 $(.+?)$ 的要求，返回 false
  if (!isValid(state))
    return false
  // 从 state 读取符合条件的 $(.+?)$, 起始和结束分别为 start 和 end
  let start, end, token
  // silent 时表示静默不处理
  if (!silent) {
    // 向 token 流中添加一个类型为 `math_inline` 的 token
    token = state.push('math_inline', 'math', 0)
    token.markup = '$'
    // 将 token 的内容设定为识别到的 tex 字符串
    token.content = state.src.slice(start, end)
  }
  // 将字符指针移出公式的范围
  state.pos = end + 1
  // 返回值为 true 应该表示当前的 token 生效
  return true
}

/** 生成 KaTeX 的 HTML 字符串 */
function inlineRenderer(code: string) {
  try {
    return katex.renderToString(tex, { throwOnError: false })
  }
  catch (err) {
    return `<pre style="white-space: normal; background-color: #7f7f7f18; padding: 0.5rem;">${err}</pre>`
  }
}

declare class StateInline {
  constructor(src: string, md: MarkdownIt, env: any, outTokens: Token[])
  /**
   * 完整的 markdown 字符串
   */
  src: string

  /**
   * token 序列
   */
  tokens: Token[]
  tokens_meta: Array<StateInline.TokenMata | null>

  /**
   * markdown 字符串指针
   */
  pos: number

  /**
   * 行尾的索引，如果 pos >= posMax 通常就不用再处理该行内元素了
   */
  posMax: number
  level: number
  pending: string

  md: markdownit

  /**
   * 将新的 token 加入 token stream
   * If pending text exists - flush it as text token
   */
  push(type: string, tag: string, nesting: Token.Nesting): Token

}

declare class StateBlock {
  constructor(src: string, md: MarkdownIt, env: any, tokens: Token[])
  /**
   * 完整的 markdown 字符串
   */
  src: string

  tokens: Token[]

  /**
   * 行首的索引，即每行第一个字符在 src 中的 index
   */
  bMarks: number[]
  /**
   * 行尾的索引，即每行最后一个字符在 src 中的 index
   */
  eMarks: number[]
  /**
   * 每一行中第一个不是空白字符串的索引
   */
  tShift: number[]
  /**
   * 每行的缩进
   */
  sCount: number[]

  /**
   * 当前指针所在的行号
   */
  line: number
  /**
   * 总行数
   */
  lineMax: number

  md: markdownit

  /**
   * 将新的 token 加入 token stream
   */
  push(type: string, tag: string, nesting: Token.Nesting): Token
}

const start = state.bMarks[lineNum] + state.tShift[lineNum]
const max = state.eMarks[lineNum]