marked-katex-extension 2.1.0 → 3.0.0

package/README.md

@@ -2,8 +2,6 @@
 
 Render [katex](https://katex.org/) code in marked
 
-Note: Block level katex requires at least 2 `$` at the beginning and end.
-
 ```markdown
 This is inline katex: $c = \\pm\\sqrt{a^2 + b^2}$
 
@@ -17,7 +15,7 @@ $$
 You will still need to include the css in your html document to allow katex styles.
 
 ```html
-<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.2/dist/katex.min.css" integrity="sha384-bYdxxUwYipFNohQlHt0bjN/LCpueqWz13HufFEV1SUatKs1cm4L6fFgCi1jT643X" crossorigin="anonymous">
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.css" integrity="sha384-GvrOXuhMATgEsSwCs4smul74iXGOixntILdUW9XmUC6+HX0sLNAK3q71HotJqlAn" crossorigin="anonymous">
 ```
 
 # Usage
@@ -41,6 +39,25 @@ marked.parse("katex: $c = \\pm\\sqrt{a^2 + b^2}$");
 
 ![image](https://user-images.githubusercontent.com/97994/188899567-e6e8268c-209e-4067-8f44-0ada16caacdd.png)
 
+## Block level
+
+You can include newlines in block level katex. Block level katex must contain starting and ending delimiters on their own line.
+
+```js
+marked.parse(`
+$$
+\\begin{array}{cc}
+   a & b \\\\
+   c & d
+\\end{array}
+$$
+`);
+```
+
+## DisplayMode
+
+[`displayMode`](https://katex.org/docs/options.html) will be on by default when using two dollar signs (`$$`) in inline or block katex. And it will be off by default for a single dollar sign (`$`) in inline or block katex.
+
 ## `options`
 
-Options are sent directly to [`katex.renderToString`](https://katex.org/docs/api.html#server-side-rendering-or-rendering-to-a-string)
+Options are sent directly to [`katex`](https://katex.org/docs/options.html)

package/lib/index.cjs

@@ -2,54 +2,71 @@
 
 var katex = require('katex');
 
+const inlineStartRule = /(?<=\s|^)\${1,2}(?!\$)/;
+const inlineRule = /^(\${1,2})(?!\$)((?:\\.|[^\\\n])+?)(?<!\$)\1(?=\s|$)/;
+const blockRule = /^(\${1,2})\n((?:\\[^]|[^\\])+?)\n\1(?:\n|$)/;
+
 function index(options = {}) {
   return {
     extensions: [
-      inlineKatex(options),
-      blockKatex(options)
+      inlineKatex(options, createRenderer(options, false)),
+      blockKatex(options, createRenderer(options, true))
     ]
   };
 }
 
-function inlineKatex(options) {
+function createRenderer(options, newlineAfter) {
+  return (token) => katex.renderToString(token.text, { ...options, displayMode: token.displayMode }) + (newlineAfter ? '\n' : '');
+}
+
+function inlineKatex(options, renderer) {
   return {
     name: 'inlineKatex',
     level: 'inline',
-    start(src) { return src.indexOf('$'); },
+    start(src) {
+      const match = src.match(inlineStartRule);
+      if (!match) {
+        return;
+      }
+
+      const possibleKatex = src.substring(match.index);
+
+      if (possibleKatex.match(inlineRule)) {
+        return match.index;
+      }
+    },
     tokenizer(src, tokens) {
-      const match = src.match(/^\$+([^$\n]+?)\$+/);
+      const match = src.match(inlineRule);
       if (match) {
         return {
           type: 'inlineKatex',
           raw: match[0],
-          text: match[1].trim()
+          text: match[2].trim(),
+          displayMode: match[1].length === 2
         };
       }
     },
-    renderer(token) {
-      return katex.renderToString(token.text, options);
-    }
+    renderer
   };
 }
 
-function blockKatex(options) {
+function blockKatex(options, renderer) {
   return {
     name: 'blockKatex',
     level: 'block',
-    start(src) { return src.indexOf('\n$$'); },
+    start(src) { return src.indexOf('\n$'); },
     tokenizer(src, tokens) {
-      const match = src.match(/^\$\$+\n([^$]+?)\n\$\$+\n/);
+      const match = src.match(blockRule);
       if (match) {
         return {
           type: 'blockKatex',
           raw: match[0],
-          text: match[1].trim()
+          text: match[2].trim(),
+          displayMode: match[1].length === 2
         };
       }
     },
-    renderer(token) {
-      return `<p>${katex.renderToString(token.text, options)}</p>`;
-    }
+    renderer
   };
 }
 

package/lib/index.umd.js

@@ -96,13 +96,19 @@
    * about where in the source string the problem occurred.
    */
   class ParseError {
-    // Error position based on passed-in Token or ParseNode.
+    // Error start position based on passed-in Token or ParseNode.
+    // Length of affected text based on passed-in Token or ParseNode.
+    // The underlying error message without any context added.
     constructor(message, // The error message
     token // An object providing position information
     ) {
+      this.name = void 0;
       this.position = void 0;
+      this.length = void 0;
+      this.rawMessage = void 0;
       var error = "KaTeX parse error: " + message;
       var start;
+      var end;
       var loc = token && token.loc;
 
       if (loc && loc.start <= loc.end) {
@@ -111,7 +117,7 @@
         var input = loc.lexer.input; // Prepend some information
 
         start = loc.start;
-        var end = loc.end;
+        end = loc.end;
 
         if (start === input.length) {
           error += " at end of input: ";
@@ -141,14 +147,20 @@
         error += left + underlined + right;
       } // Some hackery to make ParseError a prototype of Error
       // See http://stackoverflow.com/a/8460753
+      // $FlowFixMe
 
 
       var self = new Error(error);
       self.name = "ParseError"; // $FlowFixMe
 
-      self.__proto__ = ParseError.prototype; // $FlowFixMe
-
+      self.__proto__ = ParseError.prototype;
       self.position = start;
+
+      if (start != null && end != null) {
+        self.length = end - start;
+      }
+
+      self.rawMessage = message;
       return self;
     }
 
@@ -18303,7 +18315,7 @@
     /**
      * Current KaTeX version
      */
-    version: "0.16.7",
+    version: "0.16.8",
 
     /**
      * Renders the given LaTeX into an HTML+MathML combination, and adds
@@ -18397,54 +18409,71 @@
     }
   };
 
+  const inlineStartRule = /(?<=\s|^)\${1,2}(?!\$)/;
+  const inlineRule = /^(\${1,2})(?!\$)((?:\\.|[^\\\n])+?)(?<!\$)\1(?=\s|$)/;
+  const blockRule = /^(\${1,2})\n((?:\\[^]|[^\\])+?)\n\1(?:\n|$)/;
+
   function index(options = {}) {
     return {
       extensions: [
-        inlineKatex(options),
-        blockKatex(options)
+        inlineKatex(options, createRenderer(options, false)),
+        blockKatex(options, createRenderer(options, true))
       ]
     };
   }
 
-  function inlineKatex(options) {
+  function createRenderer(options, newlineAfter) {
+    return (token) => katex.renderToString(token.text, { ...options, displayMode: token.displayMode }) + (newlineAfter ? '\n' : '');
+  }
+
+  function inlineKatex(options, renderer) {
     return {
       name: 'inlineKatex',
       level: 'inline',
-      start(src) { return src.indexOf('$'); },
+      start(src) {
+        const match = src.match(inlineStartRule);
+        if (!match) {
+          return;
+        }
+
+        const possibleKatex = src.substring(match.index);
+
+        if (possibleKatex.match(inlineRule)) {
+          return match.index;
+        }
+      },
       tokenizer(src, tokens) {
-        const match = src.match(/^\$+([^$\n]+?)\$+/);
+        const match = src.match(inlineRule);
         if (match) {
           return {
             type: 'inlineKatex',
             raw: match[0],
-            text: match[1].trim()
+            text: match[2].trim(),
+            displayMode: match[1].length === 2
           };
         }
       },
-      renderer(token) {
-        return katex.renderToString(token.text, options);
-      }
+      renderer
     };
   }
 
-  function blockKatex(options) {
+  function blockKatex(options, renderer) {
     return {
       name: 'blockKatex',
       level: 'block',
-      start(src) { return src.indexOf('\n$$'); },
+      start(src) { return src.indexOf('\n$'); },
       tokenizer(src, tokens) {
-        const match = src.match(/^\$\$+\n([^$]+?)\n\$\$+\n/);
+        const match = src.match(blockRule);
         if (match) {
           return {
             type: 'blockKatex',
             raw: match[0],
-            text: match[1].trim()
+            text: match[2].trim(),
+            displayMode: match[1].length === 2
           };
         }
       },
-      renderer(token) {
-        return `<p>${katex.renderToString(token.text, options)}</p>`;
-      }
+      renderer
     };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marked-katex-extension",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "MarkedJS extesion to render katex",
   "main": "./lib/index.cjs",
   "module": "./src/index.js",
@@ -27,7 +27,8 @@
     "test:cover": "jest --coverage",
     "test:types": "tsd -f spec/index.test-d.ts -t src/index.d.ts",
     "lint": "eslint .",
-    "build": "rollup -c rollup.config.js"
+    "build": "rollup -c rollup.config.js",
+    "update-specs": "node ./update-specs.js"
   },
   "repository": {
     "type": "git",
@@ -43,30 +44,32 @@
     "marked": "^4 || ^5"
   },
   "devDependencies": {
-    "@babel/core": "^7.21.8",
-    "@babel/preset-env": "^7.21.5",
-    "@rollup/plugin-node-resolve": "^15.0.2",
+    "@babel/core": "^7.22.6",
+    "@babel/preset-env": "^7.22.6",
+    "@rollup/plugin-node-resolve": "^15.1.0",
     "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/commit-analyzer": "^9.0.2",
+    "@semantic-release/commit-analyzer": "^10.0.1",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^8.0.7",
-    "@semantic-release/npm": "^10.0.3",
-    "@semantic-release/release-notes-generator": "^11.0.1",
+    "@semantic-release/github": "^9.0.3",
+    "@semantic-release/npm": "^10.0.4",
+    "@semantic-release/release-notes-generator": "^11.0.4",
     "@types/marked": "^5.0.0",
-    "babel-jest": "^29.5.0",
-    "eslint": "^8.41.0",
-    "eslint-config-standard": "^17.0.0",
+    "babel-jest": "^29.6.0",
+    "cheerio": "^1.0.0-rc.12",
+    "eslint": "^8.44.0",
+    "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-n": "^15.7.0",
+    "eslint-plugin-n": "^16.0.1",
     "eslint-plugin-promise": "^6.1.1",
-    "jest-cli": "^29.5.0",
-    "marked": "^5.0.2",
-    "rollup": "^3.23.0",
-    "semantic-release": "^21.0.2",
+    "jest-cli": "^29.6.0",
+    "marked": "^5.1.0",
+    "node-fetch": "^3.3.1",
+    "rollup": "^3.26.1",
+    "semantic-release": "^21.0.7",
     "tsd": "^0.28.1"
   },
   "dependencies": {
     "@types/katex": "^0.16.0",
-    "katex": "^0.16.7"
+    "katex": "^0.16.8"
   }
 }

package/src/index.js

@@ -1,52 +1,69 @@
 import katex from 'katex';
 
+const inlineStartRule = /(?<=\s|^)\${1,2}(?!\$)/;
+const inlineRule = /^(\${1,2})(?!\$)((?:\\.|[^\\\n])+?)(?<!\$)\1(?=\s|$)/;
+const blockRule = /^(\${1,2})\n((?:\\[^]|[^\\])+?)\n\1(?:\n|$)/;
+
 export default function(options = {}) {
   return {
     extensions: [
-      inlineKatex(options),
-      blockKatex(options)
+      inlineKatex(options, createRenderer(options, false)),
+      blockKatex(options, createRenderer(options, true))
     ]
   };
 }
 
-function inlineKatex(options) {
+function createRenderer(options, newlineAfter) {
+  return (token) => katex.renderToString(token.text, { ...options, displayMode: token.displayMode }) + (newlineAfter ? '\n' : '');
+}
+
+function inlineKatex(options, renderer) {
   return {
     name: 'inlineKatex',
     level: 'inline',
-    start(src) { return src.indexOf('$'); },
+    start(src) {
+      const match = src.match(inlineStartRule);
+      if (!match) {
+        return;
+      }
+
+      const possibleKatex = src.substring(match.index);
+
+      if (possibleKatex.match(inlineRule)) {
+        return match.index;
+      }
+    },
     tokenizer(src, tokens) {
-      const match = src.match(/^\$+([^$\n]+?)\$+/);
+      const match = src.match(inlineRule);
       if (match) {
         return {
           type: 'inlineKatex',
           raw: match[0],
-          text: match[1].trim()
+          text: match[2].trim(),
+          displayMode: match[1].length === 2
         };
       }
     },
-    renderer(token) {
-      return katex.renderToString(token.text, options);
-    }
+    renderer
   };
 }
 
-function blockKatex(options) {
+function blockKatex(options, renderer) {
   return {
     name: 'blockKatex',
     level: 'block',
-    start(src) { return src.indexOf('\n$$'); },
+    start(src) { return src.indexOf('\n$'); },
     tokenizer(src, tokens) {
-      const match = src.match(/^\$\$+\n([^$]+?)\n\$\$+\n/);
+      const match = src.match(blockRule);
       if (match) {
         return {
           type: 'blockKatex',
           raw: match[0],
-          text: match[1].trim()
+          text: match[2].trim(),
+          displayMode: match[1].length === 2
         };
       }
     },
-    renderer(token) {
-      return `<p>${katex.renderToString(token.text, options)}</p>`;
-    }
+    renderer
   };
 }