katex 0.16.47 → 0.17.0

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.
 

package/src/functions/phantom.ts

@@ -9,10 +9,9 @@ import * as mml from "../buildMathML";
 defineFunction({
     type: "phantom",
     names: ["\\phantom"],
-    props: {
-        numArgs: 1,
-        allowedInText: true,
-    },
+    numArgs: 1,
+    allowedInText: true,
+
     handler: ({parser}, args) => {
         const body = args[0];
         return {
@@ -21,6 +20,7 @@ defineFunction({
             body: ordargument(body),
         };
     },
+
     htmlBuilder: (group, options) => {
         const elements = html.buildExpression(
             group.body,
@@ -43,10 +43,9 @@ defineMacro("\\hphantom", "\\smash{\\phantom{#1}}");
 defineFunction({
     type: "vphantom",
     names: ["\\vphantom"],
-    props: {
-        numArgs: 1,
-        allowedInText: true,
-    },
+    numArgs: 1,
+    allowedInText: true,
+
     handler: ({parser}, args) => {
         const body = args[0];
         return {
@@ -55,6 +54,7 @@ defineFunction({
             body,
         };
     },
+
     htmlBuilder: (group, options) => {
         const inner = makeSpan(
             ["inner"],

package/src/functions/pmb.ts

@@ -5,7 +5,7 @@ import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
 import {binrelClass} from "./mclass";
 
-import type {ParseNode} from "../parseNode";
+import type {ParseNode} from "../types/nodes";
 
 // \pmb is a simulation of bold font.
 // The version of \pmb in ambsy.sty works by typesetting three copies
@@ -15,10 +15,9 @@ import type {ParseNode} from "../parseNode";
 defineFunction({
     type: "pmb",
     names: ["\\pmb"],
-    props: {
-        numArgs: 1,
-        allowedInText: true,
-    },
+    numArgs: 1,
+    allowedInText: true,
+
     handler({parser}, args) {
         return {
             type: "pmb",
@@ -27,6 +26,7 @@ defineFunction({
             body: ordargument(args[0]),
         };
     },
+
     htmlBuilder(group: ParseNode<"pmb">, options) {
         const elements = html.buildExpression(group.body, options, true);
         const node = makeSpan([group.mclass], elements, options);

package/src/functions/raisebox.ts

@@ -11,11 +11,10 @@ import * as mml from "../buildMathML";
 defineFunction({
     type: "raisebox",
     names: ["\\raisebox"],
-    props: {
-        numArgs: 2,
-        argTypes: ["size", "hbox"],
-        allowedInText: true,
-    },
+    numArgs: 2,
+    argTypes: ["size", "hbox"],
+    allowedInText: true,
+
     handler({parser}, args) {
         const amount = assertNodeType(args[0], "size").value;
         const body = args[1];
@@ -26,6 +25,7 @@ defineFunction({
             body,
         };
     },
+
     htmlBuilder(group, options) {
         const body = html.buildGroup(group.body, options);
         const dy = calculateSize(group.dy, options);

package/src/functions/relax.ts

@@ -3,11 +3,10 @@ import defineFunction from "../defineFunction";
 defineFunction({
     type: "internal",
     names: ["\\relax"],
-    props: {
-        numArgs: 0,
-        allowedInText: true,
-        allowedInArgument: true,
-    },
+    numArgs: 0,
+    allowedInText: true,
+    allowedInArgument: true,
+
     handler({parser}) {
         return {
             type: "internal",

package/src/functions/rule.ts

@@ -7,13 +7,12 @@ import {calculateSize, makeEm} from "../units";
 defineFunction({
     type: "rule",
     names: ["\\rule"],
-    props: {
-        numArgs: 2,
-        numOptionalArgs: 1,
-        allowedInText: true,
-        allowedInMath: true,
-        argTypes: ["size", "size", "size"],
-    },
+    numArgs: 2,
+    numOptionalArgs: 1,
+    allowedInText: true,
+    allowedInMath: true,
+    argTypes: ["size", "size", "size"],
+
     handler({parser}, args, optArgs) {
         const shift = optArgs[0];
         const width = assertNodeType(args[0], "size");
@@ -26,6 +25,7 @@ defineFunction({
             height: height.value,
         };
     },
+
     htmlBuilder(group, options) {
         // Make an empty span for the rule
         const rule = makeSpan(["mord", "rule"], [], options);

package/src/functions/sizing.ts

@@ -7,7 +7,7 @@ import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
 
 import type Options from "../Options";
-import type {AnyParseNode} from "../parseNode";
+import type {AnyParseNode} from "../types/nodes";
 import type {HtmlBuilder} from "../defineFunction";
 import type {documentFragment as HtmlDocumentFragment} from "../domTree";
 
@@ -43,7 +43,7 @@ export function sizingGroup(
 const sizeFuncs = [
     "\\tiny", "\\sixptsize", "\\scriptsize", "\\footnotesize", "\\small",
     "\\normalsize", "\\large", "\\Large", "\\LARGE", "\\huge", "\\Huge",
-];
+] as const;
 
 export const htmlBuilder: HtmlBuilder<"sizing"> = (group, options) => {
     // Handle sizing operators like \Huge. Real TeX doesn't actually allow
@@ -56,10 +56,9 @@ export const htmlBuilder: HtmlBuilder<"sizing"> = (group, options) => {
 defineFunction({
     type: "sizing",
     names: sizeFuncs,
-    props: {
-        numArgs: 0,
-        allowedInText: true,
-    },
+    numArgs: 0,
+    allowedInText: true,
+
     handler: ({breakOnTokenText, funcName, parser}, args) => {
         const body = parser.parseExpression(false, breakOnTokenText);
 
@@ -71,6 +70,7 @@ defineFunction({
             body,
         };
     },
+
     htmlBuilder,
     mathmlBuilder: (group, options) => {
         const newOptions = options.havingSize(group.size);

package/src/functions/smash.ts

@@ -10,11 +10,10 @@ import * as mml from "../buildMathML";
 defineFunction({
     type: "smash",
     names: ["\\smash"],
-    props: {
-        numArgs: 1,
-        numOptionalArgs: 1,
-        allowedInText: true,
-    },
+    numArgs: 1,
+    numOptionalArgs: 1,
+    allowedInText: true,
+
     handler: ({parser}, args, optArgs) => {
         let smashHeight = false;
         let smashDepth = false;
@@ -51,6 +50,7 @@ defineFunction({
             smashDepth,
         };
     },
+
     htmlBuilder: (group, options) => {
         const node = makeSpan(
             [], [html.buildGroup(group.body, options)]);

package/src/functions/sqrt.ts

@@ -11,10 +11,9 @@ import * as mml from "../buildMathML";
 defineFunction({
     type: "sqrt",
     names: ["\\sqrt"],
-    props: {
-        numArgs: 1,
-        numOptionalArgs: 1,
-    },
+    numArgs: 1,
+    numOptionalArgs: 1,
+
     handler({parser}, args, optArgs) {
         const index = optArgs[0];
         const body = args[0];
@@ -25,6 +24,7 @@ defineFunction({
             index,
         };
     },
+
     htmlBuilder(group, options) {
         // Square roots are handled in the TeXbook pg. 443, Rule 11.
 

package/src/functions/styling.ts

@@ -23,11 +23,10 @@ defineFunction({
         "\\displaystyle", "\\textstyle", "\\scriptstyle",
         "\\scriptscriptstyle",
     ],
-    props: {
-        numArgs: 0,
-        allowedInText: true,
-        primitive: true,
-    },
+    numArgs: 0,
+    allowedInText: true,
+    primitive: true,
+
     handler({breakOnTokenText, funcName, parser}, args) {
         // parse out the implicit body
         const body = parser.parseExpression(true, breakOnTokenText);
@@ -47,6 +46,7 @@ defineFunction({
             body,
         };
     },
+
     htmlBuilder(group, options) {
         // Style changes are handled in the TeXbook on pg. 442, Rule 3.
         const newStyle = styleMap[group.style];

package/src/functions/supsub.ts

@@ -14,7 +14,7 @@ import * as op from "./op";
 import * as operatorname from "./operatorname";
 
 import type Options from "../Options";
-import type {ParseNode} from "../parseNode";
+import type {ParseNode} from "../types/nodes";
 import type {HtmlBuilder} from "../defineFunction";
 import type {MathNodeType} from "../mathMLTree";
 

package/src/functions/symbolsOrd.ts

@@ -4,7 +4,7 @@ import {MathNode} from "../mathMLTree";
 
 import * as mml from "../buildMathML";
 
-import type {ParseNode} from "../parseNode";
+import type {ParseNode} from "../types/nodes";
 
 // "mathord" and "textord" ParseNodes created in Parser.js from symbol Groups in
 // src/symbols.js.
@@ -18,7 +18,7 @@ const defaultVariant: Record<string, string> = {
 defineFunctionBuilders({
     type: "mathord",
     htmlBuilder(group, options) {
-        return makeOrd(group, options, "mathord");
+        return makeOrd(group, options);
     },
     mathmlBuilder(group: ParseNode<"mathord">, options) {
         const node = new MathNode(
@@ -36,7 +36,7 @@ defineFunctionBuilders({
 defineFunctionBuilders({
     type: "textord",
     htmlBuilder(group, options) {
-        return makeOrd(group, options, "textord");
+        return makeOrd(group, options);
     },
     mathmlBuilder(group: ParseNode<"textord">, options) {
         const text = mml.makeText(group.text, group.mode, options);

package/src/functions/symbolsSpacing.ts

@@ -37,7 +37,7 @@ defineFunctionBuilders({
             // things has an entry in the symbols table, so these will be turned
             // into appropriate outputs.
             if (group.mode === "text") {
-                const ord = makeOrd(group, options, "textord");
+                const ord = makeOrd(group, options);
                 ord.classes.push(className);
                 return ord;
             } else {