temml 0.9.1

package/src/functions/text.js

@@ -0,0 +1,75 @@
+import defineFunction, { ordargument } from "../defineFunction";
+import * as mml from "../buildMathML";
+
+// Non-mathy text, possibly in a font
+const textFontFamilies = {
+  "\\text": undefined,
+  "\\textrm": "textrm",
+  "\\textsf": "textsf",
+  "\\texttt": "texttt",
+  "\\textnormal": "textrm",
+  "\\textsc": "textsc"      // small caps
+};
+
+const textFontWeights = {
+  "\\textbf": "textbf",
+  "\\textmd": "textmd"
+};
+
+const textFontShapes = {
+  "\\textit": "textit",
+  "\\textup": "textup"
+};
+
+const styleWithFont = (group, style) => {
+  const font = group.font;
+  // Checks if the argument is a font family or a font style.
+  if (!font) {
+    return style;
+  } else if (textFontFamilies[font]) {
+    return style.withTextFontFamily(textFontFamilies[font]);
+  } else if (textFontWeights[font]) {
+    return style.withTextFontWeight(textFontWeights[font]);
+  } else {
+    return style.withTextFontShape(textFontShapes[font]);
+  }
+};
+
+defineFunction({
+  type: "text",
+  names: [
+    // Font families
+    "\\text",
+    "\\textrm",
+    "\\textsf",
+    "\\texttt",
+    "\\textnormal",
+    "\\textsc",
+    // Font weights
+    "\\textbf",
+    "\\textmd",
+    // Font Shapes
+    "\\textit",
+    "\\textup"
+  ],
+  props: {
+    numArgs: 1,
+    argTypes: ["text"],
+    allowedInArgument: true,
+    allowedInText: true
+  },
+  handler({ parser, funcName }, args) {
+    const body = args[0];
+    return {
+      type: "text",
+      mode: parser.mode,
+      body: ordargument(body),
+      font: funcName
+    };
+  },
+  mathmlBuilder(group, style) {
+    const newStyle = styleWithFont(group, style)
+    const mrow = mml.buildExpressionRow(group.body, newStyle)
+    return mml.consolidateText(mrow)
+  }
+});

package/src/functions/tip.js

@@ -0,0 +1,63 @@
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import * as mml from "../buildMathML";
+
+// Two functions included to enable migration from Mathjax.
+
+defineFunction({
+  type: "tip",
+  names: ["\\mathtip"],
+  props: {
+    numArgs: 2
+  },
+  handler({ parser }, args) {
+    return {
+      type: "tip",
+      mode: parser.mode,
+      body: args[0],
+      tip: args[1]
+    };
+  },
+  mathmlBuilder: (group, style) => {
+    const math = mml.buildGroup(group.body, style)
+    const tip = mml.buildGroup(group.tip, style)
+    // Browsers don't support the tooltip actiontype.
+    // TODO: Come back and fix \mathtip when it can be done via CSS w/o a JS event.
+    const node = new mathMLTree.MathNode("maction", [math, tip], ["tml-tip"])
+    node.setAttribute("actiontype", "tooltip")
+    return node
+  }
+})
+
+defineFunction({
+  type: "tip",
+  names: ["\\texttip"],
+  props: {
+    numArgs: 2,
+    argTypes: ["math", "text"]
+  },
+  handler({ parser }, args) {
+    return {
+      type: "tip",
+      mode: parser.mode,
+      body: args[0],
+      tip: args[1]
+    };
+  },
+  mathmlBuilder: (group, style) => {
+    const math = mml.buildGroup(group.body, style)
+    const tip = mml.buildGroup(group.tip, style)
+    // args[1] only accepted text, so tip is a <mtext> element or a <mrow> of them.
+    let str = ""
+    if (tip.type === "mtext") {
+      str = tip.children[0].text
+    } else {
+      for (const child of tip.children) {
+        str += child.children[0].text
+      }
+    }
+    // Implement \texttip via a title attribute.
+    math.setAttribute("title", str)
+    return math
+  }
+})

package/src/functions/toggle.js

@@ -0,0 +1,13 @@
+import { defineFunctionBuilders } from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import * as mml from "../buildMathML";
+
+defineFunctionBuilders({
+  type: "toggle",
+  mathmlBuilder(group, style) {
+    const expression = mml.buildExpression(group.body, style)
+    const node = new mathMLTree.MathNode("maction", expression, [], { cursor: "default" })
+    node.setAttribute("actiontype", "toggle")
+    return node
+  }
+})

package/src/functions/verb.js

