temml 0.9.1

package/src/environments/cd.js

@@ -0,0 +1,252 @@
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import * as mml from "../buildMathML";
+import { assertSymbolNodeType } from "../parseNode";
+import ParseError from "../ParseError";
+
+const cdArrowFunctionName = {
+  ">": "\\\\cdrightarrow",
+  "<": "\\\\cdleftarrow",
+  "=": "\\\\cdlongequal",
+  A: "\\uparrow",
+  V: "\\downarrow",
+  "|": "\\Vert",
+  ".": "no arrow"
+};
+
+const newCell = () => {
+  // Create an empty cell, to be filled below with parse nodes.
+  return { type: "styling", body: [], mode: "math", scriptLevel: "display" };
+};
+
+const isStartOfArrow = (node) => {
+  return node.type === "textord" && node.text === "@";
+};
+
+const isLabelEnd = (node, endChar) => {
+  return (node.type === "mathord" || node.type === "atom") && node.text === endChar;
+};
+
+function cdArrow(arrowChar, labels, parser) {
+  // Return a parse tree of an arrow and its labels.
+  // This acts in a way similar to a macro expansion.
+  const funcName = cdArrowFunctionName[arrowChar];
+  switch (funcName) {
+    case "\\\\cdrightarrow":
+    case "\\\\cdleftarrow":
+      return parser.callFunction(funcName, [labels[0]], [labels[1]]);
+    case "\\uparrow":
+    case "\\downarrow": {
+      const leftLabel = parser.callFunction("\\\\cdleft", [labels[0]], []);
+      const bareArrow = {
+        type: "atom",
+        text: funcName,
+        mode: "math",
+        family: "rel"
+      };
+      const sizedArrow = parser.callFunction("\\Big", [bareArrow], []);
+      const rightLabel = parser.callFunction("\\\\cdright", [labels[1]], []);
+      const arrowGroup = {
+        type: "ordgroup",
+        mode: "math",
+        body: [leftLabel, sizedArrow, rightLabel]
+      };
+      return parser.callFunction("\\\\cdparent", [arrowGroup], []);
+    }
+    case "\\\\cdlongequal":
+      return parser.callFunction("\\\\cdlongequal", [], []);
+    case "\\Vert": {
+      const arrow = { type: "textord", text: "\\Vert", mode: "math" };
+      return parser.callFunction("\\Big", [arrow], []);
+    }
+    default:
+      return { type: "textord", text: " ", mode: "math" };
+  }
+}
+
+export function parseCD(parser) {
+  // Get the array's parse nodes with \\ temporarily mapped to \cr.
+  const parsedRows = [];
+  parser.gullet.beginGroup();
+  parser.gullet.macros.set("\\cr", "\\\\\\relax");
+  parser.gullet.beginGroup();
+  while (true) { // eslint-disable-line no-constant-condition
+    // Get the parse nodes for the next row.
+    parsedRows.push(parser.parseExpression(false, "\\\\"));
+    parser.gullet.endGroup();
+    parser.gullet.beginGroup();
+    const next = parser.fetch().text;
+    if (next === "&" || next === "\\\\") {
+      parser.consume();
+    } else if (next === "\\end") {
+      if (parsedRows[parsedRows.length - 1].length === 0) {
+        parsedRows.pop(); // final row ended in \\
+      }
+      break;
+    } else {
+      throw new ParseError("Expected \\\\ or \\cr or \\end", parser.nextToken);
+    }
+  }
+
+  let row = [];
+  const body = [row];
+
+  // Loop thru the parse nodes. Collect them into cells and arrows.
+  for (let i = 0; i < parsedRows.length; i++) {
+    // Start a new row.
+    const rowNodes = parsedRows[i];
+    // Create the first cell.
+    let cell = newCell();
+
+    for (let j = 0; j < rowNodes.length; j++) {
+      if (!isStartOfArrow(rowNodes[j])) {
+        // If a parseNode is not an arrow, it goes into a cell.
+        cell.body.push(rowNodes[j]);
+      } else {
+        // Parse node j is an "@", the start of an arrow.
+        // Before starting on the arrow, push the cell into `row`.
+        row.push(cell);
+
+        // Now collect parseNodes into an arrow.
+        // The character after "@" defines the arrow type.
+        j += 1;
+        const arrowChar = assertSymbolNodeType(rowNodes[j]).text;
+
+        // Create two empty label nodes. We may or may not use them.
+        const labels = new Array(2);
+        labels[0] = { type: "ordgroup", mode: "math", body: [] };
+        labels[1] = { type: "ordgroup", mode: "math", body: [] };
+
+        // Process the arrow.
+        if ("=|.".indexOf(arrowChar) > -1) {
+          // Three "arrows", ``@=`, `@|`, and `@.`, do not take labels.
+          // Do nothing here.
+        } else if ("<>AV".indexOf(arrowChar) > -1) {
+          // Four arrows, `@>>>`, `@<<<`, `@AAA`, and `@VVV`, each take
+          // two optional labels. E.g. the right-point arrow syntax is
+          // really:  @>{optional label}>{optional label}>
+          // Collect parseNodes into labels.
+          for (let labelNum = 0; labelNum < 2; labelNum++) {
+            let inLabel = true;
+            for (let k = j + 1; k < rowNodes.length; k++) {
+              if (isLabelEnd(rowNodes[k], arrowChar)) {
+                inLabel = false;
+                j = k;
+                break;
+              }
+              if (isStartOfArrow(rowNodes[k])) {
+                throw new ParseError(
+                  "Missing a " + arrowChar + " character to complete a CD arrow.",
+                  rowNodes[k]
+                );
+              }
+
+              labels[labelNum].body.push(rowNodes[k]);
+            }
+            if (inLabel) {
+              // isLabelEnd never returned a true.
+              throw new ParseError(
+                "Missing a " + arrowChar + " character to complete a CD arrow.",
+                rowNodes[j]
+              );
+            }
+          }
+        } else {
+          throw new ParseError(`Expected one of "<>AV=|." after @.`);
+        }
+
+        // Now join the arrow to its labels.
+        const arrow = cdArrow(arrowChar, labels, parser);
+
+        // Wrap the arrow in a styling node
+        row.push(arrow);
+        // In CD's syntax, cells are implicit. That is, everything that
+        // is not an arrow gets collected into a cell. So create an empty
+        // cell now. It will collect upcoming parseNodes.
+        cell = newCell();
+      }
+    }
+    if (i % 2 === 0) {
+      // Even-numbered rows consist of: cell, arrow, cell, arrow, ... cell
+      // The last cell is not yet pushed into `row`, so:
+      row.push(cell);
+    } else {
+      // Odd-numbered rows consist of: vert arrow, empty cell, ... vert arrow
+      // Remove the empty cell that was placed at the beginning of `row`.
+      row.shift();
+    }
+    row = [];
+    body.push(row);
+  }
+  body.pop()
+
+  // End row group
+  parser.gullet.endGroup();
+  // End array group defining \\
+  parser.gullet.endGroup();
+
+  return {
+    type: "array",
+    mode: "math",
+    body,
+    envClasses: ["jot", "cd"],
+    cols: [],
+    hLinesBeforeRow: new Array(body.length + 1).fill([])
+  };
+}
+
+// The functions below are not available for general use.
+// They are here only for internal use by the {CD} environment in placing labels
+// next to vertical arrows.
+
+// We don't need any such functions for horizontal arrows because we can reuse
+// the functionality that already exists for extensible arrows.
+
+defineFunction({
+  type: "cdlabel",
+  names: ["\\\\cdleft", "\\\\cdright"],
+  props: {
+    numArgs: 1
+  },
+  handler({ parser, funcName }, args) {
+    return {
+      type: "cdlabel",
+      mode: parser.mode,
+      side: funcName.slice(4),
+      label: args[0]
+    };
+  },
+  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.side === "left") {
+      label.setAttribute("lspace", "-1width");
+    }
+    // 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;
+  }
+});
+
+defineFunction({
+  type: "cdlabelparent",
+  names: ["\\\\cdparent"],
+  props: {
+    numArgs: 1
+  },
+  handler({ parser }, args) {
+    return {
+      type: "cdlabelparent",
+      mode: parser.mode,
+      fragment: args[0]
+    };
+  },
+  mathmlBuilder(group, style) {
+    return new mathMLTree.MathNode("mrow", [mml.buildGroup(group.fragment, style)]);
+  }
+});

