temml 0.10.32 → 0.10.34

package/dist/temml.mjs

@@ -499,6 +499,40 @@ let TextNode$1 = class TextNode {
   }
 };
 
+// Create an <a href="…"> node.
+class AnchorNode {
+  constructor(href, classes, children) {
+    this.href = href;
+    this.classes = classes;
+    this.children = children || [];
+  }
+
+  toNode() {
+    const node = document.createElement("a");
+    node.setAttribute("href", this.href);
+    if (this.classes.length > 0) {
+      node.className = createClass(this.classes);
+    }
+    for (let i = 0; i < this.children.length; i++) {
+      node.appendChild(this.children[i].toNode());
+    }
+    return node
+  }
+
+  toMarkup() {
+    let markup = `<a href='${utils.escape(this.href)}'`;
+    if (this.classes.length > 0) {
+      markup += ` class="${utils.escape(createClass(this.classes))}"`;
+    }
+    markup += ">";
+    for (let i = 0; i < this.children.length; i++) {
+      markup += this.children[i].toMarkup();
+    }
+    markup += "</a>";
+    return markup
+  }
+}
+
 /*
  * This node represents an image embed (<img>) element.
  */
@@ -573,6 +607,7 @@ class MathNode {
     this.children = children || [];
     this.classes = classes || [];
     this.style = style || {};   // Used for <mstyle> elements
+    this.label = "";
   }
 
   /**
@@ -590,6 +625,10 @@ class MathNode {
     return this.attributes[name];
   }
 
+  setLabel(value) {
+    this.label = value;
+  }
+
   /**
    * Converts the math node into a MathML-namespaced DOM element.
    */
@@ -1506,7 +1545,7 @@ defineSymbol(math, mathord, "\u03db", "\\stigma", true);
 defineSymbol(math, mathord, "\u2aeb", "\\Bot");
 defineSymbol(math, bin, "\u2217", "\u2217", true);
 defineSymbol(math, bin, "+", "+");
-defineSymbol(math, bin, "*", "*");
+defineSymbol(math, bin, "\u2217", "*");
 defineSymbol(math, bin, "\u2044", "/", true);
 defineSymbol(math, bin, "\u2044", "\u2044");
 defineSymbol(math, bin, "\u2212", "-", true);
@@ -1528,7 +1567,7 @@ defineSymbol(math, open, "\u27e8", "\\langle", true);
 defineSymbol(math, open, "\u27ea", "\\lAngle", true);
 defineSymbol(math, open, "\u2989", "\\llangle", true);
 defineSymbol(math, open, "|", "\\lvert");
-defineSymbol(math, open, "\u2016", "\\lVert");
+defineSymbol(math, open, "\u2016", "\\lVert", true);
 defineSymbol(math, textord, "!", "\\oc"); // cmll package
 defineSymbol(math, textord, "?", "\\wn");
 defineSymbol(math, textord, "\u2193", "\\shpos");
@@ -1692,7 +1731,7 @@ defineSymbol(math, inner, "\u22f0", "\\iddots", true);
 defineSymbol(math, inner, "\u22ef", "\\@cdots", true);
 defineSymbol(math, inner, "\u22f1", "\\ddots", true);
 defineSymbol(math, textord, "\u22ee", "\\varvdots"); // \vdots is a macro
-defineSymbol(text, textord, "\u22ee", "\\textvdots");
+defineSymbol(text, textord, "\u22ee", "\\varvdots");
 defineSymbol(math, accent, "\u02ca", "\\acute");
 defineSymbol(math, accent, "\u0060", "\\grave");
 defineSymbol(math, accent, "\u00a8", "\\ddot");
@@ -2145,61 +2184,6 @@ const consolidateText = mrow => {
   }
 };
 
