temml 0.9.1

package/src/functions/ref.js

@@ -0,0 +1,28 @@
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import { invalidIdRegEx } from "./label";
+
+defineFunction({
+  type: "ref",
+  names: ["\\ref", "\\eqref"],
+  props: {
+    numArgs: 1,
+    argTypes: ["raw"]
+  },
+  handler({ parser, funcName }, args) {
+    return {
+      type: "ref",
+      mode: parser.mode,
+      funcName,
+      string: args[0].string.replace(invalidIdRegEx, "")
+    };
+  },
+  mathmlBuilder(group, style) {
+    // Create an empty text node. Set a class and an href.
+    // 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
+  }
+});

package/src/functions/relax.js

@@ -0,0 +1,16 @@
+import defineFunction from "../defineFunction"
+
+defineFunction({
+  type: "internal",
+  names: ["\\relax"],
+  props: {
+    numArgs: 0,
+    allowedInText: true
+  },
+  handler({ parser }) {
+    return {
+      type: "internal",
+      mode: parser.mode
+    };
+  }
+})

package/src/functions/rule.js

@@ -0,0 +1,52 @@
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import { assertNodeType } from "../parseNode";
+import { calculateSize } from "../units";
+
+defineFunction({
+  type: "rule",
+  names: ["\\rule"],
+  props: {
+    numArgs: 2,
+    numOptionalArgs: 1,
+    argTypes: ["size", "size", "size"]
+  },
+  handler({ parser }, args, optArgs) {
+    const shift = optArgs[0];
+    const width = assertNodeType(args[0], "size");
+    const height = assertNodeType(args[1], "size");
+    return {
+      type: "rule",
+      mode: parser.mode,
+      shift: shift && assertNodeType(shift, "size").value,
+      width: width.value,
+      height: height.value
+    };
+  },
+  mathmlBuilder(group, style) {
+    const width = calculateSize(group.width, style);
+    const height = calculateSize(group.height, style);
+    const shift = group.shift
+      ? calculateSize(group.shift, style)
+      : { number: 0, unit: "em" };
+    const color = (style.color && style.getColor()) || "black";
+
+    const rule = new mathMLTree.MathNode("mspace");
+    if (width.number > 0 && height.number > 0) {
+      rule.setAttribute("mathbackground", color);
+    }
+    rule.setAttribute("width", width.number + width.unit);
+    rule.setAttribute("height", height.number + height.unit);
+    if (shift.number === 0) { return rule }
+
+    const wrapper = new mathMLTree.MathNode("mpadded", [rule]);
+    if (shift.number >= 0) {
+      wrapper.setAttribute("height", "+" + shift.number + shift.unit);
+    } else {
+      wrapper.setAttribute("height", shift.number + shift.unit);
+      wrapper.setAttribute("depth", "+" + -shift.number + shift.unit);
+    }
+    wrapper.setAttribute("voffset", shift.number + shift.unit);
+    return wrapper;
+  }
+});

package/src/functions/sizing.js

