katex 0.16.28 → 0.16.30

package/src/functions/accent.js

@@ -1,9 +1,9 @@
 // @flow
 import defineFunction, {normalizeArgument} from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
-import utils from "../utils";
-import stretchy from "../stretchy";
+import {makeOrd, makeSpan, makeVList, staticSvg, svgData} from "../buildCommon";
+import {getBaseElem, isCharacterBox} from "../utils";
+import {MathNode} from "../mathMLTree";
+import {stretchyMathML, stretchySvg} from "../stretchy";
 import {assertNodeType} from "../parseNode";
 import {assertSpan, assertSymbolDomNode} from "../domTree";
 import {makeEm} from "../units";
@@ -53,7 +53,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
     const body = html.buildGroup(base, options.havingCrampedStyle());
 
     // Does the accent need to shift for the skew of a character?
-    const mustShift = group.isShifty && utils.isCharacterBox(base);
+    const mustShift = group.isShifty && isCharacterBox(base);
 
     // Calculate the skew of the accent. This is based on the line "If the
     // nucleus is not a single character, let s = 0; otherwise set s to the
@@ -64,7 +64,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
     if (mustShift) {
         // If the base is a character box, then we want the skew of the
         // innermost character. To do that, we find the innermost character:
-        const baseChar = utils.getBaseElem(base);
+        const baseChar = getBaseElem(base);
         // Then, we render its group to get the symbol inside it
         const baseGroup = html.buildGroup(baseChar, options.havingCrampedStyle());
         // Finally, we pull the skew off of the symbol.
@@ -95,10 +95,10 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
             // render combining characters when not preceded by a character.
             // So now we use an SVG.
             // If Safari reforms, we should consider reverting to the glyph.
-            accent = buildCommon.staticSvg("vec", options);
-            width = buildCommon.svgData.vec[1];
+            accent = staticSvg("vec", options);
+            width = svgData.vec[1];
         } else {
-            accent = buildCommon.makeOrd({mode: group.mode, text: group.label},
+            accent = makeOrd({mode: group.mode, text: group.label},
                 options, "textord");
             accent = assertSymbolDomNode(accent);
             // Remove the italic correction of the accent, because it only serves to
@@ -110,7 +110,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
             }
         }
 
-        accentBody = buildCommon.makeSpan(["accent-body"], [accent]);
+        accentBody = makeSpan(["accent-body"], [accent]);
 
         // "Full" accents expand the width of the resulting symbol to be
         // at least the width of the accent, and overlap directly onto the
@@ -140,7 +140,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
             accentBody.style.top = ".2em";
         }
 
