katex 0.12.0 → 0.13.3

package/katex.js

@@ -25,6 +25,7 @@ import {
 
 import type {SettingsOptions} from "./src/Settings";
 import type {AnyParseNode} from "./src/parseNode";
+import type {DomSpan} from "./src/domTree";
 
 import {defineSymbol} from './src/symbols';
 import {defineMacro} from './src/macros';
@@ -36,7 +37,7 @@ declare var __VERSION__: string;
  * Parse and build an expression, and place that expression in the DOM node
  * given.
  */
-let render = function(
+let render: (string, Node, SettingsOptions) => void = function(
     expression: string,
     baseNode: Node,
     options: SettingsOptions,
@@ -109,7 +110,7 @@ const renderError = function(
 const renderToDomTree = function(
     expression: string,
     options: SettingsOptions,
-) {
+): DomSpan {
     const settings = new Settings(options);
     try {
         const tree = parseTree(expression, settings);
@@ -126,7 +127,7 @@ const renderToDomTree = function(
 const renderToHTMLTree = function(
     expression: string,
     options: SettingsOptions,
-) {
+): DomSpan {
     const settings = new Settings(options);
     try {
         const tree = parseTree(expression, settings);

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "katex",
-  "version": "0.12.0",
+  "version": "0.13.3",
   "description": "Fast math typesetting for the web.",
   "main": "dist/katex.js",
   "homepage": "https://katex.org",
   "repository": {
     "type": "git",
-    "url": "git://github.com/KaTeX/KaTeX.git"
+    "url": "https://github.com/KaTeX/KaTeX.git"
   },
   "files": [
     "katex.js",
@@ -17,68 +17,78 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@babel/core": "^7.3.3",
-    "@babel/plugin-proposal-class-properties": "^7.3.3",
-    "@babel/plugin-transform-runtime": "^7.2.0",
-    "@babel/preset-env": "^7.3.1",
-    "@babel/preset-flow": "^7.0.0",
-    "@babel/register": "^7.0.0",
-    "@babel/runtime": "^7.3.1",
-    "babel-eslint": "^10.0.1",
-    "babel-jest": "^24.1.0",
+    "@babel/core": "^7.10.4",
+    "@babel/plugin-proposal-class-properties": "^7.10.4",
+    "@babel/plugin-transform-runtime": "^7.10.4",
+    "@babel/preset-env": "^7.10.4",
+    "@babel/preset-flow": "^7.10.4",
+    "@babel/register": "^7.10.4",
+    "@babel/runtime": "^7.10.4",
+    "@rollup/plugin-alias": "^3.1.1",
+    "@rollup/plugin-babel": "^5.0.4",
+    "@semantic-release/changelog": "^5.0.1",
+    "@semantic-release/git": "^9.0.0",
+    "babel-eslint": "^10.1.0",
+    "babel-jest": "^26.1.0",
     "babel-loader": "^8.0.5",
-    "babel-plugin-istanbul": "^5.1.1",
-    "babel-plugin-preval": "^3.0.1",
+    "babel-plugin-istanbul": "^6.0.0",
+    "babel-plugin-preval": "^5.0.0",
     "babel-plugin-version-inline": "^1.0.0",
     "benchmark": "^2.1.4",
-    "browserslist": "^4.7.1",
-    "caniuse-lite": "^1.0.30001002",
-    "codecov": "^3.2.0",
-    "css-loader": "^3.0.0",
-    "cssnano": "^4.1.10",
-    "eslint": "^5.14.1",
-    "eslint-plugin-flowtype": "^3.4.2",
-    "eslint-plugin-react": "^7.12.4",
-    "eslint-plugin-transform-runtime-aliasing": "^2.0.0",
-    "file-loader": "^3.0.1",
-    "flow-bin": "^0.102.0",
-    "fs-extra": "^7.0.1",
-    "husky": "^1.3.1",
-    "istanbul-api": "^2.1.1",
-    "istanbul-lib-coverage": "^2.0.3",
-    "jest": "^24.1.0",
-    "jest-serializer-html": "^6.0.0",
-    "js-yaml": "^3.12.1",
+    "browserslist": "^4.13.0",
+    "browserstack-local": "^1.4.5",
+    "caniuse-lite": "^1.0.30001102",
+    "css-loader": "^5.1.2",
+    "cssnano": "^5.0.0-rc.1",
+    "eslint": "^7.4.0",
+    "eslint-plugin-actions": "^1.0.1",
+    "eslint-plugin-flowtype": "^5.2.0",
+    "eslint-plugin-react": "^7.20.3",
+    "file-loader": "^6.0.0",
+    "flow-bin": "^0.135.0",
+    "fs-extra": "^9.0.1",
+    "got": "^11.8.0",
+    "husky": "^4.2.5",
+    "istanbul-lib-coverage": "^3.0.0",
+    "istanbul-lib-report": "^3.0.0",
+    "istanbul-reports": "^3.0.2",
+    "jest": "^26.1.0",
+    "jest-diff": "^26.1.0",
+    "jest-matcher-utils": "^26.1.0",
+    "jest-message-util": "^26.1.0",
+    "jest-serializer-html": "^7.0.0",
+    "js-yaml": "^4.0.0",
     "json-stable-stringify": "^1.0.1",
     "jspngopt": "^0.2.0",
-    "less": "^3.9.0",
-    "less-loader": "^4.1.0",
-    "mini-css-extract-plugin": "^0.5.0",
-    "mkdirp": "^0.5.1",
-    "pako": "^1.0.8",
-    "postcss-loader": "^3.0.0",
-    "prettier": "^1.18.2",
-    "query-string": "^6.2.0",
-    "rimraf": "^2.6.3",
-    "rollup": "^1.2.2",
-    "rollup-plugin-alias": "^1.5.1",
-    "rollup-plugin-babel": "^4.3.2",
+    "less": "^4.0.0",
+    "less-loader": "^8.0.0",
+    "mini-css-extract-plugin": "^1.0.0",
+    "mkdirp": "^1.0.4",
+    "pako": "^2.0.0",
+    "postcss": "^8.0.0",
+    "postcss-loader": "^5.2.0",
+    "postcss-preset-env": "^6.7.0",
+    "prettier": "^2.0.5",
+    "query-string": "^7.0.0",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.21.0",
     "selenium-webdriver": "^3.6.0",
+    "semantic-release": "^17.4.1",
     "sri-toolbox": "^0.2.0",
-    "style-loader": "^0.23.1",
-    "stylelint": "^9.10.1",
-    "stylelint-config-standard": "^18.2.0",
-    "terser-webpack-plugin": "^1.2.2",
-    "webpack": "^4.29.5",
-    "webpack-bundle-analyzer": "^3.0.4",
-    "webpack-cli": "^3.2.3",
-    "webpack-dev-server": "^3.2.0"
+    "style-loader": "^2.0.0",
+    "stylelint": "^13.6.1",
+    "stylelint-config-standard": "^21.0.0",
+    "terser-webpack-plugin": "^5.0.3",
+    "webpack": "^5.8.0",
+    "webpack-bundle-analyzer": "^4.0.0",
+    "webpack-cli": "^4.2.0",
+    "webpack-dev-server": "^4.0.0-beta.0"
   },
   "bin": "cli.js",
   "scripts": {
     "test": "yarn test:lint && yarn test:flow && yarn test:jest",
     "test:lint": "yarn test:lint:js && yarn test:lint:css",
-    "test:lint:js": "eslint *.js src static test contrib dockers website",
+    "test:lint:js": "eslint .",
     "test:lint:css": "stylelint src/katex.less static/main.css contrib/**/*.css website/static/**/*.css",
     "test:flow": "flow",
     "test:jest": "jest",
@@ -90,21 +100,21 @@
     "test:perf": "NODE_ENV=test node test/perf-test.js",
     "clean": "rm -rf dist/ node_modules/",
     "clean-install": "yarn clean && yarn",
-    "start": "webpack-dev-server --hot --config webpack.dev.js",
+    "start": "webpack serve --config webpack.dev.js",
     "analyze": "webpack --config webpack.analyze.js",
-    "build": "rimraf dist/ && mkdirp dist && cp README.md dist && rollup -c && webpack",
+    "build": "rimraf dist/ && mkdirp dist && cp README.md dist && rollup -c && webpack && node update-sri.js package dist/README.md",
     "watch": "yarn build --watch",
-    "dist": "yarn test && yarn build && yarn dist:zip",
+    "postversion": "yarn dist && node update-sri.js package README.md contrib/*/README.md docs/*.md website/pages/index.html",
+    "semantic-release": "semantic-release",
+    "dist": "yarn build && yarn dist:zip",
     "dist:zip": "rimraf katex/ katex.tar.gz katex.zip && cp -R dist katex && tar czf katex.tar.gz katex && zip -rq katex.zip katex && rimraf katex/"
   },
   "dependencies": {
-    "commander": "^2.19.0"
+    "commander": "^6.0.0"
   },
   "husky": {
     "hooks": {
-      "pre-commit": "yarn test:lint",
-      "post-merge": "git submodule update --init --recursive",
-      "post-checkout": "git submodule update --init --recursive"
+      "pre-commit": "yarn test:lint"
     }
   },
   "jest": {

package/src/Lexer.js

@@ -42,7 +42,7 @@ const controlWordWhitespaceRegexString =
 const controlWordWhitespaceRegex = new RegExp(
     `^(${controlWordRegexString})${spaceRegexString}*$`);
 const combiningDiacriticalMarkString = "[\u0300-\u036f]";
-export const combiningDiacriticalMarksEndRegex =
+export const combiningDiacriticalMarksEndRegex: RegExp =
     new RegExp(`${combiningDiacriticalMarkString}+$`);
 const tokenRegexString = `(${spaceRegexString}+)|` +  // whitespace
     "([!-\\[\\]-\u2027\u202A-\uD7FF\uF900-\uFFFF]" +  // single codepoint
@@ -60,7 +60,8 @@ export default class Lexer implements LexerInterface {
     input: string;
     settings: Settings;
     tokenRegex: RegExp;
-    // category codes, only supports comment characters (14) for now
+    // Category codes. The lexer only supports comment characters (14) for now.
+    // MacroExpander additionally distinguishes active (13).
     catcodes: {[string]: number};
 
     constructor(input: string, settings: Settings) {
@@ -70,6 +71,7 @@ export default class Lexer implements LexerInterface {
         this.tokenRegex = new RegExp(tokenRegexString, 'g');
         this.catcodes = {
             "%": 14, // comment character
+            "~": 13, // active character
         };
     }
 

package/src/MacroExpander.js

@@ -13,7 +13,7 @@ import ParseError from "./ParseError";
 import Namespace from "./Namespace";
 import builtinMacros from "./macros";
 
-import type {MacroContextInterface, MacroDefinition, MacroExpansion}
+import type {MacroContextInterface, MacroDefinition, MacroExpansion, MacroArg}
     from "./macros";
 import type Settings from "./Settings";
 
@@ -108,6 +108,32 @@ export default class MacroExpander implements MacroContextInterface {
         this.stack.push(...tokens);
     }
 
+    /**
+     * Find an macro argument without expanding tokens and append the array of
+     * tokens to the token stack. Uses Token as a container for the result.
+     */
+    scanArgument(isOptional: boolean): ?Token {
+        let start;
+        let end;
+        let tokens;
+        if (isOptional) {
+            this.consumeSpaces(); // \@ifnextchar gobbles any space following it
+            if (this.future().text !== "[") {
+                return null;
+            }
+            start = this.popToken(); // don't include [ in tokens
+            ({tokens, end} = this.consumeArg(["]"]));
+        } else {
+            ({tokens, start, end} = this.consumeArg());
+        }
+
+        // indicate the end of an argument
+        this.pushToken(new Token("EOF", end.loc));
+
+        this.pushTokens(tokens);
+        return start.range(end, "");
+    }
+
     /**
      * Consume all following space tokens, without expansion.
      */
@@ -123,40 +149,91 @@ export default class MacroExpander implements MacroContextInterface {
     }
 
     /**
-     * Consume the specified number of arguments from the token stream,
-     * and return the resulting array of arguments.
+     * Consume an argument from the token stream, and return the resulting array
+     * of tokens and start/end token.
      */
-    consumeArgs(numArgs: number): Token[][] {
-        const args: Token[][] = [];
-        // obtain arguments, either single token or balanced {…} group
-        for (let i = 0; i < numArgs; ++i) {
-            this.consumeSpaces();  // ignore spaces before each argument
-            const startOfArg = this.popToken();
-            if (startOfArg.text === "{") {
-                const arg: Token[] = [];
-                let depth = 1;
-                while (depth !== 0) {
-                    const tok = this.popToken();
-                    arg.push(tok);
-                    if (tok.text === "{") {
-                        ++depth;
-                    } else if (tok.text === "}") {
-                        --depth;
-                    } else if (tok.text === "EOF") {
-                        throw new ParseError(
-                            "End of input in macro argument",
-                            startOfArg);
+    consumeArg(delims?: ?string[]): MacroArg {
+        // The argument for a delimited parameter is the shortest (possibly
+        // empty) sequence of tokens with properly nested {...} groups that is
+        // followed ... by this particular list of non-parameter tokens.
+        // The argument for an undelimited parameter is the next nonblank
+        // token, unless that token is ‘{’, when the argument will be the
+        // entire {...} group that follows.
+        const tokens: Token[] = [];
+        const isDelimited = delims && delims.length > 0;
+        if (!isDelimited) {
+            // Ignore spaces between arguments.  As the TeXbook says:
+            // "After you have said ‘\def\row#1#2{...}’, you are allowed to
+            //  put spaces between the arguments (e.g., ‘\row x n’), because
+            //  TeX doesn’t use single spaces as undelimited arguments."
+            this.consumeSpaces();
+        }
+        const start = this.future();
+        let tok;
+        let depth = 0;
+        let match = 0;
+        do {
+            tok = this.popToken();
+            tokens.push(tok);
+            if (tok.text === "{") {
+                ++depth;
+            } else if (tok.text === "}") {
+                --depth;
+                if (depth === -1) {
+                    throw new ParseError("Extra }", tok);
+                }
+            } else if (tok.text === "EOF") {
+                throw new ParseError("Unexpected end of input in a macro argument" +
+                    ", expected '" + (delims && isDelimited ? delims[match] : "}") +
+                    "'", tok);
+            }
+            if (delims && isDelimited) {
+                if ((depth === 0 || (depth === 1 && delims[match] === "{")) &&
+                    tok.text === delims[match]) {
+                    ++match;
+                    if (match === delims.length) {
+                        // don't include delims in tokens
+                        tokens.splice(-match, match);
+                        break;
                     }
+                } else {
+                    match = 0;
                 }
-                arg.pop(); // remove last }
-                arg.reverse(); // like above, to fit in with stack order
-                args[i] = arg;
-            } else if (startOfArg.text === "EOF") {
+            }
+        } while (depth !== 0 || isDelimited);
+        // If the argument found ... has the form ‘{<nested tokens>}’,
+        // ... the outermost braces enclosing the argument are removed
+        if (start.text === "{" && tokens[tokens.length - 1].text === "}") {
+            tokens.pop();
+            tokens.shift();
+        }
+        tokens.reverse(); // to fit in with stack order
+        return {tokens, start, end: tok};
+    }
+
+    /**
+     * Consume the specified number of (delimited) arguments from the token
+     * stream and return the resulting array of arguments.
+     */
+    consumeArgs(numArgs: number, delimiters?: string[][]): Token[][] {
+        if (delimiters) {
+            if (delimiters.length !== numArgs + 1) {
                 throw new ParseError(
-                    "End of input expecting macro argument");
-            } else {
-                args[i] = [startOfArg];
+                    "The length of delimiters doesn't match the number of args!");
             }
+            const delims = delimiters[0];
+            for (let i = 0; i < delims.length; i++) {
+                const tok = this.popToken();
+                if (delims[i] !== tok.text) {
+                    throw new ParseError(
+                        "Use of the macro doesn't match its definition", tok);
+                }
+            }
+        }
+
+        const args: Token[][] = [];
+        for (let i = 0; i < numArgs; i++) {
+            args.push(this.consumeArg(delimiters && delimiters[i + 1]).tokens);
         }
         return args;
     }
@@ -177,10 +254,6 @@ export default class MacroExpander implements MacroContextInterface {
      *
      * Used to implement `expandAfterFuture` and `expandNextToken`.
      *
-     * At the moment, macro expansion doesn't handle delimited macros,
-     * i.e. things like those defined by \def\foo#1\end{…}.
-     * See the TeX book page 202ff. for details on how those should behave.
-     *
      * If expandableOnly, only expandable tokens are expanded and
      * an undefined control sequence results in an error.
      */
@@ -202,8 +275,8 @@ export default class MacroExpander implements MacroContextInterface {
                 "need to increase maxExpand setting");
         }
         let tokens = expansion.tokens;
+        const args = this.consumeArgs(expansion.numArgs, expansion.delimiters);
         if (expansion.numArgs) {
-            const args = this.consumeArgs(expansion.numArgs);
             // paste arguments in place of the placeholders
             tokens = tokens.slice(); // make a shallow copy
             for (let i = tokens.length - 1; i >= 0; --i) {
@@ -322,6 +395,14 @@ export default class MacroExpander implements MacroContextInterface {
         if (definition == null) { // mainly checking for undefined here
             return definition;
         }
+        // If a single character has an associated catcode other than 13
+        // (active character), then don't expand it.
+        if (name.length === 1) {
+            const catcode = this.lexer.catcodes[name];
+            if (catcode != null && catcode !== 13) {
+                return;
+            }
+        }
         const expansion =
             typeof definition === "function" ? definition(this) : definition;
         if (typeof expansion === "string") {
@@ -368,7 +449,6 @@ export default class MacroExpander implements MacroContextInterface {
         const macro = this.macros.get(name);
         return macro != null ? typeof macro === "string"
                 || typeof macro === "function" || !macro.unexpandable
-            // TODO(ylem): #2085
-            : functions.hasOwnProperty(name)/* && !functions[name].primitive*/;
+            : functions.hasOwnProperty(name) && !functions[name].primitive;
     }
 }

package/src/Options.js

@@ -83,7 +83,7 @@ class Options {
     /**
      * The base size index.
      */
-    static BASESIZE = 6;
+    static BASESIZE: number = 6;
 
     constructor(data: OptionsData) {
         this.style = data.style;
@@ -242,7 +242,7 @@ class Options {
     /**
      * Create a new options objects with the given fontFamily.
      */
-    withTextFontFamily(fontFamily: string) {
+    withTextFontFamily(fontFamily: string): Options {
         return this.extend({
             fontFamily,
             font: "",

package/src/ParseError.js

@@ -18,7 +18,7 @@ class ParseError {
     constructor(
         message: string,               // The error message
         token?: ?Token | AnyParseNode, // An object providing position information
-    ) {
+    ): Error {
         let error = "KaTeX parse error: " + message;
         let start;