@@ -0,0 +1,64 @@
+import defineFunction from "../defineFunction";
+import { wrapWithMstyle } from "../mathMLTree"
+import * as mml from "../buildMathML";
+
+// The size mappings are taken from TeX with \normalsize=10pt.
+// We don't have to track script level. MathML does that.
+const sizeMap = {
+  "\\tiny": 0.5,
+  "\\sixptsize": 0.6,
+  "\\Tiny": 0.6,
+  "\\scriptsize": 0.7,
+  "\\footnotesize": 0.8,
+  "\\small": 0.9,
+  "\\normalsize": 1.0,
+  "\\large": 1.2,
+  "\\Large": 1.44,
+  "\\LARGE": 1.728,
+  "\\huge": 2.074,
+  "\\Huge": 2.488
+};
+
+defineFunction({
+  type: "sizing",
+  names: [
+    "\\tiny",
+    "\\sixptsize",
+    "\\Tiny",
+    "\\scriptsize",
+    "\\footnotesize",
+    "\\small",
+    "\\normalsize",
+    "\\large",
+    "\\Large",
+    "\\LARGE",
+    "\\huge",
+    "\\Huge"
+  ],
+  props: {
+    numArgs: 0,
+    allowedInText: true
+  },
+  handler: ({ breakOnTokenText, funcName, parser }, args) => {
+    if (parser.settings.strict && parser.mode === "math") {
+      // eslint-disable-next-line no-console
+      console.log(`Temml strict-mode warning: Command ${funcName} is invalid in math mode.`)
+    }
+    const body = parser.parseExpression(false, breakOnTokenText);
+    return {
+      type: "sizing",
+      mode: parser.mode,
+      funcName,
+      body
+    };
+  },
+  mathmlBuilder: (group, style) => {
+    const newStyle = style.withFontSize(sizeMap[group.funcName]);
+    const inner = mml.buildExpression(group.body, newStyle);
+    // Wrap with an <mstyle> element.
+    const node = wrapWithMstyle(inner)
+    const factor = (sizeMap[group.funcName] / style.fontSize).toFixed(4)
+    node.setAttribute("mathsize", factor + "em");
+    return node;
+  }
+});

package/src/functions/smash.js

@@ -0,0 +1,66 @@
+// smash, with optional [tb], as in AMS
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import { assertNodeType } from "../parseNode";
+
+import * as mml from "../buildMathML";
+
+defineFunction({
+  type: "smash",
+  names: ["\\smash"],
+  props: {
+    numArgs: 1,
+    numOptionalArgs: 1,
+    allowedInText: true
+  },
+  handler: ({ parser }, args, optArgs) => {
+    let smashHeight = false;
+    let smashDepth = false;
+    const tbArg = optArgs[0] && assertNodeType(optArgs[0], "ordgroup");
+    if (tbArg) {
+      // Optional [tb] argument is engaged.
+      // ref: amsmath: \renewcommand{\smash}[1][tb]{%
+      //               def\mb@t{\ht}\def\mb@b{\dp}\def\mb@tb{\ht\z@\z@\dp}%
+      let letter = "";
+      for (let i = 0; i < tbArg.body.length; ++i) {
+        const node = tbArg.body[i];
+        // TODO: Write an AssertSymbolNode
+        letter = node.text;
+        if (letter === "t") {
+          smashHeight = true;
+        } else if (letter === "b") {
+          smashDepth = true;
+        } else {
+          smashHeight = false;
+          smashDepth = false;
+          break;
+        }
+      }
+    } else {
+      smashHeight = true;
+      smashDepth = true;
+    }
+
+    const body = args[0];
+    return {
+      type: "smash",
+      mode: parser.mode,
+      body,
+      smashHeight,
+      smashDepth
+    };
+  },
+  mathmlBuilder: (group, style) => {
+    const node = new mathMLTree.MathNode("mpadded", [mml.buildGroup(group.body, style)]);
+
+    if (group.smashHeight) {
+      node.setAttribute("height", "0px");
+    }
+
+    if (group.smashDepth) {
+      node.setAttribute("depth", "0px");
+    }
+
+    return node;
+  }
+});

package/src/functions/sqrt.js

@@ -0,0 +1,31 @@
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import * as mml from "../buildMathML";
+
+defineFunction({
+  type: "sqrt",
+  names: ["\\sqrt"],
+  props: {
+    numArgs: 1,
+    numOptionalArgs: 1
+  },
+  handler({ parser }, args, optArgs) {
+    const index = optArgs[0];
+    const body = args[0];
+    return {
+      type: "sqrt",
+      mode: parser.mode,
+      body,
+      index
+    };
+  },
+  mathmlBuilder(group, style) {
+    const { body, index } = group;
+    return index
+      ? new mathMLTree.MathNode("mroot", [
+        mml.buildGroup(body, style),
+        mml.buildGroup(index, style.incrementLevel())
+      ])
+    : new mathMLTree.MathNode("msqrt", [mml.buildGroup(body, style)]);
+  }
+});