-        accentBody = buildCommon.makeVList({
+        accentBody = makeVList({
             positionType: "firstBaseline",
             children: [
                 {type: "elem", elem: body},
@@ -150,9 +150,9 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
         }, options);
 
     } else {
-        accentBody = stretchy.svgSpan(group, options);
+        accentBody = stretchySvg(group, options);
 
-        accentBody = buildCommon.makeVList({
+        accentBody = makeVList({
             positionType: "firstBaseline",
             children: [
                 {type: "elem", elem: body},
@@ -172,7 +172,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
     }
 
     const accentWrap =
-        buildCommon.makeSpan(["mord", "accent"], [accentBody], options);
+        makeSpan(["mord", "accent"], [accentBody], options);
 
     if (supSubGroup) {
         // Here, we replace the "base" child of the supsub with our newly
@@ -195,10 +195,10 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
 const mathmlBuilder: MathMLBuilder<"accent"> = (group, options) => {
     const accentNode =
         group.isStretchy ?
-            stretchy.mathMLnode(group.label) :
-            new mathMLTree.MathNode("mo", [mml.makeText(group.label, group.mode)]);
+            stretchyMathML(group.label) :
+            new MathNode("mo", [mml.makeText(group.label, group.mode)]);
 
-    const node = new mathMLTree.MathNode(
+    const node = new MathNode(
         "mover",
         [mml.buildGroup(group.base, options), accentNode]);
 

package/src/functions/accentunder.js

@@ -1,9 +1,9 @@
 // @flow
 // Horizontal overlap functions
 import defineFunction from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
-import stretchy from "../stretchy";
+import {makeSpan, makeVList} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
+import {stretchyMathML, stretchySvg} from "../stretchy";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -32,11 +32,11 @@ defineFunction({
         // Treat under accents much like underlines.
         const innerGroup = html.buildGroup(group.base, options);
 
-        const accentBody = stretchy.svgSpan(group, options);
+        const accentBody = stretchySvg(group, options);
         const kern = group.label === "\\utilde" ? 0.12 : 0;
 
         // Generate the vlist, with the appropriate kerns
-        const vlist = buildCommon.makeVList({
+        const vlist = makeVList({
             positionType: "top",
             positionData: innerGroup.height,
             children: [
@@ -46,11 +46,11 @@ defineFunction({
             ],
         }, options);
 
-        return buildCommon.makeSpan(["mord", "accentunder"], [vlist], options);
+        return makeSpan(["mord", "accentunder"], [vlist], options);
     },
     mathmlBuilder: (group, options) => {
-        const accentNode = stretchy.mathMLnode(group.label);
-        const node = new mathMLTree.MathNode(
+        const accentNode = stretchyMathML(group.label);
+        const node = new MathNode(
             "munder",
             [mml.buildGroup(group.base, options), accentNode]
         );

package/src/functions/arrow.js

@@ -1,8 +1,8 @@
 // @flow
 import defineFunction from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
-import stretchy from "../stretchy";
+import {makeSpan, makeVList, wrapFragment} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
+import {stretchyMathML, stretchySvg} from "../stretchy";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -11,7 +11,7 @@ import type {ParseNode} from "../parseNode";
 
 // Helper function
 const paddedNode = group => {
-    const node = new mathMLTree.MathNode("mpadded", group ? [group] : []);
+    const node = new MathNode("mpadded", group ? [group] : []);
     node.setAttribute("width", "+0.6em");
     node.setAttribute("lspace", "0.3em");
     return node;
@@ -57,7 +57,7 @@ defineFunction({
         // Some groups can return document fragments.  Handle those by wrapping
         // them in a span.
         let newOptions = options.havingStyle(style.sup());
-        const upperGroup = buildCommon.wrapFragment(
+        const upperGroup = wrapFragment(
             html.buildGroup(group.body, newOptions, options), options);
         const arrowPrefix = group.label.slice(0, 2) === "\\x" ? "x" : "cd";
         upperGroup.classes.push(arrowPrefix + "-arrow-pad");
@@ -66,14 +66,14 @@ defineFunction({
         if (group.below) {
             // Build the lower group
             newOptions = options.havingStyle(style.sub());
-            lowerGroup = buildCommon.wrapFragment(
+            lowerGroup = wrapFragment(
                 html.buildGroup(group.below, newOptions, options), options);
             lowerGroup.classes.push(arrowPrefix + "-arrow-pad");
         }
 
-        const arrowBody = stretchy.svgSpan(group, options);
+        const arrowBody = stretchySvg(group, options);
 
-        // Re shift: Note that stretchy.svgSpan returned arrowBody.depth = 0.
+        // Re shift: Note that stretchySvg returned arrowBody.depth = 0.
         // The point we want on the math axis is at 0.5 * arrowBody.height.
         const arrowShift = -options.fontMetrics().axisHeight +
             0.5 * arrowBody.height;
@@ -90,7 +90,7 @@ defineFunction({
             const lowerShift = -options.fontMetrics().axisHeight
                 + lowerGroup.height + 0.5 * arrowBody.height
                 + 0.111;
-            vlist = buildCommon.makeVList({
+            vlist = makeVList({
                 positionType: "individualShift",
                 children: [
                     {type: "elem", elem: upperGroup, shift: upperShift},
@@ -99,7 +99,7 @@ defineFunction({
                 ],
             }, options);
         } else {
-            vlist = buildCommon.makeVList({
+            vlist = makeVList({
                 positionType: "individualShift",
                 children: [
                     {type: "elem", elem: upperGroup, shift: upperShift},
@@ -111,10 +111,10 @@ defineFunction({
         // $FlowFixMe: Replace this with passing "svg-align" into makeVList.
         vlist.children[0].children[0].children[1].classes.push("svg-align");
 
-        return buildCommon.makeSpan(["mrel", "x-arrow"], [vlist], options);
+        return makeSpan(["mrel", "x-arrow"], [vlist], options);
     },
     mathmlBuilder(group, options) {
-        const arrowNode = stretchy.mathMLnode(group.label);
+        const arrowNode = stretchyMathML(group.label);
         arrowNode.setAttribute(
             "minsize", group.label.charAt(0) === "x" ? "1.75em" : "3.0em"
         );
@@ -124,20 +124,20 @@ defineFunction({
             const upperNode = paddedNode(mml.buildGroup(group.body, options));
             if (group.below) {
                 const lowerNode = paddedNode(mml.buildGroup(group.below, options));
-                node = new mathMLTree.MathNode(
+                node = new MathNode(
                     "munderover", [arrowNode, lowerNode, upperNode]
                 );
             } else {
-                node = new mathMLTree.MathNode("mover", [arrowNode, upperNode]);
+                node = new MathNode("mover", [arrowNode, upperNode]);
             }
         } else if (group.below) {
             const lowerNode = paddedNode(mml.buildGroup(group.below, options));
-            node = new mathMLTree.MathNode("munder", [arrowNode, lowerNode]);
+            node = new MathNode("munder", [arrowNode, lowerNode]);
         } else {
             // This should never happen.
             // Parser.js throws an error if there is no argument.
             node = paddedNode();
-            node = new mathMLTree.MathNode("mover", [arrowNode, node]);
+            node = new MathNode("mover", [arrowNode, node]);
         }
         return node;
     },

package/src/functions/color.js

@@ -1,7 +1,7 @@
 // @flow
 import defineFunction, {ordargument} from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {makeFragment} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
 import {assertNodeType} from "../parseNode";
 
 import type {AnyParseNode} from '../parseNode';
@@ -20,14 +20,14 @@ const htmlBuilder = (group, options) => {
     // To accomplish this, we wrap the results in a fragment, so the inner
     // elements will be able to directly interact with their neighbors. For
     // example, `\color{red}{2 +} 3` has the same spacing as `2 + 3`
-    return buildCommon.makeFragment(elements);
+    return makeFragment(elements);
 };
 
 const mathmlBuilder = (group, options) => {
     const inner = mml.buildExpression(group.body,
         options.withColor(group.color));
 
-    const node = new mathMLTree.MathNode("mstyle", inner);
+    const node = new MathNode("mstyle", inner);
 
     node.setAttribute("mathcolor", group.color);
 

package/src/functions/cr.js

@@ -2,8 +2,8 @@
 // Row breaks within tabular environments, and line breaks at top level
 
 import defineFunction from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {makeSpan} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
 import {calculateSize, makeEm} from "../units";
 import {assertNodeType} from "../parseNode";
 
@@ -36,7 +36,7 @@ defineFunction({
     // not within tabular/array environments.
 
     htmlBuilder(group, options) {
-        const span = buildCommon.makeSpan(["mspace"], [], options);
+        const span = makeSpan(["mspace"], [], options);
         if (group.newLine) {
             span.classes.push("newline");
             if (group.size) {
@@ -48,7 +48,7 @@ defineFunction({
     },
 
     mathmlBuilder(group, options) {
-        const node = new mathMLTree.MathNode("mspace");
+        const node = new MathNode("mspace");
         if (group.newLine) {
             node.setAttribute("linebreak", "newline");
             if (group.size) {

package/src/functions/delimsizing.js

@@ -1,8 +1,8 @@
 // @flow
-import buildCommon from "../buildCommon";
+import {makeSpan} from "../buildCommon";
 import defineFunction from "../defineFunction";
-import delimiter from "../delimiter";
-import mathMLTree from "../mathMLTree";
+import {makeLeftRightDelim, makeSizedDelim, sizeToMaxHeight} from "../delimiter";
+import {MathNode} from "../mathMLTree";
 import ParseError from "../ParseError";
 import {assertNodeType, checkSymbolNodeType} from "../parseNode";
 import {makeEm} from "../units";
@@ -34,7 +34,7 @@ const delimiterSizes = {
     "\\Bigg" : {mclass: "mord",     size: 4},
 };
 
-const delimiters = [
+const delimiters = new Set([
     "(", "\\lparen", ")", "\\rparen",
     "[", "\\lbrack", "]", "\\rbrack",
     "\\{", "\\lbrace", "\\}", "\\rbrace",
@@ -50,7 +50,7 @@ const delimiters = [
     "\\downarrow", "\\Downarrow",
     "\\updownarrow", "\\Updownarrow",
     ".",
-];
+]);
 
 type IsMiddle = {delim: string, options: Options};
 
@@ -60,7 +60,7 @@ function checkDelimiter(
     context: FunctionContext,
 ): SymbolParseNode {
     const symDelim = checkSymbolNodeType(delim);
-    if (symDelim && delimiters.includes(symDelim.text)) {
+    if (symDelim && delimiters.has(symDelim.text)) {
         return symDelim;
     } else if (symDelim) {
         throw new ParseError(
@@ -98,11 +98,10 @@ defineFunction({
         if (group.delim === ".") {
             // Empty delimiters still count as elements, even though they don't
             // show anything.
-            return buildCommon.makeSpan([group.mclass]);
+            return makeSpan([group.mclass]);
         }
 
-        // Use delimiter.sizedDelim to generate the delimiter.
-        return delimiter.sizedDelim(
+        return makeSizedDelim(
                 group.delim, group.size, options, group.mode, [group.mclass]);
     },
     mathmlBuilder: (group) => {
@@ -112,7 +111,7 @@ defineFunction({
             children.push(mml.makeText(group.delim, group.mode));
         }
 
-        const node = new mathMLTree.MathNode("mo", children);
+        const node = new MathNode("mo", children);
 
         if (group.mclass === "mopen" ||
             group.mclass === "mclose") {
@@ -126,7 +125,7 @@ defineFunction({
         }
 
         node.setAttribute("stretchy", "true");
-        const size = makeEm(delimiter.sizeToMaxHeight[group.size]);
+        const size = makeEm(sizeToMaxHeight[group.size]);
         node.setAttribute("minsize", size);
         node.setAttribute("maxsize", size);
 
@@ -232,7 +231,7 @@ defineFunction({
         } else {
             // Otherwise, use leftRightDelim to generate the correct sized
             // delimiter.
-            leftDelim = delimiter.leftRightDelim(
+            leftDelim = makeLeftRightDelim(
                 group.left, innerHeight, innerDepth, options,
                 group.mode, ["mopen"]);
         }
@@ -249,7 +248,7 @@ defineFunction({
                 const isMiddle: IsMiddle = middleDelim.isMiddle;
                 if (isMiddle) {
                     // Apply the options that were active when \middle was called
-                    inner[i] = delimiter.leftRightDelim(
+                    inner[i] = makeLeftRightDelim(
                         isMiddle.delim, innerHeight, innerDepth,
                         isMiddle.options, group.mode, []);
                 }
@@ -263,21 +262,21 @@ defineFunction({
         } else {
             const colorOptions = group.rightColor ?
                 options.withColor(group.rightColor) : options;
-            rightDelim = delimiter.leftRightDelim(
+            rightDelim = makeLeftRightDelim(
                 group.right, innerHeight, innerDepth, colorOptions,
                 group.mode, ["mclose"]);
         }
         // Add it to the end of the expression.
         inner.push(rightDelim);
 
-        return buildCommon.makeSpan(["minner"], inner, options);
+        return makeSpan(["minner"], inner, options);
     },
     mathmlBuilder: (group, options) => {
         assertParsed(group);
         const inner = mml.buildExpression(group.body, options);
 
         if (group.left !== ".") {
-            const leftNode = new mathMLTree.MathNode(
+            const leftNode = new MathNode(
                 "mo", [mml.makeText(group.left, group.mode)]);
 
             leftNode.setAttribute("fence", "true");
@@ -286,7 +285,7 @@ defineFunction({
         }
 
         if (group.right !== ".") {
-            const rightNode = new mathMLTree.MathNode(
+            const rightNode = new MathNode(
                 "mo", [mml.makeText(group.right, group.mode)]);
 
             rightNode.setAttribute("fence", "true");
@@ -326,7 +325,7 @@ defineFunction({
         if (group.delim === ".") {
             middleDelim = html.makeNullDelimiter(options, []);
         } else {
-            middleDelim = delimiter.sizedDelim(
+            middleDelim = makeSizedDelim(
                 group.delim, 1, options,
                 group.mode, []);
 
@@ -348,7 +347,7 @@ defineFunction({
         const textNode = (group.delim === "\\vert" || group.delim === "|")
             ? mml.makeText("|", "text")
             : mml.makeText(group.delim, group.mode);
-        const middleNode = new mathMLTree.MathNode("mo", [textNode]);
+        const middleNode = new MathNode("mo", [textNode]);
         middleNode.setAttribute("fence", "true");
         // MathML gives 5/18em spacing to each <mo> element.
         // \middle should get delimiter spacing instead.

package/src/functions/enclose.js

@@ -1,9 +1,9 @@
 // @flow
 import defineFunction from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
-import utils from "../utils";
-import stretchy from "../stretchy";
+import {makeSpan, makeSvgSpan, makeVList, wrapFragment} from "../buildCommon";
+import {isCharacterBox} from "../utils";
+import {MathNode} from "../mathMLTree";
+import {stretchyEnclose} from "../stretchy";
 import {phasePath} from "../svgGeometry";
 import {PathNode, SvgNode} from "../domTree";
 import {calculateSize, makeEm} from "../units";
@@ -17,7 +17,7 @@ const htmlBuilder = (group, options) => {
     // \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(
+    const inner = wrapFragment(
         html.buildGroup(group.body, options), options);
 
     const label = group.label.slice(1);
@@ -30,10 +30,10 @@ const htmlBuilder = (group, options) => {
     // We don't know the width of a group, so as a proxy, we test if
     // the subject is a single character. This captures most of the
     // subjects that should get the "tall" treatment.
-    const isSingleChar = utils.isCharacterBox(group.body);
+    const isSingleChar = isCharacterBox(group.body);
 
     if (label === "sout") {
-        img = buildCommon.makeSpan(["stretchy", "sout"]);
+        img = makeSpan(["stretchy", "sout"]);
         img.height = options.fontMetrics().defaultRuleThickness / scale;
         imgShift = -0.5 * options.fontMetrics().xHeight;
 
@@ -60,7 +60,7 @@ const htmlBuilder = (group, options) => {
             "preserveAspectRatio": "xMinYMin slice",
         });
         // Wrap it in a span with overflow: hidden.
-        img = buildCommon.makeSvgSpan(["hide-tail"], [svgNode], options);
+        img = makeSvgSpan(["hide-tail"], [svgNode], options);
         img.style.height = makeEm(angleHeight);
         imgShift = inner.depth + lineWeight + clearance;
 
@@ -101,7 +101,7 @@ const htmlBuilder = (group, options) => {
             bottomPad =  topPad;
         }
 
-        img = stretchy.encloseSpan(inner, label, topPad, bottomPad, options);
+        img = stretchyEnclose(inner, label, topPad, bottomPad, options);
         if (/fbox|boxed|fcolorbox/.test(label)) {
             img.style.borderStyle = "solid";
             img.style.borderWidth = makeEm(ruleThickness);
@@ -121,7 +121,7 @@ const htmlBuilder = (group, options) => {
 
     let vlist;
     if (group.backgroundColor) {
-        vlist = buildCommon.makeVList({
+        vlist = makeVList({
             positionType: "individualShift",
             children: [
                 // Put the color background behind inner;
@@ -131,7 +131,7 @@ const htmlBuilder = (group, options) => {
         }, options);
     } else {
         const classes = /cancel|phase/.test(label) ? ["svg-align"] : [];
-        vlist = buildCommon.makeVList({
+        vlist = makeVList({
             positionType: "individualShift",
             children: [
                 // Write the \cancel stroke on top of inner.
@@ -159,16 +159,16 @@ const htmlBuilder = (group, options) => {
 
     if (/cancel/.test(label) && !isSingleChar) {
         // cancel does not create horiz space for its line extension.
-        return buildCommon.makeSpan(["mord", "cancel-lap"], [vlist], options);
+        return makeSpan(["mord", "cancel-lap"], [vlist], options);
     } else {
-        return buildCommon.makeSpan(["mord"], [vlist], options);
+        return makeSpan(["mord"], [vlist], options);
     }
 };
 
 const mathmlBuilder = (group, options) => {
     let fboxsep = 0;
-    const node = new mathMLTree.MathNode(
-        (group.label.indexOf("colorbox") > -1) ? "mpadded" : "menclose",
+    const node = new MathNode(
+        group.label.includes("colorbox") ? "mpadded" : "menclose",
         [mml.buildGroup(group.body, options)]
     );
     switch (group.label) {

package/src/functions/font.js

@@ -3,7 +3,7 @@
 
 import {binrelClass} from "./mclass";
 import defineFunction, {normalizeArgument} from "../defineFunction";
-import utils from "../utils";
+import {isCharacterBox} from "../utils";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -71,7 +71,6 @@ defineFunction({
     },
     handler: ({parser}, args) => {
         const body = args[0];
-        const isCharacterBox = utils.isCharacterBox(body);
         // amsbsy.sty's \boldsymbol uses \binrel spacing to inherit the
         // argument's bin|rel|ord status
         return {
@@ -86,7 +85,7 @@ defineFunction({
                     body,
                 },
             ],
-            isCharacterBox: isCharacterBox,
+            isCharacterBox: isCharacterBox(body),
         };
     },
 });