temml 0.9.1

package/src/functions/font.js

@@ -0,0 +1,123 @@
+import defineFunction, { normalizeArgument } from "../defineFunction"
+import * as mml from "../buildMathML"
+import mathMLTree from "../mathMLTree"
+
+const mathmlBuilder = (group, style) => {
+  const font = group.font
+  const newStyle = style.withFont(font)
+  const mathGroup = mml.buildGroup(group.body, newStyle)
+
+  if (mathGroup.children.length === 0) { return mathGroup } // empty group, e.g., \mathrm{}
+  if (font === "boldsymbol" && ["mo", "mpadded"].includes(mathGroup.type)) {
+    mathGroup.style.fontWeight = "bold"
+    return mathGroup
+  }
+  // Check if it is possible to consolidate elements into a single <mi> element.
+  let canConsolidate = mathGroup.children[0].type === "mo"
+  for (let i = 1; i < mathGroup.children.length; i++) {
+    if (mathGroup.children[i].type === "mo" && font === "boldsymbol") {
+      mathGroup.children[i].style.fontWeight = "bold"
+    }
+    if (mathGroup.children[i].type !== "mi") { canConsolidate = false }
+    const localVariant = mathGroup.children[i].attributes &&
+      mathGroup.children[i].attributes.mathvariant || ""
+    if (localVariant !== "normal") { canConsolidate = false }
+  }
+  if (!canConsolidate) { return mathGroup }
+  // Consolidate the <mi> elements.
+  const mi = mathGroup.children[0]
+  for (let i = 1; i < mathGroup.children.length; i++) {
+    mi.children.push(mathGroup.children[i].children[0])
+  }
+  if (mathGroup.attributes.mathcolor) { mi.attributes.mathcolor = mathGroup.attributes.mathcolor }
+  if (mi.attributes.mathvariant && mi.attributes.mathvariant === "normal") {
+    // Workaround for a Firefox bug that renders spurious space around
+    // a <mi mathvariant="normal">
+    // Ref: https://bugs.webkit.org/show_bug.cgi?id=129097
+    // We insert a text node that contains a zero-width space and wrap in an mrow.
+    // TODO: Get rid of this <mi> workaround when the Firefox bug is fixed.
+    const bogus = new mathMLTree.MathNode("mtext", new mathMLTree.TextNode("\u200b"))
+    return new mathMLTree.MathNode("mrow", [bogus, mi])
+  }
+  return mi
+};
+
+const fontAliases = {
+  "\\Bbb": "\\mathbb",
+  "\\bold": "\\mathbf",
+  "\\frak": "\\mathfrak",
+  "\\bm": "\\boldsymbol"
+};
+
+defineFunction({
+  type: "font",
+  names: [
+    // styles
+    "\\mathrm",
+    "\\mathit",
+    "\\mathbf",
+    "\\mathnormal",
+    "\\up@greek",
+    "\\boldsymbol",
+
+    // families
+    "\\mathbb",
+    "\\mathcal",
+    "\\mathfrak",
+    "\\mathscr",
+    "\\mathsf",
+    "\\mathtt",
+    "\\oldstylenums",
+
+    // aliases
+    "\\Bbb",
+    "\\bm",
+    "\\bold",
+    "\\frak"
+  ],
+  props: {
+    numArgs: 1,
+    allowedInArgument: true
+  },
+  handler: ({ parser, funcName }, args) => {
+    const body = normalizeArgument(args[0]);
+    let func = funcName;
+    if (func in fontAliases) {
+      func = fontAliases[func];
+    }
+    return {
+      type: "font",
+      mode: parser.mode,
+      font: func.slice(1),
+      body
+    };
+  },
+  mathmlBuilder
+});
+
+// Old font changing functions
+defineFunction({
+  type: "font",
+  names: ["\\rm", "\\sf", "\\tt", "\\bf", "\\it", "\\cal"],
+  props: {
+    numArgs: 0,
+    allowedInText: true
+  },
+  handler: ({ parser, funcName, breakOnTokenText }, args) => {
+    const { mode } = parser;
+    const body = parser.parseExpression(true, breakOnTokenText);
+    const fontStyle = `math${funcName.slice(1)}`;
+
+    return {
+      type: "font",
+      mode: mode,
+      font: fontStyle,
+      body: {
+        type: "ordgroup",
+        mode: parser.mode,
+        body
+      }
+    };
+  },
+  mathmlBuilder
+});

