katex 0.16.32 → 0.16.34

package/src/environments/{array.js → array.ts}

@@ -1,4 +1,3 @@
-// @flow
 import {makeFragment, makeLineSpan, makeSpan, makeVList} from "../buildCommon";
 import Style from "../Style";
 import defineEnvironment from "../defineEnvironment";
@@ -17,15 +16,22 @@ import * as mml from "../buildMathML";
 
 import type Parser from "../Parser";
 import type {ParseNode, AnyParseNode} from "../parseNode";
-import type {StyleStr} from "../types";
+import type {StyleStr, Mode} from "../types";
 import type {HtmlBuilder, MathMLBuilder} from "../defineFunction";
+import type {HtmlDomNode} from "../domTree";
+
+type EnvContextLike = {
+    parser: Parser;
+    envName: string;
+    mode: Mode;
+};
 
 // Data stored in the ParseNode associated with the environment.
-export type AlignSpec = { type: "separator", separator: string } | {
-    type: "align",
-    align: string,
-    pregap?: number,
-    postgap?: number,
+export type AlignSpec = {type: "separator", separator: string} | {
+    type: "align";
+    align: string;
+    pregap?: number;
+    postgap?: number;
 };
 
 // Type to indicate column separation in MathML
@@ -52,7 +58,7 @@ function getHLines(parser: Parser): boolean[] {
     return hlineInfo;
 }
 
-const validateAmsEnvironmentContext = context => {
+const validateAmsEnvironmentContext = (context: EnvContextLike) => {
     const settings = context.parser.settings;
     if (!settings.displayMode) {
         throw new ParseError(`{${context.envName}} can be used only in` +
@@ -67,7 +73,7 @@ const gatherEnvironments = new Set(["gather", "gather*"]);
 // * true: Automatic equation numbering, overridable by \tag
 // * false: Tags allowed on each row, but no automatic numbering
 // This function *doesn't* work with the "split" environment name.
-function getAutoTag(name): ?boolean {
+function getAutoTag(name: string): boolean | null | undefined {
     if (!name.includes("ed")) {
         return !name.includes("*");
     }
@@ -93,18 +99,18 @@ function parseArray(
         emptySingleRow,
         maxNumCols,
         leqno,
-    }: {|
-        hskipBeforeAndAfter?: boolean,
-        addJot?: boolean,
-        cols?: AlignSpec[],
-        arraystretch?: number,
-        colSeparationType?: ColSeparationType,
-        autoTag?: ?boolean,
-        singleRow?: boolean,
-        emptySingleRow?: boolean,
-        maxNumCols?: number,
-        leqno?: boolean,
-    |},
+    }: {
+        hskipBeforeAndAfter?: boolean;
+        addJot?: boolean;
+        cols?: AlignSpec[];
+        arraystretch?: number;
+        colSeparationType?: ColSeparationType;
+        autoTag?: boolean | null | undefined;
+        singleRow?: boolean;
+        emptySingleRow?: boolean;
+        maxNumCols?: number;
+        leqno?: boolean;
+    },
     style: StyleStr,
 ): ParseNode<"array"> {
     parser.gullet.beginGroup();
@@ -131,12 +137,12 @@ function parseArray(
     // Start group for first cell
     parser.gullet.beginGroup();
 
-    let row = [];
-    const body = [row];
+    let row: AnyParseNode[] = [];
+    const body: AnyParseNode[][] = [row];
     const rowGaps = [];
     const hLinesBeforeRow = [];
-
-    const tags = (autoTag != null ? [] : undefined);
+    const tags: Array<AnyParseNode[] | boolean> | undefined =
+        (autoTag != null ? [] : undefined);
 
     // amsmath uses \global\@eqnswtrue and \global\@eqnswfalse to represent
     // whether this row should have an equation number.  Simulate this with
@@ -164,14 +170,13 @@ function parseArray(
 
     while (true) {  // eslint-disable-line no-constant-condition
         // Parse each cell in its own group (namespace)
-        let cell = parser.parseExpression(false, singleRow ? "\\end" : "\\\\");
+        const cellBody = parser.parseExpression(false, singleRow ? "\\end" : "\\\\");
         parser.gullet.endGroup();
         parser.gullet.beginGroup();
-
-        cell = {
+        let cell: AnyParseNode = {
             type: "ordgroup",
             mode: parser.mode,
-            body: cell,
+            body: cellBody,
         };
         if (style) {
             cell = {
@@ -203,6 +208,7 @@ function parseArray(
             // empty row if it's the only one.
             // NOTE: Currently, `cell` is the last item added into `row`.
             if (row.length === 1 && cell.type === "styling" &&
+                cell.body.length === 1 && cell.body[0].type === "ordgroup" &&
                 cell.body[0].body.length === 0 &&
                 (body.length > 1 || !emptySingleRow)) {
                 body.pop();
@@ -258,10 +264,9 @@ function parseArray(
     };
 }
 
-
 // Decides on a style for cells in an array according to whether the given
 // environment name starts with the letter 'd'.
-function dCellStyle(envName): StyleStr {
+function dCellStyle(envName: string): StyleStr {
     if (envName.slice(0, 1) === "d") {
         return "display";
     } else {
@@ -270,10 +275,10 @@ function dCellStyle(envName): StyleStr {
 }
 
 type Outrow = {
-    [idx: number]: *,
-    height: number,
-    depth: number,
-    pos: number,
+    [idx: number]: any;
+    height: number;
+    depth: number;
+    pos: number;
 };
 
 const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
@@ -282,13 +287,12 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
     const nr = group.body.length;
     const hLinesBeforeRow = group.hLinesBeforeRow;
     let nc = 0;
-    let body = new Array(nr);
-    const hlines = [];
-
+    const body = new Array(nr);
+    const hlines: Array<{pos: number; isDashed: boolean}> = [];
     const ruleThickness = Math.max(
         // From LaTeX \showthe\arrayrulewidth. Equals 0.04 em.
-        (options.fontMetrics().arrayRuleWidth),
-        options.minRuleThickness,  // User override.
+        options.fontMetrics().arrayRuleWidth,
+        options.minRuleThickness, // User override.
     );
 
     // Horizontal spacing
@@ -306,8 +310,8 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
 
     // Vertical spacing
     const baselineskip = group.colSeparationType === "CD"
-      ? calculateSize({number: 3, unit: "ex"}, options)
-      : 12 * pt; // see size10.clo
+        ? calculateSize({number: 3, unit: "ex"}, options)
+        : 12 * pt; // see size10.clo
     // Default \jot from ltmath.dtx
     // TODO(edemaine): allow overriding \jot via \setlength (#687)
     const jot = 3 * pt;
@@ -337,7 +341,7 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
             nc = inrow.length;
         }
 
-        const outrow: Outrow = (new Array(inrow.length): any);
+        const outrow: Outrow = (new Array(inrow.length) as any);
         for (c = 0; c < inrow.length; ++c) {
             const elt = html.buildGroup(inrow[c], options);
             if (depth < elt.depth) {
@@ -381,12 +385,16 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
 
     const offset = totalHeight / 2 + options.fontMetrics().axisHeight;
     const colDescriptions = group.cols || [];
-    const cols = [];
+    const cols: HtmlDomNode[] = [];
     let colSep;
     let colDescrNum;
+    const tagSpans: Array<{
+        type: "elem";
+        elem: HtmlDomNode;
+        shift: number;
+    }> = [];
 
-    const tagSpans = [];
-    if (group.tags && group.tags.some((tag) => tag)) {
+    if (group.tags && group.tags.some(tag => tag)) {
         // An environment with manual tags and/or automatic equation numbers.
         // Create node(s), the latter of which trigger CSS counter increment.
         for (r = 0; r < nr; ++r) {
@@ -414,11 +422,10 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
          // descriptions, so trailing separators don't get lost.
          c < nc || colDescrNum < colDescriptions.length;
          ++c, ++colDescrNum) {
-
-        let colDescr = colDescriptions[colDescrNum] || {};
+        let colDescr: AlignSpec | undefined = colDescriptions[colDescrNum];
 
         let firstSeparator = true;
-        while (colDescr.type === "separator") {
+        while (colDescr?.type === "separator") {
             // If there is more than one separator in a row, add a space
             // between them.
             if (!firstSeparator) {
@@ -429,10 +436,8 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
             }
 
             if (colDescr.separator === "|" || colDescr.separator === ":") {
-                const lineType = (colDescr.separator === "|") ? "solid" : "dashed";
-                const separator = makeSpan(
-                    ["vertical-separator"], [], options
-                );
+                const lineType = colDescr.separator === "|" ? "solid" : "dashed";
+                const separator = makeSpan(["vertical-separator"], [], options);
                 separator.style.height = makeEm(totalHeight);
                 separator.style.borderRightWidth = makeEm(ruleThickness);
                 separator.style.borderRightStyle = lineType;
@@ -449,7 +454,7 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
             }
 
             colDescrNum++;
-            colDescr = colDescriptions[colDescrNum] || {};
+            colDescr = colDescriptions[colDescrNum];
             firstSeparator = false;
         }
 
@@ -459,7 +464,7 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
 
         let sepwidth;
         if (c > 0 || group.hskipBeforeAndAfter) {
-            sepwidth = colDescr.pregap ?? arraycolsep;
+            sepwidth = colDescr?.pregap ?? arraycolsep;
             if (sepwidth !== 0) {
                 colSep = makeSpan(["arraycolsep"], []);
                 colSep.style.width = makeEm(sepwidth);
@@ -467,7 +472,11 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
             }
         }
 
-        let col = [];
+        const colElems: Array<{
+            type: "elem";
+            elem: HtmlDomNode;
+            shift: number;
+        }> = [];
         for (r = 0; r < nr; ++r) {
             const row = body[r];
             const elem = row[c];
@@ -477,20 +486,21 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
             const shift = row.pos - offset;
             elem.depth = row.depth;
             elem.height = row.height;
-            col.push({type: "elem", elem: elem, shift: shift});
+            colElems.push({type: "elem", elem: elem, shift: shift});
         }
 
-        col = makeVList({
+        const colVList = makeVList({
             positionType: "individualShift",
-            children: col,
+            children: colElems,
         }, options);
-        col = makeSpan(
-            ["col-align-" + (colDescr.align || "c")],
-            [col]);
-        cols.push(col);
+        const colSpan = makeSpan(
+            ["col-align-" + (colDescr?.align || "c")],
+            [colVList],
+        );
+        cols.push(colSpan);
 
         if (c < nc - 1 || group.hskipBeforeAndAfter) {
-            sepwidth = colDescr.postgap ?? arraycolsep;
+            sepwidth = colDescr?.postgap ?? arraycolsep;
             if (sepwidth !== 0) {
                 colSep = makeSpan(["arraycolsep"], []);
                 colSep.style.width = makeEm(sepwidth);
@@ -498,42 +508,43 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
             }
         }
     }
-    body = makeSpan(["mtable"], cols);
+
+    let tableBody: HtmlDomNode = makeSpan(["mtable"], cols);
 
     // Add \hline(s), if any.
     if (hlines.length > 0) {
         const line = makeLineSpan("hline", options, ruleThickness);
-        const dashes = makeLineSpan("hdashline", options,
-            ruleThickness);
-        const vListElems = [{type: "elem", elem: body, shift: 0}];
+        const dashes = makeLineSpan("hdashline", options, ruleThickness);
+        const vListElems = [{type: "elem" as const, elem: tableBody, shift: 0}];
         while (hlines.length > 0) {
-            const hline = hlines.pop();
+            const hline = hlines.pop()!;
             const lineShift = hline.pos - offset;
             if (hline.isDashed) {
-                vListElems.push({type: "elem", elem: dashes, shift: lineShift});
+                vListElems.push({type: "elem" as const, elem: dashes, shift: lineShift});
             } else {
-                vListElems.push({type: "elem", elem: line, shift: lineShift});
+                vListElems.push({type: "elem" as const, elem: line, shift: lineShift});
             }
         }
-        body = makeVList({
+
+        tableBody = makeVList({
             positionType: "individualShift",
             children: vListElems,
         }, options);
     }
 
     if (tagSpans.length === 0) {
-        return makeSpan(["mord"], [body], options);
+        return makeSpan(["mord"], [tableBody], options);
     } else {
-        let eqnNumCol = makeVList({
+        const eqnNumCol = makeVList({
             positionType: "individualShift",
             children: tagSpans,
         }, options);
-        eqnNumCol = makeSpan(["tag"], [eqnNumCol], options);
-        return makeFragment([body, eqnNumCol]);
+        const tagCol = makeSpan(["tag"], [eqnNumCol], options);
+        return makeFragment([tableBody, tagCol]);
     }
 };
 
-const alignMap = {
+const alignMap: Record<string, string> = {
     c: "center ",
     l: "left ",
     r: "right ",
@@ -604,20 +615,19 @@ const mathmlBuilder: MathMLBuilder<"array"> = function(group, options) {
         }
 
         for (let i = iStart; i < iEnd; i++) {
-            if (cols[i].type === "align") {
-                align += alignMap[cols[i].align];
+            const col = cols[i];
+            if (col.type === "align") {
+                align += alignMap[col.align];
 
                 if (prevTypeWasAlign) {
                     columnLines += "none ";
                 }
                 prevTypeWasAlign = true;
-            } else if (cols[i].type === "separator") {
+            } else if (col.type === "separator") {
                 // MathML accepts only single lines between cells.
                 // So we read only the first of consecutive separators.
                 if (prevTypeWasAlign) {
-                    columnLines += cols[i].separator === "|"
-                        ? "solid "
-                        : "dashed ";
+                    columnLines += col.separator === "|" ? "solid " : "dashed ";
                     prevTypeWasAlign = false;
                 }
             }
@@ -681,12 +691,12 @@ const mathmlBuilder: MathMLBuilder<"array"> = function(group, options) {
 };
 
 // Convenience function for align, align*, aligned, alignat, alignat*, alignedat.
-const alignedHandler = function(context, args) {
+const alignedHandler = function(context: EnvContextLike, args: AnyParseNode[]) {
     if (!context.envName.includes("ed")) {
         validateAmsEnvironmentContext(context);
     }
-    const cols = [];
-    const separationType = context.envName.includes("at") ? "alignat" : "align";
+    const cols: AlignSpec[] = [];
+    const separationType: ColSeparationType = context.envName.includes("at") ? "alignat" : "align";
     const isSplit = context.envName === "split";
     const res = parseArray(context.parser,
         {
@@ -710,9 +720,9 @@ const alignedHandler = function(context, args) {
     // At the same time, prepend empty group {} at beginning of every second
     // cell in each row (starting with second cell) so that operators become
     // binary.  This behavior is implemented in amsmath's \start@aligned.
-    let numMaths;
+    let numMaths = 0;
     let numCols = 0;
-    const emptyGroup = {
+    const emptyGroup: ParseNode<"ordgroup"> = {
         type: "ordgroup",
         mode: context.mode,
         body: [],
@@ -787,7 +797,7 @@ defineEnvironment({
         const symNode = checkSymbolNodeType(args[0]);
         const colalign: AnyParseNode[] =
             symNode ? [args[0]] : assertNodeType(args[0], "ordgroup").body;
-        const cols = colalign.map(function(nde) {
+        const cols: AlignSpec[] = colalign.map(function(nde) {
             const node = assertSymbolNodeType(nde);
             const ca = node.text;
             if ("lcr".includes(ca)) {
@@ -808,7 +818,7 @@ defineEnvironment({
             }
             throw new ParseError("Unknown column alignment: " + ca, nde);
         });
-        const res = {
+        const res: Parameters<typeof parseArray>[1] = {
             cols,
             hskipBeforeAndAfter: true, // \@preamble in lttab.dtx
             maxNumCols: cols.length,
@@ -853,7 +863,7 @@ defineEnvironment({
         }[context.envName.replace("*", "")];
         // \hskip -\arraycolsep in amsmath
         let colAlign = "c";
-        const payload = {
+        const payload: Parameters<typeof parseArray>[1] = {
             hskipBeforeAndAfter: false,
             cols: [{type: "align", align: colAlign}],
         };
@@ -879,7 +889,7 @@ defineEnvironment({
         const res: ParseNode<"array"> =
             parseArray(context.parser, payload, dCellStyle(context.envName));
         // Populate cols with the correct number of column alignment specs.
-        const numCols = Math.max(0, ...res.body.map((row) => row.length));
+        const numCols = Math.max(0, ...res.body.map(row => row.length));
         res.cols = new Array(numCols).fill(
             {type: "align", align: colAlign}
         );
@@ -903,7 +913,7 @@ defineEnvironment({
         numArgs: 0,
     },
     handler(context) {
-        const payload = {arraystretch: 0.5};
+        const payload: Parameters<typeof parseArray>[1] = {arraystretch: 0.5};
         const res = parseArray(context.parser, payload, "script");
         res.colSeparationType = "small";
         return res;
@@ -923,7 +933,7 @@ defineEnvironment({
         const symNode = checkSymbolNodeType(args[0]);
         const colalign: AnyParseNode[] =
             symNode ? [args[0]] : assertNodeType(args[0], "ordgroup").body;
-        const cols = colalign.map(function(nde) {
+        const cols: AlignSpec[] = colalign.map(function(nde) {
             const node = assertSymbolNodeType(nde);
             const ca = node.text;
             // {subarray} only recognizes "l" & "c"
@@ -938,12 +948,12 @@ defineEnvironment({
         if (cols.length > 1) {
             throw new ParseError("{subarray} can contain only one column");
         }
-        let res = {
+        const payload: Parameters<typeof parseArray>[1] = {
             cols,
             hskipBeforeAndAfter: false,
             arraystretch: 0.5,
         };
-        res = parseArray(context.parser, res, "script");
+        const res = parseArray(context.parser, payload, "script");
         if (res.body.length > 0 &&  res.body[0].length > 1) {
             throw new ParseError("{subarray} can contain only one column");
         }
@@ -971,7 +981,7 @@ defineEnvironment({
         numArgs: 0,
     },
     handler(context) {
-        const payload = {
+        const payload: Parameters<typeof parseArray>[1] = {
             arraystretch: 1.2,
             cols: [{
                 type: "align",
@@ -1034,7 +1044,7 @@ defineEnvironment({
         if (gatherEnvironments.has(context.envName)) {
             validateAmsEnvironmentContext(context);
         }
-        const res = {
+        const res: Parameters<typeof parseArray>[1] = {
             cols: [{
                 type: "align",
                 align: "c",
@@ -1073,7 +1083,7 @@ defineEnvironment({
     },
     handler(context) {
         validateAmsEnvironmentContext(context);
-        const res = {
+        const res: Parameters<typeof parseArray>[1] = {
             autoTag: getAutoTag(context.envName),
             emptySingleRow: true,
             singleRow: true,

package/src/environments/{cd.js → cd.ts}

@@ -1,4 +1,3 @@
-// @flow
 import {wrapFragment} from "../buildCommon";
 import defineFunction from "../defineFunction";
 import {MathNode} from "../mathMLTree";
@@ -11,7 +10,7 @@ import {makeEm} from "../units";
 import type Parser from "../Parser";
 import type {ParseNode, AnyParseNode} from "../parseNode";
 
-const cdArrowFunctionName = {
+const cdArrowFunctionName: Record<string, string> = {
     ">": "\\\\cdrightarrow",
     "<": "\\\\cdleftarrow",
     "=": "\\\\cdlongequal",
@@ -21,12 +20,11 @@ const cdArrowFunctionName = {
     ".": "no arrow",
 };
 
-const newCell = () => {
+const newCell = (): ParseNode<"styling"> => {
     // Create an empty cell, to be filled below with parse nodes.
     // The parseTree from this module must be constructed like the
     // one created by parseArray(), so an empty CD cell must
     // be a ParseNode<"styling">. And CD is always displaystyle.
-    // So these values are fixed and flow can do implicit typing.
     return {type: "styling", body: [], mode: "math", style: "display"};
 };
 
@@ -58,7 +56,7 @@ function cdArrow(
             const leftLabel = parser.callFunction(
                 "\\\\cdleft", [labels[0]], []
             );
-            const bareArrow = {
+            const bareArrow: ParseNode<"atom"> = {
                 type: "atom",
                 text: funcName,
                 mode: "math",
@@ -68,7 +66,7 @@ function cdArrow(
             const rightLabel = parser.callFunction(
                 "\\\\cdright", [labels[1]], []
             );
-            const arrowGroup = {
+            const arrowGroup: ParseNode<"ordgroup"> = {
                 type: "ordgroup",
                 mode: "math",
                 body: [leftLabel, sizedArrow, rightLabel],
@@ -78,7 +76,7 @@ function cdArrow(
         case "\\\\cdlongequal":
             return parser.callFunction("\\\\cdlongequal", [], []);
         case "\\Vert": {
-            const arrow = {type: "textord", text: "\\Vert", mode: "math"};
+            const arrow: ParseNode<"textord"> = {type: "textord", text: "\\Vert", mode: "math"};
             return parser.callFunction("\\Big", [arrow], []);
         }
         default:
@@ -111,8 +109,8 @@ export function parseCD(parser: Parser): ParseNode<"array"> {
         }
     }
 
-    let row = [];
-    const body = [row];
+    let row: ParseNode<"styling">[] = [];
+    const body: ParseNode<"styling">[][] = [row];
 
     // Loop thru the parse nodes. Collect them into cells and arrows.
     for (let i = 0; i < parsedRows.length; i++) {
@@ -180,7 +178,7 @@ export function parseCD(parser: Parser): ParseNode<"array"> {
 
                 // Wrap the arrow in  ParseNode<"styling">.
                 // This is done to match parseArray() behavior.
-                const wrappedArrow = {
+                const wrappedArrow: ParseNode<"styling"> = {
                     type: "styling",
                     body: [arrow],
                     mode: "math",
@@ -308,6 +306,6 @@ defineFunction({
     },
     mathmlBuilder(group, options) {
         return new MathNode("mrow",
-        [mml.buildGroup(group.fragment, options)]);
+            [mml.buildGroup(group.fragment, options)]);
     },
 });

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

@@ -1,4 +1,3 @@
-// @flow
 import {_environments} from "./defineEnvironment";
 
 const environments = _environments;

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

@@ -1,4 +1,3 @@
-// @flow
 import {supportedCodepoint} from "./unicodeScripts";
 
 import type {Mode} from "./types";
@@ -33,7 +32,7 @@ import type {Mode} from "./types";
 //
 // The output of each of these commands is quite lengthy.  The only part we
 // care about is the FONTDIMEN section. Each value is measured in EMs.
-const sigmasAndXis = {
+const sigmasAndXis: Record<string, [number, number, number]> = {
     slant: [0.250, 0.250, 0.250],       // sigma1
     space: [0.000, 0.000, 0.000],       // sigma2
     stretch: [0.000, 0.000, 0.000],     // sigma3
@@ -105,7 +104,7 @@ import metricMap from "./fontMetricsData";
 // descenders we prefer approximations with ascenders, primarily to prevent
 // the fraction bar or root line from intersecting the glyph.
 // TODO(kevinb) allow union of multiple glyph metrics for better accuracy.
-const extraCharacterMap = {
+const extraCharacterMap: Record<string, string> = {
     // Latin-1
     'Å': 'A',
     'Ð': 'D',
@@ -190,8 +189,8 @@ export type CharacterMetrics = {
 };
 
 export type MetricMap = {
-    [string]: number[]
-}
+    [key: string]: [number, number, number, number, number];
+};
 
 /**
  * This function adds new font metrics to default metricMap
@@ -212,7 +211,7 @@ export function getCharacterMetrics(
     character: string,
     font: string,
     mode: Mode,
-): ?CharacterMetrics {
+): CharacterMetrics | null | undefined {
     if (!metricMap[font]) {
         throw new Error(`Font metrics not found for font: ${font}.`);
     }
@@ -250,11 +249,10 @@ export function getCharacterMetrics(
 
 type FontSizeIndex = 0 | 1 | 2;
 export type FontMetrics = {
-    cssEmPerMu: number,
-    [string]: number,
+    cssEmPerMu: number;
+    [key: string]: number;
 };
-
-const fontMetricsBySizeIndex: {[FontSizeIndex]: FontMetrics} = {};
+const fontMetricsBySizeIndex: Partial<Record<FontSizeIndex, FontMetrics>> = {};
 
 /**
  * Get the font metrics for a given size.
@@ -269,7 +267,7 @@ export function getGlobalMetrics(size: number): FontMetrics {
         sizeIndex = 2;
     }
     if (!fontMetricsBySizeIndex[sizeIndex]) {
-        const metrics = fontMetricsBySizeIndex[sizeIndex] = {
+        const metrics: FontMetrics = fontMetricsBySizeIndex[sizeIndex] = {
             cssEmPerMu: sigmasAndXis.quad[sizeIndex] / 18,
         };
         for (const key in sigmasAndXis) {
@@ -278,5 +276,5 @@ export function getGlobalMetrics(size: number): FontMetrics {
             }
         }
     }
-    return fontMetricsBySizeIndex[sizeIndex];
+    return fontMetricsBySizeIndex[sizeIndex]!;
 }

package/src/fontMetricsData.d.ts

@@ -0,0 +1,3 @@
+declare const fontMetricsData: Record<string, Record<number, [number, number, number, number, number]>>;
+
+export default fontMetricsData;

package/src/functions/{accent.js → accent.ts}

@@ -1,4 +1,3 @@
-// @flow
 import defineFunction, {normalizeArgument} from "../defineFunction";
 import {makeOrd, makeSpan, makeVList, staticSvg, svgData} from "../buildCommon";
 import {getBaseElem, isCharacterBox} from "../utils";
@@ -98,7 +97,7 @@ export const htmlBuilder: HtmlBuilderSupSub<"accent"> = (grp, options) => {
             accent = staticSvg("vec", options);
             width = svgData.vec[1];
         } else {
-            accent = makeOrd({mode: group.mode, text: group.label},
+            accent = makeOrd({type: "textord", mode: group.mode, text: group.label},
                 options, "textord");
             accent = assertSymbolDomNode(accent);
             // Remove the italic correction of the accent, because it only serves to