katex 0.16.45 → 0.16.46

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/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.