package/src/functions/genfrac.js

@@ -0,0 +1,333 @@
+import defineFunction, { normalizeArgument } from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import { StyleLevel } from "../constants"
+import { assertNodeType } from "../parseNode";
+import { assert } from "../utils";
+import * as mml from "../buildMathML";
+import { calculateSize } from "../units";
+
+const stylArray = ["display", "text", "script", "scriptscript"];
+const scriptLevel = { auto: -1, display: 0, text: 0, script: 1, scriptscript: 2 };
+
+const mathmlBuilder = (group, style) => {
+  // Track the scriptLevel of the numerator and denominator.
+  // We may need that info for \mathchoice or for adjusting em dimensions.
+  const childOptions = group.scriptLevel === "auto"
+    ? style.incrementLevel()
+    : group.scriptLevel === "display"
+    ? style.withLevel(StyleLevel.TEXT)
+    : group.scriptLevel === "text"
+    ? style.withLevel(StyleLevel.SCRIPT)
+    : style.withLevel(StyleLevel.SCRIPTSCRIPT);
+
+  let node = new mathMLTree.MathNode("mfrac", [
+    mml.buildGroup(group.numer, childOptions),
+    mml.buildGroup(group.denom, childOptions)
+  ]);
+
+  if (!group.hasBarLine) {
+    node.setAttribute("linethickness", "0px");
+  } else if (group.barSize) {
+    const ruleWidth = calculateSize(group.barSize, style);
+    node.setAttribute("linethickness", ruleWidth.number + ruleWidth.unit);
+  }
+
+  if (group.leftDelim != null || group.rightDelim != null) {
+    const withDelims = [];
+
+    if (group.leftDelim != null) {
+      const leftOp = new mathMLTree.MathNode("mo", [
+        new mathMLTree.TextNode(group.leftDelim.replace("\\", ""))
+      ]);
+      leftOp.setAttribute("fence", "true");
+      withDelims.push(leftOp);
+    }
+
+    withDelims.push(node);
+
+    if (group.rightDelim != null) {
+      const rightOp = new mathMLTree.MathNode("mo", [
+        new mathMLTree.TextNode(group.rightDelim.replace("\\", ""))
+      ]);
+      rightOp.setAttribute("fence", "true");
+      withDelims.push(rightOp);
+    }
+
+    node = mml.makeRow(withDelims);
+  }
+
+  if (group.scriptLevel !== "auto") {
+    node = new mathMLTree.MathNode("mstyle", [node]);
+    node.setAttribute("displaystyle", String(group.scriptLevel === "display"));
+    node.setAttribute("scriptlevel", scriptLevel[group.scriptLevel]);
+  }
+
+  return node;
+};
+
+defineFunction({
+  type: "genfrac",
+  names: [
+    "\\dfrac",
+    "\\frac",
+    "\\tfrac",
+    "\\dbinom",
+    "\\binom",
+    "\\tbinom",
+    "\\\\atopfrac", // can’t be entered directly
+    "\\\\bracefrac",
+    "\\\\brackfrac" // ditto
+  ],
+  props: {
+    numArgs: 2,
+    allowedInArgument: true
+  },
+  handler: ({ parser, funcName }, args) => {
+    const numer = args[0];
+    const denom = args[1];
+    let hasBarLine = false;
+    let leftDelim = null;
+    let rightDelim = null;
+    let scriptLevel = "auto";
+
+    switch (funcName) {
+      case "\\dfrac":
+      case "\\frac":
+      case "\\tfrac":
+        hasBarLine = true;
+        break;
+      case "\\\\atopfrac":
+        hasBarLine = false;
+        break;
+      case "\\dbinom":
+      case "\\binom":
+      case "\\tbinom":
+        leftDelim = "(";
+        rightDelim = ")";
+        break;
+      case "\\\\bracefrac":
+        leftDelim = "\\{";
+        rightDelim = "\\}";
+        break;
+      case "\\\\brackfrac":
+        leftDelim = "[";
+        rightDelim = "]";
+        break;
+      default:
+        throw new Error("Unrecognized genfrac command");
+    }
+
+    switch (funcName) {
+      case "\\dfrac":
+      case "\\dbinom":
+        scriptLevel = "display";
+        break;
+      case "\\tfrac":
+      case "\\tbinom":
+        scriptLevel = "text";
+        break;
+    }
+
+    return {
+      type: "genfrac",
+      mode: parser.mode,
+      continued: false,
+      numer,
+      denom,
+      hasBarLine,
+      leftDelim,
+      rightDelim,
+      scriptLevel,
+      barSize: null
+    };
+  },
+  mathmlBuilder
+});
+
+defineFunction({
+  type: "genfrac",
+  names: ["\\cfrac"],
+  props: {
+    numArgs: 2
+  },
+  handler: ({ parser, funcName }, args) => {
+    const numer = args[0];
+    const denom = args[1];
+
+    return {
+      type: "genfrac",
+      mode: parser.mode,
+      continued: true,
+      numer,
+      denom,
+      hasBarLine: true,
+      leftDelim: null,
+      rightDelim: null,
+      scriptLevel: "display",
+      barSize: null
+    };
+  }
+});
+
+// Infix generalized fractions -- these are not rendered directly, but replaced
+// immediately by one of the variants above.
+defineFunction({
+  type: "infix",
+  names: ["\\over", "\\choose", "\\atop", "\\brace", "\\brack"],
+  props: {
+    numArgs: 0,
+    infix: true
+  },
+  handler({ parser, funcName, token }) {
+    let replaceWith;
+    switch (funcName) {
+      case "\\over":
+        replaceWith = "\\frac";
+        break;
+      case "\\choose":
+        replaceWith = "\\binom";
+        break;
+      case "\\atop":
+        replaceWith = "\\\\atopfrac";
+        break;
+      case "\\brace":
+        replaceWith = "\\\\bracefrac";
+        break;
+      case "\\brack":
+        replaceWith = "\\\\brackfrac";
+        break;
+      default:
+        throw new Error("Unrecognized infix genfrac command");
+    }
+    return {
+      type: "infix",
+      mode: parser.mode,
+      replaceWith,
+      token
+    };
+  }
+});
+
+const delimFromValue = function(delimString) {
+  let delim = null;
+  if (delimString.length > 0) {
+    delim = delimString;
+    delim = delim === "." ? null : delim;
+  }
+  return delim;
+};
+
+defineFunction({
+  type: "genfrac",
+  names: ["\\genfrac"],
+  props: {
+    numArgs: 6,
+    allowedInArgument: true,
+    argTypes: ["math", "math", "size", "text", "math", "math"]
+  },
+  handler({ parser }, args) {
+    const numer = args[4];
+    const denom = args[5];
+
+    // Look into the parse nodes to get the desired delimiters.
+    const leftNode = normalizeArgument(args[0]);
+    const leftDelim = leftNode.type === "atom" && leftNode.family === "open"
+      ? delimFromValue(leftNode.text)
+      : null;
+    const rightNode = normalizeArgument(args[1]);
+    const rightDelim =
+      rightNode.type === "atom" && rightNode.family === "close"
+        ? delimFromValue(rightNode.text)
+        : null;
+
+    const barNode = assertNodeType(args[2], "size");
+    let hasBarLine;
+    let barSize = null;
+    if (barNode.isBlank) {
+      // \genfrac acts differently than \above.
+      // \genfrac treats an empty size group as a signal to use a
+      // standard bar size. \above would see size = 0 and omit the bar.
+      hasBarLine = true;
+    } else {
+      barSize = barNode.value;
+      hasBarLine = barSize.number > 0;
+    }
+
+    // Find out if we want displaystyle, textstyle, etc.
+    let scriptLevel = "auto";
+    let styl = args[3];
+    if (styl.type === "ordgroup") {
+      if (styl.body.length > 0) {
+        const textOrd = assertNodeType(styl.body[0], "textord");
+        scriptLevel = stylArray[Number(textOrd.text)];
+      }
+    } else {
+      styl = assertNodeType(styl, "textord");
+      scriptLevel = stylArray[Number(styl.text)];
+    }
+
+    return {
+      type: "genfrac",
+      mode: parser.mode,
+      numer,
+      denom,
+      continued: false,
+      hasBarLine,
+      barSize,
+      leftDelim,
+      rightDelim,
+      scriptLevel
+    };
+  },
+  mathmlBuilder
+});
+
+// \above is an infix fraction that also defines a fraction bar size.
+defineFunction({
+  type: "infix",
+  names: ["\\above"],
+  props: {
+    numArgs: 1,
+    argTypes: ["size"],
+    infix: true
+  },
+  handler({ parser, funcName, token }, args) {
+    return {
+      type: "infix",
+      mode: parser.mode,
+      replaceWith: "\\\\abovefrac",
+      barSize: assertNodeType(args[0], "size").value,
+      token
+    };
+  }
+});
+
+defineFunction({
+  type: "genfrac",
+  names: ["\\\\abovefrac"],
+  props: {
+    numArgs: 3,
+    argTypes: ["math", "size", "math"]
+  },
+  handler: ({ parser, funcName }, args) => {
+    const numer = args[0];
+    const barSize = assert(assertNodeType(args[1], "infix").barSize);
+    const denom = args[2];
+
+    const hasBarLine = barSize.number > 0;
+    return {
+      type: "genfrac",
+      mode: parser.mode,
+      numer,
+      denom,
+      continued: false,
+      hasBarLine,
+      barSize,
+      leftDelim: null,
+      rightDelim: null,
+      scriptLevel: "auto"
+    };
+  },
+
+  mathmlBuilder
+});

