temml 0.9.1

package/src/Settings.js

@@ -0,0 +1,49 @@
+/**
+ * This is a module for storing settings passed into Temml. It correctly handles
+ * default settings.
+ */
+
+import utils from "./utils";
+
+/**
+ * The main Settings object
+ */
+export default class Settings {
+  constructor(options) {
+    // allow null options
+    options = options || {};
+    this.displayMode = utils.deflt(options.displayMode, false);    // boolean
+    this.annotate = utils.deflt(options.annotate, false)           // boolean
+    this.leqno = utils.deflt(options.leqno, false);                // boolean
+    this.errorColor = utils.deflt(options.errorColor, "#b22222");  // string
+    this.macros = options.macros || {};
+    this.wrap = utils.deflt(options.wrap, "none")         // "none" | "tex" | "="
+    this.xml = utils.deflt(options.xml, false);                     // boolean
+    this.colorIsTextColor = utils.deflt(options.colorIsTextColor, false);  // booelean
+    this.strict = utils.deflt(options.strict, false);    // boolean
+    this.trust = utils.deflt(options.trust, false);  // trust context. See html.js.
+    this.maxSize = (options.maxSize === undefined
+      ? [Infinity, Infinity]
+      : Array.isArray(options.maxSize)
+      ? options.maxSize
+      : [Infinity, Infinity]
+    )
+    this.maxExpand = Math.max(0, utils.deflt(options.maxExpand, 1000)); // number
+  }
+
+  /**
+   * Check whether to test potentially dangerous input, and return
+   * `true` (trusted) or `false` (untrusted).  The sole argument `context`
+   * should be an object with `command` field specifying the relevant LaTeX
+   * command (as a string starting with `\`), and any other arguments, etc.
+   * If `context` has a `url` field, a `protocol` field will automatically
+   * get added by this function (changing the specified object).
+   */
+  isTrusted(context) {
+    if (context.url && !context.protocol) {
+      context.protocol = utils.protocolFromUrl(context.url);
+    }
+    const trust = typeof this.trust === "function" ? this.trust(context) : this.trust;
+    return Boolean(trust);
+  }
+}

package/src/SourceLocation.js

@@ -0,0 +1,29 @@
+/**
+ * Lexing or parsing positional information for error reporting.
+ * This object is immutable.
+ */
+export default class SourceLocation {
+  constructor(lexer, start, end) {
+    this.lexer = lexer; // Lexer holding the input string.
+    this.start = start; // Start offset, zero-based inclusive.
+    this.end = end;     // End offset, zero-based exclusive.
+  }
+
+  /**
+   * Merges two `SourceLocation`s from location providers, given they are
+   * provided in order of appearance.
+   * - Returns the first one's location if only the first is provided.
+   * - Returns a merged range of the first and the last if both are provided
+   *   and their lexers match.
+   * - Otherwise, returns null.
+   */
+  static range(first, second) {
+    if (!second) {
+      return first && first.loc;
+    } else if (!first || !first.loc || !second.loc || first.loc.lexer !== second.loc.lexer) {
+      return null;
+    } else {
+      return new SourceLocation(first.loc.lexer, first.loc.start, second.loc.end);
+    }
+  }
+}

package/src/Style.js

