temml 0.10.32 → 0.10.34

package/src/environments/array.js

@@ -3,6 +3,7 @@ import { parseCD } from "./cd";
 import defineFunction from "../defineFunction";
 import mathMLTree from "../mathMLTree";
 import { Span } from "../domTree"
+import { Token } from "../Token";
 import { StyleLevel } from "../constants"
 import ParseError from "../ParseError";
 import { assertNodeType, assertSymbolNodeType } from "../parseNode";
@@ -57,31 +58,28 @@ 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 = mml.buildExpressionRow(tagContents.body, style, true)
-      tag.classes = ["tml-tag"]
-    } else {
-      // \notag. Return an empty span.
-      tag = new mathMLTree.MathNode("mtext", [], [])
-      return tag
+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
     }
-  } 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"])])
   }
-  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;
 }
 
 /**
@@ -95,7 +93,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
@@ -111,13 +109,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();
@@ -125,29 +116,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();
 
@@ -176,6 +177,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.
@@ -183,6 +185,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([]);
       }
@@ -198,16 +201,17 @@ function parseArray(
       if (parser.gullet.future().text !== " ") {
         size = parser.parseSizeGroup(true);
       }
-      rowGaps.push(size ? size.value : null);
+      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);
     }
@@ -218,8 +222,6 @@ function parseArray(
   // End array group defining \cr
   parser.gullet.endGroup();
 
-  tags.push(rowTag)
-
   return {
     type: "array",
     mode: parser.mode,
@@ -228,9 +230,10 @@ function parseArray(
     rowGaps,
     hLinesBeforeRow,
     envClasses,
-    addEqnNum,
+    autoTag,
     scriptLevel,
     tags,
+    labels,
     leqno,
     arraystretch,
     arraycolsep
@@ -287,19 +290,43 @@ const mathmlBuilder = 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 = mml.buildExpressionRow(tag[0].body, style.withLevel(cellLevel), true)
+        tagElement = mml.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) {
@@ -323,16 +350,17 @@ const mathmlBuilder = 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"
@@ -346,7 +374,7 @@ const mathmlBuilder = 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
     }
 
@@ -357,18 +385,18 @@ const mathmlBuilder = 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}`
       }
     }
 
@@ -382,13 +410,13 @@ const mathmlBuilder = 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")) {
@@ -408,9 +436,17 @@ const mathmlBuilder = 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%"
   }
 
@@ -440,7 +476,7 @@ const mathmlBuilder = 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];
@@ -482,7 +518,7 @@ const mathmlBuilder = function(group, style) {
       }
     }
   }
-  if (group.addEqnNum) {
+  if (group.autoTag) {
      // allow for glue cells on each side
     align = "left " + (align.length > 0 ? align : "center ") + "right "
   }
@@ -506,13 +542,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
@@ -836,7 +873,7 @@ defineEnvironment({
     const res = {
       cols: [],
       envClasses: ["abut", "jot"],
-      addEqnNum: context.envName === "gather",
+      autoTag: getAutoTag(context.envName),
       emptySingleRow: true,
       leqno: context.parser.settings.leqno
     };
@@ -854,7 +891,7 @@ defineEnvironment({
   handler(context) {
     validateAmsEnvironmentContext(context);
     const res = {
-      addEqnNum: context.envName === "equation",
+      autoTag: getAutoTag(context.envName),
       emptySingleRow: true,
       singleRow: true,
       maxNumCols: 1,
@@ -875,7 +912,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

package/src/environments/cd.js

@@ -190,6 +190,8 @@ export 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([])
@@ -218,18 +220,23 @@ defineFunction({
     };
   },
   mathmlBuilder(group, style) {
-    let label = new mathMLTree.MathNode("mrow", [mml.buildGroup(group.label, style)]);
-    label = new mathMLTree.MathNode("mpadded", [label]);
-    label.setAttribute("width", "0");
+    if (group.label.body.length === 0) {
+      return new mathMLTree.MathNode("mrow", style)  // empty label
+    }
+    // Abuse an <mtable> to create vertically centered content.
+    const mtd = new mathMLTree.MathNode("mtd", [mml.buildGroup(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.setAttribute("lspace", "-1width");
+      label.style.display = "flex"
+      label.style.justifyContent = "flex-end"
     }
-    // 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.setAttribute("displaystyle", "false");
-    label.setAttribute("scriptlevel", "1");
     return label;
   }
 });

package/src/functions/arrow.js

@@ -12,12 +12,19 @@ const padding = 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(lspace) }
   const row = group ? [group] : [];
   if (lspace !== 0)   { row.unshift(padding(lspace)) }
   if (rspace > 0) { row.push(padding(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);
@@ -57,7 +64,8 @@ const munderoverNode = (fName, body, below, style) => {
     (body.body.body || body.body.length > 0))
   if (gotUpper) {
     let label =  mml.buildGroup(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.

package/src/functions/def.js

@@ -250,10 +250,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 };
 

package/src/functions/delimsizing.js

@@ -93,6 +93,7 @@ export const delimiters = [
   "\\vert",
   "\\|",
   "\\Vert",
+  "\u2016",
   "\\uparrow",
   "\\Uparrow",
   "\\downarrow",

package/src/functions/font.js

@@ -94,6 +94,7 @@ defineFunction({
     "\\mathfrak",
     "\\mathscr",
     "\\mathsf",
+    "\\mathsfit",
     "\\mathtt",
 
     // aliases

package/src/functions/genfrac.js

@@ -20,10 +20,19 @@ const mathmlBuilder = (group, style) => {
     ? style.withLevel(StyleLevel.SCRIPT)
     : style.withLevel(StyleLevel.SCRIPTSCRIPT);
 
-  let node = new mathMLTree.MathNode("mfrac", [
-    mml.buildGroup(group.numer, childOptions),
-    mml.buildGroup(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 = mml.buildGroup(group.numer, childOptions)
+  const denom = mml.buildGroup(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");

package/src/functions/href.js

@@ -1,6 +1,7 @@
 import defineFunction, { ordargument } from "../defineFunction";
 import { assertNodeType } from "../parseNode";
 import { MathNode } from "../mathMLTree";
+import { AnchorNode } from "../domTree";
 import * as mml from "../buildMathML";
 import ParseError from "../ParseError";
 
@@ -33,12 +34,9 @@ defineFunction({
     };
   },
   mathmlBuilder: (group, style) => {
-    let math = mml.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", [mml.buildExpressionRow(group.body, style)])
+    const anchorNode = new AnchorNode(group.href, [], [math])
+    return anchorNode
   }
 });
 

package/src/functions/label.js

@@ -22,7 +22,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
   }

package/src/functions/op.js

@@ -32,13 +32,6 @@ const mathmlBuilder = (group, style) => {
     node = new mathMLTree.MathNode("mo", [mml.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")
     }

package/src/functions/ref.js

@@ -1,5 +1,5 @@
 import defineFunction from "../defineFunction";
-import mathMLTree from "../mathMLTree";
+import { AnchorNode } from "../domTree";
 import { invalidIdRegEx } from "./label";
 
 defineFunction({
@@ -18,11 +18,9 @@ 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)
   }
 });

package/src/functions/rule.js

@@ -9,6 +9,8 @@ defineFunction({
   props: {
     numArgs: 2,
     numOptionalArgs: 1,
+    allowedInText: true,
+    allowedInMath: true,
     argTypes: ["size", "size", "size"]
   },
   handler({ parser }, args, optArgs) {

package/src/functions/supsub.js

@@ -45,18 +45,27 @@ defineFunctionBuilders({
 
     const children = group.base && group.base.stack
       ? [mml.buildGroup(group.base.body[0], style)]
-      : [mml.buildGroup(group.base, style)]
+      : [mml.buildGroup(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(mml.buildGroup(group.sub, childStyle))
+      const sub = mml.buildGroup(group.sub, childStyle)
+      if (style.level === 3) { sub.setAttribute("scriptlevel", "2") }
+      children.push(sub)
     }
 
     if (group.sup) {
       const sup = mml.buildGroup(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")
       }