package/src/functions/hbox.js

@@ -0,0 +1,29 @@
+import defineFunction, { ordargument } from "../defineFunction";
+import { StyleLevel } from "../constants"
+import mathMLTree from "../mathMLTree";
+import * as mml from "../buildMathML";
+
+// \hbox is provided for compatibility with LaTeX functions that act on a box.
+// This function by itself doesn't do anything but prevent a soft line break.
+
+defineFunction({
+  type: "hbox",
+  names: ["\\hbox"],
+  props: {
+    numArgs: 1,
+    argTypes: ["hbox"],
+    allowedInArgument: true,
+    allowedInText: false
+  },
+  handler({ parser }, args) {
+    return {
+      type: "hbox",
+      mode: parser.mode,
+      body: ordargument(args[0])
+    };
+  },
+  mathmlBuilder(group, style) {
+    const newOptions = style.withLevel(StyleLevel.TEXT)
+    return new mathMLTree.MathNode("mrow", mml.buildExpression(group.body, newOptions));
+  }
+});

package/src/functions/horizBrace.js

@@ -0,0 +1,32 @@
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import stretchy from "../stretchy";
+import * as mml from "../buildMathML";
+
+const mathmlBuilder = (group, style) => {
+  const accentNode = stretchy.mathMLnode(group.label);
+  accentNode.style["math-depth"] = 0
+  return new mathMLTree.MathNode(group.isOver ? "mover" : "munder", [
+    mml.buildGroup(group.base, style),
+    accentNode
+  ]);
+};
+
+// Horizontal stretchy braces
+defineFunction({
+  type: "horizBrace",
+  names: ["\\overbrace", "\\underbrace"],
+  props: {
+    numArgs: 1
+  },
+  handler({ parser, funcName }, args) {
+    return {
+      type: "horizBrace",
+      mode: parser.mode,
+      label: funcName,
+      isOver: /^\\over/.test(funcName),
+      base: args[0]
+    };
+  },
+  mathmlBuilder
+});

