temml 0.9.1

package/src/functions/not.js

@@ -0,0 +1,46 @@
+import defineFunction, { ordargument } from "../defineFunction";
+import symbols from "../symbols";
+import * as mml from "../buildMathML";
+import utils from "../utils"
+
+defineFunction({
+  type: "not",
+  names: ["\\not"],
+  props: {
+    numArgs: 1,
+    primitive: true,
+    allowedInText: false
+  },
+  handler({ parser }, args) {
+    const isCharacterBox = utils.isCharacterBox(args[0])
+    let body
+    if (isCharacterBox) {
+      body = ordargument(args[0])
+      if (body[0].text.charAt(0) === "\\") {
+        body[0].text = symbols.math[body[0].text].replace
+      }
+      // \u0338 is the Unicode Combining Long Solidus Overlay
+      body[0].text = body[0].text.slice(0, 1) + "\u0338" + body[0].text.slice(1)
+    } else {
+      // When the argument is not a character box, TeX does an awkward, poorly placed overlay.
+      // We'll do the same.
+      const notNode = { type: "textord", mode: "math", text: "\u0338" }
+      const kernNode = { type: "kern", mode: "math", dimension: { number: -0.6, unit: "em" } }
+      body = [notNode, kernNode, args[0]]
+    }
+    return {
+      type: "not",
+      mode: parser.mode,
+      body,
+      isCharacterBox
+    };
+  },
+  mathmlBuilder(group, style) {
+    if (group.isCharacterBox) {
+      const inner = mml.buildExpression(group.body, style);
+      return inner[0]
+    } else {
+      return mml.buildExpressionRow(group.body, style, true)
+    }
+  }
+});

package/src/functions/op.js

