katex 0.16.47 → 0.18.0

package/src/functions/hbox.ts

@@ -13,12 +13,11 @@ import * as mml from "../buildMathML";
 defineFunction({
     type: "hbox",
     names: ["\\hbox"],
-    props: {
-        numArgs: 1,
-        argTypes: ["text"],
-        allowedInText: true,
-        primitive: true,
-    },
+    numArgs: 1,
+    argTypes: ["text"],
+    allowedInText: true,
+    primitive: true,
+
     handler({parser}, args) {
         return {
             type: "hbox",
@@ -26,6 +25,7 @@ defineFunction({
             body: ordargument(args[0]),
         };
     },
+
     htmlBuilder(group, options) {
         const elements = html.buildExpression(group.body, options.withFont(''), false);
         return makeFragment(elements);

package/src/functions/horizBrace.ts

@@ -9,7 +9,7 @@ import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
 
 import type {HtmlBuilderSupSub, MathMLBuilder} from "../defineFunction";
-import type {ParseNode} from "../parseNode";
+import type {ParseNode} from "../types/nodes";
 
 // NOTE: Unlike most `htmlBuilder`s, this one handles not only "horizBrace", but
 // also "supsub" since an over/underbrace can affect super/subscripting.
@@ -117,9 +117,8 @@ const mathmlBuilder: MathMLBuilder<"horizBrace"> = (group, options) => {
 defineFunction({
     type: "horizBrace",
     names: ["\\overbrace", "\\underbrace", "\\overbracket", "\\underbracket"],
-    props: {
-        numArgs: 1,
-    },
+    numArgs: 1,
+
     handler({parser, funcName}, args) {
         return {
             type: "horizBrace",
@@ -129,6 +128,7 @@ defineFunction({
             base: args[0],
         };
     },
+
     htmlBuilder,
     mathmlBuilder,
 });

package/src/functions/href.ts

@@ -5,16 +5,15 @@ import {MathNode} from "../mathMLTree";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
-import type {ParseNode} from "../parseNode";
+import type {ParseNode} from "../types/nodes";
 
 defineFunction({
     type: "href",
     names: ["\\href"],
-    props: {
-        numArgs: 2,
-        argTypes: ["url", "original"],
-        allowedInText: true,
-    },
+    numArgs: 2,
+    argTypes: ["url", "original"],
+    allowedInText: true,
+
     handler: ({parser}, args) => {
         const body = args[1];
         const href = assertNodeType(args[0], "url").url;
@@ -33,6 +32,7 @@ defineFunction({
             body: ordargument(body),
         };
     },
+
     htmlBuilder: (group, options) => {
         const elements = html.buildExpression(group.body, options, false);
         return makeAnchor(group.href, [], elements, options);
@@ -50,11 +50,10 @@ defineFunction({
 defineFunction({
     type: "href",
     names: ["\\url"],
-    props: {
-        numArgs: 1,
-        argTypes: ["url"],
-        allowedInText: true,
-    },
+    numArgs: 1,
+    argTypes: ["url"],
+    allowedInText: true,
+
     handler: ({parser}, args) => {
         const href = assertNodeType(args[0], "url").url;
 

package/src/functions/html.ts

@@ -10,11 +10,10 @@ import type {AnyTrustContext} from "../Settings";
 defineFunction({
     type: "html",
     names: ["\\htmlClass", "\\htmlId", "\\htmlStyle", "\\htmlData"],
-    props: {
-        numArgs: 2,
-        argTypes: ["raw", "original"],
-        allowedInText: true,
-    },
+    numArgs: 2,
+    argTypes: ["raw", "original"],
+    allowedInText: true,
+
     handler: ({parser, funcName, token}, args) => {
         const value = assertNodeType(args[0], "raw").string;
         const body = args[1];
@@ -83,6 +82,7 @@ defineFunction({
             body: ordargument(body),
         };
     },
+
     htmlBuilder: (group, options) => {
         const elements = html.buildExpression(group.body, options, false);
 
@@ -92,9 +92,9 @@ defineFunction({
         }
 
         const span = makeSpan(classes, elements, options);
-        for (const attr in group.attributes) {
-            if (attr !== "class" && group.attributes.hasOwnProperty(attr)) {
-                span.setAttribute(attr, group.attributes[attr]);
+        for (const [attr, value] of Object.entries(group.attributes)) {
+            if (attr !== "class") {
+                span.setAttribute(attr, value);
             }
         }
         return span;

package/src/functions/htmlmathml.ts

@@ -7,11 +7,10 @@ import * as mml from "../buildMathML";
 defineFunction({
     type: "htmlmathml",
     names: ["\\html@mathml"],
-    props: {
-        numArgs: 2,
-        allowedInArgument: true,
-        allowedInText: true,
-    },
+    numArgs: 2,
+    allowedInArgument: true,
+    allowedInText: true,
+
     handler: ({parser}, args) => {
         return {
             type: "htmlmathml",
@@ -20,6 +19,7 @@ defineFunction({
             mathml: ordargument(args[1]),
         };
     },
+
     htmlBuilder: (group, options) => {
         const elements = html.buildExpression(
             group.html,

package/src/functions/includegraphics.ts

@@ -1,11 +1,11 @@
 import defineFunction from "../defineFunction";
-import type {Measurement} from "../units";
 import {calculateSize, validUnit, makeEm} from "../units";
 import ParseError from "../ParseError";
 import {Img} from "../domTree";
 import {MathNode} from "../mathMLTree";
 import {assertNodeType} from "../parseNode";
 import type {CssStyle} from "../domTree";
+import type {Measurement} from "../types";
 
 const sizeData = function(str: string): Measurement {
     if (/^[-+]? *(\d+(\.\d*)?|\.\d+)$/.test(str)) {
@@ -33,12 +33,11 @@ const sizeData = function(str: string): Measurement {
 defineFunction({
     type: "includegraphics",
     names: ["\\includegraphics"],
-    props: {
-        numArgs: 1,
-        numOptionalArgs: 1,
-        argTypes: ["raw", "url"],
-        allowedInText: false,
-    },
+    numArgs: 1,
+    numOptionalArgs: 1,
+    argTypes: ["raw", "url"],
+    allowedInText: false,
+
     handler: ({parser}, args, optArgs) => {
         let width = {number: 0, unit: "em"};
         let height = {number: 0.9, unit: "em"};    // sorta character sized.
@@ -101,6 +100,7 @@ defineFunction({
             src: src,
         };
     },
+
     htmlBuilder: (group, options) => {
         const height = calculateSize(group.height, options);
         let depth = 0;

package/src/functions/kern.ts

@@ -11,12 +11,11 @@ import {assertNodeType} from "../parseNode";
 defineFunction({
     type: "kern",
     names: ["\\kern", "\\mkern", "\\hskip", "\\mskip"],
-    props: {
-        numArgs: 1,
-        argTypes: ["size"],
-        primitive: true,
-        allowedInText: true,
-    },
+    numArgs: 1,
+    argTypes: ["size"],
+    primitive: true,
+    allowedInText: true,
+
     handler({parser, funcName}, args) {
         const size = assertNodeType(args[0], "size");
         if (parser.settings.strict) {
@@ -45,6 +44,7 @@ defineFunction({
             dimension: size.value,
         };
     },
+
     htmlBuilder(group, options) {
         return makeGlue(group.dimension, options);
     },

package/src/functions/lap.ts

@@ -10,10 +10,9 @@ import * as mml from "../buildMathML";
 defineFunction({
     type: "lap",
     names: ["\\mathllap", "\\mathrlap", "\\mathclap"],
-    props: {
-        numArgs: 1,
-        allowedInText: true,
-    },
+    numArgs: 1,
+    allowedInText: true,
+
     handler: ({parser, funcName}, args) => {
         const body = args[0];
         return {
@@ -23,6 +22,7 @@ defineFunction({
             body,
         };
     },
+
     htmlBuilder: (group, options) => {
         // mathllap, mathrlap, mathclap
         let inner;
@@ -30,13 +30,13 @@ defineFunction({
             // ref: https://www.math.lsu.edu/~aperlis/publications/mathclap/
             inner = makeSpan(
                 [], [html.buildGroup(group.body, options)]);
-            // wrap, since CSS will center a .clap > .inner > span
-            inner = makeSpan(["inner"], [inner], options);
+            // wrap, since CSS will center a .clap > .katex-inner > span
+            inner = makeSpan(["katex-inner"], [inner], options);
         } else {
             inner = makeSpan(
-                ["inner"], [html.buildGroup(group.body, options)]);
+                ["katex-inner"], [html.buildGroup(group.body, options)]);
         }
-        const fix = makeSpan(["fix"], []);
+        const fix = makeSpan(["katex-fix"], []);
         let node = makeSpan(
             [group.alignment], [inner, fix], options);
 
@@ -45,7 +45,7 @@ defineFunction({
         // Next, use a strut to set the height of the HTML bounding box.
         // Otherwise, a tall argument may be misplaced.
         // This code resolved issue #1153
-        const strut = makeSpan(["strut"]);
+        const strut = makeSpan(["katex-strut"]);
         strut.style.height = makeEm(node.height + node.depth);
         if (node.depth) {
             strut.style.verticalAlign = makeEm(-node.depth);
@@ -54,8 +54,8 @@ defineFunction({
 
         // Next, prevent vertical misplacement when next to something tall.
         // This code resolves issue #1234
-        node = makeSpan(["thinbox"], [node], options);
-        return makeSpan(["mord", "vbox"], [node], options);
+        node = makeSpan(["katex-thinbox"], [node], options);
+        return makeSpan(["mord", "katex-vbox"], [node], options);
     },
     mathmlBuilder: (group, options) => {
         // mathllap, mathrlap, mathclap

package/src/functions/math.ts

@@ -5,11 +5,10 @@ import ParseError from "../ParseError";
 defineFunction({
     type: "styling",
     names: ["\\(", "$"],
-    props: {
-        numArgs: 0,
-        allowedInText: true,
-        allowedInMath: false,
-    },
+    numArgs: 0,
+    allowedInText: true,
+    allowedInMath: false,
+
     handler({funcName, parser}, args) {
         const outerMode = parser.mode;
         parser.switchMode("math");
@@ -31,11 +30,10 @@ defineFunction({
 defineFunction({
     type: "text", // Doesn't matter what this is.
     names: ["\\)", "\\]"],
-    props: {
-        numArgs: 0,
-        allowedInText: true,
-        allowedInMath: false,
-    },
+    numArgs: 0,
+    allowedInText: true,
+    allowedInMath: false,
+
     handler(context, args) {
         throw new ParseError(`Mismatched ${context.funcName}`);
     },

package/src/functions/mathchoice.ts

@@ -6,7 +6,7 @@ import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
 
 import type Options from "../Options";
-import type {ParseNode} from "../parseNode";
+import type {ParseNode} from "../types/nodes";
 
 const chooseMathStyle = (group: ParseNode<"mathchoice">, options: Options) => {
     switch (options.style.size) {
@@ -21,10 +21,9 @@ const chooseMathStyle = (group: ParseNode<"mathchoice">, options: Options) => {
 defineFunction({
     type: "mathchoice",
     names: ["\\mathchoice"],
-    props: {
-        numArgs: 4,
-        primitive: true,
-    },
+    numArgs: 4,
+    primitive: true,
+
     handler: ({parser}, args) => {
         return {
             type: "mathchoice",
@@ -35,6 +34,7 @@ defineFunction({
             scriptscript: ordargument(args[3]),
         };
     },
+
     htmlBuilder: (group, options) => {
         const body = chooseMathStyle(group, options);
         const elements = html.buildExpression(

package/src/functions/mclass.ts

@@ -2,13 +2,13 @@ import defineFunction, {ordargument} from "../defineFunction";
 import {makeSpan} from "../buildCommon";
 import {isCharacterBox} from "../utils";
 import {MathNode} from "../mathMLTree";
-import type {AnyParseNode} from "../parseNode";
+import type {AnyParseNode, ParseNode} from "../types/nodes";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
 
 import type Options from "../Options";
-import type {ParseNode} from "../parseNode";
+import type {MathClass, Slice5} from "../types";
 
 function htmlBuilder(group: ParseNode<"mclass">, options: Options) {
     const elements = html.buildExpression(group.body, options, true);
@@ -47,9 +47,6 @@ function mathmlBuilder(group: ParseNode<"mclass">, options: Options) {
         } 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
@@ -64,32 +61,31 @@ defineFunction({
         "\\mathord", "\\mathbin", "\\mathrel", "\\mathopen",
         "\\mathclose", "\\mathpunct", "\\mathinner",
     ],
-    props: {
-        numArgs: 1,
-        primitive: true,
-    },
+    numArgs: 1,
+    primitive: true,
     handler({parser, funcName}, args) {
         const body = args[0];
         return {
             type: "mclass",
             mode: parser.mode,
-            mclass: "m" + funcName.slice(5), // TODO(kevinb): don't prefix with 'm'
+            mclass: `m${funcName.slice(5) as Slice5<typeof funcName>}`,
             body: ordargument(body),
             isCharacterBox: isCharacterBox(body),
         };
     },
+
     htmlBuilder,
     mathmlBuilder,
 });
 
-export const binrelClass = (arg: AnyParseNode): string => {
+export const binrelClass = (arg: AnyParseNode): MathClass => {
     // \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.
     const 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;
+        return `m${atom.family}`;
     } else {
         return "mord";
     }
@@ -100,9 +96,8 @@ export const binrelClass = (arg: AnyParseNode): string => {
 defineFunction({
     type: "mclass",
     names: ["\\@binrel"],
-    props: {
-        numArgs: 2,
-    },
+    numArgs: 2,
+
     handler({parser}, args) {
         return {
             type: "mclass",
@@ -118,14 +113,13 @@ defineFunction({
 defineFunction({
     type: "mclass",
     names: ["\\stackrel", "\\overset", "\\underset"],
-    props: {
-        numArgs: 2,
-    },
+    numArgs: 2,
+
     handler({parser, funcName}, args) {
         const baseArg = args[1];
         const shiftedArg = args[0];
 
-        let mclass;
+        let mclass: MathClass;
         if (funcName !== "\\stackrel") {
             // LaTeX applies \binrel spacing to \overset and \underset.
             mclass = binrelClass(baseArg);
@@ -144,13 +138,9 @@ defineFunction({
             body: ordargument(baseArg),
         };
 
-        const supsub: ParseNode<"supsub"> = {
-            type: "supsub",
-            mode: shiftedArg.mode,
-            base: baseOp,
-            sup: funcName === "\\underset" ? null : shiftedArg,
-            sub: funcName === "\\underset" ? shiftedArg : null,
-        };
+        const supsub: ParseNode<"supsub"> = funcName === "\\underset"
+            ? {type: "supsub", mode: shiftedArg.mode, base: baseOp, sub: shiftedArg}
+            : {type: "supsub", mode: shiftedArg.mode, base: baseOp, sup: shiftedArg};
 
         return {
             type: "mclass",
@@ -160,6 +150,4 @@ defineFunction({
             isCharacterBox: isCharacterBox(supsub),
         };
     },
-    htmlBuilder,
-    mathmlBuilder,
 });

package/src/functions/op.ts

@@ -12,7 +12,7 @@ import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
 
 import type {HtmlBuilderSupSub, MathMLBuilder} from "../defineFunction";
-import type {ParseNode} from "../parseNode";
+import type {ParseNode} from "../types/nodes";
 
 // Most operators have a large successor symbol, but these don't.
 const noSuccessor = new Set([
@@ -200,11 +200,10 @@ defineFunction({
         "\u2210", "\u2211", "\u22c0", "\u22c1", "\u22c2", "\u22c3", "\u2a00",
         "\u2a01", "\u2a02", "\u2a04", "\u2a06",
     ],
-    props: {
-        numArgs: 0,
-    },
+    numArgs: 0,
+
     handler: ({parser, funcName}, args) => {
-        let fName = funcName;
+        let fName: string = funcName;
         if (fName.length === 1) {
             fName = singleCharBigOps[fName];
         }
@@ -217,19 +216,17 @@ defineFunction({
             name: fName,
         };
     },
+
     htmlBuilder,
     mathmlBuilder,
 });
 
-// Note: calling defineFunction with a type that's already been defined only
-// works because the same htmlBuilder and mathmlBuilder are being used.
 defineFunction({
     type: "op",
     names: ["\\mathop"],
-    props: {
-        numArgs: 1,
-        primitive: true,
-    },
+    numArgs: 1,
+    primitive: true,
+
     handler: ({parser}, args) => {
         const body = args[0];
         return {
@@ -241,8 +238,6 @@ defineFunction({
             body: ordargument(body),
         };
     },
-    htmlBuilder,
-    mathmlBuilder,
 });
 
 // There are 2 flags for operators; whether they produce limits in
@@ -267,9 +262,8 @@ defineFunction({
         "\\hom", "\\ker", "\\lg", "\\ln", "\\log", "\\sec", "\\sin",
         "\\sinh", "\\sh", "\\tan", "\\tanh", "\\tg", "\\th",
     ],
-    props: {
-        numArgs: 0,
-    },
+    numArgs: 0,
+
     handler({parser, funcName}) {
         return {
             type: "op",
@@ -280,8 +274,6 @@ defineFunction({
             name: funcName,
         };
     },
-    htmlBuilder,
-    mathmlBuilder,
 });
 
 // Limits, not symbols
@@ -290,9 +282,8 @@ defineFunction({
     names: [
         "\\det", "\\gcd", "\\inf", "\\lim", "\\max", "\\min", "\\Pr", "\\sup",
     ],
-    props: {
-        numArgs: 0,
-    },
+    numArgs: 0,
+
     handler({parser, funcName}) {
         return {
             type: "op",
@@ -303,8 +294,6 @@ defineFunction({
             name: funcName,
         };
     },
-    htmlBuilder,
-    mathmlBuilder,
 });
 
 // No limits, symbols
@@ -314,12 +303,11 @@ defineFunction({
         "\\int", "\\iint", "\\iiint", "\\oint", "\\oiint", "\\oiiint",
         "\u222b", "\u222c", "\u222d", "\u222e", "\u222f", "\u2230",
     ],
-    props: {
-        numArgs: 0,
-        allowedInArgument: true,
-    },
+    numArgs: 0,
+    allowedInArgument: true,
+
     handler({parser, funcName}) {
-        let fName = funcName;
+        let fName: string = funcName;
         if (fName.length === 1) {
             fName = singleCharIntegrals[fName];
         }
@@ -332,6 +320,4 @@ defineFunction({
             name: fName,
         };
     },
-    htmlBuilder,
-    mathmlBuilder,
 });

package/src/functions/operatorname.ts

@@ -10,7 +10,7 @@ import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
 
 import type {HtmlBuilderSupSub, MathMLBuilder} from "../defineFunction";
-import type {AnyParseNode, ParseNode} from "../parseNode";
+import type {AnyParseNode, ParseNode} from "../types/nodes";
 
 // NOTE: Unlike most `htmlBuilder`s, this one handles not only
 // "operatorname", but also  "supsub" since \operatorname* can
@@ -139,9 +139,8 @@ const mathmlBuilder: MathMLBuilder<"operatorname"> = (group, options) => {
 defineFunction({
     type: "operatorname",
     names: ["\\operatorname@", "\\operatornamewithlimits"],
-    props: {
-        numArgs: 1,
-    },
+    numArgs: 1,
+
     handler: ({parser, funcName}, args) => {
         const body = args[0];
         return {
@@ -153,6 +152,7 @@ defineFunction({
             parentIsSupSub: false,
         };
     },
+
     htmlBuilder,
     mathmlBuilder,
 });

package/src/functions/overline.ts

@@ -8,9 +8,8 @@ import * as mml from "../buildMathML";
 defineFunction({
     type: "overline",
     names: ["\\overline"],
-    props: {
-        numArgs: 1,
-    },
+    numArgs: 1,
+
     handler({parser}, args) {
         const body = args[0];
         return {
@@ -19,6 +18,7 @@ defineFunction({
             body,
         };
     },
+
     htmlBuilder(group, options) {
         // Overlines are handled in the TeXbook pg 443, Rule 9.
 
@@ -41,7 +41,7 @@ defineFunction({
             ],
         }, options);
 
-        return makeSpan(["mord", "overline"], [vlist], options);
+        return makeSpan(["mord", "katex-overline"], [vlist], options);
     },
     mathmlBuilder(group, options) {
         const operator = new MathNode(