package/src/functions/href.js

@@ -0,0 +1,90 @@
+import defineFunction, { ordargument } from "../defineFunction";
+import { assertNodeType } from "../parseNode";
+import { MathNode } from "../mathMLTree";
+import * as mml from "../buildMathML";
+import ParseError from "../ParseError";
+
+defineFunction({
+  type: "href",
+  names: ["\\href"],
+  props: {
+    numArgs: 2,
+    argTypes: ["url", "original"],
+    allowedInText: true
+  },
+  handler: ({ parser, token }, args) => {
+    const body = args[1];
+    const href = assertNodeType(args[0], "url").url;
+
+    if (
+      !parser.settings.isTrusted({
+        command: "\\href",
+        url: href
+      })
+    ) {
+      throw new ParseError(`Function "\\href" is not trusted`, token)
+    }
+
+    return {
+      type: "href",
+      mode: parser.mode,
+      href,
+      body: ordargument(body)
+    };
+  },
+  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;
+  }
+});
+
+defineFunction({
+  type: "href",
+  names: ["\\url"],
+  props: {
+    numArgs: 1,
+    argTypes: ["url"],
+    allowedInText: true
+  },
+  handler: ({ parser, token }, args) => {
+    const href = assertNodeType(args[0], "url").url;
+
+    if (
+      !parser.settings.isTrusted({
+        command: "\\url",
+        url: href
+      })
+    ) {
+      throw new ParseError(`Function "\\url" is not trusted`, token)
+    }
+
+    const chars = [];
+    for (let i = 0; i < href.length; i++) {
+      let c = href[i];
+      if (c === "~") {
+        c = "\\textasciitilde";
+      }
+      chars.push({
+        type: "textord",
+        mode: "text",
+        text: c
+      });
+    }
+    const body = {
+      type: "text",
+      mode: parser.mode,
+      font: "\\texttt",
+      body: chars
+    };
+    return {
+      type: "href",
+      mode: parser.mode,
+      href,
+      body: ordargument(body)
+    };
+  }
+});