package/src/functions/styling.js

@@ -0,0 +1,58 @@
+import defineFunction from "../defineFunction";
+import { wrapWithMstyle } from "../mathMLTree"
+import * as mml from "../buildMathML";
+
+const styleMap = {
+  display: 0,
+  text: 1,
+  script: 2,
+  scriptscript: 3
+};
+
+const styleAttributes = {
+  display: ["0", "true"],
+  text: ["0", "false"],
+  script: ["1", "false"],
+  scriptscript: ["2", "false"]
+};
+
+defineFunction({
+  type: "styling",
+  names: ["\\displaystyle", "\\textstyle", "\\scriptstyle", "\\scriptscriptstyle"],
+  props: {
+    numArgs: 0,
+    allowedInText: true,
+    primitive: true
+  },
+  handler({ breakOnTokenText, funcName, parser }, args) {
+    // parse out the implicit body
+    const body = parser.parseExpression(true, breakOnTokenText);
+
+    const scriptLevel = funcName.slice(1, funcName.length - 5);
+    return {
+      type: "styling",
+      mode: parser.mode,
+      // Figure out what scriptLevel to use by pulling out the scriptLevel from
+      // the function name
+      scriptLevel,
+      body
+    };
+  },
+  mathmlBuilder(group, style) {
+    // Figure out what scriptLevel we're changing to.
+    const newStyle = style.withLevel(styleMap[group.scriptLevel]);
+    // The style argument in the next line does NOT directly set a MathML script level.
+    // It just tracks the style level, in case we need to know it for supsub or mathchoice.
+    const inner = mml.buildExpression(group.body, newStyle);
+    // Wrap with an <mstyle> element.
+    const node = wrapWithMstyle(inner)
+
+    const attr = styleAttributes[group.scriptLevel];
+
+    // Here is where we set the MathML script level.
+    node.setAttribute("scriptlevel", attr[0]);
+    node.setAttribute("displaystyle", attr[1]);
+
+    return node;
+  }
+});

package/src/functions/supsub.js

