katex 0.11.1 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "katex",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "Fast math typesetting for the web.",
   "main": "dist/katex.js",
   "homepage": "https://katex.org",
@@ -28,10 +28,11 @@
     "babel-jest": "^24.1.0",
     "babel-loader": "^8.0.5",
     "babel-plugin-istanbul": "^5.1.1",
+    "babel-plugin-preval": "^3.0.1",
     "babel-plugin-version-inline": "^1.0.0",
     "benchmark": "^2.1.4",
-    "browserslist": "^4.4.1",
-    "caniuse-lite": "^1.0.30000938",
+    "browserslist": "^4.7.1",
+    "caniuse-lite": "^1.0.30001002",
     "codecov": "^3.2.0",
     "css-loader": "^3.0.0",
     "cssnano": "^4.1.10",
@@ -75,7 +76,7 @@
   },
   "bin": "cli.js",
   "scripts": {
-    "test": "yarn prestart && yarn test:lint && yarn test:flow && yarn test:jest",
+    "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:css": "stylelint src/katex.less static/main.css contrib/**/*.css website/static/**/*.css",
@@ -85,14 +86,13 @@
     "test:jest:update": "jest --updateSnapshot",
     "test:jest:coverage": "jest --coverage",
     "test:screenshots": "yarn test:screenshots:update --verify",
-    "test:screenshots:update": "yarn prestart && dockers/screenshotter/screenshotter.sh",
-    "test:perf": "yarn prestart && NODE_ENV=test node test/perf-test.js",
+    "test:screenshots:update": "dockers/screenshotter/screenshotter.sh",
+    "test:perf": "NODE_ENV=test node test/perf-test.js",
     "clean": "rm -rf dist/ node_modules/",
     "clean-install": "yarn clean && yarn",
-    "prestart": "node src/unicodeMake.js",
     "start": "webpack-dev-server --hot --config webpack.dev.js",
     "analyze": "webpack --config webpack.analyze.js",
-    "build": "yarn prestart && rimraf dist/ && mkdirp dist && cp README.md dist && rollup -c && webpack",
+    "build": "rimraf dist/ && mkdirp dist && cp README.md dist && rollup -c && webpack",
     "watch": "yarn build --watch",
     "dist": "yarn test && 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/"
@@ -111,7 +111,7 @@
     "collectCoverageFrom": [
       "src/**/*.js",
       "contrib/**/*.js",
-      "!src/unicodeMake.js",
+      "!src/unicodeSymbols.js",
       "!contrib/mhchem/**"
     ],
     "setupFilesAfterEnv": [

package/src/MacroExpander.js

@@ -180,13 +180,19 @@ export default class MacroExpander implements MacroContextInterface {
      * 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.
      */
-    expandOnce(): Token | Token[] {
+    expandOnce(expandableOnly?: boolean): Token | Token[] {
         const topToken = this.popToken();
         const name = topToken.text;
-        const expansion = this._getExpansion(name);
-        if (expansion == null) { // mainly checking for undefined here
-            // Fully expanded
+        const expansion = !topToken.noexpand ? this._getExpansion(name) : null;
+        if (expansion == null || (expandableOnly && expansion.unexpandable)) {
+            if (expandableOnly && expansion == null &&
+                    name[0] === "\\" && !this.isDefined(name)) {
+                throw new ParseError("Undefined control sequence: " + name);
+            }
             this.pushToken(topToken);
             return topToken;
         }
@@ -248,7 +254,9 @@ export default class MacroExpander implements MacroContextInterface {
             if (expanded instanceof Token) {
                 // \relax stops the expansion, but shouldn't get returned (a
                 // null return value couldn't get implemented as a function).
-                if (expanded.text === "\\relax") {
+                // the token after \noexpand is interpreted as if its meaning
+                // were ‘\relax’
+                if (expanded.text === "\\relax" || expanded.treatAsRelax) {
                     this.stack.pop();
                 } else {
                     return this.stack.pop();  // === expanded
@@ -266,16 +274,26 @@ export default class MacroExpander implements MacroContextInterface {
      * tokens, or return `undefined` if no such macro is defined.
      */
     expandMacro(name: string): Token[] | void {
-        if (!this.macros.get(name)) {
-            return undefined;
-        }
+        return this.macros.has(name)
+            ? this.expandTokens([new Token(name)]) : undefined;
+    }
+
+    /**
+     * Fully expand the given token stream and return the resulting list of tokens
+     */
+    expandTokens(tokens: Token[]): Token[] {
         const output = [];
         const oldStackLength = this.stack.length;
-        this.pushToken(new Token(name));
+        this.pushTokens(tokens);
         while (this.stack.length > oldStackLength) {
-            const expanded = this.expandOnce();
+            const expanded = this.expandOnce(true); // expand only expandable tokens
             // expandOnce returns Token if and only if it's fully expanded.
             if (expanded instanceof Token) {
+                if (expanded.treatAsRelax) {
+                    // the expansion of \noexpand is the token itself
+                    expanded.noexpand = false;
+                    expanded.treatAsRelax = false;
+                }
                 output.push(this.stack.pop());
             }
         }
@@ -342,4 +360,15 @@ export default class MacroExpander implements MacroContextInterface {
             symbols.text.hasOwnProperty(name) ||
             implicitCommands.hasOwnProperty(name);
     }
+
+    /**
+     * Determine whether a command is expandable.
+     */
+    isExpandable(name: string): boolean {
+        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*/;
+    }
 }

package/src/Parser.js

@@ -5,14 +5,16 @@ import MacroExpander, {implicitCommands} from "./MacroExpander";
 import symbols, {ATOMS, extraLatin} from "./symbols";
 import {validUnit} from "./units";
 import {supportedCodepoint} from "./unicodeScripts";
-import unicodeAccents from "./unicodeAccents";
-import unicodeSymbols from "./unicodeSymbols";
-import {checkNodeType} from "./parseNode";
 import ParseError from "./ParseError";
 import {combiningDiacriticalMarksEndRegex} from "./Lexer";
 import Settings from "./Settings";
 import SourceLocation from "./SourceLocation";
 import {Token} from "./Token";
+
+// Pre-evaluate both modules as unicodeSymbols require String.normalize()
+import unicodeAccents from /*preval*/ "./unicodeAccents";
+import unicodeSymbols from /*preval*/ "./unicodeSymbols";
+
 import type {ParseNode, AnyParseNode, SymbolParseNode, UnsupportedCmdParseNode}
     from "./parseNode";
 import type {Atom, Group} from "./symbols";
@@ -115,9 +117,11 @@ export default class Parser {
      * Main parsing function, which parses an entire input.
      */
     parse(): AnyParseNode[] {
-        // Create a group namespace for the math expression.
-        // (LaTeX creates a new group for every $...$, $$...$$, \[...\].)
-        this.gullet.beginGroup();
+        if (!this.settings.globalGroup) {
+            // Create a group namespace for the math expression.
+            // (LaTeX creates a new group for every $...$, $$...$$, \[...\].)
+            this.gullet.beginGroup();
+        }
 
         // Use old \color behavior (same as LaTeX's \textcolor) if requested.
         // We do this within the group for the math expression, so it doesn't
@@ -133,7 +137,9 @@ export default class Parser {
         this.expect("EOF");
 
         // End the group namespace for the expression
-        this.gullet.endGroup();
+        if (!this.settings.globalGroup) {
+            this.gullet.endGroup();
+        }
         return parse;
     }
 
@@ -181,6 +187,8 @@ export default class Parser {
             const atom = this.parseAtom(breakOnTokenText);
             if (!atom) {
                 break;
+            } else if (atom.type === "internal") {
+                continue;
             }
             body.push(atom);
         }
@@ -202,15 +210,14 @@ export default class Parser {
         let funcName;
 
         for (let i = 0; i < body.length; i++) {
-            const node = checkNodeType(body[i], "infix");
-            if (node) {
+            if (body[i].type === "infix") {
                 if (overIndex !== -1) {
                     throw new ParseError(
                         "only one infix operator per group",
-                        node.token);
+                        body[i].token);
                 }
                 overIndex = i;
-                funcName = node.replaceWith;
+                funcName = body[i].replaceWith;
             }
         }
 
@@ -325,21 +332,18 @@ export default class Parser {
 
             if (lex.text === "\\limits" || lex.text === "\\nolimits") {
                 // We got a limit control
-                let opNode = checkNodeType(base, "op");
-                if (opNode) {
+                if (base && base.type === "op") {
                     const limits = lex.text === "\\limits";
-                    opNode.limits = limits;
-                    opNode.alwaysHandleSupSub = true;
+                    base.limits = limits;
+                    base.alwaysHandleSupSub = true;
+                } else if (base && base.type === "operatorname"
+                        && base.alwaysHandleSupSub) {
+                    const limits = lex.text === "\\limits";
+                    base.limits = limits;
                 } else {
-                    opNode = checkNodeType(base, "operatorname");
-                    if (opNode && opNode.alwaysHandleSupSub) {
-                        const limits = lex.text === "\\limits";
-                        opNode.limits = limits;
-                    } else {
-                        throw new ParseError(
-                            "Limit controls must follow a math operator",
-                            lex);
-                    }
+                    throw new ParseError(
+                        "Limit controls must follow a math operator",
+                        lex);
                 }
                 this.consume();
             } else if (lex.text === "^") {

package/src/Settings.js

@@ -32,6 +32,22 @@ export type TrustContextTypes = {
         url: string,
         protocol?: string,
     |},
+    "\\htmlClass": {|
+        command: "\\htmlClass",
+        class: string,
+    |},
+    "\\htmlId": {|
+        command: "\\htmlId",
+        id: string,
+    |},
+    "\\htmlStyle": {|
+        command: "\\htmlStyle",
+        style: string,
+    |},
+    "\\htmlData": {|
+        command: "\\htmlData",
+        attributes: {[string]: string},
+    |},
 };
 export type AnyTrustContext = $Values<TrustContextTypes>;
 export type TrustFunction = (context: AnyTrustContext) => ?boolean;
@@ -50,6 +66,7 @@ export type SettingsOptions = {
     trust?: boolean | TrustFunction;
     maxSize?: number;
     maxExpand?: number;
+    globalGroup?: boolean;
 };
 
 /**
@@ -76,6 +93,7 @@ export default class Settings {
     trust: boolean | TrustFunction;
     maxSize: number;
     maxExpand: number;
+    globalGroup: boolean;
 
     constructor(options: SettingsOptions) {
         // allow null options
@@ -96,6 +114,7 @@ export default class Settings {
         this.trust = utils.deflt(options.trust, false);
         this.maxSize = Math.max(0, utils.deflt(options.maxSize, Infinity));
         this.maxExpand = Math.max(0, utils.deflt(options.maxExpand, 1000));
+        this.globalGroup = utils.deflt(options.globalGroup, false);
     }
 
     /**

package/src/Token.js

@@ -23,6 +23,8 @@ export interface LexerInterface {input: string, tokenRegex: RegExp}
 export class Token {
     text: string;
     loc: ?SourceLocation;
+    noexpand: ?boolean; // don't expand the token
+    treatAsRelax: ?boolean; // used in \noexpand
 
     constructor(
         text: string,           // the text of this token

package/src/buildCommon.js

@@ -8,7 +8,6 @@
 import {SymbolNode, Anchor, Span, PathNode, SvgNode, createClass} from "./domTree";
 import {getCharacterMetrics} from "./fontMetrics";
 import symbols, {ligatures} from "./symbols";
-import utils from "./utils";
 import {wideCharacterFont} from "./wide-character";
 import {calculateSize} from "./units";
 import {DocumentFragment} from "./tree";
@@ -21,13 +20,6 @@ import type {documentFragment as HtmlDocumentFragment} from "./domTree";
 import type {HtmlDomNode, DomSpan, SvgSpan, CssStyle} from "./domTree";
 import type {Measurement} from "./units";
 
-// The following have to be loaded from Main-Italic font, using class mathit
-const mathitLetters = [
-    "\\imath", "ı",       // dotless i
-    "\\jmath", "ȷ",       // dotless j
-    "\\pounds", "\\mathsterling", "\\textsterling", "£",   // pounds symbol
-];
-
 /**
  * Looks up the given symbol in fontMetrics, after applying any symbol
  * replacements defined in symbol.js
@@ -128,63 +120,6 @@ const mathsym = function(
     }
 };
 
-/**
- * Determines which of the two font names (Main-Italic and Math-Italic) and
- * corresponding style tags (maindefault or mathit) to use for default math font,
- * depending on the symbol.
- */
-const mathdefault = function(
-    value: string,
-    mode: Mode,
-    options: Options,
-    classes: string[],
-): {| fontName: string, fontClass: string |} {
-    if (/[0-9]/.test(value.charAt(0)) ||
-            // glyphs for \imath and \jmath do not exist in Math-Italic so we
-            // need to use Main-Italic instead
-            utils.contains(mathitLetters, value)) {
-        return {
-            fontName: "Main-Italic",
-            fontClass: "mathit",
-        };
-    } else {
-        return {
-            fontName: "Math-Italic",
-            fontClass: "mathdefault",
-        };
-    }
-};
-
-/**
- * Determines which of the font names (Main-Italic, Math-Italic, and Caligraphic)
- * and corresponding style tags (mathit, mathdefault, or mathcal) to use for font
- * "mathnormal", depending on the symbol.  Use this function instead of fontMap for
- * font "mathnormal".
- */
-const mathnormal = function(
-    value: string,
-    mode: Mode,
-    options: Options,
-    classes: string[],
-): {| fontName: string, fontClass: string |} {
-    if (utils.contains(mathitLetters, value)) {
-        return {
-            fontName: "Main-Italic",
-            fontClass: "mathit",
-        };
-    } else if (/[0-9]/.test(value.charAt(0))) {
-        return {
-            fontName: "Caligraphic-Regular",
-            fontClass: "mathcal",
-        };
-    } else {
-        return {
-            fontName: "Math-Italic",
-            fontClass: "mathdefault",
-        };
-    }
-};
-
 /**
  * Determines which of the two font names (Main-Bold and Math-BoldItalic) and
  * corresponding style tags (mathbf or boldsymbol) to use for font "boldsymbol",
@@ -196,8 +131,10 @@ const boldsymbol = function(
     mode: Mode,
     options: Options,
     classes: string[],
+    type: "mathord" | "textord",
 ): {| fontName: string, fontClass: string |} {
-    if (lookupSymbol(value, "Math-BoldItalic", mode).metrics) {
+    if (type !== "textord" &&
+        lookupSymbol(value, "Math-BoldItalic", mode).metrics) {
         return {
             fontName: "Math-BoldItalic",
             fontClass: "boldsymbol",
@@ -236,15 +173,10 @@ const makeOrd = function<NODETYPE: "spacing" | "mathord" | "textord">(
     } else if (fontOrFamily) {
         let fontName;
         let fontClasses;
-        if (fontOrFamily === "boldsymbol" || fontOrFamily === "mathnormal") {
-            const fontData = fontOrFamily === "boldsymbol"
-                ? boldsymbol(text, mode, options, classes)
-                : mathnormal(text, mode, options, classes);
+        if (fontOrFamily === "boldsymbol") {
+            const fontData = boldsymbol(text, mode, options, classes, type);
             fontName = fontData.fontName;
             fontClasses = [fontData.fontClass];
-        } else if (utils.contains(mathitLetters, text)) {
-            fontName = "Main-Italic";
-            fontClasses = ["mathit"];
         } else if (isFont) {
             fontName = fontMap[fontOrFamily].fontName;
             fontClasses = [fontOrFamily];
@@ -271,9 +203,8 @@ const makeOrd = function<NODETYPE: "spacing" | "mathord" | "textord">(
 
     // Makes a symbol in the default font for mathords and textords.
     if (type === "mathord") {
-        const fontLookup = mathdefault(text, mode, options, classes);
-        return makeSymbol(text, fontLookup.fontName, mode, options,
-            classes.concat([fontLookup.fontClass]));
+        return makeSymbol(text, "Math-Italic", mode, options,
+            classes.concat(["mathnormal"]));
     } else if (type === "textord") {
         const font = symbols[mode][text] && symbols[mode][text].font;
         if (font === "ams") {
@@ -752,13 +683,14 @@ const fontMap: {[string]: {| variant: FontVariant, fontName: string |}} = {
         variant: "italic",
         fontName: "Main-Italic",
     },
+    "mathnormal": {
+        variant: "italic",
+        fontName: "Math-Italic",
+    },
 
-    // Default math font, "mathnormal" and "boldsymbol" are missing because they
-    // require the use of several fonts: Main-Italic and Math-Italic for default
-    // math font, Main-Italic, Math-Italic, Caligraphic for "mathnormal", and
-    // Math-BoldItalic and Main-Bold for "boldsymbol".  This is handled by a
-    // special case in makeOrd which ends up calling mathdefault, mathnormal,
-    // and boldsymbol.
+    // "boldsymbol" is missing because they require the use of multiple fonts:
+    // Math-BoldItalic and Main-Bold.  This is handled by a special case in
+    // makeOrd which ends up calling boldsymbol.
 
     // families
     "mathbb": {
@@ -796,6 +728,8 @@ const svgData: {
     oiintSize2: ["oiintSize2", 1.472, 0.659],
     oiiintSize1: ["oiiintSize1", 1.304, 0.499],
     oiiintSize2: ["oiiintSize2", 1.98, 0.659],
+    leftParenInner: ["leftParenInner", 0.875, 0.3],
+    rightParenInner: ["rightParenInner", 0.875, 0.3],
 };
 
 const staticSvg = function(value: string, options: Options): SvgSpan {

package/src/buildHTML.js

@@ -9,9 +9,8 @@
 import ParseError from "./ParseError";
 import Style from "./Style";
 import buildCommon from "./buildCommon";
-import {Anchor} from "./domTree";
+import {Span, Anchor} from "./domTree";
 import utils from "./utils";
-import {checkNodeType} from "./parseNode";
 import {spacings, tightSpacings} from "./spacingData";
 import {_htmlGroupBuilders as groupBuilders} from "./defineFunction";
 import {DocumentFragment} from "./tree";
@@ -60,7 +59,7 @@ type DomType = $Keys<typeof DomEnum>;
 export const buildExpression = function(
     expression: AnyParseNode[],
     options: Options,
-    isRealGroup: boolean,
+    isRealGroup: boolean | "root",
     surrounding: [?DomType, ?DomType] = [null, null],
 ): HtmlDomNode[] {
     // Parse expressions into `groups`.
@@ -83,11 +82,8 @@ export const buildExpression = function(
 
     let glueOptions = options;
     if (expression.length === 1) {
-        const node = checkNodeType(expression[0], "sizing") ||
-            checkNodeType(expression[0], "styling");
-        if (!node) {
-            // No match.
-        } else if (node.type === "sizing") {
+        const node = expression[0];
+        if (node.type === "sizing") {
             glueOptions = options.havingSize(node.size);
         } else if (node.type === "styling") {
             glueOptions = options.havingStyle(styleMap[node.style]);
@@ -106,6 +102,7 @@ export const buildExpression = function(
 
     // Before determining what spaces to insert, perform bin cancellation.
     // Binary operators change to ordinary symbols in some contexts.
+    const isRoot = (isRealGroup === "root");
     traverseNonSpaceNodes(groups, (node, prev) => {
         const prevType = prev.classes[0];
         const type = node.classes[0];
@@ -114,7 +111,7 @@ export const buildExpression = function(
         } else if (type === "mbin" && utils.contains(binLeftCanceller, prevType)) {
             node.classes[0] = "mord";
         }
-    }, {node: dummyPrev}, dummyNext);
+    }, {node: dummyPrev}, dummyNext, isRoot);
 
     traverseNonSpaceNodes(groups, (node, prev) => {
         const prevType = getTypeOfDomTree(prev);
@@ -127,7 +124,7 @@ export const buildExpression = function(
         if (space) { // Insert glue (spacing) after the `prev`.
             return buildCommon.makeGlue(space, glueOptions);
         }
-    }, {node: dummyPrev}, dummyNext);
+    }, {node: dummyPrev}, dummyNext, isRoot);
 
     return groups;
 };
@@ -145,6 +142,7 @@ const traverseNonSpaceNodes = function(
         insertAfter?: HtmlDomNode => void,
     |},
     next: ?HtmlDomNode,
+    isRoot: boolean,
 ) {
     if (next) { // temporarily append the right node, if exists
         nodes.push(next);
@@ -155,27 +153,31 @@ const traverseNonSpaceNodes = function(
         const partialGroup = checkPartialGroup(node);
         if (partialGroup) { // Recursive DFS
             // $FlowFixMe: make nodes a $ReadOnlyArray by returning a new array
-            traverseNonSpaceNodes(partialGroup.children, callback, prev);
+            traverseNonSpaceNodes(partialGroup.children,
+                callback, prev, null, isRoot);
             continue;
         }
 
         // Ignore explicit spaces (e.g., \;, \,) when determining what implicit
         // spacing should go between atoms of different classes
-        if (node.classes[0] === "mspace") {
-            continue;
-        }
-
-        const result = callback(node, prev.node);
-        if (result) {
-            if (prev.insertAfter) {
-                prev.insertAfter(result);
-            } else { // insert at front
-                nodes.unshift(result);
-                i++;
+        const nonspace = !node.hasClass("mspace");
+        if (nonspace) {
+            const result = callback(node, prev.node);
+            if (result) {
+                if (prev.insertAfter) {
+                    prev.insertAfter(result);
+                } else { // insert at front
+                    nodes.unshift(result);
+                    i++;
+                }
             }
         }
 
-        prev.node = node;
+        if (nonspace) {
+            prev.node = node;
+        } else if (isRoot && node.hasClass("newline")) {
+            prev.node = makeSpan(["leftmost"]); // treat like beginning of line
+        }
         prev.insertAfter = (index => n => {
             nodes.splice(index + 1, 0, n);
             i++;
@@ -189,8 +191,9 @@ const traverseNonSpaceNodes = function(
 // Check if given node is a partial group, i.e., does not affect spacing around.
 const checkPartialGroup = function(
     node: HtmlDomNode,
-): ?(DocumentFragment<HtmlDomNode> | Anchor) {
-    if (node instanceof DocumentFragment || node instanceof Anchor) {
+): ?(DocumentFragment<HtmlDomNode> | Anchor | DomSpan) {
+    if (node instanceof DocumentFragment || node instanceof Anchor
+        || (node instanceof Span && node.hasClass("enclosing"))) {
         return node;
     }
     return null;
@@ -292,10 +295,6 @@ function buildHTMLUnbreakable(children, options) {
     // Add strut, which ensures that the top of the HTML element falls at
     // the height of the expression, and the bottom of the HTML element
     // falls at the depth of the expression.
-    // We used to have separate top and bottom struts, where the bottom strut
-    // would like to use `vertical-align: top`, but in IE 9 this lowers the
-    // baseline of the box to the bottom of this strut (instead of staying in
-    // the normal place) so we use an absolute value for vertical-align instead.
     const strut = makeSpan(["strut"]);
     strut.style.height = (body.height + body.depth) + "em";
     strut.style.verticalAlign = -body.depth + "em";
@@ -317,7 +316,7 @@ export default function buildHTML(tree: AnyParseNode[], options: Options): DomSp
     }
 
     // Build the expression contained in the tree
-    const expression = buildExpression(tree, options, true);
+    const expression = buildExpression(tree, options, "root");
 
     const children = [];
 

package/src/buildMathML.js

@@ -93,7 +93,7 @@ export const getVariant = function(
     if (font === "mathit") {
         return "italic";
     } else if (font === "boldsymbol") {
-        return "bold-italic";
+        return group.type === "textord" ? "bold" : "bold-italic";
     } else if (font === "mathbf") {
         return "bold";
     } else if (font === "mathbb") {
@@ -238,6 +238,7 @@ export default function buildMathML(
     tree: AnyParseNode[],
     texExpression: string,
     options: Options,
+    isDisplayMode: boolean,
     forMathmlOnly: boolean,
 ): DomSpan {
     const expression = buildExpression(tree, options);
@@ -263,6 +264,9 @@ export default function buildMathML(
 
     const math = new mathMLTree.MathNode("math", [semantics]);
     math.setAttribute("xmlns", "http://www.w3.org/1998/Math/MathML");
+    if (isDisplayMode) {
+        math.setAttribute("display", "block");
+    }
 
     // You can't style <math> nodes, so we wrap the node in a span.
     // NOTE: The span class is not typed to have <math> nodes as children, and

package/src/buildTree.js

@@ -39,12 +39,13 @@ export const buildTree = function(
     const options = optionsFromSettings(settings);
     let katexNode;
     if (settings.output === "mathml") {
-        return  buildMathML(tree, expression, options, true);
+        return  buildMathML(tree, expression, options, settings.displayMode, true);
     } else if (settings.output === "html") {
         const htmlNode = buildHTML(tree, options);
         katexNode = buildCommon.makeSpan(["katex"], [htmlNode]);
     } else {
-        const mathMLNode = buildMathML(tree, expression, options, false);
+        const mathMLNode = buildMathML(tree, expression, options,
+            settings.displayMode, false);
         const htmlNode = buildHTML(tree, options);
         katexNode = buildCommon.makeSpan(["katex"], [mathMLNode, htmlNode]);
     }

package/src/defineFunction.js

@@ -1,6 +1,4 @@
 // @flow
-import {checkNodeType} from "./parseNode";
-
 import type Parser from "./Parser";
 import type {ParseNode, AnyParseNode, NodeType, UnsupportedCmdParseNode}
     from "./parseNode";
@@ -228,6 +226,5 @@ export function defineFunctionBuilders<NODETYPE: NodeType>({
 // Since the corresponding buildHTML/buildMathML function expects a
 // list of elements, we normalize for different kinds of arguments
 export const ordargument = function(arg: AnyParseNode): AnyParseNode[] {
-    const node = checkNodeType(arg, "ordgroup");
-    return node ? node.body : [arg];
+    return arg.type === "ordgroup" ? arg.body : [arg];
 };