katex 0.16.32 → 0.16.34

package/src/parseNode.ts

@@ -0,0 +1,522 @@
+import {NON_ATOMS} from "./symbols";
+import type SourceLocation from "./SourceLocation";
+import type {AlignSpec, ColSeparationType} from "./environments/array";
+import type {Atom} from "./symbols";
+import type {Mode, StyleStr} from "./types";
+import type {Token} from "./Token";
+import type {Measurement} from "./units";
+export type NodeType = keyof ParseNodeTypes;
+export type ParseNode<TYPE extends NodeType> = ParseNodeTypes[TYPE];
+
+// ParseNode's corresponding to Symbol `Group`s in symbols.js.
+export type SymbolParseNode =
+    ParseNode<"atom"> |
+    ParseNode<"accent-token"> |
+    ParseNode<"mathord"> |
+    ParseNode<"op-token"> |
+    ParseNode<"spacing"> |
+    ParseNode<"textord">;
+
+// ParseNode from `Parser.formatUnsupportedCmd`
+export type UnsupportedCmdParseNode = ParseNode<"color">;
+
+// Union of all possible `ParseNode<>` types.
+export type AnyParseNode = ParseNodeTypes[keyof ParseNodeTypes];
+
+// Map from `NodeType` to the corresponding `ParseNode`.
+type ParseNodeTypes = {
+    "array": {
+        type: "array";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        colSeparationType?: ColSeparationType;
+        hskipBeforeAndAfter?: boolean;
+        addJot?: boolean;
+        cols?: AlignSpec[];
+        arraystretch: number;
+        body: AnyParseNode[][];
+        // List of rows in the (2D) array.
+        rowGaps: (Measurement | null | undefined)[];
+        hLinesBeforeRow: Array<boolean[]>;
+            // Whether each row should be automatically numbered, or an explicit tag
+        tags?: (boolean | AnyParseNode[])[];
+        leqno?: boolean;
+        isCD?: boolean;
+    };
+    "cdlabel": {
+        type: "cdlabel";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        side: string;
+        label: AnyParseNode;
+    };
+    "cdlabelparent": {
+        type: "cdlabelparent";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        fragment: AnyParseNode;
+    };
+    "color": {
+        type: "color";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        color: string;
+        body: AnyParseNode[];
+    };
+    "color-token": {
+        type: "color-token";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        color: string;
+    };
+    // To avoid requiring run-time type assertions, this more carefully captures
+    // the requirements on the fields per the op.js htmlBuilder logic:
+    // - `body` and `value` are NEVER set simultaneously.
+    // - When `symbol` is true, `body` is set.
+    "op": {
+        type: "op";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        limits: boolean;
+        alwaysHandleSupSub?: boolean;
+        suppressBaseShift?: boolean;
+        parentIsSupSub: boolean;
+        symbol: boolean;
+        name: string;
+        body?: void;
+    } | {
+        type: "op";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        limits: boolean;
+        alwaysHandleSupSub?: boolean;
+        suppressBaseShift?: boolean;
+        parentIsSupSub: boolean;
+        symbol: false;
+        // If 'symbol' is true, `body` *must* be set.
+        name?: void;
+        body: AnyParseNode[];
+    };
+    "ordgroup": {
+        type: "ordgroup";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode[];
+        semisimple?: boolean;
+    };
+    "raw": {
+        type: "raw";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        string: string;
+    };
+    "size": {
+        type: "size";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        value: Measurement;
+        isBlank: boolean;
+    };
+    "styling": {
+        type: "styling";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        style: StyleStr;
+        body: AnyParseNode[];
+    };
+    "supsub": {
+        type: "supsub";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        base: AnyParseNode | null | undefined;
+        sup?: AnyParseNode | null | undefined;
+        sub?: AnyParseNode | null | undefined;
+    };
+    "tag": {
+        type: "tag";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode[];
+        tag: AnyParseNode[];
+    };
+    "text": {
+        type: "text";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode[];
+        font?: string;
+    };
+    "url": {
+        type: "url";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        url: string;
+    };
+    "verb": {
+        type: "verb";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: string;
+        star: boolean;
+    };
+    // From symbol groups, constructed in Parser.js via `symbols` lookup.
+    // (Some of these have "-token" suffix to distinguish them from existing
+    // `ParseNode` types.)
+    "atom": {
+        type: "atom";
+        family: Atom;
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        text: string;
+    };
+    "mathord": {
+        type: "mathord";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        text: string;
+    };
+    "spacing": {
+        type: "spacing";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        text: string;
+    };
+    "textord": {
+        type: "textord";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        text: string;
+    };
+    // These "-token" types don't have corresponding HTML/MathML builders.
+    "accent-token": {
+        type: "accent-token";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        text: string;
+    };
+    "op-token": {
+        type: "op-token";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        text: string;
+    };
+    // From functions.js and functions/*.js. See also "color", "op", "styling",
+    // and "text" above.
+    "accent": {
+        type: "accent";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        label: string;
+        isStretchy?: boolean;
+        isShifty?: boolean;
+        base: AnyParseNode;
+    };
+    "accentUnder": {
+        type: "accentUnder";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        label: string;
+        isStretchy?: boolean;
+        isShifty?: boolean;
+        base: AnyParseNode;
+    };
+    "cr": {
+        type: "cr";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        newLine: boolean;
+        size: Measurement | null | undefined;
+    };
+    "delimsizing": {
+        type: "delimsizing";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        size: 1 | 2 | 3 | 4;
+        mclass: "mopen" | "mclose" | "mrel" | "mord";
+        delim: string;
+    };
+    "enclose": {
+        type: "enclose";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        label: string;
+        backgroundColor?: string;
+        borderColor?: string;
+        body: AnyParseNode;
+    };
+    "environment": {
+        type: "environment";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        name: string;
+        nameGroup: AnyParseNode;
+    };
+    "font": {
+        type: "font";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        font: string;
+        body: AnyParseNode;
+    };
+    "genfrac": {
+        type: "genfrac";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        continued: boolean;
+        numer: AnyParseNode;
+        denom: AnyParseNode;
+        hasBarLine: boolean;
+        leftDelim: string | null | undefined;
+        rightDelim: string | null | undefined;
+        barSize: Measurement | null;
+    };
+    "hbox": {
+        type: "hbox";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode[];
+    };
+    "horizBrace": {
+        type: "horizBrace";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        label: string;
+        isOver: boolean;
+        base: AnyParseNode;
+    };
+    "href": {
+        type: "href";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        href: string;
+        body: AnyParseNode[];
+    };
+    "html": {
+        type: "html";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        attributes: Record<string, string>;
+        body: AnyParseNode[];
+    };
+    "htmlmathml": {
+        type: "htmlmathml";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        html: AnyParseNode[];
+        mathml: AnyParseNode[];
+    };
+    "includegraphics": {
+        type: "includegraphics";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        alt: string;
+        width: Measurement;
+        height: Measurement;
+        totalheight: Measurement;
+        src: string;
+    };
+    "infix": {
+        type: "infix";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        replaceWith: string;
+        size?: Measurement;
+        token: Token | null | undefined;
+    };
+    "internal": {
+        type: "internal";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+    };
+    "kern": {
+        type: "kern";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        dimension: Measurement;
+    };
+    "lap": {
+        type: "lap";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        alignment: string;
+        body: AnyParseNode;
+    };
+    "leftright": {
+        type: "leftright";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode[];
+        left: string;
+        right: string;
+        rightColor: string | null | undefined; // undefined means "inherit"
+    };
+    "leftright-right": {
+        type: "leftright-right";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        delim: string;
+        color: string | null | undefined; // undefined means "inherit"
+    };
+    "mathchoice": {
+        type: "mathchoice";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        display: AnyParseNode[];
+        text: AnyParseNode[];
+        script: AnyParseNode[];
+        scriptscript: AnyParseNode[];
+    };
+    "middle": {
+        type: "middle";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        delim: string;
+    };
+    "mclass": {
+        type: "mclass";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        mclass: string;
+        body: AnyParseNode[];
+        isCharacterBox: boolean;
+    };
+    "operatorname": {
+        type: "operatorname";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode[];
+        alwaysHandleSupSub: boolean;
+        limits: boolean;
+        parentIsSupSub: boolean;
+    };
+    "overline": {
+        type: "overline";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode;
+    };
+    "phantom": {
+        type: "phantom";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode[];
+    };
+    "hphantom": {
+        type: "hphantom";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode;
+    };
+    "vphantom": {
+        type: "vphantom";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode;
+    };
+    "pmb": {
+        type: "pmb";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        mclass: string;
+        body: AnyParseNode[];
+    };
+    "raisebox": {
+        type: "raisebox";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        dy: Measurement;
+        body: AnyParseNode;
+    };
+    "rule": {
+        type: "rule";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        shift: Measurement | null | undefined;
+        width: Measurement;
+        height: Measurement;
+    };
+    "sizing": {
+        type: "sizing";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        size: number;
+        body: AnyParseNode[];
+    };
+    "smash": {
+        type: "smash";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode;
+        smashHeight: boolean;
+        smashDepth: boolean;
+    };
+    "sqrt": {
+        type: "sqrt";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode;
+        index: AnyParseNode | null | undefined;
+    };
+    "underline": {
+        type: "underline";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode;
+    };
+    "vcenter": {
+        type: "vcenter";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        body: AnyParseNode;
+    };
+    "xArrow": {
+        type: "xArrow";
+        mode: Mode;
+        loc?: SourceLocation | null | undefined;
+        label: string;
+        body: AnyParseNode;
+        below: AnyParseNode | null | undefined;
+    };
+};
+
+/**
+ * Asserts that the node is of the given type and returns it with stricter
+ * typing. Throws if the node's type does not match.
+ */
+export function assertNodeType<NODETYPE extends NodeType>(
+    node: AnyParseNode | null | undefined,
+    type: NODETYPE,
+): ParseNode<NODETYPE> {
+    if (!node || node.type !== type) {
+        throw new Error(
+            `Expected node of type ${type}, but got ` +
+            (node ? `node of type ${node.type}` : String(node)));
+    }
+
+    return node as ParseNode<NODETYPE>;
+}
+
+/**
+ * Returns the node more strictly typed iff it is of the given type. Otherwise,
+ * returns null.
+ */
+export function assertSymbolNodeType(node: AnyParseNode | null | undefined): SymbolParseNode {
+    const typedNode = checkSymbolNodeType(node);
+    if (!typedNode) {
+        throw new Error(
+            `Expected node of symbol group type, but got ` +
+            (node ? `node of type ${node.type}` : String(node)));
+    }
+    return typedNode;
+}
+
+/**
+ * Returns the node more strictly typed iff it is of the given type. Otherwise,
+ * returns null.
+ */
+export function checkSymbolNodeType(node: AnyParseNode | null | undefined): SymbolParseNode | null | undefined {
+    if (node && (node.type === "atom" || NON_ATOMS.hasOwnProperty(node.type))) {
+        return node as SymbolParseNode;
+    }
+    return null;
+}