@@ -0,0 +1,135 @@
+import { defineFunctionBuilders } from "../defineFunction"
+import { StyleLevel } from "../constants"
+import mathMLTree from "../mathMLTree"
+import * as mml from "../buildMathML"
+
+/**
+ * Sometimes, groups perform special rules when they have superscripts or
+ * subscripts attached to them. This function lets the `supsub` group know that
+ * Sometimes, groups perform special rules when they have superscripts or
+ * its inner element should handle the superscripts and subscripts instead of
+ * handling them itself.
+ */
+
+// Helpers
+const symbolRegEx = /^m(over|under|underover)$/
+
+// Super scripts and subscripts, whose precise placement can depend on other
+// functions that precede them.
+defineFunctionBuilders({
+  type: "supsub",
+  mathmlBuilder(group, style) {
+    // Is the inner group a relevant horizonal brace?
+    let isBrace = false
+    let isOver
+    let isSup
+    let appendApplyFunction = false
+    let needsLeadingSpace = false
+
+    if (group.base && group.base.type === "horizBrace") {
+      isSup = !!group.sup
+      if (isSup === group.base.isOver) {
+        isBrace = true
+        isOver = group.base.isOver
+      }
+    }
+
+    if (group.base && !group.base.stack &&
+      (group.base.type === "op" || group.base.type === "operatorname")) {
+      group.base.parentIsSupSub = true
+      appendApplyFunction = !group.base.symbol
+      needsLeadingSpace = group.base.needsLeadingSpace
+    }
+
+    const children = group.base && group.base.stack
+      ? [mml.buildGroup(group.base.body[0], style)]
+      : [mml.buildGroup(group.base, style)]
+
+    const childStyle = style.inSubOrSup()
+    if (group.sub) {
+      children.push(mml.buildGroup(group.sub, childStyle))
+    }
+
+    if (group.sup) {
+      children.push(mml.buildGroup(group.sup, childStyle))
+    }
+
+    let nodeType;
+    if (isBrace) {
+      nodeType = isOver ? "mover" : "munder"
+    } else if (!group.sub) {
+      const base = group.base
+      if (
+        base &&
+        base.type === "op" &&
+        base.limits &&
+        (style.level === StyleLevel.DISPLAY || base.alwaysHandleSupSub)
+      ) {
+        nodeType = "mover"
+      } else if (
+        base &&
+        base.type === "operatorname" &&
+        base.alwaysHandleSupSub &&
+        (base.limits || style.level === StyleLevel.DISPLAY)
+      ) {
+        nodeType = "mover"
+      } else {
+        nodeType = "msup"
+      }
+    } else if (!group.sup) {
+      const base = group.base;
+      if (
+        base &&
+        base.type === "op" &&
+        base.limits &&
+        (style.level === StyleLevel.DISPLAY || base.alwaysHandleSupSub)
+      ) {
+        nodeType = "munder";
+      } else if (
+        base &&
+        base.type === "operatorname" &&
+        base.alwaysHandleSupSub &&
+        (base.limits || style.level === StyleLevel.DISPLAY)
+      ) {
+        nodeType = "munder"
+      } else {
+        nodeType = "msub"
+      }
+    } else {
+      const base = group.base;
+      if (base && ((base.type === "op" && base.limits) || base.type === "multiscript") &&
+        (style.level === StyleLevel.DISPLAY || base.alwaysHandleSupSub)
+      ) {
+        nodeType = "munderover"
+      } else if (
+        base &&
+        base.type === "operatorname" &&
+        base.alwaysHandleSupSub &&
+        (style.level === StyleLevel.DISPLAY || base.limits)
+      ) {
+        nodeType = "munderover"
+      } else {
+        nodeType = "msubsup"
+      }
+    }
+
+    let node = new mathMLTree.MathNode(nodeType, children)
+    if (appendApplyFunction) {
+      // Append an <mo>&ApplyFunction;</mo>.
+      // ref: https://www.w3.org/TR/REC-MathML/chap3_2.html#sec3.2.4
+      const operator = new mathMLTree.MathNode("mo", [mml.makeText("\u2061", "text")])
+      if (needsLeadingSpace) {
+        const space = new mathMLTree.MathNode("mspace")
+        space.setAttribute("width", "0.1667em") // thin space.
+        node = mathMLTree.newDocumentFragment([space, node, operator])
+      } else {
+        node = mathMLTree.newDocumentFragment([node, operator])
+      }
+    } else if (symbolRegEx.test(nodeType)) {
+      // Wrap in a <mrow>. Otherwise Firefox stretchy parens will not stretch to include limits.
+      node = new mathMLTree.MathNode("mrow", [node])
+    }
+
+    return node
+  }
+});

package/src/functions/symbolsOp.js

@@ -0,0 +1,53 @@
+import { defineFunctionBuilders } from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import * as mml from "../buildMathML";
+
+// Operator ParseNodes created in Parser.js from symbol Groups in src/symbols.js.
+
+const short = ["\\shortmid", "\\nshortmid", "\\shortparallel",
+  "\\nshortparallel", "\\smallsetminus"]
+
+const arrows = ["\\Rsh", "\\Lsh", "\\restriction"]
+
+const isArrow = str => {
+  if (str.length === 1) {
+    const codePoint = str.codePointAt(0)
+    return (0x218f < codePoint && codePoint < 0x2200)
+  }
+  return str.indexOf("arrow") > -1 || str.indexOf("harpoon") > -1 || arrows.includes(str)
+}
+
+defineFunctionBuilders({
+  type: "atom",
+  mathmlBuilder(group, style) {
+    const node = new mathMLTree.MathNode("mo", [mml.makeText(group.text, group.mode)]);
+    if (group.family === "punct") {
+      node.setAttribute("separator", "true");
+    } else if (group.family === "open" || group.family === "close") {
+      // Delims built here should not stretch vertically.
+      // See delimsizing.js for stretchy delims.
+      if (group.family === "open") {
+        node.setAttribute("form", "prefix")
+        // Set an explicit attribute for stretch. Otherwise Firefox may do it wrong.
+        node.setAttribute("stretchy", "false")
+      } else if (group.family === "close") {
+        node.setAttribute("form", "postfix");
+        node.setAttribute("stretchy", "false")
+      }
+    } else if (group.text === "\\mid") {
+      // Firefox messes up this spacing if at the end of an <mrow>. See it explicitly.
+      node.setAttribute("lspace", "0.22em") // medium space
+      node.setAttribute("rspace", "0.22em")
+      node.setAttribute("stretchy", "false")
+    } else if (group.family === "rel" && isArrow(group.text)) {
+      node.setAttribute("stretchy", "false")
+    } else if (short.includes(group.text)) {
+      node.setAttribute("mathsize", "70%")
+    } else if (group.text === ":") {
+      // ":" is not in the MathML operator dictionary. Give it BIN spacing.
+      node.attributes.lspace = "0.2222em"
+      node.attributes.rspace = "0.2222em"
+    }
+    return node;
+  }
+});

