temml 0.9.1

package/src/functions/includegraphics.js

@@ -0,0 +1,131 @@
+import defineFunction from "../defineFunction"
+import { calculateSize, validUnit } from "../units"
+import ParseError from "../ParseError"
+import { Img } from "../domTree"
+import mathMLTree from "../mathMLTree"
+import { assertNodeType } from "../parseNode"
+
+const sizeData = function(str) {
+  if (/^[-+]? *(\d+(\.\d*)?|\.\d+)$/.test(str)) {
+    // str is a number with no unit specified.
+    // default unit is bp, per graphix package.
+    return { number: +str, unit: "bp" }
+  } else {
+    const match = /([-+]?) *(\d+(?:\.\d*)?|\.\d+) *([a-z]{2})/.exec(str);
+    if (!match) {
+      throw new ParseError("Invalid size: '" + str + "' in \\includegraphics");
+    }
+    const data = {
+      number: +(match[1] + match[2]), // sign + magnitude, cast to number
+      unit: match[3]
+    }
+    if (!validUnit(data)) {
+      throw new ParseError("Invalid unit: '" + data.unit + "' in \\includegraphics.");
+    }
+    return data
+  }
+}
+
+defineFunction({
+  type: "includegraphics",
+  names: ["\\includegraphics"],
+  props: {
+    numArgs: 1,
+    numOptionalArgs: 1,
+    argTypes: ["raw", "url"],
+    allowedInText: false
+  },
+  handler: ({ parser, token }, args, optArgs) => {
+    let width = { number: 0, unit: "em" }
+    let height = { number: 0.9, unit: "em" }  // sorta character sized.
+    let totalheight = { number: 0, unit: "em" }
+    let alt = ""
+
+    if (optArgs[0]) {
+      const attributeStr = assertNodeType(optArgs[0], "raw").string
+
+      // Parser.js does not parse key/value pairs. We get a string.
+      const attributes = attributeStr.split(",")
+      for (let i = 0; i < attributes.length; i++) {
+        const keyVal = attributes[i].split("=")
+        if (keyVal.length === 2) {
+          const str = keyVal[1].trim()
+          switch (keyVal[0].trim()) {
+            case "alt":
+              alt = str
+              break
+            case "width":
+              width = sizeData(str)
+              break
+            case "height":
+              height = sizeData(str)
+              break
+            case "totalheight":
+              totalheight = sizeData(str)
+              break
+            default:
+              throw new ParseError("Invalid key: '" + keyVal[0] + "' in \\includegraphics.")
+          }
+        }
+      }
+    }
+
+    const src = assertNodeType(args[0], "url").url
+
+    if (alt === "") {
+      // No alt given. Use the file name. Strip away the path.
+      alt = src
+      alt = alt.replace(/^.*[\\/]/, "")
+      alt = alt.substring(0, alt.lastIndexOf("."))
+    }
+
+    if (
+      !parser.settings.isTrusted({
+        command: "\\includegraphics",
+        url: src
+      })
+    ) {
+      throw new ParseError(`Function "\\includegraphics" is not trusted`, token)
+    }
+
+    return {
+      type: "includegraphics",
+      mode: parser.mode,
+      alt: alt,
+      width: width,
+      height: height,
+      totalheight: totalheight,
+      src: src
+    }
+  },
+  mathmlBuilder: (group, style) => {
+    const height = calculateSize(group.height, style)
+    const depth = { number: 0, unit: "em" }
+
+    if (group.totalheight.number > 0) {
+      if (group.totalheight.unit === height.unit &&
+        group.totalheight.number > height.number) {
+        depth.number = group.totalheight.number - height.number
+        depth.unit = height.unit
+      }
+    }
+
+    let width = 0
+    if (group.width.number > 0) {
+      width = calculateSize(group.width, style)
+    }
+
+    const graphicStyle = { height: height.number + depth.number + "em" }
+    if (width.number > 0) {
+      graphicStyle.width = width.number + width.unit
+    }
+    if (depth.number > 0) {
+      graphicStyle.verticalAlign = -depth.number + depth.unit
+    }
+
+    const node = new Img(group.src, group.alt, graphicStyle)
+    node.height = height
+    node.depth = depth
+    return new mathMLTree.MathNode("mtext", [node])
+  }
+})

