katex 0.11.1 → 0.12.0

package/src/delimiter.js

@@ -375,9 +375,20 @@ const makeStackedDelim = function(
 
     // To cover the gap create by the overlaps, insert one more repeat element,
     // at a position that juts 0.005 above the bottom of the top element.
-    inners.push({type: "kern", size: shiftOfExtraElement});
-    inners.push(makeInner(repeat, font, mode));
-    inners.push(lap);
+    if ((repeat === "\u239c" || repeat === "\u239f") && repeatCount === 0) {
+        // Parentheses need a short repeat element in order to avoid an overrun.
+        // We'll make a 0.3em tall element from a SVG.
+        const overlap = buildCommon.svgData.leftParenInner[2] / 2;
+        inners.push({type: "kern", size: -overlap});
+        const pathName = repeat === "\u239c" ? "leftParenInner" : "rightParenInner";
+        const innerSpan = buildCommon.staticSvg(pathName, options);
+        inners.push({type: "elem", elem: innerSpan});
+        inners.push({type: "kern", size: -overlap});
+    } else {
+        inners.push({type: "kern", size: shiftOfExtraElement});
+        inners.push(makeInner(repeat, font, mode));
+        inners.push(lap);
+    }
 
     // Add the top symbol
     inners.push(makeInner(top, font, mode));

package/src/environments/array.js

@@ -6,7 +6,7 @@ import defineFunction from "../defineFunction";
 import mathMLTree from "../mathMLTree";
 import ParseError from "../ParseError";
 import {assertNodeType, assertSymbolNodeType} from "../parseNode";
-import {checkNodeType, checkSymbolNodeType} from "../parseNode";
+import {checkSymbolNodeType} from "../parseNode";
 import {calculateSize} from "../units";
 import utils from "../utils";
 
@@ -435,7 +435,7 @@ const mathmlBuilder: MathMLBuilder<"array"> = function(group, options) {
     let menclose = "";
     let align = "";
 
-    if (group.cols) {
+    if (group.cols && group.cols.length > 0) {
         // Find column alignment, column spacing, and  vertical lines.
         const cols = group.cols;
         let columnLines = "";
@@ -547,11 +547,10 @@ const alignedHandler = function(context, args) {
         mode: context.mode,
         body: [],
     };
-    const ordgroup = checkNodeType(args[0], "ordgroup");
-    if (ordgroup) {
+    if (args[0] && args[0].type === "ordgroup") {
         let arg0 = "";
-        for (let i = 0; i < ordgroup.body.length; i++) {
-            const textord = assertNodeType(ordgroup.body[i], "textord");
+        for (let i = 0; i < args[0].body.length; i++) {
+            const textord = assertNodeType(args[0].body[i], "textord");
             arg0 += textord.text;
         }
         numMaths = Number(arg0);
@@ -738,7 +737,7 @@ defineEnvironment({
             arraystretch: 0.5,
         };
         res = parseArray(context.parser, res, "script");
-        if (res.body[0].length > 1) {
+        if (res.body.length > 0 &&  res.body[0].length > 1) {
             throw new ParseError("{subarray} can contain only one column");
         }
         return res;
@@ -752,11 +751,14 @@ defineEnvironment({
 // \left\{\begin{array}{@{}l@{\quad}l@{}} … \end{array}\right.
 // {dcases} is a {cases} environment where cells are set in \displaystyle,
 // as defined in mathtools.sty.
+// {rcases} is another mathtools environment. It's brace is on the right side.
 defineEnvironment({
     type: "array",
     names: [
         "cases",
         "dcases",
+        "rcases",
+        "drcases",
     ],
     props: {
         numArgs: 0,
@@ -786,8 +788,8 @@ defineEnvironment({
             type: "leftright",
             mode: context.mode,
             body: [res],
-            left: "\\{",
-            right: ".",
+            left: context.envName.indexOf("r") > -1 ? "." : "\\{",
+            right: context.envName.indexOf("r") > -1 ? "\\}" : ".",
             rightColor: undefined,
         };
     },

package/src/functions/accent.js

@@ -4,7 +4,7 @@ import buildCommon from "../buildCommon";
 import mathMLTree from "../mathMLTree";
 import utils from "../utils";
 import stretchy from "../stretchy";
-import {assertNodeType, checkNodeType} from "../parseNode";
+import {assertNodeType} from "../parseNode";
 import {assertSpan, assertSymbolDomNode} from "../domTree";
 
 import * as html from "../buildHTML";
@@ -20,9 +20,8 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
     let base: AnyParseNode;
     let group: ParseNode<"accent">;
 
-    const supSub: ?ParseNode<"supsub"> = checkNodeType(grp, "supsub");
     let supSubGroup;
-    if (supSub) {
+    if (grp && grp.type === "supsub") {
         // If our base is a character box, and we have superscripts and
         // subscripts, the supsub will defer to us. In particular, we want
         // to attach the superscripts and subscripts to the inner body (so
@@ -32,18 +31,18 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
         // rendering that, while keeping track of where the accent is.
 
         // The real accent group is the base of the supsub group
-        group = assertNodeType(supSub.base, "accent");
+        group = assertNodeType(grp.base, "accent");
         // The character box is the base of the accent group
         base = group.base;
         // Stick the character box into the base of the supsub group
-        supSub.base = base;
+        grp.base = base;
 
         // Rerender the supsub group with its new base, and store that
         // result.
-        supSubGroup = assertSpan(html.buildGroup(supSub, options));
+        supSubGroup = assertSpan(html.buildGroup(grp, options));
 
         // reset original base
-        supSub.base = group;
+        grp.base = group;
     } else {
         group = assertNodeType(grp, "accent");
         base = group.base;

package/src/functions/accentunder.js

@@ -37,8 +37,8 @@ defineFunction({
 
         // Generate the vlist, with the appropriate kerns
         const vlist = buildCommon.makeVList({
-            positionType: "bottom",
-            positionData: accentBody.height + kern,
+            positionType: "top",
+            positionData: innerGroup.height,
             children: [
                 {type: "elem", elem: accentBody, wrapperClasses: ["svg-align"]},
                 {type: "kern", size: kern},

package/src/functions/def.js

@@ -0,0 +1,184 @@
+//@flow
+import defineFunction from "../defineFunction";
+import ParseError from "../ParseError";
+import {assertNodeType} from "../parseNode";
+
+const globalMap = {
+    "\\global": "\\global",
+    "\\long": "\\\\globallong",
+    "\\\\globallong": "\\\\globallong",
+    "\\def": "\\gdef",
+    "\\gdef": "\\gdef",
+    "\\edef": "\\xdef",
+    "\\xdef": "\\xdef",
+    "\\let": "\\\\globallet",
+    "\\futurelet": "\\\\globalfuture",
+};
+
+const checkControlSequence = (tok) => {
+    const name = tok.text;
+    if (/^(?:[\\{}$&#^_]|EOF)$/.test(name)) {
+        throw new ParseError("Expected a control sequence", tok);
+    }
+    return name;
+};
+
+const getRHS = (parser) => {
+    let tok = parser.gullet.popToken();
+    if (tok.text === "=") { // consume optional equals
+        tok = parser.gullet.popToken();
+        if (tok.text === " ") { // consume one optional space
+            tok = parser.gullet.popToken();
+        }
+    }
+    return tok;
+};
+
+const letCommand = (parser, name, tok, global) => {
+    let macro = parser.gullet.macros.get(tok.text);
+    if (macro == null) {
+        // don't expand it later even if a macro with the same name is defined
+        // e.g., \let\foo=\frac \def\frac{\relax} \frac12
+        tok.noexpand = true;
+        macro = {
+            tokens: [tok],
+            numArgs: 0,
+            // reproduce the same behavior in expansion
+            unexpandable: !parser.gullet.isExpandable(tok.text),
+        };
+    }
+    parser.gullet.macros.set(name, macro, global);
+};
+
+// <assignment> -> <non-macro assignment>|<macro assignment>
+// <non-macro assignment> -> <simple assignment>|\global<non-macro assignment>
+// <macro assignment> -> <definition>|<prefix><macro assignment>
+// <prefix> -> \global|\long|\outer
+defineFunction({
+    type: "internal",
+    names: [
+        "\\global", "\\long",
+        "\\\\globallong", // can’t be entered directly
+    ],
+    props: {
+        numArgs: 0,
+        allowedInText: true,
+    },
+    handler({parser, funcName}) {
+        parser.consumeSpaces();
+        const token = parser.fetch();
+        if (globalMap[token.text]) {
+            // KaTeX doesn't have \par, so ignore \long
+            if (funcName === "\\global" || funcName === "\\\\globallong") {
+                token.text = globalMap[token.text];
+            }
+            return assertNodeType(parser.parseFunction(), "internal");
+        }
+        throw new ParseError(`Invalid token after macro prefix`, token);
+    },
+});
+
+// Basic support for macro definitions: \def, \gdef, \edef, \xdef
+// <definition> -> <def><control sequence><definition text>
+// <def> -> \def|\gdef|\edef|\xdef
+// <definition text> -> <parameter text><left brace><balanced text><right brace>
+defineFunction({
+    type: "internal",
+    names: ["\\def", "\\gdef", "\\edef", "\\xdef"],
+    props: {
+        numArgs: 0,
+        allowedInText: true,
+    },
+    handler({parser, funcName}) {
+        let arg = parser.gullet.consumeArgs(1)[0];
+        if (arg.length !== 1) {
+            throw new ParseError("\\gdef's first argument must be a macro name");
+        }
+        const name = arg[0].text;
+        // Count argument specifiers, and check they are in the order #1 #2 ...
+        let numArgs = 0;
+        arg = parser.gullet.consumeArgs(1)[0];
+        while (arg.length === 1 && arg[0].text === "#") {
+            arg = parser.gullet.consumeArgs(1)[0];
+            if (arg.length !== 1) {
+                throw new ParseError(
+                    `Invalid argument number length "${arg.length}"`);
+            }
+            if (!(/^[1-9]$/.test(arg[0].text))) {
+                throw new ParseError(
+                    `Invalid argument number "${arg[0].text}"`);
+            }
+            numArgs++;
+            if (parseInt(arg[0].text) !== numArgs) {
+                throw new ParseError(
+                    `Argument number "${arg[0].text}" out of order`);
+            }
+            arg = parser.gullet.consumeArgs(1)[0];
+        }
+        if (funcName === "\\edef" || funcName === "\\xdef") {
+            arg = parser.gullet.expandTokens(arg);
+            arg.reverse(); // to fit in with stack order
+        }
+        // Final arg is the expansion of the macro
+        parser.gullet.macros.set(name, {
+            tokens: arg,
+            numArgs,
+        }, funcName === globalMap[funcName]);
+
+        return {
+            type: "internal",
+            mode: parser.mode,
+        };
+    },
+});
+
+// <simple assignment> -> <let assignment>
+// <let assignment> -> \futurelet<control sequence><token><token>
+//     | \let<control sequence><equals><one optional space><token>
+// <equals> -> <optional spaces>|<optional spaces>=
+defineFunction({
+    type: "internal",
+    names: [
+        "\\let",
+        "\\\\globallet", // can’t be entered directly
+    ],
+    props: {
+        numArgs: 0,
+        allowedInText: true,
+    },
+    handler({parser, funcName}) {
+        const name = checkControlSequence(parser.gullet.popToken());
+        parser.gullet.consumeSpaces();
+        const tok = getRHS(parser);
+        letCommand(parser, name, tok, funcName === "\\\\globallet");
+        return {
+            type: "internal",
+            mode: parser.mode,
+        };
+    },
+});
+
+// ref: https://www.tug.org/TUGboat/tb09-3/tb22bechtolsheim.pdf
+defineFunction({
+    type: "internal",
+    names: [
+        "\\futurelet",
+        "\\\\globalfuture", // can’t be entered directly
+    ],
+    props: {
+        numArgs: 0,
+        allowedInText: true,
+    },
+    handler({parser, funcName}) {
+        const name = checkControlSequence(parser.gullet.popToken());
+        const middle = parser.gullet.popToken();
+        const tok = parser.gullet.popToken();
+        letCommand(parser, name, tok, funcName === "\\\\globalfuture");
+        parser.gullet.pushToken(tok);
+        parser.gullet.pushToken(middle);
+        return {
+            type: "internal",
+            mode: parser.mode,
+        };
+    },
+});

package/src/functions/delimsizing.js

@@ -62,11 +62,12 @@ function checkDelimiter(
     const symDelim = checkSymbolNodeType(delim);
     if (symDelim && utils.contains(delimiters, symDelim.text)) {
         return symDelim;
-    } else {
+    } else if (symDelim) {
         throw new ParseError(
-            "Invalid delimiter: '" +
-            (symDelim ? symDelim.text : JSON.stringify(delim)) +
-            "' after '" + context.funcName + "'", delim);
+            `Invalid delimiter '${symDelim.text}' after '${context.funcName}'`,
+            delim);
+    } else {
+        throw new ParseError(`Invalid delimiter type '${delim.type}'`, delim);
     }
 }
 

package/src/functions/font.js

@@ -95,7 +95,7 @@ defineFunction({
 // Old font changing functions
 defineFunction({
     type: "font",
-    names: ["\\rm", "\\sf", "\\tt", "\\bf", "\\it"],
+    names: ["\\rm", "\\sf", "\\tt", "\\bf", "\\it", "\\cal"],
     props: {
         numArgs: 0,
         allowedInText: true,

package/src/functions/genfrac.js

@@ -4,7 +4,7 @@ import buildCommon from "../buildCommon";
 import delimiter from "../delimiter";
 import mathMLTree from "../mathMLTree";
 import Style from "../Style";
-import {assertNodeType, assertAtomFamily, checkNodeType} from "../parseNode";
+import {assertNodeType} from "../parseNode";
 import {assert} from "../utils";
 
 import * as html from "../buildHTML";
@@ -382,17 +382,10 @@ defineFunction({
         const denom = args[5];
 
         // Look into the parse nodes to get the desired delimiters.
-        let leftNode = checkNodeType(args[0], "atom");
-        if (leftNode) {
-            leftNode = assertAtomFamily(args[0], "open");
-        }
-        const leftDelim = leftNode ? delimFromValue(leftNode.text) : null;
-
-        let rightNode = checkNodeType(args[1], "atom");
-        if (rightNode) {
-            rightNode = assertAtomFamily(args[1], "close");
-        }
-        const rightDelim = rightNode ? delimFromValue(rightNode.text) : null;
+        const leftDelim = args[0].type === "atom" && args[0].family === "open"
+            ? delimFromValue(args[0].text) : null;
+        const rightDelim = args[1].type === "atom" && args[1].family === "close"
+            ? delimFromValue(args[1].text) : null;
 
         const barNode = assertNodeType(args[2], "size");
         let hasBarLine;
@@ -409,14 +402,14 @@ defineFunction({
 
         // Find out if we want displaystyle, textstyle, etc.
         let size = "auto";
-        let styl = checkNodeType(args[3], "ordgroup");
-        if (styl) {
+        let styl = args[3];
+        if (styl.type === "ordgroup") {
             if (styl.body.length > 0) {
                 const textOrd = assertNodeType(styl.body[0], "textord");
                 size = stylArray[Number(textOrd.text)];
             }
         } else {
-            styl = assertNodeType(args[3], "textord");
+            styl = assertNodeType(styl, "textord");
             size = stylArray[Number(styl.text)];
         }
 

package/src/functions/horizBrace.js

@@ -4,7 +4,7 @@ import buildCommon from "../buildCommon";
 import mathMLTree from "../mathMLTree";
 import stretchy from "../stretchy";
 import Style from "../Style";
-import {assertNodeType, checkNodeType} from "../parseNode";
+import {assertNodeType} from "../parseNode";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -20,15 +20,14 @@ export const htmlBuilder: HtmlBuilderSupSub<"horizBrace"> = (grp, options) => {
     // Pull out the `ParseNode<"horizBrace">` if `grp` is a "supsub" node.
     let supSubGroup;
     let group: ParseNode<"horizBrace">;
-    const supSub = checkNodeType(grp, "supsub");
-    if (supSub) {
+    if (grp.type === "supsub") {
         // Ref: LaTeX source2e: }}}}\limits}
         // i.e. LaTeX treats the brace similar to an op and passes it
         // with \limits, so we need to assign supsub style.
-        supSubGroup = supSub.sup ?
-            html.buildGroup(supSub.sup, options.havingStyle(style.sup()), options) :
-            html.buildGroup(supSub.sub, options.havingStyle(style.sub()), options);
-        group = assertNodeType(supSub.base, "horizBrace");
+        supSubGroup = grp.sup ?
+            html.buildGroup(grp.sup, options.havingStyle(style.sup()), options) :
+            html.buildGroup(grp.sub, options.havingStyle(style.sub()), options);
+        group = assertNodeType(grp.base, "horizBrace");
     } else {
         group = assertNodeType(grp, "horizBrace");
     }

package/src/functions/html.js

@@ -0,0 +1,102 @@
+// @flow
+import defineFunction, {ordargument} from "../defineFunction";
+import buildCommon from "../buildCommon";
+import {assertNodeType} from "../parseNode";
+import ParseError from "../ParseError";
+
+import * as html from "../buildHTML";
+import * as mml from "../buildMathML";
+
+defineFunction({
+    type: "html",
+    names: ["\\htmlClass", "\\htmlId", "\\htmlStyle", "\\htmlData"],
+    props: {
+        numArgs: 2,
+        argTypes: ["raw", "original"],
+        allowedInText: true,
+    },
+    handler: ({parser, funcName, token}, args) => {
+        const value = assertNodeType(args[0], "raw").string;
+        const body = args[1];
+
+        if (parser.settings.strict) {
+            parser.settings.reportNonstrict("htmlExtension",
+                "HTML extension is disabled on strict mode");
+        }
+
+        let trustContext;
+        const attributes = {};
+
+        switch (funcName) {
+            case "\\htmlClass":
+                attributes.class = value;
+                trustContext = {
+                    command: "\\htmlClass",
+                    class: value,
+                };
+                break;
+            case "\\htmlId":
+                attributes.id = value;
+                trustContext = {
+                    command: "\\htmlId",
+                    id: value,
+                };
+                break;
+            case "\\htmlStyle":
+                attributes.style = value;
+                trustContext = {
+                    command: "\\htmlStyle",
+                    style: value,
+                };
+                break;
+            case "\\htmlData": {
+                const data = value.split(",");
+                for (let i = 0; i < data.length; i++) {
+                    const keyVal = data[i].split("=");
+                    if (keyVal.length !== 2) {
+                        throw new ParseError(
+                            "Error parsing key-value for \\htmlData");
+                    }
+                    attributes["data-" + keyVal[0].trim()] = keyVal[1].trim();
+                }
+
+                trustContext = {
+                    command: "\\htmlData",
+                    attributes,
+                };
+                break;
+            }
+            default:
+                throw new Error("Unrecognized html command");
+        }
+
+        if (!parser.settings.isTrusted(trustContext)) {
+            return parser.formatUnsupportedCmd(funcName);
+        }
+        return {
+            type: "html",
+            mode: parser.mode,
+            attributes,
+            body: ordargument(body),
+        };
+    },
+    htmlBuilder: (group, options) => {
+        const elements = html.buildExpression(group.body, options, false);
+
+        const classes = ["enclosing"];
+        if (group.attributes.class) {
+            classes.push(...group.attributes.class.trim().split(/\s+/));
+        }
+
+        const span = buildCommon.makeSpan(classes, elements, options);
+        for (const attr in group.attributes) {
+            if (attr !== "class" && group.attributes.hasOwnProperty(attr)) {
+                span.setAttribute(attr, group.attributes[attr]);
+            }
+        }
+        return span;
+    },
+    mathmlBuilder: (group, options) => {
+        return mml.buildExpressionRow(group.body, options);
+    },
+});

package/src/functions/lap.js

@@ -44,19 +44,16 @@ defineFunction({
         // two items involved in the lap.
         // Next, use a strut to set the height of the HTML bounding box.
         // Otherwise, a tall argument may be misplaced.
+        // This code resolved issue #1153
         const strut = buildCommon.makeSpan(["strut"]);
         strut.style.height = (node.height + node.depth) + "em";
         strut.style.verticalAlign = -node.depth + "em";
         node.children.unshift(strut);
 
         // Next, prevent vertical misplacement when next to something tall.
-        node = buildCommon.makeVList({
-            positionType: "firstBaseline",
-            children: [{type: "elem", elem: node}],
-        }, options);
-
-        // Get the horizontal spacing correct relative to adjacent items.
-        return buildCommon.makeSpan(["mord"], [node], options);
+        // This code resolves issue #1234
+        node = buildCommon.makeSpan(["thinbox"], [node], options);
+        return buildCommon.makeSpan(["mord", "vbox"], [node], options);
     },
     mathmlBuilder: (group, options) => {
         // mathllap, mathrlap, mathclap

package/src/functions/op.js

@@ -7,7 +7,7 @@ import * as mathMLTree from "../mathMLTree";
 import utils from "../utils";
 import Style from "../Style";
 import {assembleSupSub} from "./utils/assembleSupSub";
-import {assertNodeType, checkNodeType} from "../parseNode";
+import {assertNodeType} from "../parseNode";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -28,14 +28,13 @@ export const htmlBuilder: HtmlBuilderSupSub<"op"> = (grp, options) => {
     let subGroup;
     let hasLimits = false;
     let group: ParseNode<"op">;
-    const supSub = checkNodeType(grp, "supsub");
-    if (supSub) {
+    if (grp.type === "supsub") {
         // If we have limits, supsub will pass us its group to handle. Pull
         // out the superscript and subscript and set the group to the op in
         // its base.
-        supGroup = supSub.sup;
-        subGroup = supSub.sub;
-        group = assertNodeType(supSub.base, "op");
+        supGroup = grp.sup;
+        subGroup = grp.sub;
+        group = assertNodeType(grp.base, "op");
         hasLimits = true;
     } else {
         group = assertNodeType(grp, "op");

package/src/functions/operatorname.js

@@ -4,7 +4,7 @@ import buildCommon from "../buildCommon";
 import mathMLTree from "../mathMLTree";
 import {SymbolNode} from "../domTree";
 import {assembleSupSub} from "./utils/assembleSupSub";
-import {assertNodeType, checkNodeType} from "../parseNode";
+import {assertNodeType} from "../parseNode";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -21,14 +21,13 @@ export const htmlBuilder: HtmlBuilderSupSub<"operatorname"> = (grp, options) =>
     let subGroup;
     let hasLimits = false;
     let group: ParseNode<"operatorname">;
-    const supSub = checkNodeType(grp, "supsub");
-    if (supSub) {
+    if (grp.type === "supsub") {
         // If we have limits, supsub will pass us its group to handle. Pull
         // out the superscript and subscript and set the group to the op in
         // its base.
-        supGroup = supSub.sup;
-        subGroup = supSub.sub;
-        group = assertNodeType(supSub.base, "operatorname");
+        supGroup = grp.sup;
+        subGroup = grp.sub;
+        group = assertNodeType(grp.base, "operatorname");
         hasLimits = true;
     } else {
         group = assertNodeType(grp, "operatorname");

package/src/functions/supsub.js

@@ -5,7 +5,6 @@ import {SymbolNode} from "../domTree";
 import mathMLTree from "../mathMLTree";
 import utils from "../utils";
 import Style from "../Style";
-import {checkNodeType} from "../parseNode";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -197,12 +196,11 @@ defineFunctionBuilders({
         let isOver;
         let isSup;
 
-        const horizBrace = checkNodeType(group.base, "horizBrace");
-        if (horizBrace) {
+        if (group.base && group.base.type === "horizBrace") {
             isSup = !!group.sup;
-            if (isSup === horizBrace.isOver) {
+            if (isSup === group.base.isOver) {
                 isBrace = true;
-                isOver = horizBrace.isOver;
+                isOver = group.base.isOver;
             }
         }
 

package/src/functions/utils/assembleSupSub.js

@@ -17,8 +17,6 @@ export const assembleSupSub = (
     slant: number,
     baseShift: number,
 ): DomSpan => {
-    // IE 8 clips \int if it is in a display: inline-block. We wrap it
-    // in a new span so it is an inline, and works.
     base = buildCommon.makeSpan([], [base]);
     let sub;
     let sup;