temml 0.9.1

package/src/functions/color.js

@@ -0,0 +1,253 @@
+import defineFunction, { ordargument } from "../defineFunction"
+import { wrapWithMstyle } from "../mathMLTree"
+import { assertNodeType } from "../parseNode"
+import ParseError from "../ParseError"
+import * as mml from "../buildMathML"
+
+// Helpers
+const htmlRegEx = /^(#[a-f0-9]{3}|#?[a-f0-9]{6})$/i
+const htmlOrNameRegEx = /^(#[a-f0-9]{3}|#?[a-f0-9]{6}|[a-z]+)$/i
+const RGBregEx = /^ *\d{1,3} *(?:, *\d{1,3} *){2}$/
+const rgbRegEx = /^ *[10](?:\.\d*)? *(?:, *[10](?:\.\d*)? *){2}$/
+const xcolorHtmlRegEx = /^[a-f0-9]{6}$/i
+const toHex = num => {
+  let str = num.toString(16)
+  if (str.length === 1) { str = "0" + str }
+  return str
+}
+
+// Colors from Tables 4.1 and 4.2 of the xcolor package.
+// Table 4.1 (lower case) RGB values are taken from chroma and xcolor.dtx.
+// Table 4.2 (Capitalizzed) values were sampled, because Chroma contains a unreliable
+// conversion from cmyk to RGB. See https://tex.stackexchange.com/a/537274.
+const xcolors = JSON.parse(`{
+  "Apricot": "#ffb484",
+  "Aquamarine": "#08b4bc",
+  "Bittersweet": "#c84c14",
+  "blue": "#0000FF",
+  "Blue": "#303494",
+  "BlueGreen": "#08b4bc",
+  "BlueViolet": "#503c94",
+  "BrickRed": "#b8341c",
+  "brown": "#BF8040",
+  "Brown": "#802404",
+  "BurntOrange": "#f8941c",
+  "CadetBlue": "#78749c",
+  "CarnationPink": "#f884b4",
+  "Cerulean": "#08a4e4",
+  "CornflowerBlue": "#40ace4",
+  "cyan": "#00FFFF",
+  "Cyan": "#08acec",
+  "Dandelion": "#ffbc44",
+  "darkgray": "#404040",
+  "DarkOrchid": "#a8548c",
+  "Emerald": "#08ac9c",
+  "ForestGreen": "#089c54",
+  "Fuchsia": "#90348c",
+  "Goldenrod": "#ffdc44",
+  "gray": "#808080",
+  "Gray": "#98949c",
+  "green": "#00FF00",
+  "Green": "#08a44c",
+  "GreenYellow": "#e0e474",
+  "JungleGreen": "#08ac9c",
+  "Lavender": "#f89cc4",
+  "lightgray": "#c0c0c0",
+  "lime": "#BFFF00",
+  "LimeGreen": "#90c43c",
+  "magenta": "#FF00FF",
+  "Magenta": "#f0048c",
+  "Mahogany": "#b0341c",
+  "Maroon": "#b03434",
+  "Melon": "#f89c7c",
+  "MidnightBlue": "#086494",
+  "Mulberry": "#b03c94",
+  "NavyBlue": "#086cbc",
+  "olive": "#7F7F00",
+  "OliveGreen": "#407c34",
+  "orange": "#FF8000",
+  "Orange": "#f8843c",
+  "OrangeRed": "#f0145c",
+  "Orchid": "#b074ac",
+  "Peach": "#f8945c",
+  "Periwinkle": "#8074bc",
+  "PineGreen": "#088c74",
+  "pink": "#ff7f7f",
+  "Plum": "#98248c",
+  "ProcessBlue": "#08b4ec",
+  "purple": "#BF0040",
+  "Purple": "#a0449c",
+  "RawSienna": "#983c04",
+  "red": "#ff0000",
+  "Red": "#f01c24",
+  "RedOrange": "#f86434",
+  "RedViolet": "#a0246c",
+  "Rhodamine": "#f0549c",
+  "Royallue": "#0874bc",
+  "RoyalPurple": "#683c9c",
+  "RubineRed": "#f0047c",
+  "Salmon": "#f8948c",
+  "SeaGreen": "#30bc9c",
+  "Sepia": "#701404",
+  "SkyBlue": "#48c4dc",
+  "SpringGreen": "#c8dc64",
+  "Tan": "#e09c74",
+  "teal": "#007F7F",
+  "TealBlue": "#08acb4",
+  "Thistle": "#d884b4",
+  "Turquoise": "#08b4cc",
+  "violet": "#800080",
+  "Violet": "#60449c",
+  "VioletRed": "#f054a4",
+  "WildStrawberry": "#f0246c",
+  "yellow": "#FFFF00",
+  "Yellow": "#fff404",
+  "YellowGreen": "#98cc6c",
+  "YellowOrange": "#ffa41c"
+}`)
+
+export const colorFromSpec = (model, spec) => {
+  let color = ""
+  if (model === "HTML") {
+    if (!htmlRegEx.test(spec)) {
+      throw new ParseError("Invalid HTML input.")
+    }
+    color = spec
+  } else if (model === "RGB") {
+    if (!RGBregEx.test(spec)) {
+      throw new ParseError("Invalid RGB input.")
+    }
+    spec.split(",").map(e => { color += toHex(Number(e.trim())) })
+  } else {
+    if (!rgbRegEx.test(spec)) {
+      throw new ParseError("Invalid rbg input.")
+    }
+    spec.split(",").map(e => {
+      const num = Number(e.trim())
+      if (num > 1) { throw new ParseError("Color rgb input must be < 1.") }
+      color += toHex((num * 255))
+    })
+  }
+  if (color.charAt(0) !== "#") { color = "#" + color }
+  return color
+}
+
+export const validateColor = (color, macros, token) => {
+  const macroName = `\\\\color@${color}` // from \defineColor.
+  const match = htmlOrNameRegEx.exec(color);
+  if (!match) { throw new ParseError("Invalid color: '" + color + "'", token) }
+  // We allow a 6-digit HTML color spec without a leading "#".
+  // This follows the xcolor package's HTML color model.
+  // Predefined color names are all missed by this RegEx pattern.
+  if (xcolorHtmlRegEx.test(color)) {
+    return "#" + color
+  } else if (color.charAt(0) === "#") {
+    return color
+  } else if (macros.has(macroName)) {
+    color = macros.get(macroName).tokens[0].text
+  } else if (xcolors[color]) {
+    color = xcolors[color]
+  }
+  return color
+}
+
+const mathmlBuilder = (group, style) => {
+  const inner = mml.buildExpression(group.body, style.withColor(group.color))
+  // Wrap with an <mstyle> element.
+  const node = wrapWithMstyle(inner)
+  node.setAttribute("mathcolor", group.color)
+  return node
+}
+
+defineFunction({
+  type: "color",
+  names: ["\\textcolor"],
+  props: {
+    numArgs: 2,
+    numOptionalArgs: 1,
+    allowedInText: true,
+    argTypes: ["raw", "raw", "original"]
+  },
+  handler({ parser, token }, args, optArgs) {
+    const model = optArgs[0] && assertNodeType(optArgs[0], "raw").string
+    let color = ""
+    if (model) {
+      const spec = assertNodeType(args[0], "raw").string
+      color = colorFromSpec(model, spec)
+    } else {
+      color = validateColor(assertNodeType(args[0], "raw").string, parser.gullet.macros, token)
+    }
+    const body = args[1];
+    return {
+      type: "color",
+      mode: parser.mode,
+      color,
+      body: ordargument(body)
+    }
+  },
+  mathmlBuilder
+})
+
+defineFunction({
+  type: "color",
+  names: ["\\color"],
+  props: {
+    numArgs: 1,
+    numOptionalArgs: 1,
+    allowedInText: true,
+    argTypes: ["raw", "raw"]
+  },
+  handler({ parser, token }, args, optArgs) {
+    const model = optArgs[0] && assertNodeType(optArgs[0], "raw").string
+    let color = ""
+    if (model) {
+      const spec = assertNodeType(args[0], "raw").string
+      color = colorFromSpec(model, spec)
+    } else {
+      color = validateColor(assertNodeType(args[0], "raw").string, parser.gullet.macros, token)
+    }
+
+    // Set macro \current@color in current namespace to store the current
+    // color, mimicking the behavior of color.sty.
+    // This is currently used just to correctly color a \right
+    // that follows a \color command.
+    parser.gullet.macros.set("\\current@color", color)
+
+    // Parse out the implicit body that should be colored.
+    // Since \color nodes should not be nested, break on \color.
+    const body = parser.parseExpression(true, "\\color")
+
+    return {
+      type: "color",
+      mode: parser.mode,
+      color,
+      body
+    }
+  },
+  mathmlBuilder
+})
+
+defineFunction({
+  type: "color",
+  names: ["\\definecolor"],
+  props: {
+    numArgs: 3,
+    allowedInText: true,
+    argTypes: ["raw", "raw", "raw"]
+  },
+  handler({ parser, funcName, token }, args) {
+    const name = assertNodeType(args[0], "raw").string
+    if (!/^[A-Za-z]+$/.test(name)) {
+      throw new ParseError("Color name must be latin letters.", token)
+    }
+    const model = assertNodeType(args[1], "raw").string
+    if (!["HTML", "RGB", "rgb"].includes(model)) {
+      throw new ParseError("Color model must be HTML, RGB, or rgb.", token)
+    }
+    const spec = assertNodeType(args[2], "raw").string
+    const color = colorFromSpec(model, spec)
+    parser.gullet.macros.set(`\\\\color@${name}`, { tokens: [{ text: color }], numArgs: 0 })
+    return { type: "internal", mode: parser.mode }
+  }
+  // No mathmlBuilder. The point of \definecolor is to set a macro.
+})

package/src/functions/cr.js

@@ -0,0 +1,46 @@
+// Row breaks within tabular environments, and line breaks at top level
+
+import defineFunction from "../defineFunction"
+import mathMLTree from "../mathMLTree"
+import { calculateSize } from "../units"
+import { assertNodeType } from "../parseNode"
+
+// \DeclareRobustCommand\\{...\@xnewline}
+defineFunction({
+  type: "cr",
+  names: ["\\\\"],
+  props: {
+    numArgs: 0,
+    numOptionalArgs: 1,
+    argTypes: ["size"],
+    allowedInText: true
+  },
+
+  handler({ parser }, args, optArgs) {
+    const size = optArgs[0];
+    const newLine = !parser.settings.displayMode;
+    return {
+      type: "cr",
+      mode: parser.mode,
+      newLine,
+      size: size && assertNodeType(size, "size").value
+    }
+  },
+
+  // The following builder is called only at the top level,
+  // not within tabular/array environments.
+
+  mathmlBuilder(group, style) {
+    // MathML 3.0 calls for newline to occur in an <mo> or an <mspace>.
+    // Ref: https://www.w3.org/TR/MathML3/chapter3.html#presm.linebreaking
+    const node = new mathMLTree.MathNode("mo")
+    if (group.newLine) {
+      node.setAttribute("linebreak", "newline")
+      if (group.size) {
+        const size = calculateSize(group.size, style)
+        node.setAttribute("height", size.number + size.unit)
+      }
+    }
+    return node
+  }
+})

package/src/functions/def.js

@@ -0,0 +1,259 @@
+import defineFunction from "../defineFunction";
+import ParseError from "../ParseError";
+import { assertNodeType } from "../parseNode";
+
+const globalMap = {
+  "\\global": "\\global",
+  "\\long": "\\\\globallong",
+  "\\\\globallong": "\\\\globallong",
+  "\\def": "\\gdef",
+  "\\gdef": "\\gdef",
+  "\\edef": "\\xdef",
+  "\\xdef": "\\xdef",
+  "\\let": "\\\\globallet",
+  "\\futurelet": "\\\\globalfuture"
+}
+
+const checkControlSequence = (tok) => {
+  const name = tok.text;
+  if (/^(?:[\\{}$&#^_]|EOF)$/.test(name)) {
+    throw new ParseError("Expected a control sequence", tok);
+  }
+  return name;
+};
+
+const getRHS = (parser) => {
+  let tok = parser.gullet.popToken();
+  if (tok.text === "=") {
+    // consume optional equals
+    tok = parser.gullet.popToken();
+    if (tok.text === " ") {
+      // consume one optional space
+      tok = parser.gullet.popToken();
+    }
+  }
+  return tok;
+};
+
+const letCommand = (parser, name, tok, global) => {
+  let macro = parser.gullet.macros.get(tok.text);
+  if (macro == null) {
+    // don't expand it later even if a macro with the same name is defined
+    // e.g., \let\foo=\frac \def\frac{\relax} \frac12
+    tok.noexpand = true;
+    macro = {
+      tokens: [tok],
+      numArgs: 0,
+      // reproduce the same behavior in expansion
+      unexpandable: !parser.gullet.isExpandable(tok.text)
+    };
+  }
+  parser.gullet.macros.set(name, macro, global);
+};
+
+// <assignment> -> <non-macro assignment>|<macro assignment>
+// <non-macro assignment> -> <simple assignment>|\global<non-macro assignment>
+// <macro assignment> -> <definition>|<prefix><macro assignment>
+// <prefix> -> \global|\long|\outer
+defineFunction({
+  type: "internal",
+  names: [
+    "\\global",
+    "\\long",
+    "\\\\globallong" // can’t be entered directly
+  ],
+  props: {
+    numArgs: 0,
+    allowedInText: true
+  },
+  handler({ parser, funcName }) {
+    parser.consumeSpaces();
+    const token = parser.fetch();
+    if (globalMap[token.text]) {
+      // Temml doesn't have \par, so ignore \long
+      if (funcName === "\\global" || funcName === "\\\\globallong") {
+        token.text = globalMap[token.text];
+      }
+      return assertNodeType(parser.parseFunction(), "internal");
+    }
+    throw new ParseError(`Invalid token after macro prefix`, token);
+  }
+});
+
+// Basic support for macro definitions: \def, \gdef, \edef, \xdef
+// <definition> -> <def><control sequence><definition text>
+// <def> -> \def|\gdef|\edef|\xdef
+// <definition text> -> <parameter text><left brace><balanced text><right brace>
+defineFunction({
+  type: "internal",
+  names: ["\\def", "\\gdef", "\\edef", "\\xdef"],
+  props: {
+    numArgs: 0,
+    allowedInText: true,
+    primitive: true
+  },
+  handler({ parser, funcName }) {
+    let tok = parser.gullet.popToken();
+    const name = tok.text;
+    if (/^(?:[\\{}$&#^_]|EOF)$/.test(name)) {
+      throw new ParseError("Expected a control sequence", tok);
+    }
+
+    let numArgs = 0;
+    let insert;
+    const delimiters = [[]];
+    // <parameter text> contains no braces
+    while (parser.gullet.future().text !== "{") {
+      tok = parser.gullet.popToken();
+      if (tok.text === "#") {
+        // If the very last character of the <parameter text> is #, so that
+        // this # is immediately followed by {, TeX will behave as if the {
+        // had been inserted at the right end of both the parameter text
+        // and the replacement text.
+        if (parser.gullet.future().text === "{") {
+          insert = parser.gullet.future();
+          delimiters[numArgs].push("{");
+          break;
+        }
+
+        // A parameter, the first appearance of # must be followed by 1,
+        // the next by 2, and so on; up to nine #’s are allowed
+        tok = parser.gullet.popToken();
+        if (!/^[1-9]$/.test(tok.text)) {
+          throw new ParseError(`Invalid argument number "${tok.text}"`);
+        }
+        if (parseInt(tok.text) !== numArgs + 1) {
+          throw new ParseError(`Argument number "${tok.text}" out of order`);
+        }
+        numArgs++;
+        delimiters.push([]);
+      } else if (tok.text === "EOF") {
+        throw new ParseError("Expected a macro definition");
+      } else {
+        delimiters[numArgs].push(tok.text);
+      }
+    }
+    // replacement text, enclosed in '{' and '}' and properly nested
+    let { tokens } = parser.gullet.consumeArg();
+    if (insert) {
+      tokens.unshift(insert);
+    }
+
+    if (funcName === "\\edef" || funcName === "\\xdef") {
+      tokens = parser.gullet.expandTokens(tokens);
+      tokens.reverse(); // to fit in with stack order
+    }
+    // Final arg is the expansion of the macro
+    parser.gullet.macros.set(
+      name,
+      { tokens, numArgs, delimiters },
+      funcName === globalMap[funcName]
+    );
+    return { type: "internal", mode: parser.mode };
+  }
+});
+
+// <simple assignment> -> <let assignment>
+// <let assignment> -> \futurelet<control sequence><token><token>
+//     | \let<control sequence><equals><one optional space><token>
+// <equals> -> <optional spaces>|<optional spaces>=
+defineFunction({
+  type: "internal",
+  names: [
+    "\\let",
+    "\\\\globallet" // can’t be entered directly
+  ],
+  props: {
+    numArgs: 0,
+    allowedInText: true,
+    primitive: true
+  },
+  handler({ parser, funcName }) {
+    const name = checkControlSequence(parser.gullet.popToken());
+    parser.gullet.consumeSpaces();
+    const tok = getRHS(parser);
+    letCommand(parser, name, tok, funcName === "\\\\globallet");
+    return { type: "internal", mode: parser.mode };
+  }
+});
+
+// ref: https://www.tug.org/TUGboat/tb09-3/tb22bechtolsheim.pdf
+defineFunction({
+  type: "internal",
+  names: [
+    "\\futurelet",
+    "\\\\globalfuture" // can’t be entered directly
+  ],
+  props: {
+    numArgs: 0,
+    allowedInText: true,
+    primitive: true
+  },
+  handler({ parser, funcName }) {
+    const name = checkControlSequence(parser.gullet.popToken());
+    const middle = parser.gullet.popToken();
+    const tok = parser.gullet.popToken();
+    letCommand(parser, name, tok, funcName === "\\\\globalfuture");
+    parser.gullet.pushToken(tok);
+    parser.gullet.pushToken(middle);
+    return { type: "internal", mode: parser.mode };
+  }
+});
+
+defineFunction({
+  type: "internal",
+  names: ["\\newcommand", "\\renewcommand", "\\providecommand"],
+  props: {
+    numArgs: 0,
+    allowedInText: true,
+    primitive: true
+  },
+  handler({ parser, funcName }) {
+    let name = ""
+    const tok = parser.gullet.popToken()
+    if (tok.text === "{") {
+      name = checkControlSequence(parser.gullet.popToken())
+      parser.gullet.popToken()
+    } else {
+      name = checkControlSequence(tok)
+    }
+
+    const exists = parser.gullet.isDefined(name);
+    if (exists && funcName === "\\newcommand") {
+      throw new ParseError(
+        `\\newcommand{${name}} attempting to redefine ${name}; use \\renewcommand`
+      );
+    }
+    if (!exists && funcName === "\\renewcommand") {
+      throw new ParseError(
+        `\\renewcommand{${name}} when command ${name} does not yet exist; use \\newcommand`
+      );
+    }
+
+    let numArgs = 0;
+    if (parser.gullet.future().text === "[") {
+      let tok = parser.gullet.popToken();
+      tok = parser.gullet.popToken();
+      if (!/^[0-9]$/.test(tok.text)) {
+        throw new ParseError(`Invalid number of arguments: "${tok.text}"`);
+      }
+      numArgs = parseInt(tok.text);
+      tok = parser.gullet.popToken();
+      if (tok.text !== "]") {
+        throw new ParseError(`Invalid argument "${tok.text}"`);
+      }
+    }
+
+    // replacement text, enclosed in '{' and '}' and properly nested
+    const { tokens } = parser.gullet.consumeArg();
+
+    parser.gullet.macros.set(
+      name,
+      { tokens, numArgs },
+      !parser.settings.strict
+    )
+
+    return { type: "internal", mode: parser.mode };
+
+  }
+});