package/src/functions/kern.js

@@ -0,0 +1,75 @@
+// Horizontal spacing commands
+
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import { calculateSize } from "../units";
+import { assertNodeType } from "../parseNode";
+import ParseError from "../ParseError"
+
+// TODO: \hskip and \mskip should support plus and minus in lengths
+
+defineFunction({
+  type: "kern",
+  names: ["\\kern", "\\mkern", "\\hskip", "\\mskip"],
+  props: {
+    numArgs: 1,
+    argTypes: ["size"],
+    primitive: true,
+    allowedInText: true
+  },
+  handler({ parser, funcName, token }, args) {
+    const size = assertNodeType(args[0], "size");
+    if (parser.settings.strict) {
+      const mathFunction = funcName[1] === "m"; // \mkern, \mskip
+      const muUnit = size.value.unit === "mu";
+      if (mathFunction) {
+        if (!muUnit) {
+          throw new ParseError(`LaTeX's ${funcName} supports only mu units, ` +
+            `not ${size.value.unit} units`, token)
+        }
+        if (parser.mode !== "math") {
+          throw new ParseError(`LaTeX's ${funcName} works only in math mode`, token)
+        }
+      } else {
+        // !mathFunction
+        if (muUnit) {
+          throw new ParseError(`LaTeX's ${funcName} doesn't support mu units`, token)
+        }
+      }
+    }
+    return {
+      type: "kern",
+      mode: parser.mode,
+      dimension: size.value
+    };
+  },
+  mathmlBuilder(group, style) {
+    const dimension = calculateSize(group.dimension, style);
+    const ch = dimension.unit === "em" ? spaceCharacter(dimension.number) : "";
+    if (group.mode === "text" && ch.length > 0) {
+      const character = new mathMLTree.TextNode(ch);
+      return new mathMLTree.MathNode("mtext", [character]);
+    } else {
+      const node = new mathMLTree.MathNode("mspace");
+      node.setAttribute("width", dimension.number + dimension.unit);
+      if (dimension.number < 0) {
+        node.style.marginLeft = dimension.number + dimension.unit
+      }
+      return node;
+    }
+  }
+});
+
+export const spaceCharacter = function(width) {
+  if (width >= 0.05555 && width <= 0.05556) {
+    return "\u200a"; // &VeryThinSpace;
+  } else if (width >= 0.1666 && width <= 0.1667) {
+    return "\u2009"; // &ThinSpace;
+  } else if (width >= 0.2222 && width <= 0.2223) {
+    return "\u2005"; // &MediumSpace;
+  } else if (width >= 0.2777 && width <= 0.2778) {
+    return "\u2005\u200a"; // &ThickSpace;
+  } else {
+    return "";
+  }
+};

package/src/functions/label.js

@@ -0,0 +1,29 @@
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+
+// Limit valid characters to a small set, for safety.
+export const invalidIdRegEx = /[^A-Za-z_0-9-]/g
+
+defineFunction({
+  type: "label",
+  names: ["\\label"],
+  props: {
+    numArgs: 1,
+    argTypes: ["raw"]
+  },
+  handler({ parser }, args) {
+    return {
+      type: "label",
+      mode: parser.mode,
+      string: args[0].string.replace(invalidIdRegEx, "")
+    };
+  },
+  mathmlBuilder(group, style) {
+    // 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)
+    }
+    return node
+  }
+});

package/src/functions/lap.js