-const numberRegEx$1 = /^[0-9]$/;
-const isDotOrComma = (node, followingNode) => {
-  return ((node.type === "textord" && node.text === ".") ||
-    (node.type === "atom" && node.text === ",")) &&
-    // Don't consolidate if there is a space after the comma.
-    node.loc && followingNode.loc && node.loc.end === followingNode.loc.start
-};
-const consolidateNumbers = expression => {
-  // Consolidate adjacent numbers. We want to return <mn>1,506.3</mn>,
-  // not <mn>1</mn><mo>,</mo><mn>5</mn><mn>0</mn><mn>6</mn><mi>.</mi><mn>3</mn>
-  if (expression.length < 2) { return }
-  const nums = [];
-  let inNum = false;
-  // Find adjacent numerals
-  for (let i = 0; i < expression.length; i++) {
-    const node = expression[i];
-    if (node.type === "textord" && numberRegEx$1.test(node.text)) {
-      if (!inNum) { nums.push({ start: i }); }
-      inNum = true;
-    } else {
-      if (inNum) { nums[nums.length - 1].end = i - 1; }
-      inNum = false;
-    }
-  }
-  if (inNum) { nums[nums.length - 1].end = expression.length - 1; }
-
-  // Determine if numeral groups are separated by a comma or dot.
-  for (let i = nums.length - 1; i > 0; i--) {
-    if (nums[i - 1].end === nums[i].start - 2 &&
-      isDotOrComma(expression[nums[i].start - 1], expression[nums[i].start])) {
-      // Merge the two groups.
-      nums[i - 1].end = nums[i].end;
-      nums.splice(i, 1);
-    }
-  }
-
-  // Consolidate the number nodes
-  for (let i = nums.length - 1; i >= 0; i--) {
-    for (let j = nums[i].start + 1; j <= nums[i].end; j++) {
-      expression[nums[i].start].text += expression[j].text;
-    }
-    expression.splice(nums[i].start + 1, nums[i].end - nums[i].start);
-    // Check if the <mn> is followed by a numeric base in a supsub, e.g. the "3" in 123^4
-    // If so, merge the first <mn> into the base.
-    if (expression.length > nums[i].start + 1) {
-      const nextTerm = expression[nums[i].start + 1];
-      if (nextTerm.type === "supsub" && nextTerm.base && nextTerm.base.type === "textord" &&
-          numberRegEx$1.test(nextTerm.base.text)) {
-        nextTerm.base.text = expression[nums[i].start].text + nextTerm.base.text;
-        expression.splice(nums[i].start, 1);
-      }
-    }
-  }
-};
-
 /**
  * Wrap the given array of nodes in an <mrow> node if needed, i.e.,
  * unless the array has length 1.  Always returns a single node.
@@ -2222,6 +2206,39 @@ const makeRow = function(body, semisimple = false) {
   return new mathMLTree.MathNode("mrow", body);
 };
 
+/**
+ * Check for <mi>.</mi> which is how a dot renders in MathML,
+ * or <mo separator="true" lspace="0em" rspace="0em">,</mo>
+ * which is how a braced comma {,} renders in MathML
+ */
+function isNumberPunctuation(group) {
+  if (!group) {
+    return false
+  }
+  if (group.type === 'mi' && group.children.length === 1) {
+    const child = group.children[0];
+    return child instanceof TextNode && child.text === '.'
+  } else if (group.type === "mtext" && group.children.length === 1) {
+    const child = group.children[0];
+    return child instanceof TextNode && child.text === '\u2008' // punctuation space
+  } else if (group.type === 'mo' && group.children.length === 1 &&
+    group.getAttribute('separator') === 'true' &&
+    group.getAttribute('lspace') === '0em' &&
+    group.getAttribute('rspace') === '0em') {
+    const child = group.children[0];
+    return child instanceof TextNode && child.text === ','
+  } else {
+    return false
+  }
+}
+const isComma = (expression, i) => {
+  const node = expression[i];
+  const followingNode = expression[i + 1];
+  return (node.type === "atom" && node.text === ",") &&
+    // Don't consolidate if there is a space after the comma.
+    node.loc && followingNode.loc && node.loc.end === followingNode.loc.start
+};
+
 const isRel = item => {
   return (item.type === "atom" && item.family === "rel") ||
       (item.type === "mclass" && item.mclass === "mrel")
@@ -2245,11 +2262,16 @@ const buildExpression = function(expression, style, semisimple = false) {
     return [group];
   }
 
-  consolidateNumbers(expression);
-
   const groups = [];
+  const groupArray = [];
+  let lastGroup;
   for (let i = 0; i < expression.length; i++) {
-    const group = buildGroup$1(expression[i], style);
+    groupArray.push(buildGroup$1(expression[i], style));
+  }
+
+  for (let i = 0; i < groupArray.length; i++) {
+    const group = groupArray[i];
+
     // Suppress spacing between adjacent relations
     if (i < expression.length - 1 && isRel(expression[i]) && isRel(expression[i + 1])) {
       group.setAttribute("rspace", "0em");
@@ -2257,9 +2279,39 @@ const buildExpression = function(expression, style, semisimple = false) {
     if (i > 0 && isRel(expression[i]) && isRel(expression[i - 1])) {
       group.setAttribute("lspace", "0em");
     }
+
+    // Concatenate numbers
+    if (group.type === 'mn' && lastGroup && lastGroup.type === 'mn') {
+      // Concatenate <mn>...</mn> followed by <mi>.</mi>
+      lastGroup.children.push(...group.children);
+      continue
+    } else if (isNumberPunctuation(group) && lastGroup && lastGroup.type === 'mn') {
+      // Concatenate <mn>...</mn> followed by <mi>.</mi>
+      lastGroup.children.push(...group.children);
+      continue
+    } else if (lastGroup && lastGroup.type === "mn" && i < groupArray.length - 1 &&
+      groupArray[i + 1].type === "mn" && isComma(expression, i)) {
+      lastGroup.children.push(...group.children);
+      continue
+    } else if (group.type === 'mn' && isNumberPunctuation(lastGroup)) {
+      // Concatenate <mi>.</mi> followed by <mn>...</mn>
+      group.children = [...lastGroup.children, ...group.children];
+      groups.pop();
+    } else if ((group.type === 'msup' || group.type === 'msub') &&
+        group.children.length >= 1 && lastGroup &&
+        (lastGroup.type === 'mn' || isNumberPunctuation(lastGroup))) {
+      // Put preceding <mn>...</mn> or <mi>.</mi> inside base of
+      // <msup><mn>...base...</mn>...exponent...</msup> (or <msub>)
+      const base = group.children[0];
+      if (base instanceof MathNode && base.type === 'mn' && lastGroup) {
+        base.children = [...lastGroup.children, ...base.children];
+        groups.pop();
+      }
+    }
     groups.push(group);
+    lastGroup = group;
   }
-  return groups;
+  return groups
 };
 
 /**
@@ -2292,16 +2344,36 @@ const glue$1 = _ => {
   return new mathMLTree.MathNode("mtd", [], [], { padding: "0", width: "50%" })
 };
 
+const labelContainers = ["mrow", "mtd", "mtable", "mtr"];
+const getLabel = parent => {
+  for (const node of parent.children) {
+    if (node.type && labelContainers.includes(node.type)) {
+      if (node.classes && node.classes[0] === "tml-label") {
+        const label = node.label;
+        return label
+      } else {
+        const label = getLabel(node);
+        if (label) { return label }
+      }
+    } else if (!node.type) {
+      const label = getLabel(node);
+      if (label) { return label }
+    }
+  }
+};
+
 const taggedExpression = (expression, tag, style, leqno) => {
   tag = buildExpressionRow(tag[0].body, style);
   tag = consolidateText(tag);
   tag.classes.push("tml-tag");
 
+  const label = getLabel(expression); // from a \label{} function.
   expression = new mathMLTree.MathNode("mtd", [expression]);
   const rowArray = [glue$1(), expression, glue$1()];
   rowArray[leqno ? 0 : 2].classes.push(leqno ? "tml-left" : "tml-right");
   rowArray[leqno ? 0 : 2].children.push(tag);
   const mtr = new mathMLTree.MathNode("mtr", rowArray, ["tml-tageqn"]);
+  if (label) { mtr.setAttribute("id", label); }
   const table = new mathMLTree.MathNode("mtable", [mtr]);
   table.style.width = "100%";
   table.setAttribute("displaystyle", "true");
@@ -2321,6 +2393,11 @@ function buildMathML(tree, texExpression, style, settings) {
   }
 
   const expression = buildExpression(tree, style);
+
+  if (expression.length === 1 && expression[0] instanceof AnchorNode) {
+    return expression[0]
+  }
+
   const wrap = (settings.displayMode || settings.annotate) ? "none" : settings.wrap;
 
   const n1 = expression.length === 0 ? null : expression[0];
@@ -2345,6 +2422,9 @@ function buildMathML(tree, texExpression, style, settings) {
   if (settings.xml) {
     math.setAttribute("xmlns", "http://www.w3.org/1998/Math/MathML");
   }
+  if (wrapper.style.width) {
+    math.style.width = "100%";
+  }
   if (settings.displayMode) {
     math.setAttribute("display", "block");
     math.style.display = "block math"; // necessary in Chromium.
@@ -2676,12 +2756,19 @@ const padding$2 = width => {
   return node
 };
 
-const paddedNode = (group, lspace = 0.3, rspace = 0) => {
+const paddedNode = (group, lspace = 0.3, rspace = 0, mustSmash = false) => {
   if (group == null && rspace === 0) { return padding$2(lspace) }
   const row = group ? [group] : [];
   if (lspace !== 0)   { row.unshift(padding$2(lspace)); }
   if (rspace > 0) { row.push(padding$2(rspace)); }
-  return new mathMLTree.MathNode("mrow", row)
+  if (mustSmash) {
+    // Used for the bottom arrow in a {CD} environment
+    const mpadded = new mathMLTree.MathNode("mpadded", row);
+    mpadded.setAttribute("height", "0");
+    return mpadded
+  } else {
+    return new mathMLTree.MathNode("mrow", row)
+  }
 };
 
 const labelSize = (size, scriptLevel) =>  Number(size) / emScale(scriptLevel);
@@ -2721,7 +2808,8 @@ const munderoverNode = (fName, body, below, style) => {
     (body.body.body || body.body.length > 0));
   if (gotUpper) {
     let label =  buildGroup$1(body, labelStyle);
-    label = paddedNode(label, space, space);
+    const mustSmash = (fName === "\\\\cdrightarrow" || fName === "\\\\cdleftarrow");
+    label = paddedNode(label, space, space, mustSmash);
     // Since Firefox does not support minsize, stack a invisible node
     // on top of the label. Its width will serve as a min-width.
     // TODO: Refactor this after Firefox supports minsize.
@@ -3116,6 +3204,8 @@ function parseCD(parser) {
     type: "array",
     mode: "math",
     body,
+    tags: null,
+    labels: new Array(body.length + 1).fill(""),
     envClasses: ["jot", "cd"],
     cols: [],
     hLinesBeforeRow: new Array(body.length + 1).fill([])
@@ -3144,18 +3234,23 @@ defineFunction({
     };
   },
   mathmlBuilder(group, style) {
-    let label = new mathMLTree.MathNode("mrow", [buildGroup$1(group.label, style)]);
-    label = new mathMLTree.MathNode("mpadded", [label]);
-    label.setAttribute("width", "0");
-    if (group.side === "left") {
-      label.setAttribute("lspace", "-1width");
+    if (group.label.body.length === 0) {
+      return new mathMLTree.MathNode("mrow", style)  // empty label
     }
-    // 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]);
+    // Abuse an <mtable> to create vertically centered content.
+    const mtd = new mathMLTree.MathNode("mtd", [buildGroup$1(group.label, style)]);
+    mtd.style.padding = "0";
+    const mtr = new mathMLTree.MathNode("mtr", [mtd]);
+    const mtable = new mathMLTree.MathNode("mtable", [mtr]);
+    const label = new mathMLTree.MathNode("mpadded", [mtable]);
+    // Set the label width to zero so that the arrow will be centered under the corner cell.
+    label.setAttribute("width", "0");
     label.setAttribute("displaystyle", "false");
     label.setAttribute("scriptlevel", "1");
+    if (group.side === "left") {
+      label.style.display = "flex";
+      label.style.justifyContent = "flex-end";
+    }
     return label;
   }
 });
@@ -3745,10 +3840,13 @@ defineFunction({
     // replacement text, enclosed in '{' and '}' and properly nested
     const { tokens } = parser.gullet.consumeArg();
 
-    parser.gullet.macros.set(
-      name,
-      { tokens, numArgs }
-    );
+    if (!(funcName === "\\providecommand" && parser.gullet.macros.has(name))) {
+      // Ignore \providecommand
+      parser.gullet.macros.set(
+        name,
+        { tokens, numArgs }
+      );
+    }
 
     return { type: "internal", mode: parser.mode };
 
@@ -3842,6 +3940,7 @@ const delimiters = [
   "\\vert",
   "\\|",
   "\\Vert",
+  "\u2016",
   "\\uparrow",
   "\\Uparrow",
   "\\downarrow",
@@ -4347,6 +4446,75 @@ function defineEnvironment({ type, names, props, handler, mathmlBuilder }) {
   }
 }
 
+/**
+ * Lexing or parsing positional information for error reporting.
+ * This object is immutable.
+ */
+class SourceLocation {
+  constructor(lexer, start, end) {
+    this.lexer = lexer; // Lexer holding the input string.
+    this.start = start; // Start offset, zero-based inclusive.
+    this.end = end;     // End offset, zero-based exclusive.
+  }
+
+  /**
+   * Merges two `SourceLocation`s from location providers, given they are
+   * provided in order of appearance.
+   * - Returns the first one's location if only the first is provided.
+   * - Returns a merged range of the first and the last if both are provided
+   *   and their lexers match.
+   * - Otherwise, returns null.
+   */
+  static range(first, second) {
+    if (!second) {
+      return first && first.loc;
+    } else if (!first || !first.loc || !second.loc || first.loc.lexer !== second.loc.lexer) {
+      return null;
+    } else {
+      return new SourceLocation(first.loc.lexer, first.loc.start, second.loc.end);
+    }
+  }
+}
+
+/**
+ * Interface required to break circular dependency between Token, Lexer, and
+ * ParseError.
+ */
+
+/**
+ * The resulting token returned from `lex`.
+ *
+ * It consists of the token text plus some position information.
+ * The position information is essentially a range in an input string,
+ * but instead of referencing the bare input string, we refer to the lexer.
+ * That way it is possible to attach extra metadata to the input string,
+ * like for example a file name or similar.
+ *
+ * The position information is optional, so it is OK to construct synthetic
+ * tokens if appropriate. Not providing available position information may
+ * lead to degraded error reporting, though.
+ */
+class Token {
+  constructor(
+    text, // the text of this token
+    loc
+  ) {
+    this.text = text;
+    this.loc = loc;
+  }
+
+  /**
+   * Given a pair of tokens (this and endToken), compute a `Token` encompassing
+   * the whole input range enclosed by these two.
+   */
+  range(
+    endToken, // last token of the range, inclusive
+    text // the text of the newly constructed token
+  ) {
+    return new Token(text, SourceLocation.range(this, endToken));
+  }
+}
+
 // In TeX, there are actually three sets of dimensions, one for each of
 // textstyle, scriptstyle, and scriptscriptstyle.  These are
 // provided in the the arrays below, in that order.
@@ -4611,7 +4779,7 @@ defineMacro("\\underbar", "\\underline{\\text{#1}}");
 // \kern6\p@\hbox{.}\hbox{.}\hbox{.}}}
 // We'll call \varvdots, which gets a glyph from symbols.js.
 // The zero-width rule gets us an equivalent to the vertical 6pt kern.
-defineMacro("\\vdots", "\\TextOrMath{\\textvdots}{{\\varvdots\\rule{0pt}{15pt}}}\\relax");
+defineMacro("\\vdots", "{\\varvdots\\rule{0pt}{15pt}}");
 defineMacro("\u22ee", "\\vdots");
 
 // {array} environment gaps
@@ -4831,8 +4999,10 @@ defineMacro("\\tag@literal", (context) => {
   if (context.macros.get("\\df@tag")) {
     throw new ParseError("Multiple \\tag");
   }
-  return "\\def\\df@tag{\\text{#1}}";
+  return "\\gdef\\df@tag{\\text{#1}}";
 });
+defineMacro("\\notag", "\\nonumber");
+defineMacro("\\nonumber", "\\gdef\\@eqnsw{0}");
 
 // \renewcommand{\bmod}{\nonscript\mskip-\medmuskip\mkern5mu\mathbin
 //   {\operator@font mod}\penalty900
@@ -7036,33 +7206,30 @@ const arrayGaps = macros => {
   return [arraystretch, arraycolsep]
 };
 
-const getTag = (group, style, rowNum) => {
-  let tag;
-  const tagContents = group.tags.shift();
-  if (tagContents) {
-    // The author has written a \tag or a \notag in this row.
-    if (tagContents.body) {
-      tag = buildExpressionRow(tagContents.body, style, true);
-      tag.classes = ["tml-tag"];
-    } else {
-      // \notag. Return an empty span.
-      tag = new mathMLTree.MathNode("mtext", [], []);
-      return tag
-    }
-  } else if (group.envClasses.includes("multline") &&
-    ((group.leqno && rowNum !== 0) || (!group.leqno && rowNum !== group.body.length - 1))) {
-    // A multiline that does not receive a tag. Return an empty cell.
-    tag = new mathMLTree.MathNode("mtext", [], []);
-    return tag
-  } else {
-    // AMS automatcally numbered equaton.
-    // Insert a class so the element can be populated by a CSS counter.
-    // WebKit will display the CSS counter only inside a span.
-    tag = new mathMLTree.MathNode("mtext", [new Span(["tml-eqn"])]);
+const checkCellForLabels = cell => {
+  // Check if the author wrote a \tag{} inside this cell.
+  let rowLabel = "";
+  for (let i = 0; i < cell.length; i++) {
+    if (cell[i].type === "label") {
+      if (rowLabel) { throw new ParseError(("Multiple \\labels in one row")) }
+      rowLabel = cell[i].string;
+    }
   }
-  return tag
+  return rowLabel
 };
 
+// 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) {
+  if (name.indexOf("ed") === -1) {
+    return name.indexOf("*") === -1;
+  }
+  // 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
@@ -7074,7 +7241,7 @@ function parseArray(
   {
     cols, // [{ type: string , align: l|c|r|null }]
     envClasses, // align(ed|at|edat) | array | cases | cd | small | multline
-    addEqnNum,      // boolean
+    autoTag,        // boolean
     singleRow,      // boolean
     emptySingleRow, // boolean
     maxNumCols,     // number
@@ -7090,13 +7257,6 @@ function parseArray(
     // TODO: provide helpful error when \cr is used outside array environment
     parser.gullet.macros.set("\\cr", "\\\\\\relax");
   }
-  if (addEqnNum) {
-    parser.gullet.macros.set("\\tag", "\\@ifstar\\envtag@literal\\envtag@paren");
-    parser.gullet.macros.set("\\envtag@paren", "\\env@tag{{(\\text{#1})}}");
-    parser.gullet.macros.set("\\envtag@literal", "\\env@tag{\\text{#1}}");
-    parser.gullet.macros.set("\\notag", "\\env@notag");
-    parser.gullet.macros.set("\\nonumber", "\\env@notag");
-  }
 
   // Start group for first cell
   parser.gullet.beginGroup();
@@ -7104,29 +7264,39 @@ function parseArray(
   let row = [];
   const body = [row];
   const rowGaps = [];
-  const tags = [];
-  let rowTag;
+  const labels = [];
+
   const hLinesBeforeRow = [];
 
+  const tags = (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)
     let cell = parser.parseExpression(false, singleRow ? "\\end" : "\\\\");
-
-    if (addEqnNum && !rowTag) {
-      // Check if the author wrote a \tag{} inside this cell.
-      for (let i = 0; i < cell.length; i++) {
-        if (cell[i].type === "envTag" || cell[i].type === "noTag") {
-          // Get the contents of the \text{} nested inside the \env@Tag{}
-          rowTag = cell[i].type === "envTag"
-            ? cell.splice(i, 1)[0].body.body[0]
-            : { body: null };
-          break
-        }
-      }
-    }
     parser.gullet.endGroup();
     parser.gullet.beginGroup();
 
@@ -7155,6 +7325,7 @@ function parseArray(
       }
       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.
@@ -7162,6 +7333,7 @@ function parseArray(
       if (row.length === 1 && cell.body.length === 0 && (body.length > 1 || !emptySingleRow)) {
         body.pop();
       }
+      labels.push(checkCellForLabels(cell.body));
       if (hLinesBeforeRow.length < body.length + 1) {
         hLinesBeforeRow.push([]);
       }
@@ -7178,15 +7350,16 @@ function parseArray(
         size = parser.parseSizeGroup(true);
       }
       rowGaps.push(size ? size.value : null);
+      endRow();
 
-      tags.push(rowTag);
+      labels.push(checkCellForLabels(cell.body));
 
       // check for \hline(s) following the row separator
       hLinesBeforeRow.push(getHLines(parser));
 
       row = [];
-      rowTag = null;
       body.push(row);
+      beginRow();
     } else {
       throw new ParseError("Expected & or \\\\ or \\cr or \\end", parser.nextToken);
     }
@@ -7197,8 +7370,6 @@ function parseArray(
   // End array group defining \cr
   parser.gullet.endGroup();
 
-  tags.push(rowTag);
-
   return {
     type: "array",
     mode: parser.mode,
@@ -7207,9 +7378,10 @@ function parseArray(
     rowGaps,
     hLinesBeforeRow,
     envClasses,
-    addEqnNum,
+    autoTag,
     scriptLevel,
     tags,
+    labels,
     leqno,
     arraystretch,
     arraycolsep
@@ -7266,19 +7438,43 @@ const mathmlBuilder$7 = function(group, style) {
       }
       row.push(mtd);
     }
-    if (group.addEqnNum) {
-      row.unshift(glue(group));
-      row.push(glue(group));
-      const tag = getTag(group, style.withLevel(cellLevel), i);
-      if (group.leqno) {
-        row[0].children.push(tag);
-        row[0].classes.push("tml-left");
-      } else {
-        row[row.length - 1].children.push(tag);
-        row[row.length - 1].classes.push("tml-right");
+    const numColumns = group.body[0].length;
+    // Fill out a short row with empty <mtd> elements.
+    for (let k = 0; k < numColumns - rw.length; k++) {
+      row.push(new mathMLTree.MathNode("mtd", [], style));
+    }
+    if (group.autoTag) {
+      const tag = group.tags[i];
+      let tagElement;
+      if (tag === true) {  // automatic numbering
+        tagElement = new mathMLTree.MathNode("mtext", [new Span(["tml-eqn"])]);
+      } else if (tag === false) {
+        // \nonumber/\notag or starred environment
+        tagElement = new mathMLTree.MathNode("mtext", [], []);
+      } else {  // manual \tag
+        tagElement = buildExpressionRow(tag[0].body, style.withLevel(cellLevel), true);
+        tagElement = consolidateText(tagElement);
+        tagElement.classes = ["tml-tag"];
+      }
+      if (tagElement) {
+        row.unshift(glue(group));
+        row.push(glue(group));
+        if (group.leqno) {
+          row[0].children.push(tagElement);
+          row[0].classes.push("tml-left");
+        } else {
+          row[row.length - 1].children.push(tagElement);
+          row[row.length - 1].classes.push("tml-right");
+        }
       }
     }
     const mtr = new mathMLTree.MathNode("mtr", row, []);
+    const label = group.labels.shift();
+    if (label && group.tags && group.tags[i]) {
+      mtr.setAttribute("id", label);
+      if (Array.isArray(group.tags[i])) { mtr.classes.push("tml-tageqn"); }
+    }
+
     // Write horizontal rules
     if (i === 0 && hlines[0].length > 0) {
       if (hlines[0].length === 2) {
@@ -7302,16 +7498,17 @@ const mathmlBuilder$7 = function(group, style) {
   }
 
   if (group.envClasses.length > 0) {
-    let pad = group.envClasses.includes("jot")
-      ? "0.7" // 0.5ex + 0.09em top & bot padding
-      : group.envClasses.includes("small")
-      ? "0.35"
-      : "0.5"; // 0.5ex default top & bot padding
     if (group.arraystretch && group.arraystretch !== 1) {
       // In LaTeX, \arraystretch is a factor applied to a 12pt strut height.
       // It defines a baseline to baseline distance.
       // Here, we do an approximation of that approach.
-      pad = String(1.4 * group.arraystretch - 0.8);
+      const pad = String(1.4 * group.arraystretch - 0.8) + "ex";
+      for (let i = 0; i < tbl.length; i++) {
+        for (let j = 0; j < tbl[i].children.length; j++) {
+          tbl[i].children[j].style.paddingTop = pad;
+          tbl[i].children[j].style.paddingBottom = pad;
+        }
+      }
     }
     let sidePadding = group.envClasses.includes("abut")
       ? "0"
@@ -7325,7 +7522,7 @@ const mathmlBuilder$7 = function(group, style) {
     let sidePadUnit = "em";
     if (group.arraycolsep) {
       const arraySidePad = calculateSize(group.arraycolsep, style);
-      sidePadding = arraySidePad.number;
+      sidePadding = arraySidePad.number.toFixed(4);
       sidePadUnit = arraySidePad.unit;
     }
 
@@ -7336,18 +7533,18 @@ const mathmlBuilder$7 = function(group, style) {
       if (j === numCols - 1 && hand === 1) { return "0" }
       if (group.envClasses[0] !== "align") { return sidePadding }
       if (hand === 1) { return "0" }
-      if (group.addEqnNum) {
+      if (group.autoTag) {
         return (j % 2) ? "1" : "0"
       } else {
         return (j % 2) ? "0" : "1"
       }
     };
 
-    // Padding
+    // Side padding
     for (let i = 0; i < tbl.length; i++) {
       for (let j = 0; j < tbl[i].children.length; j++) {
-        tbl[i].children[j].style.padding = `${pad}ex ${sidePad(j, 1)}${sidePadUnit}`
-          + ` ${pad}ex ${sidePad(j, 0)}${sidePadUnit}`;
+        tbl[i].children[j].style.paddingLeft = `${sidePad(j, 0)}${sidePadUnit}`;
+        tbl[i].children[j].style.paddingRight = `${sidePad(j, 1)}${sidePadUnit}`;
       }
     }
 
@@ -7361,13 +7558,13 @@ const mathmlBuilder$7 = function(group, style) {
           // TODO: Remove -webkit- when Chromium no longer needs it.
           row.children[j].classes = ["tml-" + (j % 2 ? "left" : "right")];
         }
-        if (group.addEqnNum) {
+        if (group.autoTag) {
           const k = group.leqno ? 0 : row.children.length - 1;
           row.children[k].classes = ["tml-" + (group.leqno ? "left" : "right")];
         }
       }
       if (row.children.length > 1 && group.envClasses.includes("cases")) {
-        row.children[1].style.padding = row.children[1].style.padding.replace(/0em$/, "1em");
+        row.children[1].style.paddingLeft = "1em";
       }
 
       if (group.envClasses.includes("cases") || group.envClasses.includes("subarray")) {
@@ -7387,9 +7584,17 @@ const mathmlBuilder$7 = function(group, style) {
   }
 
   let table = new mathMLTree.MathNode("mtable", tbl);
+  if (group.envClasses.length > 0) {
+    // Top & bottom padding
+    if (group.envClasses.includes("jot")) {
+      table.classes.push("tml-jot");
+    } else if (group.envClasses.includes("small")) {
+      table.classes.push("tml-small");
+    }
+  }
   if (group.scriptLevel === "display") { table.setAttribute("displaystyle", "true"); }
 
-  if (group.addEqnNum || group.envClasses.includes("multline")) {
+  if (group.autoTag || group.envClasses.includes("multline")) {
     table.style.width = "100%";
   }
 
@@ -7419,7 +7624,7 @@ const mathmlBuilder$7 = function(group, style) {
         row.children[0].style.borderLeft = sep;
       }
     }
-    let iCol = group.addEqnNum ? 0 : -1;
+    let iCol = group.autoTag ? 0 : -1;
     for (let i = iStart; i < iEnd; i++) {
       if (cols[i].type === "align") {
         const colAlign = alignMap[cols[i].align];
@@ -7461,7 +7666,7 @@ const mathmlBuilder$7 = function(group, style) {
       }
     }
   }
-  if (group.addEqnNum) {
+  if (group.autoTag) {
      // allow for glue cells on each side
     align = "left " + (align.length > 0 ? align : "center ") + "right ";
   }
@@ -7485,13 +7690,14 @@ const alignedHandler = function(context, args) {
   if (context.envName.indexOf("ed") === -1) {
     validateAmsEnvironmentContext(context);
   }
+  const isSplit = context.envName === "split";
   const cols = [];
   const res = parseArray(
     context.parser,
     {
       cols,
-      addEqnNum: context.envName === "align" || context.envName === "alignat",
       emptySingleRow: true,
+      autoTag: isSplit ? undefined : getAutoTag(context.envName),
       envClasses: ["abut", "jot"], // set row spacing & provisional column spacing
       maxNumCols: context.envName === "split" ? 2 : undefined,
       leqno: context.parser.settings.leqno
@@ -7813,7 +8019,7 @@ defineEnvironment({
     const res = {
       cols: [],
       envClasses: ["abut", "jot"],
-      addEqnNum: context.envName === "gather",
+      autoTag: getAutoTag(context.envName),
       emptySingleRow: true,
       leqno: context.parser.settings.leqno
     };
@@ -7831,7 +8037,7 @@ defineEnvironment({
   handler(context) {
     validateAmsEnvironmentContext(context);
     const res = {
-      addEqnNum: context.envName === "equation",
+      autoTag: getAutoTag(context.envName),
       emptySingleRow: true,
       singleRow: true,
       maxNumCols: 1,
@@ -7852,7 +8058,7 @@ defineEnvironment({
   handler(context) {
     validateAmsEnvironmentContext(context);
     const res = {
-      addEqnNum: context.envName === "multline",
+      autoTag: context.envName === "multline",
       maxNumCols: 1,
       envClasses: ["jot", "multline"],
       leqno: context.parser.settings.leqno
@@ -8074,6 +8280,7 @@ defineFunction({
     "\\mathfrak",
     "\\mathscr",
     "\\mathsf",
+    "\\mathsfit",
     "\\mathtt",
 
     // aliases
@@ -8143,10 +8350,19 @@ const mathmlBuilder$5 = (group, style) => {
     ? style.withLevel(StyleLevel.SCRIPT)
     : style.withLevel(StyleLevel.SCRIPTSCRIPT);
 
-  let node = new mathMLTree.MathNode("mfrac", [
-    buildGroup$1(group.numer, childOptions),
-    buildGroup$1(group.denom, childOptions)
-  ]);
+  // Chromium (wrongly) continues to shrink fractions beyond scriptscriptlevel.
+  // So we check for levels that Chromium shrinks too small.
+  // If necessary, set an explicit fraction depth.
+  const numer = buildGroup$1(group.numer, childOptions);
+  const denom = buildGroup$1(group.denom, childOptions);
+  if (style.level === 3) {
+    numer.style.mathDepth = "2";
+    numer.setAttribute("scriptlevel", "2");
+    denom.style.mathDepth = "2";
+    denom.setAttribute("scriptlevel", "2");
+  }
+
+  let node = new mathMLTree.MathNode("mfrac", [numer, denom]);
 
   if (!group.hasBarLine) {
     node.setAttribute("linethickness", "0px");
@@ -8539,12 +8755,9 @@ defineFunction({
     };
   },
   mathmlBuilder: (group, style) => {
-    let math = buildExpressionRow(group.body, style);
-    if (!(math instanceof MathNode)) {
-      math = new MathNode("mrow", [math]);
-    }
-    math.setAttribute("href", group.href);
-    return math;
+    const math = new MathNode("math", [buildExpressionRow(group.body, style)]);
+    const anchorNode = new AnchorNode(group.href, [], [math]);
+    return anchorNode
   }
 });
 
@@ -8902,7 +9115,7 @@ defineFunction({
     // Return a no-width, no-ink element with an HTML id.
     const node = new mathMLTree.MathNode("mrow", [], ["tml-label"]);
     if (group.string.length > 0) {
-      node.setAttribute("id", group.string);
+      node.setLabel(group.string);
     }
     return node
   }
@@ -9416,13 +9629,6 @@ const mathmlBuilder$2 = (group, style) => {
     node = new MathNode("mo", [makeText(group.name, group.mode)]);
     if (noSuccessor.includes(group.name)) {
       node.setAttribute("largeop", "false");
-    } else if (group.limits) {
-      // This is a workaround for a MathML/Chromium bug.
-      // This is being applied to singleCharBigOps, which are not really stretchy.
-      // But by setting the stretchy attribute, Chromium will vertically center
-      // big ops around the math axis. This is needed since STIX TWO does not do so.
-      // TODO: Remove this hack when MathML & Chromium fix their problem.
-      node.setAttribute("stretchy", "true");
     } else {
       node.setAttribute("movablelimits", "false");
     }
@@ -10057,12 +10263,10 @@ defineFunction({
     };
   },
   mathmlBuilder(group, style) {
-    // Create an empty text node. Set a class and an href.
+    // Create an empty <a> node. Set a class and an href attribute.
     // The post-processor will populate with the target's tag or equation number.
     const classes = group.funcName === "\\ref" ? ["tml-ref"] : ["tml-ref", "tml-eqref"];
-    const node = new mathMLTree.MathNode("mtext", [new mathMLTree.TextNode("")], classes);
-    node.setAttribute("href", "#" + group.string);
-    return node
+    return new AnchorNode("#" + group.string, classes, null)
   }
 });
 
@@ -10109,6 +10313,8 @@ defineFunction({
   props: {
     numArgs: 2,
     numOptionalArgs: 1,
+    allowedInText: true,
+    allowedInMath: true,
     argTypes: ["size", "size", "size"]
   },
   handler({ parser }, args, optArgs) {
@@ -10401,16 +10607,25 @@ defineFunctionBuilders({
       ? [buildGroup$1(group.base.body[0], style)]
       : [buildGroup$1(group.base, style)];
 
+    // Note regarding scriptstyle level.
+    // (Sub|super)scripts should not shrink beyond MathML scriptlevel 2 aka \scriptscriptstyle
+    // Ref: https://w3c.github.io/mathml-core/#the-displaystyle-and-scriptlevel-attributes
+    // (BTW, MathML scriptlevel 2 is equal to Temml level 3.)
+    // But Chromium continues to shrink the (sub|super)scripts. So we explicitly set scriptlevel 2.
+
     const childStyle = style.inSubOrSup();
     if (group.sub) {
-      children.push(buildGroup$1(group.sub, childStyle));
+      const sub = buildGroup$1(group.sub, childStyle);
+      if (style.level === 3) { sub.setAttribute("scriptlevel", "2"); }
+      children.push(sub);
     }
 
     if (group.sup) {
       const sup = buildGroup$1(group.sup, childStyle);
+      if (style.level === 3) { sup.setAttribute("scriptlevel", "2"); }
       const testNode = sup.type === "mrow" ? sup.children[0] : sup;
       if ((testNode && testNode.type === "mo" && testNode.classes.includes("tml-prime"))
-        && group.base && group.base.text && group.base.text === "f") {
+        && group.base && group.base.text && "fF".indexOf(group.base.text) > -1) {
         // Chromium does not address italic correction on prime.  Prevent f′ from overlapping.
         testNode.classes.push("prime-pad");
       }
@@ -10637,6 +10852,8 @@ const getVariant = function(group, style) {
       return "script"
     case "mathsf":
       return "sans-serif"
+    case "mathsfit":
+      return "sans-serif-italic"
     case "mathtt":
       return "monospace"
   }
@@ -11101,6 +11318,32 @@ defineFunction({
   }
 });
 
+// \vcenter:  Vertically center the argument group on the math axis.
+
+defineFunction({
+  type: "vcenter",
+  names: ["\\vcenter"],
+  props: {
+    numArgs: 1,
+    argTypes: ["original"],
+    allowedInText: false
+  },
+  handler({ parser }, args) {
+    return {
+      type: "vcenter",
+      mode: parser.mode,
+      body: args[0]
+    };
+  },
+  mathmlBuilder(group, style) {
+    // Use a math table to create vertically centered content.
+    const mtd = new mathMLTree.MathNode("mtd", [buildGroup$1(group.body, style)]);
+    mtd.style.padding = "0";
+    const mtr = new mathMLTree.MathNode("mtr", [mtd]);
+    return new mathMLTree.MathNode("mtable", [mtr])
+  }
+});
+
 defineFunction({
   type: "verb",
   names: ["\\verb"],
@@ -11135,75 +11378,6 @@ const makeVerb = (group) => group.body.replace(/ /g, group.star ? "\u2423" : "\x
 
 const functions = _functions;
 
-/**
- * Lexing or parsing positional information for error reporting.
- * This object is immutable.
- */
-class SourceLocation {
-  constructor(lexer, start, end) {
-    this.lexer = lexer; // Lexer holding the input string.
-    this.start = start; // Start offset, zero-based inclusive.
-    this.end = end;     // End offset, zero-based exclusive.
-  }
-
-  /**
-   * Merges two `SourceLocation`s from location providers, given they are
-   * provided in order of appearance.
-   * - Returns the first one's location if only the first is provided.
-   * - Returns a merged range of the first and the last if both are provided
-   *   and their lexers match.
-   * - Otherwise, returns null.
-   */
-  static range(first, second) {
-    if (!second) {
-      return first && first.loc;
-    } else if (!first || !first.loc || !second.loc || first.loc.lexer !== second.loc.lexer) {
-      return null;
-    } else {
-      return new SourceLocation(first.loc.lexer, first.loc.start, second.loc.end);
-    }
-  }
-}
-
-/**
- * Interface required to break circular dependency between Token, Lexer, and
- * ParseError.
- */
-
-/**
- * The resulting token returned from `lex`.
- *
- * It consists of the token text plus some position information.
- * The position information is essentially a range in an input string,
- * but instead of referencing the bare input string, we refer to the lexer.
- * That way it is possible to attach extra metadata to the input string,
- * like for example a file name or similar.
- *
- * The position information is optional, so it is OK to construct synthetic
- * tokens if appropriate. Not providing available position information may
- * lead to degraded error reporting, though.
- */
-class Token {
-  constructor(
-    text, // the text of this token
-    loc
-  ) {
-    this.text = text;
-    this.loc = loc;
-  }
-
-  /**
-   * Given a pair of tokens (this and endToken), compute a `Token` encompassing
-   * the whole input range enclosed by these two.
-   */
-  range(
-    endToken, // last token of the range, inclusive
-    text // the text of the newly constructed token
-  ) {
-    return new Token(text, SourceLocation.range(this, endToken));
-  }
-}
-
 /**
  * The Lexer class handles tokenizing the input in various ways. Since our
  * parser expects us to be able to backtrack, the lexer allows lexing from any
@@ -13367,9 +13541,11 @@ class Style {
   constructor(data) {
     // Style.level can be 0 | 1 | 2 | 3, which correspond to
     //       displaystyle, textstyle, scriptstyle, and scriptscriptstyle.
-    // style.level does not directly set MathML's script level. MathML does that itself.
-    // We use style.level to track, not set, math style so that we can get the
-    // correct scriptlevel when needed in supsub.js, mathchoice.js, or for dimensions in em.
+    // style.level usually does not directly set MathML's script level. MathML does that itself.
+    // However, Chromium does not stop shrinking after scriptscriptstyle, so we do explicitly
+    // set a scriptlevel attribute in those conditions.
+    // We also use style.level to track math style so that we can get the correct
+    // scriptlevel when needed in supsub.js, mathchoice.js, or for dimensions in em.
     this.level = data.level;
     this.color = data.color;  // string | void
     // A font family applies to a group of fonts (i.e. SansSerif), while a font
@@ -13493,42 +13669,51 @@ class Style {
 }
 
 /* Temml Post Process
- * Perform two tasks not done by Temml when it created each individual Temml <math> element.
- * Given a block,
- *   1. At each AMS auto-numbered environment, assign an id.
- *   2. Populate the text contents of each \ref & \eqref
+ * Populate the text contents of each \ref & \eqref
  *
  * As with other Temml code, this file is released under terms of the MIT license.
  * https://mit-license.org/
  */
 
-const version = "0.10.32";
+const version = "0.10.34";
 
 function postProcess(block) {
   const labelMap = {};
   let i = 0;
 
   // Get a collection of the parents of each \tag & auto-numbered equation
-  const parents = block.getElementsByClassName("tml-tageqn");
-  for (const parent of parents) {
-    const eqns = parent.getElementsByClassName("tml-eqn");
-    if (eqns. length > 0 ) {
-      // AMS automatically numbered equation.
-      // Assign an id.
-      i += 1;
-      eqns[0].id = "tml-eqn-" + i;
-      // No need to write a number into the text content of the element.
-      // A CSS counter does that even if this postProcess() function is not used.
+  const amsEqns = document.getElementsByClassName('tml-eqn');
+  for (let parent of amsEqns) {
+    // AMS automatically numbered equation.
+    // Assign an id.
+    i += 1;
+    parent.setAttribute("id", "tml-eqn-" + String(i));
+    // No need to write a number into the text content of the element.
+    // A CSS counter has done that even if this postProcess() function is not used.
+
+    // Find any \label that refers to an AMS automatic eqn number.
+    while (true) {
+      if (parent.tagName === "mtable") { break }
+      const labels = parent.getElementsByClassName("tml-label");
+      if (labels.length > 0) {
+        const id = parent.attributes.id.value;
+        labelMap[id] = String(i);
+        break
+      } else {
+        parent = parent.parentElement;
+      }
     }
-    // If there is a \label, add it to labelMap
+  }
+
+  // Find \labels associated with \tag
+  const taggedEqns = document.getElementsByClassName('tml-tageqn');
+  for (const parent of taggedEqns) {
     const labels = parent.getElementsByClassName("tml-label");
-    if (labels.length === 0) { continue }
-    if (eqns.length > 0) {
-      labelMap[labels[0].id] = String(i);
-    } else {
+    if (labels.length > 0) {
       const tags = parent.getElementsByClassName("tml-tag");
       if (tags.length > 0) {
-        labelMap[labels[0].id] = tags[0].textContent;
+        const id = parent.attributes.id.value;
+        labelMap[id] = tags[0].textContent;
       }
     }
   }
@@ -13536,17 +13721,22 @@ function postProcess(block) {
   // Populate \ref & \eqref text content
   const refs = block.getElementsByClassName("tml-ref");
   [...refs].forEach(ref => {
-    let str = labelMap[ref.getAttribute("href").slice(1)];
+    const attr = ref.getAttribute("href");
+    let str = labelMap[attr.slice(1)];
     if (ref.className.indexOf("tml-eqref") === -1) {
       // \ref. Omit parens.
       str = str.replace(/^\(/, "");
-      str = str.replace(/\($/, "");
-    }  {
+      str = str.replace(/\)$/, "");
+    } else {
       // \eqref. Include parens
       if (str.charAt(0) !== "(") { str = "(" + str; }
       if (str.slice(-1) !== ")") { str =  str + ")"; }
     }
-    ref.textContent = str;
+    const mtext = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mtext");
+    mtext.appendChild(document.createTextNode(str));
+    const math =  document.createElementNS("http://www.w3.org/1998/Math/MathML", "math");
+    math.appendChild(mtext);
+    ref.appendChild(math);
   });
 }