@@ -0,0 +1,144 @@
+/**
+ * This file contains information about the style that the mathmlBuilder carries
+ * around with it. Data is held in an `Style` object, and when
+ * recursing, a new `Style` object can be created with the `.with*` functions.
+ */
+
+const subOrSupLevel = [2, 2, 3, 3];
+
+/**
+ * This is the main Style class. It contains the current style.level, color, and font.
+ *
+ * Style objects should not be modified. To create a new Style with
+ * different properties, call a `.with*` method.
+ */
+class Style {
+  constructor(data) {
+    // Style.level can be 0 | 1 | 2 | 3, which correspond to
+    //       displaystyle, textstyle, scriptstyle, and scriptscriptstyle.
+    // style.level does not directly set MathML's script level. MathML does that itself.
+    // We use style.level to track, not set, math style so that we can get the
+    // correct scriptlevel when needed in supsub.js, mathchoice.js, or for dimensions in em.
+    this.level = data.level;
+    this.color = data.color;  // string | void
+    // A font family applies to a group of fonts (i.e. SansSerif), while a font
+    // represents a specific font (i.e. SansSerif Bold).
+    // See: https://tex.stackexchange.com/questions/22350/difference-between-textrm-and-mathrm
+    this.font = data.font || "";                // string
+    this.fontFamily = data.fontFamily || "";    // string
+    this.fontSize = data.fontSize || 1.0;       // number
+    this.fontWeight = data.fontWeight || "";
+    this.fontShape = data.fontShape || "";
+    this.maxSize = data.maxSize;                // [number, number]
+  }
+
+  /**
+   * Returns a new style object with the same properties as "this".  Properties
+   * from "extension" will be copied to the new style object.
+   */
+  extend(extension) {
+    const data = {
+      level: this.level,
+      color: this.color,
+      font: this.font,
+      fontFamily: this.fontFamily,
+      fontSize: this.fontSize,
+      fontWeight: this.fontWeight,
+      fontShape: this.fontShape,
+      maxSize: this.maxSize
+    };
+
+    for (const key in extension) {
+      if (Object.prototype.hasOwnProperty.call(extension, key)) {
+        data[key] = extension[key];
+      }
+    }
+
+    return new Style(data);
+  }
+
+  withLevel(n) {
+    return this.extend({
+      level: n
+    });
+  }
+
+  incrementLevel() {
+    return this.extend({
+      level: Math.min(this.level + 1, 3)
+    });
+  }
+
+  inSubOrSup() {
+    return this.extend({
+      level: subOrSupLevel[this.level]
+    })
+  }
+
+  /**
+   * Create a new style object with the given color.
+   */
+  withColor(color) {
+    return this.extend({
+      color: color
+    });
+  }
+
+  /**
+   * Creates a new style object with the given math font or old text font.
+   * @type {[type]}
+   */
+  withFont(font) {
+    return this.extend({
+      font
+    });
+  }
+
+  /**
+   * Create a new style objects with the given fontFamily.
+   */
+  withTextFontFamily(fontFamily) {
+    return this.extend({
+      fontFamily,
+      font: ""
+    });
+  }
+
+  /**
+   * Creates a new style object with the given font size
+   */
+  withFontSize(num) {
+    return this.extend({
+      fontSize: num
+    });
+  }
+
+  /**
+   * Creates a new style object with the given font weight
+   */
+  withTextFontWeight(fontWeight) {
+    return this.extend({
+      fontWeight,
+      font: ""
+    });
+  }
+
+  /**
+   * Creates a new style object with the given font weight
+   */
+  withTextFontShape(fontShape) {
+    return this.extend({
+      fontShape,
+      font: ""
+    });
+  }
+
+  /**
+   * Gets the CSS color of the current style object
+   */
+  getColor() {
+    return this.color;
+  }
+}
+
+export default Style;

package/src/Token.js

@@ -0,0 +1,40 @@
+import SourceLocation from "./SourceLocation";
+
+/**
+ * Interface required to break circular dependency between Token, Lexer, and
+ * ParseError.
+ */
+
+/**
+ * The resulting token returned from `lex`.
+ *
+ * It consists of the token text plus some position information.
+ * The position information is essentially a range in an input string,
+ * but instead of referencing the bare input string, we refer to the lexer.
+ * That way it is possible to attach extra metadata to the input string,
+ * like for example a file name or similar.
+ *
+ * The position information is optional, so it is OK to construct synthetic
+ * tokens if appropriate. Not providing available position information may
+ * lead to degraded error reporting, though.
+ */
+export class Token {
+  constructor(
+    text, // the text of this token
+    loc
+  ) {
+    this.text = text;
+    this.loc = loc;
+  }
+
+  /**
+   * Given a pair of tokens (this and endToken), compute a `Token` encompassing
+   * the whole input range enclosed by these two.
+   */
+  range(
+    endToken, // last token of the range, inclusive
+    text // the text of the newly constructed token
+  ) {
+    return new Token(text, SourceLocation.range(this, endToken));
+  }
+}

package/src/buildMathML.js