@@ -0,0 +1,75 @@
+// Horizontal overlap functions
+import defineFunction, { ordargument } from "../defineFunction";
+import mathMLTree from "../mathMLTree"
+import * as mml from "../buildMathML"
+import ParseError from "../ParseError";
+
+const textModeLap = ["\\clap", "\\llap", "\\rlap"]
+
+defineFunction({
+  type: "lap",
+  names: ["\\mathllap", "\\mathrlap", "\\mathclap", "\\clap", "\\llap", "\\rlap"],
+  props: {
+    numArgs: 1,
+    allowedInText: true
+  },
+  handler: ({ parser, funcName, token }, args) => {
+    if (textModeLap.includes(funcName)) {
+      if (parser.settings.strict && parser.mode !== "text") {
+        throw new ParseError(`{${funcName}} can be used only in text mode.
+ Try \\math${funcName.slice(1)}`, token)
+      }
+      funcName = funcName.slice(1)
+    } else {
+      funcName = funcName.slice(5)
+    }
+    const body = args[0]
+    return {
+      type: "lap",
+      mode: parser.mode,
+      alignment: funcName,
+      body
+    }
+  },
+  mathmlBuilder: (group, style) => {
+    // mathllap, mathrlap, mathclap
+    let strut
+    if (group.alignment === "llap") {
+      // We need an invisible strut with the same depth as the group.
+      // We can't just read the depth, so we use \vphantom methods.
+      const phantomInner = mml.buildExpression(ordargument(group.body), style);
+      const phantom = new mathMLTree.MathNode("mphantom", phantomInner);
+      strut = new mathMLTree.MathNode("mpadded", [phantom]);
+      strut.setAttribute("width", "0px");
+    }
+
+    const inner = mml.buildGroup(group.body, style)
+    let node
+    if (group.alignment === "llap") {
+      inner.style.position = "absolute"
+      inner.style.right = "0"
+      inner.style.bottom = `0` // If we could have read the ink depth, it would go here.
+      node = new mathMLTree.MathNode("mpadded", [strut, inner])
+    } else {
+      node = new mathMLTree.MathNode("mpadded", [inner])
+    }
+
+    if (group.alignment === "rlap") {
+      if (group.body.body.length > 0 && group.body.body[0].type === "genfrac") {
+        // In Firefox, a <mpadded> squashes the 3/18em padding of a child \frac. Put it back.
+        node.setAttribute("lspace", "0.16667em")
+      }
+    } else {
+      const offset = group.alignment === "llap" ? "-1" : "-0.5"
+      node.setAttribute("lspace", offset + "width")
+      if (group.alignment === "llap") {
+        node.style.position = "relative"
+      } else {
+        node.style.display = "flex"
+        node.style.justifyContent = "center"
+      }
+    }
+    node.setAttribute("width", "0px")
+    return node
+  }
+})

package/src/functions/math.js

@@ -0,0 +1,40 @@
+import defineFunction from "../defineFunction";
+import ParseError from "../ParseError";
+
+// Switching from text mode back to math mode
+defineFunction({
+  type: "ordgroup",
+  names: ["\\(", "$"],
+  props: {
+    numArgs: 0,
+    allowedInText: true,
+    allowedInMath: false
+  },
+  handler({ funcName, parser }, args) {
+    const outerMode = parser.mode;
+    parser.switchMode("math");
+    const close = funcName === "\\(" ? "\\)" : "$";
+    const body = parser.parseExpression(false, close);
+    parser.expect(close);
+    parser.switchMode(outerMode);
+    return {
+      type: "ordgroup",
+      mode: parser.mode,
+      body
+    };
+  }
+});
+
+// Check for extra closing math delimiters
+defineFunction({
+  type: "text", // Doesn't matter what this is.
+  names: ["\\)", "\\]"],
+  props: {
+    numArgs: 0,
+    allowedInText: true,
+    allowedInMath: false
+  },
+  handler(context, token) {
+    throw new ParseError(`Mismatched ${context.funcName}`, token);
+  }
+});