package/src/environments.js

@@ -0,0 +1,8 @@
+import { _environments } from "./defineEnvironment";
+
+const environments = _environments;
+
+export default environments;
+
+// All environment definitions should be imported below
+import "./environments/array";

package/src/functions/accent.js

@@ -0,0 +1,127 @@
+import defineFunction, { normalizeArgument } from "../defineFunction"
+import mathMLTree from "../mathMLTree"
+import stretchy from "../stretchy"
+import * as mml from "../buildMathML"
+
+const mathmlBuilder = (group, style) => {
+  const accentNode = group.isStretchy
+    ? stretchy.mathMLnode(group.label)
+    : new mathMLTree.MathNode("mo", [mml.makeText(group.label, group.mode)]);
+
+  if (group.label === "\\vec") {
+    accentNode.style.transform = "scale(0.75) translate(10%, 30%)"
+  } else {
+    accentNode.style.mathStyle = "normal"
+    accentNode.style.mathDepth = "0"
+  }
+  if (!group.isStretchy) {
+    accentNode.setAttribute("stretchy", "false")
+  }
+
+  const node = new mathMLTree.MathNode((group.label === "\\c" ? "munder" : "mover"),
+    [mml.buildGroup(group.base, style), accentNode]
+  );
+
+  return node;
+};
+
+const NON_STRETCHY_ACCENT_REGEX = new RegExp(
+  [
+    "\\acute",
+    "\\grave",
+    "\\ddot",
+    "\\dddot",
+    "\\ddddot",
+    "\\tilde",
+    "\\bar",
+    "\\breve",
+    "\\check",
+    "\\hat",
+    "\\vec",
+    "\\dot",
+    "\\mathring"
+  ]
+    .map((accent) => `\\${accent}`)
+    .join("|")
+);
+
+// Accents
+defineFunction({
+  type: "accent",
+  names: [
+    "\\acute",
+    "\\grave",
+    "\\ddot",
+    "\\dddot",
+    "\\ddddot",
+    "\\tilde",
+    "\\bar",
+    "\\breve",
+    "\\check",
+    "\\hat",
+    "\\vec",
+    "\\dot",
+    "\\mathring",
+    "\\overparen",
+    "\\widecheck",
+    "\\widehat",
+    "\\wideparen",
+    "\\widetilde",
+    "\\overrightarrow",
+    "\\overleftarrow",
+    "\\Overrightarrow",
+    "\\overleftrightarrow",
+    "\\overgroup",
+    "\\overleftharpoon",
+    "\\overrightharpoon"
+  ],
+  props: {
+    numArgs: 1
+  },
+  handler: (context, args) => {
+    const base = normalizeArgument(args[0]);
+
+    const isStretchy = !NON_STRETCHY_ACCENT_REGEX.test(context.funcName);
+
+    return {
+      type: "accent",
+      mode: context.parser.mode,
+      label: context.funcName,
+      isStretchy: isStretchy,
+      base: base
+    };
+  },
+  mathmlBuilder
+});
+
+// Text-mode accents
+defineFunction({
+  type: "accent",
+  names: ["\\'", "\\`", "\\^", "\\~", "\\=", "\\c", "\\u", "\\.", '\\"', "\\r", "\\H", "\\v"],
+  props: {
+    numArgs: 1,
+    allowedInText: true,
+    allowedInMath: true,
+    argTypes: ["primitive"]
+  },
+  handler: (context, args) => {
+    const base = normalizeArgument(args[0]);
+    const mode = context.parser.mode;
+
+    if (mode === "math" && context.parser.settings.strict) {
+      // LaTeX only writes a warning. It doesn't stop. We'll issue the same warning.
+      // eslint-disable-next-line no-console
+      console.log(`Temml parse error: Command ${context.funcName} is invalid in math mode.`)
+    }
+
+    return {
+      type: "accent",
+      mode: mode,
+      label: context.funcName,
+      isStretchy: false,
+      isShifty: true,
+      base: base
+    };
+  },
+  mathmlBuilder
+});