@@ -0,0 +1,235 @@
+/**
+ * This file converts a parse tree into a cooresponding MathML tree. The main
+ * entry point is the `buildMathML` function, which takes a parse tree from the
+ * parser.
+ */
+
+import mathMLTree from "./mathMLTree"
+import ParseError from "./ParseError"
+import symbols, { ligatures } from "./symbols"
+import { _mathmlGroupBuilders as groupBuilders } from "./defineFunction"
+import { MathNode } from "./mathMLTree"
+import setLineBreaks from "./linebreaking"
+
+/**
+ * Takes a symbol and converts it into a MathML text node after performing
+ * optional replacement from symbols.js.
+ */
+export const makeText = function(text, mode, style) {
+  if (
+    symbols[mode][text] &&
+    symbols[mode][text].replace &&
+    text.charCodeAt(0) !== 0xd835 &&
+    !(
+      Object.prototype.hasOwnProperty.call(ligatures, text) &&
+      style &&
+      ((style.fontFamily && style.fontFamily.slice(4, 6) === "tt") ||
+        (style.font && style.font.slice(4, 6) === "tt"))
+    )
+  ) {
+    text = symbols[mode][text].replace;
+  }
+
+  return new mathMLTree.TextNode(text);
+};
+
+export const consolidateText = mrow => {
+  // If possible, consolidate adjacent <mtext> elements into a single element.
+  if (mrow.type !== "mrow") { return mrow }
+  if (mrow.children.length === 0) { return mrow } // empty group, e.g., \text{}
+  if (!mrow.children[0].attributes || mrow.children[0].type !== "mtext") { return mrow }
+  const variant = mrow.children[0].attributes.mathvariant || ""
+  const mtext = new mathMLTree.MathNode(
+    "mtext",
+    [new mathMLTree.TextNode(mrow.children[0].children[0].text)]
+  )
+  for (let i = 1; i < mrow.children.length; i++) {
+    // Check each child and, if possible, copy the character into child[0].
+    const localVariant = mrow.children[i].attributes.mathvariant || ""
+    if (mrow.children[i].type === "mrow") {
+      const childRow = mrow.children[i]
+      for (let j = 0; j < childRow.children.length; j++) {
+        // We'll also check the children of a mrow. One level only. No recursion.
+        const childVariant = childRow.children[j].attributes.mathvariant || ""
+        if (childVariant !== variant || childRow.children[j].type !== "mtext") {
+          return mrow // At least one element cannot be consolidated. Get out.
+        } else {
+          mtext.children[0].text += childRow.children[j].children[0].text
+        }
+      }
+    } else if (localVariant !== variant || mrow.children[i].type !== "mtext") {
+      return mrow
+    } else {
+      mtext.children[0].text += mrow.children[i].children[0].text
+    }
+  }
+  // Firefox does not render a space at either end of an <mtext> string.
+  // To get proper rendering, we replace leading or trailing spaces with no-break spaces.
+  if (mtext.children[0].text.charAt(0) === " ") {
+    mtext.children[0].text = "\u00a0" + mtext.children[0].text.slice(1)
+  }
+  const L = mtext.children[0].text.length
+  if (L > 0 && mtext.children[0].text.charAt(L - 1) === " ") {
+    mtext.children[0].text = mtext.children[0].text.slice(0, -1) + "\u00a0"
+  }
+  return mtext
+}
+
+/**
+ * Wrap the given array of nodes in an <mrow> node if needed, i.e.,
+ * unless the array has length 1.  Always returns a single node.
+ */
+export const makeRow = function(body) {
+  if (body.length === 1) {
+    return body[0];
+  } else {
+    return new mathMLTree.MathNode("mrow", body);
+  }
+};
+
+const isRel = item => {
+  return (item.type === "atom" && item.family === "rel") ||
+      (item.type === "mclass" && item.mclass === "mrel")
+}
+
+/**
+ * Takes a list of nodes, builds them, and returns a list of the generated
+ * MathML nodes.  Also do a couple chores along the way:
+ * (1) Suppress spacing when an author wraps an operator w/braces, as in {=}.
+ * (2) Suppress spacing between two adjacent relations.
+ */
+export const buildExpression = function(expression, style, isOrdgroup) {
+  if (expression.length === 1) {
+    const group = buildGroup(expression[0], style);
+    if (isOrdgroup && group instanceof MathNode && group.type === "mo") {
+      // When TeX writers want to suppress spacing on an operator,
+      // they often put the operator by itself inside braces.
+      group.setAttribute("lspace", "0em");
+      group.setAttribute("rspace", "0em");
+    }
+    return [group];
+  }
+
+  const groups = [];
+  for (let i = 0; i < expression.length; i++) {
+    const group = buildGroup(expression[i], style);
+    // Suppress spacing between adjacent relations
+    if (i < expression.length - 1 && isRel(expression[i]) && isRel(expression[i + 1])) {
+      group.setAttribute("rspace", "0em")
+    }
+    if (i > 0 && isRel(expression[i]) && isRel(expression[i - 1])) {
+      group.setAttribute("lspace", "0em")
+    }
+    groups.push(group);
+  }
+  return groups;
+};
+
+/**
+ * Equivalent to buildExpression, but wraps the elements in an <mrow>
+ * if there's more than one.  Returns a single node instead of an array.
+ */
+export const buildExpressionRow = function(expression, style, isOrdgroup) {
+  return makeRow(buildExpression(expression, style, isOrdgroup));
+};
+
+/**
+ * Takes a group from the parser and calls the appropriate groupBuilders function
+ * on it to produce a MathML node.
+ */
+export const buildGroup = function(group, style) {
+  if (!group) {
+    return new mathMLTree.MathNode("mrow");
+  }
+
+  if (groupBuilders[group.type]) {
+    // Call the groupBuilders function
+    const result = groupBuilders[group.type](group, style);
+    return result;
+  } else {
+    throw new ParseError("Got group of unknown type: '" + group.type + "'");
+  }
+};
+
+const glue = _ => {
+  return new mathMLTree.MathNode("mtd", [], [], { padding: "0", width: "50%" })
+}
+
+const taggedExpression = (expression, tag, style, leqno) => {
+  tag = buildExpressionRow(tag[0].body, style)
+  tag = consolidateText(tag)
+  tag.classes.push("tml-tag")
+
+  expression = new mathMLTree.MathNode("mtd", [expression])
+  const rowArray = [glue(), expression, glue()]
+  if (leqno) {
+    rowArray[0].children.push(tag)
+    rowArray[0].style.textAlign = "-webkit-left"
+  } else {
+    rowArray[2].children.push(tag)
+    rowArray[2].style.textAlign = "-webkit-right"
+  }
+  const mtr = new mathMLTree.MathNode("mtr", rowArray, ["tml-tageqn"])
+  const table = new mathMLTree.MathNode("mtable", [mtr])
+  table.style.width = "100%"
+  table.setAttribute("displaystyle", "true")
+  return table
+}
+
+/**
+ * Takes a full parse tree and settings and builds a MathML representation of
+ * it.
+ */
+export default function buildMathML(tree, texExpression, style, settings) {
+  // Strip off outer tag wrapper for processing below.
+  let tag = null
+  if (tree.length === 1 && tree[0].type === "tag") {
+    tag = tree[0].tag
+    tree = tree[0].body
+  }
+
+  const expression = buildExpression(tree, style);
+  const wrap = (settings.displayMode || settings.annotate) ? "none" : settings.wrap
+
+  const n1 = expression.length === 0 ? null : expression[0]
+  let wrapper = expression.length === 1 && tag === null && (n1 instanceof MathNode)
+          && !(n1.type === "mstyle" && n1.attributes.mathcolor)
+      ? expression[0]
+      : expression.length > 1 && wrap === "none"
+      ? new mathMLTree.MathNode("mrow", expression)
+      : setLineBreaks(expression, wrap, settings.displayMode)
+
+  if (tag) {
+    wrapper = taggedExpression(wrapper, tag, style, settings.leqno)
+  }
+
+  if (settings.annotate) {
+    // Build a TeX annotation of the source
+    const annotation = new mathMLTree.MathNode(
+      "annotation", [new mathMLTree.TextNode(texExpression)]);
+    annotation.setAttribute("encoding", "application/x-tex");
+    wrapper = new mathMLTree.MathNode("semantics", [wrapper, annotation]);
+  }
+
+  if (wrap !== "none") {
+    const maths = []
+    for (let i = 0; i < wrapper.children.length; i++) {
+      const math = new mathMLTree.MathNode("math", [wrapper.children[i]])
+      if (settings.xml) {
+        math.setAttribute("xmlns", "http://www.w3.org/1998/Math/MathML")
+      }
+      maths.push(math)
+    }
+    return mathMLTree.newDocumentFragment(maths)
+  }
+
+  const math = new mathMLTree.MathNode("math", [wrapper])
+
+  if (settings.xml) {
+    math.setAttribute("xmlns", "http://www.w3.org/1998/Math/MathML")
+  }
+  if (settings.displayMode) {
+    math.setAttribute("display", "block");
+  }
+  return math;
+}

