katex 0.16.47 → 0.18.0

package/src/buildHTML.ts

@@ -8,15 +8,16 @@
 import ParseError from "./ParseError";
 import Style from "./Style";
 import {makeGlue, makeSpan, tryCombineChars} from "./buildCommon";
-import {Span, Anchor} from "./domTree";
+import type {DomSpan, HtmlDomNode} from "./domTree";
+import {Anchor, Span} from "./domTree";
 import {makeEm} from "./units";
 import {spacings, tightSpacings} from "./spacingData";
 import {_htmlGroupBuilders as groupBuilders} from "./defineFunction";
 import {DocumentFragment} from "./tree";
 
 import type Options from "./Options";
-import type {AnyParseNode} from "./parseNode";
-import type {HtmlDomNode, DomSpan} from "./domTree";
+import type {AnyParseNode} from "./types/nodes";
+import type {Side} from "./types";
 
 // Binary atoms (first class `mbin`) change into ordinary atoms (`mord`)
 // depending on their surroundings. See TeXbook pg. 442-446, Rules 5 and 6,
@@ -35,8 +36,6 @@ const styleMap = {
     "scriptscript": Style.SCRIPTSCRIPT,
 };
 
-type Side = "left" | "right";
-
 const DomEnum = {
     mord: "mord",
     mop: "mop",
@@ -183,7 +182,7 @@ const traverseNonSpaceNodes = function(
 
         if (nonspace) {
             prev.node = node;
-        } else if (isRoot && node.hasClass("newline")) {
+        } else if (isRoot && node.hasClass("katex-newline")) {
             prev.node = makeSpan(["leftmost"]); // treat like beginning of line
         }
         prev.insertAfter = (index => n => {
@@ -293,18 +292,18 @@ export const buildGroup = function(
 
 /**
  * Combine an array of HTML DOM nodes (e.g., the output of `buildExpression`)
- * into an unbreakable HTML node of class .base, with proper struts to
+ * into an unbreakable HTML node of class .katex-base, with proper struts to
  * guarantee correct vertical extent.  `buildHTML` calls this repeatedly to
  * make up the entire expression as a sequence of unbreakable units.
  */
 function buildHTMLUnbreakable(children: HtmlDomNode[], options: Options) {
     // Compute height and depth of this chunk.
-    const body = makeSpan(["base"], children, options);
+    const body = makeSpan(["katex-base"], children, options);
 
     // Add strut, which ensures that the top of the HTML element falls at
     // the height of the expression, and the bottom of the HTML element
     // falls at the depth of the expression.
-    const strut = makeSpan(["strut"]);
+    const strut = makeSpan(["katex-strut"]);
     strut.style.height = makeEm(body.height + body.depth);
     if (body.depth) {
         strut.style.verticalAlign = makeEm(-body.depth);
@@ -330,7 +329,7 @@ export default function buildHTML(tree: AnyParseNode[], options: Options): DomSp
     const expression = buildExpression(tree, options, "root");
 
     let eqnNum;
-    if (expression.length === 2 && expression[1].hasClass("tag")) {
+    if (expression.length === 2 && expression[1].hasClass("katex-tag")) {
         // An environment with automatic equation numbers, e.g. {gather}.
         eqnNum = expression.pop();
     }
@@ -355,7 +354,7 @@ export default function buildHTML(tree: AnyParseNode[], options: Options): DomSp
             let nobreak = false;
             while (i < expression.length - 1 &&
                    expression[i + 1].hasClass("mspace") &&
-                   !expression[i + 1].hasClass("newline")) {
+                   !expression[i + 1].hasClass("katex-newline")) {
                 i++;
                 parts.push(expression[i]);
                 if (expression[i].hasClass("nobreak")) {
@@ -367,7 +366,7 @@ export default function buildHTML(tree: AnyParseNode[], options: Options): DomSp
                 children.push(buildHTMLUnbreakable(parts, options));
                 parts = [];
             }
-        } else if (expression[i].hasClass("newline")) {
+        } else if (expression[i].hasClass("katex-newline")) {
             // Write the line except the newline
             parts.pop();
             if (parts.length > 0) {
@@ -389,7 +388,7 @@ export default function buildHTML(tree: AnyParseNode[], options: Options): DomSp
             buildExpression(tag, options, true),
             options,
         );
-        tagChild.classes = ["tag"];
+        tagChild.classes = ["katex-tag"];
         children.push(tagChild);
     } else if (eqnNum) {
         children.push(eqnNum);

package/src/buildMathML.ts

@@ -12,11 +12,11 @@ import {_mathmlGroupBuilders as groupBuilders} from "./defineFunction";
 import {MathNode, TextNode} from "./mathMLTree";
 
 import type Options from "./Options";
-import type {AnyParseNode, SymbolParseNode} from "./parseNode";
 import type {DomSpan, HtmlDomNode} from "./domTree";
 import type {MathDomNode} from "./mathMLTree";
 import type {Mode} from "./types";
 import type {FontVariant, MathFont} from "./types/fonts";
+import type {AnyParseNode, SymbolParseNode} from "./types/nodes";
 
 const noVariantSymbols = new Set(["\\imath", "\\jmath"]);
 const rowLikeTypes = new Set(["mrow", "mtable"]);
@@ -32,9 +32,9 @@ export const makeText = function(
 ): TextNode {
     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")))) {
+        !(Object.prototype.hasOwnProperty.call(ligatures, text) &&
+          (options?.fontFamily?.slice(4, 6) === "tt" ||
+           options?.font?.slice(4, 6) === "tt"))) {
         text = symbols[mode][text].replace!;
     }
 

package/src/buildTree.ts

@@ -5,7 +5,7 @@ import Options from "./Options";
 import Settings from "./Settings";
 import Style from "./Style";
 
-import type {AnyParseNode} from "./parseNode";
+import type {AnyParseNode} from "./types/nodes";
 import type {DomSpan} from "./domTree";
 
 const optionsFromSettings = function(settings: Settings) {

package/src/defineEnvironment.ts

@@ -1,9 +1,8 @@
 import {_htmlGroupBuilders, _mathmlGroupBuilders} from "./defineFunction";
 
 import type Parser from "./Parser";
-import type {AnyParseNode} from "./parseNode";
+import type {AnyParseNode, NodeType} from "./types/nodes";
 import type {ArgType, Mode} from "./types";
-import type {NodeType} from "./parseNode";
 import type {HtmlBuilder, MathMLBuilder} from "./defineFunction";
 
 /**

package/src/defineFunction.ts

@@ -1,24 +1,26 @@
 import type Parser from "./Parser";
-import type {ParseNode, AnyParseNode, NodeType, UnsupportedCmdParseNode}
-    from "./parseNode";
 import type Options from "./Options";
 import type {ArgType, BreakToken} from "./types";
+import type {AnyParseNode, NodeType, ParseNode, UnsupportedCmdParseNode} from "./types/nodes";
 import type {HtmlDomNode} from "./domTree";
 import type {Token} from "./Token";
 import type {MathDomNode} from "./mathMLTree";
 
 /** Context provided to function handlers for error messages. */
-export type FunctionContext = {
-    funcName: string;
+export type FunctionContext<FUNCNAME extends string = string> = {
+    funcName: FUNCNAME;
     parser: Parser;
     token?: Token;
     breakOnTokenText?: BreakToken;
 };
 
-export type FunctionHandler<NODETYPE extends NodeType> = (
-    context: FunctionContext,
+export type FunctionHandler<
+    NODETYPE extends NodeType,
+    FUNCNAME extends string = string,
+> = (
+    context: FunctionContext<FUNCNAME>,
     args: AnyParseNode[],
-    optArgs: (AnyParseNode | null | undefined)[],
+    optArgs: (AnyParseNode | null)[],
 ) => UnsupportedCmdParseNode | ParseNode<NODETYPE>;
 // Note: reverse the order of the return type union will cause a flow error.
 // See https://github.com/facebook/flow/issues/3663.
@@ -34,104 +36,109 @@ export type MathMLBuilder<NODETYPE extends NodeType> =
 export type HtmlBuilderSupSub<NODETYPE extends NodeType> =
     (group: ParseNode<"supsub"> | ParseNode<NODETYPE>, options: Options) => HtmlDomNode;
 
-export type FunctionPropSpec = {
-    // The number of arguments the function takes.
+/**
+ * Parser-facing function spec.  Optional properties should use the defaults
+ * documented below.
+ */
+export type FunctionSpec<
+    NODETYPE extends NodeType,
+    FUNCNAME extends string = string,
+> = {
+    /**
+     * Unique string to differentiate parse nodes.
+     * Also determines the type of the value returned by `handler`.
+     */
+    type: NODETYPE;
+
+    /** The number of arguments the function takes. */
     numArgs: number;
 
-    // An array corresponding to each argument of the function, giving the
-    // type of argument that should be parsed. Its length should be equal
-    // to `numOptionalArgs + numArgs`, and types for optional arguments
-    // should appear before types for mandatory arguments.
+    /**
+     * An array corresponding to each argument of the function, giving the
+     * type of argument that should be parsed. Its length should be equal
+     * to `numOptionalArgs + numArgs`, and types for optional arguments
+     * should appear before types for mandatory arguments.
+     */
     argTypes?: ArgType[];
 
-    // Whether it expands to a single token or a braced group of tokens.
-    // If it's grouped, it can be used as an argument to primitive commands,
-    // such as \sqrt (without the optional argument) and super/subscript.
+    /**
+     * Whether it expands to a single token or a braced group of tokens.
+     * If it's grouped, it can be used as an argument to primitive commands,
+     * such as \sqrt (without the optional argument) and super/subscript.
+     * (default false)
+     */
     allowedInArgument?: boolean;
 
-    // Whether or not the function is allowed inside text mode
-    // (default false)
+    /**
+     * Whether or not the function is allowed inside text mode
+     * (default false)
+     */
     allowedInText?: boolean;
 
-    // Whether or not the function is allowed inside text mode
-    // (default true)
+    /**
+     * Whether or not the function is allowed inside math mode
+     * (default true)
+     */
     allowedInMath?: boolean;
 
-    // (optional) The number of optional arguments the function
-    // should parse. If the optional arguments aren't found,
-    // `null` will be passed to the handler in their place.
-    // (default 0)
+    /**
+     * The number of optional arguments the function should parse. If the
+     * optional arguments aren't found, `null` will be passed to the handler in
+     * their place.
+     * (default 0)
+     */
     numOptionalArgs?: number;
 
-    // Must be true if the function is an infix operator.
+    /** Must be true if the function is an infix operator. */
     infix?: boolean;
 
-    // Whether or not the function is a TeX primitive.
+    /** Whether or not the function is a TeX primitive. */
     primitive?: boolean;
-};
 
-type FunctionDefSpec<NODETYPE extends NodeType> = {
-    // Unique string to differentiate parse nodes.
-    // Also determines the type of the value returned by `handler`.
-    type: NODETYPE;
-
-    // The first argument to defineFunction is a single name or a list of names.
-    // All functions named in such a list will share a single implementation.
-    names: Array<string>;
-
-    // Properties that control how the functions are parsed.
-    props: FunctionPropSpec;
-
-    // The handler is called to handle these functions and their arguments and
-    // returns a `ParseNode`.
-    handler: FunctionHandler<NODETYPE> | null | undefined;
+    /**
+     * The handler is called to handle these functions and their arguments and
+     * returns a `ParseNode`.  It must be specified unless it's handled directly
+     * in the parser.
+     */
+    handler: FunctionHandler<NODETYPE, FUNCNAME> | null | undefined;
+};
 
-    // This function returns an object representing the DOM structure to be
-    // created when rendering the defined LaTeX function.
-    // This should not modify the `ParseNode`.
+/**
+ * Builder fields consumed during registration.  These are stored separately in
+ * `_htmlGroupBuilders` and `_mathmlGroupBuilders`, and are not used by Parser.
+ */
+export type FunctionBuilders<NODETYPE extends NodeType> = {
+    /**
+     * This function returns an object representing the DOM structure to be
+     * created when rendering the defined LaTeX function.
+     * This should not modify the `ParseNode`.
+     */
     htmlBuilder?: HtmlBuilder<NODETYPE>;
 
-    // This function returns an object representing the MathML structure to be
-    // created when rendering the defined LaTeX function.
-    // This should not modify the `ParseNode`.
+    /**
+     * This function returns an object representing the MathML structure to be
+     * created when rendering the defined LaTeX function.
+     * This should not modify the `ParseNode`.
+     */
     mathmlBuilder?: MathMLBuilder<NODETYPE>;
 };
 
 /**
- * Final function spec for use at parse time.
- * This is almost identical to `FunctionPropSpec`, except it
- * 1. includes the function handler, and
- * 2. requires all arguments except argTypes.
- * It is generated by `defineFunction()` below.
+ * Full registration spec passed to `defineFunction`.  It combines the
+ * parser-facing fields with optional builder fields and the names being
+ * registered.
  */
-export type FunctionSpec<NODETYPE extends NodeType> = {
-    type: NODETYPE; // Need to use the type to avoid error. See NOTES below.
-    numArgs: number;
-    argTypes?: ArgType[];
-    allowedInArgument: boolean;
-    allowedInText: boolean;
-    allowedInMath: boolean;
-    numOptionalArgs: number;
-    infix: boolean;
-    primitive: boolean;
-
-    // FLOW TYPE NOTES: Doing either one of the following two
-    //
-    // - removing the NODETYPE type parameter in FunctionSpec above;
-    // - using ?FunctionHandler<NODETYPE> below;
-    //
-    // results in a confusing flow typing error:
-    //   "string literal `styling`. This type is incompatible with..."
-    // pointing to the definition of `defineFunction` and finishing with
-    //   "some incompatible instantiation of `NODETYPE`"
-    //
-    // Having FunctionSpec<NODETYPE> above and FunctionHandler<*> below seems to
-    // circumvent this error. This is not harmful for catching errors since
-    // _functions is typed FunctionSpec<*> (it stores all TeX function specs).
-
-    // Must be specified unless it's handled directly in the parser.
-    handler: FunctionHandler<NodeType> | null | undefined;
-};
+type FunctionDefSpec<
+    NODETYPE extends NodeType,
+    NAMES extends readonly string[],
+> =
+    FunctionSpec<NODETYPE, NAMES[number]> & FunctionBuilders<NODETYPE> & {
+        /**
+         * The first argument to defineFunction is a single name or a list of names.
+         * All functions named in such a list will share a single implementation.
+         */
+        names: NAMES;
+    };
 
 /**
  * All registered functions.
@@ -159,30 +166,17 @@ export const _htmlGroupBuilders: Record<string, HtmlBuilder<any>> = {};
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const _mathmlGroupBuilders: Record<string, MathMLBuilder<any>> = {};
 
-export default function defineFunction<NODETYPE extends NodeType>({
-    type,
-    names,
-    props,
-    handler,
-    htmlBuilder,
-    mathmlBuilder,
-}: FunctionDefSpec<NODETYPE>) {
-    // Set default values of functions
-    const data = {
-        type,
-        numArgs: props.numArgs,
-        argTypes: props.argTypes,
-        allowedInArgument: !!props.allowedInArgument,
-        allowedInText: !!props.allowedInText,
-        allowedInMath: (props.allowedInMath === undefined)
-            ? true
-            : props.allowedInMath,
-        numOptionalArgs: props.numOptionalArgs || 0,
-        infix: !!props.infix,
-        primitive: !!props.primitive,
-        handler,
-    };
+export default function defineFunction<
+    NODETYPE extends NodeType,
+    const NAMES extends readonly string[],
+>(
+    data: FunctionDefSpec<NODETYPE, NAMES>,
+) {
+    const {type, names, htmlBuilder, mathmlBuilder} = data;
     for (let i = 0; i < names.length; ++i) {
+        // To avoid destructuring and rebuilding an object,
+        // we store the entire FunctionDefSpec object,
+        // even though Parser only needs the FunctionSpec fields.
         _functions[names[i]] = data;
     }
     if (type) {
@@ -207,14 +201,12 @@ export function defineFunctionBuilders<NODETYPE extends NodeType>({
     htmlBuilder?: HtmlBuilder<NODETYPE>;
     mathmlBuilder: MathMLBuilder<NODETYPE>;
 }) {
-    defineFunction({
-        type,
-        names: [],
-        props: {numArgs: 0},
-        handler() { throw new Error('Should never be called.'); },
-        htmlBuilder,
-        mathmlBuilder,
-    });
+    if (htmlBuilder) {
+        _htmlGroupBuilders[type] = htmlBuilder;
+    }
+    if (mathmlBuilder) {
+        _mathmlGroupBuilders[type] = mathmlBuilder;
+    }
 }
 
 export const normalizeArgument = function(arg: AnyParseNode): AnyParseNode {

package/src/environments/array.ts

@@ -15,8 +15,8 @@ import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
 
 import type Parser from "../Parser";
-import type {ParseNode, AnyParseNode} from "../parseNode";
 import type {StyleStr, Mode} from "../types";
+import type {AnyParseNode, ParseNode} from "../types/nodes";
 import type {HtmlBuilder, MathMLBuilder} from "../defineFunction";
 import type {HtmlDomNode} from "../domTree";
 
@@ -520,8 +520,8 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
 
     // Add \hline(s), if any.
     if (hlines.length > 0) {
-        const line = makeLineSpan("hline", options, ruleThickness);
-        const dashes = makeLineSpan("hdashline", options, ruleThickness);
+        const line = makeLineSpan("katex-hline", options, ruleThickness);
+        const dashes = makeLineSpan("katex-hdashline", options, ruleThickness);
         const vListElems = [{type: "elem" as const, elem: tableBody, shift: 0}];
         while (hlines.length > 0) {
             const hline = hlines.pop()!;
@@ -546,7 +546,7 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
             positionType: "individualShift",
             children: tagSpans,
         }, options);
-        const tagCol = makeSpan(["tag"], [eqnNumCol], options);
+        const tagCol = makeSpan(["katex-tag"], [eqnNumCol], options);
         return makeFragment([tableBody, tagCol]);
     }
 };
@@ -703,7 +703,6 @@ const alignedHandler = function(context: EnvContextLike, args: AnyParseNode[]) {
         validateAmsEnvironmentContext(context);
     }
     const cols: AlignSpec[] = [];
-    const separationType: ColSeparationType = context.envName.includes("at") ? "alignat" : "align";
     const isSplit = context.envName === "split";
     const res = parseArray(context.parser,
         {
@@ -711,7 +710,7 @@ const alignedHandler = function(context: EnvContextLike, args: AnyParseNode[]) {
             addJot: true,
             autoTag: isSplit ? undefined : getAutoTag(context.envName),
             emptySingleRow: true,
-            colSeparationType: separationType,
+            colSeparationType: context.envName.includes("at") ? "alignat" : "align",
             maxNumCols: isSplit ? 2 : undefined,
             leqno: context.parser.settings.leqno,
         },
@@ -893,8 +892,7 @@ defineEnvironment({
                 payload.cols = [{type: "align", align: colAlign}];
             }
         }
-        const res: ParseNode<"array"> =
-            parseArray(context.parser, payload, dCellStyle(context.envName));
+        const res = parseArray(context.parser, payload, dCellStyle(context.envName));
         // Populate cols with the correct number of column alignment specs.
         const numCols = Math.max(0, ...res.body.map(row => row.length));
         res.cols = new Array(numCols).fill(
@@ -1006,8 +1004,7 @@ defineEnvironment({
                 postgap: 0,
             }],
         };
-        const res: ParseNode<"array"> =
-            parseArray(context.parser, payload, dCellStyle(context.envName));
+        const res = parseArray(context.parser, payload, dCellStyle(context.envName));
         return {
             type: "leftright",
             mode: context.mode,
@@ -1124,11 +1121,10 @@ defineMacro("\\notag", "\\nonumber");
 defineFunction({
     type: "text", // Doesn't matter what this is.
     names: ["\\hline", "\\hdashline"],
-    props: {
-        numArgs: 0,
-        allowedInText: true,
-        allowedInMath: true,
-    },
+    numArgs: 0,
+    allowedInText: true,
+    allowedInMath: true,
+
     handler(context, args) {
         throw new ParseError(
             `${context.funcName} valid only within array environment`);

package/src/environments/cd.ts

@@ -8,7 +8,8 @@ import ParseError from "../ParseError";
 import {makeEm} from "../units";
 
 import type Parser from "../Parser";
-import type {ParseNode, AnyParseNode} from "../parseNode";
+import type {AnyParseNode, ParseNode} from "../types/nodes";
+import type {Slice4} from "../types";
 
 const cdArrowFunctionName: Record<string, string> = {
     ">": "\\\\cdrightarrow",
@@ -247,17 +248,16 @@ export function parseCD(parser: Parser): ParseNode<"array"> {
 defineFunction({
     type: "cdlabel",
     names: ["\\\\cdleft", "\\\\cdright"],
-    props: {
-        numArgs: 1,
-    },
+    numArgs: 1,
     handler({parser, funcName}, args) {
         return {
             type: "cdlabel",
             mode: parser.mode,
-            side: funcName.slice(4),
+            side: funcName.slice(4) as Slice4<typeof funcName>,
             label: args[0],
         };
     },
+
     htmlBuilder(group, options) {
         const newOptions = options.havingStyle(options.style.sup());
         const label = wrapFragment(
@@ -291,9 +291,8 @@ defineFunction({
 defineFunction({
     type: "cdlabelparent",
     names: ["\\\\cdparent"],
-    props: {
-        numArgs: 1,
-    },
+    numArgs: 1,
+
     handler({parser}, args) {
         return {
             type: "cdlabelparent",
@@ -301,6 +300,7 @@ defineFunction({
             fragment: args[0],
         };
     },
+
     htmlBuilder(group, options) {
         // Wrap the vertical arrow and its labels.
         // The parent gets position: relative. The child gets position: absolute.

package/src/fontMetrics.ts

@@ -257,10 +257,8 @@ export function getGlobalMetrics(size: number): FontMetrics {
         const metrics: FontMetrics = fontMetricsBySizeIndex[sizeIndex] = {
             cssEmPerMu: sigmasAndXis.quad[sizeIndex] / 18,
         };
-        for (const key in sigmasAndXis) {
-            if (sigmasAndXis.hasOwnProperty(key)) {
-                metrics[key] = sigmasAndXis[key][sizeIndex];
-            }
+        for (const key of Object.keys(sigmasAndXis)) {
+            metrics[key] = sigmasAndXis[key][sizeIndex];
         }
     }
     return fontMetricsBySizeIndex[sizeIndex]!;

package/src/functions/accent.ts

@@ -10,9 +10,9 @@ import {makeEm} from "../units";
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
 
-import type {ParseNode, AnyParseNode} from "../parseNode";
 import type {HtmlBuilderSupSub, MathMLBuilder} from "../defineFunction";
 import type {HtmlDomNode} from "../domTree";
+import type {AnyParseNode, ParseNode} from "../types/nodes";
 
 const getBaseSymbol = (group: HtmlDomNode): SymbolNode | undefined => {
     if (group instanceof SymbolNode) {
@@ -100,7 +100,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
             width = svgData.vec[1];
         } else {
             accent = makeOrd({type: "textord", mode: group.mode, text: group.label},
-                options, "textord");
+                options);
             accent = assertSymbolDomNode(accent);
             // Remove the italic correction of the accent, because it only serves to
             // shift the accent over to a place we don't want.
@@ -125,7 +125,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
         // Shift the accent over by the skew.
         let left = skew;
 
-        // CSS defines `.katex .accent .accent-body:not(.accent-full) { width: 0 }`
+        // CSS defines `.katex .katex-accent .accent-body:not(.accent-full) { width: 0 }`
         // so that the accent doesn't contribute to the bounding box.
         // We need to shift the character by its width (effectively half
         // its width) to compensate.
@@ -173,7 +173,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
     }
 
     const accentWrap =
-        makeSpan(["mord", "accent"], [accentBody], options);
+        makeSpan(["mord", "katex-accent"], [accentBody], options);
 
     if (supSubGroup) {
         // Here, we replace the "base" child of the supsub with our newly
@@ -223,9 +223,8 @@ defineFunction({
         "\\Overrightarrow", "\\overleftrightarrow", "\\overgroup",
         "\\overlinesegment", "\\overleftharpoon", "\\overrightharpoon",
     ],
-    props: {
-        numArgs: 1,
-    },
+    numArgs: 1,
+
     handler: (context, args) => {
         const base = normalizeArgument(args[0]);
 
@@ -244,6 +243,7 @@ defineFunction({
             base: base,
         };
     },
+
     htmlBuilder,
     mathmlBuilder,
 });
@@ -255,12 +255,11 @@ defineFunction({
         "\\'", "\\`", "\\^", "\\~", "\\=", "\\u", "\\.", '\\"',
         "\\c", "\\r", "\\H", "\\v", "\\textcircled",
     ],
-    props: {
-        numArgs: 1,
-        allowedInText: true,
-        allowedInMath: true, // unless in strict mode
-        argTypes: ["primitive"],
-    },
+    numArgs: 1,
+    allowedInText: true,
+    allowedInMath: true, // unless in strict mode
+    argTypes: ["primitive"],
+
     handler: (context, args) => {
         const base = args[0];
         let mode = context.parser.mode;
@@ -280,6 +279,4 @@ defineFunction({
             base: base,
         };
     },
-    htmlBuilder,
-    mathmlBuilder,
 });