temml 0.9.2 → 0.10.2

package/dist/temml.js

@@ -669,7 +669,7 @@ var temml = (function () {
 
     /**
      * Converts the text node into a string
-     * (representing the text iteself).
+     * (representing the text itself).
      */
     toText() {
       return this.text;
@@ -846,7 +846,6 @@ var temml = (function () {
   defineSymbol(math, rel, "\u226b", "\\gg", true);
   defineSymbol(math, rel, "\u224d", "\\asymp", true);
   defineSymbol(math, rel, "\u2225", "\\parallel");
-  defineSymbol(math, rel, "\u22c8", "\\bowtie", true);
   defineSymbol(math, rel, "\u2323", "\\smile", true);
   defineSymbol(math, rel, "\u2291", "\\sqsubseteq", true);
   defineSymbol(math, rel, "\u2292", "\\sqsupseteq", true);
@@ -1163,7 +1162,6 @@ var temml = (function () {
   defineSymbol(math, bin, "\u22b2", "\\lhd");
   defineSymbol(math, bin, "\u22b3", "\\rhd");
   defineSymbol(math, rel, "\u2242", "\\eqsim", true);
-  defineSymbol(math, rel, "\u22c8", "\\Join");
   defineSymbol(math, rel, "\u2251", "\\Doteq", true);
   defineSymbol(math, rel, "\u297d", "\\strictif", true);
   defineSymbol(math, rel, "\u297c", "\\strictfi", true);
@@ -1189,6 +1187,11 @@ var temml = (function () {
   defineSymbol(math, bin, "\u22d2", "\\doublecap");
   defineSymbol(math, bin, "\u22d3", "\\doublecup");
   defineSymbol(math, bin, "\u22a0", "\\boxtimes", true);
+  defineSymbol(math, bin, "\u22c8", "\\bowtie", true);
+  defineSymbol(math, bin, "\u22c8", "\\Join");
+  defineSymbol(math, bin, "\u27d5", "\\leftouterjoin", true);
+  defineSymbol(math, bin, "\u27d6", "\\rightouterjoin", true);
+  defineSymbol(math, bin, "\u27d7", "\\fullouterjoin", true);
 
   // AMS Arrows
   // Note: unicode-math maps \u21e2 to their own function \rightdasharrow.
@@ -1235,6 +1238,8 @@ var temml = (function () {
   defineSymbol(math, textord, "$", "\\$");
   defineSymbol(text, textord, "$", "\\$");
   defineSymbol(text, textord, "$", "\\textdollar");
+  defineSymbol(math, textord, "¢", "\\cent");
+  defineSymbol(text, textord, "¢", "\\cent");
   defineSymbol(math, textord, "%", "\\%");
   defineSymbol(text, textord, "%", "\\%");
   defineSymbol(math, textord, "_", "\\_");
@@ -1891,7 +1896,7 @@ var temml = (function () {
   }
 
   /**
-   * This file converts a parse tree into a cooresponding MathML tree. The main
+   * This file converts a parse tree into a corresponding MathML tree. The main
    * entry point is the `buildMathML` function, which takes a parse tree from the
    * parser.
    */
@@ -3149,13 +3154,12 @@ var temml = (function () {
     names: ["\\\\"],
     props: {
       numArgs: 0,
-      numOptionalArgs: 1,
-      argTypes: ["size"],
+      numOptionalArgs: 0,
       allowedInText: true
     },
 
     handler({ parser }, args, optArgs) {
-      const size = optArgs[0];
+      const size = parser.gullet.future().text === "[" ? parser.parseSizeGroup(true) : null;
       const newLine = !parser.settings.displayMode;
       return {
         type: "cr",
@@ -3523,6 +3527,11 @@ var temml = (function () {
     "."
   ];
 
+  // Export isDelimiter for benefit of parser.
+  const dels = ["}", "\\left", "\\middle", "\\right"];
+  const isDelimiter = str => str.length > 0 &&
+    (delimiters.includes(str) || delimiterSizes[str] || dels.includes(str));
+
   // Metrics of the different sizes. Found by looking at TeX's output of
   // $\bigl| // \Bigl| \biggl| \Biggl| \showlists$
   // Used to create stacked delimiters of appropriate sizes in makeSizedDelim.
@@ -4915,7 +4924,6 @@ var temml = (function () {
       "\\mathscr",
       "\\mathsf",
       "\\mathtt",
-      "\\oldstylenums",
 
       // aliases
       "\\Bbb",
@@ -6206,10 +6214,6 @@ var temml = (function () {
   // Math operators (e.g. \sin) need a space between these types and themselves:
   const ordTypes = ["textord", "mathord", "ordgroup", "close", "leftright"];
 
-  const dels$1 = ["}", "\\left", "\\middle", "\\right"];
-  const isDelimiter$1 = str => str.length > 0 &&
-    (delimiters.includes(str) || delimiterSizes[str] || dels$1.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.
 
@@ -6430,7 +6434,7 @@ var temml = (function () {
         parentIsSupSub: false,
         symbol: false,
         stack: false,
-        isFollowedByDelimiter: isDelimiter$1(next),
+        isFollowedByDelimiter: isDelimiter(next),
         needsLeadingSpace: prevAtomType.length > 0 && ordTypes.includes(prevAtomType),
         name: funcName
       };
@@ -6455,7 +6459,7 @@ var temml = (function () {
         parentIsSupSub: false,
         symbol: false,
         stack: false,
-        isFollowedByDelimiter: isDelimiter$1(next),
+        isFollowedByDelimiter: isDelimiter(next),
         needsLeadingSpace: prevAtomType.length > 0 && ordTypes.includes(prevAtomType),
         name: funcName
       };
@@ -6541,11 +6545,7 @@ var temml = (function () {
     _macros[name] = body;
   }
 
-  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
+  // NOTE: Unlike most builders, this one handles not only
   // "operatorname", but also  "supsub" since \operatorname* can
   // affect super/subscripting.
 
@@ -6555,8 +6555,12 @@ var temml = (function () {
     // 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];
+      let node = expression[i];
       if (node instanceof mathMLTree.MathNode) {
+        if (node.type === "mrow" && node.children.length === 1 &&
+            node.children[0] instanceof mathMLTree.MathNode) {
+          node = node.children[0];
+        }
         switch (node.type) {
           case "mi":
           case "mn":
@@ -6614,7 +6618,9 @@ var temml = (function () {
     let wrapper;
     if (isAllString) {
       wrapper = new mathMLTree.MathNode("mi", expression);
-      wrapper.setAttribute("mathvariant", "normal");
+      if (expression[0].text.length === 1) {
+        wrapper.setAttribute("mathvariant", "normal");
+      }
     } else {
       wrapper = new mathMLTree.MathNode("mrow", expression);
     }
@@ -7152,6 +7158,7 @@ var temml = (function () {
       let isOver;
       let isSup;
       let appendApplyFunction = false;
+      let appendSpace = false;
       let needsLeadingSpace = false;
 
       if (group.base && group.base.type === "horizBrace") {
@@ -7166,6 +7173,7 @@ var temml = (function () {
         (group.base.type === "op" || group.base.type === "operatorname")) {
         group.base.parentIsSupSub = true;
         appendApplyFunction = !group.base.symbol;
+        appendSpace = appendApplyFunction && !group.isFollowedByDelimiter;
         needsLeadingSpace = group.base.needsLeadingSpace;
       }
 
@@ -7253,6 +7261,11 @@ var temml = (function () {
         } else {
           node = mathMLTree.newDocumentFragment([node, operator]);
         }
+        if (appendSpace) {
+          const space = new mathMLTree.MathNode("mspace");
+          space.setAttribute("width", "0.1667em"); // thin space.
+          node.children.push(space);
+        }
       } else if (symbolRegEx.test(nodeType)) {
         // Wrap in a <mrow>. Otherwise Firefox stretchy parens will not stretch to include limits.
         node = new mathMLTree.MathNode("mrow", [node]);
@@ -7329,8 +7342,7 @@ var temml = (function () {
     mathfrak: "fraktur",
     mathscr: "script",
     mathsf: "sans-serif",
-    mathtt: "monospace",
-    oldstylenums: "oldstylenums"
+    mathtt: "monospace"
   };
 
   /**
@@ -7400,8 +7412,6 @@ var temml = (function () {
         return "sans-serif"
       case "mathtt":
         return "monospace"
-      case "oldstylenums":
-        return "oldstylenums"
     }
 
     let text = group.text;
@@ -7697,10 +7707,7 @@ var temml = (function () {
       let node;
       if (numberRegEx$1.test(group.text)) {
         const tag = group.mode === "text" ? "mtext" : "mn";
-        if (variant === "oldstylenums") {
-          const ms = new mathMLTree.MathNode("mstyle", [text], ["oldstylenums"]);
-          node = new mathMLTree.MathNode(tag, [ms]);
-        } else if (variant === "italic" || variant === "bold-italic") {
+        if (variant === "italic" || variant === "bold-italic") {
           return italicNumber(text, variant, tag)
         } else {
           if (variant !== "normal") {
@@ -9113,15 +9120,15 @@ var temml = (function () {
      * Expand the next token only once if possible.
      *
      * If the token is expanded, the resulting tokens will be pushed onto
-     * the stack in reverse order and will be returned as an array,
-     * also in reverse order.
+     * the stack in reverse order, and the number of such tokens will be
+     * returned.  This number might be zero or positive.
      *
-     * If not, the next token will be returned without removing it
-     * from the stack.  This case can be detected by a `Token` return value
-     * instead of an `Array` return value.
+     * If not, the return value is `false`, and the next token remains at the
+     * top of the stack.
      *
      * In either case, the next token will be on the top of the stack,
-     * or the stack will be empty.
+     * or the stack will be empty (in case of empty expansion
+     * and no other tokens).
      *
      * Used to implement `expandAfterFuture` and `expandNextToken`.
      *
@@ -9137,7 +9144,7 @@ var temml = (function () {
           throw new ParseError("Undefined control sequence: " + name);
         }
         this.pushToken(topToken);
-        return topToken;
+        return false;
       }
       this.expansionCount++;
       if (this.expansionCount > this.settings.maxExpand) {
@@ -9171,7 +9178,7 @@ var temml = (function () {
       }
       // Concatenate expansion onto top of stack.
       this.pushTokens(tokens);
-      return tokens;
+      return tokens.length;
     }
 
     /**
@@ -9190,14 +9197,13 @@ var temml = (function () {
      */
     expandNextToken() {
       for (;;) {
-        const expanded = this.expandOnce();
-        // expandOnce returns Token if and only if it's fully expanded.
-        if (expanded instanceof Token) {
+        if (this.expandOnce() === false) { // fully expanded
+          const token = this.stack.pop();
           // The token after \noexpand is interpreted as if its meaning were ‘\relax’
-          if (expanded.treatAsRelax) {
-            expanded.text = "\\relax";
+          if (token.treatAsRelax) {
+            token.text = "\\relax";
           }
-          return this.stack.pop(); // === expanded
+          return token
         }
       }
 
@@ -9223,15 +9229,15 @@ var temml = (function () {
       const oldStackLength = this.stack.length;
       this.pushTokens(tokens);
       while (this.stack.length > oldStackLength) {
-        const expanded = this.expandOnce(true); // expand only expandable tokens
-        // expandOnce returns Token if and only if it's fully expanded.
-        if (expanded instanceof Token) {
-          if (expanded.treatAsRelax) {
+        // Expand only expandable tokens
+        if (this.expandOnce(true) === false) {  // fully expanded
+          const token = this.stack.pop();
+          if (token.treatAsRelax) {
             // the expansion of \noexpand is the token itself
-            expanded.noexpand = false;
-            expanded.treatAsRelax = false;
+            token.noexpand = false;
+            token.treatAsRelax = false;
           }
-          output.push(this.stack.pop());
+          output.push(token);
         }
       }
       return output;
@@ -9531,6 +9537,36 @@ var temml = (function () {
     '\u1DBF': 'θ'
   });
 
+  // Used for Unicode input of calligraphic and script letters
+  const asciiFromScript = Object.freeze({
+    "\ud835\udc9c": "A",
+    "\u212c": "B",
+    "\ud835\udc9e": "C",
+    "\ud835\udc9f": "D",
+    "\u2130": "E",
+    "\u2131": "F",
+    "\ud835\udca2": "G",
+    "\u210B": "H",
+    "\u2110": "I",
+    "\ud835\udca5": "J",
+    "\ud835\udca6": "K",
+    "\u2112": "L",
+    "\u2113": "M",
+    "\ud835\udca9": "N",
+    "\ud835\udcaa": "O",
+    "\ud835\udcab": "P",
+    "\ud835\udcac": "Q",
+    "\u211B": "R",
+    "\ud835\udcae": "S",
+    "\ud835\udcaf": "T",
+    "\ud835\udcb0": "U",
+    "\ud835\udcb1": "V",
+    "\ud835\udcb2": "W",
+    "\ud835\udcb3": "X",
+    "\ud835\udcb4": "Y",
+    "\ud835\udcb5": "Z"
+  });
+
   // Mapping of Unicode accent characters to their LaTeX equivalent in text and
   // math mode (when they exist).
   var unicodeAccents = {
@@ -10029,7 +10065,7 @@ var temml = (function () {
      * Parses an "expression", which is a list of atoms.
      *
      * `breakOnInfix`: Should the parsing stop when we hit infix nodes? This
-     *                 happens when functions have higher precendence han infix
+     *                 happens when functions have higher precedence han infix
      *                 nodes in implicit parses.
      *
      * `breakOnTokenText`: The text of the token that the expression should end
@@ -10280,12 +10316,16 @@ var temml = (function () {
           return base
         } else {
           // We got either a superscript or subscript, create a supsub
+          const isFollowedByDelimiter = (!base || base.type !== "op" && base.type !== "operatorname")
+            ? undefined
+            : isDelimiter(this.nextToken.text);
           return {
             type: "supsub",
             mode: this.mode,
             base: base,
             sup: superscript,
-            sub: subscript
+            sub: subscript,
+            isFollowedByDelimiter
           }
         }
       } else {
@@ -10446,7 +10486,7 @@ var temml = (function () {
       while (true) {
         const ch = this.fetch().text;
         // \ufe0e is the Unicode variation selector to supress emoji. Ignore it.
-        if (ch === " " || ch === "\ufe0e") {
+        if (ch === " " || ch === "\u00a0" || ch === "\ufe0e") {
           this.consume();
         } else {
           break
@@ -10766,6 +10806,22 @@ var temml = (function () {
             text
           };
         } else {
+          if (asciiFromScript[text]) {
+            // Unicode 14 disambiguates chancery from roundhand.
+            // See https://www.unicode.org/charts/PDF/U1D400.pdf
+            this.consume();
+            const nextCode = this.fetch().text.charCodeAt(0);
+            // mathcal is Temml default. Use mathscript if called for.
+            const font = nextCode === 0xfe01 ? "mathscr" : "mathcal";
+            if (nextCode === 0xfe00 || nextCode === 0xfe01) { this.consume(); }
+            return {
+              type: "font",
+              mode: "math",
+              font,
+              body: { type: "mathord", mode: "math", loc, text: asciiFromScript[text] }
+            }
+          }
+          // Default ord character. No disambiguation necessary.
           s = {
             type: group,
             mode: this.mode,
@@ -11022,7 +11078,7 @@ var temml = (function () {
    * https://mit-license.org/
    */
 
-  const version = "0.9.2";
+  const version = "0.10.2";
 
   function postProcess(block) {
     const labelMap = {};