katex 0.16.1 → 0.16.2

package/dist/katex.mjs

@@ -5465,7 +5465,7 @@ var makeOrd = function makeOrd(group, options, type) {
 
     if (lookupSymbol(text, fontName, mode).metrics) {
       return makeSymbol(text, fontName, mode, options, classes.concat(fontClasses));
-    } else if (ligatures.hasOwnProperty(text) && fontName.substr(0, 10) === "Typewriter") {
+    } else if (ligatures.hasOwnProperty(text) && fontName.slice(0, 10) === "Typewriter") {
       // Deconstruct ligatures in monospace fonts (\texttt, \tt).
       var parts = [];
 
@@ -6799,7 +6799,7 @@ var mathMLTree = {
  * optional replacement from symbols.js.
  */
 var makeText = function makeText(text, mode, options) {
-  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"))) {
+  if (symbols[mode][text] && symbols[mode][text].replace && text.charCodeAt(0) !== 0xD835 && !(ligatures.hasOwnProperty(text) && options && (options.fontFamily && options.fontFamily.slice(4, 6) === "tt" || options.font && options.font.slice(4, 6) === "tt"))) {
     text = symbols[mode][text].replace;
   }
 
@@ -7233,7 +7233,7 @@ var svgSpan = function svgSpan(group, options) {
   function buildSvgSpan_() {
     var viewBoxWidth = 400000; // default
 
-    var label = group.label.substr(1);
+    var 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
@@ -7882,6 +7882,217 @@ defineFunction({
 
 });
 
+var makeSpan = buildCommon.makeSpan;
+
+function htmlBuilder$9(group, options) {
+  var elements = buildExpression$1(group.body, options, true);
+  return makeSpan([group.mclass], elements, options);
+}
+
+function mathmlBuilder$8(group, options) {
+  var node;
+  var inner = buildExpression(group.body, options);
+
+  if (group.mclass === "minner") {
+    node = new mathMLTree.MathNode("mpadded", inner);
+  } else if (group.mclass === "mord") {
+    if (group.isCharacterBox) {
+      node = inner[0];
+      node.type = "mi";
+    } else {
+      node = new mathMLTree.MathNode("mi", inner);
+    }
+  } else {
+    if (group.isCharacterBox) {
+      node = inner[0];
+      node.type = "mo";
+    } else {
+      node = new mathMLTree.MathNode("mo", inner);
+    } // Set spacing based on what is the most likely adjacent atom type.
+    // See TeXbook p170.
+
+
+    if (group.mclass === "mbin") {
+      node.attributes.lspace = "0.22em"; // medium space
+
+      node.attributes.rspace = "0.22em";
+    } else if (group.mclass === "mpunct") {
+      node.attributes.lspace = "0em";
+      node.attributes.rspace = "0.17em"; // thinspace
+    } else if (group.mclass === "mopen" || group.mclass === "mclose") {
+      node.attributes.lspace = "0em";
+      node.attributes.rspace = "0em";
+    } else if (group.mclass === "minner") {
+      node.attributes.lspace = "0.0556em"; // 1 mu is the most likely option
+
+      node.attributes.width = "+0.1111em";
+    } // MathML <mo> default space is 5/18 em, so <mrel> needs no action.
+    // Ref: https://developer.mozilla.org/en-US/docs/Web/MathML/Element/mo
+
+  }
+
+  return node;
+} // Math class commands except \mathop
+
+
+defineFunction({
+  type: "mclass",
+  names: ["\\mathord", "\\mathbin", "\\mathrel", "\\mathopen", "\\mathclose", "\\mathpunct", "\\mathinner"],
+  props: {
+    numArgs: 1,
+    primitive: true
+  },
+
+  handler(_ref, args) {
+    var {
+      parser,
+      funcName
+    } = _ref;
+    var body = args[0];
+    return {
+      type: "mclass",
+      mode: parser.mode,
+      mclass: "m" + funcName.slice(5),
+      // TODO(kevinb): don't prefix with 'm'
+      body: ordargument(body),
+      isCharacterBox: utils.isCharacterBox(body)
+    };
+  },
+
+  htmlBuilder: htmlBuilder$9,
+  mathmlBuilder: mathmlBuilder$8
+});
+var binrelClass = arg => {
+  // \binrel@ spacing varies with (bin|rel|ord) of the atom in the argument.
+  // (by rendering separately and with {}s before and after, and measuring
+  // the change in spacing).  We'll do roughly the same by detecting the
+  // atom type directly.
+  var atom = arg.type === "ordgroup" && arg.body.length ? arg.body[0] : arg;
+
+  if (atom.type === "atom" && (atom.family === "bin" || atom.family === "rel")) {
+    return "m" + atom.family;
+  } else {
+    return "mord";
+  }
+}; // \@binrel{x}{y} renders like y but as mbin/mrel/mord if x is mbin/mrel/mord.
+// This is equivalent to \binrel@{x}\binrel@@{y} in AMSTeX.
+
+defineFunction({
+  type: "mclass",
+  names: ["\\@binrel"],
+  props: {
+    numArgs: 2
+  },
+
+  handler(_ref2, args) {
+    var {
+      parser
+    } = _ref2;
+    return {
+      type: "mclass",
+      mode: parser.mode,
+      mclass: binrelClass(args[0]),
+      body: ordargument(args[1]),
+      isCharacterBox: utils.isCharacterBox(args[1])
+    };
+  }
+
+}); // Build a relation or stacked op by placing one symbol on top of another
+
+defineFunction({
+  type: "mclass",
+  names: ["\\stackrel", "\\overset", "\\underset"],
+  props: {
+    numArgs: 2
+  },
+
+  handler(_ref3, args) {
+    var {
+      parser,
+      funcName
+    } = _ref3;
+    var baseArg = args[1];
+    var shiftedArg = args[0];
+    var mclass;
+
+    if (funcName !== "\\stackrel") {
+      // LaTeX applies \binrel spacing to \overset and \underset.
+      mclass = binrelClass(baseArg);
+    } else {
+      mclass = "mrel"; // for \stackrel
+    }
+
+    var baseOp = {
+      type: "op",
+      mode: baseArg.mode,
+      limits: true,
+      alwaysHandleSupSub: true,
+      parentIsSupSub: false,
+      symbol: false,
+      suppressBaseShift: funcName !== "\\stackrel",
+      body: ordargument(baseArg)
+    };
+    var supsub = {
+      type: "supsub",
+      mode: shiftedArg.mode,
+      base: baseOp,
+      sup: funcName === "\\underset" ? null : shiftedArg,
+      sub: funcName === "\\underset" ? shiftedArg : null
+    };
+    return {
+      type: "mclass",
+      mode: parser.mode,
+      mclass,
+      body: [supsub],
+      isCharacterBox: utils.isCharacterBox(supsub)
+    };
+  },
+
+  htmlBuilder: htmlBuilder$9,
+  mathmlBuilder: mathmlBuilder$8
+});
+
+// \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(_ref, args) {
+    var {
+      parser
+    } = _ref;
+    return {
+      type: "pmb",
+      mode: parser.mode,
+      mclass: binrelClass(args[0]),
+      body: ordargument(args[0])
+    };
+  },
+
+  htmlBuilder(group, options) {
+    var elements = buildExpression$1(group.body, options, true);
+    var node = buildCommon.makeSpan([group.mclass], elements, options);
+    node.style.textShadow = "0.02em 0.01em 0.04px";
+    return node;
+  },
+
+  mathmlBuilder(group, style) {
+    var inner = buildExpression(group.body, style); // Wrap with an <mstyle> element.
+
+    var node = new mathMLTree.MathNode("mstyle", inner);
+    node.setAttribute("style", "text-shadow: 0.02em 0.01em 0.04px");
+    return node;
+  }
+
+});
+
 var cdArrowFunctionName = {
   ">": "\\\\cdrightarrow",
   "<": "\\\\cdleftarrow",
@@ -8255,7 +8466,7 @@ defineFunction({
 
 });
 
-var htmlBuilder$9 = (group, options) => {
+var htmlBuilder$8 = (group, options) => {
   var elements = buildExpression$1(group.body, options.withColor(group.color), false); // \color isn't supposed to affect the type of the elements it contains.
   // To accomplish this, we wrap the results in a fragment, so the inner
   // elements will be able to directly interact with their neighbors. For
@@ -8264,7 +8475,7 @@ var htmlBuilder$9 = (group, options) => {
   return buildCommon.makeFragment(elements);
 };
 
-var mathmlBuilder$8 = (group, options) => {
+var mathmlBuilder$7 = (group, options) => {
   var inner = buildExpression(group.body, options.withColor(group.color));
   var node = new mathMLTree.MathNode("mstyle", inner);
   node.setAttribute("mathcolor", group.color);
@@ -8294,8 +8505,8 @@ defineFunction({
     };
   },
 
-  htmlBuilder: htmlBuilder$9,
-  mathmlBuilder: mathmlBuilder$8
+  htmlBuilder: htmlBuilder$8,
+  mathmlBuilder: mathmlBuilder$7
 });
 defineFunction({
   type: "color",
@@ -8327,8 +8538,8 @@ defineFunction({
     };
   },
 
-  htmlBuilder: htmlBuilder$9,
-  mathmlBuilder: mathmlBuilder$8
+  htmlBuilder: htmlBuilder$8,
+  mathmlBuilder: mathmlBuilder$7
 });
 
 // Row breaks within tabular environments, and line breaks at top level
@@ -9689,12 +9900,12 @@ defineFunction({
   }
 });
 
-var htmlBuilder$8 = (group, options) => {
+var htmlBuilder$7 = (group, options) => {
   // \cancel, \bcancel, \xcancel, \sout, \fbox, \colorbox, \fcolorbox, \phase
   // Some groups can return document fragments.  Handle those by wrapping
   // them in a span.
   var inner = buildCommon.wrapFragment(buildGroup$1(group.body, options), options);
-  var label = group.label.substr(1);
+  var label = group.label.slice(1);
   var scale = options.sizeMultiplier;
   var img;
   var imgShift = 0; // In the LaTeX cancel package, line geometry is slightly different
@@ -9841,7 +10052,7 @@ var htmlBuilder$8 = (group, options) => {
   }
 };
 
-var mathmlBuilder$7 = (group, options) => {
+var mathmlBuilder$6 = (group, options) => {
   var fboxsep = 0;
   var node = new mathMLTree.MathNode(group.label.indexOf("colorbox") > -1 ? "mpadded" : "menclose", [buildGroup(group.body, options)]);
 
@@ -9927,8 +10138,8 @@ defineFunction({
     };
   },
 
-  htmlBuilder: htmlBuilder$8,
-  mathmlBuilder: mathmlBuilder$7
+  htmlBuilder: htmlBuilder$7,
+  mathmlBuilder: mathmlBuilder$6
 });
 defineFunction({
   type: "enclose",
@@ -9957,8 +10168,8 @@ defineFunction({
     };
   },
 
-  htmlBuilder: htmlBuilder$8,
-  mathmlBuilder: mathmlBuilder$7
+  htmlBuilder: htmlBuilder$7,
+  mathmlBuilder: mathmlBuilder$6
 });
 defineFunction({
   type: "enclose",
@@ -10003,8 +10214,8 @@ defineFunction({
     };
   },
 
-  htmlBuilder: htmlBuilder$8,
-  mathmlBuilder: mathmlBuilder$7
+  htmlBuilder: htmlBuilder$7,
+  mathmlBuilder: mathmlBuilder$6
 });
 defineFunction({
   type: "enclose",
@@ -10291,14 +10502,14 @@ function parseArray(parser, _ref, style) {
 
 
 function dCellStyle(envName) {
-  if (envName.substr(0, 1) === "d") {
+  if (envName.slice(0, 1) === "d") {
     return "display";
   } else {
     return "text";
   }
 }
 
-var htmlBuilder$7 = function htmlBuilder(group, options) {
+var htmlBuilder$6 = function htmlBuilder(group, options) {
   var r;
   var c;
   var nr = group.body.length;
@@ -10601,7 +10812,7 @@ var alignMap = {
   r: "right "
 };
 
-var mathmlBuilder$6 = function mathmlBuilder(group, options) {
+var mathmlBuilder$5 = function mathmlBuilder(group, options) {
   var tbl = [];
   var glue = new mathMLTree.MathNode("mtd", [], ["mtr-glue"]);
   var tag = new mathMLTree.MathNode("mtd", [], ["mml-eqn-num"]);
@@ -10885,8 +11096,8 @@ defineEnvironment({
     return parseArray(context.parser, res, dCellStyle(context.envName));
   },
 
-  htmlBuilder: htmlBuilder$7,
-  mathmlBuilder: mathmlBuilder$6
+  htmlBuilder: htmlBuilder$6,
+  mathmlBuilder: mathmlBuilder$5
 }); // The matrix environments of amsmath builds on the array environment
 // of LaTeX, which is discussed above.
 // The mathtools package adds starred versions of the same environments.
@@ -10962,8 +11173,8 @@ defineEnvironment({
     } : res;
   },
 
-  htmlBuilder: htmlBuilder$7,
-  mathmlBuilder: mathmlBuilder$6
+  htmlBuilder: htmlBuilder$6,
+  mathmlBuilder: mathmlBuilder$5
 });
 defineEnvironment({
   type: "array",
@@ -10981,8 +11192,8 @@ defineEnvironment({
     return res;
   },
 
-  htmlBuilder: htmlBuilder$7,
-  mathmlBuilder: mathmlBuilder$6
+  htmlBuilder: htmlBuilder$6,
+  mathmlBuilder: mathmlBuilder$5
 });
 defineEnvironment({
   type: "array",
@@ -11027,8 +11238,8 @@ defineEnvironment({
     return res;
   },
 
-  htmlBuilder: htmlBuilder$7,
-  mathmlBuilder: mathmlBuilder$6
+  htmlBuilder: htmlBuilder$6,
+  mathmlBuilder: mathmlBuilder$5
 }); // A cases environment (in amsmath.sty) is almost equivalent to
 // \def\arraystretch{1.2}%
 // \left\{\begin{array}{@{}l@{\quad}l@{}} … \end{array}\right.
@@ -11075,8 +11286,8 @@ defineEnvironment({
     };
   },
 
-  htmlBuilder: htmlBuilder$7,
-  mathmlBuilder: mathmlBuilder$6
+  htmlBuilder: htmlBuilder$6,
+  mathmlBuilder: mathmlBuilder$5
 }); // In the align environment, one uses ampersands, &, to specify number of
 // columns in each row, and to locate spacing between each column.
 // align gets automatic numbering. align* and aligned do not.
@@ -11091,8 +11302,8 @@ defineEnvironment({
     numArgs: 0
   },
   handler: alignedHandler,
-  htmlBuilder: htmlBuilder$7,
-  mathmlBuilder: mathmlBuilder$6
+  htmlBuilder: htmlBuilder$6,
+  mathmlBuilder: mathmlBuilder$5
 }); // A gathered environment is like an array environment with one centered
 // column, but where rows are considered lines so get \jot line spacing
 // and contents are set in \displaystyle.
@@ -11123,8 +11334,8 @@ defineEnvironment({
     return parseArray(context.parser, res, "display");
   },
 
-  htmlBuilder: htmlBuilder$7,
-  mathmlBuilder: mathmlBuilder$6
+  htmlBuilder: htmlBuilder$6,
+  mathmlBuilder: mathmlBuilder$5
 }); // alignat environment is like an align environment, but one must explicitly
 // specify maximum number of columns in each row, and can adjust spacing between
 // each columns.
@@ -11136,8 +11347,8 @@ defineEnvironment({
     numArgs: 1
   },
   handler: alignedHandler,
-  htmlBuilder: htmlBuilder$7,
-  mathmlBuilder: mathmlBuilder$6
+  htmlBuilder: htmlBuilder$6,
+  mathmlBuilder: mathmlBuilder$5
 });
 defineEnvironment({
   type: "array",
@@ -11158,8 +11369,8 @@ defineEnvironment({
     return parseArray(context.parser, res, "display");
   },
 
-  htmlBuilder: htmlBuilder$7,
-  mathmlBuilder: mathmlBuilder$6
+  htmlBuilder: htmlBuilder$6,
+  mathmlBuilder: mathmlBuilder$5
 });
 defineEnvironment({
   type: "array",
@@ -11173,8 +11384,8 @@ defineEnvironment({
     return parseCD(context.parser);
   },
 
-  htmlBuilder: htmlBuilder$7,
-  mathmlBuilder: mathmlBuilder$6
+  htmlBuilder: htmlBuilder$6,
+  mathmlBuilder: mathmlBuilder$5
 });
 defineMacro("\\nonumber", "\\gdef\\@eqnsw{0}");
 defineMacro("\\notag", "\\nonumber"); // Catch \hline outside array environment
@@ -11265,176 +11476,6 @@ defineFunction({
 
 });
 
-var makeSpan = buildCommon.makeSpan;
-
-function htmlBuilder$6(group, options) {
-  var elements = buildExpression$1(group.body, options, true);
-  return makeSpan([group.mclass], elements, options);
-}
-
-function mathmlBuilder$5(group, options) {
-  var node;
-  var inner = buildExpression(group.body, options);
-
-  if (group.mclass === "minner") {
-    node = new mathMLTree.MathNode("mpadded", inner);
-  } else if (group.mclass === "mord") {
-    if (group.isCharacterBox) {
-      node = inner[0];
-      node.type = "mi";
-    } else {
-      node = new mathMLTree.MathNode("mi", inner);
-    }
-  } else {
-    if (group.isCharacterBox) {
-      node = inner[0];
-      node.type = "mo";
-    } else {
-      node = new mathMLTree.MathNode("mo", inner);
-    } // Set spacing based on what is the most likely adjacent atom type.
-    // See TeXbook p170.
-
-
-    if (group.mclass === "mbin") {
-      node.attributes.lspace = "0.22em"; // medium space
-
-      node.attributes.rspace = "0.22em";
-    } else if (group.mclass === "mpunct") {
-      node.attributes.lspace = "0em";
-      node.attributes.rspace = "0.17em"; // thinspace
-    } else if (group.mclass === "mopen" || group.mclass === "mclose") {
-      node.attributes.lspace = "0em";
-      node.attributes.rspace = "0em";
-    } else if (group.mclass === "minner") {
-      node.attributes.lspace = "0.0556em"; // 1 mu is the most likely option
-
-      node.attributes.width = "+0.1111em";
-    } // MathML <mo> default space is 5/18 em, so <mrel> needs no action.
-    // Ref: https://developer.mozilla.org/en-US/docs/Web/MathML/Element/mo
-
-  }
-
-  return node;
-} // Math class commands except \mathop
-
-
-defineFunction({
-  type: "mclass",
-  names: ["\\mathord", "\\mathbin", "\\mathrel", "\\mathopen", "\\mathclose", "\\mathpunct", "\\mathinner"],
-  props: {
-    numArgs: 1,
-    primitive: true
-  },
-
-  handler(_ref, args) {
-    var {
-      parser,
-      funcName
-    } = _ref;
-    var body = args[0];
-    return {
-      type: "mclass",
-      mode: parser.mode,
-      mclass: "m" + funcName.substr(5),
-      // TODO(kevinb): don't prefix with 'm'
-      body: ordargument(body),
-      isCharacterBox: utils.isCharacterBox(body)
-    };
-  },
-
-  htmlBuilder: htmlBuilder$6,
-  mathmlBuilder: mathmlBuilder$5
-});
-var binrelClass = arg => {
-  // \binrel@ spacing varies with (bin|rel|ord) of the atom in the argument.
-  // (by rendering separately and with {}s before and after, and measuring
-  // the change in spacing).  We'll do roughly the same by detecting the
-  // atom type directly.
-  var atom = arg.type === "ordgroup" && arg.body.length ? arg.body[0] : arg;
-
-  if (atom.type === "atom" && (atom.family === "bin" || atom.family === "rel")) {
-    return "m" + atom.family;
-  } else {
-    return "mord";
-  }
-}; // \@binrel{x}{y} renders like y but as mbin/mrel/mord if x is mbin/mrel/mord.
-// This is equivalent to \binrel@{x}\binrel@@{y} in AMSTeX.
-
-defineFunction({
-  type: "mclass",
-  names: ["\\@binrel"],
-  props: {
-    numArgs: 2
-  },
-
-  handler(_ref2, args) {
-    var {
-      parser
-    } = _ref2;
-    return {
-      type: "mclass",
-      mode: parser.mode,
-      mclass: binrelClass(args[0]),
-      body: ordargument(args[1]),
-      isCharacterBox: utils.isCharacterBox(args[1])
-    };
-  }
-
-}); // Build a relation or stacked op by placing one symbol on top of another
-
-defineFunction({
-  type: "mclass",
-  names: ["\\stackrel", "\\overset", "\\underset"],
-  props: {
-    numArgs: 2
-  },
-
-  handler(_ref3, args) {
-    var {
-      parser,
-      funcName
-    } = _ref3;
-    var baseArg = args[1];
-    var shiftedArg = args[0];
-    var mclass;
-
-    if (funcName !== "\\stackrel") {
-      // LaTeX applies \binrel spacing to \overset and \underset.
-      mclass = binrelClass(baseArg);
-    } else {
-      mclass = "mrel"; // for \stackrel
-    }
-
-    var baseOp = {
-      type: "op",
-      mode: baseArg.mode,
-      limits: true,
-      alwaysHandleSupSub: true,
-      parentIsSupSub: false,
-      symbol: false,
-      suppressBaseShift: funcName !== "\\stackrel",
-      body: ordargument(baseArg)
-    };
-    var supsub = {
-      type: "supsub",
-      mode: shiftedArg.mode,
-      base: baseOp,
-      sup: funcName === "\\underset" ? null : shiftedArg,
-      sub: funcName === "\\underset" ? shiftedArg : null
-    };
-    return {
-      type: "mclass",
-      mode: parser.mode,
-      mclass,
-      body: [supsub],
-      isCharacterBox: utils.isCharacterBox(supsub)
-    };
-  },
-
-  htmlBuilder: htmlBuilder$6,
-  mathmlBuilder: mathmlBuilder$5
-});
-
 // TODO(kevinb): implement \\sl and \\sc
 
 var htmlBuilder$5 = (group, options) => {
@@ -13032,7 +13073,7 @@ var htmlBuilder$2 = (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";
     }
 
@@ -15493,7 +15534,7 @@ defineMacro("\\dots", function (context) {
 
   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)) {
@@ -15630,12 +15671,7 @@ defineMacro("\\tag@literal", context => {
 defineMacro("\\bmod", "\\mathchoice{\\mskip1mu}{\\mskip1mu}{\\mskip5mu}{\\mskip5mu}" + "\\mathbin{\\rm mod}" + "\\mathchoice{\\mskip1mu}{\\mskip1mu}{\\mskip5mu}{\\mskip5mu}");
 defineMacro("\\pod", "\\allowbreak" + "\\mathchoice{\\mkern18mu}{\\mkern8mu}{\\mkern8mu}{\\mkern8mu}(#1)");
 defineMacro("\\pmod", "\\pod{{\\rm mod}\\mkern6mu#1}");
-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}}"); //////////////////////////////////////////////////////////////////////
+defineMacro("\\mod", "\\allowbreak" + "\\mathchoice{\\mkern18mu}{\\mkern12mu}{\\mkern12mu}{\\mkern12mu}" + "{\\rm mod}\\,\\,#1"); //////////////////////////////////////////////////////////////////////
 // LaTeX source2e
 // \expandafter\let\expandafter\@normalcr
 //     \csname\expandafter\@gobble\string\\ \endcsname
@@ -18008,7 +18044,7 @@ class Parser {
         this.settings.reportNonstrict("unicodeTextInMathMode", "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
 
 
@@ -18254,7 +18290,7 @@ var katex = {
   /**
    * Current KaTeX version
    */
-  version: "0.16.1",
+  version: "0.16.2",
 
   /**
    * Renders the given LaTeX into an HTML+MathML combination, and adds

package/package.json

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