@rse/ase 0.0.42 → 0.0.43

package/plugin/node_modules/katex/src/environments/array.ts

@@ -1,1136 +0,0 @@
-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 {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 * as html from "../buildHTML";
-import * as mml from "../buildMathML";
-
-import type Parser from "../Parser";
-import type {ParseNode, AnyParseNode} from "../parseNode";
-import type {StyleStr, Mode} from "../types";
-import type {HtmlBuilder, MathMLBuilder} from "../defineFunction";
-import type {HtmlDomNode} from "../domTree";
-
-type EnvContextLike = {
-    parser: Parser;
-    envName: string;
-    mode: Mode;
-};
-
-// Data stored in the ParseNode associated with the environment.
-export type AlignSpec = {type: "separator", separator: string} | {
-    type: "align";
-    align: string;
-    pregap?: number;
-    postgap?: number;
-};
-
-// Type to indicate column separation in MathML
-export type ColSeparationType = "align" | "alignat" | "gather" | "small" | "CD";
-
-// Helper functions
-function getHLines(parser: Parser): boolean[] {
-    // Return an array. The array length = number of hlines.
-    // Each element in the array tells if the line is dashed.
-    const hlineInfo = [];
-    parser.consumeSpaces();
-    let nxt = parser.fetch().text;
-    if (nxt === "\\relax") { // \relax is an artifact of the \cr macro below
-        parser.consume();
-        parser.consumeSpaces();
-        nxt = parser.fetch().text;
-    }
-    while (nxt === "\\hline" || nxt === "\\hdashline") {
-        parser.consume();
-        hlineInfo.push(nxt === "\\hdashline");
-        parser.consumeSpaces();
-        nxt = parser.fetch().text;
-    }
-    return hlineInfo;
-}
-
-const validateAmsEnvironmentContext = (context: EnvContextLike) => {
-    const settings = context.parser.settings;
-    if (!settings.displayMode) {
-        throw new ParseError(`{${context.envName}} can be used only in` +
-            ` display mode.`);
-    }
-};
-
-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: string): boolean | null | undefined {
-    if (!name.includes("ed")) {
-        return !name.includes("*");
-    }
-    // return undefined;
-}
-
-/**
- * Parse the body of the environment, with rows delimited by \\ and
- * columns delimited by &, and create a nested list in row-major order
- * with one group per cell.  If given an optional argument style
- * ("text", "display", etc.), then each cell is cast into that style.
- */
-function parseArray(
-    parser: Parser,
-    {
-        hskipBeforeAndAfter,
-        addJot,
-        cols,
-        arraystretch,
-        colSeparationType,
-        autoTag,
-        singleRow,
-        emptySingleRow,
-        maxNumCols,
-        leqno,
-    }: {
-        hskipBeforeAndAfter?: boolean;
-        addJot?: boolean;
-        cols?: AlignSpec[];
-        arraystretch?: number;
-        colSeparationType?: ColSeparationType;
-        autoTag?: boolean | null | undefined;
-        singleRow?: boolean;
-        emptySingleRow?: boolean;
-        maxNumCols?: number;
-        leqno?: boolean;
-    },
-    style: StyleStr,
-): ParseNode<"array"> {
-    parser.gullet.beginGroup();
-    if (!singleRow) {
-        // \cr is equivalent to \\ without the optional size argument (see below)
-        // TODO: provide helpful error when \cr is used outside array environment
-        parser.gullet.macros.set("\\cr", "\\\\\\relax");
-    }
-
-    // Get current arraystretch if it's not set by the environment
-    if (!arraystretch) {
-        const stretch = parser.gullet.expandMacroAsText("\\arraystretch");
-        if (stretch == null) {
-            // Default \arraystretch from lttab.dtx
-            arraystretch = 1;
-        } else {
-            arraystretch = parseFloat(stretch);
-            if (!arraystretch || arraystretch < 0) {
-                throw new ParseError(`Invalid \\arraystretch: ${stretch}`);
-            }
-        }
-    }
-
-    // Start group for first cell
-    parser.gullet.beginGroup();
-
-    let row: AnyParseNode[] = [];
-    const body: AnyParseNode[][] = [row];
-    const rowGaps = [];
-    const hLinesBeforeRow = [];
-    const tags: Array<AnyParseNode[] | boolean> | undefined =
-        (autoTag != null ? [] : undefined);
-
-    // amsmath uses \global\@eqnswtrue and \global\@eqnswfalse to represent
-    // whether this row should have an equation number.  Simulate this with
-    // a \@eqnsw macro set to 1 or 0.
-    function beginRow() {
-        if (autoTag) {
-            parser.gullet.macros.set("\\@eqnsw", "1", true);
-        }
-    }
-    function endRow() {
-        if (tags) {
-            if (parser.gullet.macros.get("\\df@tag")) {
-                tags.push(parser.subparse([new Token("\\df@tag")]));
-                parser.gullet.macros.set("\\df@tag", undefined, true);
-            } else {
-                tags.push(Boolean(autoTag) &&
-                    parser.gullet.macros.get("\\@eqnsw") === "1");
-            }
-        }
-    }
-    beginRow();
-
-    // Test for \hline at the top of the array.
-    hLinesBeforeRow.push(getHLines(parser));
-
-    while (true) {
-        // Parse each cell in its own group (namespace)
-        const cellBody = parser.parseExpression(false, singleRow ? "\\end" : "\\\\");
-        parser.gullet.endGroup();
-        parser.gullet.beginGroup();
-        let cell: AnyParseNode = {
-            type: "ordgroup",
-            mode: parser.mode,
-            body: cellBody,
-        };
-        if (style) {
-            cell = {
-                type: "styling",
-                mode: parser.mode,
-                style,
-                resetFont: true,
-                body: [cell],
-            };
-        }
-        row.push(cell);
-        const next = parser.fetch().text;
-        if (next === "&") {
-            if (maxNumCols && row.length === maxNumCols) {
-                if (singleRow || colSeparationType) {
-                    // {equation} or {split}
-                    throw new ParseError("Too many tab characters: &",
-                                        parser.nextToken);
-                } else {
-                    // {array} environment
-                    parser.settings.reportNonstrict("textEnv", "Too few columns " +
-                    "specified in the {array} column argument.");
-                }
-            }
-            parser.consume();
-        } else if (next === "\\end") {
-            endRow();
-            // Arrays terminate newlines with `\crcr` which consumes a `\cr` if
-            // the last line is empty.  However, AMS environments keep the
-            // empty row if it's the only one.
-            // NOTE: Currently, `cell` is the last item added into `row`.
-            if (row.length === 1 && cell.type === "styling" &&
-                cell.body.length === 1 && cell.body[0].type === "ordgroup" &&
-                cell.body[0].body.length === 0 &&
-                (body.length > 1 || !emptySingleRow)) {
-                body.pop();
-            }
-            if (hLinesBeforeRow.length < body.length + 1) {
-                hLinesBeforeRow.push([]);
-            }
-            break;
-        } else if (next === "\\\\") {
-            parser.consume();
-            let size;
-            // \def\Let@{\let\\\math@cr}
-            // \def\math@cr{...\math@cr@}
-            // \def\math@cr@{\new@ifnextchar[\math@cr@@{\math@cr@@[\z@]}}
-            // \def\math@cr@@[#1]{...\math@cr@@@...}
-            // \def\math@cr@@@{\cr}
-            if (parser.gullet.future().text !== " ") {
-                size = parser.parseSizeGroup(true);
-            }
-            rowGaps.push(size ? size.value : null);
-            endRow();
-
-            // check for \hline(s) following the row separator
-            hLinesBeforeRow.push(getHLines(parser));
-
-            row = [];
-            body.push(row);
-            beginRow();
-        } else {
-            throw new ParseError("Expected & or \\\\ or \\cr or \\end",
-                                 parser.nextToken);
-        }
-    }
-
-    // End cell group
-    parser.gullet.endGroup();
-    // End array group defining \cr
-    parser.gullet.endGroup();
-
-    return {
-        type: "array",
-        mode: parser.mode,
-        addJot,
-        arraystretch,
-        body,
-        cols,
-        rowGaps,
-        hskipBeforeAndAfter,
-        hLinesBeforeRow,
-        colSeparationType,
-        tags,
-        leqno,
-    };
-}
-
-// Decides on a style for cells in an array according to whether the given
-// environment name starts with the letter 'd'.
-function dCellStyle(envName: string): StyleStr {
-    if (envName.slice(0, 1) === "d") {
-        return "display";
-    } else {
-        return "text";
-    }
-}
-
-type Outrow = {
-    cells: HtmlDomNode[];
-    height: number;
-    depth: number;
-    pos: number;
-};
-
-const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
-    let r;
-    let c;
-    const nr = group.body.length;
-    const hLinesBeforeRow = group.hLinesBeforeRow;
-    let nc = 0;
-    const body: Outrow[] = new Array(nr);
-    const hlines: Array<{pos: number; isDashed: boolean}> = [];
-    const ruleThickness = Math.max(
-        // From LaTeX \showthe\arrayrulewidth. Equals 0.04 em.
-        options.fontMetrics().arrayRuleWidth,
-        options.minRuleThickness, // User override.
-    );
-
-    // Horizontal spacing
-    const pt = 1 / options.fontMetrics().ptPerEm;
-    let arraycolsep = 5 * pt; // default value, i.e. \arraycolsep in article.cls
-    if (group.colSeparationType && group.colSeparationType === "small") {
-        // We're in a {smallmatrix}. Default column space is \thickspace,
-        // i.e. 5/18em = 0.2778em, per amsmath.dtx for {smallmatrix}.
-        // But that needs adjustment because LaTeX applies \scriptstyle to the
-        // entire array, including the colspace, but this function applies
-        // \scriptstyle only inside each element.
-        const localMultiplier = options.havingStyle(Style.SCRIPT).sizeMultiplier;
-        arraycolsep = 0.2778 * (localMultiplier / options.sizeMultiplier);
-    }
-
-    // Vertical spacing
-    const baselineskip = group.colSeparationType === "CD"
-        ? calculateSize({number: 3, unit: "ex"}, options)
-        : 12 * pt; // see size10.clo
-    // Default \jot from ltmath.dtx
-    // TODO(edemaine): allow overriding \jot via \setlength (#687)
-    const jot = 3 * pt;
-    const arrayskip = group.arraystretch * baselineskip;
-    const arstrutHeight = 0.7 * arrayskip; // \strutbox in ltfsstrc.dtx and
-    const arstrutDepth = 0.3 * arrayskip;  // \@arstrutbox in lttab.dtx
-
-    let totalHeight = 0;
-
-    // Set a position for \hline(s) at the top of the array, if any.
-    function setHLinePos(hlinesInGap: boolean[]) {
-        for (let i = 0; i < hlinesInGap.length; ++i) {
-            if (i > 0) {
-                totalHeight += 0.25;
-            }
-            hlines.push({pos: totalHeight, isDashed: hlinesInGap[i]});
-        }
-    }
-    setHLinePos(hLinesBeforeRow[0]);
-
-    for (r = 0; r < group.body.length; ++r) {
-        const inrow = group.body[r];
-        let height = arstrutHeight; // \@array adds an \@arstrut
-        let depth = arstrutDepth;   // to each tow (via the template)
-
-        if (nc < inrow.length) {
-            nc = inrow.length;
-        }
-
-        const outrow: Outrow = {
-            cells: new Array<HtmlDomNode>(inrow.length),
-            height: 0,
-            depth: 0,
-            pos: 0,
-        };
-        for (c = 0; c < inrow.length; ++c) {
-            const elt = html.buildGroup(inrow[c], options);
-            if (depth < elt.depth) {
-                depth = elt.depth;
-            }
-            if (height < elt.height) {
-                height = elt.height;
-            }
-            outrow.cells[c] = elt;
-        }
-
-        const rowGap = group.rowGaps[r];
-        let gap = 0;
-        if (rowGap) {
-            gap = calculateSize(rowGap, options);
-            if (gap > 0) { // \@argarraycr
-                gap += arstrutDepth;
-                if (depth < gap) {
-                    depth = gap; // \@xargarraycr
-                }
-                gap = 0;
-            }
-        }
-        // In AMS multiline environments such as aligned and gathered, rows
-        // correspond to lines that have additional \jot added between lines
-        // via \openup.
-        // We simulate this by adding \jot depth to each row except the last.
-        if (group.addJot && r < group.body.length - 1) {
-            depth += jot;
-        }
-
-        outrow.height = height;
-        outrow.depth = depth;
-        totalHeight += height;
-        outrow.pos = totalHeight;
-        totalHeight += depth + gap; // \@yargarraycr
-        body[r] = outrow;
-
-        // Set a position for \hline(s), if any.
-        setHLinePos(hLinesBeforeRow[r + 1]);
-    }
-
-    const offset = totalHeight / 2 + options.fontMetrics().axisHeight;
-    const colDescriptions = group.cols || [];
-    const cols: HtmlDomNode[] = [];
-    let colSep;
-    let colDescrNum;
-    const tagSpans: Array<{
-        type: "elem";
-        elem: HtmlDomNode;
-        shift: number;
-    }> = [];
-
-    if (group.tags && group.tags.some(tag => tag)) {
-        // An environment with manual tags and/or automatic equation numbers.
-        // Create node(s), the latter of which trigger CSS counter increment.
-        for (r = 0; r < nr; ++r) {
-            const rw = body[r];
-            const shift = rw.pos - offset;
-            const tag = group.tags[r];
-            let tagSpan;
-            if (tag === true) {  // automatic numbering
-                tagSpan = makeSpan(["eqn-num"], [], options);
-            } else if (tag === false) {
-                // \nonumber/\notag or starred environment
-                tagSpan = makeSpan([], [], options);
-            } else {  // manual \tag
-                tagSpan = makeSpan([],
-                    html.buildExpression(tag, options, true), options);
-            }
-            tagSpan.depth = rw.depth;
-            tagSpan.height = rw.height;
-            tagSpans.push({type: "elem", elem: tagSpan, shift});
-        }
-    }
-
-    for (c = 0, colDescrNum = 0;
-         // Continue while either there are more columns or more column
-         // descriptions, so trailing separators don't get lost.
-         c < nc || colDescrNum < colDescriptions.length;
-         ++c, ++colDescrNum) {
-        let colDescr: AlignSpec | undefined = colDescriptions[colDescrNum];
-
-        let firstSeparator = true;
-        while (colDescr?.type === "separator") {
-            // If there is more than one separator in a row, add a space
-            // between them.
-            if (!firstSeparator) {
-                colSep = makeSpan(["arraycolsep"], []);
-                colSep.style.width =
-                    makeEm(options.fontMetrics().doubleRuleSep);
-                cols.push(colSep);
-            }
-
-            if (colDescr.separator === "|" || colDescr.separator === ":") {
-                const lineType = colDescr.separator === "|" ? "solid" : "dashed";
-                const separator = makeSpan(["vertical-separator"], [], options);
-                separator.style.height = makeEm(totalHeight);
-                separator.style.borderRightWidth = makeEm(ruleThickness);
-                separator.style.borderRightStyle = lineType;
-                separator.style.margin = `0 ${makeEm(-ruleThickness / 2)}`;
-                const shift = totalHeight - offset;
-                if (shift) {
-                    separator.style.verticalAlign = makeEm(-shift);
-                }
-
-                cols.push(separator);
-            } else {
-                throw new ParseError(
-                    "Invalid separator type: " + colDescr.separator);
-            }
-
-            colDescrNum++;
-            colDescr = colDescriptions[colDescrNum];
-            firstSeparator = false;
-        }
-
-        if (c >= nc) {
-            continue;
-        }
-
-        let sepwidth;
-        if (c > 0 || group.hskipBeforeAndAfter) {
-            sepwidth = colDescr?.pregap ?? arraycolsep;
-            if (sepwidth !== 0) {
-                colSep = makeSpan(["arraycolsep"], []);
-                colSep.style.width = makeEm(sepwidth);
-                cols.push(colSep);
-            }
-        }
-
-        const colElems: Array<{
-            type: "elem";
-            elem: HtmlDomNode;
-            shift: number;
-        }> = [];
-        for (r = 0; r < nr; ++r) {
-            const row = body[r];
-            const elem = row.cells[c];
-            if (!elem) {
-                continue;
-            }
-            const shift = row.pos - offset;
-            elem.depth = row.depth;
-            elem.height = row.height;
-            colElems.push({type: "elem", elem: elem, shift: shift});
-        }
-
-        const colVList = makeVList({
-            positionType: "individualShift",
-            children: colElems,
-        }, options);
-        const colSpan = makeSpan(
-            ["col-align-" + (colDescr?.align || "c")],
-            [colVList],
-        );
-        cols.push(colSpan);
-
-        if (c < nc - 1 || group.hskipBeforeAndAfter) {
-            sepwidth = colDescr?.postgap ?? arraycolsep;
-            if (sepwidth !== 0) {
-                colSep = makeSpan(["arraycolsep"], []);
-                colSep.style.width = makeEm(sepwidth);
-                cols.push(colSep);
-            }
-        }
-    }
-
-    let tableBody: HtmlDomNode = makeSpan(["mtable"], cols);
-
-    // Add \hline(s), if any.
-    if (hlines.length > 0) {
-        const line = makeLineSpan("hline", options, ruleThickness);
-        const dashes = makeLineSpan("hdashline", options, ruleThickness);
-        const vListElems = [{type: "elem" as const, elem: tableBody, shift: 0}];
-        while (hlines.length > 0) {
-            const hline = hlines.pop()!;
-            const lineShift = hline.pos - offset;
-            if (hline.isDashed) {
-                vListElems.push({type: "elem" as const, elem: dashes, shift: lineShift});
-            } else {
-                vListElems.push({type: "elem" as const, elem: line, shift: lineShift});
-            }
-        }
-
-        tableBody = makeVList({
-            positionType: "individualShift",
-            children: vListElems,
-        }, options);
-    }
-
-    if (tagSpans.length === 0) {
-        return makeSpan(["mord"], [tableBody], options);
-    } else {
-        const eqnNumCol = makeVList({
-            positionType: "individualShift",
-            children: tagSpans,
-        }, options);
-        const tagCol = makeSpan(["tag"], [eqnNumCol], options);
-        return makeFragment([tableBody, tagCol]);
-    }
-};
-
-const alignMap: Record<string, string> = {
-    c: "center ",
-    l: "left ",
-    r: "right ",
-};
-
-const mathmlBuilder: MathMLBuilder<"array"> = function(group, options) {
-    const tbl = [];
-    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 MathNode("mtd",
-                [mml.buildGroup(rw[j], options)]));
-        }
-        if (group.tags && group.tags[i]) {
-            row.unshift(glue);
-            row.push(glue);
-            if (group.leqno) {
-                row.unshift(tag);
-            } else {
-                row.push(tag);
-            }
-        }
-        tbl.push(new MathNode("mtr", row));
-    }
-    let table = new MathNode("mtable", tbl);
-
-    // Set column alignment, row spacing, column spacing, and
-    // array lines by setting attributes on the table element.
-
-    // Set the row spacing. In MathML, we specify a gap distance.
-    // We do not use rowGap[] because MathML automatically increases
-    // cell height with the height/depth of the element content.
-
-    // LaTeX \arraystretch multiplies the row baseline-to-baseline distance.
-    // We simulate this by adding (arraystretch - 1)em to the gap. This
-    // does a reasonable job of adjusting arrays containing 1 em tall content.
-
-    // The 0.16 and 0.09 values are found empirically. They produce an array
-    // similar to LaTeX and in which content does not interfere with \hlines.
-    const gap = (group.arraystretch === 0.5)
-        ? 0.1  // {smallmatrix}, {subarray}
-        : 0.16 + group.arraystretch - 1 + (group.addJot ? 0.09 : 0);
-    table.setAttribute("rowspacing", makeEm(gap));
-
-    // MathML table lines go only between cells.
-    // To place a line on an edge we'll use <menclose>, if necessary.
-    let menclose = "";
-    let align = "";
-
-    if (group.cols && group.cols.length > 0) {
-        // Find column alignment, column spacing, and  vertical lines.
-        const cols = group.cols;
-        let columnLines = "";
-        let prevTypeWasAlign = false;
-        let iStart = 0;
-        let iEnd = cols.length;
-
-        if (cols[0].type === "separator") {
-            menclose += "top ";
-            iStart = 1;
-        }
-        if (cols[cols.length - 1].type === "separator") {
-            menclose += "bottom ";
-            iEnd -= 1;
-        }
-
-        for (let i = iStart; i < iEnd; i++) {
-            const col = cols[i];
-            if (col.type === "align") {
-                align += alignMap[col.align];
-
-                if (prevTypeWasAlign) {
-                    columnLines += "none ";
-                }
-                prevTypeWasAlign = true;
-            } else if (col.type === "separator") {
-                // MathML accepts only single lines between cells.
-                // So we read only the first of consecutive separators.
-                if (prevTypeWasAlign) {
-                    columnLines += col.separator === "|" ? "solid " : "dashed ";
-                    prevTypeWasAlign = false;
-                }
-            }
-        }
-
-        table.setAttribute("columnalign", align.trim());
-
-        if (/[sd]/.test(columnLines)) {
-            table.setAttribute("columnlines", columnLines.trim());
-        }
-    }
-
-    // Set column spacing.
-    if (group.colSeparationType === "align") {
-        const cols = group.cols || [];
-        let spacing = "";
-        for (let i = 1; i < cols.length; i++) {
-            spacing += i % 2 ? "0em " : "1em ";
-        }
-        table.setAttribute("columnspacing", spacing.trim());
-    } else if (group.colSeparationType === "alignat" ||
-        group.colSeparationType === "gather") {
-        table.setAttribute("columnspacing", "0em");
-    } else if (group.colSeparationType === "small") {
-        table.setAttribute("columnspacing", "0.2778em");
-    } else if (group.colSeparationType === "CD") {
-        table.setAttribute("columnspacing", "0.5em");
-    } else {
-        table.setAttribute("columnspacing", "1em");
-    }
-
-    // Address \hline and \hdashline
-    let rowLines = "";
-    const hlines = group.hLinesBeforeRow;
-
-    menclose += hlines[0].length > 0 ? "left " : "";
-    menclose += hlines[hlines.length - 1].length > 0 ? "right " : "";
-
-    for (let i = 1; i < hlines.length - 1; i++) {
-        rowLines += (hlines[i].length === 0)
-          ? "none "
-             // MathML accepts only a single line between rows. Read one element.
-          : hlines[i][0] ? "dashed " : "solid ";
-    }
-    if (/[sd]/.test(rowLines)) {
-        table.setAttribute("rowlines", rowLines.trim());
-    }
-
-    if (menclose !== "") {
-        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 MathNode("mstyle", [table]);
-        table.setAttribute("scriptlevel", "1");
-    }
-
-    return table;
-};
-
-// Convenience function for align, align*, aligned, alignat, alignat*, alignedat.
-const alignedHandler = function(context: EnvContextLike, args: AnyParseNode[]) {
-    if (!context.envName.includes("ed")) {
-        validateAmsEnvironmentContext(context);
-    }
-    const cols: AlignSpec[] = [];
-    const separationType: ColSeparationType = context.envName.includes("at") ? "alignat" : "align";
-    const isSplit = context.envName === "split";
-    const res = parseArray(context.parser,
-        {
-            cols,
-            addJot: true,
-            autoTag: isSplit ? undefined : getAutoTag(context.envName),
-            emptySingleRow: true,
-            colSeparationType: separationType,
-            maxNumCols: isSplit ? 2 : undefined,
-            leqno: context.parser.settings.leqno,
-        },
-        "display"
-    );
-
-    // Determining number of columns.
-    // 1. If the first argument is given, we use it as a number of columns,
-    //    and makes sure that each row doesn't exceed that number.
-    // 2. Otherwise, just count number of columns = maximum number
-    //    of cells in each row ("aligned" mode -- isAligned will be true).
-    //
-    // At the same time, prepend empty group {} at beginning of every second
-    // cell in each row (starting with second cell) so that operators become
-    // binary.  This behavior is implemented in amsmath's \start@aligned.
-    let numMaths = 0;
-    let numCols = 0;
-    const emptyGroup: ParseNode<"ordgroup"> = {
-        type: "ordgroup",
-        mode: context.mode,
-        body: [],
-    };
-    if (args[0] && args[0].type === "ordgroup") {
-        let arg0 = "";
-        for (let i = 0; i < args[0].body.length; i++) {
-            const textord = assertNodeType(args[0].body[i], "textord");
-            arg0 += textord.text;
-        }
-        numMaths = Number(arg0);
-        numCols = numMaths * 2;
-    }
-    const isAligned = !numCols;
-    res.body.forEach(function(row) {
-        for (let i = 1; i < row.length; i += 2) {
-            // Modify ordgroup node within styling node
-            const styling = assertNodeType(row[i], "styling");
-            const ordgroup = assertNodeType(styling.body[0], "ordgroup");
-            ordgroup.body.unshift(emptyGroup);
-        }
-        if (!isAligned) { // Case 1
-            const curMaths = row.length / 2;
-            if (numMaths < curMaths) {
-                throw new ParseError(
-                    "Too many math in a row: " +
-                    `expected ${numMaths}, but got ${curMaths}`,
-                    row[0]);
-            }
-        } else if (numCols < row.length) { // Case 2
-            numCols = row.length;
-        }
-    });
-
-    // Adjusting alignment.
-    // In aligned mode, we add one \qquad between columns;
-    // otherwise we add nothing.
-    for (let i = 0; i < numCols; ++i) {
-        let align = "r";
-        let pregap = 0;
-        if (i % 2 === 1) {
-            align = "l";
-        } else if (i > 0 && isAligned) { // "aligned" mode.
-            pregap = 1; // add one \quad
-        }
-        cols[i] = {
-            type: "align",
-            align: align,
-            pregap: pregap,
-            postgap: 0,
-        };
-    }
-    res.colSeparationType = isAligned ? "align" : "alignat";
-    return res;
-};
-
-// Arrays are part of LaTeX, defined in lttab.dtx so its documentation
-// is part of the source2e.pdf file of LaTeX2e source documentation.
-// {darray} is an {array} environment where cells are set in \displaystyle,
-// as defined in nccmath.sty.
-defineEnvironment({
-    type: "array",
-    names: ["array", "darray"],
-    props: {
-        numArgs: 1,
-    },
-    handler(context, args) {
-        // Since no types are specified above, the two possibilities are
-        // - The argument is wrapped in {} or [], in which case Parser's
-        //   parseGroup() returns an "ordgroup" wrapping some symbol node.
-        // - The argument is a bare symbol node.
-        const symNode = checkSymbolNodeType(args[0]);
-        const colalign: AnyParseNode[] =
-            symNode ? [args[0]] : assertNodeType(args[0], "ordgroup").body;
-        const cols: AlignSpec[] = colalign.map(function(nde) {
-            const node = assertSymbolNodeType(nde);
-            const ca = node.text;
-            if ("lcr".includes(ca)) {
-                return {
-                    type: "align",
-                    align: ca,
-                };
-            } else if (ca === "|") {
-                return {
-                    type: "separator",
-                    separator: "|",
-                };
-            } else if (ca === ":") {
-                return {
-                    type: "separator",
-                    separator: ":",
-                };
-            }
-            throw new ParseError("Unknown column alignment: " + ca, nde);
-        });
-        const res: Parameters<typeof parseArray>[1] = {
-            cols,
-            hskipBeforeAndAfter: true, // \@preamble in lttab.dtx
-            maxNumCols: cols.length,
-        };
-        return parseArray(context.parser, res, dCellStyle(context.envName));
-    },
-    htmlBuilder,
-    mathmlBuilder,
-});
-
-// The matrix environments of amsmath builds on the array environment
-// of LaTeX, which is discussed above.
-// The mathtools package adds starred versions of the same environments.
-// These have an optional argument to choose left|center|right justification.
-defineEnvironment({
-    type: "array",
-    names: [
-        "matrix",
-        "pmatrix",
-        "bmatrix",
-        "Bmatrix",
-        "vmatrix",
-        "Vmatrix",
-        "matrix*",
-        "pmatrix*",
-        "bmatrix*",
-        "Bmatrix*",
-        "vmatrix*",
-        "Vmatrix*",
-    ],
-    props: {
-        numArgs: 0,
-    },
-    handler(context) {
-        const delimiters = {
-            "matrix": null,
-            "pmatrix": ["(", ")"],
-            "bmatrix": ["[", "]"],
-            "Bmatrix": ["\\{", "\\}"],
-            "vmatrix": ["|", "|"],
-            "Vmatrix": ["\\Vert", "\\Vert"],
-        }[context.envName.replace("*", "")];
-        // \hskip -\arraycolsep in amsmath
-        let colAlign = "c";
-        const payload: Parameters<typeof parseArray>[1] = {
-            hskipBeforeAndAfter: false,
-            cols: [{type: "align", align: colAlign}],
-        };
-        if (context.envName.charAt(context.envName.length - 1) === "*") {
-            // It's one of the mathtools starred functions.
-            // Parse the optional alignment argument.
-            const parser = context.parser;
-            parser.consumeSpaces();
-            if (parser.fetch().text === "[") {
-                parser.consume();
-                parser.consumeSpaces();
-                colAlign = parser.fetch().text;
-                if (!"lcr".includes(colAlign)) {
-                    throw new ParseError("Expected l or c or r", parser.nextToken);
-                }
-                parser.consume();
-                parser.consumeSpaces();
-                parser.expect("]");
-                parser.consume();
-                payload.cols = [{type: "align", align: colAlign}];
-            }
-        }
-        const res: ParseNode<"array"> =
-            parseArray(context.parser, payload, dCellStyle(context.envName));
-        // Populate cols with the correct number of column alignment specs.
-        const numCols = Math.max(0, ...res.body.map(row => row.length));
-        res.cols = new Array(numCols).fill(
-            {type: "align", align: colAlign}
-        );
-        return delimiters ? {
-            type: "leftright",
-            mode: context.mode,
-            body: [res],
-            left: delimiters[0],
-            right: delimiters[1],
-            rightColor: undefined, // \right uninfluenced by \color in array
-        } : res;
-    },
-    htmlBuilder,
-    mathmlBuilder,
-});
-
-defineEnvironment({
-    type: "array",
-    names: ["smallmatrix"],
-    props: {
-        numArgs: 0,
-    },
-    handler(context) {
-        const payload: Parameters<typeof parseArray>[1] = {arraystretch: 0.5};
-        const res = parseArray(context.parser, payload, "script");
-        res.colSeparationType = "small";
-        return res;
-    },
-    htmlBuilder,
-    mathmlBuilder,
-});
-
-defineEnvironment({
-    type: "array",
-    names: ["subarray"],
-    props: {
-        numArgs: 1,
-    },
-    handler(context, args) {
-        // Parsing of {subarray} is similar to {array}
-        const symNode = checkSymbolNodeType(args[0]);
-        const colalign: AnyParseNode[] =
-            symNode ? [args[0]] : assertNodeType(args[0], "ordgroup").body;
-        const cols: AlignSpec[] = colalign.map(function(nde) {
-            const node = assertSymbolNodeType(nde);
-            const ca = node.text;
-            // {subarray} only recognizes "l" & "c"
-            if ("lc".includes(ca)) {
-                return {
-                    type: "align",
-                    align: ca,
-                };
-            }
-            throw new ParseError("Unknown column alignment: " + ca, nde);
-        });
-        if (cols.length > 1) {
-            throw new ParseError("{subarray} can contain only one column");
-        }
-        const payload: Parameters<typeof parseArray>[1] = {
-            cols,
-            hskipBeforeAndAfter: false,
-            arraystretch: 0.5,
-        };
-        const res = parseArray(context.parser, payload, "script");
-        if (res.body.length > 0 &&  res.body[0].length > 1) {
-            throw new ParseError("{subarray} can contain only one column");
-        }
-        return res;
-    },
-    htmlBuilder,
-    mathmlBuilder,
-});
-
-// A cases environment (in amsmath.sty) is almost equivalent to
-// \def\arraystretch{1.2}%
-// \left\{\begin{array}{@{}l@{\quad}l@{}} … \end{array}\right.
-// {dcases} is a {cases} environment where cells are set in \displaystyle,
-// as defined in mathtools.sty.
-// {rcases} is another mathtools environment. It's brace is on the right side.
-defineEnvironment({
-    type: "array",
-    names: [
-        "cases",
-        "dcases",
-        "rcases",
-        "drcases",
-    ],
-    props: {
-        numArgs: 0,
-    },
-    handler(context) {
-        const payload: Parameters<typeof parseArray>[1] = {
-            arraystretch: 1.2,
-            cols: [{
-                type: "align",
-                align: "l",
-                pregap: 0,
-                // TODO(kevinb) get the current style.
-                // For now we use the metrics for TEXT style which is what we were
-                // doing before.  Before attempting to get the current style we
-                // should look at TeX's behavior especially for \over and matrices.
-                postgap: 1.0, /* 1em quad */
-            }, {
-                type: "align",
-                align: "l",
-                pregap: 0,
-                postgap: 0,
-            }],
-        };
-        const res: ParseNode<"array"> =
-            parseArray(context.parser, payload, dCellStyle(context.envName));
-        return {
-            type: "leftright",
-            mode: context.mode,
-            body: [res],
-            left: context.envName.includes("r") ? "." : "\\{",
-            right: context.envName.includes("r") ? "\\}" : ".",
-            rightColor: undefined,
-        };
-    },
-    htmlBuilder,
-    mathmlBuilder,
-});
-
-// In the align environment, one uses ampersands, &, to specify number of
-// columns in each row, and to locate spacing between each column.
-// align gets automatic numbering. align* and aligned do not.
-// The alignedat environment can be used in math mode.
-// Note that we assume \nomallineskiplimit to be zero,
-// so that \strut@ is the same as \strut.
-defineEnvironment({
-    type: "array",
-    names: ["align", "align*", "aligned", "split"],
-    props: {
-        numArgs: 0,
-    },
-    handler: alignedHandler,
-    htmlBuilder,
-    mathmlBuilder,
-});
-
-// A gathered environment is like an array environment with one centered
-// column, but where rows are considered lines so get \jot line spacing
-// and contents are set in \displaystyle.
-defineEnvironment({
-    type: "array",
-    names: ["gathered", "gather", "gather*"],
-    props: {
-        numArgs: 0,
-    },
-    handler(context) {
-        if (gatherEnvironments.has(context.envName)) {
-            validateAmsEnvironmentContext(context);
-        }
-        const res: Parameters<typeof parseArray>[1] = {
-            cols: [{
-                type: "align",
-                align: "c",
-            }],
-            addJot: true,
-            colSeparationType: "gather",
-            autoTag: getAutoTag(context.envName),
-            emptySingleRow: true,
-            leqno: context.parser.settings.leqno,
-        };
-        return parseArray(context.parser, res, "display");
-    },
-    htmlBuilder,
-    mathmlBuilder,
-});
-
-// alignat environment is like an align environment, but one must explicitly
-// specify maximum number of columns in each row, and can adjust spacing between
-// each columns.
-defineEnvironment({
-    type: "array",
-    names: ["alignat", "alignat*", "alignedat"],
-    props: {
-        numArgs: 1,
-    },
-    handler: alignedHandler,
-    htmlBuilder,
-    mathmlBuilder,
-});
-
-defineEnvironment({
-    type: "array",
-    names: ["equation", "equation*"],
-    props: {
-        numArgs: 0,
-    },
-    handler(context) {
-        validateAmsEnvironmentContext(context);
-        const res: Parameters<typeof parseArray>[1] = {
-            autoTag: getAutoTag(context.envName),
-            emptySingleRow: true,
-            singleRow: true,
-            maxNumCols: 1,
-            leqno: context.parser.settings.leqno,
-        };
-        return parseArray(context.parser, res, "display");
-    },
-    htmlBuilder,
-    mathmlBuilder,
-});
-
-defineEnvironment({
-    type: "array",
-    names: ["CD"],
-    props: {
-        numArgs: 0,
-    },
-    handler(context) {
-        validateAmsEnvironmentContext(context);
-        return parseCD(context.parser);
-    },
-    htmlBuilder,
-    mathmlBuilder,
-});
-
-defineMacro("\\nonumber", "\\gdef\\@eqnsw{0}");
-defineMacro("\\notag", "\\nonumber");
-
-// Catch \hline outside array environment
-defineFunction({
-    type: "text", // Doesn't matter what this is.
-    names: ["\\hline", "\\hdashline"],
-    props: {
-        numArgs: 0,
-        allowedInText: true,
-        allowedInMath: true,
-    },
-    handler(context, args) {
-        throw new ParseError(
-            `${context.funcName} valid only within array environment`);
-    },
-});