@@ -0,0 +1,338 @@
+// Limits, symbols
+import defineFunction, { ordargument } from "../defineFunction";
+import * as mathMLTree from "../mathMLTree";
+import * as mml from "../buildMathML";
+import { delimiters, delimiterSizes } from "./delimsizing"
+
+// Some helpers
+
+const ordAtomTypes = ["textord", "mathord", "atom"]
+
+// Most operators have a large successor symbol, but these don't.
+const noSuccessor = ["\\smallint"];
+
+// Math operators (e.g. \sin) need a space between these types and themselves:
+export const ordTypes = ["textord", "mathord", "ordgroup", "close", "leftright"];
+
+const dels = ["}", "\\left", "\\middle", "\\right"]
+const isDelimiter = str => str.length > 0 &&
+  (delimiters.includes(str) || delimiterSizes[str] || dels.includes(str))
+
+// NOTE: Unlike most `builders`s, this one handles not only "op", but also
+// "supsub" since some of them (like \int) can affect super/subscripting.
+
+const mathmlBuilder = (group, style) => {
+  let node;
+
+  if (group.symbol) {
+    // This is a symbol. Just add the symbol.
+    node = new mathMLTree.MathNode("mo", [mml.makeText(group.name, group.mode)]);
+    if (noSuccessor.includes(group.name)) {
+      node.setAttribute("largeop", "false")
+    } else {
+      node.setAttribute("movablelimits", "false")
+    }
+  } else if (group.body) {
+    // This is an operator with children. Add them.
+    node = new mathMLTree.MathNode("mo", mml.buildExpression(group.body, style));
+  } else {
+    // This is a text operator. Add all of the characters from the operator's name.
+    node = new mathMLTree.MathNode("mi", [new mathMLTree.TextNode(group.name.slice(1))]);
+
+    if (!group.parentIsSupSub) {
+      // Append an invisible <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")]);
+      const row = [node, operator]
+      // Set spacing
+      if (group.needsLeadingSpace) {
+        const lead = new mathMLTree.MathNode("mspace")
+        lead.setAttribute("width", "0.1667em") // thin space.
+        row.unshift(lead)
+      }
+      if (!group.isFollowedByDelimiter) {
+        const trail = new mathMLTree.MathNode("mspace")
+        trail.setAttribute("width", "0.1667em") // thin space.
+        row.push(trail)
+      }
+      node = new mathMLTree.MathNode("mrow", row)
+    }
+  }
+
+  return node;
+};
+
+const singleCharBigOps = {
+  "\u220F": "\\prod",
+  "\u2210": "\\coprod",
+  "\u2211": "\\sum",
+  "\u22c0": "\\bigwedge",
+  "\u22c1": "\\bigvee",
+  "\u22c2": "\\bigcap",
+  "\u22c3": "\\bigcup",
+  "\u2a00": "\\bigodot",
+  "\u2a01": "\\bigoplus",
+  "\u2a02": "\\bigotimes",
+  "\u2a04": "\\biguplus",
+  "\u2a05": "\\bigsqcap",
+  "\u2a06": "\\bigsqcup"
+};
+
+defineFunction({
+  type: "op",
+  names: [
+    "\\coprod",
+    "\\bigvee",
+    "\\bigwedge",
+    "\\biguplus",
+    "\\bigcap",
+    "\\bigcup",
+    "\\intop",
+    "\\prod",
+    "\\sum",
+    "\\bigotimes",
+    "\\bigoplus",
+    "\\bigodot",
+    "\\bigsqcap",
+    "\\bigsqcup",
+    "\\smallint",
+    "\u220F",
+    "\u2210",
+    "\u2211",
+    "\u22c0",
+    "\u22c1",
+    "\u22c2",
+    "\u22c3",
+    "\u2a00",
+    "\u2a01",
+    "\u2a02",
+    "\u2a04",
+    "\u2a06"
+  ],
+  props: {
+    numArgs: 0
+  },
+  handler: ({ parser, funcName }, args) => {
+    let fName = funcName;
+    if (fName.length === 1) {
+      fName = singleCharBigOps[fName];
+    }
+    return {
+      type: "op",
+      mode: parser.mode,
+      limits: true,
+      parentIsSupSub: false,
+      symbol: true,
+      stack: false, // This is true for \stackrel{}, not here.
+      name: fName
+    };
+  },
+  mathmlBuilder
+});
+
+// Note: calling defineFunction with a type that's already been defined only
+// works because the same mathmlBuilder is being used.
+defineFunction({
+  type: "op",
+  names: ["\\mathop"],
+  props: {
+    numArgs: 1,
+    primitive: true
+  },
+  handler: ({ parser }, args) => {
+    const body = args[0];
+    // It would be convienient to just wrap a <mo> around the argument.
+    // But if the argument is a <mi> or <mord>, that would be invalid MathML.
+    // In that case, we instead promote the text contents of the body to the parent.
+    const arr = (body.body) ? body.body : [body];
+    const isSymbol = arr.length === 1 && ordAtomTypes.includes(arr[0].type)
+    return {
+      type: "op",
+      mode: parser.mode,
+      limits: true,
+      parentIsSupSub: false,
+      symbol: isSymbol,
+      stack: false,
+      name: isSymbol ? arr[0].text : null,
+      body: isSymbol ? null : ordargument(body)
+    };
+  },
+  mathmlBuilder
+});
+
+// There are 2 flags for operators; whether they produce limits in
+// displaystyle, and whether they are symbols and should grow in
+// displaystyle. These four groups cover the four possible choices.
+
+const singleCharIntegrals = {
+  "\u222b": "\\int",
+  "\u222c": "\\iint",
+  "\u222d": "\\iiint",
+  "\u222e": "\\oint",
+  "\u222f": "\\oiint",
+  "\u2230": "\\oiiint",
+  "\u2231": "\\intclockwise",
+  "\u2232": "\\varointclockwise",
+  "\u2a0c": "\\iiiint",
+  "\u2a0d": "\\intbar",
+  "\u2a0e": "\\intBar",
+  "\u2a0f": "\\fint",
+  "\u2a12": "\\rppolint",
+  "\u2a13": "\\scpolint",
+  "\u2a15": "\\pointint",
+  "\u2a16": "\\sqint",
+  "\u2a17": "\\intlarhk",
+  "\u2a18": "\\intx",
+  "\u2a19": "\\intcap",
+  "\u2a1a": "\\intcup"
+};
+
+// No limits, not symbols
+defineFunction({
+  type: "op",
+  names: [
+    "\\arcsin",
+    "\\arccos",
+    "\\arctan",
+    "\\arctg",
+    "\\arcctg",
+    "\\arg",
+    "\\ch",
+    "\\cos",
+    "\\cosec",
+    "\\cosh",
+    "\\cot",
+    "\\cotg",
+    "\\coth",
+    "\\csc",
+    "\\ctg",
+    "\\cth",
+    "\\deg",
+    "\\dim",
+    "\\exp",
+    "\\hom",
+    "\\ker",
+    "\\lg",
+    "\\ln",
+    "\\log",
+    "\\sec",
+    "\\sin",
+    "\\sinh",
+    "\\sh",
+    "\\sgn",
+    "\\tan",
+    "\\tanh",
+    "\\tg",
+    "\\th"
+  ],
+  props: {
+    numArgs: 0
+  },
+  handler({ parser, funcName }) {
+    const prevAtomType = parser.prevAtomType
+    const next = parser.gullet.future().text
+    return {
+      type: "op",
+      mode: parser.mode,
+      limits: false,
+      parentIsSupSub: false,
+      symbol: false,
+      stack: false,
+      isFollowedByDelimiter: isDelimiter(next),
+      needsLeadingSpace: prevAtomType.length > 0 && ordTypes.includes(prevAtomType),
+      name: funcName
+    };
+  },
+  mathmlBuilder
+});
+
+// Limits, not symbols
+defineFunction({
+  type: "op",
+  names: ["\\det", "\\gcd", "\\inf", "\\lim", "\\max", "\\min", "\\Pr", "\\sup"],
+  props: {
+    numArgs: 0
+  },
+  handler({ parser, funcName }) {
+    const prevAtomType = parser.prevAtomType
+    const next = parser.gullet.future().text
+    return {
+      type: "op",
+      mode: parser.mode,
+      limits: true,
+      parentIsSupSub: false,
+      symbol: false,
+      stack: false,
+      isFollowedByDelimiter: isDelimiter(next),
+      needsLeadingSpace: prevAtomType.length > 0 && ordTypes.includes(prevAtomType),
+      name: funcName
+    };
+  },
+  mathmlBuilder
+});
+
+// No limits, symbols
+defineFunction({
+  type: "op",
+  names: [
+    "\\int",
+    "\\iint",
+    "\\iiint",
+    "\\iiiint",
+    "\\oint",
+    "\\oiint",
+    "\\oiiint",
+    "\\intclockwise",
+    "\\varointclockwise",
+    "\\intbar",
+    "\\intBar",
+    "\\fint",
+    "\\rppolint",
+    "\\scpolint",
+    "\\pointint",
+    "\\sqint",
+    "\\intlarhk",
+    "\\intx",
+    "\\intcap",
+    "\\intcup",
+    "\u222b",
+    "\u222c",
+    "\u222d",
+    "\u222e",
+    "\u222f",
+    "\u2230",
+    "\u2231",
+    "\u2232",
+    "\u2a0c",
+    "\u2a0d",
+    "\u2a0e",
+    "\u2a0f",
+    "\u2a12",
+    "\u2a13",
+    "\u2a15",
+    "\u2a16",
+    "\u2a17",
+    "\u2a18",
+    "\u2a19",
+    "\u2a1a"
+  ],
+  props: {
+    numArgs: 0
+  },
+  handler({ parser, funcName }) {
+    let fName = funcName;
+    if (fName.length === 1) {
+      fName = singleCharIntegrals[fName];
+    }
+    return {
+      type: "op",
+      mode: parser.mode,
+      limits: false,
+      parentIsSupSub: false,
+      symbol: true,
+      stack: false,
+      name: fName
+    };
+  },
+  mathmlBuilder
+});