package/src/constants.js

@@ -0,0 +1,25 @@
+// In TeX, there are actually three sets of dimensions, one for each of
+// textstyle, scriptstyle, and scriptscriptstyle.  These are
+// provided in the the arrays below, in that order.
+//
+export const metrics = {
+  quad: [1.0, 1.171, 1.472], // Extracted from TeX
+
+  // The TeX default rule thickness, 0.04 em, often disappears from a browser screen.
+  // So we use a thicker rule.
+  defaultRuleThickness: [0.06, 0.074, 0.074],
+
+  // The space between adjacent `|` columns in an array definition.
+  doubleRuleSep: [0.3, 0.3, 0.3],
+
+  // The width of separator lines in {array} environments.
+  arrayRuleWidth: [0.06, 0.06, 0.04]
+};
+
+// Math style is not quite the same thing as script level.
+export const StyleLevel = {
+  DISPLAY: 0,
+  TEXT: 1,
+  SCRIPT: 2,
+  SCRIPTSCRIPT: 3
+};

package/src/defineEnvironment.js

@@ -0,0 +1,25 @@
+import { _mathmlGroupBuilders } from "./defineFunction";
+
+/**
+ * All registered environments.
+ * `environments.js` exports this same dictionary again and makes it public.
+ * `Parser.js` requires this dictionary via `environments.js`.
+ */
+export const _environments = {};
+
+export default function defineEnvironment({ type, names, props, handler, mathmlBuilder }) {
+  // Set default values of environments.
+  const data = {
+    type,
+    numArgs: props.numArgs || 0,
+    allowedInText: false,
+    numOptionalArgs: 0,
+    handler
+  };
+  for (let i = 0; i < names.length; ++i) {
+    _environments[names[i]] = data;
+  }
+  if (mathmlBuilder) {
+    _mathmlGroupBuilders[type] = mathmlBuilder;
+  }
+}

