temml 0.10.21 → 0.10.23

package/src/functions/reflect.js

@@ -0,0 +1,24 @@
+import defineFunction from "../defineFunction"
+import * as mml from "../buildMathML"
+
+defineFunction({
+  type: "reflect",
+  names: ["\\reflectbox"],
+  props: {
+    numArgs: 1,
+    argTypes: ["hbox"],
+    allowedInText: true
+  },
+  handler({ parser }, args) {
+    return {
+      type: "reflect",
+      mode: parser.mode,
+      body: args[0]
+    };
+  },
+  mathmlBuilder(group, style) {
+    const node = mml.buildGroup(group.body, style)
+    node.style.transform = "scaleX(-1)"
+    return node
+  }
+})

package/src/functions/sizing.js

@@ -44,7 +44,7 @@ defineFunction({
       // eslint-disable-next-line no-console
       console.log(`Temml strict-mode warning: Command ${funcName} is invalid in math mode.`)
     }
-    const body = parser.parseExpression(false, breakOnTokenText);
+    const body = parser.parseExpression(false, breakOnTokenText, true);
     return {
       type: "sizing",
       mode: parser.mode,

package/src/functions/styling.js

@@ -26,7 +26,7 @@ defineFunction({
   },
   handler({ breakOnTokenText, funcName, parser }, args) {
     // parse out the implicit body
-    const body = parser.parseExpression(true, breakOnTokenText);
+    const body = parser.parseExpression(true, breakOnTokenText, true);
 
     const scriptLevel = funcName.slice(1, funcName.length - 5);
     return {

package/src/functions/symbolsOrd.js

@@ -90,8 +90,6 @@ defineFunctionBuilders({
       node = new mathMLTree.MathNode("mi", [text])
       if (text.text === origText && latinRegEx.test(origText)) {
         node.setAttribute("mathvariant", "italic")
-      } else if (text.text === "∇" && variant === "normal") {
-        node.setAttribute("mathvariant", "normal")
       }
     }
     return node

package/src/functions.js

@@ -41,6 +41,7 @@ import "./functions/phantom";
 import "./functions/pmb";
 import "./functions/raise";
 import "./functions/ref";
+import "./functions/reflect";
 import "./functions/relax";
 import "./functions/rule";
 import "./functions/sizing";

package/src/linebreaking.js

@@ -57,7 +57,8 @@ export default function setLineBreaks(expression, wrapMode, isDisplayMode) {
       continue
     }
     block.push(node);
-    if (node.type && node.type === "mo" && node.children.length === 1) {
+    if (node.type && node.type === "mo" && node.children.length === 1 &&
+        !Object.hasOwn(node.attributes, "movablelimits")) {
       const ch = node.children[0].text
       if (openDelims.indexOf(ch) > -1) {
         level += 1
@@ -72,7 +73,7 @@ export default function setLineBreaks(expression, wrapMode, isDisplayMode) {
           mrows.push(element)
           block = [node];
         }
-      } else if (level === 0 && wrapMode === "tex") {
+      } else if (level === 0 && wrapMode === "tex" && ch !== "∇") {
         // 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;

package/src/macros.js

@@ -184,6 +184,24 @@ defineMacro("\\char", function(context) {
   return `\\@char{${number}}`;
 });
 
+function recreateArgStr(context) {
+  // Recreate the macro's original argument string from the array of parse tokens.
+  const tokens = context.consumeArgs(1)[0];
+  let str = ""
+  let expectedLoc = tokens[tokens.length - 1].loc.start
+  for (let i = tokens.length - 1; i >= 0; i--) {
+    const actualLoc = tokens[i].loc.start
+    if (actualLoc > expectedLoc) {
+      // context.consumeArgs has eaten a space.
+      str += " "
+      expectedLoc = actualLoc;
+    }
+    str += tokens[i].text
+    expectedLoc += tokens[i].text.length
+  }
+  return str
+}
+
 // The Latin Modern font renders <mi>√</mi> at the wrong vertical alignment.
 // This macro provides a better rendering.
 defineMacro("\\surd", '\\sqrt{\\vphantom{|}}')
@@ -191,10 +209,6 @@ defineMacro("\\surd", '\\sqrt{\\vphantom{|}}')
 // See comment for \oplus in symbols.js.
 defineMacro("\u2295", "\\oplus")
 
-// Per TeXbook p.122, "/" gets zero operator spacing.
-// And MDN recommends using U+2044 instead of / for inline
-defineMacro("/", "{\u2044}")
-
 // Since Temml has no \par, ignore \long.
 defineMacro("\\long", "")
 
@@ -572,6 +586,11 @@ defineMacro("\\argmin", "\\DOTSB\\operatorname*{arg\\,min}");
 defineMacro("\\argmax", "\\DOTSB\\operatorname*{arg\\,max}");
 defineMacro("\\plim", "\\DOTSB\\operatorname*{plim}");
 
+//////////////////////////////////////////////////////////////////////
+// MnSymbol.sty
+
+defineMacro("\\leftmodels", "\\mathop{\\reflectbox{$\\models$}}")
+
 //////////////////////////////////////////////////////////////////////
 // braket.sty
 // http://ctan.math.washington.edu/tex-archive/macros/latex/contrib/braket/braket.pdf
@@ -581,56 +600,33 @@ defineMacro("\\ket", "\\mathinner{|{#1}\\rangle}");
 defineMacro("\\braket", "\\mathinner{\\langle{#1}\\rangle}");
 defineMacro("\\Bra", "\\left\\langle#1\\right|");
 defineMacro("\\Ket", "\\left|#1\\right\\rangle");
-const braketHelper = (one) => (context) => {
-  const left = context.consumeArg().tokens;
-  const middle = context.consumeArg().tokens;
-  const middleDouble = context.consumeArg().tokens;
-  const right = context.consumeArg().tokens;
-  const oldMiddle = context.macros.get("|");
-  const oldMiddleDouble = context.macros.get("\\|");
-  context.macros.beginGroup();
-  const midMacro = (double) => (context) => {
-    if (one) {
-      // Only modify the first instance of | or \|
-      context.macros.set("|", oldMiddle);
-      if (middleDouble.length) {
-        context.macros.set("\\|", oldMiddleDouble);
-      }
-    }
-    let doubled = double;
-    if (!double && middleDouble.length) {
-      // Mimic \@ifnextchar
-      const nextToken = context.future();
-      if (nextToken.text === "|") {
-        context.popToken();
-        doubled = true;
-      }
-    }
-    return {
-      tokens: doubled ? middleDouble : middle,
-      numArgs: 0
-    };
-  };
-  context.macros.set("|", midMacro(false));
-  if (middleDouble.length) {
-    context.macros.set("\\|", midMacro(true));
+// A helper for \Braket and \Set
+const replaceVert = (argStr, match) => {
+  const ch = match[0] === "|" ? "\\vert" : "\\Vert"
+  const replaceStr = `}\\,\\middle${ch}\\,{`
+  return argStr.slice(0, match.index) + replaceStr + argStr.slice(match.index + match[0].length)
+}
+defineMacro("\\Braket",  function(context) {
+  let argStr = recreateArgStr(context)
+  const regEx = /\|\||\||\\\|/g
+  let match
+  while ((match = regEx.exec(argStr)) !== null) {
+    argStr = replaceVert(argStr, match)
   }
-  const arg = context.consumeArg().tokens;
-  const expanded = context.expandTokens([...right, ...arg, ...left]);  // reversed
-  context.macros.endGroup();
-  return {
-    tokens: expanded.reverse(),
-    numArgs: 0
-  };
-};
-defineMacro("\\bra@ket", braketHelper(false));
-defineMacro("\\bra@set", braketHelper(true));
-defineMacro("\\Braket", "\\bra@ket{\\left\\langle}" +
-  "{\\,\\middle\\vert\\,}{\\,\\middle\\vert\\,}{\\right\\rangle}");
-defineMacro("\\Set", "\\bra@set{\\left\\{\\:}" +
-  "{\\;\\middle\\vert\\;}{\\;\\middle\\Vert\\;}{\\:\\right\\}}");
-defineMacro("\\set", "\\bra@set{\\{\\,}{\\mid}{}{\\,\\}}");
-  // has no support for special || or \|
+  return "\\left\\langle{" + argStr + "}\\right\\rangle"
+});
+defineMacro("\\Set",  function(context) {
+  let argStr = recreateArgStr(context)
+  const match = /\|\||\||\\\|/.exec(argStr)
+  if (match) {
+    argStr = replaceVert(argStr, match)
+  }
+  return "\\left\\{\\:{" + argStr + "}\\:\\right\\}"
+});
+defineMacro("\\set",  function(context) {
+  const argStr = recreateArgStr(context)
+  return "\\{{" + argStr.replace(/\|/, "}\\mid{") + "}\\}"
+});
 
 //////////////////////////////////////////////////////////////////////
 // actuarialangle.dtx

package/src/postProcess.js

@@ -8,7 +8,7 @@
  * https://mit-license.org/
  */
 
-export const version = "0.10.21";
+export const version = "0.10.23";
 
 export function postProcess(block) {
   const labelMap = {}

package/src/replace.js

@@ -106,22 +106,22 @@ const offset = Object.freeze({
     "sans-serif-bold-italic": ch => { return 0x1D5F5 },
     "monospace": ch =>              { return 0x1D629 }
   },
-  upperCaseGreek: { // A-Ω ∇
+  upperCaseGreek: { // A-Ω
     "normal": ch =>                 { return 0 },
-    "bold": ch =>                   { return ch === "∇" ? 0x1B4BA : 0x1D317 },
-    "italic": ch =>                 { return ch === "∇" ? 0x1B4F4 : 0x1D351 },
+    "bold": ch =>                   { return 0x1D317 },
+    "italic": ch =>                 { return 0x1D351 },
     // \boldsymbol actually returns upright bold for upperCaseGreek
-    "bold-italic": ch =>            { return ch === "∇" ? 0x1B4BA : 0x1D317 },
+    "bold-italic": ch =>            { return 0x1D317 },
     "script": ch =>                 { return 0 },
     "script-bold": ch =>            { return 0 },
     "fraktur": ch =>                { return 0 },
     "fraktur-bold": ch =>           { return 0 },
     "double-struck": ch =>          { return 0 },
     // Unicode has no code points for regular-weight san-serif Greek. Use bold.
-    "sans-serif": ch =>             { return ch === "∇" ? 0x1B568 : 0x1D3C5 },
-    "sans-serif-bold": ch =>        { return ch === "∇" ? 0x1B568 : 0x1D3C5 },
+    "sans-serif": ch =>             { return 0x1D3C5 },
+    "sans-serif-bold": ch =>        { return 0x1D3C5 },
     "sans-serif-italic": ch =>      { return 0 },
-    "sans-serif-bold-italic": ch => { return ch === "∇" ? 0x1B5A2 : 0x1D3FF },
+    "sans-serif-bold-italic": ch => { return 0x1D3FF },
     "monospace": ch =>              { return 0 }
   },
   lowerCaseGreek: { // α-ω
@@ -181,7 +181,7 @@ export const variantChar = (ch, variant) => {
     ? "upperCaseLatin"
     : 0x60 < codePoint && codePoint < 0x7b
     ? "lowerCaseLatin"
-    : (0x390  < codePoint && codePoint < 0x3AA) || ch === "∇"
+    : (0x390  < codePoint && codePoint < 0x3AA)
     ? "upperCaseGreek"
     : 0x3B0 < codePoint && codePoint < 0x3CA || ch === "\u03d5"
     ? "lowerCaseGreek"

package/src/symbols.js

@@ -128,7 +128,8 @@ defineSymbol(math, textord, "\u2135", "\\aleph", true);
 defineSymbol(math, textord, "\u2200", "\\forall", true);
 defineSymbol(math, textord, "\u210f", "\\hbar", true);
 defineSymbol(math, textord, "\u2203", "\\exists", true);
-defineSymbol(math, textord, "\u2207", "\\nabla", true);
+// ∇ is actually a unary operator, not binary. But this works.
+defineSymbol(math, bin, "\u2207", "\\nabla", true);
 defineSymbol(math, textord, "\u266d", "\\flat", true);
 defineSymbol(math, textord, "\u2113", "\\ell", true);
 defineSymbol(math, textord, "\u266e", "\\natural", true);
@@ -182,6 +183,7 @@ defineSymbol(math, bin, "\u2021", "\\ddagger");
 defineSymbol(math, bin, "\u2240", "\\wr", true);
 defineSymbol(math, bin, "\u2a3f", "\\amalg");
 defineSymbol(math, bin, "\u0026", "\\And"); // from amsmath
+defineSymbol(math, bin, "\u2AFD", "\\sslash", true); // from stmaryrd
 
 // Arrow Symbols
 defineSymbol(math, rel, "\u27f5", "\\longleftarrow", true);
@@ -216,6 +218,7 @@ defineSymbol(math, mathord, "\u2609", "\\astrosun", true);
 defineSymbol(math, mathord, "\u263c", "\\sun", true);
 defineSymbol(math, mathord, "\u263e", "\\leftmoon", true);
 defineSymbol(math, mathord, "\u263d", "\\rightmoon", true);
+defineSymbol(math, mathord, "\u2295", "\\Earth");
 
 // AMS Negated Binary Relations
 defineSymbol(math, rel, "\u226e", "\\nless", true);
@@ -443,6 +446,8 @@ defineSymbol(math, bin, "\u27d5", "\\leftouterjoin", true);
 defineSymbol(math, bin, "\u27d6", "\\rightouterjoin", true);
 defineSymbol(math, bin, "\u27d7", "\\fullouterjoin", true);
 
+defineSymbol(math, bin, "\u2238", "\\dotminus", true); // stix
+
 // AMS Arrows
 // Note: unicode-math maps \u21e2 to their own function \rightdasharrow.
 // We'll map it to AMS function \dashrightarrow. It produces the same atom.
@@ -600,6 +605,7 @@ defineSymbol(math, mathord, "\u2aeb", "\\Bot");
 defineSymbol(math, bin, "\u2217", "\u2217", true);
 defineSymbol(math, bin, "+", "+");
 defineSymbol(math, bin, "*", "*");
+defineSymbol(math, bin, "\u2044", "/", true);
 defineSymbol(math, bin, "\u2044", "\u2044");
 defineSymbol(math, bin, "\u2212", "-", true);
 defineSymbol(math, bin, "\u22c5", "\\cdot", true);