package/src/functions/mathchoice.js

@@ -0,0 +1,41 @@
+import defineFunction, { ordargument } from "../defineFunction";
+import { StyleLevel } from "../constants";
+import * as mml from "../buildMathML";
+
+const chooseStyle = (group, style) => {
+  switch (style.level) {
+    case StyleLevel.DISPLAY:       // 0
+      return group.display;
+    case StyleLevel.TEXT:          // 1
+      return group.text;
+    case StyleLevel.SCRIPT:        // 2
+      return group.script;
+    case StyleLevel.SCRIPTSCRIPT:  // 3
+      return group.scriptscript;
+    default:
+      return group.text;
+  }
+};
+
+defineFunction({
+  type: "mathchoice",
+  names: ["\\mathchoice"],
+  props: {
+    numArgs: 4,
+    primitive: true
+  },
+  handler: ({ parser }, args) => {
+    return {
+      type: "mathchoice",
+      mode: parser.mode,
+      display: ordargument(args[0]),
+      text: ordargument(args[1]),
+      script: ordargument(args[2]),
+      scriptscript: ordargument(args[3])
+    };
+  },
+  mathmlBuilder: (group, style) => {
+    const body = chooseStyle(group, style);
+    return mml.buildExpressionRow(body, style);
+  }
+});

package/src/functions/mclass.js

