Merge branch 'perf'

Author: serkodev

.github/workflows/bench.yml

@@ -0,0 +1,26 @@
+name: bench
+
+on:
+  workflow_dispatch:
+
+jobs:
+  bench:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm run build
+
+      - name: Run benchmarks
+        run: pnpm -F bench run bench --run
+        env:
+          CI: true

packages/bench/compare.bench.ts

@@ -4,13 +4,16 @@ import { createRunners } from './runners'
 const fixtures = import.meta.glob<string>('./samples/*', { query: '?raw', import: 'default', eager: true })
 const contents = Object.values(fixtures)
 
-describe('all samples', () => {
-  const runners = createRunners()
-  for (const [name, runner] of Object.entries(runners)) {
-    bench(name, () => {
-      for (const content of contents) {
-        runner(content)
-      }
-    })
-  }
-})
+const runners = createRunners()
+
+for (const [category, runnerGroup] of Object.entries(runners)) {
+  describe(`category: ${category}`, () => {
+    for (const [name, runner] of Object.entries(runnerGroup)) {
+      bench(name, () => {
+        for (const content of contents) {
+          runner(content)
+        }
+      }, { time: 1000, warmupTime: 200 })
+    }
+  })
+}

packages/bench/runners.ts

@@ -55,13 +55,17 @@ export function createCommonmark() {
   return (input: string): string => renderer.render(parser.parse(input))
 }
 
