katex 0.16.44 → 0.16.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "katex",
-  "version": "0.16.44",
+  "version": "0.16.46",
   "description": "Fast math typesetting for the web.",
   "main": "dist/katex.js",
   "types": "types/katex.d.ts",
@@ -58,7 +58,6 @@
   "packageManager": "yarn@4.1.1",
   "devDependencies": {
     "@babel/core": "^7.29.0",
-    "@babel/eslint-parser": "^7.28.6",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
     "@babel/plugin-transform-react-jsx": "^7.28.6",
     "@babel/plugin-transform-runtime": "^7.29.0",
@@ -67,13 +66,16 @@
     "@babel/preset-typescript": "^7.28.5",
     "@babel/register": "^7.28.6",
     "@babel/runtime": "^7.28.6",
+    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/js": "^10.0.1",
     "@rollup/plugin-babel": "^5.3.1",
     "@rollup/plugin-commonjs": "^28.0.9",
     "@rollup/plugin-typescript": "^12.3.0",
     "@semantic-release/changelog": "^6.0.1",
     "@semantic-release/git": "^10.0.1",
-    "@typescript-eslint/eslint-plugin": "^8.56.0",
-    "@typescript-eslint/parser": "^8.56.0",
+    "@stylistic/stylelint-plugin": "^5.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.59.1",
+    "@typescript-eslint/parser": "^8.59.1",
     "babel-jest": "^30.2.0",
     "babel-loader": "^8.2.5",
     "babel-plugin-istanbul": "^6.1.1",
@@ -85,12 +87,11 @@
     "caniuse-lite": "^1.0.30001384",
     "css-loader": "^6.7.1",
     "cssnano": "^5.1.13",
-    "eslint": "^8.23.0",
-    "eslint-import-resolver-webpack": "^0.13.10",
+    "eslint": "^10.0.3",
     "eslint-plugin-actions": "^2.0.0",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-react": "^7.31.1",
+    "eslint-plugin-react": "^7.37.5",
     "fs-extra": "^10.1.0",
+    "globals": "^17.6.0",
     "got": "^11.8.5",
     "husky": "^4.3.8",
     "istanbul-lib-coverage": "^3.2.0",
@@ -113,7 +114,6 @@
     "postcss-loader": "^7.0.1",
     "postcss-preset-env": "^7.8.0",
     "postcss-scss": "^4.0.9",
-    "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
     "rollup": "^2.79.2",
     "sass": "^1.94.2",
@@ -122,16 +122,16 @@
     "semantic-release": "^19.0.5",
     "sri-toolbox": "^0.2.0",
     "style-loader": "^3.3.1",
-    "stylelint": "^14.11.0",
-    "stylelint-config-standard": "^28.0.0",
-    "stylelint-scss": "^6.3.2",
+    "stylelint": "^17.9.1",
+    "stylelint-config-standard": "^40.0.0",
+    "stylelint-scss": "^7.0.0",
     "terser-webpack-plugin": "^5.3.6",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "webpack": "^5.74.0",
-    "webpack-bundle-analyzer": "^4.6.1",
-    "webpack-cli": "^4.10.0",
-    "webpack-dev-server": "^4.10.1",
+    "webpack-bundle-analyzer": "^5.0.0",
+    "webpack-cli": "^5.0.0",
+    "webpack-dev-server": "^5.0.0",
     "webpack-remove-empty-scripts": "^1.0.4"
   },
   "bin": "cli.js",

package/src/Options.ts

@@ -6,8 +6,8 @@
  */
 
 import {getGlobalMetrics} from "./fontMetrics";
-import type {FontMetrics} from "./fontMetrics";
 import type {StyleInterface} from "./Style";