@@ -0,0 +1,201 @@
+import defineFunction, { ordargument } from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import utils from "../utils";
+
+import * as mml from "../buildMathML";
+
+const textAtomTypes = ["text", "textord", "mathord", "atom"]
+
+const padding = width => {
+  const node = new mathMLTree.MathNode("mspace")
+  node.setAttribute("width", width + "em")
+  return node
+}
+
+function mathmlBuilder(group, style) {
+  let node;
+  const inner = mml.buildExpression(group.body, style);
+
+  if (group.mclass === "minner") {
+    node = new mathMLTree.MathNode("mpadded", inner)
+  } else if (group.mclass === "mord") {
+    if (group.isCharacterBox || inner[0].type === "mathord") {
+      node = inner[0];
+      node.type = "mi";
+    } else {
+      node = new mathMLTree.MathNode("mi", inner);
+    }
+  } else {
+    node = new mathMLTree.MathNode("mrow", inner)
+    if (group.mustPromote) {
+      node = inner[0];
+      node.type = "mo";
+      if (group.isCharacterBox && group.body[0].text && /[A-Za-z]/.test(group.body[0].text)) {
+        node.setAttribute("mathvariant", "italic")
+      }
+    } else {
+      node = new mathMLTree.MathNode("mrow", inner);
+    }
+
+    // Set spacing based on what is the most likely adjacent atom type.
+    // See TeXbook p170.
+    const doSpacing = style.level < 2 // Operator spacing is zero inside a (sub|super)script.
+    if (node.type === "mrow") {
+      if (doSpacing ) {
+        if (group.mclass === "mbin") {
+          // medium space
+          node.children.unshift(padding(0.2222))
+          node.children.push(padding(0.2222))
+        } else if (group.mclass === "mrel") {
+          // thickspace
+          node.children.unshift(padding(0.2778))
+          node.children.push(padding(0.2778))
+        } else if (group.mclass === "mpunct") {
+          node.children.push(padding(0.1667))
+        } else if (group.mclass === "minner") {
+          node.children.unshift(padding(0.0556))  // 1 mu is the most likely option
+          node.children.push(padding(0.0556))
+        }
+      }
+    } else {
+      if (group.mclass === "mbin") {
+        // medium space
+        node.attributes.lspace = (doSpacing ? "0.2222em" : "0")
+        node.attributes.rspace = (doSpacing ? "0.2222em" : "0")
+      } else if (group.mclass === "mrel") {
+        // thickspace
+        node.attributes.lspace = (doSpacing ? "0.2778em" : "0")
+        node.attributes.rspace = (doSpacing ? "0.2778em" : "0")
+      } else if (group.mclass === "mpunct") {
+        node.attributes.lspace = "0em";
+        node.attributes.rspace = (doSpacing ? "0.1667em" : "0")
+      } else if (group.mclass === "mopen" || group.mclass === "mclose") {
+        node.attributes.lspace = "0em"
+        node.attributes.rspace = "0em"
+      } else if (group.mclass === "minner" && doSpacing) {
+        node.attributes.lspace = "0.0556em" // 1 mu is the most likely option
+        node.attributes.width = "+0.1111em"
+      }
+    }
+
+    if (!(group.mclass === "mopen" || group.mclass === "mclose")) {
+      delete node.attributes.stretchy
+      delete node.attributes.form
+    }
+  }
+  return node;
+}
+
+// Math class commands except \mathop
+defineFunction({
+  type: "mclass",
+  names: [
+    "\\mathord",
+    "\\mathbin",
+    "\\mathrel",
+    "\\mathopen",
+    "\\mathclose",
+    "\\mathpunct",
+    "\\mathinner"
+  ],
+  props: {
+    numArgs: 1,
+    primitive: true
+  },
+  handler({ parser, funcName }, args) {
+    const body = args[0]
+    const isCharacterBox = utils.isCharacterBox(body)
+    // We should not wrap a <mo> around a <mi> or <mord>. That would be invalid MathML.
+    // In that case, we instead promote the text contents of the body to the parent.
+    let mustPromote = true
+    const mord = { type: "mathord", text: "", mode: parser.mode }
+    const arr = (body.body) ? body.body : [body];
+    for (const arg of arr) {
+      if (textAtomTypes.includes(arg.type)) {
+        if (arg.text) {
+          mord.text += arg.text
+        } else if (arg.body) {
+          arg.body.map(e => { mord.text += e.text })
+        }
+      } else {
+        mustPromote = false
+        break
+      }
+    }
+    return {
+      type: "mclass",
+      mode: parser.mode,
+      mclass: "m" + funcName.slice(5),
+      body: ordargument(mustPromote ? mord : body),
+      isCharacterBox,
+      mustPromote
+    };
+  },
+  mathmlBuilder
+});
+
+export const binrelClass = (arg) => {
+  // \binrel@ spacing varies with (bin|rel|ord) of the atom in the argument.
+  // (by rendering separately and with {}s before and after, and measuring
+  // the change in spacing).  We'll do roughly the same by detecting the
+  // atom type directly.
+  const atom = arg.type === "ordgroup" && arg.body.length ? arg.body[0] : arg;
+  if (atom.type === "atom" && (atom.family === "bin" || atom.family === "rel")) {
+    return "m" + atom.family;
+  } else {
+    return "mord";
+  }
+};
+
+// \@binrel{x}{y} renders like y but as mbin/mrel/mord if x is mbin/mrel/mord.
+// This is equivalent to \binrel@{x}\binrel@@{y} in AMSTeX.
+defineFunction({
+  type: "mclass",
+  names: ["\\@binrel"],
+  props: {
+    numArgs: 2
+  },
+  handler({ parser }, args) {
+    return {
+      type: "mclass",
+      mode: parser.mode,
+      mclass: binrelClass(args[0]),
+      body: ordargument(args[1]),
+      isCharacterBox: utils.isCharacterBox(args[1])
+    };
+  }
+});
+
+// Build a relation or stacked op by placing one symbol on top of another
+defineFunction({
+  type: "mclass",
+  names: ["\\stackrel", "\\overset", "\\underset"],
+  props: {
+    numArgs: 2
+  },
+  handler({ parser, funcName }, args) {
+    const baseArg = args[1];
+    const shiftedArg = args[0];
+
+    const baseOp = {
+      type: "op",
+      mode: baseArg.mode,
+      limits: true,
+      alwaysHandleSupSub: true,
+      parentIsSupSub: false,
+      symbol: false,
+      stack: true,
+      suppressBaseShift: funcName !== "\\stackrel",
+      body: ordargument(baseArg)
+    };
+
+    return {
+      type: "supsub",
+      mode: shiftedArg.mode,
+      base: baseOp,
+      sup: funcName === "\\underset" ? null : shiftedArg,
+      sub: funcName === "\\underset" ? shiftedArg : null
+    };
+  },
+  mathmlBuilder
+});