@@ -0,0 +1,33 @@
+import defineFunction from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import ParseError from "../ParseError";
+
+defineFunction({
+  type: "verb",
+  names: ["\\verb"],
+  props: {
+    numArgs: 0,
+    allowedInText: true
+  },
+  handler(context, args, optArgs) {
+    // \verb and \verb* are dealt with directly in Parser.js.
+    // If we end up here, it's because of a failure to match the two delimiters
+    // in the regex in Lexer.js.  LaTeX raises the following error when \verb is
+    // terminated by end of line (or file).
+    throw new ParseError("\\verb ended by end of line instead of matching delimiter");
+  },
+  mathmlBuilder(group, style) {
+    const text = new mathMLTree.TextNode(makeVerb(group));
+    const node = new mathMLTree.MathNode("mtext", [text]);
+    node.setAttribute("mathvariant", "monospace");
+    return node;
+  }
+});
+
+/**
+ * Converts verb group into body string.
+ *
+ * \verb* replaces each space with an open box \u2423
+ * \verb replaces each space with a no-break space \xA0
+ */
+const makeVerb = (group) => group.body.replace(/ /g, group.star ? "\u2423" : "\xA0");

package/src/functions.js

@@ -0,0 +1,57 @@
+/** Include this to ensure that all functions are defined. */
+import { _functions } from "./defineFunction";
+
+const functions = _functions;
+export default functions;
+
+// TODO(kevinb): have functions return an object and call defineFunction with
+// that object in this file instead of relying on side-effects.
+import "./functions/accent";
+import "./functions/accentunder";
+import "./functions/arrow";
+//import "./functions/cancelto";
+import "./environments/cd";
+import "./functions/char";
+import "./functions/color";
+import "./functions/cr";
+import "./functions/def";
+import "./functions/delimsizing";
+import "./functions/enclose";
+import "./functions/environment";
+import "./functions/envTag";
+import "./functions/font";
+import "./functions/genfrac";
+import "./functions/horizBrace";
+import "./functions/href";
+import "./functions/html";
+import "./functions/includegraphics";
+import "./functions/kern";
+import "./functions/label";
+import "./functions/lap";
+import "./functions/math";
+import "./functions/mathchoice";
+import "./functions/mclass";
+import "./functions/multiscript";
+import "./functions/not";
+import "./functions/op";
+import "./functions/operatorname";
+import "./functions/ordgroup";
+import "./functions/phantom";
+import "./functions/pmb";
+import "./functions/raise";
+import "./functions/ref";
+import "./functions/relax";
+import "./functions/rule";
+import "./functions/sizing";
+import "./functions/smash";
+import "./functions/sqrt";
+import "./functions/styling";
+import "./functions/supsub";
+import "./functions/symbolsOp";
+import "./functions/symbolsOrd";
+import "./functions/symbolsSpacing";
+import "./functions/tag";
+import "./functions/text";
+// import "./functions/tip";
+// import "./functions/toggle";
+import "./functions/verb";

package/src/linebreaking.js