package/src/functions/operatorname.js

@@ -0,0 +1,139 @@
+import defineFunction, { ordargument } from "../defineFunction"
+import defineMacro from "../defineMacro";
+import mathMLTree from "../mathMLTree"
+import { spaceCharacter } from "./kern"
+import { ordTypes } from "./op"
+import { delimiters, delimiterSizes } from "./delimsizing"
+
+import * as mml from "../buildMathML"
+
+const dels = ["}", "\\left", "\\middle", "\\right"]
+const isDelimiter = str => str.length > 0 &&
+  (delimiters.includes(str) || delimiterSizes[str] || dels.includes(str))
+
+  // NOTE: Unlike most builders, this one handles not only
+// "operatorname", but also  "supsub" since \operatorname* can
+// affect super/subscripting.
+
+const mathmlBuilder = (group, style) => {
+  let expression = mml.buildExpression(group.body, style.withFont("mathrm"))
+
+  // Is expression a string or has it something like a fraction?
+  let isAllString = true; // default
+  for (let i = 0; i < expression.length; i++) {
+    const node = expression[i]
+    if (node instanceof mathMLTree.MathNode) {
+      switch (node.type) {
+        case "mi":
+        case "mn":
+        case "ms":
+        case "mtext":
+          break; // Do nothing yet.
+        case "mspace":
+          {
+            if (node.attributes.width) {
+              const width = node.attributes.width.replace("em", "")
+              const ch = spaceCharacter(Number(width))
+              if (ch === "") {
+                isAllString = false
+              } else {
+                expression[i] = new mathMLTree.MathNode("mtext", [new mathMLTree.TextNode(ch)])
+              }
+            }
+          }
+          break
+        case "mo": {
+          const child = node.children[0]
+          if (node.children.length === 1 && child instanceof mathMLTree.TextNode) {
+            child.text = child.text.replace(/\u2212/, "-").replace(/\u2217/, "*")
+          } else {
+            isAllString = false
+          }
+          break
+        }
+        default:
+          isAllString = false
+      }
+    } else {
+      isAllString = false
+    }
+  }
+
+  if (isAllString) {
+    // Write a single TextNode instead of multiple nested tags.
+    const word = expression.map((node) => node.toText()).join("")
+    expression = [new mathMLTree.TextNode(word)]
+  } else if (
+    expression.length === 1
+    && ["mover", "munder"].includes(expression[0].type) &&
+    (expression[0].children[0].type === "mi" || expression[0].children[0].type === "mtext")
+  ) {
+    expression[0].children[0].type = "mi"
+    if (group.parentIsSupSub) {
+      return new mathMLTree.MathNode("mrow", expression)
+    } else {
+      const operator = new mathMLTree.MathNode("mo", [mml.makeText("\u2061", "text")])
+      return mathMLTree.newDocumentFragment([expression[0], operator])
+    }
+  }
+
+  let wrapper;
+  if (isAllString) {
+    wrapper = new mathMLTree.MathNode("mi", expression)
+    wrapper.setAttribute("mathvariant", "normal")
+  } else {
+    wrapper = new mathMLTree.MathNode("mrow", expression)
+  }
+
+  if (!group.parentIsSupSub) {
+    // 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")])
+    const fragment = [wrapper, operator]
+    if (group.needsLeadingSpace) {
+      // LaTeX gives operator spacing, but a <mi> gets ord spacing.
+      // So add a leading space.
+      const space = new mathMLTree.MathNode("mspace")
+      space.setAttribute("width", "0.1667em") // thin space.
+      fragment.unshift(space)
+    }
+    if (!group.isFollowedByDelimiter) {
+      const trail = new mathMLTree.MathNode("mspace")
+      trail.setAttribute("width", "0.1667em") // thin space.
+      fragment.push(trail)
+    }
+    return mathMLTree.newDocumentFragment(fragment)
+  }
+
+  return wrapper
+};
+
+// \operatorname
+// amsopn.dtx: \mathop{#1\kern\z@\operator@font#3}\newmcodes@
+defineFunction({
+  type: "operatorname",
+  names: ["\\operatorname@", "\\operatornamewithlimits"],
+  props: {
+    numArgs: 1,
+    allowedInArgument: true
+  },
+  handler: ({ parser, funcName }, args) => {
+    const body = args[0]
+    const prevAtomType = parser.prevAtomType
+    const next = parser.gullet.future().text
+    return {
+      type: "operatorname",
+      mode: parser.mode,
+      body: ordargument(body),
+      alwaysHandleSupSub: (funcName === "\\operatornamewithlimits"),
+      limits: false,
+      parentIsSupSub: false,
+      isFollowedByDelimiter: isDelimiter(next),
+      needsLeadingSpace: prevAtomType.length > 0 && ordTypes.includes(prevAtomType)
+    };
+  },
+  mathmlBuilder
+});
+
+defineMacro("\\operatorname",
+  "\\@ifstar\\operatornamewithlimits\\operatorname@");