package/src/functions/multiscript.js

@@ -0,0 +1,91 @@
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import * as mml from "../buildMathML"
+import ParseError from "../ParseError";
+
+// Helper function
+export const buildGroup = (el, style, noneNode) => {
+  if (!el) { return noneNode }
+  const node = mml.buildGroup(el, style)
+  if (node.type === "mrow" && node.children.length === 0) { return noneNode }
+  return node
+}
+
+defineFunction({
+  type: "multiscript",
+  names: ["\\sideset", "\\pres@cript"], // See macros.js for \prescript
+  props: {
+    numArgs: 3
+  },
+  handler({ parser, funcName, token }, args) {
+    if (args[2].body.length === 0) {
+      throw new ParseError(funcName + `cannot parse an empty base.`)
+    }
+    const base = args[2].body[0]
+    if (parser.settings.strict && funcName === "\\sideset" && !base.symbol) {
+      throw new ParseError(`The base of \\sideset must be a big operator. Try \\prescript.`)
+    }
+
+    if ((args[0].body.length > 0 && args[0].body[0].type !== "supsub") ||
+        (args[1].body.length > 0 && args[1].body[0].type !== "supsub")) {
+      throw new ParseError("\\sideset can parse only subscripts and " +
+                            "superscripts in its first two arguments", token)
+    }
+
+    // The prescripts and postscripts come wrapped in a supsub.
+    const prescripts = args[0].body.length > 0 ? args[0].body[0] : null
+    const postscripts = args[1].body.length > 0 ? args[1].body[0] : null
+
+    if (!prescripts && !postscripts) {
+      return base
+    } else if (!prescripts) {
+      // It's not a multi-script. Get a \textstyle supsub.
+      return {
+        type: "styling",
+        mode: parser.mode,
+        scriptLevel: "text",
+        body: [{
+          type: "supsub",
+          mode: parser.mode,
+          base,
+          sup: postscripts.sup,
+          sub: postscripts.sub
+        }]
+      }
+    } else {
+      return {
+        type: "multiscript",
+        mode: parser.mode,
+        isSideset: funcName === "\\sideset",
+        prescripts,
+        postscripts,
+        base
+      }
+    }
+  },
+  mathmlBuilder(group, style) {
+    const base =  mml.buildGroup(group.base, style)
+
+    const prescriptsNode = new mathMLTree.MathNode("mprescripts")
+    const noneNode = new mathMLTree.MathNode("none")
+    let children = []
+
+    const preSub = buildGroup(group.prescripts.sub, style, noneNode)
+    const preSup = buildGroup(group.prescripts.sup, style, noneNode)
+    if (group.isSideset) {
+      // This seems silly, but LaTeX does this. Firefox ignores it, which does not make me sad.
+      preSub.setAttribute("style", "text-align: left;")
+      preSup.setAttribute("style", "text-align: left;")
+    }
+
+    if (group.postscripts) {
+      const postSub = buildGroup(group.postscripts.sub, style, noneNode)
+      const postSup = buildGroup(group.postscripts.sup, style, noneNode)
+      children = [base, postSub, postSup, prescriptsNode, preSub, preSup]
+    } else {
+      children = [base, prescriptsNode, preSub, preSup]
+    }
+
+    return new mathMLTree.MathNode("mmultiscripts", children);
+  }
+});