@@ -0,0 +1,159 @@
+import mathMLTree from "./mathMLTree"
+
+/*
+ * Neither Firefox nor Chrome support hard line breaks or soft line breaks.
+ * (Despite https://www.w3.org/Math/draft-spec/mathml.html#chapter3_presm.lbattrs)
+ * So Temml has work-arounds for both hard and soft breaks.
+ * The work-arounds sadly do not work simultaneously. Any top-level hard
+ * break makes soft line breaks impossible.
+ *
+ * Hard breaks are simulated by creating a <mtable> and putting each line in its own <mtr>.
+ *
+ * To create soft line breaks, Temml avoids using the <semantics> and <annotation> tags.
+ * Then the top level of a <math> element can be occupied by <mrow> elements, and the browser
+ * will break after a <mrow> if the expression extends beyond the container limit.
+ *
+ * We want the expression to render with soft line breaks after each top-level binary or
+ * relational operator, per TeXbook p. 173. So we gather the expression into <mrow>s so that
+ * each <mrow> ends in a binary or relational operator.
+ *
+ * Soft line breaks will not work in Chromium and Safari, only Firefox.
+ *
+ * Hopefully browsers will someday do their own linebreaking and we will be able to delete
+ * much of this module.
+ */
+
+export default function setLineBreaks(expression, wrapMode, isDisplayMode, color) {
+  if (color === undefined && wrapMode !== "none") {
+    // First, make one pass through the expression and split any color nodes.
+    const upperLimit = expression.length - 1
+    for (let i = upperLimit; i >= 0; i--) {
+      const node = expression[i];
+      if (node.type === "mstyle" && node.attributes.mathcolor) {
+        const color = node.attributes.mathcolor
+        const fragment = setLineBreaks(node.children, wrapMode, isDisplayMode, color)
+        if (!(fragment.type && fragment.type !== "mtable")) {
+          expression.splice(i, 1, ...fragment.children)
+        }
+      }
+    }
+  }
+
+  const tagName = color ? "mstyle" : "mrow"
+
+  const mtrs = [];
+  let mrows = [];
+  let block = [];
+  let numTopLevelEquals = 0
+  let canBeBIN = false // The first node cannot be an infix binary operator.
+  for (let i = 0; i < expression.length; i++) {
+    const node = expression[i];
+    if (node.type && node.type === "mstyle" && node.attributes.mathcolor) {
+      if (block.length > 0) {
+        // Start a new block. (Insert a soft linebreak.)
+        mrows.push(new mathMLTree.MathNode(tagName, block))
+      }
+      // Insert the mstyle
+      mrows.push(node)
+      block = [];
+      continue
+    }
+    if (node.attributes && node.attributes.linebreak &&
+      node.attributes.linebreak === "newline") {
+      // A hard line break. Create a <mtr> for the current block.
+      if (block.length > 0) {
+        const element = new mathMLTree.MathNode(tagName, block)
+        if (color) { element.setAttribute("mathcolor", color) }
+        mrows.push(new mathMLTree.MathNode(tagName, block))
+      }
+      mrows.push(node)
+      block = [];
+      const mtd = new mathMLTree.MathNode("mtd", mrows)
+      mtrs.push(new mathMLTree.MathNode("mtr", [mtd]))
+      mrows = [];
+      continue
+    }
+    block.push(node);
+    if (node.type && node.type === "mo" && wrapMode === "=") {
+      if (node.children.length === 1 && node.children[0].text === "=") {
+        numTopLevelEquals += 1
+        if (numTopLevelEquals > 1) {
+          block.pop()
+          // Start a new block. (Insert a soft linebreak.)
+          const element = new mathMLTree.MathNode(tagName, block)
+          if (color) { element.setAttribute("mathcolor", color) }
+          mrows.push(element)
+          block = [node];
+        }
+      }
+    } else if (node.type && node.type === "mo" && wrapMode === "tex") {
+      // This may be a place for a soft line break.
+      if (canBeBIN && !node.attributes.form) {
+        // Check if the following node is a \nobreak text node, e.g. "~""
+        const next = i < expression.length - 1 ? expression[i + 1] : null;
+        let glueIsFreeOfNobreak = true;
+        if (
+          !(
+            next &&
+            next.type === "mtext" &&
+            next.attributes.linebreak &&
+            next.attributes.linebreak === "nobreak"
+          )
+        ) {
+          // We may need to start a new block.
+          // First, put any post-operator glue on same line as operator.
+          for (let j = i + 1; j < expression.length; j++) {
+            const nd = expression[j];
+            if (
+              nd.type &&
+              nd.type === "mspace" &&
+              !(nd.attributes.linebreak && nd.attributes.linebreak === "newline")
+            ) {
+              block.push(nd);
+              i += 1;
+              if (
+                nd.attributes &&
+                nd.attributes.linebreak &&
+                nd.attributes.linebreak === "nobreak"
+              ) {
+                glueIsFreeOfNobreak = false;
+              }
+            } else {
+              break;
+            }
+          }
+        }
+        if (glueIsFreeOfNobreak) {
+          // Start a new block. (Insert a soft linebreak.)
+          const element = new mathMLTree.MathNode(tagName, block)
+          if (color) { element.setAttribute("mathcolor", color) }
+          mrows.push(element)
+          block = [];
+        }
+        canBeBIN = false;
+      }
+      const isOpenDelimiter = node.attributes.form && node.attributes.form === "prefix";
+      // Any operator that follows an open delimiter is unary.
+      canBeBIN = !(node.attributes.separator || isOpenDelimiter);
+    } else {
+      canBeBIN = true;
+    }
+  }
+  if (block.length > 0) {
+    const element = new mathMLTree.MathNode(tagName, block)
+    if (color) { element.setAttribute("mathcolor", color) }
+    mrows.push(element)
+  }
+  if (mtrs.length > 0) {
+    const mtd = new mathMLTree.MathNode("mtd", mrows)
+    const mtr = new mathMLTree.MathNode("mtr", [mtd])
+    mtrs.push(mtr)
+    const mtable = new mathMLTree.MathNode("mtable", mtrs)
+    if (!isDisplayMode) {
+      mtable.setAttribute("columnalign", "left")
+      mtable.setAttribute("rowspacing", "0em")
+    }
+    return mtable
+  }
+  return mathMLTree.newDocumentFragment(mrows);
+}