temml 0.10.21 → 0.10.23

package/README.md

@@ -2,7 +2,7 @@
 
 | Library       | Minified JavaScript + CSS |
 |:--------------|:-------------------------:|
-| Temml         |         150 KB            |
+| Temml         |         151 KB            |
 | MathJax 2.7.5 |         338 KB            |
 | KaTeX         |         280 KB            |
 | TeXZilla      |         168 KB            |

package/dist/Temml-Asana.css

@@ -30,10 +30,6 @@ math * {
   border-color: currentColor;
 }
 
-mtext {
-  font-family: Asana Math;
-}
-
 math {
   font-family: Asana Math, math;
 }

package/dist/Temml-Fira.css

@@ -0,0 +1,152 @@
+/*
+Fira Math fonts are released under the SIL OPEN FONT LICENSE Version 1.1.
+
+The Fira Math WOFF2 font has been obtained from
+http://www.gust.org.pl/projects/e-foundry/
+
+The Temml.woff2 is a clone of KaTeX_Script-Regular, except that the code points
+have been changed from ASCII to Unicode Mathematical Alphanumeric Symbols Script capitals,
+Unicode range 1D49C to 1D4B5.
+*/
+
+@font-face {
+  font-family: 'Temml';
+  src: url('Temml.woff2') format('woff2');
+  font-weight: normal;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: Fira Math;
+  src: url('FiraMath-Regular.woff2');
+}
+
+math {
+  font-style: normal;
+  font-weight: normal;
+  line-height: normal;
+  font-size-adjust: none;
+  text-indent: 0;
+  text-transform: none;
+  letter-spacing: normal;
+  word-wrap: normal;
+  direction: ltr;
+}
+
+math * {
+  border-color: currentColor;
+}
+
+math {
+  font-family: "Fira Math", math;
+}
+
+/* Next line is active in Firefox and Safari.
+ * Not in Chromium, which recognizes display: "block math" written inline. */
+math.tml-display { display: block; }
+
+*.mathscr {
+  font-family: "Temml";
+}
+
+/* Chromium prime alignment */
+mo.tml-prime {
+  font-family: Temml;
+}
+
+mrow.tml-cancel {
+  background: linear-gradient(to top left,
+    rgba(0,0,0,0) 0%,
+    rgba(0,0,0,0) calc(50% - 0.06em),
+    rgba(0,0,0,1) 50%,
+    rgba(0,0,0,0) calc(50% + 0.06em),
+    rgba(0,0,0,0) 100%);
+}
+
+mrow.tml-bcancel {
+  background: linear-gradient(to top right,
+  rgba(0,0,0,0) 0%,
+  rgba(0,0,0,0) calc(50% - 0.06em),
+  rgba(0,0,0,1) 50%,
+  rgba(0,0,0,0) calc(50% + 0.06em),
+  rgba(0,0,0,0) 100%);
+}
+
+mrow.tml-xcancel {
+  background: linear-gradient(to top left,
+  rgba(0,0,0,0) 0%,
+  rgba(0,0,0,0) calc(50% - 0.06em),
+  rgba(0,0,0,1) 50%,
+  rgba(0,0,0,0) calc(50% + 0.06em),
+  rgba(0,0,0,0) 100%),
+  linear-gradient(to top right,
+  rgba(0,0,0,0) 0%,
+  rgba(0,0,0,0) calc(50% - 0.06em),
+  rgba(0,0,0,1) 50%,
+  rgba(0,0,0,0) calc(50% + 0.06em),
+  rgba(0,0,0,0) 100%)
+}
+
+/* Prevent f' from overlapping in Chromium */
+mo.prime-pad {
+  padding-left: 0.08em;
+}
+
+/* Array cell justification in Firefox & WebKit */
+.tml-right {
+  text-align: right;
+}
+.tml-left {
+  text-align: left;
+}
+
+/* Stretch \widetilde & set array cell justification in Chromium */
+@supports (not (-webkit-backdrop-filter: blur(1px))) and (not (-moz-appearance: none)) {
+  .tml-crooked-2 {
+    transform: scale(2.0, 1.1)
+  }
+  .tml-crooked-3 {
+    transform: scale(3.0, 1.3)
+  }
+  .tml-crooked-4 {
+    transform: scale(4.0, 1.4)
+  }
+  .tml-right {
+    text-align: -webkit-right;
+  }
+  .tml-left {
+    text-align: -webkit-left;
+  }
+}
+
+/* Adjust WebKit accents */
+@supports (-webkit-backdrop-filter: blur(1px)) {
+  .tml-xshift { transform: translate(0px, 0.45em) }
+  .tml-capshift { transform: translate(0px, 0.35em) }
+}
+
+/* flex-wrap for line-breaking in Chromium */
+math {
+  display: inline-flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+}
+math > mrow {
+  padding: 0.5ex 0ex;
+}
+
+/* Avoid flex-wrap in Firefox */
+@-moz-document url-prefix() {
+  math { display: inline; }
+  math > mrow { padding: 0 }
+}
+
+/* AMS environment auto-numbering via CSS counter. */
+.tml-eqn::before {
+  counter-increment: tmlEqnNo;
+  content: "(" counter(tmlEqnNo) ")";
+}
+
+body {
+  counter-reset: tmlEqnNo;
+}

