pantsdown 2.2.7 → 2.2.8

package/src/renderer.ts

@@ -2,7 +2,9 @@ import GithubSlugger from "github-slugger";
 import hljs from "highlight.js";
 import { renderToString } from "katex";
 import { type Pantsdown } from "./pantsdown.ts";
+import { type Parser } from "./parser.ts";
 import { inline } from "./rules/inline.ts";
+import { other } from "./rules/other.ts";
 import { type HTMLAttrs, type SourceMap, type Tokens } from "./types.ts";
 import {
    addGithubImageStyles,
@@ -19,15 +21,20 @@ import {
  */
 export class Renderer {
    private pantsdown: Pantsdown;
+   parser!: Parser; // set by the parser
    slugger = new GithubSlugger();
 
    constructor(pantsdown: Pantsdown) {
       this.pantsdown = pantsdown;
    }
 
-   code(code: string, infostring: string | undefined, sourceMap: SourceMap): string {
-      const lang = /^\S*/.exec(infostring ?? "")?.[0];
-      code = code.replace(/\n$/, "");
+   space(_token: Tokens["Space"]): string {
+      return "";
+   }
+
+   code({ text, lang: infostring, sourceMap }: Tokens["Code"]): string {
+      const lang = other.notSpaceStart.exec(infostring ?? "")?.[0];
+      let code = text.replace(other.endingNewline, "");
 
       const attrs: HTMLAttrs = [];
 
@@ -40,7 +47,7 @@ export class Renderer {
       }
 
       if (lang === "math") {
-         return this.latexBlock(code, sourceMap);
+         return this.latexBlock({ text: code, sourceMap });
       }
 
       const language = lang && hljs.getLanguage(lang) ? lang : "plaintext";
@@ -51,51 +58,70 @@ export class Renderer {
       return injectHtmlAttributes(result, attrs, sourceMap);
    }
 
-   alert(body: string, token: Tokens["Alert"]): string {
+   alert(token: Tokens["Alert"]): string {
+      const body = this.parser.parse(token.tokens);
       const result = `<div><span>${token.icon + token.variant}</span>${body}</div>\n`;
       return injectHtmlAttributes(result, [
          ["class", `markdown-alert markdown-alert-${token.variant.toLowerCase()}`],
       ]);
    }
 
-   blockquote(quote: string): string {
-      return `<blockquote>\n${quote}</blockquote>\n`;
+   blockquote({ tokens }: Tokens["Blockquote"]): string {
+      const body = this.parser.parse(tokens);
+      return `<blockquote>\n${body}</blockquote>\n`;
    }
 
-   html(html: string, _block: boolean, sourceMap?: SourceMap): string {
-      let result = fixHtmlLocalImageHref(html, this.pantsdown.config);
+   html(token: Tokens["HTML"] | Tokens["Tag"]): string {
+      let result = fixHtmlLocalImageHref(token.text, this.pantsdown.config);
       result = addGithubImageStyles(result);
 
       const attrs: HTMLAttrs = [];
 
       if (this.pantsdown.config.renderer.detailsTagDefaultOpen) {
-         const tag = inline.tag.exec(html);
+         const tag = inline.tag.exec(token.text);
          if (tag?.[0] === "<details>") {
             attrs.push(["open", ""]);
          }
       }
 
-      return injectHtmlAttributes(result, attrs, sourceMap);
+      return injectHtmlAttributes(
+         result,
+         attrs,
+         "sourceMap" in token ? token.sourceMap : undefined,
+      );
    }
 
-   heading(text: string, level: number, sourceMap: SourceMap): string {
+   heading({ tokens, depth, sourceMap }: Tokens["Heading"]): string {
+      const text = this.parser.parseInline(tokens);
       const elementText = getHtmlElementText(text);
       const slug = this.slugger.slug(elementText);
-      let result = `<h${level}>`;
+      let result = `<h${depth}>`;
       // span with negative top to add some offset when scrolling to #slug
       result += `<span style="position: absolute; top: -50px;" id="${slug}"></span>`;
       result += `${text}<a class="anchor octicon-link" href="#${slug}"></a>`;
-      result += `</h${level}>\n`;
+      result += `</h${depth}>\n`;
       return injectHtmlAttributes(result, [["style", "position: relative;"]], sourceMap);
    }
 
-   hr(sourceMap: SourceMap): string {
+   hr({ sourceMap }: Tokens["Hr"]): string {
       return injectHtmlAttributes(`<hr>\n`, [], sourceMap);
    }
 
-   list(body: string, ordered: boolean, start: number | "", classes: string[] = []): string {
+   list(token: Tokens["List"]): string {
+      const ordered = token.ordered;
+      const start = token.start;
+
+      let body = "";
+      let containsTaskList = false;
+      for (const item of token.items) {
+         if (item.task) containsTaskList = true;
+         body += this.listitem(item);
+      }
+
       const type = ordered ? "ol" : "ul";
-      const attrs: HTMLAttrs = [["class", classes.join(" ")]];
+      const listClasses: string[] = [];
+      if (containsTaskList) listClasses.push("contains-task-list");
+      const attrs: HTMLAttrs = [["class", listClasses.join(" ")]];
       if (ordered && start && start !== 1) {
          attrs.push(["start", String(start)]);
       }
@@ -103,49 +129,75 @@ export class Renderer {
       return injectHtmlAttributes(result, attrs);
    }
 
-   listitem(text: string, task: boolean, _checked: boolean, sourceMap: SourceMap): string {
-      const attrs: [string, string][] = [];
-      if (task) attrs.push(["class", "task-list-item"]);
+   listitem(item: Tokens["ListItem"]): string {
+      const attrs: HTMLAttrs = [];
+      if (item.task) attrs.push(["class", "task-list-item"]);
+      const text = this.parser.parse(item.tokens, false);
       const result = `<li>${text}</li>\n`;
-      return injectHtmlAttributes(result, attrs, sourceMap);
+      return injectHtmlAttributes(result, attrs, item.sourceMap);
    }
 
-   checkbox(checked: boolean, classes: string[] = []): string {
+   checkbox({ checked }: Tokens["Checkbox"]): string {
       const result = "<input>";
       const attrs: HTMLAttrs = [
          ["disabled", ""],
          ["type", "checkbox"],
-         ["class", classes.join(" ")],
+         ["class", "task-list-item-checkbox"],
       ];
       if (checked) attrs.push(["checked", ""]);
-      return injectHtmlAttributes(result, attrs);
+      return injectHtmlAttributes(result, attrs) + " ";
    }
 
-   paragraph(text: string, sourceMap: SourceMap): string {
-      const result = `<p>${text}</p>\n`;
+   paragraph({ tokens, sourceMap }: Tokens["Paragraph"]): string {
+      const result = `<p>${this.parser.parseInline(tokens)}</p>\n`;
       return injectHtmlAttributes(result, [], sourceMap);
    }
 
-   table(header: string, body: string): string {
+   table(token: Tokens["Table"]): string {
+      const sourceMapLineStart = token.sourceMap?.[0];
+
+      let header = "";
+      let cell = "";
+      for (const headerCell of token.header) {
+         cell += this.tablecell(headerCell);
+      }
+      header += this.tablerow({ text: cell, sourceMapStart: sourceMapLineStart });
+
+      let body = "";
+      for (let j = 0, rowsLen = token.rows.length; j < rowsLen; j++) {
+         const row = token.rows[j]!;
+
+         cell = "";
+         for (const rowCell of row) {
+            cell += this.tablecell(rowCell);
+         }
+
+         body += this.tablerow({
+            text: cell,
+            sourceMapStart: sourceMapLineStart ? sourceMapLineStart + 2 + j : undefined,
+         });
+      }
       if (body) body = `<tbody>${body}</tbody>`;
+
       return "<table>\n" + "<thead>\n" + header + "</thead>\n" + body + "</table>\n";
    }
 
-   tablerow(content: string, sourceMapStart: number | undefined): string {
+   tablerow({
+      text,
+      sourceMapStart,
+   }: {
+      text: string;
+      sourceMapStart?: number | undefined;
+   }): string {
       const sourceMap: SourceMap = sourceMapStart ? [sourceMapStart, sourceMapStart] : undefined;
-      return injectHtmlAttributes(`<tr>\n${content}</tr>\n`, [], sourceMap);
+      return injectHtmlAttributes(`<tr>\n${text}</tr>\n`, [], sourceMap);
    }
 
-   tablecell(
-      content: string,
-      flags: {
-         header: boolean;
-         align: "center" | "left" | "right" | null;
-      },
-   ): string {
-      const type = flags.header ? "th" : "td";
+   tablecell(token: Tokens["TableCell"]): string {
+      const content = this.parser.parseInline(token.tokens);
+      const type = token.header ? "th" : "td";
       const attrs: HTMLAttrs = [];
-      if (flags.align) attrs.push(["align", flags.align]);
+      if (token.align) attrs.push(["align", token.align]);
       const result = `<${type}>` + content + `</${type}>\n`;
       return injectHtmlAttributes(result, attrs);
    }
@@ -153,46 +205,48 @@ export class Renderer {
    /**
     * span level renderer
     */
-   strong(text: string): string {
-      return `<strong>${text}</strong>`;
+   strong({ tokens }: Tokens["Strong"]): string {
+      return `<strong>${this.parser.parseInline(tokens)}</strong>`;
    }
 
-   em(text: string): string {
-      return `<em>${text}</em>`;
+   em({ tokens }: Tokens["Em"]): string {
+      return `<em>${this.parser.parseInline(tokens)}</em>`;
    }
 
-   codespan(text: string): string {
-      return `<code>${text}</code>`;
+   codespan({ text }: Tokens["Codespan"]): string {
+      return `<code>${escape(text, true)}</code>`;
    }
 
-   br(): string {
+   br(_token: Tokens["Br"]): string {
       return "<br>";
    }
 
-   del(text: string): string {
-      return `<del>${text}</del>`;
+   del({ tokens }: Tokens["Del"]): string {
+      return `<del>${this.parser.parseInline(tokens)}</del>`;
    }
 
-   link(href: string, title: string | null | undefined, text: string): string {
+   link({ href, title, tokens }: Tokens["Link"]): string {
+      const text = this.parser.parseInline(tokens);
       const cleanHref = cleanUrl(href);
       if (cleanHref === null) {
          return text;
       }
       const attrs: HTMLAttrs = [["href", cleanHref]];
-      if (title) attrs.push(["title", title]);
+      if (title) attrs.push(["title", escape(title)]);
       return injectHtmlAttributes(`<a>${text}</a>`, attrs);
    }
 
-   image(href: string, title: string | null, text: string): string {
+   image({ href, title, tokens }: Tokens["Image"]): string {
+      const text = this.parser.parseInline(tokens, this.parser.textRenderer);
       const cleanHref = cleanUrl(href);
       if (cleanHref === null) {
-         return text;
+         return escape(text);
       }
       const attrs: HTMLAttrs = [
          ["src", fixLocalImageHref(cleanHref, this.pantsdown.config)],
-         ["alt", text],
+         ["alt", escape(text)],
       ];
-      if (title) attrs.push(["title", title]);
+      if (title) attrs.push(["title", escape(title)]);
       return injectHtmlAttributes("<img>", attrs);
    }
 
@@ -204,9 +258,19 @@ export class Renderer {
       }" data-footnote-ref aria-describedby="footnote-label">${token.label}</a></sup>`;
    }
 
-   footnotes(token: Tokens["Footnotes"], body: string) {
+   footnotes(token: Tokens["Footnotes"]) {
       if (!token.items.length) return "";
 
+      const body = token.items.reduce((acc, { label, content, sourceMap }) => {
+         let footnoteItem = `<li id="footnote-${encodeURIComponent(label)}">\n`;
+         footnoteItem += this.parser.parse(content);
+         footnoteItem += "</li>\n";
+
+         footnoteItem = injectHtmlAttributes(footnoteItem, [], sourceMap);
+
+         return acc + footnoteItem;
+      }, "");
+
       let footnotesHTML = '<section class="footnotes" data-footnotes>\n';
       footnotesHTML += `<ol>\n${body}\n</ol>\n`;
       footnotesHTML += "</section>\n";
@@ -214,13 +278,17 @@ export class Renderer {
       return footnotesHTML;
    }
 
-   text(text: string): string {
-      return text;
+   text(token: Tokens["Text"] | Tokens["Escape"] | Tokens["Tag"]): string {
+      return "tokens" in token
+         ? this.parser.parseInline(token.tokens)
+         : "escaped" in token && token.escaped
+           ? token.text
+           : escape(token.text);
    }
 
-   latexBlock(latex: string, sourceMap: SourceMap): string {
+   latexBlock({ text, sourceMap }: Pick<Tokens["LatexBlock"], "text" | "sourceMap">): string {
       try {
-         const rendered = renderToString(latex, {
+         const rendered = renderToString(text, {
             displayMode: true,
             throwOnError: false,
             output: "html",
@@ -229,16 +297,16 @@ export class Renderer {
          return injectHtmlAttributes(`<div class="katex-block">${rendered}</div>\n`, [], sourceMap);
       } catch {
          return injectHtmlAttributes(
-            `<div class="katex-block katex-error"><code>${escape(latex)}</code></div>\n`,
+            `<div class="katex-block katex-error"><code>${escape(text)}</code></div>\n`,
             [],
             sourceMap,
          );
       }
    }
 
-   latexInline(latex: string): string {
+   latexInline({ text }: Tokens["LatexInline"]): string {
       try {
-         const rendered = renderToString(latex, {
+         const rendered = renderToString(text, {
             displayMode: false,
             throwOnError: false,
             output: "html",
@@ -246,7 +314,7 @@ export class Renderer {
          });
          return `<span class="katex-inline">${rendered}</span>`;
       } catch {
-         return `<span class="katex-inline katex-error"><code>${escape(latex)}</code></span>`;
+         return `<span class="katex-inline katex-error"><code>${escape(text)}</code></span>`;
       }
    }
 }

package/src/rules/block.ts

@@ -19,7 +19,7 @@ type BlockRuleNames =
    | "paragraph"
    | "latexBlock";
 
-export const label = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+export const label = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/;
 
 const tag =
    "address|article|aside|base|basefont|blockquote|body|caption" +
@@ -32,19 +32,19 @@ const tag =
 const title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/;
 
 const block_def = edit(
-   /^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/,
+   /^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/,
 )
    .replace("label", label)
    .replace("title", title)
    .getRegex();
 
-const block_bullet = /(?:[*+-]|\d{1,9}[.)])/;
+const block_bullet = / {0,3}(?:[*+-]|\d{1,9}[.)])/;
 
 const block_listItemStart = edit(/^( *)(bull) */)
    .replace("bull", block_bullet)
    .getRegex();
 
-const block_list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/)
+const block_list = edit(/^(bull)([ \t][^\n]*?)?(?:\n|$)/)
    .replace(/bull/g, block_bullet)
    .replace("hr", "\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))")
    .replace("def", "\\n+(?=" + block_def.source + ")")
@@ -54,14 +54,14 @@ export const comment = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
 
 const block_html = edit(
    "^ {0,3}(?:" + // optional indentation
-      "<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)" + // (1)
+      "<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n*|$)" + // (1)
       "|comment[^\\n]*(\\n+|$)" + // (2)
-      "|<\\?[\\s\\S]*?(?:\\?>\\n*|$)" + // (3)
-      "|<![A-Z][\\s\\S]*?(?:>\\n*|$)" + // (4)
-      "|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)" + // (5)
-      "|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n *)+\\n|$)" + // (6)
-      "|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)" + // (7) open tag
-      "|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)" + // (7) closing tag
+      "|<\\?[\\s\\S]*?(?:\\?>[^\\n]*\\n*|$)" + // (3)
+      "|<![A-Z][\\s\\S]*?(?:>[^\\n]*\\n*|$)" + // (4)
+      "|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>[^\\n]*\\n*|$)" + // (5)
+      "|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ \\t]*)+\\n|$)" + // (6)
+      "|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \\t]*)+\\n|$)" + // (7) open tag
+      "|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \\t]*)+\\n|$)" + // (7) closing tag
       ")",
    "i",
 )
@@ -70,16 +70,17 @@ const block_html = edit(
    .replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/)
    .getRegex();
 
-// const block_lheading = edit(/^(?!bull )((?:.|\n(?!\s*?\n|bull ))+?)\n {0,3}(=+|-+) *(?:\n+|$)/)
+// upstream's lheadingGfm variant (we are GFM-only; the commonmark variant drops |table)
 const block_lheading = edit(
-   /^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
+   /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
 )
    .replace(/bull/g, block_bullet) // lists can interrupt
-   .replace(/blockCode/g, / {4}/) // indented code blocks can interrupt
+   .replace(/blockCode/g, /(?: {4}| {0,3}\t)/) // indented code blocks can interrupt
    .replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt
    .replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt
-   .replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt
+   .replace(/heading/g, / {0,3}#{1,6}(?:\s|$)/) // ATX heading can interrupt
    .replace(/html/g, / {0,3}<[^\n>]+>\n/) // block html can interrupt
+   .replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/) // table can interrupt
    .getRegex();
 
 const block_hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
@@ -92,34 +93,40 @@ const block_table = edit(
    .replace("hr", block_hr)
    .replace("heading", " {0,3}#{1,6}(?:\\s|$)")
    .replace("blockquote", " {0,3}>")
-   .replace("code", " {4}[^\\n]")
-   .replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n")
-   .replace("list", " {0,3}(?:[*+-]|1[.)]) ") // only lists starting from 1 can interrupt
+   .replace("code", "(?: {4}| {0,3}\\t)[^\\n]")
+   .replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~~~)[^\\n]*\\n")
+   .replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]") // any bullet ends the table rows
    .replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)")
    .replace("tag", tag) // tables can be interrupted by type (6) html blocks
    .getRegex();
 
-const block_paragraph = edit(
-   /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,
-)
-   .replace("hr", block_hr)
-   .replace("heading", " {0,3}#{1,6}(?:\\s|$)")
-   .replace("|lheading", "") // setext headings don't interrupt commonmark paragraphs
-   .replace("table", block_table) // interrupt paragraphs with table
-   .replace("blockquote", " {0,3}>")
-   .replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n")
-   .replace("list", " {0,3}(?:[*+-]|1[.)]) ") // only lists starting from 1 can interrupt
-   .replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)")
-   .replace("tag", tag) // pars can be interrupted by type (6) html blocks
-   .getRegex();
+const createParagraph = (listInterrupt: string) =>
+   edit(/^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table|[ \t]+\n)[^\n]+)*)/)
+      .replace("hr", block_hr)
+      .replace("heading", " {0,3}#{1,6}(?:\\s|$)")
+      .replace("|lheading", "") // setext headings don't interrupt commonmark paragraphs
+      .replace("table", block_table) // interrupt paragraphs with table
+      .replace("blockquote", " {0,3}>")
+      .replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~~~)[^\\n]*\\n")
+      .replace("list", listInterrupt)
+      .replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)")
+      .replace("tag", tag) // pars can be interrupted by type (6) html blocks
+      .getRegex();
+
+// only non-empty lists starting from 1 can interrupt paragraphs
+const block_paragraph = createParagraph(" {0,3}(?:[*+-]|1[.)])[ \\t]+[^ \\t\\n]");
+// inside a blockquote a bare list marker (any number) starts a sibling list,
+// so it must not be lazily continued as paragraph text (unlike a top level
+// paragraph, where an empty list cannot interrupt)
+const block_blockquoteParagraph = createParagraph(" {0,3}(?:[*+-]|\\d{1,9}[.)])(?:[ \\t]|\\n|$)");
 
 const block_blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/)
-   .replace("paragraph", block_paragraph)
+   .replace("paragraph", block_blockquoteParagraph)
    .getRegex();
 
 export const block: Record<BlockRuleNames, RegExp> = {
-   newline: /^(?: *(?:\n|$))+/,
-   code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,
+   newline: /^(?:[ \t]*(?:\n|$))+/,
+   code: /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/,
    fences:
       /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,
    hr: block_hr,