package/src/{parseTree.js → parseTree.ts}

@@ -1,4 +1,3 @@
-// @flow
 /**
  * Provides a single function for parsing an expression using a Parser
  * TODO(emily): Remove this
@@ -14,11 +13,14 @@ import type {AnyParseNode} from "./parseNode";
 /**
  * Parses an expression using a Parser, then returns the parsed result.
  */
-const parseTree = function(toParse: string, settings: Settings): AnyParseNode[] {
+const parseTree = function(
+    toParse: string | InstanceType<typeof String>,
+    settings: Settings,
+): AnyParseNode[] {
     if (!(typeof toParse === 'string' || toParse instanceof String)) {
         throw new TypeError('KaTeX can only parse string typed expression');
     }
-    const parser = new Parser(toParse, settings);
+    const parser = new Parser(toParse as string, settings);
 
     // Blank out any \df@tag to avoid spurious "Duplicate \tag" errors
     delete parser.gullet.macros.current["\\df@tag"];

package/src/{spacingData.js → spacingData.ts}

@@ -1,4 +1,3 @@
-// @flow
 /**
  * Describes spaces between different classes of atoms.
  */
@@ -22,19 +21,19 @@ const thickspace: Measurement = {
 // - https://github.com/facebook/flow/issues/5688
 // However, since *all* fields are optional, $Shape<> works as suggested in 5688
 // above.
-export type Spacings = $Shape<{
-    mord: Measurement,
-    mop: Measurement,
-    mbin: Measurement,
-    mrel: Measurement,
-    mopen: Measurement,
-    mclose: Measurement,
-    mpunct: Measurement,
-    minner: Measurement,
+export type Spacings = Partial<{
+    mord: Measurement;
+    mop: Measurement;
+    mbin: Measurement;
+    mrel: Measurement;
+    mopen: Measurement;
+    mclose: Measurement;
+    mpunct: Measurement;
+    minner: Measurement;
 }> & {};
 
 // Spacing relationships for display and text styles
-export const spacings: {[$Keys<Spacings>]: Spacings} = {
+export const spacings: {[key in keyof Spacings]?: Spacings} = {
     mord: {
         mop: thinspace,
         mbin: mediumspace,
@@ -87,7 +86,7 @@ export const spacings: {[$Keys<Spacings>]: Spacings} = {
 };
 
 // Spacing relationships for script and scriptscript styles
-export const tightSpacings: {[$Keys<Spacings>]: Spacings} = {
+export const tightSpacings: {[key in keyof Spacings]?: Spacings} = {
     mord: {
         mop: thinspace,
     },

package/src/{stretchy.js → stretchy.ts}

@@ -1,4 +1,3 @@
-// @flow
 /**
  * This file provides support to buildMathML.js and buildHTML.js
  * for stretchy wide elements rendered from SVG files
@@ -14,7 +13,7 @@ import type Options from "./Options";
 import type {ParseNode} from "./parseNode";
 import type {DomSpan, HtmlDomNode, SvgSpan} from "./domTree";
 
-const stretchyCodePoint: {[string]: string} = {
+const stretchyCodePoint: Record<string, string> = {
     widehat: "^",
     widecheck: "ˇ",
     widetilde: "~",
@@ -115,7 +114,7 @@ export const stretchyMathML = function(label: string): MathNode {
 // corresponds to 0.522 em inside the document.
 
 const katexImagesData: {
-    [string]: ([string[], number, number] | [[string], number, number, string])
+    [key: string]: ([string[], number, number] | [[string], number, number, string])
 } = {
                    //   path(s), minWidth, height, align
     overrightarrow: [["rightarrow"], 0.888, 522, "xMaxYMin"],
@@ -189,8 +188,8 @@ export const stretchySvg = function(
         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`.
-            // $FlowFixMe
-            const grp: ParseNode<"accent"> | ParseNode<"accentUnder"> = group;
+            // TODO(ts)
+            const grp = group as ParseNode<"accent"> | ParseNode<"accentUnder">;
             // There are four SVG images available for each function.
             // Choose a taller image when there are more characters.
             const numChars = grp.base.type === "ordgroup" ?
@@ -248,8 +247,9 @@ export const stretchySvg = function(
             let widthClasses;
             let aligns;
             if (numSvgChildren === 1) {
-                // $FlowFixMe: All these cases must be of the 4-tuple type.
-                const align1: string = data[3];
+                // TODO(ts): All these cases must be of the 4-tuple type.
+                const align1: string =
+                    (data as [[string], number, number, string])[3];
                 widthClasses = ["hide-tail"];
                 aligns = [align1];
             } else if (numSvgChildren === 2) {

package/src/styles/katex-swap.scss

@@ -1,7 +1,4 @@
-@use 'fonts.scss' with (
-  $font-display: swap,
-);
-
 @use 'katex' with (
+  $font-display: swap,
   $version: $version,
 );

package/src/styles/katex.scss

@@ -1,6 +1,15 @@
 /* stylelint-disable font-family-no-missing-generic-family-keyword */
 @use "sass:list";
 @use "sass:math";
+
+@forward "fonts.scss" with (
+    $font-folder: "../../fonts" !default,
+    $use-woff2: true !default,
+    $use-woff: true !default,
+    $use-ttf: true !default,
+    $font-display: block !default
+);
+
 @use "fonts.scss";
 
 // The mu unit is defined as 1/18 em

package/src/{svgGeometry.js → svgGeometry.ts}

@@ -1,4 +1,3 @@
-// @flow
 /**
  * This file provides support to domTree.js and delimiter.js.
  * It's a storehouse of path geometry for SVG images.
@@ -179,7 +178,7 @@ export const innerPath = function(name: string, height: number): string {
     }
 };
 
-export const path: {[string]: string} = {
+export const path: Record<string, string> = {
     // The doubleleftarrow geometry is from glyph U+21D0 in the font KaTeX Main
     doubleleftarrow: `M262 157
 l10-10c34-36 62.7-77 86-123 3.3-8 5-13.3 5-16 0-5.3-6.7-8-20-8-7.3

package/src/{symbols.js → symbols.ts}

@@ -1,4 +1,3 @@
-// @flow
 /**
  * This file holds a list of all no-argument functions and single-character
  * symbols (like 'a' or ';').
@@ -40,12 +39,13 @@ export const NON_ATOMS = {
     "textord": 1,
 };
 
-export type Atom = $Keys<typeof ATOMS>;
-export type NonAtom = $Keys<typeof NON_ATOMS>
+export type Atom = keyof typeof ATOMS;
+export type NonAtom = keyof typeof NON_ATOMS;
 export type Group = Atom | NonAtom;
-type CharInfoMap = {[string]: {font: Font, group: Group, replace: ?string}};
 
-const symbols: {[Mode]: CharInfoMap} = {
+type CharInfoMap = Record<string, {font: Font, group: Group, replace: string | null | undefined}>;
+
+const symbols: Record<Mode, CharInfoMap> = {
     "math": {},
     "text": {},
 };
@@ -56,7 +56,7 @@ export function defineSymbol(
     mode: Mode,
     font: Font,
     group: Group,
-    replace: ?string,
+    replace: string | null | undefined,
     name: string,
     acceptUnicodeChar?: boolean,
 ) {