katex 0.16.1 → 0.16.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "katex",
-  "version": "0.16.1",
+  "version": "0.16.3",
   "description": "Fast math typesetting for the web.",
   "main": "dist/katex.js",
   "exports": {

package/src/Parser.js

@@ -922,7 +922,7 @@ export default class Parser {
                     `Accented Unicode text character "${text[0]}" used in ` +
                     `math mode`, nucleus);
             }
-            text = unicodeSymbols[text[0]] + text.substr(1);
+            text = unicodeSymbols[text[0]] + text.slice(1);
         }
         // Strip off any combining characters
         const match = combiningDiacriticalMarksEndRegex.exec(text);

package/src/buildCommon.js

@@ -190,7 +190,7 @@ const makeOrd = function<NODETYPE: "spacing" | "mathord" | "textord">(
             return makeSymbol(text, fontName, mode, options,
                 classes.concat(fontClasses));
         } else if (ligatures.hasOwnProperty(text) &&
-                   fontName.substr(0, 10) === "Typewriter") {
+                   fontName.slice(0, 10) === "Typewriter") {
             // Deconstruct ligatures in monospace fonts (\texttt, \tt).
             const parts = [];
             for (let i = 0; i < text.length; i++) {

package/src/buildMathML.js

@@ -32,8 +32,8 @@ export const makeText = function(
     if (symbols[mode][text] && symbols[mode][text].replace &&
         text.charCodeAt(0) !== 0xD835 &&
         !(ligatures.hasOwnProperty(text) && options &&
-          ((options.fontFamily && options.fontFamily.substr(4, 2) === "tt") ||
-           (options.font && options.font.substr(4, 2) === "tt")))) {
+          ((options.fontFamily && options.fontFamily.slice(4, 6) === "tt") ||
+           (options.font && options.font.slice(4, 6) === "tt")))) {
         text = symbols[mode][text].replace;
     }
 

package/src/domTree.js

@@ -153,6 +153,7 @@ export type CssStyle = $Shape<{
     minWidth: string,
     paddingLeft: string,
     position: string,
+    textShadow: string,
     top: string,
     width: string,
     verticalAlign: string,

package/src/environments/array.js

@@ -39,6 +39,11 @@ function getHLines(parser: Parser): boolean[] {
     const hlineInfo = [];
     parser.consumeSpaces();
     let nxt = parser.fetch().text;
+    if (nxt === "\\relax") { // \relax is an artifact of the \cr macro below
+        parser.consume();
+        parser.consumeSpaces();
+        nxt = parser.fetch().text;
+    }
     while (nxt === "\\hline" || nxt === "\\hdashline") {
         parser.consume();
         hlineInfo.push(nxt === "\\hdashline");
@@ -256,7 +261,7 @@ function parseArray(
 // Decides on a style for cells in an array according to whether the given
 // environment name starts with the letter 'd'.
 function dCellStyle(envName): StyleStr {
-    if (envName.substr(0, 1) === "d") {
+    if (envName.slice(0, 1) === "d") {
         return "display";
     } else {
         return "text";

package/src/functions/enclose.js

@@ -20,7 +20,7 @@ const htmlBuilder = (group, options) => {
     const inner = buildCommon.wrapFragment(
         html.buildGroup(group.body, options), options);
 
-    const label = group.label.substr(1);
+    const label = group.label.slice(1);
     let scale = options.sizeMultiplier;
     let img;
     let imgShift = 0;

package/src/functions/mclass.js

@@ -75,7 +75,7 @@ defineFunction({
         return {
             type: "mclass",
             mode: parser.mode,
-            mclass: "m" + funcName.substr(5), // TODO(kevinb): don't prefix with 'm'
+            mclass: "m" + funcName.slice(5), // TODO(kevinb): don't prefix with 'm'
             body: ordargument(body),
             isCharacterBox: utils.isCharacterBox(body),
         };

package/src/functions/op.js

@@ -61,7 +61,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"op"> = (grp, options) => {
         if (group.name === "\\oiint" || group.name === "\\oiiint") {
             // No font glyphs yet, so use a glyph w/o the oval.
             // TODO: When font glyphs are available, delete this code.
-            stash = group.name.substr(1);
+            stash = group.name.slice(1);
             group.name = stash === "oiint" ? "\\iint" : "\\iiint";
         }
 

package/src/functions/pmb.js

@@ -0,0 +1,44 @@
+// @flow
+import defineFunction, {ordargument} from "../defineFunction";
+import buildCommon from "../buildCommon";
+import mathMLTree from "../mathMLTree";
+import * as html from "../buildHTML";
+import * as mml from "../buildMathML";
+import {binrelClass} from "./mclass";
+
+import type {ParseNode} from "../parseNode";
+
+// \pmb is a simulation of bold font.
+// The version of \pmb in ambsy.sty works by typesetting three copies
+// with small offsets. We use CSS text-shadow.
+// It's a hack. Not as good as a real bold font. Better than nothing.
+
+defineFunction({
+    type: "pmb",
+    names: ["\\pmb"],
+    props: {
+        numArgs: 1,
+        allowedInText: true,
+    },
+    handler({parser}, args) {
+        return {
+            type: "pmb",
+            mode: parser.mode,
+            mclass: binrelClass(args[0]),
+            body: ordargument(args[0]),
+        };
+    },
+    htmlBuilder(group: ParseNode<"pmb">, options) {
+        const elements = html.buildExpression(group.body, options, true);
+        const node = buildCommon.makeSpan([group.mclass], elements, options);
+        node.style.textShadow = "0.02em 0.01em 0.04px";
+        return node;
+    },
+    mathmlBuilder(group: ParseNode<"pmb">, style) {
+        const inner = mml.buildExpression(group.body, style);
+        // Wrap with an <mstyle> element.
+        const node = new mathMLTree.MathNode("mstyle", inner);
+        node.setAttribute("style", "text-shadow: 0.02em 0.01em 0.04px");
+        return node;
+    },
+});

package/src/functions.js

@@ -10,6 +10,7 @@ export default functions;
 import "./functions/accent";
 import "./functions/accentunder";
 import "./functions/arrow";
+import "./functions/pmb";
 import "./environments/cd";
 import "./functions/char";
 import "./functions/color";

package/src/macros.js

@@ -447,7 +447,7 @@ defineMacro("\\dots", function(context) {
     const next = context.expandAfterFuture().text;
     if (next in dotsByToken) {
         thedots = dotsByToken[next];
-    } else if (next.substr(0, 4) === '\\not') {
+    } else if (next.slice(0, 4) === '\\not') {
         thedots = '\\dotsb';
     } else if (next in symbols.math) {
         if (utils.contains(['bin', 'rel'], symbols.math[next].group)) {
@@ -597,14 +597,6 @@ defineMacro("\\mod", "\\allowbreak" +
     "\\mathchoice{\\mkern18mu}{\\mkern12mu}{\\mkern12mu}{\\mkern12mu}" +
     "{\\rm mod}\\,\\,#1");
 
-// \pmb    --   A simulation of bold.
-// The version in ambsy.sty works by typesetting three copies of the argument
-// with small offsets. We use two copies. We omit the vertical offset because
-// of rendering problems that makeVList encounters in Safari.
-defineMacro("\\pmb", "\\html@mathml{" +
-    "\\@binrel{#1}{\\mathrlap{#1}\\kern0.5px#1}}" +
-    "{\\mathbf{#1}}");
-
 //////////////////////////////////////////////////////////////////////
 // LaTeX source2e
 

package/src/parseNode.js

@@ -414,6 +414,13 @@ type ParseNodeTypes = {
         loc?: ?SourceLocation,
         body: AnyParseNode,
     |},
+    "pmb": {|
+        type: "pmb",
+        mode: Mode,
+        loc?: ?SourceLocation,
+        mclass: string,
+        body: AnyParseNode[],
+    |},
     "raisebox": {|
         type: "raisebox",
         mode: Mode,

package/src/stretchy.js

@@ -191,7 +191,7 @@ const svgSpan = function(
         height: number,
     } {
         let viewBoxWidth = 400000;  // default
-        const label = group.label.substr(1);
+        const label = group.label.slice(1);
         if (utils.contains(["widehat", "widecheck", "widetilde", "utilde"],
             label)) {
             // Each type in the `if` statement corresponds to one of the ParseNode