katex 0.16.28 → 0.16.30

package/src/functions/ordgroup.js

@@ -1,6 +1,6 @@
 // @flow
 import {defineFunctionBuilders} from "../defineFunction";
-import buildCommon from "../buildCommon";
+import {makeFragment, makeSpan} from "../buildCommon";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -9,10 +9,10 @@ defineFunctionBuilders({
     type: "ordgroup",
     htmlBuilder(group, options) {
         if (group.semisimple) {
-            return buildCommon.makeFragment(
+            return makeFragment(
                 html.buildExpression(group.body, options, false));
         }
-        return buildCommon.makeSpan(
+        return makeSpan(
             ["mord"], html.buildExpression(group.body, options, true), options);
     },
     mathmlBuilder(group, options) {

package/src/functions/overline.js

@@ -1,7 +1,7 @@
 // @flow
 import defineFunction from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {makeLineSpan, makeSpan, makeVList} from "../buildCommon";
+import {MathNode, TextNode} from "../mathMLTree";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -28,11 +28,11 @@ defineFunction({
             options.havingCrampedStyle());
 
         // Create the line above the body
-        const line = buildCommon.makeLineSpan("overline-line", options);
+        const line = makeLineSpan("overline-line", options);
 
         // Generate the vlist, with the appropriate kerns
         const defaultRuleThickness = options.fontMetrics().defaultRuleThickness;
-        const vlist = buildCommon.makeVList({
+        const vlist = makeVList({
             positionType: "firstBaseline",
             children: [
                 {type: "elem", elem: innerGroup},
@@ -42,14 +42,14 @@ defineFunction({
             ],
         }, options);
 
-        return buildCommon.makeSpan(["mord", "overline"], [vlist], options);
+        return makeSpan(["mord", "overline"], [vlist], options);
     },
     mathmlBuilder(group, options) {
-        const operator = new mathMLTree.MathNode(
-            "mo", [new mathMLTree.TextNode("\u203e")]);
+        const operator = new MathNode(
+            "mo", [new TextNode("\u203e")]);
         operator.setAttribute("stretchy", "true");
 
-        const node = new mathMLTree.MathNode(
+        const node = new MathNode(
             "mover",
             [mml.buildGroup(group.body, options), operator]);
         node.setAttribute("accent", "true");

package/src/functions/phantom.js

@@ -1,7 +1,7 @@
 // @flow
 import defineFunction, {ordargument} from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {makeFragment, makeSpan, makeVList} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -30,11 +30,11 @@ defineFunction({
 
         // \phantom isn't supposed to affect the elements it contains.
         // See "color" for more details.
-        return buildCommon.makeFragment(elements);
+        return makeFragment(elements);
     },
     mathmlBuilder: (group, options) => {
         const inner = mml.buildExpression(group.body, options);
-        return new mathMLTree.MathNode("mphantom", inner);
+        return new MathNode("mphantom", inner);
     },
 });
 
@@ -54,7 +54,7 @@ defineFunction({
         };
     },
     htmlBuilder: (group, options) => {
-        let node = buildCommon.makeSpan(
+        let node = makeSpan(
             [], [html.buildGroup(group.body, options.withPhantom())]);
         node.height = 0;
         node.depth = 0;
@@ -66,18 +66,18 @@ defineFunction({
         }
 
         // See smash for comment re: use of makeVList
-        node = buildCommon.makeVList({
+        node = makeVList({
             positionType: "firstBaseline",
             children: [{type: "elem", elem: node}],
         }, options);
 
         // For spacing, TeX treats \smash as a math group (same spacing as ord).
-        return buildCommon.makeSpan(["mord"], [node], options);
+        return makeSpan(["mord"], [node], options);
     },
     mathmlBuilder: (group, options) => {
         const inner = mml.buildExpression(ordargument(group.body), options);
-        const phantom = new mathMLTree.MathNode("mphantom", inner);
-        const node = new mathMLTree.MathNode("mpadded", [phantom]);
+        const phantom = new MathNode("mphantom", inner);
+        const node = new MathNode("mpadded", [phantom]);
         node.setAttribute("height", "0px");
         node.setAttribute("depth", "0px");
         return node;
@@ -100,17 +100,17 @@ defineFunction({
         };
     },
     htmlBuilder: (group, options) => {
-        const inner = buildCommon.makeSpan(
+        const inner = makeSpan(
             ["inner"],
             [html.buildGroup(group.body, options.withPhantom())]);
-        const fix = buildCommon.makeSpan(["fix"], []);
-        return buildCommon.makeSpan(
+        const fix = makeSpan(["fix"], []);
+        return makeSpan(
             ["mord", "rlap"], [inner, fix], options);
     },
     mathmlBuilder: (group, options) => {
         const inner = mml.buildExpression(ordargument(group.body), options);
-        const phantom = new mathMLTree.MathNode("mphantom", inner);
-        const node = new mathMLTree.MathNode("mpadded", [phantom]);
+        const phantom = new MathNode("mphantom", inner);
+        const node = new MathNode("mpadded", [phantom]);
         node.setAttribute("width", "0px");
         return node;
     },

package/src/functions/pmb.js

@@ -1,7 +1,7 @@
 // @flow
 import defineFunction, {ordargument} from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {makeSpan} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
 import {binrelClass} from "./mclass";
@@ -30,14 +30,14 @@ defineFunction({
     },
     htmlBuilder(group: ParseNode<"pmb">, options) {
         const elements = html.buildExpression(group.body, options, true);
-        const node = buildCommon.makeSpan([group.mclass], elements, options);
+        const node = makeSpan([group.mclass], elements, options);
         node.style.textShadow = "0.02em 0.01em 0.04px";
         return node;
     },
     mathmlBuilder(group: ParseNode<"pmb">, style) {
         const inner = mml.buildExpression(group.body, style);
         // Wrap with an <mstyle> element.
-        const node = new mathMLTree.MathNode("mstyle", inner);
+        const node = new MathNode("mstyle", inner);
         node.setAttribute("style", "text-shadow: 0.02em 0.01em 0.04px");
         return node;
     },

package/src/functions/raisebox.js

@@ -1,7 +1,7 @@
 // @flow
 import defineFunction from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {makeVList} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
 import {assertNodeType} from "../parseNode";
 import {calculateSize} from "../units";
 
@@ -30,14 +30,14 @@ defineFunction({
     htmlBuilder(group, options) {
         const body = html.buildGroup(group.body, options);
         const dy = calculateSize(group.dy, options);
-        return buildCommon.makeVList({
+        return makeVList({
             positionType: "shift",
             positionData: -dy,
             children: [{type: "elem", elem: body}],
         }, options);
     },
     mathmlBuilder(group, options) {
-        const node = new mathMLTree.MathNode(
+        const node = new MathNode(
             "mpadded", [mml.buildGroup(group.body, options)]);
         const dy = group.dy.number + group.dy.unit;
         node.setAttribute("voffset", dy);

package/src/functions/rule.js

@@ -1,7 +1,7 @@
 // @flow
-import buildCommon from "../buildCommon";
+import {makeSpan} from "../buildCommon";
 import defineFunction from "../defineFunction";
-import mathMLTree from "../mathMLTree";
+import {MathNode} from "../mathMLTree";
 import {assertNodeType} from "../parseNode";
 import {calculateSize, makeEm} from "../units";
 
@@ -29,7 +29,7 @@ defineFunction({
     },
     htmlBuilder(group, options) {
         // Make an empty span for the rule
-        const rule = buildCommon.makeSpan(["mord", "rule"], [], options);
+        const rule = makeSpan(["mord", "rule"], [], options);
 
         // Calculate the shift, width, and height of the rule, and account for units
         const width = calculateSize(group.width, options);
@@ -58,12 +58,12 @@ defineFunction({
         const shift = (group.shift) ? calculateSize(group.shift, options) : 0;
         const color = options.color && options.getColor() || "black";
 
-        const rule = new mathMLTree.MathNode("mspace");
+        const rule = new MathNode("mspace");
         rule.setAttribute("mathbackground", color);
         rule.setAttribute("width", makeEm(width));
         rule.setAttribute("height", makeEm(height));
 
-        const wrapper = new mathMLTree.MathNode("mpadded", [rule]);
+        const wrapper = new MathNode("mpadded", [rule]);
         if (shift >= 0) {
             wrapper.setAttribute("height", makeEm(shift));
         } else {

package/src/functions/sizing.js

@@ -1,7 +1,7 @@
 // @flow
-import buildCommon from "../buildCommon";
+import {makeFragment} from "../buildCommon";
 import defineFunction from "../defineFunction";
-import mathMLTree from "../mathMLTree";
+import {MathNode} from "../mathMLTree";
 import {makeEm} from "../units";
 
 import * as html from "../buildHTML";
@@ -38,7 +38,7 @@ export function sizingGroup(
         inner[i].depth *= multiplier;
     }
 
-    return buildCommon.makeFragment(inner);
+    return makeFragment(inner);
 }
 
 const sizeFuncs = [
@@ -77,7 +77,7 @@ defineFunction({
         const newOptions = options.havingSize(group.size);
         const inner = mml.buildExpression(group.body, newOptions);
 
-        const node = new mathMLTree.MathNode("mstyle", inner);
+        const node = new MathNode("mstyle", inner);
 
         // TODO(emily): This doesn't produce the correct size for nested size
         // changes, because we don't keep state of what style we're currently

package/src/functions/smash.js

@@ -1,8 +1,8 @@
 // @flow
 // smash, with optional [tb], as in AMS
 import defineFunction from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {makeSpan, makeVList} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
 import {assertNodeType} from "../parseNode";
 
 import * as html from "../buildHTML";
@@ -54,7 +54,7 @@ defineFunction({
         };
     },
     htmlBuilder: (group, options) => {
-        const node = buildCommon.makeSpan(
+        const node = makeSpan(
             [], [html.buildGroup(group.body, options)]);
 
         if (!group.smashHeight && !group.smashDepth) {
@@ -85,16 +85,16 @@ defineFunction({
         // makeVList applies "display: table-cell", which prevents the browser
         // from acting on that line height. So we'll call makeVList now.
 
-        const smashedNode = buildCommon.makeVList({
+        const smashedNode = makeVList({
             positionType: "firstBaseline",
             children: [{type: "elem", elem: node}],
         }, options);
 
         // For spacing, TeX treats \hphantom as a math group (same spacing as ord).
-        return buildCommon.makeSpan(["mord"], [smashedNode], options);
+        return makeSpan(["mord"], [smashedNode], options);
     },
     mathmlBuilder: (group, options) => {
-        const node = new mathMLTree.MathNode(
+        const node = new MathNode(
             "mpadded", [mml.buildGroup(group.body, options)]);
 
         if (group.smashHeight) {

package/src/functions/sqrt.js

@@ -1,8 +1,8 @@
 // @flow
 import defineFunction from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
-import delimiter from "../delimiter";
+import {makeSpan, makeVList, wrapFragment} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
+import {makeSqrtImage} from "../delimiter";
 import Style from "../Style";
 import {makeEm} from "../units";
 
@@ -39,7 +39,7 @@ defineFunction({
 
         // Some groups can return document fragments.  Handle those by wrapping
         // them in a span.
-        inner = buildCommon.wrapFragment(inner, options);
+        inner = wrapFragment(inner, options);
 
         // Calculate the minimum size for the \surd delimiter
         const metrics = options.fontMetrics();
@@ -58,7 +58,7 @@ defineFunction({
 
         // Create a sqrt SVG of the required minimum size
         const {span: img, ruleWidth, advanceWidth} =
-            delimiter.sqrtImage(minDelimiterHeight, options);
+            makeSqrtImage(minDelimiterHeight, options);
 
         const delimDepth = img.height - ruleWidth;
 
@@ -74,7 +74,7 @@ defineFunction({
         inner.style.paddingLeft = makeEm(advanceWidth);
 
         // Overlay the image and the argument.
-        const body = buildCommon.makeVList({
+        const body = makeVList({
             positionType: "firstBaseline",
             children: [
                 {type: "elem", elem: inner, wrapperClasses: ["svg-align"]},
@@ -85,7 +85,7 @@ defineFunction({
         }, options);
 
         if (!group.index) {
-            return buildCommon.makeSpan(["mord", "sqrt"], [body], options);
+            return makeSpan(["mord", "sqrt"], [body], options);
         } else {
             // Handle the optional root index
 
@@ -98,28 +98,28 @@ defineFunction({
             const toShift = 0.6 * (body.height - body.depth);
 
             // Build a VList with the superscript shifted up correctly
-            const rootVList = buildCommon.makeVList({
+            const rootVList = makeVList({
                 positionType: "shift",
                 positionData: -toShift,
                 children: [{type: "elem", elem: rootm}],
             }, options);
             // Add a class surrounding it so we can add on the appropriate
             // kerning
-            const rootVListWrap = buildCommon.makeSpan(["root"], [rootVList]);
+            const rootVListWrap = makeSpan(["root"], [rootVList]);
 
-            return buildCommon.makeSpan(["mord", "sqrt"],
+            return makeSpan(["mord", "sqrt"],
                 [rootVListWrap, body], options);
         }
     },
     mathmlBuilder(group, options) {
         const {body, index} = group;
         return index ?
-            new mathMLTree.MathNode(
+            new MathNode(
                 "mroot", [
                     mml.buildGroup(body, options),
                     mml.buildGroup(index, options),
                 ]) :
-            new mathMLTree.MathNode(
+            new MathNode(
                 "msqrt", [mml.buildGroup(body, options)]);
     },
 });

package/src/functions/styling.js

@@ -1,6 +1,6 @@
 // @flow
 import defineFunction from "../defineFunction";
-import mathMLTree from "../mathMLTree";
+import {MathNode} from "../mathMLTree";
 import Style from "../Style";
 import {sizingGroup} from "./sizing";
 
@@ -54,7 +54,7 @@ defineFunction({
 
         const inner = mml.buildExpression(group.body, newOptions);
 
-        const node = new mathMLTree.MathNode("mstyle", inner);
+        const node = new MathNode("mstyle", inner);
 
         const styleAttributes = {
             "display": ["0", "true"],

package/src/functions/supsub.js

@@ -1,9 +1,9 @@
 // @flow
 import {defineFunctionBuilders} from "../defineFunction";
-import buildCommon from "../buildCommon";
+import {makeSpan, makeVList} from "../buildCommon";
 import {SymbolNode} from "../domTree";
-import mathMLTree from "../mathMLTree";
-import utils from "../utils";
+import {isCharacterBox} from "../utils";
+import {MathNode} from "../mathMLTree";
 import {makeEm} from "../units";
 import Style from "../Style";
 
@@ -45,7 +45,7 @@ const htmlBuilderDelegate = function(
             (options.style.size === Style.DISPLAY.size || base.limits);
         return delegate ? operatorname.htmlBuilder : null;
     } else if (base.type === "accent") {
-        return utils.isCharacterBox(base.base) ? accent.htmlBuilder : null;
+        return isCharacterBox(base.base) ? accent.htmlBuilder : null;
     } else if (base.type === "horizBrace") {
         const isSup = !group.sub;
         return isSup === base.isOver ? horizBrace.htmlBuilder : null;
@@ -80,11 +80,11 @@ defineFunctionBuilders({
         let supShift = 0;
         let subShift = 0;
 
-        const isCharacterBox = valueBase && utils.isCharacterBox(valueBase);
+        const isCharBox = valueBase && isCharacterBox(valueBase);
         if (valueSup) {
             const newOptions = options.havingStyle(options.style.sup());
             supm = html.buildGroup(valueSup, newOptions, options);
-            if (!isCharacterBox) {
+            if (!isCharBox) {
                 supShift = base.height - newOptions.fontMetrics().supDrop
                     * newOptions.sizeMultiplier / options.sizeMultiplier;
             }
@@ -93,7 +93,7 @@ defineFunctionBuilders({
         if (valueSub) {
             const newOptions = options.havingStyle(options.style.sub());
             subm = html.buildGroup(valueSub, newOptions, options);
-            if (!isCharacterBox) {
+            if (!isCharBox) {
                 subShift = base.depth + newOptions.fontMetrics().subDrop
                     * newOptions.sizeMultiplier / options.sizeMultiplier;
             }
@@ -153,7 +153,7 @@ defineFunctionBuilders({
                 {type: "elem", elem: supm, shift: -supShift, marginRight},
             ];
 
-            supsub = buildCommon.makeVList({
+            supsub = makeVList({
                 positionType: "individualShift",
                 children: vlistElem,
             }, options);
@@ -166,7 +166,7 @@ defineFunctionBuilders({
             const vlistElem =
                 [{type: "elem", elem: subm, marginLeft, marginRight}];
 
-            supsub = buildCommon.makeVList({
+            supsub = makeVList({
                 positionType: "shift",
                 positionData: subShift,
                 children: vlistElem,
@@ -176,7 +176,7 @@ defineFunctionBuilders({
             supShift = Math.max(supShift, minSupShift,
                 supm.depth + 0.25 * metrics.xHeight);
 
-            supsub = buildCommon.makeVList({
+            supsub = makeVList({
                 positionType: "shift",
                 positionData: -supShift,
                 children: [{type: "elem", elem: supm, marginRight}],
@@ -187,8 +187,8 @@ defineFunctionBuilders({
 
         // Wrap the supsub vlist in a span.msupsub to reset text-align.
         const mclass = html.getTypeOfDomTree(base, "right") || "mord";
-        return buildCommon.makeSpan([mclass],
-            [base, buildCommon.makeSpan(["msupsub"], [supsub])],
+        return makeSpan([mclass],
+            [base, makeSpan(["msupsub"], [supsub])],
             options);
     },
     mathmlBuilder(group, options) {
@@ -261,7 +261,7 @@ defineFunctionBuilders({
             }
         }
 
-        return new mathMLTree.MathNode(nodeType, children);
+        return new MathNode(nodeType, children);
     },
 });
 

package/src/functions/symbolsOp.js

@@ -1,7 +1,7 @@
 // @flow
 import {defineFunctionBuilders} from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {mathsym} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
 
 import * as mml from "../buildMathML";
 
@@ -10,11 +10,11 @@ import * as mml from "../buildMathML";
 defineFunctionBuilders({
     type: "atom",
     htmlBuilder(group, options) {
-        return buildCommon.mathsym(
+        return mathsym(
             group.text, group.mode, options, ["m" + group.family]);
     },
     mathmlBuilder(group, options) {
-        const node = new mathMLTree.MathNode(
+        const node = new MathNode(
             "mo", [mml.makeText(group.text, group.mode)]);
         if (group.family === "bin") {
             const variant = mml.getVariant(group, options);

package/src/functions/symbolsOrd.js

@@ -1,7 +1,7 @@
 // @flow
 import {defineFunctionBuilders} from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {makeOrd} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
 
 import * as mml from "../buildMathML";
 
@@ -19,10 +19,10 @@ const defaultVariant: {[string]: string} = {
 defineFunctionBuilders({
     type: "mathord",
     htmlBuilder(group, options) {
-        return buildCommon.makeOrd(group, options, "mathord");
+        return makeOrd(group, options, "mathord");
     },
     mathmlBuilder(group: ParseNode<"mathord">, options) {
-        const node = new mathMLTree.MathNode(
+        const node = new MathNode(
             "mi",
             [mml.makeText(group.text, group.mode, options)]);
 
@@ -37,7 +37,7 @@ defineFunctionBuilders({
 defineFunctionBuilders({
     type: "textord",
     htmlBuilder(group, options) {
-        return buildCommon.makeOrd(group, options, "textord");
+        return makeOrd(group, options, "textord");
     },
     mathmlBuilder(group: ParseNode<"textord">, options) {
         const text = mml.makeText(group.text, group.mode, options);
@@ -45,13 +45,13 @@ defineFunctionBuilders({
 
         let node;
         if (group.mode === 'text') {
-            node = new mathMLTree.MathNode("mtext", [text]);
+            node = new MathNode("mtext", [text]);
         } else if (/[0-9]/.test(group.text)) {
-            node = new mathMLTree.MathNode("mn", [text]);
+            node = new MathNode("mn", [text]);
         } else if (group.text === "\\prime") {
-            node = new mathMLTree.MathNode("mo", [text]);
+            node = new MathNode("mo", [text]);
         } else {
-            node = new mathMLTree.MathNode("mi", [text]);
+            node = new MathNode("mi", [text]);
         }
         if (variant !== defaultVariant[node.type]) {
             node.setAttribute("mathvariant", variant);

package/src/functions/symbolsSpacing.js

@@ -1,7 +1,7 @@
 // @flow
 import {defineFunctionBuilders} from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {mathsym, makeOrd, makeSpan} from "../buildCommon";
+import {MathNode, TextNode} from "../mathMLTree";
 import ParseError from "../ParseError";
 
 // A map of CSS-based spacing functions to their CSS class.
@@ -38,17 +38,17 @@ defineFunctionBuilders({
             // things has an entry in the symbols table, so these will be turned
             // into appropriate outputs.
             if (group.mode === "text") {
-                const ord = buildCommon.makeOrd(group, options, "textord");
+                const ord = makeOrd(group, options, "textord");
                 ord.classes.push(className);
                 return ord;
             } else {
-                return buildCommon.makeSpan(["mspace", className],
-                    [buildCommon.mathsym(group.text, group.mode, options)],
+                return makeSpan(["mspace", className],
+                    [mathsym(group.text, group.mode, options)],
                     options);
             }
         } else if (cssSpace.hasOwnProperty(group.text)) {
             // Spaces based on just a CSS class.
-            return buildCommon.makeSpan(
+            return makeSpan(
                 ["mspace", cssSpace[group.text]],
                 [], options);
         } else {
@@ -59,11 +59,11 @@ defineFunctionBuilders({
         let node;
 
         if (regularSpace.hasOwnProperty(group.text)) {
-            node = new mathMLTree.MathNode(
-                "mtext", [new mathMLTree.TextNode("\u00a0")]);
+            node = new MathNode(
+                "mtext", [new TextNode("\u00a0")]);
         } else if (cssSpace.hasOwnProperty(group.text)) {
             // CSS-based MathML spaces (\nobreak, \allowbreak) are ignored
-            return new mathMLTree.MathNode("mspace");
+            return new MathNode("mspace");
         } else {
             throw new ParseError(`Unknown type of space "${group.text}"`);
         }

package/src/functions/tag.js

@@ -1,11 +1,11 @@
 // @flow
 import {defineFunctionBuilders} from "../defineFunction";
-import mathMLTree from "../mathMLTree";
+import {MathNode} from "../mathMLTree";
 
 import * as mml from "../buildMathML";
 
 const pad = () => {
-    const padNode = new mathMLTree.MathNode("mtd", []);
+    const padNode = new MathNode("mtd", []);
     padNode.setAttribute("width", "50%");
     return padNode;
 };
@@ -13,14 +13,14 @@ const pad = () => {
 defineFunctionBuilders({
     type: "tag",
     mathmlBuilder(group, options) {
-        const table = new mathMLTree.MathNode("mtable", [
-            new mathMLTree.MathNode("mtr", [
+        const table = new MathNode("mtable", [
+            new MathNode("mtr", [
                 pad(),
-                new mathMLTree.MathNode("mtd", [
+                new MathNode("mtd", [
                     mml.buildExpressionRow(group.body, options),
                 ]),
                 pad(),
-                new mathMLTree.MathNode("mtd", [
+                new MathNode("mtd", [
                     mml.buildExpressionRow(group.tag, options),
                 ]),
             ]),

package/src/functions/text.js

@@ -1,6 +1,6 @@
 // @flow
 import defineFunction, {ordargument} from "../defineFunction";
-import buildCommon from "../buildCommon";
+import {makeSpan} from "../buildCommon";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -67,7 +67,7 @@ defineFunction({
     htmlBuilder(group, options) {
         const newOptions = optionsWithFont(group, options);
         const inner = html.buildExpression(group.body, newOptions, true);
-        return buildCommon.makeSpan(["mord", "text"], inner, newOptions);
+        return makeSpan(["mord", "text"], inner, newOptions);
     },
     mathmlBuilder(group, options) {
         const newOptions = optionsWithFont(group, options);