katex 0.16.47 → 0.17.0

package/katex.ts

@@ -23,7 +23,7 @@ import {
 } from "./src/domTree";
 
 import type {SettingsOptions} from "./src/Settings";
-import type {AnyParseNode} from "./src/parseNode";
+import type {AnyParseNode} from "./src/types/nodes";
 import type {DomSpan} from "./src/domTree";
 
 import {defineSymbol} from './src/symbols';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "katex",
-  "version": "0.16.47",
+  "version": "0.17.0",
   "description": "Fast math typesetting for the web.",
   "main": "dist/katex.js",
   "types": "types/katex.d.ts",

package/src/MacroExpander.ts

@@ -119,7 +119,7 @@ export default class MacroExpander implements MacroContextInterface {
      * Find an macro argument without expanding tokens and append the array of
      * tokens to the token stack. Uses Token as a container for the result.
      */
-    scanArgument(isOptional: boolean): Token | null | undefined {
+    scanArgument(isOptional: boolean): Token | null {
         let start;
         let end;
         let tokens;

package/src/Namespace.ts

@@ -82,7 +82,7 @@ export default class Namespace<Value> {
      * to `false` in JavaScript.  Use `if (namespace.get(...) != null)` or
      * `if (namespace.has(...))`.
      */
-    get(name: string): Value | null | undefined {
+    get(name: string): Value | undefined {
         if (this.current.hasOwnProperty(name)) {
             return this.current[name];
         } else {

package/src/ParseError.ts

@@ -1,6 +1,6 @@
 import {Token} from "./Token";
 
-import type {AnyParseNode} from "./parseNode";
+import type {AnyParseNode} from "./types/nodes";
 
 /**
  * This is the ParseError class, which is the main error thrown by KaTeX

package/src/Parser.ts

@@ -2,6 +2,7 @@
 import functions from "./functions";
 import MacroExpander, {implicitCommands} from "./MacroExpander";
 import symbols, {extraLatin} from "./symbols";
+import type {Group} from "./atoms";
 import {isAtom} from "./atoms";
 import {validUnit} from "./units";
 import {supportedCodepoint} from "./unicodeScripts";
@@ -9,17 +10,15 @@ import ParseError from "./ParseError";
 import {combiningDiacriticalMarksEndRegex} from "./Lexer";
 import Settings from "./Settings";
 import SourceLocation from "./SourceLocation";
-import {uSubsAndSups, unicodeSubRegEx} from "./unicodeSupOrSub";
+import {unicodeSubRegEx, uSubsAndSups} from "./unicodeSupOrSub";
 import {Token} from "./Token";
 
 // Pre-evaluate both modules as unicodeSymbols require String.normalize()
 import unicodeAccents from /*preval*/ "./unicodeAccents";
 import unicodeSymbols from /*preval*/ "./unicodeSymbols";
 
-import type {NodeType, ParseNode, AnyParseNode, SymbolParseNode,
-    UnsupportedCmdParseNode} from "./parseNode";
-import type {Group} from "./atoms";
-import type {Mode, ArgType, BreakToken} from "./types";
+import type {ArgType, BreakToken, Mode} from "./types";
+import type {AnyParseNode, NodeType, ParseNode, SymbolParseNode, UnsupportedCmdParseNode} from "./types/nodes";
 import type {FunctionContext, FunctionSpec} from "./defineFunction";
 import type {EnvSpec} from "./defineEnvironment";
 
@@ -336,13 +335,13 @@ export default class Parser {
     /**
      * Parses a group with optional super/subscripts.
      */
-    parseAtom(breakOnTokenText?: BreakToken): AnyParseNode | null | undefined {
+    parseAtom(breakOnTokenText?: BreakToken): AnyParseNode | null {
         // The body of an atom is an implicit group, so that things like
         // \left(x\right)^2 work correctly.
         const base = this.parseGroup("atom", breakOnTokenText);
 
         // Internal nodes (e.g. \relax) cannot support super/subscripts.
-        // Instead we will pick up super/subscripts with blank base next round.
+        // Instead, we will pick up super/subscripts with blank base next round.
         if (base?.type === "internal") {
             return base;
         }
@@ -352,10 +351,8 @@ export default class Parser {
             return base;
         }
 
-        // Note that base may be empty (i.e. null) at this point.
-
-        let superscript: AnyParseNode | null | undefined;
-        let subscript: AnyParseNode | null | undefined;
+        let superscript: AnyParseNode | undefined;
+        let subscript: AnyParseNode | undefined;
         while (true) {
             // Guaranteed in math mode, so eat any spaces first.
             this.consumeSpaces();
@@ -366,8 +363,7 @@ export default class Parser {
             if (lex.text === "\\limits" || lex.text === "\\nolimits") {
                 // We got a limit control
                 if (base && base.type === "op") {
-                    const limits = lex.text === "\\limits";
-                    base.limits = limits;
+                    base.limits = lex.text === "\\limits";
                     base.alwaysHandleSupSub = true;
                 } else if (base && base.type === "operatorname") {
                     if (base.alwaysHandleSupSub) {
@@ -447,15 +443,12 @@ export default class Parser {
 
         // Base must be set if superscript or subscript are set per logic above,
         // but need to check here for type check to pass.
-        if (superscript || subscript) {
-            // If we got either a superscript or subscript, create a supsub
-            return {
-                type: "supsub",
-                mode: this.mode,
-                base: base,
-                sup: superscript,
-                sub: subscript,
-            };
+        if (superscript && subscript) {
+            return {type: "supsub", mode: this.mode, base, sup: superscript, sub: subscript};
+        } else if (superscript) {
+            return {type: "supsub", mode: this.mode, base, sup: superscript};
+        } else if (subscript) {
+            return {type: "supsub", mode: this.mode, base, sub: subscript};
         } else {
             // Otherwise return the original body
             return base;
@@ -468,7 +461,7 @@ export default class Parser {
     parseFunction(
         breakOnTokenText?: BreakToken,
         name?: string, // For determining its context
-    ): AnyParseNode | null | undefined {
+    ): AnyParseNode | null {
         const token = this.fetch();
         const func = token.text;
         const funcData = functions[func];
@@ -481,9 +474,11 @@ export default class Parser {
             throw new ParseError(
                 "Got function '" + func + "' with no arguments" +
                 (name ? " as " + name : ""), token);
+        // Treat undefined allowedInText as false.
         } else if (this.mode === "text" && !funcData.allowedInText) {
             throw new ParseError(
                 "Can't use function '" + func + "' in text mode", token);
+        // Treat undefined allowedInMath as true.
         } else if (this.mode === "math" && funcData.allowedInMath === false) {
             throw new ParseError(
                 "Can't use function '" + func + "' in math mode", token);
@@ -499,7 +494,7 @@ export default class Parser {
     callFunction(
         name: string,
         args: AnyParseNode[],
-        optArgs: (AnyParseNode | null | undefined)[],
+        optArgs: (AnyParseNode | null)[],
         token?: Token,
         breakOnTokenText?: BreakToken,
     ): AnyParseNode {
@@ -525,19 +520,20 @@ export default class Parser {
         funcData: FunctionSpec<NodeType> | EnvSpec<NodeType>,
     ): {
         args: AnyParseNode[];
-        optArgs: (AnyParseNode | null | undefined)[];
+        optArgs: (AnyParseNode | null)[];
     } {
-        const totalArgs = funcData.numArgs + funcData.numOptionalArgs;
+        const numOptionalArgs = funcData.numOptionalArgs ?? 0;
+        const totalArgs = funcData.numArgs + numOptionalArgs;
         if (totalArgs === 0) {
             return {args: [], optArgs: []};
         }
 
         const args: AnyParseNode[] = [];
-        const optArgs: (AnyParseNode | null | undefined)[] = [];
+        const optArgs: (AnyParseNode | null)[] = [];
 
         for (let i = 0; i < totalArgs; i++) {
-            let argType = funcData.argTypes && funcData.argTypes[i];
-            const isOptional = i < funcData.numOptionalArgs;
+            let argType = funcData.argTypes?.[i];
+            const isOptional = i < numOptionalArgs;
 
             if (("primitive" in funcData && funcData.primitive && argType == null) ||
                 // \sqrt expands into primitive if optional argument doesn't exist
@@ -547,7 +543,7 @@ export default class Parser {
             }
 
             const arg = this.parseGroupOfType(`argument to '${func}'`,
-                argType as ArgType | null | undefined, isOptional);
+                argType, isOptional);
             if (isOptional) {
                 optArgs.push(arg);
             } else if (arg != null) {
@@ -565,9 +561,9 @@ export default class Parser {
      */
     parseGroupOfType(
         name: string,
-        type: ArgType | null | undefined,
+        type: ArgType | undefined,
         optional: boolean,
-    ): AnyParseNode | null | undefined {
+    ): AnyParseNode | null {
         switch (type) {
             case "color":
                 return this.parseColorGroup(optional);
@@ -592,7 +588,7 @@ export default class Parser {
                 } : null;
             }
             case "raw": {
-                const token = this.parseStringGroup("raw", optional);
+                const token = this.parseStringGroup(optional);
                 return token != null ? {
                     type: "raw",
                     mode: "text",
@@ -610,7 +606,6 @@ export default class Parser {
                 return group;
             }
             case "original":
-            case null:
             case undefined:
                 return this.parseArgumentGroup(optional);
             default:
@@ -633,9 +628,8 @@ export default class Parser {
      * brace-enclosed tokens plus some position information.
      */
     parseStringGroup(
-        modeName: ArgType,  // Used to describe the mode in error messages.
         optional: boolean,
-    ): Token | null | undefined {
+    ): Token | null {
         const argToken = this.gullet.scanArgument(optional);
         if (argToken == null) {
             return null;
@@ -681,8 +675,8 @@ export default class Parser {
     /**
      * Parses a color description.
      */
-    parseColorGroup(optional: boolean): ParseNode<"color-token"> | null | undefined {
-        const res = this.parseStringGroup("color", optional);
+    parseColorGroup(optional: boolean): ParseNode<"color-token"> | null {
+        const res = this.parseStringGroup(optional);
         if (res == null) {
             return null;
         }
@@ -710,8 +704,8 @@ export default class Parser {
     /**
      * Parses a size specification, consisting of magnitude and unit.
      */
-    parseSizeGroup(optional: boolean): ParseNode<"size"> | null | undefined {
-        let res: Token | null | undefined;
+    parseSizeGroup(optional: boolean): ParseNode<"size"> | null {
+        let res: Token | null;
         let isBlank = false;
         // don't expand before parseStringGroup
         this.gullet.consumeSpaces();
@@ -719,7 +713,7 @@ export default class Parser {
             res = this.parseRegexGroup(
                 /^[-+]? *(?:$|\d+|\d+\.\d*|\.\d*) *[a-z]{0,2} *$/, "size");
         } else {
-            res = this.parseStringGroup("size", optional);
+            res = this.parseStringGroup(optional);
         }
         if (!res) {
             return null;
@@ -755,10 +749,10 @@ export default class Parser {
      * Parses an URL, checking escaped letters and allowed protocols,
      * and setting the catcode of % as an active character (as in \hyperref).
      */
-    parseUrlGroup(optional: boolean): ParseNode<"url"> | null | undefined {
+    parseUrlGroup(optional: boolean): ParseNode<"url"> | null {
         this.gullet.lexer.setCatcode("%", 13); // active character
         this.gullet.lexer.setCatcode("~", 12); // other character
-        const res = this.parseStringGroup("url", optional);
+        const res = this.parseStringGroup(optional);
         this.gullet.lexer.setCatcode("%", 14); // comment character
         this.gullet.lexer.setCatcode("~", 13); // active character
         if (res == null) {
@@ -779,7 +773,7 @@ export default class Parser {
     /**
      * Parses an argument with the mode specified.
      */
-    parseArgumentGroup(optional: boolean, mode?: Mode): ParseNode<"ordgroup"> | null | undefined {
+    parseArgumentGroup(optional: boolean, mode?: Mode): ParseNode<"ordgroup"> | null {
         const argToken = this.gullet.scanArgument(optional);
         if (argToken == null) {
             return null;
@@ -816,11 +810,11 @@ export default class Parser {
     parseGroup(
         name: string, // For error reporting.
         breakOnTokenText?: BreakToken,
-    ): AnyParseNode | null | undefined {
+    ): AnyParseNode | null {
         const firstToken = this.fetch();
         const text = firstToken.text;
 
-        let result: AnyParseNode | null | undefined;
+        let result;
         // Try to parse an open brace or \begingroup
         if (text === "{" || text === "\\begingroup") {
             this.consume();
@@ -842,7 +836,7 @@ export default class Parser {
                 // https://tex.stackexchange.com/questions/1930/when-should-one-
                 // use-begingroup-instead-of-bgroup
                 semisimple: text === "\\begingroup" || undefined,
-            };
+            } as const satisfies ParseNode<"ordgroup">;
         } else {
             // If there exists a function with this name, parse the function.
             // Otherwise, just return a nucleus
@@ -917,7 +911,7 @@ export default class Parser {
      * Parse a single symbol out of the string. Here, we handle single character
      * symbols and special functions like \verb.
      */
-    parseSymbol(): AnyParseNode | null | undefined {
+    parseSymbol(): AnyParseNode | null {
         const nucleus = this.fetch();
         let text = nucleus.text;
 

package/src/Settings.ts

@@ -8,7 +8,7 @@ import {protocolFromUrl} from "./utils";
 import ParseError from "./ParseError";
 import {Token} from "./Token";
 
-import type {AnyParseNode} from "./parseNode";
+import type {AnyParseNode} from "./types/nodes";
 import type {MacroMap} from "./defineMacro";
 
 export type StrictFunction =

package/src/SourceLocation.ts

@@ -25,8 +25,8 @@ export default class SourceLocation {
      * - Otherwise, returns null.
      */
     static range(
-        first?: {loc?: SourceLocation | null | undefined},
-        second?: {loc?: SourceLocation | null | undefined},
+        first: {loc?: SourceLocation | null},
+        second?: {loc?: SourceLocation | null},
     ): SourceLocation | null | undefined {
         if (!second) {
             return first && first.loc;

package/src/buildCommon.ts

@@ -12,11 +12,10 @@ import {calculateSize, makeEm} from "./units";
 import {DocumentFragment} from "./tree";
 
 import type Options from "./Options";
-import type {ParseNode} from "./parseNode";
-import type {Mode} from "./types";
+import type {Measurement, Mode} from "./types";
+import type {ParseNode} from "./types/nodes";
 import type {documentFragment as HtmlDocumentFragment} from "./domTree";
 import type {HtmlDomNode, DomSpan, SvgSpan, CssStyle} from "./domTree";
-import type {Measurement} from "./units";
 import type {
     CharacterMetrics,
     FontName,
@@ -167,11 +166,12 @@ const boldSymbol = function(
 /**
  * Makes either a mathord or textord in the correct font and color.
  */
-export const makeOrd = function<NODETYPE extends "spacing" | "mathord" | "textord">(
-    group: ParseNode<NODETYPE>,
+export const makeOrd = function(
+    group: ParseNode<"spacing"> | ParseNode<"mathord"> | ParseNode<"textord">,
     options: Options,
-    type: "mathord" | "textord",
 ): HtmlDocumentFragment | SymbolNode {
+    // Spacing nodes are rendered as textord.
+    const type: "mathord" | "textord" = group.type === "mathord" ? "mathord" : "textord";
     const mode = group.mode;
     const text = group.text;
     const classes = ["mord"];

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",

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"]);

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";
 
 /**