katex 0.16.32 → 0.16.34

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

@@ -1,4 +1,3 @@
-// @flow
 import type Parser from "./Parser";
 import type {ParseNode, AnyParseNode, NodeType, UnsupportedCmdParseNode}
     from "./parseNode";
@@ -9,95 +8,94 @@ import type {Token} from "./Token";
 import type {MathDomNode} from "./mathMLTree";
 
 /** Context provided to function handlers for error messages. */
-export type FunctionContext = {|
-    funcName: string,
-    parser: Parser,
-    token?: Token,
-    breakOnTokenText?: BreakToken,
-|};
-
-export type FunctionHandler<NODETYPE: NodeType> = (
+export type FunctionContext = {
+    funcName: string;
+    parser: Parser;
+    token?: Token;
+    breakOnTokenText?: BreakToken;
+};
+
+export type FunctionHandler<NODETYPE extends NodeType> = (
     context: FunctionContext,
     args: AnyParseNode[],
-    optArgs: (?AnyParseNode)[],
+    optArgs: (AnyParseNode | null | undefined)[],
 ) => UnsupportedCmdParseNode | ParseNode<NODETYPE>;
 // Note: reverse the order of the return type union will cause a flow error.
 // See https://github.com/facebook/flow/issues/3663.
 
-export type HtmlBuilder<NODETYPE> = (ParseNode<NODETYPE>, Options) => HtmlDomNode;
-export type MathMLBuilder<NODETYPE> = (
-    group: ParseNode<NODETYPE>,
-    options: Options,
-) => MathDomNode;
+export type HtmlBuilder<NODETYPE extends NodeType> =
+    (group: ParseNode<NODETYPE>, options: Options) => HtmlDomNode;
+export type MathMLBuilder<NODETYPE extends NodeType> =
+    (group: ParseNode<NODETYPE>, options: Options) => MathDomNode;
 
 // More general version of `HtmlBuilder` for nodes (e.g. \sum, accent types)
 // whose presence impacts super/subscripting. In this case, ParseNode<"supsub">
 // delegates its HTML building to the HtmlBuilder corresponding to these nodes.
-export type HtmlBuilderSupSub<NODETYPE> =
-    (ParseNode<"supsub"> | ParseNode<NODETYPE>, Options) => HtmlDomNode;
+export type HtmlBuilderSupSub<NODETYPE extends NodeType> =
+    (group: ParseNode<"supsub"> | ParseNode<NODETYPE>, options: Options) => HtmlDomNode;
 
 export type FunctionPropSpec = {
     // The number of arguments the function takes.
-    numArgs: number,
+    numArgs: number;
 
     // An array corresponding to each argument of the function, giving the
     // type of argument that should be parsed. Its length should be equal
     // to `numOptionalArgs + numArgs`, and types for optional arguments
     // should appear before types for mandatory arguments.
-    argTypes?: ArgType[],
+    argTypes?: ArgType[];
 
     // Whether it expands to a single token or a braced group of tokens.
     // If it's grouped, it can be used as an argument to primitive commands,
     // such as \sqrt (without the optional argument) and super/subscript.
-    allowedInArgument?: boolean,
+    allowedInArgument?: boolean;
 
     // Whether or not the function is allowed inside text mode
     // (default false)
-    allowedInText?: boolean,
+    allowedInText?: boolean;
 
     // Whether or not the function is allowed inside text mode
     // (default true)
-    allowedInMath?: boolean,
+    allowedInMath?: boolean;
 
     // (optional) The number of optional arguments the function
     // should parse. If the optional arguments aren't found,
     // `null` will be passed to the handler in their place.
     // (default 0)
-    numOptionalArgs?: number,
+    numOptionalArgs?: number;
 
     // Must be true if the function is an infix operator.
-    infix?: boolean,
+    infix?: boolean;
 
     // Whether or not the function is a TeX primitive.
-    primitive?: boolean,
+    primitive?: boolean;
 };
 
-type FunctionDefSpec<NODETYPE: NodeType> = {|
+type FunctionDefSpec<NODETYPE extends NodeType> = {
     // Unique string to differentiate parse nodes.
     // Also determines the type of the value returned by `handler`.
-    type: NODETYPE,
+    type: NODETYPE;
 
     // The first argument to defineFunction is a single name or a list of names.
     // All functions named in such a list will share a single implementation.
-    names: Array<string>,
+    names: Array<string>;
 
     // Properties that control how the functions are parsed.
-    props: FunctionPropSpec,
+    props: FunctionPropSpec;
 
     // The handler is called to handle these functions and their arguments and
     // returns a `ParseNode`.
-    handler: ?FunctionHandler<NODETYPE>,
+    handler: FunctionHandler<NODETYPE> | null | undefined;
 
     // This function returns an object representing the DOM structure to be
     // created when rendering the defined LaTeX function.
     // This should not modify the `ParseNode`.
-    htmlBuilder?: HtmlBuilder<NODETYPE>,
+    htmlBuilder?: HtmlBuilder<NODETYPE>;
 
     // This function returns an object representing the MathML structure to be
     // created when rendering the defined LaTeX function.
     // This should not modify the `ParseNode`.
-    mathmlBuilder?: MathMLBuilder<NODETYPE>,
-|};
+    mathmlBuilder?: MathMLBuilder<NODETYPE>;
+};
 
 /**
  * Final function spec for use at parse time.
@@ -106,16 +104,16 @@ type FunctionDefSpec<NODETYPE: NodeType> = {|
  * 2. requires all arguments except argTypes.
  * It is generated by `defineFunction()` below.
  */
-export type FunctionSpec<NODETYPE: NodeType> = {|
-    type: NODETYPE, // Need to use the type to avoid error. See NOTES below.
-    numArgs: number,
-    argTypes?: ArgType[],
-    allowedInArgument: boolean,
-    allowedInText: boolean,
-    allowedInMath: boolean,
-    numOptionalArgs: number,
-    infix: boolean,
-    primitive: boolean,
+export type FunctionSpec<NODETYPE extends NodeType> = {
+    type: NODETYPE; // Need to use the type to avoid error. See NOTES below.
+    numArgs: number;
+    argTypes?: ArgType[];
+    allowedInArgument: boolean;
+    allowedInText: boolean;
+    allowedInMath: boolean;
+    numOptionalArgs: number;
+    infix: boolean;
+    primitive: boolean;
 
     // FLOW TYPE NOTES: Doing either one of the following two
     //
@@ -132,29 +130,29 @@ export type FunctionSpec<NODETYPE: NodeType> = {|
     // _functions is typed FunctionSpec<*> (it stores all TeX function specs).
 
     // Must be specified unless it's handled directly in the parser.
-    handler: ?FunctionHandler<*>,
-|};
+    handler: FunctionHandler<any> | null | undefined;
+};
 
 /**
  * All registered functions.
  * `functions.js` just exports this same dictionary again and makes it public.
  * `Parser.js` requires this dictionary.
  */
-export const _functions: {[string]: FunctionSpec<*>} = {};
+export const _functions: Record<string, FunctionSpec<any>> = {};
 
 /**
  * All HTML builders. Should be only used in the `define*` and the `build*ML`
  * functions.
  */
-export const _htmlGroupBuilders: {[string]: HtmlBuilder<*>} = {};
+export const _htmlGroupBuilders: Record<string, HtmlBuilder<any>> = {};
 
 /**
  * All MathML builders. Should be only used in the `define*` and the `build*ML`
  * functions.
  */
-export const _mathmlGroupBuilders: {[string]: MathMLBuilder<*>} = {};
+export const _mathmlGroupBuilders: Record<string, MathMLBuilder<any>> = {};
 
-export default function defineFunction<NODETYPE: NodeType>({
+export default function defineFunction<NODETYPE extends NodeType>({
     type,
     names,
     props,
@@ -175,7 +173,7 @@ export default function defineFunction<NODETYPE: NodeType>({
         numOptionalArgs: props.numOptionalArgs || 0,
         infix: !!props.infix,
         primitive: !!props.primitive,
-        handler: handler,
+        handler,
     };
     for (let i = 0; i < names.length; ++i) {
         _functions[names[i]] = data;
@@ -195,13 +193,13 @@ export default function defineFunction<NODETYPE: NodeType>({
  * if the function's ParseNode is generated in Parser.js rather than via a
  * stand-alone handler provided to `defineFunction`).
  */
-export function defineFunctionBuilders<NODETYPE: NodeType>({
+export function defineFunctionBuilders<NODETYPE extends NodeType>({
     type, htmlBuilder, mathmlBuilder,
-}: {|
-    type: NODETYPE,
-    htmlBuilder?: HtmlBuilder<NODETYPE>,
-    mathmlBuilder: MathMLBuilder<NODETYPE>,
-|}) {
+}: {
+    type: NODETYPE;
+    htmlBuilder?: HtmlBuilder<NODETYPE>;
+    mathmlBuilder: MathMLBuilder<NODETYPE>;
+}) {
     defineFunction({
         type,
         names: [],

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

@@ -1,4 +1,3 @@
-// @flow
 
 import {Token} from "./Token";
 import type Namespace from "./Namespace";
@@ -53,13 +52,13 @@ export interface MacroContextInterface {
      * Fully expand the given macro name and return the resulting list of
      * tokens, or return `undefined` if no such macro is defined.
      */
-    expandMacro(name: string): Token[] | void;
+    expandMacro(name: string): Token[] | undefined;
 
     /**
      * Fully expand the given macro name and return the result as a string,
      * or return `undefined` if no such macro is defined.
      */
-    expandMacroAsText(name: string): string | void;
+    expandMacroAsText(name: string): string | undefined;
 
     /**
      * Fully expand the given token stream and return the resulting list of
@@ -72,7 +71,7 @@ export interface MacroContextInterface {
      * Consume an argument from the token stream, and return the resulting array
      * of tokens and start/end token.
      */
-    consumeArg(delims?: ?string[]): MacroArg;
+    consumeArg(delims?: string[] | null | undefined): MacroArg;
 
     /**
      * Consume the specified number of arguments from the token stream,
@@ -95,22 +94,22 @@ export interface MacroContextInterface {
 }
 
 export type MacroArg = {
-    tokens: Token[],
-    start: Token,
-    end: Token
+    tokens: Token[];
+    start: Token;
+    end: Token;
 };
 
 /** Macro tokens (in reverse order). */
 export type MacroExpansion = {
-    tokens: Token[],
-    numArgs: number,
-    delimiters?: string[][],
-    unexpandable?: boolean, // used in \let
+    tokens: Token[];
+    numArgs: number;
+    delimiters?: string[][];
+    unexpandable?: boolean; // used in \let
 };
 
 export type MacroDefinition = string | MacroExpansion |
-    (MacroContextInterface => (string | MacroExpansion));
-export type MacroMap = {[string]: MacroDefinition};
+    ((arg0: MacroContextInterface) => string | MacroExpansion);
+export type MacroMap = Record<string, MacroDefinition>;
 
 /**
  * All registered global/built-in macros.

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

@@ -1,4 +1,3 @@
-// @flow
 /**
  * This file deals with creating delimiters of various sizes. The TeXbook
  * discusses these routines on page 441-442, in the "Another subroutine sets box
@@ -39,6 +38,8 @@ import type {Mode} from "./types";
 import type {StyleInterface} from "./Style";
 import type {VListElem} from "./buildCommon";
 
+type StackedDelimiterFont = "Size1-Regular" | "Size4-Regular";
+
 /**
  * Get the metrics for a given symbol and font, after transformation (i.e.
  * after following replacement from symbols.js)
@@ -136,7 +137,7 @@ const mathrmSize = function(
  * Makes a large delimiter. This is a delimiter that comes in the Size1, Size2,
  * Size3, or Size4 fonts. It is always rendered in textstyle.
  */
-const makeLargeDelim = function(delim,
+const makeLargeDelim = function(delim: string,
     size: number,
     center: boolean,
     options: Options,
@@ -159,7 +160,7 @@ const makeLargeDelim = function(delim,
  */
 const makeGlyphSpan = function(
     symbol: string,
-    font: "Size1-Regular" | "Size4-Regular",
+    font: StackedDelimiterFont,
     mode: Mode,
 ): VListElem {
     let sizeClass;
@@ -206,7 +207,7 @@ const makeInner = function(
 
 // Helpers for makeStackedDelim
 const lapInEms = 0.008;
-const lap = {type: "kern", size: -1 * lapInEms};
+const lap: {type: "kern"; size: number} = {type: "kern", size: -1 * lapInEms};
 const verts = new Set(["|", "\\lvert", "\\rvert", "\\vert"]);
 const doubleVerts = new Set(["\\|", "\\lVert", "\\rVert", "\\Vert"]);
 
@@ -233,7 +234,7 @@ const makeStackedDelim = function(
     top = repeat = bottom = delim;
     middle = null;
     // Also keep track of what font the delimiters are in
-    let font = "Size1-Regular";
+    let font: StackedDelimiterFont = "Size1-Regular";
 
     // We set the parts and font based on the symbol. Note that we use
     // '\u23d0' instead of '|' and '\u2016' instead of '\\|' for the
@@ -388,7 +389,7 @@ const makeStackedDelim = function(
 
     // Now, we start building the pieces that will go into the vlist
     // Keep a list of the pieces of the stacked delimiter
-    const stack = [];
+    const stack: Array<VListElem | {type: "kern"; size: number}> = [];
 
     if (svgLabel.length > 0) {
         // Instead of stacking glyphs, create a single SVG.
@@ -649,7 +650,7 @@ type Delimiter =
     {type: "stack"};
 
 // Delimiters that never stack try small delimiters and large delimiters only
-const stackNeverDelimiterSequence = [
+const stackNeverDelimiterSequence: Delimiter[] = [
     {type: "small", style: Style.SCRIPTSCRIPT},
     {type: "small", style: Style.SCRIPT},
     {type: "small", style: Style.TEXT},
@@ -660,7 +661,7 @@ const stackNeverDelimiterSequence = [
 ];
 
 // Delimiters that always stack try the small delimiters first, then stack
-const stackAlwaysDelimiterSequence = [
+const stackAlwaysDelimiterSequence: Delimiter[] = [
     {type: "small", style: Style.SCRIPTSCRIPT},
     {type: "small", style: Style.SCRIPT},
     {type: "small", style: Style.TEXT},
@@ -669,7 +670,7 @@ const stackAlwaysDelimiterSequence = [
 
 // Delimiters that stack when large try the small and then large delimiters, and
 // stack afterwards
-const stackLargeDelimiterSequence = [
+const stackLargeDelimiterSequence: Delimiter[] = [
     {type: "small", style: Style.SCRIPTSCRIPT},
     {type: "small", style: Style.SCRIPT},
     {type: "small", style: Style.TEXT},
@@ -692,7 +693,8 @@ const delimTypeToFont = function(type: Delimiter): string {
     } else if (type.type === "stack") {
         return "Size4-Regular";
     } else {
-        throw new Error(`Add support for delim type '${type.type}' here.`);
+        const delimKind = (type as Delimiter).type;
+        throw new Error(`Add support for delim type '${delimKind}' here.`);
     }
 };
 
@@ -712,25 +714,25 @@ const traverseSequence = function(
     // at index 3-2=1, text starts at 3-1=2, and display starts at min(2,3-0)=2
     const start = Math.min(2, 3 - options.style.size);
     for (let i = start; i < sequence.length; i++) {
-        if (sequence[i].type === "stack") {
+        const delimType = sequence[i];
+        if (delimType.type === "stack") {
             // This is always the last delimiter, so we just break the loop now.
             break;
         }
 
-        const metrics = getMetrics(delim, delimTypeToFont(sequence[i]), "math");
+        const metrics = getMetrics(delim, delimTypeToFont(delimType), "math");
         let heightDepth = metrics.height + metrics.depth;
 
         // Small delimiters are scaled down versions of the same font, so we
         // account for the style change size.
-
-        if (sequence[i].type === "small") {
-            const newOptions = options.havingBaseStyle(sequence[i].style);
+        if (delimType.type === "small") {
+            const newOptions = options.havingBaseStyle(delimType.style);
             heightDepth *= newOptions.sizeMultiplier;
         }
 
         // Check if the delimiter at this size works for the given height.
         if (heightDepth > height) {
-            return sequence[i];
+            return delimType;
         }
     }
 
@@ -757,7 +759,7 @@ export const makeCustomSizedDelim = function(
     }
 
     // Decide what sequence to use
-    let sequence;
+    let sequence: Delimiter[];
     if (stackNeverDelimiters.has(delim)) {
         sequence = stackNeverDelimiterSequence;
     } else if (stackLargeDelimiters.has(delim)) {