katex 0.16.28 → 0.16.30

package/src/delimiter.js

@@ -26,7 +26,7 @@ import Style from "./Style";
 
 import {PathNode, SvgNode, SymbolNode} from "./domTree";
 import {sqrtPath, innerPath, tallDelim} from "./svgGeometry";
-import buildCommon from "./buildCommon";
+import {makeSpan, makeSymbol, makeSvgSpan, makeVList} from "./buildCommon";
 import {getCharacterMetrics} from "./fontMetrics";
 import symbols from "./symbols";
 import {makeEm} from "./units";
@@ -69,7 +69,7 @@ const styleWrap = function(
 ): DomSpan {
     const newOptions = options.havingBaseStyle(toStyle);
 
-    const span = buildCommon.makeSpan(
+    const span = makeSpan(
         classes.concat(newOptions.sizingClasses(options)),
         [delim], options);
 
@@ -111,7 +111,7 @@ const makeSmallDelim = function(
     mode: Mode,
     classes: string[],
 ): DomSpan {
-    const text = buildCommon.makeSymbol(delim, "Main-Regular", mode, options);
+    const text = makeSymbol(delim, "Main-Regular", mode, options);
     const span = styleWrap(text, style, options, classes);
     if (center) {
         centerSpan(span, options, style);
@@ -128,7 +128,7 @@ const mathrmSize = function(
     mode: Mode,
     options: Options,
 ): SymbolNode {
-    return buildCommon.makeSymbol(value, "Size" + size + "-Regular",
+    return makeSymbol(value, "Size" + size + "-Regular",
         mode, options);
 };
 
@@ -145,7 +145,7 @@ const makeLargeDelim = function(delim,
 ): DomSpan {
     const inner = mathrmSize(delim, size, mode, options);
     const span = styleWrap(
-        buildCommon.makeSpan(["delimsizing", "size" + size], [inner], options),
+        makeSpan(["delimsizing", "size" + size], [inner], options),
         Style.TEXT, options, classes);
     if (center) {
         centerSpan(span, options, Style.TEXT);
@@ -170,9 +170,9 @@ const makeGlyphSpan = function(
         sizeClass = "delim-size4";
     }
 
-    const corner = buildCommon.makeSpan(
+    const corner = makeSpan(
         ["delimsizinginner", sizeClass],
-        [buildCommon.makeSpan([], [buildCommon.makeSymbol(symbol, font, mode)])]);
+        [makeSpan([], [makeSymbol(symbol, font, mode)])]);
 
     // Since this will be passed into `makeVList` in the end, wrap the element
     // in the appropriate tag that VList uses.
@@ -197,7 +197,7 @@ const makeInner = function(
         "viewBox": "0 0 " + 1000 * width + " " + Math.round(1000 * height),
         "preserveAspectRatio": "xMinYMin",
     });
-    const span = buildCommon.makeSvgSpan([], [svgNode], options);
+    const span = makeSvgSpan([], [svgNode], options);
     span.height = height;
     span.style.height = makeEm(height);
     span.style.width = makeEm(width);
@@ -207,8 +207,8 @@ const makeInner = function(
 // Helpers for makeStackedDelim
 const lapInEms = 0.008;
 const lap = {type: "kern", size: -1 * lapInEms};
-const verts = ["|", "\\lvert", "\\rvert", "\\vert"];
-const doubleVerts = ["\\|", "\\lVert", "\\rVert", "\\Vert"];
+const verts = new Set(["|", "\\lvert", "\\rvert", "\\vert"]);
+const doubleVerts = new Set(["\\|", "\\lVert", "\\rVert", "\\Vert"]);
 
 /**
  * Make a stacked delimiter out of a given delimiter, with the total height at
@@ -254,11 +254,11 @@ const makeStackedDelim = function(
         top = "\\Uparrow";
         repeat = "\u2016";
         bottom = "\\Downarrow";
-    } else if (verts.includes(delim)) {
+    } else if (verts.has(delim)) {
         repeat = "\u2223";
         svgLabel = "vert";
         viewBoxWidth = 333;
-    } else if (doubleVerts.includes(delim)) {
+    } else if (doubleVerts.has(delim)) {
         repeat = "\u2225";
         svgLabel = "doublevert";
         viewBoxWidth = 556;
@@ -404,7 +404,7 @@ const makeStackedDelim = function(
             "height": height,
             "viewBox": `0 0 ${viewBoxWidth} ${viewBoxHeight}`,
         });
-        const wrapper = buildCommon.makeSvgSpan([], [svg], options);
+        const wrapper = makeSvgSpan([], [svg], options);
         wrapper.height = viewBoxHeight / 1000;
         wrapper.style.width = width;
         wrapper.style.height = height;
@@ -441,14 +441,14 @@ const makeStackedDelim = function(
 
     // Finally, build the vlist
     const newOptions = options.havingBaseStyle(Style.TEXT);
-    const inner = buildCommon.makeVList({
+    const inner = makeVList({
         positionType: "bottom",
         positionData: depth,
         children: stack,
     }, newOptions);
 
     return styleWrap(
-        buildCommon.makeSpan(["delimsizing", "mult"], [inner], newOptions),
+        makeSpan(["delimsizing", "mult"], [inner], newOptions),
         Style.TEXT, options, classes);
 };
 
@@ -475,13 +475,13 @@ const sqrtSvg = function(
         "preserveAspectRatio": "xMinYMin slice",
     });
 
-    return buildCommon.makeSvgSpan(["hide-tail"], [svg], options);
+    return makeSvgSpan(["hide-tail"], [svg], options);
 };
 
 /**
  * Make a sqrt image of the given height,
  */
-const makeSqrtImage = function(
+export const makeSqrtImage = function(
     height: number,
     options: Options,
 ): {
@@ -573,39 +573,39 @@ const makeSqrtImage = function(
 
 // There are three kinds of delimiters, delimiters that stack when they become
 // too large
-const stackLargeDelimiters = [
+const stackLargeDelimiters = new Set([
     "(", "\\lparen", ")", "\\rparen",
     "[", "\\lbrack", "]", "\\rbrack",
     "\\{", "\\lbrace", "\\}", "\\rbrace",
     "\\lfloor", "\\rfloor", "\u230a", "\u230b",
     "\\lceil", "\\rceil", "\u2308", "\u2309",
     "\\surd",
-];
+]);
 
 // delimiters that always stack
-const stackAlwaysDelimiters = [
+const stackAlwaysDelimiters = new Set([
     "\\uparrow", "\\downarrow", "\\updownarrow",
     "\\Uparrow", "\\Downarrow", "\\Updownarrow",
     "|", "\\|", "\\vert", "\\Vert",
     "\\lvert", "\\rvert", "\\lVert", "\\rVert",
     "\\lgroup", "\\rgroup", "\u27ee", "\u27ef",
     "\\lmoustache", "\\rmoustache", "\u23b0", "\u23b1",
-];
+]);
 
 // and delimiters that never stack
-const stackNeverDelimiters = [
+const stackNeverDelimiters = new Set([
     "<", ">", "\\langle", "\\rangle", "/", "\\backslash", "\\lt", "\\gt",
-];
+]);
 
 // Metrics of the different sizes. Found by looking at TeX's output of
 // $\bigl| // \Bigl| \biggl| \Biggl| \showlists$
 // Used to create stacked delimiters of appropriate sizes in makeSizedDelim.
-const sizeToMaxHeight = [0, 1.2, 1.8, 2.4, 3.0];
+export const sizeToMaxHeight = [0, 1.2, 1.8, 2.4, 3.0];
 
 /**
  * Used to create a delimiter of a specific size, where `size` is 1, 2, 3, or 4.
  */
-const makeSizedDelim = function(
+export const makeSizedDelim = function(
     delim: string,
     size: number,
     options: Options,
@@ -620,10 +620,10 @@ const makeSizedDelim = function(
     }
 
     // Sized delimiters are never centered.
-    if (stackLargeDelimiters.includes(delim) ||
-        stackNeverDelimiters.includes(delim)) {
+    if (stackLargeDelimiters.has(delim) ||
+        stackNeverDelimiters.has(delim)) {
         return makeLargeDelim(delim, size, false, options, mode, classes);
-    } else if (stackAlwaysDelimiters.includes(delim)) {
+    } else if (stackAlwaysDelimiters.has(delim)) {
         return makeStackedDelim(
             delim, sizeToMaxHeight[size], false, options, mode, classes);
     } else {
@@ -742,7 +742,7 @@ const traverseSequence = function(
  * Make a delimiter of a given height+depth, with optional centering. Here, we
  * traverse the sequences, and create a delimiter that the sequence tells us to.
  */
-const makeCustomSizedDelim = function(
+export const makeCustomSizedDelim = function(
     delim: string,
     height: number,
     center: boolean,
@@ -758,9 +758,9 @@ const makeCustomSizedDelim = function(
 
     // Decide what sequence to use
     let sequence;
-    if (stackNeverDelimiters.includes(delim)) {
+    if (stackNeverDelimiters.has(delim)) {
         sequence = stackNeverDelimiterSequence;
-    } else if (stackLargeDelimiters.includes(delim)) {
+    } else if (stackLargeDelimiters.has(delim)) {
         sequence = stackLargeDelimiterSequence;
     } else {
         sequence = stackAlwaysDelimiterSequence;
@@ -788,7 +788,7 @@ const makeCustomSizedDelim = function(
  * Make a delimiter for use with `\left` and `\right`, given a height and depth
  * of an expression that the delimiters surround.
  */
-const makeLeftRightDelim = function(
+export const makeLeftRightDelim = function(
     delim: string,
     height: number,
     depth: number,
@@ -824,11 +824,3 @@ const makeLeftRightDelim = function(
     // height
     return makeCustomSizedDelim(delim, totalHeight, true, options, mode, classes);
 };
-
-export default {
-    sqrtImage: makeSqrtImage,
-    sizedDelim: makeSizedDelim,
-    sizeToMaxHeight: sizeToMaxHeight,
-    customSizedDelim: makeCustomSizedDelim,
-    leftRightDelim: makeLeftRightDelim,
-};

package/src/domTree.js

@@ -12,7 +12,7 @@
  * target environments support class inheritance
  */
 import {scriptFromCodepoint} from "./unicodeScripts";
-import utils from "./utils";
+import {escape, hyphenate} from "./utils";
 import {path} from "./svgGeometry";
 import type Options from "./Options";
 import {DocumentFragment} from "./tree";
@@ -102,7 +102,7 @@ const toMarkup = function(tagName: string): string {
 
     // Add the class
     if (this.classes.length) {
-        markup += ` class="${utils.escape(createClass(this.classes))}"`;
+        markup += ` class="${escape(createClass(this.classes))}"`;
     }
 
     let styles = "";
@@ -110,12 +110,12 @@ const toMarkup = function(tagName: string): string {
     // Add the styles, after hyphenation
     for (const style in this.style) {
         if (this.style.hasOwnProperty(style)) {
-            styles += `${utils.hyphenate(style)}:${this.style[style]};`;
+            styles += `${hyphenate(style)}:${this.style[style]};`;
         }
     }
 
     if (styles) {
-        markup += ` style="${utils.escape(styles)}"`;
+        markup += ` style="${escape(styles)}"`;
     }
 
     // Add the attributes
@@ -124,7 +124,7 @@ const toMarkup = function(tagName: string): string {
             if (invalidAttributeNameRegex.test(attr)) {
                 throw new ParseError(`Invalid attribute name '${attr}'`);
             }
-            markup += ` ${attr}="${utils.escape(this.attributes[attr])}"`;
+            markup += ` ${attr}="${escape(this.attributes[attr])}"`;
         }
     }
 
@@ -329,18 +329,18 @@ export class Img implements VirtualNode {
     }
 
     toMarkup(): string {
-        let markup = `<img src="${utils.escape(this.src)}"` +
-          ` alt="${utils.escape(this.alt)}"`;
+        let markup = `<img src="${escape(this.src)}"` +
+          ` alt="${escape(this.alt)}"`;
 
         // Add the styles, after hyphenation
         let styles = "";
         for (const style in this.style) {
             if (this.style.hasOwnProperty(style)) {
-                styles += `${utils.hyphenate(style)}:${this.style[style]};`;
+                styles += `${hyphenate(style)}:${this.style[style]};`;
             }
         }
         if (styles) {
-            markup += ` style="${utils.escape(styles)}"`;
+            markup += ` style="${escape(styles)}"`;
         }
 
         markup += "'/>";
@@ -460,7 +460,7 @@ export class SymbolNode implements HtmlDomNode {
         if (this.classes.length) {
             needsSpan = true;
             markup += " class=\"";
-            markup += utils.escape(createClass(this.classes));
+            markup += escape(createClass(this.classes));
             markup += "\"";
         }
 
@@ -471,16 +471,16 @@ export class SymbolNode implements HtmlDomNode {
         }
         for (const style in this.style) {
             if (this.style.hasOwnProperty(style)) {
-                styles += utils.hyphenate(style) + ":" + this.style[style] + ";";
+                styles += hyphenate(style) + ":" + this.style[style] + ";";
             }
         }
 
         if (styles) {
             needsSpan = true;
-            markup += " style=\"" + utils.escape(styles) + "\"";
+            markup += " style=\"" + escape(styles) + "\"";
         }
 
-        const escaped = utils.escape(this.text);
+        const escaped = escape(this.text);
         if (needsSpan) {
             markup += ">";
             markup += escaped;
@@ -527,7 +527,7 @@ export class SvgNode implements VirtualNode {
         // Apply attributes
         for (const attr in this.attributes) {
             if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {
-                markup += ` ${attr}="${utils.escape(this.attributes[attr])}"`;
+                markup += ` ${attr}="${escape(this.attributes[attr])}"`;
             }
         }
 
@@ -568,9 +568,9 @@ export class PathNode implements VirtualNode {
 
     toMarkup(): string {
         if (this.alternate) {
-            return `<path d="${utils.escape(this.alternate)}"/>`;
+            return `<path d="${escape(this.alternate)}"/>`;
         } else {
-            return `<path d="${utils.escape(path[this.pathName])}"/>`;
+            return `<path d="${escape(path[this.pathName])}"/>`;
         }
     }
 }
@@ -601,7 +601,7 @@ export class LineNode implements VirtualNode {
 
         for (const attr in this.attributes) {
             if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {
-                markup += ` ${attr}="${utils.escape(this.attributes[attr])}"`;
+                markup += ` ${attr}="${escape(this.attributes[attr])}"`;
             }
         }
 

package/src/environments/array.js

@@ -1,17 +1,16 @@
 // @flow
-import buildCommon from "../buildCommon";
+import {makeFragment, makeLineSpan, makeSpan, makeVList} from "../buildCommon";
 import Style from "../Style";
 import defineEnvironment from "../defineEnvironment";
 import {parseCD} from "./cd";
 import defineFunction from "../defineFunction";
 import defineMacro from "../defineMacro";
-import mathMLTree from "../mathMLTree";
+import {MathNode} from "../mathMLTree";
 import ParseError from "../ParseError";
 import {assertNodeType, assertSymbolNodeType} from "../parseNode";
 import {checkSymbolNodeType} from "../parseNode";
 import {Token} from "../Token";
 import {calculateSize, makeEm} from "../units";
-import utils from "../utils";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -61,14 +60,16 @@ const validateAmsEnvironmentContext = context => {
     }
 };
 
+const gatherEnvironments = new Set(["gather", "gather*"]);
+
 // autoTag (an argument to parseArray) can be one of three values:
 // * undefined: Regular (not-top-level) array; no tags on each row
 // * true: Automatic equation numbering, overridable by \tag
 // * false: Tags allowed on each row, but no automatic numbering
 // This function *doesn't* work with the "split" environment name.
 function getAutoTag(name): ?boolean {
-    if (name.indexOf("ed") === -1) {
-        return name.indexOf("*") === -1;
+    if (!name.includes("ed")) {
+        return !name.includes("*");
     }
     // return undefined;
 }
@@ -394,12 +395,12 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
             const tag = group.tags[r];
             let tagSpan;
             if (tag === true) {  // automatic numbering
-                tagSpan = buildCommon.makeSpan(["eqn-num"], [], options);
+                tagSpan = makeSpan(["eqn-num"], [], options);
             } else if (tag === false) {
                 // \nonumber/\notag or starred environment
-                tagSpan = buildCommon.makeSpan([], [], options);
+                tagSpan = makeSpan([], [], options);
             } else {  // manual \tag
-                tagSpan = buildCommon.makeSpan([],
+                tagSpan = makeSpan([],
                     html.buildExpression(tag, options, true), options);
             }
             tagSpan.depth = rw.depth;
@@ -421,7 +422,7 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
             // If there is more than one separator in a row, add a space
             // between them.
             if (!firstSeparator) {
-                colSep = buildCommon.makeSpan(["arraycolsep"], []);
+                colSep = makeSpan(["arraycolsep"], []);
                 colSep.style.width =
                     makeEm(options.fontMetrics().doubleRuleSep);
                 cols.push(colSep);
@@ -429,7 +430,7 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
 
             if (colDescr.separator === "|" || colDescr.separator === ":") {
                 const lineType = (colDescr.separator === "|") ? "solid" : "dashed";
-                const separator = buildCommon.makeSpan(
+                const separator = makeSpan(
                     ["vertical-separator"], [], options
                 );
                 separator.style.height = makeEm(totalHeight);
@@ -458,9 +459,9 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
 
         let sepwidth;
         if (c > 0 || group.hskipBeforeAndAfter) {
-            sepwidth = utils.deflt(colDescr.pregap, arraycolsep);
+            sepwidth = colDescr.pregap ?? arraycolsep;
             if (sepwidth !== 0) {
-                colSep = buildCommon.makeSpan(["arraycolsep"], []);
+                colSep = makeSpan(["arraycolsep"], []);
                 colSep.style.width = makeEm(sepwidth);
                 cols.push(colSep);
             }
@@ -479,30 +480,30 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
             col.push({type: "elem", elem: elem, shift: shift});
         }
 
-        col = buildCommon.makeVList({
+        col = makeVList({
             positionType: "individualShift",
             children: col,
         }, options);
-        col = buildCommon.makeSpan(
+        col = makeSpan(
             ["col-align-" + (colDescr.align || "c")],
             [col]);
         cols.push(col);
 
         if (c < nc - 1 || group.hskipBeforeAndAfter) {
-            sepwidth = utils.deflt(colDescr.postgap, arraycolsep);
+            sepwidth = colDescr.postgap ?? arraycolsep;
             if (sepwidth !== 0) {
-                colSep = buildCommon.makeSpan(["arraycolsep"], []);
+                colSep = makeSpan(["arraycolsep"], []);
                 colSep.style.width = makeEm(sepwidth);
                 cols.push(colSep);
             }
         }
     }
-    body = buildCommon.makeSpan(["mtable"], cols);
+    body = makeSpan(["mtable"], cols);
 
     // Add \hline(s), if any.
     if (hlines.length > 0) {
-        const line = buildCommon.makeLineSpan("hline", options, ruleThickness);
-        const dashes = buildCommon.makeLineSpan("hdashline", options,
+        const line = makeLineSpan("hline", options, ruleThickness);
+        const dashes = makeLineSpan("hdashline", options,
             ruleThickness);
         const vListElems = [{type: "elem", elem: body, shift: 0}];
         while (hlines.length > 0) {
@@ -514,21 +515,21 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
                 vListElems.push({type: "elem", elem: line, shift: lineShift});
             }
         }
-        body = buildCommon.makeVList({
+        body = makeVList({
             positionType: "individualShift",
             children: vListElems,
         }, options);
     }
 
     if (tagSpans.length === 0) {
-        return buildCommon.makeSpan(["mord"], [body], options);
+        return makeSpan(["mord"], [body], options);
     } else {
-        let eqnNumCol = buildCommon.makeVList({
+        let eqnNumCol = makeVList({
             positionType: "individualShift",
             children: tagSpans,
         }, options);
-        eqnNumCol = buildCommon.makeSpan(["tag"], [eqnNumCol], options);
-        return buildCommon.makeFragment([body, eqnNumCol]);
+        eqnNumCol = makeSpan(["tag"], [eqnNumCol], options);
+        return makeFragment([body, eqnNumCol]);
     }
 };
 
@@ -540,13 +541,13 @@ const alignMap = {
 
 const mathmlBuilder: MathMLBuilder<"array"> = function(group, options) {
     const tbl = [];
-    const glue = new mathMLTree.MathNode("mtd", [], ["mtr-glue"]);
-    const tag = new mathMLTree.MathNode("mtd", [], ["mml-eqn-num"]);
+    const glue = new MathNode("mtd", [], ["mtr-glue"]);
+    const tag = new MathNode("mtd", [], ["mml-eqn-num"]);
     for (let i = 0; i < group.body.length; i++) {
         const rw = group.body[i];
         const row = [];
         for (let j = 0; j < rw.length; j++) {
-            row.push(new mathMLTree.MathNode("mtd",
+            row.push(new MathNode("mtd",
                 [mml.buildGroup(rw[j], options)]));
         }
         if (group.tags && group.tags[i]) {
@@ -558,9 +559,9 @@ const mathmlBuilder: MathMLBuilder<"array"> = function(group, options) {
                 row.push(tag);
             }
         }
-        tbl.push(new mathMLTree.MathNode("mtr", row));
+        tbl.push(new MathNode("mtr", row));
     }
-    let table = new mathMLTree.MathNode("mtable", tbl);
+    let table = new MathNode("mtable", tbl);
 
     // Set column alignment, row spacing, column spacing, and
     // array lines by setting attributes on the table element.
@@ -666,13 +667,13 @@ const mathmlBuilder: MathMLBuilder<"array"> = function(group, options) {
     }
 
     if (menclose !== "") {
-        table = new mathMLTree.MathNode("menclose", [table]);
+        table = new MathNode("menclose", [table]);
         table.setAttribute("notation", menclose.trim());
     }
 
     if (group.arraystretch && group.arraystretch < 1) {
         // A small array. Wrap in scriptstyle so row gap is not too large.
-        table = new mathMLTree.MathNode("mstyle", [table]);
+        table = new MathNode("mstyle", [table]);
         table.setAttribute("scriptlevel", "1");
     }
 
@@ -681,11 +682,11 @@ const mathmlBuilder: MathMLBuilder<"array"> = function(group, options) {
 
 // Convenience function for align, align*, aligned, alignat, alignat*, alignedat.
 const alignedHandler = function(context, args) {
-    if (context.envName.indexOf("ed") === -1) {
+    if (!context.envName.includes("ed")) {
         validateAmsEnvironmentContext(context);
     }
     const cols = [];
-    const separationType = context.envName.indexOf("at") > -1 ? "alignat" : "align";
+    const separationType = context.envName.includes("at") ? "alignat" : "align";
     const isSplit = context.envName === "split";
     const res = parseArray(context.parser,
         {
@@ -789,7 +790,7 @@ defineEnvironment({
         const cols = colalign.map(function(nde) {
             const node = assertSymbolNodeType(nde);
             const ca = node.text;
-            if ("lcr".indexOf(ca) !== -1) {
+            if ("lcr".includes(ca)) {
                 return {
                     type: "align",
                     align: ca,
@@ -865,7 +866,7 @@ defineEnvironment({
                 parser.consume();
                 parser.consumeSpaces();
                 colAlign = parser.fetch().text;
-                if ("lcr".indexOf(colAlign) === -1) {
+                if (!"lcr".includes(colAlign)) {
                     throw new ParseError("Expected l or c or r", parser.nextToken);
                 }
                 parser.consume();
@@ -926,7 +927,7 @@ defineEnvironment({
             const node = assertSymbolNodeType(nde);
             const ca = node.text;
             // {subarray} only recognizes "l" & "c"
-            if ("lc".indexOf(ca) !== -1) {
+            if ("lc".includes(ca)) {
                 return {
                     type: "align",
                     align: ca,
@@ -994,8 +995,8 @@ defineEnvironment({
             type: "leftright",
             mode: context.mode,
             body: [res],
-            left: context.envName.indexOf("r") > -1 ? "." : "\\{",
-            right: context.envName.indexOf("r") > -1 ? "\\}" : ".",
+            left: context.envName.includes("r") ? "." : "\\{",
+            right: context.envName.includes("r") ? "\\}" : ".",
             rightColor: undefined,
         };
     },
@@ -1030,7 +1031,7 @@ defineEnvironment({
         numArgs: 0,
     },
     handler(context) {
-        if (["gather", "gather*"].includes(context.envName)) {
+        if (gatherEnvironments.has(context.envName)) {
             validateAmsEnvironmentContext(context);
         }
         const res = {

package/src/environments/cd.js

@@ -1,7 +1,7 @@
 // @flow
-import buildCommon from "../buildCommon";
+import {wrapFragment} from "../buildCommon";
 import defineFunction from "../defineFunction";
-import mathMLTree from "../mathMLTree";
+import {MathNode} from "../mathMLTree";
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
 import {assertSymbolNodeType} from "../parseNode";
@@ -141,10 +141,10 @@ export function parseCD(parser: Parser): ParseNode<"array"> {
                 labels[1] = {type: "ordgroup", mode: "math", body: []};
 
                 // Process the arrow.
-                if ("=|.".indexOf(arrowChar) > -1) {
+                if ("=|.".includes(arrowChar)) {
                     // Three "arrows", ``@=`, `@|`, and `@.`, do not take labels.
                     // Do nothing here.
-                } else if ("<>AV".indexOf(arrowChar) > -1) {
+                } else if ("<>AV".includes(arrowChar)) {
                     // Four arrows, `@>>>`, `@<<<`, `@AAA`, and `@VVV`, each take
                     // two optional labels. E.g. the right-point arrow syntax is
                     // really:  @>{optional label}>{optional label}>
@@ -255,7 +255,7 @@ defineFunction({
     },
     htmlBuilder(group, options) {
         const newOptions = options.havingStyle(options.style.sup());
-        const label = buildCommon.wrapFragment(
+        const label = wrapFragment(
             html.buildGroup(group.label, newOptions, options), options);
         label.classes.push("cd-label-" + group.side);
         label.style.bottom = makeEm(0.8 - label.depth);
@@ -266,9 +266,9 @@ defineFunction({
         return label;
     },
     mathmlBuilder(group, options) {
-        let label = new mathMLTree.MathNode("mrow",
+        let label = new MathNode("mrow",
             [mml.buildGroup(group.label, options)]);
-        label = new mathMLTree.MathNode("mpadded", [label]);
+        label = new MathNode("mpadded", [label]);
         label.setAttribute("width", "0");
         if (group.side === "left") {
             label.setAttribute("lspace", "-1width");
@@ -276,7 +276,7 @@ defineFunction({
         // We have to guess at vertical alignment. We know the arrow is 1.8em tall,
         // But we don't know the height or depth of the label.
         label.setAttribute("voffset", "0.7em");
-        label = new mathMLTree.MathNode("mstyle", [label]);
+        label = new MathNode("mstyle", [label]);
         label.setAttribute("displaystyle", "false");
         label.setAttribute("scriptlevel", "1");
         return label;
@@ -300,14 +300,14 @@ defineFunction({
         // Wrap the vertical arrow and its labels.
         // The parent gets position: relative. The child gets position: absolute.
         // So CSS can locate the label correctly.
-        const parent = buildCommon.wrapFragment(
+        const parent = wrapFragment(
             html.buildGroup(group.fragment, options), options
         );
         parent.classes.push("cd-vert-arrow");
         return parent;
     },
     mathmlBuilder(group, options) {
-        return new mathMLTree.MathNode("mrow",
+        return new MathNode("mrow",
         [mml.buildGroup(group.fragment, options)]);
     },
 });