package/src/defineFunction.js

@@ -0,0 +1,69 @@
+/**
+ * All registered functions.
+ * `functions.js` just exports this same dictionary again and makes it public.
+ * `Parser.js` requires this dictionary.
+ */
+export const _functions = {}
+
+/**
+ * All MathML builders. Should be only used in the `define*` and the `build*ML`
+ * functions.
+ */
+export const _mathmlGroupBuilders = {}
+
+export default function defineFunction({
+  type,
+  names,
+  props,
+  handler,
+  mathmlBuilder
+}) {
+  // Set default values of functions
+  const data = {
+    type,
+    numArgs: props.numArgs,
+    argTypes: props.argTypes,
+    allowedInArgument: !!props.allowedInArgument,
+    allowedInText: !!props.allowedInText,
+    allowedInMath: props.allowedInMath === undefined ? true : props.allowedInMath,
+    numOptionalArgs: props.numOptionalArgs || 0,
+    infix: !!props.infix,
+    primitive: !!props.primitive,
+    handler: handler
+  }
+  for (let i = 0; i < names.length; ++i) {
+    _functions[names[i]] = data
+  }
+  if (type) {
+    if (mathmlBuilder) {
+      _mathmlGroupBuilders[type] = mathmlBuilder
+    }
+  }
+}
+
+/**
+ * Use this to register only the MathML builder for a function(e.g.
+ * if the function's ParseNode is generated in Parser.js rather than via a
+ * stand-alone handler provided to `defineFunction`).
+ */
+export function defineFunctionBuilders({ type, mathmlBuilder }) {
+  defineFunction({
+    type,
+    names: [],
+    props: { numArgs: 0 },
+    handler() {
+      throw new Error("Should never be called.")
+    },
+    mathmlBuilder
+  })
+}
+
+export const normalizeArgument = function(arg) {
+  return arg.type === "ordgroup" && arg.body.length === 1 ? arg.body[0] : arg
+}
+
+// Since the corresponding buildMathML function expects a
+// list of elements, we normalize for different kinds of arguments
+export const ordargument = function(arg) {
+  return arg.type === "ordgroup" ? arg.body : [arg]
+}

package/src/defineMacro.js

@@ -0,0 +1,11 @@
+/**
+ * All registered global/built-in macros.
+ * `macros.js` exports this same dictionary again and makes it public.
+ * `Parser.js` requires this dictionary via `macros.js`.
+ */
+export const _macros = {};
+
+// This function might one day accept an additional argument and do more things.
+export default function defineMacro(name, body) {
+  _macros[name] = body;
+}