katex 0.16.32 → 0.16.34

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

@@ -1,4 +1,3 @@
-// @flow
 /* eslint no-constant-condition:0 */
 import functions from "./functions";
 import MacroExpander, {implicitCommands} from "./MacroExpander";
@@ -58,7 +57,7 @@ export default class Parser {
     gullet: MacroExpander;
     settings: Settings;
     leftrightDepth: number;
-    nextToken: ?Token;
+    nextToken: Token | null;
 
     constructor(input: string, settings: Settings) {
         // Start in math mode
@@ -70,13 +69,14 @@ export default class Parser {
         this.settings = settings;
         // Count leftright depth (for \middle errors)
         this.leftrightDepth = 0;
+        this.nextToken = null;
     }
 
     /**
      * Checks a result to make sure it has the right type, and throws an
      * appropriate error otherwise.
      */
-    expect(text: string, consume?: boolean = true) {
+    expect(text: string, consume = true) {
         if (this.fetch().text !== text) {
             throw new ParseError(
                 `Expected '${text}', got '${this.fetch().text}'`, this.fetch()
@@ -235,20 +235,21 @@ export default class Parser {
         let funcName;
 
         for (let i = 0; i < body.length; i++) {
-            if (body[i].type === "infix") {
+            const node = body[i];
+            if (node.type === "infix") {
                 if (overIndex !== -1) {
                     throw new ParseError(
                         "only one infix operator per group",
-                        body[i].token);
+                        node.token);
                 }
                 overIndex = i;
-                funcName = body[i].replaceWith;
+                funcName = node.replaceWith;
             }
         }
 
         if (overIndex !== -1 && funcName) {
-            let numerNode;
-            let denomNode;
+            let numerNode: AnyParseNode;
+            let denomNode: AnyParseNode;
 
             const numerBody = body.slice(0, overIndex);
             const denomBody = body.slice(overIndex + 1);
@@ -290,7 +291,7 @@ export default class Parser {
         this.consumeSpaces(); // ignore spaces before sup/subscript argument
 
         // Skip over allowed internal nodes such as \relax
-        let group: ?AnyParseNode;
+        let group: AnyParseNode | null | undefined;
         do {
             group = this.parseGroup(name);
         } while (group?.type === "internal");
@@ -310,19 +311,18 @@ export default class Parser {
      * contained within a color node whose color is determined by errorColor
      */
     formatUnsupportedCmd(text: string): UnsupportedCmdParseNode {
-        const textordArray = [];
+        const textordArray: ParseNode<"textord">[] = [];
 
         for (let i = 0; i < text.length; i++) {
             textordArray.push({type: "textord", mode: "text", text: text[i]});
         }
 
-        const textNode = {
+        const textNode: ParseNode<"text"> = {
             type: "text",
             mode: this.mode,
             body: textordArray,
         };
-
-        const colorNode = {
+        const colorNode: ParseNode<"color"> = {
             type: "color",
             mode: this.mode,
             color: this.settings.errorColor,
@@ -335,7 +335,7 @@ export default class Parser {
     /**
      * Parses a group with optional super/subscripts.
      */
-    parseAtom(breakOnTokenText?: BreakToken): ?AnyParseNode {
+    parseAtom(breakOnTokenText?: BreakToken): AnyParseNode | null | undefined {
         // 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);
@@ -353,8 +353,8 @@ export default class Parser {
 
         // Note that base may be empty (i.e. null) at this point.
 
-        let superscript;
-        let subscript;
+        let superscript: AnyParseNode | null | undefined;
+        let subscript: AnyParseNode | null | undefined;
         while (true) {
             // Guaranteed in math mode, so eat any spaces first.
             this.consumeSpaces();
@@ -395,10 +395,11 @@ export default class Parser {
                 if (superscript) {
                     throw new ParseError("Double superscript", lex);
                 }
-                const prime = {type: "textord", mode: this.mode, text: "\\prime"};
+
+                const prime: ParseNode<"textord"> = {type: "textord", mode: this.mode, text: "\\prime"};
 
                 // Many primes can be grouped together, so we handle this here
-                const primes = [prime];
+                const primes: AnyParseNode[] = [prime];
                 this.consume();
                 // Keep lexing tokens until we get something that's not a prime
                 while (this.fetch().text === "'") {
@@ -466,7 +467,7 @@ export default class Parser {
     parseFunction(
         breakOnTokenText?: BreakToken,
         name?: string, // For determining its context
-    ): ?AnyParseNode {
+    ): AnyParseNode | null | undefined {
         const token = this.fetch();
         const func = token.text;
         const funcData = functions[func];
@@ -497,7 +498,7 @@ export default class Parser {
     callFunction(
         name: string,
         args: AnyParseNode[],
-        optArgs: (?AnyParseNode)[],
+        optArgs: (AnyParseNode | null | undefined)[],
         token?: Token,
         breakOnTokenText?: BreakToken,
     ): AnyParseNode {
@@ -520,31 +521,32 @@ export default class Parser {
      */
     parseArguments(
         func: string,   // Should look like "\name" or "\begin{name}".
-        funcData: FunctionSpec<*> | EnvSpec<*>,
+        funcData: FunctionSpec<any> | EnvSpec<any>,
     ): {
-        args: AnyParseNode[],
-        optArgs: (?AnyParseNode)[],
+        args: AnyParseNode[];
+        optArgs: (AnyParseNode | null | undefined)[];
     } {
         const totalArgs = funcData.numArgs + funcData.numOptionalArgs;
         if (totalArgs === 0) {
             return {args: [], optArgs: []};
         }
 
-        const args = [];
-        const optArgs = [];
+        const args: AnyParseNode[] = [];
+        const optArgs: (AnyParseNode | null | undefined)[] = [];
 
         for (let i = 0; i < totalArgs; i++) {
             let argType = funcData.argTypes && funcData.argTypes[i];
             const isOptional = i < funcData.numOptionalArgs;
 
-            if ((funcData.primitive && argType == null) ||
+            if (("primitive" in funcData && funcData.primitive && argType == null) ||
                 // \sqrt expands into primitive if optional argument doesn't exist
-                (funcData.type === "sqrt" && i === 1 && optArgs[0] == null)) {
+                (funcData.type === "sqrt" && i === 1 && optArgs[0] == null)
+            ) {
                 argType = "primitive";
             }
 
             const arg = this.parseGroupOfType(`argument to '${func}'`,
-                argType, isOptional);
+                argType as ArgType | null | undefined, isOptional);
             if (isOptional) {
                 optArgs.push(arg);
             } else if (arg != null) {
@@ -562,9 +564,9 @@ export default class Parser {
      */
     parseGroupOfType(
         name: string,
-        type: ?ArgType,
+        type: ArgType | null | undefined,
         optional: boolean,
-    ): ?AnyParseNode {
+    ): AnyParseNode | null | undefined {
         switch (type) {
             case "color":
                 return this.parseColorGroup(optional);
@@ -630,13 +632,13 @@ export default class Parser {
     parseStringGroup(
         modeName: ArgType,  // Used to describe the mode in error messages.
         optional: boolean,
-    ): ?Token {
+    ): Token | null | undefined {
         const argToken = this.gullet.scanArgument(optional);
         if (argToken == null) {
             return null;
         }
         let str = "";
-        let nextToken;
+        let nextToken: Token;
         while ((nextToken = this.fetch()).text !== "EOF") {
             str += nextToken.text;
             this.consume();
@@ -658,7 +660,7 @@ export default class Parser {
         const firstToken = this.fetch();
         let lastToken = firstToken;
         let str = "";
-        let nextToken;
+        let nextToken: Token;
         while ((nextToken = this.fetch()).text !== "EOF" &&
                regex.test(str + nextToken.text)) {
             lastToken = nextToken;
@@ -676,7 +678,7 @@ export default class Parser {
     /**
      * Parses a color description.
      */
-    parseColorGroup(optional: boolean): ?ParseNode<"color-token"> {
+    parseColorGroup(optional: boolean): ParseNode<"color-token"> | null | undefined {
         const res = this.parseStringGroup("color", optional);
         if (res == null) {
             return null;
@@ -694,6 +696,7 @@ export default class Parser {
             // Predefined color names are all missed by this RegEx pattern.
             color = "#" + color;
         }
+
         return {
             type: "color-token",
             mode: this.mode,
@@ -704,8 +707,8 @@ export default class Parser {
     /**
      * Parses a size specification, consisting of magnitude and unit.
      */
-    parseSizeGroup(optional: boolean): ?ParseNode<"size"> {
-        let res;
+    parseSizeGroup(optional: boolean): ParseNode<"size"> | null | undefined {
+        let res: Token | null | undefined;
         let isBlank = false;
         // don't expand before parseStringGroup
         this.gullet.consumeSpaces();
@@ -736,6 +739,7 @@ export default class Parser {
         if (!validUnit(data)) {
             throw new ParseError("Invalid unit: '" + data.unit + "'", res);
         }
+
         return {
             type: "size",
             mode: this.mode,
@@ -748,7 +752,7 @@ 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"> {
+    parseUrlGroup(optional: boolean): ParseNode<"url"> | null | undefined {
         this.gullet.lexer.setCatcode("%", 13); // active character
         this.gullet.lexer.setCatcode("~", 12); // other character
         const res = this.parseStringGroup("url", optional);
@@ -772,7 +776,7 @@ export default class Parser {
     /**
      * Parses an argument with the mode specified.
      */
-    parseArgumentGroup(optional: boolean, mode?: Mode): ?ParseNode<"ordgroup"> {
+    parseArgumentGroup(optional: boolean, mode?: Mode): ParseNode<"ordgroup"> | null | undefined {
         const argToken = this.gullet.scanArgument(optional);
         if (argToken == null) {
             return null;
@@ -787,7 +791,7 @@ export default class Parser {
         // TODO: find an alternative way to denote the end
         this.expect("EOF"); // expect the end of the argument
         this.gullet.endGroup();
-        const result = {
+        const result: ParseNode<"ordgroup"> = {
             type: "ordgroup",
             mode: this.mode,
             loc: argToken.loc,
@@ -809,11 +813,11 @@ export default class Parser {
     parseGroup(
         name: string, // For error reporting.
         breakOnTokenText?: BreakToken,
-    ): ?AnyParseNode {
+    ): AnyParseNode | null | undefined {
         const firstToken = this.fetch();
         const text = firstToken.text;
 
-        let result;
+        let result: AnyParseNode | null | undefined;
         // Try to parse an open brace or \begingroup
         if (text === "{" || text === "\\begingroup") {
             this.consume();
@@ -866,14 +870,21 @@ export default class Parser {
         let n = group.length - 1;
         for (let i = 0; i < n; ++i) {
             const a = group[i];
-            // $FlowFixMe: Not every node type has a `text` property.
+            if (a.type !== "textord") {
+                continue;
+            }
             const v = a.text;
-            if (v === "-" && group[i + 1].text === "-") {
-                if (i + 1 < n && group[i + 2].text === "-") {
+            const next = group[i + 1];
+            if (!next || next.type !== "textord") {
+                continue;
+            }
+            if (v === "-" && next.text === "-") {
+                const afterNext = group[i + 2];
+                if (i + 1 < n && afterNext && afterNext.type === "textord" && afterNext.text === "-") {
                     group.splice(i, 3, {
                         type: "textord",
                         mode: "text",
-                        loc: SourceLocation.range(a, group[i + 2]),
+                        loc: SourceLocation.range(a, afterNext),
                         text: "---",
                     });
                     n -= 2;
@@ -881,17 +892,17 @@ export default class Parser {
                     group.splice(i, 2, {
                         type: "textord",
                         mode: "text",
-                        loc: SourceLocation.range(a, group[i + 1]),
+                        loc: SourceLocation.range(a, next),
                         text: "--",
                     });
                     n -= 1;
                 }
             }
-            if ((v === "'" || v === "`") && group[i + 1].text === v) {
+            if ((v === "'" || v === "`") && next.text === v) {
                 group.splice(i, 2, {
                     type: "textord",
                     mode: "text",
-                    loc: SourceLocation.range(a, group[i + 1]),
+                    loc: SourceLocation.range(a, next),
                     text: v + v,
                 });
                 n -= 1;
@@ -903,7 +914,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 {
+    parseSymbol(): AnyParseNode | null | undefined {
         const nucleus = this.fetch();
         let text = nucleus.text;
 
@@ -921,6 +932,7 @@ export default class Parser {
                     please report what input caused this bug`);
             }
             arg = arg.slice(1, -1);  // remove first and last char
+
             return {
                 type: "verb",
                 mode: "text",
@@ -963,8 +975,8 @@ export default class Parser {
             const loc = SourceLocation.range(nucleus);
             let s: SymbolParseNode;
             if (ATOMS.hasOwnProperty(group)) {
-                // $FlowFixMe
-                const family: Atom = group;
+                // TODO(ts)
+                const family = group as Atom;
                 s = {
                     type: "atom",
                     mode: this.mode,
@@ -973,15 +985,15 @@ export default class Parser {
                     text,
                 };
             } else {
-                // $FlowFixMe
+                // TODO(ts)
                 s = {
-                    type: group,
+                    type: group as Exclude<SymbolParseNode["type"], "atom">,
                     mode: this.mode,
                     loc,
                     text,
                 };
             }
-            // $FlowFixMe
+            // TODO(ts)
             symbol = s;
         } else if (text.charCodeAt(0) >= 0x80) { // no symbol for e.g. ^
             if (this.settings.strict) {
@@ -1033,12 +1045,12 @@ export default class Parser {
                     label: command,
                     isStretchy: false,
                     isShifty: true,
-                    // $FlowFixMe
+                    // TODO(ts)
                     base: symbol,
                 };
             }
         }
-        // $FlowFixMe
+        // TODO(ts)
         return symbol;
     }
 }

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

@@ -1,4 +1,3 @@
-// @flow
 /* eslint no-console:0 */
 /**
  * This is a module for storing settings passed into KaTeX. It correctly handles
@@ -14,50 +13,52 @@ import type {MacroMap} from "./defineMacro";
 
 export type StrictFunction =
     (errorCode: string, errorMsg: string, token?: Token | AnyParseNode) =>
-    ?(boolean | string);
+    (boolean | string) | null | undefined;
 
 export type TrustContextTypes = {
-    "\\href": {|
-        command: "\\href",
-        url: string,
-        protocol?: string,
-    |},
-    "\\includegraphics": {|
-        command: "\\includegraphics",
-        url: string,
-        protocol?: string,
-    |},
-    "\\url": {|
-        command: "\\url",
-        url: string,
-        protocol?: string,
-    |},
-    "\\htmlClass": {|
-        command: "\\htmlClass",
-        class: string,
-    |},
-    "\\htmlId": {|
-        command: "\\htmlId",
-        id: string,
-    |},
-    "\\htmlStyle": {|
-        command: "\\htmlStyle",
-        style: string,
-    |},
-    "\\htmlData": {|
-        command: "\\htmlData",
-        attributes: {[string]: string},
-    |},
+    "\\href": {
+        command: "\\href";
+        url: string;
+        protocol?: string;
+    };
+    "\\includegraphics": {
+        command: "\\includegraphics";
+        url: string;
+        protocol?: string;
+    };
+    "\\url": {
+        command: "\\url";
+        url: string;
+        protocol?: string;
+    };
+    "\\htmlClass": {
+        command: "\\htmlClass";
+        class: string;
+    };
+    "\\htmlId": {
+        command: "\\htmlId";
+        id: string;
+    };
+    "\\htmlStyle": {
+        command: "\\htmlStyle";
+        style: string;
+    };
+    "\\htmlData": {
+        command: "\\htmlData";
+        attributes: Record<string, string>;
+    };
 };
-export type AnyTrustContext = $Values<TrustContextTypes>;
-export type TrustFunction = (context: AnyTrustContext) => ?boolean;
+export type AnyTrustContext = TrustContextTypes[keyof TrustContextTypes];
+export type TrustFunction = (context: AnyTrustContext) => boolean | null | undefined;
+export type SettingsOptions = Partial<Settings>;
 
-export type SettingsOptions = $Shape<Settings>;
+type EnumType = {
+    enum: string[];
+};
 
-type EnumType = {| enum: string[] |};
 type Type = "boolean" | "string" | "number" | "object" | "function" | EnumType;
 type Schema = {
-    [$Keys<SettingsOptions>]: {
+    [key in keyof SettingsOptions]?: {
         /**
          * Allowed type(s) of the value.
          */
@@ -76,7 +77,7 @@ type Schema = {
         /**
          * The function to process the option.
          */
-        processor?: (any) => any,
+        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
@@ -96,10 +97,12 @@ type Schema = {
          * The custom argument processor for the CLI. See Commander.js docs for
          * more information.
          */
-        cliProcessor?: (any, any) => any;
+        cliProcessor?: (arg0: any, arg1: any) => any;
     };
 };
 
+type SchemaEntry = NonNullable<Schema[keyof SettingsOptions]>;
+
 // TODO: automatically generate documentation
 // TODO: check all properties on Settings exist
 // TODO: check the type of a property on Settings matches
@@ -205,8 +208,8 @@ export const SETTINGS_SCHEMA: Schema = {
     },
 };
 
-function getDefaultValue(schema): any {
-    if (schema.default) {
+function getDefaultValue(schema: SchemaEntry): any {
+    if ("default" in schema) {
         return schema.default;
     }
     const type = schema.type;
@@ -237,34 +240,31 @@ function getDefaultValue(schema): any {
  *                 and is placed in a block with vertical margin.
  */
 export default class Settings {
-    displayMode: boolean;
-    output: "html" | "mathml" | "htmlAndMathml";
-    leqno: boolean;
-    fleqn: boolean;
-    throwOnError: boolean;
-    errorColor: string;
-    macros: MacroMap;
-    minRuleThickness: number;
-    colorIsTextColor: boolean;
-    strict: boolean | "ignore" | "warn" | "error" | StrictFunction;
-    trust: boolean | TrustFunction;
-    maxSize: number;
-    maxExpand: number;
-    globalGroup: boolean;
+    displayMode!: boolean;
+    output!: "html" | "mathml" | "htmlAndMathml";
+    leqno!: boolean;
+    fleqn!: boolean;
+    throwOnError!: boolean;
+    errorColor!: string;
+    macros!: MacroMap;
+    minRuleThickness!: number;
+    colorIsTextColor!: boolean;
+    strict!: boolean | "ignore" | "warn" | "error" | StrictFunction;
+    trust!: boolean | TrustFunction;
+    maxSize!: number;
+    maxExpand!: number;
+    globalGroup!: boolean;
 
-    constructor(options: SettingsOptions) {
+    constructor(options: SettingsOptions = {}) {
         // allow null options
         options = options || {};
-        for (const prop in SETTINGS_SCHEMA) {
-            if (SETTINGS_SCHEMA.hasOwnProperty(prop)) {
-                // $FlowFixMe
-                const schema = SETTINGS_SCHEMA[prop];
-                // TODO: validate options
-                // $FlowFixMe
-                this[prop] = options[prop] !== undefined ? (schema.processor
-                        ? schema.processor(options[prop]) : options[prop])
-                    : getDefaultValue(schema);
-            }
+        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);
         }
     }
 
@@ -274,7 +274,7 @@ export default class Settings {
      */
     reportNonstrict(errorCode: string, errorMsg: string,
                     token?: Token | AnyParseNode) {
-        let strict = this.strict;
+        let strict: Settings["strict"] | ReturnType<StrictFunction> = this.strict;
         if (typeof strict === "function") {
             // Allow return value of strict function to be boolean or string
             // (or null/undefined, meaning no further processing).
@@ -307,7 +307,7 @@ export default class Settings {
      */
     useStrictBehavior(errorCode: string, errorMsg: string,
                       token?: Token | AnyParseNode): boolean {
-        let strict = this.strict;
+        let strict: Settings["strict"] | ReturnType<StrictFunction> = this.strict;
         if (typeof strict === "function") {
             // Allow return value of strict function to be boolean or string
             // (or null/undefined, meaning no further processing).
@@ -345,7 +345,7 @@ export default class Settings {
      * get added by this function (changing the specified object).
      */
     isTrusted(context: AnyTrustContext): boolean {
-        if (context.url && !context.protocol) {
+        if ("url" in context && context.url && !context.protocol) {
             const protocol = protocolFromUrl(context.url);
             if (protocol == null) {
                 return false;

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

@@ -1,4 +1,3 @@
-// @flow
 import type {LexerInterface} from "./Token";
 
 /**
@@ -7,9 +6,9 @@ import type {LexerInterface} from "./Token";
  */
 export default class SourceLocation {
     // The + prefix indicates that these fields aren't writeable
-    +lexer: LexerInterface; // Lexer holding the input string.
-    +start: number;         // Start offset, zero-based inclusive.
-    +end: number;           // End offset, zero-based exclusive.
+    readonly lexer: LexerInterface; // Lexer holding the input string.
+    readonly start: number;         // Start offset, zero-based inclusive.
+    readonly end: number;           // End offset, zero-based exclusive.
 
     constructor(lexer: LexerInterface, start: number, end: number) {
         this.lexer = lexer;
@@ -26,9 +25,9 @@ export default class SourceLocation {
      * - Otherwise, returns null.
      */
     static range(
-        first?: {loc: ?SourceLocation},
-        second?: {loc: ?SourceLocation},
-    ): ?SourceLocation {
+        first?: {loc?: SourceLocation | null | undefined},
+        second?: {loc?: SourceLocation | null | undefined},
+    ): SourceLocation | null | undefined {
         if (!second) {
             return first && first.loc;
         } else if (!first || !first.loc || !second.loc ||

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

@@ -1,4 +1,3 @@
-// @flow
 /**
  * This file contains information and classes for the various kinds of styles
  * used in TeX. It provides a generic `Style` class, which holds information
@@ -123,8 +122,8 @@ const text = [D, Dc, T, Tc, T, Tc, T, Tc];
 
 // We only export some of the styles.
 export default {
-    DISPLAY: (styles[D]: Style),
-    TEXT: (styles[T]: Style),
-    SCRIPT: (styles[S]: Style),
-    SCRIPTSCRIPT: (styles[SS]: Style),
+    DISPLAY: (styles[D] as Style),
+    TEXT: (styles[T] as Style),
+    SCRIPT: (styles[S] as Style),
+    SCRIPTSCRIPT: (styles[SS] as Style),
 };