package/src/functions/accentunder.js

@@ -0,0 +1,38 @@
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import stretchy from "../stretchy";
+
+import * as mml from "../buildMathML";
+
+defineFunction({
+  type: "accentUnder",
+  names: [
+    "\\underleftarrow",
+    "\\underrightarrow",
+    "\\underleftrightarrow",
+    "\\undergroup",
+    "\\underparen",
+    "\\utilde"
+  ],
+  props: {
+    numArgs: 1
+  },
+  handler: ({ parser, funcName }, args) => {
+    const base = args[0];
+    return {
+      type: "accentUnder",
+      mode: parser.mode,
+      label: funcName,
+      base: base
+    };
+  },
+  mathmlBuilder: (group, style) => {
+    const accentNode = stretchy.mathMLnode(group.label);
+    accentNode.style["math-depth"] = 0
+    const node = new mathMLTree.MathNode("munder", [
+      mml.buildGroup(group.base, style),
+      accentNode
+    ]);
+    return node;
+  }
+});

package/src/functions/arrow.js

@@ -0,0 +1,204 @@
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import stretchy from "../stretchy";
+import { emScale } from "../units";
+import * as mml from "../buildMathML";
+
+// Helper functions
+
+const padding = width => {
+  const node = new mathMLTree.MathNode("mspace")
+  node.setAttribute("width", width + "em")
+  return node
+}
+
+const paddedNode = (group, lspace = 0.3, rspace = 0) => {
+  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)
+};
+
+const labelSize = (size, scriptLevel) =>  (size / emScale(scriptLevel)).toFixed(4)
+
+const munderoverNode = (name, body, below, style) => {
+  const arrowNode = stretchy.mathMLnode(name);
+  // Is this the short part of a mhchem equilibrium arrow?
+  const isEq = name.slice(1, 3) === "eq"
+  const minWidth = name.charAt(1) === "x"
+    ? "1.75"  // mathtools extensible arrows are 1.75em long
+    : name.slice(2, 4) === "cd"
+    ? "3.0"  // cd package arrows
+    : isEq
+    ? "1.0"  // The shorter harpoon of a mhchem equilibrium arrow
+    : "2.0"; // other mhchem arrows
+  arrowNode.setAttribute("minsize", String(minWidth) + "em");
+  arrowNode.setAttribute("lspace", "0")
+  arrowNode.setAttribute("rspace", (isEq ? "0.5em" : "0"))
+
+  // <munderover> upper and lower labels are set to scriptlevel by MathML
+  // So we have to adjust our dimensions accordingly.
+  const labelStyle = style.withLevel(style.level < 2 ? 2 : 3)
+  const emptyLabelWidth = labelSize(minWidth, labelStyle.level)
+  const lspace = labelSize((isEq ? 0 : 0.3), labelStyle.level)
+  const rspace = labelSize((isEq ? 0 : 0.3), labelStyle.level)
+
+  const upperNode = (body && body.body &&
+    // \hphantom        visible content
+    (body.body.body || body.body.length > 0))
+    ? paddedNode(mml.buildGroup(body, labelStyle), lspace, rspace)
+      // Since Firefox does not recognize minsize set on the arrow,
+      // create an upper node w/correct width.
+    : paddedNode(null, emptyLabelWidth, 0)
+  const lowerNode = (below && below.body &&
+    (below.body.body || below.body.length > 0))
+    ? paddedNode(mml.buildGroup(below, labelStyle), lspace, rspace)
+    : paddedNode(null, emptyLabelWidth, 0)
+  const node = new mathMLTree.MathNode("munderover", [arrowNode, lowerNode, upperNode]);
+  if (minWidth === "3.0") { node.style.height = "1em" }
+  return node
+}
+
+// Stretchy arrows with an optional argument
+defineFunction({
+  type: "xArrow",
+  names: [
+    "\\xleftarrow",
+    "\\xrightarrow",
+    "\\xLeftarrow",
+    "\\xRightarrow",
+    "\\xleftrightarrow",
+    "\\xLeftrightarrow",
+    "\\xhookleftarrow",
+    "\\xhookrightarrow",
+    "\\xmapsto",
+    "\\xrightharpoondown",
+    "\\xrightharpoonup",
+    "\\xleftharpoondown",
+    "\\xleftharpoonup",
+    "\\xlongequal",
+    "\\xtwoheadrightarrow",
+    "\\xtwoheadleftarrow",
+    // The next 5 functions are here only to support mhchem
+    "\\yields",
+    "\\yieldsLeft",
+    "\\mesomerism",
+    "\\longrightharpoonup",
+    "\\longleftharpoondown",
+    // The next 3 functions are here only to support the {CD} environment.
+    "\\\\cdrightarrow",
+    "\\\\cdleftarrow",
+    "\\\\cdlongequal"
+  ],
+  props: {
+    numArgs: 1,
+    numOptionalArgs: 1
+  },
+  handler({ parser, funcName }, args, optArgs) {
+    return {
+      type: "xArrow",
+      mode: parser.mode,
+      name: funcName,
+      body: args[0],
+      below: optArgs[0]
+    };
+  },
+  mathmlBuilder(group, style) {
+    // Build the arrow and its labels.
+    const node = munderoverNode(group.name, group.body, group.below, style)
+    // Create operator spacing for a relation.
+    const row = [node]
+    row.unshift(padding(0.2778))
+    row.push(padding(0.2778))
+    return new mathMLTree.MathNode("mrow", row)
+  }
+});
+
+const arrowComponent = {
+  "\\xtofrom": ["\\xrightarrow", "\\xleftarrow"],
+  "\\xleftrightharpoons": ["\\xleftharpoonup", "\\xrightharpoondown"],
+  "\\xrightleftharpoons": ["\\xrightharpoonup", "\\xleftharpoondown"],
+  "\\yieldsLeftRight": ["\\yields", "\\yieldsLeft"],
+  // The next three all get the same harpoon glyphs. Only the lengths and paddings differ.
+  "\\equilibrium": ["\\longrightharpoonup", "\\longleftharpoondown"],
+  "\\equilibriumRight": ["\\longrightharpoonup", "\\eqleftharpoondown"],
+  "\\equilibriumLeft": ["\\eqrightharpoonup", "\\longleftharpoondown"]
+}
+
+// Browsers are not good at stretching a glyph that contains a pair of stacked arrows such as ⇄.
+// So we stack a pair of single arrows.
+defineFunction({
+  type: "stackedArrow",
+  names: [
+    "\\xtofrom",              // expfeil
+    "\\xleftrightharpoons",   // mathtools
+    "\\xrightleftharpoons",   // mathtools
+    "\\yieldsLeftRight",      // mhchem
+    "\\equilibrium",           // mhchem
+    "\\equilibriumRight",
+    "\\equilibriumLeft"
+  ],
+  props: {
+    numArgs: 1,
+    numOptionalArgs: 1
+  },
+  handler({ parser, funcName }, args, optArgs) {
+    const lowerArrowBody = args[0]
+      ? {
+        type: "hphantom",
+        mode: parser.mode,
+        body: args[0]
+      }
+      : null;
+    const upperArrowBelow = optArgs[0]
+      ? {
+        type: "hphantom",
+        mode: parser.mode,
+        body: optArgs[0]
+      }
+      : null;
+    return {
+      type: "stackedArrow",
+      mode: parser.mode,
+      name: funcName,
+      body: args[0],
+      upperArrowBelow,
+      lowerArrowBody,
+      below: optArgs[0]
+    };
+  },
+  mathmlBuilder(group, style) {
+    const topLabel = arrowComponent[group.name][0]
+    const botLabel = arrowComponent[group.name][1]
+    const topArrow = munderoverNode(topLabel, group.body, group.upperArrowBelow, style)
+    const botArrow = munderoverNode(botLabel, group.lowerArrowBody, group.below, style)
+    let wrapper
+
+    const raiseNode = new mathMLTree.MathNode("mpadded", [topArrow])
+    raiseNode.setAttribute("voffset", "0.3em")
+    raiseNode.setAttribute("height", "+0.3em")
+    raiseNode.setAttribute("depth", "-0.3em")
+    // One of the arrows is given ~zero width. so the other has the same horzontal alignment.
+    if (group.name === "\\equilibriumLeft") {
+      const botNode =  new mathMLTree.MathNode("mpadded", [botArrow])
+      botNode.setAttribute("width", "0.5em")
+      wrapper = new mathMLTree.MathNode(
+        "mpadded",
+        [padding(0.2778), botNode, raiseNode, padding(0.2778)]
+      )
+    } else {
+      raiseNode.setAttribute("width", (group.name === "\\equilibriumRight" ? "0.5em" : "0"))
+      wrapper = new mathMLTree.MathNode(
+        "mpadded",
+        [padding(0.2778), raiseNode, botArrow, padding(0.2778)]
+      )
+    }
+
+    wrapper.setAttribute("voffset", "-0.18em")
+    wrapper.setAttribute("height", "-0.18em")
+    wrapper.setAttribute("depth", "+0.18em")
+    return wrapper
+  }
+});
+