package/src/functions/ordgroup.js

@@ -0,0 +1,9 @@
+import { defineFunctionBuilders } from "../defineFunction";
+import * as mml from "../buildMathML";
+
+defineFunctionBuilders({
+  type: "ordgroup",
+  mathmlBuilder(group, style) {
+    return mml.buildExpressionRow(group.body, style, true);
+  }
+});

package/src/functions/phantom.js

@@ -0,0 +1,73 @@
+import defineFunction, { ordargument } from "../defineFunction";
+import mathMLTree from "../mathMLTree";
+import * as mml from "../buildMathML";
+
+defineFunction({
+  type: "phantom",
+  names: ["\\phantom"],
+  props: {
+    numArgs: 1,
+    allowedInText: true
+  },
+  handler: ({ parser }, args) => {
+    const body = args[0];
+    return {
+      type: "phantom",
+      mode: parser.mode,
+      body: ordargument(body)
+    };
+  },
+  mathmlBuilder: (group, style) => {
+    const inner = mml.buildExpression(group.body, style);
+    return new mathMLTree.MathNode("mphantom", inner);
+  }
+});
+
+defineFunction({
+  type: "hphantom",
+  names: ["\\hphantom"],
+  props: {
+    numArgs: 1,
+    allowedInText: true
+  },
+  handler: ({ parser }, args) => {
+    const body = args[0];
+    return {
+      type: "hphantom",
+      mode: parser.mode,
+      body
+    };
+  },
+  mathmlBuilder: (group, style) => {
+    const inner = mml.buildExpression(ordargument(group.body), style);
+    const phantom = new mathMLTree.MathNode("mphantom", inner);
+    const node = new mathMLTree.MathNode("mpadded", [phantom]);
+    node.setAttribute("height", "0px");
+    node.setAttribute("depth", "0px");
+    return node;
+  }
+});
+
+defineFunction({
+  type: "vphantom",
+  names: ["\\vphantom"],
+  props: {
+    numArgs: 1,
+    allowedInText: true
+  },
+  handler: ({ parser }, args) => {
+    const body = args[0];
+    return {
+      type: "vphantom",
+      mode: parser.mode,
+      body
+    };
+  },
+  mathmlBuilder: (group, style) => {
+    const inner = mml.buildExpression(ordargument(group.body), style);
+    const phantom = new mathMLTree.MathNode("mphantom", inner);
+    const node = new mathMLTree.MathNode("mpadded", [phantom]);
+    node.setAttribute("width", "0px");
+    return node;
+  }
+});