package/src/functions/symbolsOrd.js

@@ -0,0 +1,102 @@
+import { defineFunctionBuilders } from "../defineFunction"
+import { getVariant } from "../variant"
+import { variantChar, smallCaps } from "../replace"
+import mathMLTree from "../mathMLTree"
+import * as mml from "../buildMathML"
+
+// "mathord" and "textord" ParseNodes created in Parser.js from symbol Groups in
+// src/symbols.js.
+
+const numberRegEx = /^\d(?:[\d,.]*\d)?$/  // Keep in sync with numberRegEx in Parser.js
+const latinRegEx = /[A-Ba-z]/
+
+const italicNumber = (text, variant) => {
+  const mn = new mathMLTree.MathNode("mn", [text])
+  const wrapper = new mathMLTree.MathNode("mstyle", [mn])
+  wrapper.style["font-style"] = "italic"
+  wrapper.style["font-family"] = "Cambria, 'Times New Roman', serif"
+  if (variant === "bold-italic") { wrapper.style["font-weight"] = "bold" }
+  return wrapper
+}
+
+defineFunctionBuilders({
+  type: "mathord",
+  mathmlBuilder(group, style) {
+    const text = mml.makeText(group.text, group.mode, style)
+    const codePoint = text.text.codePointAt(0)
+    // Test for upper-case Greek
+    const defaultVariant = (0x0390 < codePoint && codePoint < 0x03aa) ? "normal" : "italic"
+    const variant = getVariant(group, style) || defaultVariant
+    if (variant === "script") {
+      text.text = variantChar(text.text, variant)
+      return new mathMLTree.MathNode("mi", [text], [style.font])
+    } else if (variant !== "italic") {
+      text.text = variantChar(text.text, variant)
+    }
+    let node = new mathMLTree.MathNode("mi", [text])
+    // TODO: Handle U+1D49C - U+1D4CF per https://www.unicode.org/charts/PDF/U1D400.pdf
+    if (variant === "normal") {
+      node.setAttribute("mathvariant", "normal")
+      if (text.text.length === 1) {
+        // A Firefox bug will apply spacing here, but there should be none. Fix it.
+        node = new mathMLTree.MathNode("mrow", [node])
+      }
+    }
+    return node
+  }
+})
+
+defineFunctionBuilders({
+  type: "textord",
+  mathmlBuilder(group, style) {
+    let ch = group.text
+    const codePoint = ch.codePointAt(0)
+    if (style.fontFamily === "textsc") {
+      // Convert small latin letters to small caps.
+      if (96 < codePoint && codePoint < 123) {
+        ch = smallCaps[ch]
+      }
+    }
+    const text = mml.makeText(ch, group.mode, style)
+    const variant = getVariant(group, style) || "normal"
+
+    let node
+    if (group.mode === "text") {
+      if (variant === "italic" || variant === "bold-italic") {
+        if (numberRegEx.test(group.text)) {
+          return italicNumber(text, variant)
+        }
+      }
+      if (variant !== "normal") {
+        text.text = variantChar(text.text, variant)
+      }
+      node = new mathMLTree.MathNode("mtext", [text])
+    } else if (numberRegEx.test(group.text)) {
+      if (variant === "oldstylenums") {
+        const ms = new mathMLTree.MathNode("mstyle", [text], ["oldstylenums"])
+        node = new mathMLTree.MathNode("mn", [ms])
+      } else if (variant === "italic" || variant === "bold-italic") {
+        return italicNumber(text, variant)
+      } else {
+        if (variant !== "normal") {
+          text.text = text.text.split("").map(c => variantChar(c, variant)).join("")
+        }
+        node = new mathMLTree.MathNode("mn", [text])
+      }
+    } else if (group.text === "\\prime") {
+      node = new mathMLTree.MathNode("mo", [text])
+      // TODO: If/when Chromium uses ssty variant for prime, remove the next line.
+      node.classes.push("tml-prime")
+    } else {
+      const origText = text.text
+      if (variant !== "italic") {
+        text.text = variantChar(text.text, variant)
+      }
+      node = new mathMLTree.MathNode("mi", [text])
+      if (text.text === origText && latinRegEx.test(origText)) {
+        node.setAttribute("mathvariant", "italic")
+      }
+    }
+    return node
+  }
+})

