katex 0.16.44 → 0.16.46

package/src/stretchy.ts

@@ -96,18 +96,6 @@ export const stretchyMathML = function(label: string): MathNode {
 //    Some functions, such as \cancel, need to vary their aspect ratio. These
 //    functions do not get the overflow SVG treatment.
 
-// Second Brush Stroke
-//    Low resolution monitors struggle to display images in fine detail.
-//    So browsers apply anti-aliasing. A long straight arrow shaft therefore
-//    will sometimes appear as if it has a blurred edge.
-
-//    To mitigate this, these SVG files contain a second "brush-stroke" on the
-//    arrow shafts. That is, a second long thin rectangular SVG path has been
-//    written directly on top of each arrow shaft. This reinforcement causes
-//    some of the screen pixels to display as black instead of the anti-aliased
-//    gray pixel that a  single path would generate. So we get arrow shafts
-//    whose edges appear to be sharper.
-
 // In the katexImagesData object just below, the dimensions all
 // correspond to path geometry inside the relevant SVG.
 // For example, \overrightarrow uses the same arrowhead as glyph U+2192
@@ -115,9 +103,9 @@ export const stretchyMathML = function(label: string): MathNode {
 // That is, inside the font, that arrowhead is 522 units tall, which
 // corresponds to 0.522 em inside the document.
 
-const katexImagesData: {
-    [key: string]: ([string[], number, number] | [[string], number, number, string])
-} = {
+type SvgData = [string[], number, number, string?];
+
+const katexImagesData: {[key: string]: SvgData} = {
                    //   path(s), minWidth, height, align
     overrightarrow: [["rightarrow"], 0.888, 522, "xMaxYMin"],
     overleftarrow: [["leftarrow"], 0.888, 522, "xMinYMin"],
@@ -189,15 +177,11 @@ export const stretchySvg = function(
     } {
         let viewBoxWidth = 400000;  // default
         const label = group.label.slice(1);
-        if (wideAccentLabels.has(label)) {
-            // Each type in the `if` statement corresponds to one of the ParseNode
-            // types below. This narrowing is required to access `grp.base`.
-            // TODO(ts)
-            const grp = group as ParseNode<"accent"> | ParseNode<"accentUnder">;
+        if (wideAccentLabels.has(label) && 'base' in group) {
             // There are four SVG images available for each function.
             // Choose a taller image when there are more characters.
-            const numChars = grp.base.type === "ordgroup" ?
-                grp.base.body.length : 1;
+            const numChars = group.base.type === "ordgroup" ?
+                group.base.body.length : 1;
             let viewBoxHeight;
             let pathName;
             let height;
@@ -244,6 +228,9 @@ export const stretchySvg = function(
             const spans = [];
 
             const data = katexImagesData[label];
+            if (!data) {
+                throw new Error(`No SVG data for "${label}".`);
+            }
             const [paths, minWidth, viewBoxHeight] = data;
             const height = viewBoxHeight / 1000;
 
@@ -251,11 +238,12 @@ export const stretchySvg = function(
             let widthClasses;
             let aligns;
             if (numSvgChildren === 1) {
-                // TODO(ts): All these cases must be of the 4-tuple type.
-                const align1: string =
-                    (data as [[string], number, number, string])[3];
+                if (data.length !== 4) {
+                    throw new Error(
+                        `Expected 4-tuple for single-path SVG data "${label}".`);
+                }
                 widthClasses = ["hide-tail"];
-                aligns = [align1];
+                aligns = [data[3]];
             } else if (numSvgChildren === 2) {
                 widthClasses = ["halfarrow-left", "halfarrow-right"];
                 aligns = ["xMinYMin", "xMaxYMin"];

package/src/styles/katex.scss

@@ -49,7 +49,7 @@ $display-margin: 1em 0 !default;
         /* Accessibility hack to only show to screen readers
          Found at: http://a11yproject.com/posts/how-to-hide-content/ */
         position: absolute;
-        clip: rect(1px, 1px, 1px, 1px);
+        clip-path: inset(50%);
         padding: 0;
         border: 0;
         height: 1px;
@@ -349,7 +349,9 @@ $display-margin: 1em 0 !default;
         > .root {
             /* These values are taken from the definition of `\r@@t`,
              `\mkern 5mu` and `\mkern -10mu`. */
+            /* stylelint-disable-next-line declaration-property-value-no-unknown */
             margin-left: calc(5*$mu);
+            /* stylelint-disable-next-line declaration-property-value-no-unknown */
             margin-right: calc(-10*$mu);
         }
     }

package/src/svgGeometry.ts

@@ -5,6 +5,19 @@
 
 // In all paths below, the viewBox-to-em scale is 1000:1.
 
+// Second Brush Stroke
+//    Low resolution monitors struggle to display images in fine detail.
+//    So browsers apply anti-aliasing. A long straight arrow shaft therefore
+//    will sometimes appear as if it has a blurred edge.
+
+//    To mitigate this, these SVG files contain a second "brush-stroke" on the
+//    arrow shafts. That is, a second long thin rectangular SVG path has been
+//    written directly on top of each arrow shaft. This reinforcement causes
+//    some of the screen pixels to display as black instead of the anti-aliased
+//    gray pixel that a  single path would generate. So we get arrow shafts
+//    whose edges appear to be sharper.
+const doubleBrushStroke = (svgPath: string): string => `${svgPath} ${svgPath}`;
+
 const hLinePad = 80;  // padding above a sqrt vinculum. Prevents image cropping.
 
 // The vinculum of a \sqrt can be made thicker by a KaTeX rendering option.
@@ -154,25 +167,25 @@ export const innerPath = function(name: string, height: number): string {
     // The inner part of stretchy tall delimiters
     switch (name) {
         case "\u239c":
-            return `M291 0 H417 V${height} H291z M291 0 H417 V${height} H291z`;
+            return doubleBrushStroke(`M291 0 H417 V${height} H291z`);
         case "\u2223":
-            return `M145 0 H188 V${height} H145z M145 0 H188 V${height} H145z`;
+            return doubleBrushStroke(`M145 0 H188 V${height} H145z`);
         case "\u2225":
-            return `M145 0 H188 V${height} H145z M145 0 H188 V${height} H145z` +
-                `M367 0 H410 V${height} H367z M367 0 H410 V${height} H367z`;
+            return doubleBrushStroke(`M145 0 H188 V${height} H145z`) +
+                doubleBrushStroke(`M367 0 H410 V${height} H367z`);
         case "\u239f":
-            return `M457 0 H583 V${height} H457z M457 0 H583 V${height} H457z`;
+            return doubleBrushStroke(`M457 0 H583 V${height} H457z`);
         case "\u23a2":
-            return `M319 0 H403 V${height} H319z M319 0 H403 V${height} H319z`;
+            return doubleBrushStroke(`M319 0 H403 V${height} H319z`);
         case "\u23a5":
-            return `M263 0 H347 V${height} H263z M263 0 H347 V${height} H263z`;
+            return doubleBrushStroke(`M263 0 H347 V${height} H263z`);
         case "\u23aa":
-            return `M384 0 H504 V${height} H384z M384 0 H504 V${height} H384z`;
+            return doubleBrushStroke(`M384 0 H504 V${height} H384z`);
         case "\u23d0":
-            return `M312 0 H355 V${height} H312z M312 0 H355 V${height} H312z`;
+            return doubleBrushStroke(`M312 0 H355 V${height} H312z`);
         case "\u2016":
-            return `M257 0 H300 V${height} H257z M257 0 H300 V${height} H257z` +
-            `M478 0 H521 V${height} H478z M478 0 H521 V${height} H478z`;
+            return doubleBrushStroke(`M257 0 H300 V${height} H257z`) +
+                doubleBrushStroke(`M478 0 H521 V${height} H478z`);
         default:
             return "";
     }
@@ -256,17 +269,13 @@ v40h399900v-40zM0 241v40h399900v-40zm0 0v40h399900v-40z`,
 -68.7 15.7-86 37-10 12-15 25.3-15 40 0 22.7 9.8 40.7 29.5 54 19.7 13.3 43.5 21
  71.5 23h399859zM103 281v-40h399897v40z`,
 
-    leftlinesegment: `M40 281 V428 H0 V94 H40 V241 H400000 v40z
-M40 281 V428 H0 V94 H40 V241 H400000 v40z`,
+    leftlinesegment: doubleBrushStroke(`M40 281 V428 H0 V94 H40 V241 H400000 v40z`),
 
-    leftbracketunder: `M0 0 h120 V290 H399995 v120 H0z
-M0 0 h120 V290 H399995 v120 H0z`,
+    leftbracketunder: doubleBrushStroke(`M0 0 h120 V290 H399995 v120 H0z`),
 
-    leftbracketover: `M0 440 h120 V150 H399995 v-120 H0z
-M0 440 h120 V150 H399995 v-120 H0z`,
+    leftbracketover: doubleBrushStroke(`M0 440 h120 V150 H399995 v-120 H0z`),
 
-    leftmapsto: `M40 281 V448H0V74H40V241H400000v40z
-M40 281 V448H0V74H40V241H400000v40z`,
+    leftmapsto: doubleBrushStroke(`M40 281 V448H0V74H40V241H400000v40z`),
 
     // tofrom is from glyph U+21C4 in font KaTeX AMS Regular
     leftToFrom: `M0 147h400000v40H0zm0 214c68 40 115.7 95.7 143 167h22c15.3 0 23
@@ -274,8 +283,7 @@ M40 281 V448H0V74H40V241H400000v40z`,
 c28.7-32 52-65.7 70-101 10.7-23.3 16-35.7 16-37 0-.7-7.7-1-23-1h-22C115.7 265.3
  68 321 0 361zm0-174v-40h399900v40zm100 154v40h399900v-40z`,
 
-    longequal: `M0 50 h400000 v40H0z m0 194h40000v40H0z
-M0 50 h400000 v40H0z m0 194h40000v40H0z`,
+    longequal: doubleBrushStroke(`M0 50 h400000 v40H0z m0 194h40000v40H0z`),
 
     midbrace: `M200428 334
 c-100.7-8.3-195.3-44-280-108-55.3-42-101.7-93-139-153l-9-14c-2.7 4-5.7 8.7-9 14
@@ -358,14 +366,11 @@ m0-194v40h400000v-40zm0 0v40h400000v-40z`,
 -13.3 8.7-20 26-20 38 0 71 11.2 99 33.5 0 0 7 5.6 21 16.7 14 11.2 21 33.5 21
  66.8s-14 61.2-42 83.5c-28 22.3-61 33.5-99 33.5L0 241z M0 281v-40h399859v40z`,
 
-    rightlinesegment: `M399960 241 V94 h40 V428 h-40 V281 H0 v-40z
-M399960 241 V94 h40 V428 h-40 V281 H0 v-40z`,
+    rightlinesegment: doubleBrushStroke(`M399960 241 V94 h40 V428 h-40 V281 H0 v-40z`),
 
-    rightbracketunder: `M399995 0 h-120 V290 H0 v120 H400000z
-M399995 0 h-120 V290 H0 v120 H400000z`,
+    rightbracketunder: doubleBrushStroke(`M399995 0 h-120 V290 H0 v120 H400000z`),
 
-    rightbracketover: `M399995 440 h-120 V150 H0 v-120 H399995z
-M399995 440 h-120 V150 H0 v-120 H399995z`,
+    rightbracketover: doubleBrushStroke(`M399995 440 h-120 V150 H0 v-120 H399995z`),
 
     rightToFrom: `M400000 167c-70.7-42-118-97.7-142-167h-23c-15.3 0-23 .3-23
  1 0 1.3 5.3 13.7 16 37 18 35.3 41.3 69 70 101l7 8H0v40h399905l-7 8c-28.7 32

package/src/symbols.ts

@@ -16,34 +16,19 @@
  * accepted in (e.g. "math" or "text").
  */
 
+import type {Group} from "./atoms";
 import type {Mode} from "./types";
+import type {SymbolFont} from "./types/fonts";
 
-type Font = "main" | "ams";
 // 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;
 
-type CharInfoMap = Record<string, {font: Font, group: Group, replace: string | null | undefined}>;
+type CharInfoMap = Record<
+    string,
+    {font: SymbolFont; group: Group; replace: string | null | undefined}
+>;
 
 const symbols: Record<Mode, CharInfoMap> = {
     "math": {},
@@ -54,9 +39,9 @@ export default symbols;
 /** `acceptUnicodeChar = true` is only applicable if `replace` is set. */
 export function defineSymbol(
     mode: Mode,
-    font: Font,
+    font: SymbolFont,
     group: Group,
-    replace: string | null | undefined,
+    replace: string,
     name: string,
     acceptUnicodeChar?: boolean,
 ) {
@@ -595,8 +580,8 @@ defineSymbol(text, main, spacing, "\u00a0", "\\ ");
 defineSymbol(text, main, spacing, "\u00a0", " ");
 defineSymbol(text, main, spacing, "\u00a0", "\\space");
 defineSymbol(text, main, spacing, "\u00a0", "\\nobreakspace");
-defineSymbol(math, main, spacing, null, "\\nobreak");
-defineSymbol(math, main, spacing, null, "\\allowbreak");
+defineSymbol(math, main, spacing, "", "\\nobreak");
+defineSymbol(math, main, spacing, "", "\\allowbreak");
 defineSymbol(math, main, punct, ",", ",");
 defineSymbol(math, main, punct, ";", ";");
 defineSymbol(math, ams, bin, "\u22bc", "\\barwedge", true);
@@ -799,7 +784,7 @@ defineSymbol(text, main, mathord, "h", "\u210E");
 // Mathematical Alphanumeric Symbols.
 // Some editors do not deal well with wide characters. So don't write the
 // string into this file. Instead, create the string from the surrogate pair.
-let wideChar = "";
+let wideChar;
 for (let i = 0; i < letters.length; i++) {
     const ch = letters.charAt(i);
 

package/src/tree.ts

@@ -8,6 +8,10 @@ export interface VirtualNode {
     toMarkup(): string;
 }
 
+function isMathDomNode(node: VirtualNode): node is MathDomNode {
+    return 'toText' in node;
+}
+
 
 /**
  * This node represents a document fragment, which contains elements, but when
@@ -64,10 +68,12 @@ export class DocumentFragment<ChildType extends VirtualNode>
      * MathDomNode's only.
      */
     toText(): string {
-        // To avoid this, we would subclass documentFragment separately for
-        // MathML, but polyfills for subclassing is expensive per PR 1469.
-        // TODO(ts): Only works for ChildType = MathDomNode.
-        const toText = (child: ChildType): string => (child as unknown as MathDomNode).toText();
-        return this.children.map(toText).join("");
+        return this.children.map((child: ChildType): string => {
+            if (isMathDomNode(child)) {
+                return child.toText();
+            }
+            throw new Error(
+                `Expected MathDomNode with toText, got ${child.constructor.name}`);
+        }).join("");
     }
 }

package/src/types/fonts.ts

@@ -0,0 +1,73 @@
+// Math font variants.
+export type FontVariant =
+    | "bold"
+    | "bold-italic"
+    | "bold-sans-serif"
+    | "double-struck"
+    | "fraktur"
+    | "italic"
+    | "monospace"
+    | "normal"
+    | "sans-serif"
+    | "sans-serif-bold-italic"
+    | "sans-serif-italic"
+    | "script";
+
+export type FontName =
+    | "AMS-Regular"
+    | "Caligraphic-Regular"
+    | "Fraktur-Regular"
+    | "Main-Bold"
+    | "Main-BoldItalic"
+    | "Main-Italic"
+    | "Main-Regular"
+    | "Math-BoldItalic"
+    | "Math-Italic"
+    | "SansSerif-Regular"
+    | "SansSerif-Bold"
+    | "SansSerif-Italic"
+    | "Script-Regular"
+    | "Size1-Regular"
+    | "Size2-Regular"
+    | "Size3-Regular"
+    | "Size4-Regular"
+    | "Typewriter-Regular";
+
+//[depth, height, italic, skew, width]
+export type CharacterMetricsTuple = [depth: number, height: number, italic: number, skew: number, width: number];
+
+export type CharacterMetrics = {
+    depth: number;
+    height: number;
+    italic: number;
+    skew: number;
+    width: number;
+};
+
+export type FontMetrics = {
+    cssEmPerMu: number;
+    [key: string]: number;
+};
+
+export type SymbolFont = "main" | "ams";
+
+export type MathFont =
+    | ""
+    | "mathrm"
+    | "mathit"
+    | "mathbf"
+    | "mathnormal"
+    | "mathsfit"
+    | "mathbb"
+    | "mathcal"
+    | "mathfrak"
+    | "mathscr"
+    | "mathsf"
+    | "mathtt"
+    | "boldsymbol";
+
+export type TextFont = "textrm" | "textsf" | "texttt" | "amsrm" | "";
+
+// In these types, "" (empty string) means "no change".
+export type FontWeight = "textbf" | "textmd" | "";
+export type FontShape = "textit" | "textup" | "";

package/src/{types.ts → types/index.ts}

@@ -1,9 +1,3 @@
-
-/**
- * This file consists only of basic types used in multiple places.
- * For types with javascript, create separate files by themselves.
- */
-
 export type Mode = "math" | "text";
 
 // LaTeX argument type.
@@ -29,7 +23,7 @@ export type StyleStr = "text" | "display" | "script" | "scriptscript";
 export type BreakToken = "]" | "}" | "\\endgroup" | "$" | "\\)" | "\\\\" | "\\end" |
     "EOF";
 
-// Math font variants.
-export type FontVariant = "bold" | "bold-italic" | "bold-sans-serif" |
-    "double-struck" | "fraktur" | "italic" | "monospace" | "normal" | "sans-serif" |
-    "sans-serif-bold-italic" | "sans-serif-italic" | "script";
+export type DelimiterSize = 1 | 2 | 3 | 4;
+
+export type Slice1<S extends string> =
+    S extends `${string}${infer Rest}` ? Rest : "";

package/src/utils.ts

@@ -70,7 +70,6 @@ export const protocolFromUrl = (url: string): string | null => {
     // Check for possible leading protocol.
     // https://url.spec.whatwg.org/#url-parsing strips leading whitespace
     // (U+20) or C0 control (U+00-U+1F) characters.
-    // eslint-disable-next-line no-control-regex
     const protocol = /^[\x00-\x20]*([^\\/#?]*?)(:|&#0*58|&#x0*3a|&colon)/i
     .exec(url);
     if (!protocol) {

package/src/wide-character.ts

@@ -6,101 +6,147 @@
  * the font information necessary to render it properly.
  */
 
-import type {Mode} from "./types";
 import ParseError from "./ParseError";
+import type {FontName} from "./types/fonts";
+
+type WideChar = {
+    readonly mathClass: string;
+    readonly textClass: string;
+    readonly font: Extract<FontName,
+        | "Main-Bold"
+        | "Math-Italic"
+        | "Main-BoldItalic"
+        | "Script-Regular"
+        | "Fraktur-Regular"
+        | "AMS-Regular"
+        | "SansSerif-Regular"
+        | "SansSerif-Bold"
+        | "SansSerif-Italic"
+        | "Typewriter-Regular"
+    > | "";
+};
+
+const boldUpright: WideChar = {
+    mathClass: "mathbf",
+    textClass: "textbf",
+    font: "Main-Bold",
+};
+const italic: WideChar = {
+    mathClass: "mathnormal",
+    textClass: "textit",
+    font: "Math-Italic",
+};
+const boldItalic: WideChar = {
+    mathClass: "boldsymbol",
+    textClass: "boldsymbol",
+    font: "Main-BoldItalic",
+};
+const script: WideChar = {
+    mathClass: "mathscr",
+    textClass: "textscr",
+    font: "Script-Regular",
+};
+const noFont: WideChar = {mathClass: "", textClass: "", font: ""};
+const fraktur: WideChar = {
+    mathClass: "mathfrak",
+    textClass: "textfrak",
+    font: "Fraktur-Regular",
+};
+const doubleStruck: WideChar = {
+    mathClass: "mathbb",
+    textClass: "textbb",
+    font: "AMS-Regular",
+};
+const boldFraktur: WideChar = {
+    mathClass: "mathboldfrak",
+    textClass: "textboldfrak",
+    font: "Fraktur-Regular",
+};
+const sansSerif: WideChar = {
+    mathClass: "mathsf",
+    textClass: "textsf",
+    font: "SansSerif-Regular",
+};
+const boldSansSerif: WideChar = {
+    mathClass: "mathboldsf",
+    textClass: "textboldsf",
+    font: "SansSerif-Bold",
+};
+const italicSansSerif: WideChar = {
+    mathClass: "mathitsf",
+    textClass: "textitsf",
+    font: "SansSerif-Italic",
+};
+const monospace: WideChar = {
+    mathClass: "mathtt",
+    textClass: "texttt",
+    font: "Typewriter-Regular",
+};
 
 /**
  * Data below is from https://www.unicode.org/charts/PDF/U1D400.pdf
  * That document sorts characters into groups by font type, say bold or italic.
  *
- * In the arrays below, each subarray consists three elements:
+ * In the arrays below, each object consists of three properties:
  *      * The CSS class of that group when in math mode.
  *      * The CSS class of that group when in text mode.
  *      * The font name, so that KaTeX can get font metrics.
  */
 
 const wideLatinLetterData = [
-    ["mathbf", "textbf", "Main-Bold"],                // A-Z bold upright
-    ["mathbf", "textbf", "Main-Bold"],                // a-z bold upright
-
-    ["mathnormal", "textit", "Math-Italic"],         // A-Z italic
-    ["mathnormal", "textit", "Math-Italic"],         // a-z italic
-
-    ["boldsymbol", "boldsymbol", "Main-BoldItalic"],  // A-Z bold italic
-    ["boldsymbol", "boldsymbol", "Main-BoldItalic"],  // a-z bold italic
-
+    boldUpright, boldUpright,  // A-Z, a-z
+    italic, italic,            // A-Z, a-z
+    boldItalic, boldItalic,   // A-Z, a-z
     // Map fancy A-Z letters to script, not calligraphic.
     // This aligns with unicode-math and math fonts (except Cambria Math).
-    ["mathscr", "textscr", "Script-Regular"],       // A-Z script
-    ["", "", ""],                                   // a-z script.  No font
-
-    ["", "", ""],                                   // A-Z bold script. No font
-    ["", "", ""],                                   // a-z bold script. No font
-
-    ["mathfrak", "textfrak", "Fraktur-Regular"],    // A-Z Fraktur
-    ["mathfrak", "textfrak", "Fraktur-Regular"],    // a-z Fraktur
-
-    ["mathbb", "textbb", "AMS-Regular"],            // A-Z double-struck
-    ["mathbb", "textbb", "AMS-Regular"],            // k double-struck
-
+    script, noFont, // A-Z script, a-z — no font
+    noFont, noFont, // A-Z bold script, a-z bold script — no font
+    fraktur, fraktur,          // A-Z, a-z
+    doubleStruck, doubleStruck, // A-Z double-struck, k double-struck
     // Note that we are using a bold font, but font metrics for regular Fraktur.
-    ["mathboldfrak", "textboldfrak", "Fraktur-Regular"],  // A-Z bold Fraktur
-    ["mathboldfrak", "textboldfrak", "Fraktur-Regular"],  // a-z bold Fraktur
-
-    ["mathsf", "textsf", "SansSerif-Regular"],      // A-Z sans-serif
-    ["mathsf", "textsf", "SansSerif-Regular"],      // a-z sans-serif
-
-    ["mathboldsf", "textboldsf", "SansSerif-Bold"], // A-Z bold sans-serif
-    ["mathboldsf", "textboldsf", "SansSerif-Bold"], // a-z bold sans-serif
-
-    ["mathitsf", "textitsf", "SansSerif-Italic"],   // A-Z italic sans-serif
-    ["mathitsf", "textitsf", "SansSerif-Italic"],   // a-z italic sans-serif
-
-    ["", "", ""],                              // A-Z bold italic sans. No font
-    ["", "", ""],                              // a-z bold italic sans. No font
-
-    ["mathtt", "texttt", "Typewriter-Regular"],     // A-Z monospace
-    ["mathtt", "texttt", "Typewriter-Regular"],     // a-z monospace
-] as const satisfies readonly (readonly [string, string, string])[];
+    boldFraktur, boldFraktur,  // A-Z, a-z
+    sansSerif, sansSerif,      // A-Z, a-z
+    boldSansSerif, boldSansSerif, // A-Z, a-z
+    italicSansSerif, italicSansSerif, // A-Z, a-z
+    noFont, noFont,           // A-Z bold italic sans, a-z bold italic sans - no font
+    monospace, monospace,     // A-Z, a-z
+] as const;
 
 const wideNumeralData = [
-    ["mathbf", "textbf", "Main-Bold"],                // 0-9 bold
-    ["", "", ""],                         // 0-9 double-struck. No KaTeX font.
-    ["mathsf", "textsf", "SansSerif-Regular"],        // 0-9 sans-serif
-    ["mathboldsf", "textboldsf", "SansSerif-Bold"],   // 0-9 bold sans-serif
-    ["mathtt", "texttt", "Typewriter-Regular"],       // 0-9 monospace
-] as const satisfies readonly (readonly [string, string, string])[];
+    boldUpright,      // 0-9
+    noFont,           // 0-9 double-struck. No KaTeX font.
+    sansSerif,        // 0-9
+    boldSansSerif,   // 0-9
+    monospace,       // 0-9
+] as const;
 
 export const wideCharacterFont = (
     wideChar: string,
-    mode: Mode,
-): [string, string] => {
+): WideChar => {
 
     // IE doesn't support codePointAt(). So work with the surrogate pair.
     const H = wideChar.charCodeAt(0);    // high surrogate
     const L = wideChar.charCodeAt(1);    // low surrogate
     const codePoint = ((H - 0xD800) * 0x400) + (L - 0xDC00) + 0x10000;
 
-    const j = mode === "math" ? 0 : 1;  // column index for CSS class.
-
     if (0x1D400 <= codePoint && codePoint < 0x1D6A4) {
         // wideLatinLetterData contains exactly 26 chars on each row.
         // So we can calculate the relevant row. No traverse necessary.
         const i = Math.floor((codePoint - 0x1D400) / 26);
-        return [wideLatinLetterData[i]![2], wideLatinLetterData[i]![j]];
+        return wideLatinLetterData[i];
 
     } else if (0x1D7CE <= codePoint && codePoint <= 0x1D7FF) {
         // Numerals, ten per row.
         const i = Math.floor((codePoint - 0x1D7CE) / 10);
-        return [wideNumeralData[i]![2], wideNumeralData[i]![j]];
+        return wideNumeralData[i];
 
     } else if (codePoint === 0x1D6A5 || codePoint === 0x1D6A6) {
         // dotless i or j
-        return [wideLatinLetterData[0][2], wideLatinLetterData[0][j]];
+        return wideLatinLetterData[0];
 
     } else if (0x1D6A6 < codePoint && codePoint < 0x1D7CE) {
         // Greek letters. Not supported, yet.
-        return ["", ""];
+        return noFont;
 
     } else {
         // We don't support any wide characters outside 1D400–1D7FF.