katex 0.12.0 → 0.13.3

package/src/functions/enclose.js

@@ -4,6 +4,9 @@ import buildCommon from "../buildCommon";
 import mathMLTree from "../mathMLTree";
 import utils from "../utils";
 import stretchy from "../stretchy";
+import {phasePath} from "../svgGeometry";
+import {PathNode, SvgNode} from "../domTree";
+import {calculateSize} from "../units";
 import {assertNodeType} from "../parseNode";
 
 import * as html from "../buildHTML";
@@ -11,14 +14,14 @@ import * as mml from "../buildMathML";
 
 
 const htmlBuilder = (group, options) => {
-    // \cancel, \bcancel, \xcancel, \sout, \fbox, \colorbox, \fcolorbox
+    // \cancel, \bcancel, \xcancel, \sout, \fbox, \colorbox, \fcolorbox, \phase
     // Some groups can return document fragments.  Handle those by wrapping
     // them in a span.
     const inner = buildCommon.wrapFragment(
         html.buildGroup(group.body, options), options);
 
     const label = group.label.substr(1);
-    const scale = options.sizeMultiplier;
+    let scale = options.sizeMultiplier;
     let img;
     let imgShift = 0;
 
@@ -34,18 +37,48 @@ const htmlBuilder = (group, options) => {
         img.height = options.fontMetrics().defaultRuleThickness / scale;
         imgShift = -0.5 * options.fontMetrics().xHeight;
 
+    } else if (label === "phase") {
+        // Set a couple of dimensions from the steinmetz package.
+        const lineWeight = calculateSize({number: 0.6, unit: "pt"}, options);
+        const clearance = calculateSize({number: 0.35, unit: "ex"}, options);
+
+        // Prevent size changes like \Huge from affecting line thickness
+        const newOptions = options.havingBaseSizing();
+        scale = scale / newOptions.sizeMultiplier;
+
+        const angleHeight = inner.height + inner.depth + lineWeight + clearance;
+        // Reserve a left pad for the angle.
+        inner.style.paddingLeft = (angleHeight / 2 + lineWeight) + "em";
+
+        // Create an SVG
+        const viewBoxHeight = Math.floor(1000 * angleHeight * scale);
+        const path = phasePath(viewBoxHeight);
+        const svgNode = new SvgNode([new PathNode("phase", path)], {
+            "width": "400em",
+            "height": `${viewBoxHeight / 1000}em`,
+            "viewBox": `0 0 400000 ${viewBoxHeight}`,
+            "preserveAspectRatio": "xMinYMin slice",
+        });
+        // Wrap it in a span with overflow: hidden.
+        img = buildCommon.makeSvgSpan(["hide-tail"], [svgNode], options);
+        img.style.height = angleHeight + "em";
+        imgShift = inner.depth + lineWeight + clearance;
+
     } else {
         // Add horizontal padding
         if (/cancel/.test(label)) {
             if (!isSingleChar) {
                 inner.classes.push("cancel-pad");
             }
+        } else if (label === "angl") {
+            inner.classes.push("anglpad");
         } else {
             inner.classes.push("boxpad");
         }
 
         // Add vertical padding
-        let vertPad = 0;
+        let topPad = 0;
+        let bottomPad = 0;
         let ruleThickness = 0;
         // ref: cancel package: \advance\totalheight2\p@ % "+2"
         if (/box/.test(label)) {
@@ -53,18 +86,30 @@ const htmlBuilder = (group, options) => {
                 options.fontMetrics().fboxrule, // default
                 options.minRuleThickness, // User override.
             );
-            vertPad = options.fontMetrics().fboxsep +
+            topPad = options.fontMetrics().fboxsep +
                 (label === "colorbox" ? 0 : ruleThickness);
+            bottomPad =  topPad;
+        } else if (label === "angl") {
+            ruleThickness = Math.max(
+                options.fontMetrics().defaultRuleThickness,
+                options.minRuleThickness
+            );
+            topPad = 4 * ruleThickness; // gap = 3 × line, plus the line itself.
+            bottomPad = Math.max(0, 0.25 - inner.depth);
         } else {
-            vertPad = isSingleChar ? 0.2 : 0;
+            topPad = isSingleChar ? 0.2 : 0;
+            bottomPad =  topPad;
         }
 
-        img = stretchy.encloseSpan(inner, label, vertPad, options);
+        img = stretchy.encloseSpan(inner, label, topPad, bottomPad, options);
         if (/fbox|boxed|fcolorbox/.test(label)) {
             img.style.borderStyle = "solid";
             img.style.borderWidth = `${ruleThickness}em`;
+        } else if (label === "angl" && ruleThickness !== 0.049) {
+            img.style.borderTopWidth = `${ruleThickness}em`;
+            img.style.borderRightWidth = `${ruleThickness}em`;
         }
-        imgShift = inner.depth + vertPad;
+        imgShift = inner.depth + bottomPad;
 
         if (group.backgroundColor) {
             img.style.backgroundColor = group.backgroundColor;
@@ -85,6 +130,7 @@ const htmlBuilder = (group, options) => {
             ],
         }, options);
     } else {
+        const classes = /cancel|phase/.test(label) ? ["svg-align"] : [];
         vlist = buildCommon.makeVList({
             positionType: "individualShift",
             children: [
@@ -98,7 +144,7 @@ const htmlBuilder = (group, options) => {
                     type: "elem",
                     elem: img,
                     shift: imgShift,
-                    wrapperClasses: /cancel/.test(label) ? ["svg-align"] : [],
+                    wrapperClasses: classes,
                 },
             ],
         }, options);
@@ -132,12 +178,18 @@ const mathmlBuilder = (group, options) => {
         case "\\bcancel":
             node.setAttribute("notation", "downdiagonalstrike");
             break;
+        case "\\phase":
+            node.setAttribute("notation", "phasorangle");
+            break;
         case "\\sout":
             node.setAttribute("notation", "horizontalstrike");
             break;
         case "\\fbox":
             node.setAttribute("notation", "box");
             break;
+        case "\\angl":
+            node.setAttribute("notation", "actuarial");
+            break;
         case "\\fcolorbox":
         case "\\colorbox":
             // <menclose> doesn't have a good notation option. So use <mpadded>
@@ -173,7 +225,6 @@ defineFunction({
     props: {
         numArgs: 2,
         allowedInText: true,
-        greediness: 3,
         argTypes: ["color", "text"],
     },
     handler({parser, funcName}, args, optArgs) {
@@ -197,7 +248,6 @@ defineFunction({
     props: {
         numArgs: 3,
         allowedInText: true,
-        greediness: 3,
         argTypes: ["color", "color", "text"],
     },
     handler({parser, funcName}, args, optArgs) {
@@ -237,11 +287,11 @@ defineFunction({
 
 defineFunction({
     type: "enclose",
-    names: ["\\cancel", "\\bcancel", "\\xcancel", "\\sout"],
+    names: ["\\cancel", "\\bcancel", "\\xcancel", "\\sout", "\\phase"],
     props: {
         numArgs: 1,
     },
-    handler({parser, funcName}, args, optArgs) {
+    handler({parser, funcName}, args) {
         const body = args[0];
         return {
             type: "enclose",
@@ -253,3 +303,21 @@ defineFunction({
     htmlBuilder,
     mathmlBuilder,
 });
+
+defineFunction({
+    type: "enclose",
+    names: ["\\angl"],
+    props: {
+        numArgs: 1,
+        argTypes: ["hbox"],
+        allowedInText: false,
+    },
+    handler({parser}, args) {
+        return {
+            type: "enclose",
+            mode: parser.mode,
+            label: "\\angl",
+            body: args[0],
+        };
+    },
+});

package/src/functions/environment.js

@@ -6,7 +6,6 @@ import environments from "../environments";
 
 // Environment delimiters. HTML/MathML rendering is defined in the corresponding
 // defineEnvironment definitions.
-// $FlowFixMe, "environment" handler returns an environment ParseNode
 defineFunction({
     type: "environment",
     names: ["\\begin", "\\end"],
@@ -49,6 +48,7 @@ defineFunction({
                     `Mismatch: \\begin{${envName}} matched by \\end{${end.name}}`,
                     endNameToken);
             }
+            // $FlowFixMe, "environment" handler returns an environment ParseNode
             return result;
         }
 

package/src/functions/font.js

@@ -2,7 +2,7 @@
 // TODO(kevinb): implement \\sl and \\sc
 
 import {binrelClass} from "./mclass";
-import defineFunction from "../defineFunction";
+import defineFunction, {normalizeArgument} from "../defineFunction";
 import utils from "../utils";
 
 import * as html from "../buildHTML";
@@ -44,10 +44,10 @@ defineFunction({
     ],
     props: {
         numArgs: 1,
-        greediness: 2,
+        allowedInArgument: true,
     },
     handler: ({parser, funcName}, args) => {
-        const body = args[0];
+        const body = normalizeArgument(args[0]);
         let func = funcName;
         if (func in fontAliases) {
             func = fontAliases[func];
@@ -68,7 +68,6 @@ defineFunction({
     names: ["\\boldsymbol", "\\bm"],
     props: {
         numArgs: 1,
-        greediness: 2,
     },
     handler: ({parser}, args) => {
         const body = args[0];

package/src/functions/genfrac.js

@@ -1,5 +1,5 @@
 // @flow
-import defineFunction from "../defineFunction";
+import defineFunction, {normalizeArgument} from "../defineFunction";
 import buildCommon from "../buildCommon";
 import delimiter from "../delimiter";
 import mathMLTree from "../mathMLTree";
@@ -241,14 +241,14 @@ const mathmlBuilder = (group, options) => {
 defineFunction({
     type: "genfrac",
     names: [
-        "\\cfrac", "\\dfrac", "\\frac", "\\tfrac",
+        "\\dfrac", "\\frac", "\\tfrac",
         "\\dbinom", "\\binom", "\\tbinom",
         "\\\\atopfrac", // can’t be entered directly
         "\\\\bracefrac", "\\\\brackfrac",   // ditto
     ],
     props: {
         numArgs: 2,
-        greediness: 2,
+        allowedInArgument: true,
     },
     handler: ({parser, funcName}, args) => {
         const numer = args[0];
@@ -259,7 +259,6 @@ defineFunction({
         let size = "auto";
 
         switch (funcName) {
-            case "\\cfrac":
             case "\\dfrac":
             case "\\frac":
             case "\\tfrac":
@@ -290,7 +289,6 @@ defineFunction({
         }
 
         switch (funcName) {
-            case "\\cfrac":
             case "\\dfrac":
             case "\\dbinom":
                 size = "display";
@@ -304,7 +302,7 @@ defineFunction({
         return {
             type: "genfrac",
             mode: parser.mode,
-            continued: funcName === "\\cfrac",
+            continued: false,
             numer,
             denom,
             hasBarLine,
@@ -319,6 +317,31 @@ defineFunction({
     mathmlBuilder,
 });
 
+defineFunction({
+    type: "genfrac",
+    names: ["\\cfrac"],
+    props: {
+        numArgs: 2,
+    },
+    handler: ({parser, funcName}, args) => {
+        const numer = args[0];
+        const denom = args[1];
+
+        return {
+            type: "genfrac",
+            mode: parser.mode,
+            continued: true,
+            numer,
+            denom,
+            hasBarLine: true,
+            leftDelim: null,
+            rightDelim: null,
+            size: "display",
+            barSize: null,
+        };
+    },
+});
+
 // Infix generalized fractions -- these are not rendered directly, but replaced
 // immediately by one of the variants above.
 defineFunction({
@@ -374,7 +397,7 @@ defineFunction({
     names: ["\\genfrac"],
     props: {
         numArgs: 6,
-        greediness: 6,
+        allowedInArgument: true,
         argTypes: ["math", "math", "size", "text", "math", "math"],
     },
     handler({parser}, args) {
@@ -382,10 +405,12 @@ defineFunction({
         const denom = args[5];
 
         // Look into the parse nodes to get the desired delimiters.
-        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 leftNode = normalizeArgument(args[0]);
+        const leftDelim = leftNode.type === "atom" && leftNode.family === "open"
+            ? delimFromValue(leftNode.text) : null;
+        const rightNode = normalizeArgument(args[1]);
+        const rightDelim = rightNode.type === "atom" && rightNode.family === "close"
+            ? delimFromValue(rightNode.text) : null;
 
         const barNode = assertNodeType(args[2], "size");
         let hasBarLine;

package/src/functions/hbox.js

@@ -0,0 +1,39 @@
+// @flow
+import defineFunction, {ordargument} from "../defineFunction";
+import buildCommon from "../buildCommon";
+import mathMLTree from "../mathMLTree";
+
+import * as html from "../buildHTML";
+import * as mml from "../buildMathML";
+
+// \hbox is provided for compatibility with LaTeX \vcenter.
+// In LaTeX, \vcenter can act only on a box, as in
+// \vcenter{\hbox{$\frac{a+b}{\dfrac{c}{d}}$}}
+// This function by itself doesn't do anything but prevent a soft line break.
+
+defineFunction({
+    type: "hbox",
+    names: ["\\hbox"],
+    props: {
+        numArgs: 1,
+        argTypes: ["text"],
+        allowedInText: true,
+        primitive: true,
+    },
+    handler({parser}, args) {
+        return {
+            type: "hbox",
+            mode: parser.mode,
+            body: ordargument(args[0]),
+        };
+    },
+    htmlBuilder(group, options) {
+        const elements = html.buildExpression(group.body, options, false);
+        return buildCommon.makeFragment(elements);
+    },
+    mathmlBuilder(group, options) {
+        return new mathMLTree.MathNode(
+          "mrow", mml.buildExpression(group.body, options)
+        );
+    },
+});

package/src/functions/kern.js

@@ -15,6 +15,7 @@ defineFunction({
     props: {
         numArgs: 1,
         argTypes: ["size"],
+        primitive: true,
         allowedInText: true,
     },
     handler({parser, funcName}, args) {

package/src/functions/mathchoice.js

@@ -23,6 +23,7 @@ defineFunction({
     names: ["\\mathchoice"],
     props: {
         numArgs: 4,
+        primitive: true,
     },
     handler: ({parser}, args) => {
         return {

package/src/functions/mclass.js

@@ -65,6 +65,7 @@ defineFunction({
     ],
     props: {
         numArgs: 1,
+        primitive: true,
     },
     handler({parser, funcName}, args) {
         const body = args[0];
@@ -106,7 +107,7 @@ defineFunction({
             type: "mclass",
             mode: parser.mode,
             mclass: binrelClass(args[0]),
-            body: [args[1]],
+            body: ordargument(args[1]),
             isCharacterBox: utils.isCharacterBox(args[1]),
         };
     },

package/src/functions/op.js

@@ -61,7 +61,6 @@ export const htmlBuilder: HtmlBuilderSupSub<"op"> = (grp, options) => {
             // No font glyphs yet, so use a glyph w/o the oval.
             // TODO: When font glyphs are available, delete this code.
             stash = group.name.substr(1);
-            // $FlowFixMe
             group.name = stash === "oiint" ? "\\iint" : "\\iiint";
         }
 
@@ -82,7 +81,6 @@ export const htmlBuilder: HtmlBuilderSupSub<"op"> = (grp, options) => {
                     {type: "elem", elem: oval, shift: large ? 0.08 : 0},
                 ],
             }, options);
-            // $FlowFixMe
             group.name = "\\" + stash;
             base.classes.unshift("mop");
             // $FlowFixMe
@@ -95,14 +93,11 @@ export const htmlBuilder: HtmlBuilderSupSub<"op"> = (grp, options) => {
             base = inner[0];
             base.classes[0] = "mop"; // replace old mclass
         } else {
-            base = buildCommon.makeSpan(
-                ["mop"], buildCommon.tryCombineChars(inner), options);
+            base = buildCommon.makeSpan(["mop"], inner, options);
         }
     } else {
         // Otherwise, this is a text operator. Build the text from the
         // operator's name.
-        // TODO(emily): Add a space in the middle of some of these
-        // operators, like \limsup
         const output = [];
         for (let i = 1; i < group.name.length; i++) {
             output.push(buildCommon.mathsym(group.name[i], group.mode, options));
@@ -168,7 +163,7 @@ const mathmlBuilder: MathMLBuilder<"op"> = (group, options) => {
         const operator = new mathMLTree.MathNode("mo",
             [mml.makeText("\u2061", "text")]);
         if (group.parentIsSupSub) {
-            node = new mathMLTree.MathNode("mo", [node, operator]);
+            node = new mathMLTree.MathNode("mrow", [node, operator]);
         } else {
             node = mathMLTree.newDocumentFragment([node, operator]);
         }
@@ -229,6 +224,7 @@ defineFunction({
     names: ["\\mathop"],
     props: {
         numArgs: 1,
+        primitive: true,
     },
     handler: ({parser}, args) => {
         const body = args[0];

package/src/functions/operatorname.js

@@ -130,7 +130,7 @@ const mathmlBuilder: MathMLBuilder<"operatorname"> = (group, options) => {
         [mml.makeText("\u2061", "text")]);
 
     if (group.parentIsSupSub) {
-        return new mathMLTree.MathNode("mo", [identifier, operator]);
+        return new mathMLTree.MathNode("mrow", [identifier, operator]);
     } else {
         return mathMLTree.newDocumentFragment([identifier, operator]);
     }

package/src/functions/raisebox.js

@@ -44,4 +44,3 @@ defineFunction({
         return node;
     },
 });
-

package/src/functions/styling.js

@@ -22,6 +22,7 @@ defineFunction({
     props: {
         numArgs: 0,
         allowedInText: true,
+        primitive: true,
     },
     handler({breakOnTokenText, funcName, parser}, args) {
         // parse out the implicit body

package/src/functions/supsub.js

@@ -260,9 +260,7 @@ defineFunctionBuilders({
             }
         }
 
-        const node = new mathMLTree.MathNode(nodeType, children);
-
-        return node;
+        return new mathMLTree.MathNode(nodeType, children);
     },
 });
 

package/src/functions/symbolsOrd.js

@@ -47,8 +47,6 @@ defineFunctionBuilders({
         if (group.mode === 'text') {
             node = new mathMLTree.MathNode("mtext", [text]);
         } else if (/[0-9]/.test(group.text)) {
-            // TODO(kevinb) merge adjacent <mn> nodes
-            // do it as a post processing step
             node = new mathMLTree.MathNode("mn", [text]);
         } else if (group.text === "\\prime") {
             node = new mathMLTree.MathNode("mo", [text]);

package/src/functions/text.js

@@ -48,7 +48,7 @@ defineFunction({
     props: {
         numArgs: 1,
         argTypes: ["text"],
-        greediness: 2,
+        allowedInArgument: true,
         allowedInText: true,
     },
     handler({parser, funcName}, args) {
@@ -63,8 +63,7 @@ defineFunction({
     htmlBuilder(group, options) {
         const newOptions = optionsWithFont(group, options);
         const inner = html.buildExpression(group.body, newOptions, true);
-        return buildCommon.makeSpan(
-            ["mord", "text"], buildCommon.tryCombineChars(inner), newOptions);
+        return buildCommon.makeSpan(["mord", "text"], inner, newOptions);
     },
     mathmlBuilder(group, options) {
         const newOptions = optionsWithFont(group, options);

package/src/functions/vcenter.js

@@ -0,0 +1,44 @@
+// @flow
+import defineFunction from "../defineFunction";
+import buildCommon from "../buildCommon";
+import mathMLTree from "../mathMLTree";
+
+import * as html from "../buildHTML";
+import * as mml from "../buildMathML";
+
+// \vcenter:  Vertically center the argument group on the math axis.
+
+defineFunction({
+    type: "vcenter",
+    names: ["\\vcenter"],
+    props: {
+        numArgs: 1,
+        argTypes: ["original"], // In LaTeX, \vcenter can act only on a box.
+        allowedInText: false,
+    },
+    handler({parser}, args) {
+        return {
+            type: "vcenter",
+            mode: parser.mode,
+            body: args[0],
+        };
+    },
+    htmlBuilder(group, options) {
+        const body = html.buildGroup(group.body, options);
+        const axisHeight = options.fontMetrics().axisHeight;
+        const dy = 0.5 * ((body.height - axisHeight) - (body.depth + axisHeight));
+        return buildCommon.makeVList({
+            positionType: "shift",
+            positionData: dy,
+            children: [{type: "elem", elem: body}],
+        }, options);
+    },
+    mathmlBuilder(group, options) {
+        // There is no way to do this in MathML.
+        // Write a class as a breadcrumb in case some post-processor wants
+        // to perform a vcenter adjustment.
+        return new mathMLTree.MathNode(
+            "mpadded", [mml.buildGroup(group.body, options)], ["vcenter"]);
+    },
+});
+

package/src/functions.js

@@ -10,6 +10,7 @@ export default functions;
 import "./functions/accent";
 import "./functions/accentunder";
 import "./functions/arrow";
+import "./environments/cd";
 import "./functions/char";
 import "./functions/color";
 import "./functions/cr";
@@ -21,6 +22,7 @@ import "./functions/font";
 import "./functions/genfrac";
 import "./functions/horizBrace";
 import "./functions/href";
+import "./functions/hbox";
 import "./functions/html";
 import "./functions/htmlmathml";
 import "./functions/includegraphics";
@@ -47,4 +49,5 @@ import "./functions/symbolsSpacing";
 import "./functions/tag";
 import "./functions/text";
 import "./functions/underline";
+import "./functions/vcenter";
 import "./functions/verb";