katex 0.16.28 → 0.16.30

package/src/functions/genfrac.js

@@ -1,11 +1,10 @@
 // @flow
 import defineFunction, {normalizeArgument} from "../defineFunction";
-import buildCommon from "../buildCommon";
-import delimiter from "../delimiter";
-import mathMLTree from "../mathMLTree";
+import {makeLineSpan, makeSpan, makeVList} from "../buildCommon";
+import {makeCustomSizedDelim} from "../delimiter";
+import {MathNode, TextNode} from "../mathMLTree";
 import Style from "../Style";
 import {assertNodeType} from "../parseNode";
-import {assert} from "../utils";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -60,9 +59,9 @@ const htmlBuilder = (group, options) => {
     if (group.hasBarLine) {
         if (group.barSize) {
             ruleWidth = calculateSize(group.barSize, options);
-            rule = buildCommon.makeLineSpan("frac-line", options, ruleWidth);
+            rule = makeLineSpan("frac-line", options, ruleWidth);
         } else {
-            rule = buildCommon.makeLineSpan("frac-line", options);
+            rule = makeLineSpan("frac-line", options);
         }
         ruleWidth = rule.height;
         ruleSpacing = rule.height;
@@ -105,7 +104,7 @@ const htmlBuilder = (group, options) => {
             denomShift += 0.5 * (clearance - candidateClearance);
         }
 
-        frac = buildCommon.makeVList({
+        frac = makeVList({
             positionType: "individualShift",
             children: [
                 {type: "elem", elem: denomm, shift: denomShift},
@@ -132,7 +131,7 @@ const htmlBuilder = (group, options) => {
 
         const midShift = -(axisHeight - 0.5 * ruleWidth);
 
-        frac = buildCommon.makeVList({
+        frac = makeVList({
             positionType: "individualShift",
             children: [
                 {type: "elem", elem: denomm, shift: denomShift},
@@ -163,29 +162,29 @@ const htmlBuilder = (group, options) => {
     if (group.leftDelim == null) {
         leftDelim = html.makeNullDelimiter(options, ["mopen"]);
     } else {
-        leftDelim = delimiter.customSizedDelim(
+        leftDelim = makeCustomSizedDelim(
             group.leftDelim, delimSize, true,
             options.havingStyle(style), group.mode, ["mopen"]);
     }
 
     if (group.continued) {
-        rightDelim = buildCommon.makeSpan([]); // zero width for \cfrac
+        rightDelim = makeSpan([]); // zero width for \cfrac
     } else if (group.rightDelim == null) {
         rightDelim = html.makeNullDelimiter(options, ["mclose"]);
     } else {
-        rightDelim = delimiter.customSizedDelim(
+        rightDelim = makeCustomSizedDelim(
             group.rightDelim, delimSize, true,
             options.havingStyle(style), group.mode, ["mclose"]);
     }
 
-    return buildCommon.makeSpan(
+    return makeSpan(
         ["mord"].concat(newOptions.sizingClasses(options)),
-        [leftDelim, buildCommon.makeSpan(["mfrac"], [frac]), rightDelim],
+        [leftDelim, makeSpan(["mfrac"], [frac]), rightDelim],
         options);
 };
 
 const mathmlBuilder = (group, options) => {
-    let node = new mathMLTree.MathNode(
+    let node = new MathNode(
         "mfrac",
         [
             mml.buildGroup(group.numer, options),
@@ -201,7 +200,7 @@ const mathmlBuilder = (group, options) => {
 
     const style = adjustStyle(group.size, options.style);
     if (style.size !== options.style.size) {
-        node = new mathMLTree.MathNode("mstyle", [node]);
+        node = new MathNode("mstyle", [node]);
         const isDisplay = (style.size === Style.DISPLAY.size) ? "true" : "false";
         node.setAttribute("displaystyle", isDisplay);
         node.setAttribute("scriptlevel", "0");
@@ -211,9 +210,9 @@ const mathmlBuilder = (group, options) => {
         const withDelims = [];
 
         if (group.leftDelim != null) {
-            const leftOp = new mathMLTree.MathNode(
+            const leftOp = new MathNode(
                 "mo",
-                [new mathMLTree.TextNode(group.leftDelim.replace("\\", ""))]
+                [new TextNode(group.leftDelim.replace("\\", ""))]
             );
 
             leftOp.setAttribute("fence", "true");
@@ -224,9 +223,9 @@ const mathmlBuilder = (group, options) => {
         withDelims.push(node);
 
         if (group.rightDelim != null) {
-            const rightOp = new mathMLTree.MathNode(
+            const rightOp = new MathNode(
                 "mo",
-                [new mathMLTree.TextNode(group.rightDelim.replace("\\", ""))]
+                [new TextNode(group.rightDelim.replace("\\", ""))]
             );
 
             rightOp.setAttribute("fence", "true");
@@ -487,7 +486,13 @@ defineFunction({
     },
     handler: ({parser, funcName}, args) => {
         const numer = args[0];
-        const barSize = assert(assertNodeType(args[1], "infix").size);
+        const barSize = assertNodeType(args[1], "infix").size;
+
+        if (!barSize) {
+            throw new Error(
+                `\\\\abovefrac expected size, but got ${String(barSize)}`);
+        }
+
         const denom = args[2];
 
         const hasBarLine = barSize.number > 0;

package/src/functions/hbox.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 * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -29,10 +29,10 @@ defineFunction({
     },
     htmlBuilder(group, options) {
         const elements = html.buildExpression(group.body, options, false);
-        return buildCommon.makeFragment(elements);
+        return makeFragment(elements);
     },
     mathmlBuilder(group, options) {
-        return new mathMLTree.MathNode(
+        return new MathNode(
           "mrow", mml.buildExpression(group.body, options)
         );
     },

package/src/functions/horizBrace.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} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
+import {stretchyMathML, stretchySvg} from "../stretchy";
 import Style from "../Style";
 import {assertNodeType} from "../parseNode";
 
@@ -37,13 +37,13 @@ export const htmlBuilder: HtmlBuilderSupSub<"horizBrace"> = (grp, options) => {
         group.base, options.havingBaseStyle(Style.DISPLAY));
 
     // Create the stretchy element
-    const braceBody = stretchy.svgSpan(group, options);
+    const braceBody = stretchySvg(group, options);
 
     // Generate the vlist, with the appropriate kerns        ┏━━━━━━━━┓
     // This first vlist contains the content and the brace:   equation
     let vlist;
     if (group.isOver) {
-        vlist = buildCommon.makeVList({
+        vlist = makeVList({
             positionType: "firstBaseline",
             children: [
                 {type: "elem", elem: body},
@@ -54,7 +54,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"horizBrace"> = (grp, options) => {
         // $FlowFixMe: Replace this with passing "svg-align" into makeVList.
         vlist.children[0].children[0].children[1].classes.push("svg-align");
     } else {
-        vlist = buildCommon.makeVList({
+        vlist = makeVList({
             positionType: "bottom",
             positionData: body.depth + 0.1 + braceBody.height,
             children: [
@@ -77,12 +77,12 @@ export const htmlBuilder: HtmlBuilderSupSub<"horizBrace"> = (grp, options) => {
         //   ┏━━━━━━━━┓   or    ┏━━━┓     not    ┏━━━━━━━━━┓
         //    equation           eqn                 eqn
 
-        const vSpan = buildCommon.makeSpan(
+        const vSpan = makeSpan(
             ["mord", (group.isOver ? "mover" : "munder")],
             [vlist], options);
 
         if (group.isOver) {
-            vlist = buildCommon.makeVList({
+            vlist = makeVList({
                 positionType: "firstBaseline",
                 children: [
                     {type: "elem", elem: vSpan},
@@ -91,7 +91,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"horizBrace"> = (grp, options) => {
                 ],
             }, options);
         } else {
-            vlist = buildCommon.makeVList({
+            vlist = makeVList({
                 positionType: "bottom",
                 positionData: vSpan.depth + 0.2 + supSubGroup.height +
                     supSubGroup.depth,
@@ -104,13 +104,13 @@ export const htmlBuilder: HtmlBuilderSupSub<"horizBrace"> = (grp, options) => {
         }
     }
 
-    return buildCommon.makeSpan(
+    return makeSpan(
         ["mord", (group.isOver ? "mover" : "munder")], [vlist], options);
 };
 
 const mathmlBuilder: MathMLBuilder<"horizBrace"> = (group, options) => {
-    const accentNode = stretchy.mathMLnode(group.label);
-    return new mathMLTree.MathNode(
+    const accentNode = stretchyMathML(group.label);
+    return new MathNode(
         (group.isOver ? "mover" : "munder"),
         [mml.buildGroup(group.base, options), accentNode]
     );

package/src/functions/href.js

@@ -1,6 +1,6 @@
 // @flow
 import defineFunction, {ordargument} from "../defineFunction";
-import buildCommon from "../buildCommon";
+import {makeAnchor} from "../buildCommon";
 import {assertNodeType} from "../parseNode";
 import {MathNode} from "../mathMLTree";
 
@@ -35,7 +35,7 @@ defineFunction({
     },
     htmlBuilder: (group, options) => {
         const elements = html.buildExpression(group.body, options, false);
-        return buildCommon.makeAnchor(group.href, [], elements, options);
+        return makeAnchor(group.href, [], elements, options);
     },
     mathmlBuilder: (group, options) => {
         let math = mml.buildExpressionRow(group.body, options);

package/src/functions/html.js

@@ -1,6 +1,6 @@
 // @flow
 import defineFunction, {ordargument} from "../defineFunction";
-import buildCommon from "../buildCommon";
+import {makeSpan} from "../buildCommon";
 import {assertNodeType} from "../parseNode";
 import ParseError from "../ParseError";
 
@@ -91,7 +91,7 @@ defineFunction({
             classes.push(...group.attributes.class.trim().split(/\s+/));
         }
 
-        const span = buildCommon.makeSpan(classes, elements, options);
+        const span = makeSpan(classes, elements, options);
         for (const attr in group.attributes) {
             if (attr !== "class" && group.attributes.hasOwnProperty(attr)) {
                 span.setAttribute(attr, group.attributes[attr]);

package/src/functions/htmlmathml.js

@@ -1,6 +1,6 @@
 // @flow
 import defineFunction, {ordargument} from "../defineFunction";
-import buildCommon from "../buildCommon";
+import {makeFragment} from "../buildCommon";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -10,6 +10,7 @@ defineFunction({
     names: ["\\html@mathml"],
     props: {
         numArgs: 2,
+        allowedInArgument: true,
         allowedInText: true,
     },
     handler: ({parser}, args) => {
@@ -26,7 +27,7 @@ defineFunction({
             options,
             false
         );
-        return buildCommon.makeFragment(elements);
+        return makeFragment(elements);
     },
     mathmlBuilder: (group, options) => {
         return mml.buildExpressionRow(group.mathml, options);

package/src/functions/includegraphics.js

@@ -4,7 +4,7 @@ import type {Measurement} from "../units";
 import {calculateSize, validUnit, makeEm} from "../units";
 import ParseError from "../ParseError";
 import {Img} from "../domTree";
-import mathMLTree from "../mathMLTree";
+import {MathNode} from "../mathMLTree";
 import {assertNodeType} from "../parseNode";
 import type {CssStyle} from "../domTree";
 
@@ -130,7 +130,7 @@ defineFunction({
         return node;
     },
     mathmlBuilder: (group, options) => {
-        const node = new mathMLTree.MathNode("mglyph", []);
+        const node = new MathNode("mglyph", []);
         node.setAttribute("alt", group.alt);
 
         const height = calculateSize(group.height, options);

package/src/functions/kern.js

@@ -2,8 +2,8 @@
 // Horizontal spacing commands
 
 import defineFunction from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {makeGlue} from "../buildCommon";
+import {SpaceNode} from "../mathMLTree";
 import {calculateSize} from "../units";
 import {assertNodeType} from "../parseNode";
 
@@ -47,10 +47,10 @@ defineFunction({
         };
     },
     htmlBuilder(group, options) {
-        return buildCommon.makeGlue(group.dimension, options);
+        return makeGlue(group.dimension, options);
     },
     mathmlBuilder(group, options) {
         const dimension = calculateSize(group.dimension, options);
-        return new mathMLTree.SpaceNode(dimension);
+        return new SpaceNode(dimension);
     },
 });

package/src/functions/lap.js

@@ -1,8 +1,8 @@
 // @flow
 // Horizontal overlap functions
 import defineFunction from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {makeSpan} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
 import {makeEm} from "../units";
 
 import * as html from "../buildHTML";
@@ -29,16 +29,16 @@ defineFunction({
         let inner;
         if (group.alignment === "clap") {
             // ref: https://www.math.lsu.edu/~aperlis/publications/mathclap/
-            inner = buildCommon.makeSpan(
+            inner = makeSpan(
                 [], [html.buildGroup(group.body, options)]);
             // wrap, since CSS will center a .clap > .inner > span
-            inner = buildCommon.makeSpan(["inner"], [inner], options);
+            inner = makeSpan(["inner"], [inner], options);
         } else {
-            inner = buildCommon.makeSpan(
+            inner = makeSpan(
                 ["inner"], [html.buildGroup(group.body, options)]);
         }
-        const fix = buildCommon.makeSpan(["fix"], []);
-        let node = buildCommon.makeSpan(
+        const fix = makeSpan(["fix"], []);
+        let node = makeSpan(
             [group.alignment], [inner, fix], options);
 
         // At this point, we have correctly set horizontal alignment of the
@@ -46,7 +46,7 @@ defineFunction({
         // 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"]);
+        const strut = makeSpan(["strut"]);
         strut.style.height = makeEm(node.height + node.depth);
         if (node.depth) {
             strut.style.verticalAlign = makeEm(-node.depth);
@@ -55,12 +55,12 @@ defineFunction({
 
         // Next, prevent vertical misplacement when next to something tall.
         // This code resolves issue #1234
-        node = buildCommon.makeSpan(["thinbox"], [node], options);
-        return buildCommon.makeSpan(["mord", "vbox"], [node], options);
+        node = makeSpan(["thinbox"], [node], options);
+        return makeSpan(["mord", "vbox"], [node], options);
     },
     mathmlBuilder: (group, options) => {
         // mathllap, mathrlap, mathclap
-        const node = new mathMLTree.MathNode(
+        const node = new MathNode(
             "mpadded", [mml.buildGroup(group.body, options)]);
 
         if (group.alignment !== "rlap")    {

package/src/functions/mathchoice.js

@@ -1,6 +1,6 @@
 // @flow
 import defineFunction, {ordargument} from "../defineFunction";
-import buildCommon from "../buildCommon";
+import {makeFragment} from "../buildCommon";
 import Style from "../Style";
 
 import * as html from "../buildHTML";
@@ -42,7 +42,7 @@ defineFunction({
             options,
             false
         );
-        return buildCommon.makeFragment(elements);
+        return makeFragment(elements);
     },
     mathmlBuilder: (group, options) => {
         const body = chooseMathStyle(group, options);

package/src/functions/mclass.js

@@ -1,8 +1,8 @@
 // @flow
 import defineFunction, {ordargument} from "../defineFunction";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
-import utils from "../utils";
+import {makeSpan} from "../buildCommon";
+import {isCharacterBox} from "../utils";
+import {MathNode} from "../mathMLTree";
 import type {AnyParseNode} from "../parseNode";
 
 import * as html from "../buildHTML";
@@ -10,32 +10,30 @@ import * as mml from "../buildMathML";
 
 import type {ParseNode} from "../parseNode";
 
-const makeSpan = buildCommon.makeSpan;
-
 function htmlBuilder(group: ParseNode<"mclass">, options) {
     const elements = html.buildExpression(group.body, options, true);
     return makeSpan([group.mclass], elements, options);
 }
 
 function mathmlBuilder(group: ParseNode<"mclass">, options) {
-    let node: mathMLTree.MathNode;
+    let node: MathNode;
     const inner = mml.buildExpression(group.body, options);
 
     if (group.mclass === "minner") {
-        node = new mathMLTree.MathNode("mpadded", inner);
+        node = new MathNode("mpadded", inner);
     } else if (group.mclass === "mord") {
         if (group.isCharacterBox) {
             node = inner[0];
             node.type = "mi";
         } else {
-            node = new mathMLTree.MathNode("mi", inner);
+            node = new MathNode("mi", inner);
         }
     } else {
         if (group.isCharacterBox) {
             node = inner[0];
             node.type = "mo";
         } else {
-            node = new mathMLTree.MathNode("mo", inner);
+            node = new MathNode("mo", inner);
         }
 
         // Set spacing based on what is the most likely adjacent atom type.
@@ -77,7 +75,7 @@ defineFunction({
             mode: parser.mode,
             mclass: "m" + funcName.slice(5), // TODO(kevinb): don't prefix with 'm'
             body: ordargument(body),
-            isCharacterBox: utils.isCharacterBox(body),
+            isCharacterBox: isCharacterBox(body),
         };
     },
     htmlBuilder,
@@ -111,7 +109,7 @@ defineFunction({
             mode: parser.mode,
             mclass: binrelClass(args[0]),
             body: ordargument(args[1]),
-            isCharacterBox: utils.isCharacterBox(args[1]),
+            isCharacterBox: isCharacterBox(args[1]),
         };
     },
 });
@@ -159,7 +157,7 @@ defineFunction({
             mode: parser.mode,
             mclass,
             body: [supsub],
-            isCharacterBox: utils.isCharacterBox(supsub),
+            isCharacterBox: isCharacterBox(supsub),
         };
     },
     htmlBuilder,

package/src/functions/op.js

@@ -1,9 +1,9 @@
 // @flow
 // Limits, symbols
 import defineFunction, {ordargument} from "../defineFunction";
-import buildCommon from "../buildCommon";
+import {mathsym, makeSpan, makeSymbol, makeVList, staticSvg} from "../buildCommon";
 import {SymbolNode} from "../domTree";
-import * as mathMLTree from "../mathMLTree";
+import {MathNode, newDocumentFragment, TextNode} from "../mathMLTree";
 import Style from "../Style";
 import {assembleSupSub} from "./utils/assembleSupSub";
 import {assertNodeType} from "../parseNode";
@@ -16,9 +16,9 @@ import type {HtmlBuilderSupSub, MathMLBuilder} from "../defineFunction";
 import type {ParseNode} from "../parseNode";
 
 // Most operators have a large successor symbol, but these don't.
-const noSuccessor = [
+const noSuccessor = new Set([
     "\\smallint",
-];
+]);
 
 // NOTE: Unlike most `htmlBuilder`s, this one handles not only "op", but also
 // "supsub" since some of them (like \int) can affect super/subscripting.
@@ -45,7 +45,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"op"> = (grp, options) => {
     let large = false;
     if (style.size === Style.DISPLAY.size &&
         group.symbol &&
-        !noSuccessor.includes(group.name)) {
+        !noSuccessor.has(group.name)) {
 
         // Most symbol operators get larger in displaystyle (rule 13)
         large = true;
@@ -64,7 +64,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"op"> = (grp, options) => {
             group.name = stash === "oiint" ? "\\iint" : "\\iiint";
         }
 
-        base = buildCommon.makeSymbol(
+        base = makeSymbol(
             group.name, fontName, "math", options,
             ["mop", "op-symbol", large ? "large-op" : "small-op"]);
 
@@ -72,9 +72,9 @@ export const htmlBuilder: HtmlBuilderSupSub<"op"> = (grp, options) => {
             // We're in \oiint or \oiiint. Overlay the oval.
             // TODO: When font glyphs are available, delete this code.
             const italic = base.italic;
-            const oval = buildCommon.staticSvg(stash + "Size"
+            const oval = staticSvg(stash + "Size"
                 + (large ? "2" : "1"), options);
-            base = buildCommon.makeVList({
+            base = makeVList({
                 positionType: "individualShift",
                 children: [
                     {type: "elem", elem: base, shift: 0},
@@ -93,16 +93,16 @@ export const htmlBuilder: HtmlBuilderSupSub<"op"> = (grp, options) => {
             base = inner[0];
             base.classes[0] = "mop"; // replace old mclass
         } else {
-            base = buildCommon.makeSpan(["mop"], inner, options);
+            base = makeSpan(["mop"], inner, options);
         }
     } else {
         // Otherwise, this is a text operator. Build the text from the
         // operator's name.
         const output = [];
         for (let i = 1; i < group.name.length; i++) {
-            output.push(buildCommon.mathsym(group.name[i], group.mode, options));
+            output.push(mathsym(group.name[i], group.mode, options));
         }
-        base = buildCommon.makeSpan(["mop"], output, options);
+        base = makeSpan(["mop"], output, options);
     }
 
     // If content of op is a single symbol, shift it vertically.
@@ -144,28 +144,28 @@ const mathmlBuilder: MathMLBuilder<"op"> = (group, options) => {
 
     if (group.symbol) {
         // This is a symbol. Just add the symbol.
-        node = new mathMLTree.MathNode(
+        node = new MathNode(
             "mo", [mml.makeText(group.name, group.mode)]);
-        if (noSuccessor.includes(group.name)) {
+        if (noSuccessor.has(group.name)) {
             node.setAttribute("largeop", "false");
         }
     } else if (group.body) {
         // This is an operator with children. Add them.
-        node = new mathMLTree.MathNode(
+        node = new MathNode(
             "mo", mml.buildExpression(group.body, options));
     } else {
-        // This is a text operator. Add all of the characters from the
+        // This is a text operator. Add all the characters from the
         // operator's name.
-        node = new mathMLTree.MathNode(
-            "mi", [new mathMLTree.TextNode(group.name.slice(1))]);
+        node = new MathNode(
+            "mi", [new TextNode(group.name.slice(1))]);
         // Append an <mo>&ApplyFunction;</mo>.
         // ref: https://www.w3.org/TR/REC-MathML/chap3_2.html#sec3.2.4
-        const operator = new mathMLTree.MathNode("mo",
+        const operator = new MathNode("mo",
             [mml.makeText("\u2061", "text")]);
         if (group.parentIsSupSub) {
-            node = new mathMLTree.MathNode("mrow", [node, operator]);
+            node = new MathNode("mrow", [node, operator]);
         } else {
-            node = mathMLTree.newDocumentFragment([node, operator]);
+            node = newDocumentFragment([node, operator]);
         }
     }
 

package/src/functions/operatorname.js

@@ -1,8 +1,8 @@
 // @flow
 import defineFunction, {ordargument} from "../defineFunction";
 import defineMacro from "../defineMacro";
-import buildCommon from "../buildCommon";
-import mathMLTree from "../mathMLTree";
+import {makeSpan} from "../buildCommon";
+import {MathNode, newDocumentFragment, SpaceNode, TextNode} from "../mathMLTree";
 import {SymbolNode} from "../domTree";
 import {assembleSupSub} from "./utils/assembleSupSub";
 import {assertNodeType} from "../parseNode";
@@ -63,9 +63,9 @@ export const htmlBuilder: HtmlBuilderSupSub<"operatorname"> = (grp, options) =>
                     .replace(/\u2217/, "*");
             }
         }
-        base = buildCommon.makeSpan(["mop"], expression, options);
+        base = makeSpan(["mop"], expression, options);
     } else {
-        base = buildCommon.makeSpan(["mop"], [], options);
+        base = makeSpan(["mop"], [], options);
     }
 
     if (hasLimits) {
@@ -86,9 +86,9 @@ const mathmlBuilder: MathMLBuilder<"operatorname"> = (group, options) => {
     let isAllString = true;  // default
     for (let i = 0; i < expression.length; i++) {
         const node = expression[i];
-        if (node instanceof mathMLTree.SpaceNode) {
+        if (node instanceof SpaceNode) {
             // Do nothing
-        } else if (node instanceof mathMLTree.MathNode) {
+        } else if (node instanceof MathNode) {
             switch (node.type) {
                 case "mi":
                 case "mn":
@@ -99,7 +99,7 @@ const mathmlBuilder: MathMLBuilder<"operatorname"> = (group, options) => {
                 case "mo": {
                     const child = node.children[0];
                     if (node.children.length === 1 &&
-                        child instanceof mathMLTree.TextNode) {
+                        child instanceof TextNode) {
                         child.text =
                             child.text.replace(/\u2212/, "-")
                                 .replace(/\u2217/, "*");
@@ -119,21 +119,21 @@ const mathmlBuilder: MathMLBuilder<"operatorname"> = (group, options) => {
     if (isAllString) {
         // Write a single TextNode instead of multiple nested tags.
         const word = expression.map(node => node.toText()).join("");
-        expression = [new mathMLTree.TextNode(word)];
+        expression = [new TextNode(word)];
     }
 
-    const identifier = new mathMLTree.MathNode("mi", expression);
+    const identifier = new MathNode("mi", expression);
     identifier.setAttribute("mathvariant", "normal");
 
     // \u2061 is the same as &ApplyFunction;
     // ref: https://www.w3schools.com/charsets/ref_html_entities_a.asp
-    const operator = new mathMLTree.MathNode("mo",
+    const operator = new MathNode("mo",
         [mml.makeText("\u2061", "text")]);
 
     if (group.parentIsSupSub) {
-        return new mathMLTree.MathNode("mrow", [identifier, operator]);
+        return new MathNode("mrow", [identifier, operator]);
     } else {
-        return mathMLTree.newDocumentFragment([identifier, operator]);
+        return newDocumentFragment([identifier, operator]);
     }
 };