katex 0.16.47 → 0.18.0

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,11 +54,12 @@ defineFunction({
             body,
         };
     },
+
     htmlBuilder: (group, options) => {
         const inner = makeSpan(
-            ["inner"],
+            ["katex-inner"],
             [html.buildGroup(group.body, options.withPhantom())]);
-        const fix = makeSpan(["fix"], []);
+        const fix = makeSpan(["katex-fix"], []);
         return makeSpan(
             ["mord", "rlap"], [inner, fix], options);
     },

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,9 +25,10 @@ defineFunction({
             height: height.value,
         };
     },
+
     htmlBuilder(group, options) {
         // Make an empty span for the rule
-        const rule = makeSpan(["mord", "rule"], [], options);
+        const rule = makeSpan(["mord", "katex-rule"], [], options);
 
         // Calculate the shift, width, and height of the rule, and account for units
         const width = calculateSize(group.width, 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";
 
@@ -22,7 +22,7 @@ export function sizingGroup(
     // Add size-resetting classes to the inner list and set maxFontSize
     // manually. Handle nested size changes.
     for (let i = 0; i < inner.length; i++) {
-        const pos = inner[i].classes.indexOf("sizing");
+        const pos = inner[i].classes.indexOf("katex-sizing");
         if (pos < 0) {
             Array.prototype.push.apply(inner[i].classes,
                 options.sizingClasses(baseOptions));
@@ -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)]);
@@ -69,7 +69,7 @@ defineFunction({
 
         if (group.smashHeight && group.smashDepth) {
             // Symmetric \smash can stay in inline layout.
-            return makeSpan(["mord", "smash"], [node], options);
+            return makeSpan(["mord", "katex-smash"], [node], options);
         }
 
         // In order to influence makeVList for asymmetric smashing, we have to

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.
 
@@ -104,7 +104,7 @@ defineFunction({
             }, options);
             // Add a class surrounding it so we can add on the appropriate
             // kerning
-            const rootVListWrap = makeSpan(["root"], [rootVList]);
+            const rootVListWrap = makeSpan(["katex-root"], [rootVList]);
 
             return makeSpan(["mord", "sqrt"],
                 [rootVListWrap, body], options);

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

@@ -4,40 +4,39 @@ import {MathNode, TextNode} from "../mathMLTree";
 import ParseError from "../ParseError";
 
 // A map of CSS-based spacing functions to their CSS class.
-const cssSpace: Record<string, string> = {
-    "\\nobreak": "nobreak",
-    "\\allowbreak": "allowbreak",
-};
+const cssSpace = new Map<string, string>([
+    ["\\nobreak", "nobreak"],
+    ["\\allowbreak", "allowbreak"],
+]);
 
 // A lookup table to determine whether a spacing function/symbol should be
 // treated like a regular space character.  If a symbol or command is a key
 // in this table, then it should be a regular space character.  Furthermore,
 // the associated value may have a `className` specifying an extra CSS class
 // to add to the created `span`.
-const regularSpace: Record<string, {className?: string}> = {
-    " ": {},
-    "\\ ": {},
-    "~": {
-        className: "nobreak",
-    },
-    "\\space": {},
-    "\\nobreakspace": {
-        className: "nobreak",
-    },
-};
+const regularSpace = new Map<string, {className?: string}>([
+    [" ", {}],
+    ["\\ ", {}],
+    ["~", {className: "nobreak"}],
+    ["\\space", {}],
+    ["\\nobreakspace", {className: "nobreak"}],
+]);
 
 // ParseNode<"spacing"> created in Parser.js from the "spacing" symbol Groups in
 // src/symbols.js.
 defineFunctionBuilders({
     type: "spacing",
     htmlBuilder(group, options) {
-        if (regularSpace.hasOwnProperty(group.text)) {
-            const className = regularSpace[group.text].className || "";
+        const regularSpaceItem = regularSpace.get(group.text);
+        const cssSpaceClass = cssSpace.get(group.text);
+
+        if (regularSpaceItem) {
+            const className = regularSpaceItem.className || "";
             // Spaces are generated by adding an actual space. Each of these
             // 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 {
@@ -45,10 +44,10 @@ defineFunctionBuilders({
                     [mathsym(group.text, group.mode, options)],
                     options);
             }
-        } else if (cssSpace.hasOwnProperty(group.text)) {
+        } else if (cssSpaceClass) {
             // Spaces based on just a CSS class.
             return makeSpan(
-                ["mspace", cssSpace[group.text]],
+                ["mspace", cssSpaceClass],
                 [], options);
         } else {
             throw new ParseError(`Unknown type of space "${group.text}"`);
@@ -57,10 +56,10 @@ defineFunctionBuilders({
     mathmlBuilder(group, options) {
         let node;
 
-        if (regularSpace.hasOwnProperty(group.text)) {
+        if (regularSpace.has(group.text)) {
             node = new MathNode(
                 "mtext", [new TextNode("\u00a0")]);
-        } else if (cssSpace.hasOwnProperty(group.text)) {
+        } else if (cssSpace.has(group.text)) {
             // CSS-based MathML spaces (\nobreak, \allowbreak) are ignored
             return new MathNode("mspace");
         } else {

package/src/functions/text.ts

@@ -5,7 +5,7 @@ import {makeSpan} from "../buildCommon";
 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";
 
 // Non-mathy text, possibly in a font
 const textFontFamilies: Record<string, TextFont | undefined> = {
@@ -54,12 +54,11 @@ defineFunction({
         // Font Shapes
         "\\textit", "\\textup", "\\emph",
     ],
-    props: {
-        numArgs: 1,
-        argTypes: ["text"],
-        allowedInArgument: true,
-        allowedInText: true,
-    },
+    numArgs: 1,
+    argTypes: ["text"],
+    allowedInArgument: true,
+    allowedInText: true,
+
     handler({parser, funcName}, args) {
         const body = args[0];
         return {
@@ -69,6 +68,7 @@ defineFunction({
             font: funcName,
         };
     },
+
     htmlBuilder(group, options) {
         const newOptions = optionsWithFont(group, options);
         const inner = html.buildExpression(group.body, newOptions, true);

package/src/functions/underline.ts

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

package/src/functions/utils/assembleSupSub.ts

@@ -4,7 +4,7 @@ import {isCharacterBox} from "../../utils";
 import type {StyleInterface} from "../../Style";
 import type Options from "../../Options";
 import type {DomSpan, SymbolNode} from "../../domTree";
-import type {AnyParseNode} from "../../parseNode";
+import type {AnyParseNode} from "../../types/nodes";
 import {makeEm} from "../../units";
 
 // For an operator with limits, assemble the base, sup, and sub into a span.

package/src/functions/vcenter.ts

@@ -10,11 +10,10 @@ import * as mml from "../buildMathML";
 defineFunction({
     type: "vcenter",
     names: ["\\vcenter"],
-    props: {
-        numArgs: 1,
-        argTypes: ["original"], // In LaTeX, \vcenter can act only on a box.
-        allowedInText: false,
-    },
+    numArgs: 1,
+    argTypes: ["original"], // In LaTeX, \vcenter can act only on a box.
+    allowedInText: false,
+
     handler({parser}, args) {
         return {
             type: "vcenter",
@@ -22,6 +21,7 @@ defineFunction({
             body: args[0],
         };
     },
+
     htmlBuilder(group, options) {
         const body = html.buildGroup(group.body, options);
         const axisHeight = options.fontMetrics().axisHeight;

package/src/functions/verb.ts

@@ -3,15 +3,14 @@ import {makeSpan, makeSymbol, tryCombineChars} from "../buildCommon";
 import {MathNode, TextNode} from "../mathMLTree";
 import ParseError from "../ParseError";
 
-import type {ParseNode} from "../parseNode";
+import type {ParseNode} from "../types/nodes";
 
 defineFunction({
     type: "verb",
     names: ["\\verb"],
-    props: {
-        numArgs: 0,
-        allowedInText: true,
-    },
+    numArgs: 0,
+    allowedInText: true,
+
     handler(context, args, optArgs) {
         // \verb and \verb* are dealt with directly in Parser.js.
         // If we end up here, it's because of a failure to match the two delimiters
@@ -20,6 +19,7 @@ defineFunction({
         throw new ParseError(
             "\\verb ended by end of line instead of matching delimiter");
     },
+
     htmlBuilder(group, options) {
         const text = makeVerb(group);
         const body = [];

package/src/macros.ts

@@ -14,7 +14,7 @@ import symbols from "./symbols";
 import {makeEm} from "./units";
 import ParseError from "./ParseError";
 
-import type {MacroContextInterface} from "./defineMacro";
+import type {MacroContextInterface, MacroExpansion} from "./defineMacro";
 
 //////////////////////////////////////////////////////////////////////
 // macro tools
@@ -916,7 +916,7 @@ defineMacro("\\ket", "\\mathinner{|{#1}\\rangle}");
 defineMacro("\\braket", "\\mathinner{\\langle{#1}\\rangle}");
 defineMacro("\\Bra", "\\left\\langle#1\\right|");
 defineMacro("\\Ket", "\\left|#1\\right\\rangle");
-const braketHelper = (one: boolean) => (context: MacroContextInterface) => {
+const braketHelper = (one: boolean) => (context: MacroContextInterface): MacroExpansion => {
     const left = context.consumeArg().tokens;
     const middle = context.consumeArg().tokens;
     const middleDouble = context.consumeArg().tokens;
@@ -924,7 +924,7 @@ const braketHelper = (one: boolean) => (context: MacroContextInterface) => {
     const oldMiddle = context.macros.get("|");
     const oldMiddleDouble = context.macros.get("\\|");
     context.macros.beginGroup();
-    const midMacro = (double: boolean) => (context: MacroContextInterface) => {
+    const midMacro = (double: boolean) => (context: MacroContextInterface): MacroExpansion => {
         if (one) {
             // Only modify the first instance of | or \|
             context.macros.set("|", oldMiddle);

package/src/mathMLTree.ts

@@ -83,10 +83,8 @@ export class MathNode implements MathDomNode {
         const node = document.createElementNS(
             "http://www.w3.org/1998/Math/MathML", this.type);
 
-        for (const attr in this.attributes) {
-            if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {
-                node.setAttribute(attr, this.attributes[attr]);
-            }
+        for (const [attr, value] of Object.entries(this.attributes)) {
+            node.setAttribute(attr, value);
         }
 
         if (this.classes.length > 0) {
@@ -118,12 +116,10 @@ export class MathNode implements MathDomNode {
         let markup = "<" + this.type;
 
         // Add the attributes
-        for (const attr in this.attributes) {
-            if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {
-                markup += " " + attr + "=\"";
-                markup += escape(this.attributes[attr]);
-                markup += "\"";
-            }
+        for (const [attr, value] of Object.entries(this.attributes)) {
+            markup += " " + attr + "=\"";
+            markup += escape(value);
+            markup += "\"";
         }
 
         if (this.classes.length > 0) {