package/src/functions/cancelto.js

@@ -0,0 +1,36 @@
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import * as mml from "../buildMathML";
+
+defineFunction({
+  type: "cancelto",
+  names: ["\\cancelto"],
+  props: {
+    numArgs: 2
+  },
+  handler({ parser }, args) {
+    return {
+      type: "cancelto",
+      mode: parser.mode,
+      value: args[0],
+      expression: args[1]
+    };
+  },
+  mathmlBuilder(group, style) {
+    const value = new mathMLTree.MathNode(
+      "mpadded",
+      [mml.buildGroup(group.value, style)]
+    )
+    value.setAttribute("depth", `-0.1em`)
+    value.setAttribute("height", `+0.1em`)
+    value.setAttribute("voffset", `0.1em`)
+
+    const expression = new mathMLTree.MathNode(
+      "menclose",
+      [mml.buildGroup(group.expression, style)]
+    )
+    expression.setAttribute("notation", `updiagonalarrow`)
+
+    return new mathMLTree.MathNode("msup", [expression, value])
+  }
+})

package/src/functions/char.js

@@ -0,0 +1,33 @@
+import defineFunction from "../defineFunction"
+import ParseError from "../ParseError"
+import { assertNodeType } from "../parseNode"
+
+// \@char is an internal function that takes a grouped decimal argument like
+// {123} and converts into symbol with code 123.  It is used by the *macro*
+// \char defined in macros.js.
+defineFunction({
+  type: "textord",
+  names: ["\\@char"],
+  props: {
+    numArgs: 1,
+    allowedInText: true
+  },
+  handler({ parser, token }, args) {
+    const arg = assertNodeType(args[0], "ordgroup")
+    const group = arg.body
+    let number = ""
+    for (let i = 0; i < group.length; i++) {
+      const node = assertNodeType(group[i], "textord")
+      number += node.text
+    }
+    const code = parseInt(number)
+    if (isNaN(code)) {
+      throw new ParseError(`\\@char has non-numeric argument ${number}`, token)
+    }
+    return {
+      type: "textord",
+      mode: parser.mode,
+      text: String.fromCodePoint(code)
+    }
+  }
+})