+import type {FontMetrics, MathFont, TextFont, FontWeight, FontShape} from "./types/fonts";
 
 const sizeStyleMap = [
     // Each element contains [textsize, scriptsize, scriptscriptsize].
@@ -35,18 +35,14 @@ const sizeAtStyle = function(size: number, style: StyleInterface): number {
     return style.size < 2 ? size : sizeStyleMap[size - 1][style.size - 1];
 };
 
-// In these types, "" (empty string) means "no change".
-export type FontWeight = "textbf" | "textmd" | "";
-export type FontShape = "textit" | "textup" | "";
-
 export type OptionsData = {
     style: StyleInterface;
     color?: string | undefined;
     size?: number;
     textSize?: number;
     phantom?: boolean;
-    font?: string;
-    fontFamily?: string;
+    font?: MathFont;
+    fontFamily?: TextFont;
     fontWeight?: FontWeight;
     fontShape?: FontShape;
     sizeMultiplier?: number;
@@ -70,8 +66,8 @@ class Options {
     // A font family applies to a group of fonts (i.e. SansSerif), while a font
     // represents a specific font (i.e. SansSerif Bold).
     // See: https://tex.stackexchange.com/questions/22350/difference-between-textrm-and-mathrm
-    font: string;
-    fontFamily: string;
+    font: MathFont;
+    fontFamily: TextFont;
     fontWeight: FontWeight;
     fontShape: FontShape;
     sizeMultiplier: number;
@@ -92,8 +88,8 @@ class Options {
         this.phantom = !!data.phantom;
         this.font = data.font || "";
         this.fontFamily = data.fontFamily || "";
-        this.fontWeight = data.fontWeight || '';
-        this.fontShape = data.fontShape || '';
+        this.fontWeight = data.fontWeight || "";
+        this.fontShape = data.fontShape || "";
         this.sizeMultiplier = sizeMultipliers[this.size - 1];
         this.maxSize = data.maxSize;
         this.minRuleThickness = data.minRuleThickness;
@@ -171,8 +167,11 @@ class Options {
     havingBaseStyle(style: StyleInterface): Options {
         style = style || this.style.text();
         const wantSize = sizeAtStyle(Options.BASESIZE, style);
-        if (this.size === wantSize && this.textSize === Options.BASESIZE
-            && this.style === style) {
+        if (
+            this.size === wantSize &&
+            this.textSize === Options.BASESIZE &&
+            this.style === style
+        ) {
             return this;
         } else {
             return this.extend({
@@ -191,14 +190,14 @@ class Options {
         switch (this.style.id) {
             case 4:
             case 5:
-                size = 3;  // normalsize in scriptstyle
+                size = 3; // normalsize in scriptstyle
                 break;
             case 6:
             case 7:
-                size = 1;  // normalsize in scriptscriptstyle
+                size = 1; // normalsize in scriptscriptstyle
                 break;
             default:
-                size = 6;  // normalsize in textstyle or displaystyle
+                size = 6; // normalsize in textstyle or displaystyle
         }
         return this.extend({
             style: this.style.text(),
@@ -228,20 +227,15 @@ class Options {
      * Creates a new options object with the given math font or old text font.
      * @type {[type]}
      */
-    withFont(font: string): Options {
-        return this.extend({
-            font,
-        });
+    withFont(font: MathFont): Options {
+        return this.extend({font});
     }
 
     /**
      * Create a new options objects with the given fontFamily.
      */
-    withTextFontFamily(fontFamily: string): Options {
-        return this.extend({
-            fontFamily,
-            font: "",
-        });
+    withTextFontFamily(fontFamily: TextFont): Options {
+        return this.extend({fontFamily, font: ""});
     }
 
     /**
@@ -270,7 +264,11 @@ class Options {
      */
     sizingClasses(oldOptions: Options): Array<string> {
         if (oldOptions.size !== this.size) {
-            return ["sizing", "reset-size" + oldOptions.size, "size" + this.size];
+            return [
+                "sizing",
+                "reset-size" + oldOptions.size,
+                "size" + this.size,
+            ];
         } else {
             return [];
         }
@@ -282,7 +280,11 @@ class Options {
      */
     baseSizingClasses(): Array<string> {
         if (this.size !== Options.BASESIZE) {
-            return ["sizing", "reset-size" + this.size, "size" + Options.BASESIZE];
+            return [
+                "sizing",
+                "reset-size" + this.size,
+                "size" + Options.BASESIZE,
+            ];
         } else {
             return [];
         }
@@ -298,7 +300,6 @@ class Options {
         return this._fontMetrics;
     }
 
-
     /**
      * Gets the CSS color of the current options object
      */

package/src/Parser.ts

@@ -1,7 +1,8 @@
 /* eslint no-constant-condition:0 */
 import functions from "./functions";
 import MacroExpander, {implicitCommands} from "./MacroExpander";
-import symbols, {ATOMS, extraLatin} from "./symbols";
+import symbols, {extraLatin} from "./symbols";
+import {isAtom} from "./atoms";
 import {validUnit} from "./units";
 import {supportedCodepoint} from "./unicodeScripts";
 import ParseError from "./ParseError";
@@ -15,9 +16,9 @@ import {Token} from "./Token";
 import unicodeAccents from /*preval*/ "./unicodeAccents";
 import unicodeSymbols from /*preval*/ "./unicodeSymbols";
 
-import type {ParseNode, AnyParseNode, SymbolParseNode, UnsupportedCmdParseNode}
-    from "./parseNode";
-import type {Atom, Group} from "./symbols";
+import type {NodeType, ParseNode, AnyParseNode, SymbolParseNode,
+    UnsupportedCmdParseNode} from "./parseNode";
+import type {Group} from "./atoms";
 import type {Mode, ArgType, BreakToken} from "./types";
 import type {FunctionContext, FunctionSpec} from "./defineFunction";
 import type {EnvSpec} from "./defineEnvironment";
@@ -521,7 +522,7 @@ export default class Parser {
      */
     parseArguments(
         func: string,   // Should look like "\name" or "\begin{name}".
-        funcData: FunctionSpec<any> | EnvSpec<any>,
+        funcData: FunctionSpec<NodeType> | EnvSpec<NodeType>,
     ): {
         args: AnyParseNode[];
         optArgs: (AnyParseNode | null | undefined)[];
@@ -579,13 +580,15 @@ export default class Parser {
                 return this.parseArgumentGroup(optional, type);
             case "hbox": {
                 // hbox argument type wraps the argument in the equivalent of
-                // \hbox, which is like \text but switching to \textstyle size.
+                // \hbox, which is like \text but switching to \textstyle size
+                // and resetting math font.
                 const group = this.parseArgumentGroup(optional, "text");
                 return group != null ? {
                     type: "styling",
                     mode: group.mode,
                     body: [group],
                     style: "text", // simulate \textstyle
+                    resetFont: true,
                 } : null;
             }
             case "raw": {
@@ -974,26 +977,22 @@ export default class Parser {
             const group: Group = symbols[this.mode][text].group;
             const loc = SourceLocation.range(nucleus);
             let s: SymbolParseNode;
-            if (ATOMS.hasOwnProperty(group)) {
-                // TODO(ts)
-                const family = group as Atom;
+            if (isAtom(group)) {
                 s = {
                     type: "atom",
                     mode: this.mode,
-                    family,
+                    family: group,
                     loc,
                     text,
                 };
             } else {
-                // TODO(ts)
                 s = {
-                    type: group as Exclude<SymbolParseNode["type"], "atom">,
+                    type: group,
                     mode: this.mode,
                     loc,
                     text,
                 };
             }
-            // TODO(ts)
             symbol = s;
         } else if (text.charCodeAt(0) >= 0x80) { // no symbol for e.g. ^
             if (this.settings.strict) {
@@ -1045,12 +1044,10 @@ export default class Parser {
                     label: command,
                     isStretchy: false,
                     isShifty: true,
-                    // TODO(ts)
                     base: symbol,
                 };
             }
         }
-        // TODO(ts)
         return symbol;
     }
 }

package/src/Settings.ts

@@ -52,56 +52,144 @@ export type AnyTrustContext = TrustContextTypes[keyof TrustContextTypes];
 export type TrustFunction = (context: AnyTrustContext) => boolean | null | undefined;
 export type SettingsOptions = Partial<Settings>;
 
-type EnumType = {
-    enum: string[];
+type EnumType<T extends string = string> = {
+    enum: T[];
 };
 
 type Type = "boolean" | "string" | "number" | "object" | "function" | EnumType;
-type Schema = {
-    [key in keyof SettingsOptions]?: {
-        /**
-         * Allowed type(s) of the value.
-         */
-        type: Type | Type[];
-        /**
-         * The default value. If not specified, false for boolean, an empty string
-         * for string, 0 for number, an empty object for object, or the first item
-         * for enum will be used. If multiple types are allowed, the first allowed
-         * type will be used for determining the default value.
-         */
-        default?: any;
-        /**
-         * The description.
-         */
-        description?: string;
-        /**
-         * The function to process the option.
-         */
-        processor?: (arg0: any) => any;
-        /**
-         * The command line argument. See Commander.js docs for more information.
-         * If not specified, the name prefixed with -- will be used. Set false not
-         * to add to the CLI.
-         */
-        cli?: string | false;
-        /**
-         * The default value for the CLI.
-         */
-        cliDefault?: any;
-        /**
-         * The description for the CLI. If not specified, the description for the
-         * option will be used.
-         */
-        cliDescription?: string;
-        /**
-         * The custom argument processor for the CLI. See Commander.js docs for
-         * more information.
-         */
-        cliProcessor?: (arg0: any, arg1: any) => any;
-    };
+/**
+ * Union of all values that appear as schema defaults, cliDefaults, or
+ * cliProcessor return values.  StrictFunction / TrustFunction are
+ * option-value types, not default/schema values, so they are excluded.
+ */
+type SettingsValue = boolean | string | number | MacroMap | string[];
+type DefaultValue = Exclude<SettingsValue, string[]>;
+
+type SchemaMetadata<K extends keyof SettingsOptions> = {
+    /**
+     * The description.
+     */
+    description?: string;
+    /**
+     * The function to process the option.
+     */
+    processor?: (value: Settings[K]) => Settings[K];
+    /**
+     * The command line argument. See Commander.js docs for more information.
+     * If not specified, the name prefixed with -- will be used. Set false not
+     * to add to the CLI.
+     */
+    cli?: string | false;
+    /**
+     * The default value for the CLI.
+     */
+    cliDefault?: SettingsValue;
+    /**
+     * The description for the CLI. If not specified, the description for the
+     * option will be used.
+     */
+    cliDescription?: string;
+    /**
+     * The custom argument processor for the CLI. See Commander.js docs for
+     * more information. Signature varies per setting (e.g. parseFloat,
+     * or (def, defs) => defs.push(def) for macros).
+     */
+    cliProcessor?: (...args: any[]) => SettingsValue;
+};
+
+type BooleanSchema<K extends keyof SettingsOptions> = SchemaMetadata<K> & {
+    /**
+     * Allowed type(s) of the value.
+     */
+    type: "boolean";
+    /**
+     * The default value. If not specified, false will be used.
+     */
+    default?: Extract<Settings[K], boolean>;
+};
+
+type StringSchema<K extends keyof SettingsOptions> = SchemaMetadata<K> & {
+    /**
+     * Allowed type(s) of the value.
+     */
+    type: "string";
+    /**
+     * The default value. If not specified, an empty string will be used.
+     */
+    default?: Extract<Settings[K], string>;
+};
+
+type NumberSchema<K extends keyof SettingsOptions> = SchemaMetadata<K> & {
+    /**
+     * Allowed type(s) of the value.
+     */
+    type: "number";
+    /**
+     * The default value. If not specified, 0 will be used.
+     */
+    default?: Extract<Settings[K], number>;
+};
+
+type ObjectSchema<K extends keyof SettingsOptions> = SchemaMetadata<K> & {
+    /**
+     * Allowed type(s) of the value.
+     */
+    type: "object";
+    /**
+     * The default value. If not specified, an empty object will be used.
+     */
+    default?: Extract<Settings[K], MacroMap>;
+};
+
+type FunctionSchema<K extends keyof SettingsOptions> = SchemaMetadata<K> & {
+    /**
+     * Allowed type(s) of the value.
+     */
+    type: "function";
+    /**
+     * Settings do not currently use function-valued defaults.
+     */
+    default?: never;
+};
+
+type EnumSchema<K extends keyof SettingsOptions> = SchemaMetadata<K> & {
+    /**
+     * Allowed type(s) of the value.
+     */
+    type: EnumType<Extract<Settings[K], string>>;
+    /**
+     * The default value. If not specified, the first enum value will be used.
+     */
+    default?: Extract<Settings[K], string>;
+};
+
+type SingleTypeSchema<K extends keyof SettingsOptions> =
+    | BooleanSchema<K>
+    | StringSchema<K>
+    | NumberSchema<K>
+    | ObjectSchema<K>
+    | FunctionSchema<K>
+    | EnumSchema<K>;
+
+type MultiTypeSchema<K extends keyof SettingsOptions> = SchemaMetadata<K> & {
+    /**
+     * Allowed type(s) of the value.
+     */
+    type: [SingleTypeSchema<K>["type"], ...Array<SingleTypeSchema<K>["type"]>];
+    /**
+     * The default value. If not specified, the first allowed type determines
+     * the default value.
+     */
+    default?: Extract<Settings[K], DefaultValue>;
 };
 
-type SchemaEntry = NonNullable<Schema[keyof SettingsOptions]>;
+type SchemaEntry<K extends keyof SettingsOptions> =
+    | SingleTypeSchema<K>
+    | MultiTypeSchema<K>;
+
+type Schema = {
+    [key in keyof SettingsOptions]?: SchemaEntry<key>;
+};
 
 // TODO: automatically generate documentation
 // TODO: check all properties on Settings exist
@@ -208,16 +296,18 @@ export const SETTINGS_SCHEMA: Schema = {
     },
 };
 
-function getDefaultValue(schema: SchemaEntry): any {
-    if ("default" in schema) {
-        return schema.default;
-    }
-    const type = schema.type;
-    const defaultType = Array.isArray(type) ? type[0] : type;
-    if (typeof defaultType !== 'string') {
-        return defaultType.enum[0];
+function getImplicitDefault(type: "boolean"): boolean;
+function getImplicitDefault(type: "string"): string;
+function getImplicitDefault(type: "number"): number;
+function getImplicitDefault(type: "object"): MacroMap;
+function getImplicitDefault(type: "function"): never;
+function getImplicitDefault<T extends string>(type: EnumType<T>): T;
+function getImplicitDefault(type: Type): DefaultValue;
+function getImplicitDefault(type: Type): DefaultValue {
+    if (typeof type !== 'string') {
+        return type.enum[0];
     }
-    switch (defaultType) {
+    switch (type) {
         case 'boolean':
             return false;
         case 'string':
@@ -226,9 +316,37 @@ function getDefaultValue(schema: SchemaEntry): any {
             return 0;
         case 'object':
             return {};
+        default:
+            throw new Error(
+                "Unexpected schema type; settings must declare an explicit default.");
     }
 }
 
+function getDefaultValue<K extends keyof SettingsOptions>(
+    schema: SchemaEntry<K>,
+): Settings[K];
+function getDefaultValue(schema: SchemaEntry<keyof SettingsOptions>): DefaultValue {
+    if (schema.default !== undefined) {
+        return schema.default;
+    }
+    const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+    return getImplicitDefault(type);
+}
+
+function applySetting<K extends keyof SettingsOptions>(
+    target: Settings,
+    prop: K,
+    options: SettingsOptions,
+    schema: SchemaEntry<K>,
+) {
+    const optionValue = options[prop];
+    target[prop] = optionValue !== undefined
+        ? (schema.processor
+            ? schema.processor(optionValue)
+            : optionValue)
+        : getDefaultValue(schema);
+}
+
 /**
  * The main Settings object
  *
@@ -259,12 +377,11 @@ export default class Settings {
         // allow null options
         options = options || {};
         for (const prop of Object.keys(SETTINGS_SCHEMA) as Array<keyof SettingsOptions>) {
-            const schema = SETTINGS_SCHEMA[prop] as SchemaEntry;
-            const optionValue = options[prop];
-            // TODO: validate options
-            (this as Record<string, unknown>)[prop] = optionValue !== undefined ?
-                (schema.processor ? schema.processor(optionValue) : optionValue)
-                : getDefaultValue(schema);
+            const schema = SETTINGS_SCHEMA[prop] as SchemaEntry<typeof prop> | undefined;
+            if (schema) {
+                // TODO: validate options
+                applySetting(this, prop, options, schema);
+            }
         }
     }
 

package/src/atoms.ts

@@ -0,0 +1,33 @@
+/**
+ * Small module for atom-group constants and type guard.  Kept separate from
+ * `symbols.ts` so that consumers (notably `contrib/render-a11y-string`) can
+ * pull in `isAtom` without dragging in the ~870-line symbol tables.
+ */
+
+// Some of these have a "-token" suffix since these are also used as `ParseNode`
+// types for raw text tokens, and we want to avoid conflicts with higher-level
+// `ParseNode` types. These `ParseNode`s are constructed within `Parser` by
+// looking up the `symbols` map.
+export const ATOMS = {
+    "bin": 1,
+    "close": 1,
+    "inner": 1,
+    "open": 1,
+    "punct": 1,
+    "rel": 1,
+};
+export const NON_ATOMS = {
+    "accent-token": 1,
+    "mathord": 1,
+    "op-token": 1,
+    "spacing": 1,
+    "textord": 1,
+};
+
+export type Atom = keyof typeof ATOMS;
+export type NonAtom = keyof typeof NON_ATOMS;
+export type Group = Atom | NonAtom;
+
+export function isAtom(value: string): value is Atom {
+    return value in ATOMS;
+}