package/src/functions/html.js

@@ -0,0 +1,95 @@
+import defineFunction, { ordargument } from "../defineFunction";
+import { assertNodeType } from "../parseNode";
+import ParseError from "../ParseError";
+
+import * as mml from "../buildMathML";
+
+defineFunction({
+  type: "html",
+  names: ["\\class", "\\id", "\\style", "\\data"],
+  props: {
+    numArgs: 2,
+    argTypes: ["raw", "original"],
+    allowedInText: true
+  },
+  handler: ({ parser, funcName, token }, args) => {
+    const value = assertNodeType(args[0], "raw").string;
+    const body = args[1];
+
+    if (parser.settings.strict) {
+      throw new ParseError(`Function "${funcName}" is disabled in strict mode`, token)
+    }
+
+    let trustContext;
+    const attributes = {};
+
+    switch (funcName) {
+      case "\\class":
+        attributes.class = value;
+        trustContext = {
+          command: "\\class",
+          class: value
+        };
+        break;
+      case "\\id":
+        attributes.id = value;
+        trustContext = {
+          command: "\\id",
+          id: value
+        };
+        break;
+      case "\\style":
+        attributes.style = value;
+        trustContext = {
+          command: "\\style",
+          style: value
+        };
+        break;
+      case "\\data": {
+        const data = value.split(",");
+        for (let i = 0; i < data.length; i++) {
+          const keyVal = data[i].split("=");
+          if (keyVal.length !== 2) {
+            throw new ParseError("Error parsing key-value for \\data");
+          }
+          attributes["data-" + keyVal[0].trim()] = keyVal[1].trim();
+        }
+
+        trustContext = {
+          command: "\\data",
+          attributes
+        };
+        break;
+      }
+      default:
+        throw new Error("Unrecognized html command");
+    }
+
+    if (!parser.settings.isTrusted(trustContext)) {
+      throw new ParseError(`Function "${funcName}" is not trusted`, token)
+    }
+    return {
+      type: "html",
+      mode: parser.mode,
+      attributes,
+      body: ordargument(body)
+    };
+  },
+  mathmlBuilder: (group, style) => {
+    const element =  mml.buildExpressionRow(group.body, style);
+
+    const classes = [];
+    if (group.attributes.class) {
+      classes.push(...group.attributes.class.trim().split(/\s+/));
+    }
+    element.classes = classes;
+
+    for (const attr in group.attributes) {
+      if (attr !== "class" && Object.prototype.hasOwnProperty.call(group.attributes, attr)) {
+        element.setAttribute(attr, group.attributes[attr]);
+      }
+    }
+
+    return element;
+  }
+});