-export function createRunners(): Record<string, (input: string) => string> {
+export function createRunners(): Record<string, Record<string, (input: string) => string>> {
   return {
-    'markdown-exit': createMarkdownExit(),
-    'markdown-exit-commonmark': createMarkdownExitCommonMark(),
-    'markdown-it': createMarkdownIt(),
-    'markdown-it-commonmark': createMarkdownItCommonMark(),
-    'marked': createMarked(),
-    'commonmark': createCommonmark(),
+    markdown: {
+      'markdown-exit': createMarkdownExit(),
+      'markdown-it': createMarkdownIt(),
+      'marked': createMarked(),
+    },
+    commonmark: {
+      'commonmark': createCommonmark(),
+      'markdown-exit-commonmark': createMarkdownExitCommonMark(),
+      'markdown-it-commonmark': createMarkdownItCommonMark(),
+    },
   }
 }

packages/markdown-exit/src/parser/block/rules/hr.ts

@@ -40,7 +40,7 @@ export default function hr(state: StateBlock, startLine: number, endLine: number
 
   const token = state.push('hr', 'hr', 0)
   token.map = [startLine, state.line]
-  token.markup = Array.from({ length: cnt + 1 }).join(String.fromCharCode(marker))
+  token.markup = String.fromCharCode(marker).repeat(cnt)
 
   return true
 }

packages/markdown-exit/src/parser/block/state_block.ts

@@ -107,39 +107,33 @@ export default class StateBlock<T extends Parser = Parser> {
     // Create caches
     // Generate markers.
     const s = this.src
+    const len = s.length
 
-    for (let start = 0, pos = 0, indent = 0, offset = 0, len = s.length, indent_found = false; pos < len; pos++) {
-      const ch = s.charCodeAt(pos)
+    for (let start = 0; start < len;) {
+      const lineEnd = s.indexOf('\n', start)
+      const end = lineEnd === -1 ? len : lineEnd
+      let indent = 0
+      let offset = 0
+      let pos = start
 
-      if (!indent_found) {
+      while (pos < end) {
+        const ch = s.charCodeAt(pos)
         if (isSpace(ch)) {
           indent++
-
-          if (ch === 0x09) {
-            offset += 4 - offset % 4
-          } else {
-            offset++
-          }
+          offset += (ch === 0x09) ? (4 - offset % 4) : 1
+          pos++
           continue
-        } else {
-          indent_found = true
         }
+        break
       }
 
-      if (ch === 0x0A || pos === len - 1) {
-        if (ch !== 0x0A)
-          pos++
-        this.bMarks.push(start)
-        this.eMarks.push(pos)
-        this.tShift.push(indent)
-        this.sCount.push(offset)
-        this.bsCount.push(0)
-
-        indent_found = false
-        indent = 0
-        offset = 0
-        start = pos + 1
-      }
+      this.bMarks.push(start)
+      this.eMarks.push(end)
+      this.tShift.push(indent)
+      this.sCount.push(offset)
+      this.bsCount.push(0)
+
+      start = end + 1
     }
 
     // Push fake entry to simplify cache bounds checks
@@ -186,8 +180,9 @@ export default class StateBlock<T extends Parser = Parser> {
    * Skip spaces from given position.
    */
   skipSpaces(pos: number): number {
-    for (let max = this.src.length; pos < max; pos++) {
-      const ch = this.src.charCodeAt(pos)
+    const src = this.src
+    for (let max = src.length; pos < max; pos++) {
+      const ch = src.charCodeAt(pos)
       if (!isSpace(ch))
         break
     }
@@ -201,8 +196,10 @@ export default class StateBlock<T extends Parser = Parser> {
     if (pos <= min)
       return pos
 
+    const src = this.src
     while (pos > min) {
-      if (!isSpace(this.src.charCodeAt(--pos)))
+      const code = src.charCodeAt(--pos)
+      if (!isSpace(code))
         return pos + 1
     }
     return pos
@@ -212,8 +209,9 @@ export default class StateBlock<T extends Parser = Parser> {
    * Skip char codes from given position
    */
   skipChars(pos: number, code: number): number {
-    for (let max = this.src.length; pos < max; pos++) {
-      if (this.src.charCodeAt(pos) !== code)
+    const src = this.src
+    for (let max = src.length; pos < max; pos++) {
+      if (src.charCodeAt(pos) !== code)
         break
     }
     return pos
@@ -226,8 +224,9 @@ export default class StateBlock<T extends Parser = Parser> {
     if (pos <= min)
       return pos
 
+    const src = this.src
     while (pos > min) {
-      if (code !== this.src.charCodeAt(--pos))
+      if (code !== src.charCodeAt(--pos))
         return pos + 1
     }
     return pos
@@ -241,8 +240,10 @@ export default class StateBlock<T extends Parser = Parser> {
       return ''
     }
 
-    const queue = Array.from({ length: end - begin })
+    /* perf */// eslint-disable-next-line unicorn/no-new-array
+    const queue = new Array<string>(end - begin)
 
+    const src = this.src
     for (let i = 0, line = begin; line < end; line++, i++) {
       let lineIndent = 0
       const lineStart = this.bMarks[line]
@@ -257,7 +258,7 @@ export default class StateBlock<T extends Parser = Parser> {
       }
 
       while (first < last && lineIndent < indent) {
-        const ch = this.src.charCodeAt(first)
+        const ch = src.charCodeAt(first)
 
         if (isSpace(ch)) {
           if (ch === 0x09) {
@@ -278,7 +279,7 @@ export default class StateBlock<T extends Parser = Parser> {
       if (lineIndent > indent) {
         // partially expanding tabs in code blocks, e.g '\t\tfoobar'
         // with indent=2 becomes '  \tfoobar'
-        queue[i] = Array.from({ length: lineIndent - indent + 1 }).join(' ') + this.src.slice(first, last)
+        queue[i] = ' '.repeat(lineIndent - indent) + this.src.slice(first, last)
       } else {
         queue[i] = this.src.slice(first, last)
       }

packages/markdown-exit/src/parser/core/rules/linkify.ts

@@ -4,7 +4,6 @@
 //
 
 import type StateCore from '../state_core'
-import { arrayReplaceAt } from '../../../common/utils'
 
 function isLinkOpen(str: string) {
   return /^<a[>\s]/i.test(str)
@@ -14,18 +13,19 @@ function isLinkClose(str: string) {
 }
 
 export default function linkify(state: StateCore) {
-  const blockTokens = state.tokens
-
   if (!state.md.options.linkify)
     return
 
+  const blockTokens = state.tokens
+  const linkify = state.md.linkify
+
   for (let j = 0, l = blockTokens.length; j < l; j++) {
     if (blockTokens[j].type !== 'inline' ||
-      !state.md.linkify.pretest(blockTokens[j].content)) {
+      !linkify.pretest(blockTokens[j].content)) {
       continue
     }
 
-    let tokens = blockTokens[j].children!
+    const tokens = blockTokens[j].children!
 
     let htmlLinkLevel = 0
 
@@ -55,9 +55,14 @@ export default function linkify(state: StateCore) {
       if (htmlLinkLevel > 0)
         continue
 
-      if (currentToken.type === 'text' && state.md.linkify.test(currentToken.content)) {
+      if (currentToken.type === 'text') {
         const text = currentToken.content
-        let links = state.md.linkify.match(text) ?? []
+        if (!linkify.pretest(text))
+          continue
+
+        const links = linkify.match(text)
+        if (!links?.length)
+          continue
 
         // Now split string to nodes
         const nodes = []
@@ -67,34 +72,33 @@ export default function linkify(state: StateCore) {
         // forbid escape sequence at the start of the string,
         // this avoids http\://example.com/ from being linkified as
         // http:<a href="//example.com/">//example.com/</a>
-        if (links.length > 0 &&
-          links[0].index === 0 &&
+        const startFrom = (links[0].index === 0 &&
           i > 0 &&
-          tokens[i - 1].type === 'text_special') {
-          links = links.slice(1)
-        }
+          tokens[i - 1].type === 'text_special')
+          ? 1
+          : 0
 
-        for (let ln = 0; ln < links.length; ln++) {
-          const url = links[ln].url
-          const fullUrl = state.md.normalizeLink(url)
+        for (let ln = startFrom; ln < links.length; ln++) {
+          const link = links[ln]
+          const fullUrl = state.md.normalizeLink(link.url)
           if (!state.md.validateLink(fullUrl))
             continue
 
-          let urlText = links[ln].text
+          let urlText = link.text
 
           // Linkifier might send raw hostnames like "example.com", where url
           // starts with domain name. So we prepend http:// in those cases,
           // and remove it afterwards.
           //
-          if (!links[ln].schema) {
+          if (!link.schema) {
             urlText = state.md.normalizeLinkText(`http://${urlText}`).replace(/^http:\/\//, '')
-          } else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {
+          } else if (link.schema === 'mailto:' && !/^mailto:/i.test(urlText)) {
             urlText = state.md.normalizeLinkText(`mailto:${urlText}`).replace(/^mailto:/, '')
           } else {
             urlText = state.md.normalizeLinkText(urlText)
           }
 
-          const pos = links[ln].index
+          const pos = link.index
 
           if (pos > lastPos) {
             const token = new state.Token('text', '', 0)
@@ -121,7 +125,7 @@ export default function linkify(state: StateCore) {
           token_c.info = 'auto'
           nodes.push(token_c)
 
-          lastPos = links[ln].lastIndex
+          lastPos = link.lastIndex
         }
         if (lastPos < text.length) {
           const token = new state.Token('text', '', 0)
@@ -131,7 +135,7 @@ export default function linkify(state: StateCore) {
         }
 
         // replace current node
-        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes)
+        tokens.splice(i, 1, ...nodes)
       }
     }
   }

packages/markdown-exit/src/parser/core/rules/normalize.ts

@@ -7,13 +7,22 @@ const NEWLINES_RE = /\r\n?|\n/g
 const NULL_RE = /\0/g
 
 export default function normalize(state: StateCore) {
-  let str
+  let str = state.src
+  const hasCR = str.includes('\r')
+  const hasNull = str.includes('\0')
+
+  if (!hasCR && !hasNull)
+    return
 
   // Normalize newlines
-  str = state.src.replace(NEWLINES_RE, '\n')
+  if (hasCR) {
+    str = str.replace(NEWLINES_RE, '\n')
+  }
 
   // Replace NULL characters
-  str = str.replace(NULL_RE, '\uFFFD')
+  if (hasNull) {
+    str = str.replace(NULL_RE, '\uFFFD')
+  }
 
   state.src = str
 }

packages/markdown-exit/src/parser/inline/parser_inline.ts

@@ -113,8 +113,9 @@ export default class ParserInline<T extends Parser = Parser> {
     const maxNesting = state.md.options.maxNesting
     const cache = state.cache
 
-    if (typeof cache[pos] !== 'undefined') {
-      state.pos = cache[pos]
+    const cachedPos = cache[pos]
+    if (cachedPos !== undefined) {
+      state.pos = cachedPos
       return
     }