package/dist/Temml-STIX2.css

@@ -32,10 +32,6 @@ math * {
  * Not in Chromium, which recognizes display: "block math" written inline. */
 math.tml-display { display: block; }
 
-mtext {
-  font-family: STIX2;
-}
-
 math {
   font-family: STIX2, math;
 }

package/dist/temml.cjs

@@ -936,7 +936,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);
@@ -990,6 +991,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);
@@ -1024,6 +1026,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);
@@ -1251,6 +1254,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.
@@ -1408,6 +1413,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);
@@ -1864,7 +1870,8 @@ 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;
@@ -1879,7 +1886,7 @@ 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;
@@ -2017,9 +2024,11 @@ const consolidateText = mrow => {
 };
 
 const numberRegEx$1 = /^[0-9]$/;
-const isCommaOrDot = node => {
-  return (node.type === "atom" && node.text === ",") ||
-         (node.type === "textord" && node.text === ".")
+const isDotOrComma = (node, followingNode) => {
+  return ((node.type === "textord" && node.text === ".") ||
+    (node.type === "atom" && node.text === ",")) &&
+    // Don't consolidate if there is a space after the comma.
+    node.loc && followingNode.loc && node.loc.end === followingNode.loc.start
 };
 const consolidateNumbers = expression => {
   // Consolidate adjacent numbers. We want to return <mn>1,506.3</mn>,
@@ -2042,7 +2051,8 @@ const consolidateNumbers = expression => {
 
   // Determine if numeral groups are separated by a comma or dot.
   for (let i = nums.length - 1; i > 0; i--) {
-    if (nums[i - 1].end === nums[i].start - 2 && isCommaOrDot(expression[nums[i].start - 1])) {
+    if (nums[i - 1].end === nums[i].start - 2 &&
+      isDotOrComma(expression[nums[i].start - 1], expression[nums[i].start])) {
       // Merge the two groups.
       nums[i - 1].end = nums[i].end;
       nums.splice(i, 1);
@@ -3258,7 +3268,7 @@ defineFunction({
     }
 
     // Parse out the implicit body that should be colored.
-    const body = parser.parseExpression(true, breakOnTokenText);
+    const body = parser.parseExpression(true, breakOnTokenText, true);
 
     return {
       type: "color",
@@ -3700,17 +3710,13 @@ const sizeToMaxHeight = [0, 1.2, 1.8, 2.4, 3.0];
 
 // Delimiter functions
 function checkDelimiter(delim, context) {
-  if (delim.type === "ordgroup" && delim.body.length === 1 && delim.body[0].text === "\u2044") {
-    // Recover "/" from the zero spacing group. (See macros.js)
-    delim = { type: "textord", text: "/", mode: "math" };
-  }
   const symDelim = checkSymbolNodeType(delim);
   if (symDelim && delimiters.includes(symDelim.text)) {
     // If a character is not in the MathML operator dictionary, it will not stretch.
     // Replace such characters w/characters that will stretch.
+    if (["/", "\u2044"].includes(symDelim.text)) { symDelim.text = "\u2215"; }
     if (["<", "\\lt"].includes(symDelim.text)) { symDelim.text = "⟨"; }
     if ([">", "\\gt"].includes(symDelim.text)) { symDelim.text = "⟩"; }
-    if (symDelim.text === "/") { symDelim.text = "\u2215"; }
     if (symDelim.text === "\\backslash") { symDelim.text = "\u2216"; }
     return symDelim;
   } else if (symDelim) {
@@ -3819,8 +3825,26 @@ defineFunction({
     const parser = context.parser;
     // Parse out the implicit body
     ++parser.leftrightDepth;
-    // parseExpression stops before '\\right'
-    const body = parser.parseExpression(false);
+    // parseExpression stops before '\\right' or `\\middle`
+    let body = parser.parseExpression(false, null, true);
+    let nextToken = parser.fetch();
+    while (nextToken.text === "\\middle") {
+      // `\middle`, from the ε-TeX package, ends one group and starts another group.
+      // We had to parse this expression with `breakOnMiddle` enabled in order
+      // to get TeX-compliant parsing of \over.
+      // But we do not want, at this point, to end on \middle, so continue
+      // to parse until we fetch a `\right`.
+      parser.consume();
+      const middle = parser.fetch().text;
+      if (!symbols.math[middle]) {
+        throw new ParseError(`Invalid delimiter '${middle}' after '\\middle'`);
+      }
+      checkDelimiter({ type: "atom", mode: "math", text: middle }, { funcName: "\\middle" });
+      body.push({ type: "middle", mode: "math", delim: middle });
+      parser.consume();
+      body = body.concat(parser.parseExpression(false, null, true));
+      nextToken = parser.fetch();
+    }
     --parser.leftrightDepth;
     // Check the next token
     parser.expect("\\right", false);
@@ -5094,6 +5118,21 @@ defineFunction({
   }
 });
 
+const isLongVariableName = (group, font) => {
+  if (font !== "mathrm" || group.body.type !== "ordgroup" || group.body.body.length === 1) {
+    return false
+  }
+  if (group.body.body[0].type !== "mathord") { return false }
+  for (let i = 1; i < group.body.body.length; i++) {
+    const parseNodeType = group.body.body[i].type;
+    if (!(parseNodeType ===  "mathord" ||
+    (parseNodeType ===  "textord" && !isNaN(group.body.body[i].text)))) {
+      return false
+    }
+  }
+  return true
+};
+
 const mathmlBuilder$6 = (group, style) => {
   const font = group.font;
   const newStyle = style.withFont(font);
@@ -5105,6 +5144,20 @@ const mathmlBuilder$6 = (group, style) => {
     return mathGroup
   }
   // Check if it is possible to consolidate elements into a single <mi> element.
+  if (isLongVariableName(group, font)) {
+    // This is a \mathrm{…} group. It gets special treatment because symbolsOrd.js
+    // wraps <mi> elements with <mrow>s to work around a Firefox bug.
+    const mi = mathGroup.children[0].children[0];
+    delete mi.attributes.mathvariant;
+    for (let i = 1; i < mathGroup.children.length; i++) {
+      mi.children[0].text += mathGroup.children[i].type === "mn"
+        ? mathGroup.children[i].children[0].text
+        : mathGroup.children[i].children[0].children[0].text;
+    }
+    // Wrap in a <mrow> to prevent the same Firefox bug.
+    const bogus = new mathMLTree.MathNode("mtext", new mathMLTree.TextNode("\u200b"));
+    return new mathMLTree.MathNode("mrow", [bogus, mi])
+  }
   let canConsolidate = mathGroup.children[0].type === "mo";
   for (let i = 1; i < mathGroup.children.length; i++) {
     if (mathGroup.children[i].type === "mo" && font === "boldsymbol") {
@@ -5195,7 +5248,7 @@ defineFunction({
   },
   handler: ({ parser, funcName, breakOnTokenText }, args) => {
     const { mode } = parser;
-    const body = parser.parseExpression(true, breakOnTokenText);
+    const body = parser.parseExpression(true, breakOnTokenText, true);
     const fontStyle = `math${funcName.slice(1)}`;
 
     return {
@@ -6156,6 +6209,9 @@ function mathmlBuilder$3(group, style) {
     if (group.isCharacterBox || inner[0].type === "mathord") {
       node = inner[0];
       node.type = "mi";
+      if (node.children.length === 1 && node.children[0].text && node.children[0].text === "∇") {
+        node.setAttribute("mathvariant", "normal");
+      }
     } else {
       node = new mathMLTree.MathNode("mi", inner);
     }
@@ -7143,6 +7199,28 @@ defineFunction({
   }
 });
 
+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 = buildGroup$1(group.body, style);
+    node.style.transform = "scaleX(-1)";
+    return node
+  }
+});
+
 defineFunction({
   type: "internal",
   names: ["\\relax"],
@@ -7248,7 +7326,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,
@@ -7381,7 +7459,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 {
@@ -7812,22 +7890,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: { // α-ω
@@ -7887,7 +7965,7 @@ 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"
@@ -8016,8 +8094,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
@@ -8654,6 +8730,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{|}}');
@@ -8661,10 +8755,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", "");
 
@@ -9042,6 +9132,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
@@ -9051,56 +9146,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));
-  }
-  const arg = context.consumeArg().tokens;
-  const expanded = context.expandTokens([...right, ...arg, ...left]);  // reversed
-  context.macros.endGroup();
-  return {
-    tokens: expanded.reverse(),
-    numArgs: 0
-  };
+// 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("\\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 \|
+defineMacro("\\Braket",  function(context) {
+  let argStr = recreateArgStr(context);
+  const regEx = /\|\||\||\\\|/g;
+  let match;
+  while ((match = regEx.exec(argStr)) !== null) {
+    argStr = replaceVert(argStr, match);
+  }
+  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
@@ -12149,8 +12221,12 @@ class Parser {
    * `breakOnTokenText`: The text of the token that the expression should end
    *                     with, or `null` if something else should end the
    *                     expression.
+   *
+   * `breakOnMiddle`: \color, \over, and old styling functions work on an implicit group.
+   *                  These groups end just before the usual tokens, but they also
+   *                  end just before `\middle`.
    */
-  parseExpression(breakOnInfix, breakOnTokenText) {
+  parseExpression(breakOnInfix, breakOnTokenText, breakOnMiddle) {
     const body = [];
     // Keep adding atoms to the body until we can't parse any more atoms (either
     // we reached the end, a }, or a \right)
@@ -12166,6 +12242,9 @@ class Parser {
       if (breakOnTokenText && lex.text === breakOnTokenText) {
         break;
       }
+      if (breakOnMiddle && lex.text === "\\middle") {
+        break
+      }
       if (breakOnInfix && functions[lex.text] && functions[lex.text].infix) {
         break;
       }
@@ -13144,7 +13223,7 @@ class Style {
  * https://mit-license.org/
  */
 
-const version = "0.10.21";
+const version = "0.10.23";
 
 function postProcess(block) {
   const labelMap = {};

package/dist/temml.d.ts

@@ -41,7 +41,7 @@ declare class ParseError {
   constructor(
     message: string, // The error message
     token: any, // An object providing position information
-  ) {}
+  );
 }
 
 declare const Temml: {