package/src/functions/pmb.js

@@ -0,0 +1,31 @@
+import defineFunction, { ordargument } from "../defineFunction"
+import { wrapWithMstyle } from "../mathMLTree"
+import * as mml from "../buildMathML"
+
+// \pmb is a simulation of bold font.
+// The version of \pmb in ambsy.sty works by typesetting three copies of the argument
+// with small offsets. We use CSS text-shadow.
+// It's a hack. Not as good as a real bold font. Better than nothing.
+
+defineFunction({
+  type: "pmb",
+  names: ["\\pmb"],
+  props: {
+    numArgs: 1,
+    allowedInText: true
+  },
+  handler({ parser }, args) {
+    return {
+      type: "pmb",
+      mode: parser.mode,
+      body: ordargument(args[0])
+    }
+  },
+  mathmlBuilder(group, style) {
+    const inner = mml.buildExpression(group.body, style)
+    // Wrap with an <mstyle> element.
+    const node = wrapWithMstyle(inner)
+    node.setAttribute("style", "text-shadow: 0.02em 0.01em 0.04px")
+    return node
+  }
+})

package/src/functions/raise.js

@@ -0,0 +1,68 @@
+import defineFunction from "../defineFunction"
+import { StyleLevel } from "../constants"
+import mathMLTree from "../mathMLTree"
+import { assertNodeType } from "../parseNode"
+import { calculateSize } from "../units"
+import * as mml from "../buildMathML"
+
+const sign = num => num >= 0 ? "+" : "-"
+
+// \raise, \lower, and \raisebox
+
+const mathmlBuilder = (group, style) => {
+  const newStyle = style.withLevel(StyleLevel.TEXT)
+  const node = new mathMLTree.MathNode("mpadded", [mml.buildGroup(group.body, newStyle)])
+  const dy = calculateSize(group.dy, style)
+  node.setAttribute("voffset", dy.number + dy.unit)
+  const dyAbs = Math.abs(dy.number)
+  // The next two lines do not work in Chromium.
+  // TODO: Find some other way to adjust height and depth.
+  node.setAttribute("height", sign(dy.number) +  dyAbs + dy.unit)
+  node.setAttribute("depth", sign(-dy.number) +  dyAbs + dy.unit)
+  return node
+}
+
+defineFunction({
+  type: "raise",
+  names: ["\\raise", "\\lower"],
+  props: {
+    numArgs: 2,
+    argTypes: ["size", "primitive"],
+    primitive: true
+  },
+  handler({ parser, funcName }, args) {
+    const amount = assertNodeType(args[0], "size").value;
+    if (funcName === "\\lower") { amount.number *= -1 }
+    const body = args[1]
+    return {
+      type: "raise",
+      mode: parser.mode,
+      dy: amount,
+      body
+    };
+  },
+  mathmlBuilder
+})
+
+
+defineFunction({
+  type: "raise",
+  names: ["\\raisebox"],
+  props: {
+    numArgs: 2,
+    argTypes: ["size", "hbox"],
+    allowedInText: true
+  },
+  handler({ parser, funcName }, args) {
+    const amount = assertNodeType(args[0], "size").value
+    const body = args[1]
+    return {
+      type: "raise",
+      mode: parser.mode,
+      dy: amount,
+      body
+    };
+  },
+  mathmlBuilder
+})
+