package/src/functions/symbolsSpacing.js

@@ -0,0 +1,53 @@
+import { defineFunctionBuilders } from "../defineFunction"
+import mathMLTree from "../mathMLTree"
+import ParseError from "../ParseError"
+
+// A map of CSS-based spacing functions to their CSS class.
+const cssSpace = {
+  "\\nobreak": "nobreak",
+  "\\allowbreak": "allowbreak"
+}
+
+// A lookup table to determine whether a spacing function/symbol should be
+// treated like a regular space character.  If a symbol or command is a key
+// in this table, then it should be a regular space character.  Furthermore,
+// the associated value may have a `className` specifying an extra CSS class
+// to add to the created `span`.
+const regularSpace = {
+  " ": {},
+  "\\ ": {},
+  "~": {
+    className: "nobreak"
+  },
+  "\\space": {},
+  "\\nobreakspace": {
+    className: "nobreak"
+  }
+}
+
+// ParseNode<"spacing"> created in Parser.js from the "spacing" symbol Groups in
+// src/symbols.js.
+defineFunctionBuilders({
+  type: "spacing",
+  mathmlBuilder(group, style) {
+    let node
+
+    if (Object.prototype.hasOwnProperty.call(regularSpace, group.text)) {
+      // Firefox does not render a space in a <mtext> </mtext>. So write a no-break space.
+      // TODO: If Firefox fixes that bug, uncomment the next line and write ch into the node.
+      //const ch = (regularSpace[group.text].className === "nobreak") ? "\u00a0" : " "
+      node = new mathMLTree.MathNode("mtext", [new mathMLTree.TextNode("\u00a0")])
+    } else if (Object.prototype.hasOwnProperty.call(cssSpace, group.text)) {
+      // MathML 3.0 calls for nobreak to occur in an <mo>, not an <mtext>
+      // Ref: https://www.w3.org/Math/draft-spec/mathml.html#chapter3_presm.lbattrs
+      node = new mathMLTree.MathNode("mo")
+      if (group.text === "\\nobreak") {
+        node.setAttribute("linebreak", "nobreak")
+      }
+    } else {
+      throw new ParseError(`Unknown type of space "${group.text}"`)
+    }
+
+    return node
+  }
+})

package/src/functions/tag.js

@@ -0,0 +1,8 @@
+import { defineFunctionBuilders } from "../defineFunction";
+
+defineFunctionBuilders({
+  type: "tag"
+});
+
+// For a \tag, the work usually done in a mathmlBuilder is instead done in buildMathML.js.
+// That way, a \tag can be pulled out of the parse tree and wrapped around the outer node.