@khanacademy/simple-markdown 0.8.6 → 0.9.1

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

@@ -1,6 +1,4 @@
-/* eslint-disable prefer-spread, no-regex-spaces, no-unused-vars, guard-for-in, no-console, no-var */
-// @flow
-
+/* eslint-disable prefer-spread, no-regex-spaces, @typescript-eslint/no-unused-vars, guard-for-in, no-console, no-var */
 /**
  * Simple-Markdown
  * ===============
@@ -20,42 +18,52 @@
  * Many of the regexes and original logic has been adapted from
  * the wonderful [marked.js](https://github.com/chjj/marked)
  */
+import * as React from "react";
 
-// Flow Type Definitions:
+// Type Definitions:
 
 type Capture =
-    | (Array<string> & {index: number})
-    | (Array<string> & {index?: number});
+    | (Array<string> & {
+          index: number;
+      })
+    | (Array<string> & {
+          index?: number;
+      });
 
-type Attr = string | number | boolean | null | void;
+type Attr = string | number | boolean | null | undefined;
 
 type SingleASTNode = {
-    type: string,
-    [string]: any,
+    type: string;
+    [key: string]: any;
 };
 
 type UnTypedASTNode = {
-    [string]: any,
+    [key: string]: any;
 };
 
 type ASTNode = SingleASTNode | Array<SingleASTNode>;
 
 type State = {
-    key?: string | number | void,
-    inline?: ?boolean,
-    [string]: any,
+    key?: string | number | undefined;
+    inline?: boolean | null | undefined;
+    [key: string]: any;
 };
 
-type ReactElement = React$Element<any>;
-type ReactElements = React$Node;
+type ReactElement = React.ReactElement<any>;
+type ReactElements = React.ReactNode;
 
-type MatchFunction = {regex?: RegExp} & ((
+type MatchFunction = {
+    regex?: RegExp;
+} & ((
     source: string,
     state: State,
     prevCapture: string,
-) => ?Capture);
+) => Capture | null | undefined);
 
-type Parser = (source: string, state?: ?State) => Array<SingleASTNode>;
+type Parser = (
+    source: string,
+    state?: State | null | undefined,
+) => Array<SingleASTNode>;
 
 type ParseFunction = (
     capture: Capture,
@@ -69,7 +77,10 @@ type SingleNodeParseFunction = (
     state: State,
 ) => UnTypedASTNode;
 
-type Output<Result> = (node: ASTNode, state?: ?State) => Result;
+type Output<Result> = (
+    node: ASTNode,
+    state?: State | null | undefined,
+) => Result;
 
 type NodeOutput<Result> = (
     node: SingleASTNode,
@@ -89,17 +100,25 @@ type HtmlOutput = Output<string>;
 type HtmlNodeOutput = NodeOutput<string>;
 
 type ParserRule = {
-    +order: number,
-    +match: MatchFunction,
-    +quality?: (capture: Capture, state: State, prevCapture: string) => number,
-    +parse: ParseFunction,
+    readonly order: number;
+    readonly match: MatchFunction;
+    readonly quality?: (
+        capture: Capture,
+        state: State,
+        prevCapture: string,
+    ) => number;
+    readonly parse: ParseFunction;
 };
 
 type SingleNodeParserRule = {
-    +order: number,
-    +match: MatchFunction,
-    +quality?: (capture: Capture, state: State, prevCapture: string) => number,
-    +parse: SingleNodeParseFunction,
+    readonly order: number;
+    readonly match: MatchFunction;
+    readonly quality?: (
+        capture: Capture,
+        state: State,
+        prevCapture: string,
+    ) => number;
+    readonly parse: SingleNodeParseFunction;
 };
 
 type ReactOutputRule = {
@@ -107,59 +126,66 @@ type ReactOutputRule = {
     // legal as long as no parsers return an AST node matching that rule.
     // We don't use ? because this makes it be explicitly defined as either
     // a valid function or null, so it can't be forgotten.
-    +react: ReactNodeOutput | null,
+    readonly react: ReactNodeOutput | null;
 };
 
 type HtmlOutputRule = {
-    +html: HtmlNodeOutput | null,
+    readonly html: HtmlNodeOutput | null;
 };
 
 type ArrayRule = {
-    +react?: ArrayNodeOutput<ReactElements>,
-    +html?: ArrayNodeOutput<string>,
-    +[string]: ArrayNodeOutput<any>,
+    // @ts-expect-error [FEI-5003] - TS2411 - Property 'react' of type 'ArrayNodeOutput<ReactNode> | undefined' is not assignable to 'string' index type 'ArrayNodeOutput<any>'.
+    readonly react?: ArrayNodeOutput<ReactElements>;
+    // @ts-expect-error [FEI-5003] - TS2411 - Property 'html' of type 'ArrayNodeOutput<string> | undefined' is not assignable to 'string' index type 'ArrayNodeOutput<any>'.
+    readonly html?: ArrayNodeOutput<string>;
+    readonly [key: string]: ArrayNodeOutput<any>;
 };
 
 type ParserRules = {
-    +Array?: ArrayRule,
-    +[type: string]: ParserRule,
+    // @ts-expect-error [FEI-5003] - TS2411 - Property 'Array' of type 'ArrayRule | undefined' is not assignable to 'string' index type 'ParserRule'.
+    readonly Array?: ArrayRule;
+    readonly [type: string]: ParserRule;
 };
 
 type OutputRules<Rule> = {
-    +Array?: ArrayRule,
-    +[type: string]: Rule,
+    // @ts-expect-error [FEI-5003] - TS2411 - Property 'Array' of type 'ArrayRule | undefined' is not assignable to 'string' index type 'Rule'.
+    readonly Array?: ArrayRule;
+    readonly [type: string]: Rule;
 };
 type Rules<OutputRule> = {
-    +Array?: ArrayRule,
-    +[type: string]: ParserRule & OutputRule,
+    // @ts-expect-error [FEI-5003] - TS2411 - Property 'Array' of type 'ArrayRule | undefined' is not assignable to 'string' index type 'ParserRule & OutputRule'.
+    readonly Array?: ArrayRule;
+    readonly [type: string]: ParserRule & OutputRule;
 };
 type ReactRules = {
-    +Array?: {
-        +react: ArrayNodeOutput<ReactElements>,
-    },
-    +[type: string]: ParserRule & ReactOutputRule,
+    // @ts-expect-error [FEI-5003] - TS2411 - Property 'Array' of type '{ readonly react: ArrayNodeOutput<ReactNode>; } | undefined' is not assignable to 'string' index type 'ParserRule & ReactOutputRule'.
+    readonly Array?: {
+        readonly react: ArrayNodeOutput<ReactElements>;
+    };
+    readonly [type: string]: ParserRule & ReactOutputRule;
 };
 type HtmlRules = {
-    +Array?: {
-        +html: ArrayNodeOutput<string>,
-    },
-    +[type: string]: ParserRule & HtmlOutputRule,
+    // @ts-expect-error [FEI-5003] - TS2411 - Property 'Array' of type '{ readonly html: ArrayNodeOutput<string>; } | undefined' is not assignable to 'string' index type 'ParserRule & HtmlOutputRule'.
+    readonly Array?: {
+        readonly html: ArrayNodeOutput<string>;
+    };
+    readonly [type: string]: ParserRule & HtmlOutputRule;
 };
 
 // We want to clarify our defaultRules types a little bit more so clients can
 // reuse defaultRules built-ins. So we make some stronger guarantess when
 // we can:
 type NonNullReactOutputRule = {
-    +react: ReactNodeOutput,
+    readonly react: ReactNodeOutput;
 };
 type ElementReactOutputRule = {
-    +react: NodeOutput<ReactElement>,
+    readonly react: NodeOutput<ReactElement>;
 };
 type TextReactOutputRule = {
-    +react: NodeOutput<string>,
+    readonly react: NodeOutput<string>;
 };
 type NonNullHtmlOutputRule = {
-    +html: HtmlNodeOutput,
+    readonly html: HtmlNodeOutput;
 };
 
 type DefaultInRule = SingleNodeParserRule & ReactOutputRule & HtmlOutputRule;
@@ -174,46 +200,46 @@ type DefaultInOutRule = SingleNodeParserRule &
     NonNullHtmlOutputRule;
 
 type DefaultRules = {
-    +Array: {
-        +react: ArrayNodeOutput<ReactElements>,
-        +html: ArrayNodeOutput<string>,
-    },
-    +heading: DefaultInOutRule,
-    +nptable: DefaultInRule,
-    +lheading: DefaultInRule,
-    +hr: DefaultInOutRule,
-    +codeBlock: DefaultInOutRule,
-    +fence: DefaultInRule,
-    +blockQuote: DefaultInOutRule,
-    +list: DefaultInOutRule,
-    +def: LenientInOutRule,
-    +table: DefaultInOutRule,
-    +tableSeparator: DefaultInRule,
-    +newline: TextInOutRule,
-    +paragraph: DefaultInOutRule,
-    +escape: DefaultInRule,
-    +autolink: DefaultInRule,
-    +mailto: DefaultInRule,
-    +url: DefaultInRule,
-    +link: DefaultInOutRule,
-    +image: DefaultInOutRule,
-    +reflink: DefaultInRule,
-    +refimage: DefaultInRule,
-    +em: DefaultInOutRule,
-    +strong: DefaultInOutRule,
-    +u: DefaultInOutRule,
-    +del: DefaultInOutRule,
-    +inlineCode: DefaultInOutRule,
-    +br: DefaultInOutRule,
-    +text: TextInOutRule,
+    readonly Array: {
+        readonly react: ArrayNodeOutput<ReactElements>;
+        readonly html: ArrayNodeOutput<string>;
+    };
+    readonly heading: DefaultInOutRule;
+    readonly nptable: DefaultInRule;
+    readonly lheading: DefaultInRule;
+    readonly hr: DefaultInOutRule;
+    readonly codeBlock: DefaultInOutRule;
+    readonly fence: DefaultInRule;
+    readonly blockQuote: DefaultInOutRule;
+    readonly list: DefaultInOutRule;
+    readonly def: LenientInOutRule;
+    readonly table: DefaultInOutRule;
+    readonly tableSeparator: DefaultInRule;
+    readonly newline: TextInOutRule;
+    readonly paragraph: DefaultInOutRule;
+    readonly escape: DefaultInRule;
+    readonly autolink: DefaultInRule;
+    readonly mailto: DefaultInRule;
+    readonly url: DefaultInRule;
+    readonly link: DefaultInOutRule;
+    readonly image: DefaultInOutRule;
+    readonly reflink: DefaultInRule;
+    readonly refimage: DefaultInRule;
+    readonly em: DefaultInOutRule;
+    readonly strong: DefaultInOutRule;
+    readonly u: DefaultInOutRule;
+    readonly del: DefaultInOutRule;
+    readonly inlineCode: DefaultInOutRule;
+    readonly br: DefaultInOutRule;
+    readonly text: TextInOutRule;
 };
 
 type RefNode = {
-    type: string,
-    content?: ASTNode,
-    target?: string,
-    title?: string,
-    alt?: string,
+    type: string;
+    content?: ASTNode;
+    target?: string;
+    title?: string;
+    alt?: string;
 };
 
 // End Flow Definitions
@@ -233,13 +259,12 @@ var preprocess = function (source: string): string {
 };
 
 var populateInitialState = function (
-    givenState: ?State,
-    defaultState: ?State,
+    givenState?: State | null,
+    defaultState?: State | null,
 ): State {
     var state: State = givenState || {};
     if (defaultState != null) {
         for (var prop in defaultState) {
-            // $FlowFixMe
             if (Object.prototype.hasOwnProperty.call(defaultState, prop)) {
                 state[prop] = defaultState[prop];
             }
@@ -267,7 +292,10 @@ var populateInitialState = function (
  *         some nesting is. For an example use-case, see passage-ref
  *         parsing in src/widgets/passage/passage-markdown.jsx
  */
-var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
+var parserFor = function (
+    rules: ParserRules,
+    defaultState?: State | null,
+): Parser {
     // Sorts rules in order of increasing order, then
     // ascending rule name in case of ties.
     var ruleList = Object.keys(rules).filter(function (type) {
@@ -291,8 +319,8 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
     });
 
     ruleList.sort(function (typeA, typeB) {
-        var ruleA: ParserRule = (rules[typeA]: any);
-        var ruleB: ParserRule = (rules[typeB]: any);
+        var ruleA: ParserRule = rules[typeA] as any;
+        var ruleB: ParserRule = rules[typeB] as any;
         var orderA = ruleA.order;
         var orderB = ruleB.order;
 
@@ -322,7 +350,7 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
     var latestState: State;
     var nestedParse: Parser = function (
         source: string,
-        state: ?State,
+        state?: State | null,
     ): Array<SingleASTNode> {
         var result: Array<SingleASTNode> = [];
         state = state || latestState;
@@ -338,7 +366,6 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
             var i = 0;
             var currRuleType = ruleList[0];
 
-            // $FlowFixMe
             var currRule: ParserRule = rules[currRuleType];
 
             do {
@@ -355,8 +382,11 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
                     // the initial quality is NaN (that's why there's the
                     // condition negation).
                     if (!(currQuality <= quality)) {
+                        // @ts-expect-error [FEI-5003] - TS2322 - Type 'string' is not assignable to type 'null'.
                         ruleType = currRuleType;
+                        // @ts-expect-error [FEI-5003] - TS2322 - Type 'ParserRule' is not assignable to type 'null'.
                         rule = currRule;
+                        // @ts-expect-error [FEI-5003] - TS2322 - Type 'Capture' is not assignable to type 'null'.
                         capture = currCapture;
                         quality = currQuality;
                     }
@@ -366,7 +396,6 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
                 // Note that this makes `currRule` be the next item
                 i++;
                 currRuleType = ruleList[i];
-                // $FlowFixMe
                 currRule = rules[currRuleType];
             } while (
                 // keep looping while we're still within the ruleList
@@ -394,6 +423,7 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
                         source,
                 );
             }
+            // @ts-expect-error [FEI-5003] - TS2339 - Property 'index' does not exist on type 'never'.
             if (capture.index) {
                 // If present and non-zero, i.e. a non-^ regexp result:
                 throw new Error(
@@ -403,13 +433,13 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
                 );
             }
 
+            // @ts-expect-error [FEI-5003] - TS2339 - Property 'parse' does not exist on type 'never'.
             var parsed = rule.parse(capture, nestedParse, state);
             // We maintain the same object here so that rules can
             // store references to the objects they return and
             // modify them later. (oops sorry! but this adds a lot
             // of power--see reflinks.)
             if (Array.isArray(parsed)) {
-                // $FlowFixMe
                 Array.prototype.push.apply(result, parsed);
             } else {
                 if (parsed == null || typeof parsed !== "object") {
@@ -423,7 +453,6 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
                 // there can be a single output function for all links,
                 // even if there are several rules to parse them.
                 if (parsed.type == null) {
-                    // $FlowFixMe
                     parsed.type = ruleType;
                 }
                 result.push(parsed);
@@ -433,13 +462,12 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
             source = source.substring(state.prevCapture[0].length);
         }
 
-        // $FlowFixMe
         return result;
     };
 
     var outerParse: Parser = function (
         source: string,
-        state: ?State,
+        state?: State | null,
     ): Array<SingleASTNode> {
         latestState = populateInitialState(state, defaultState);
         if (!latestState.inline && !latestState.disableAutoBlockNewlines) {
@@ -454,7 +482,6 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
         return nestedParse(preprocess(source), latestState);
     };
 
-    // $FlowFixMe
     return outerParse;
 };
 
@@ -464,14 +491,14 @@ var inlineRegex = function (regex: RegExp): MatchFunction {
         source: string,
         state: State,
         prevCapture: string,
-    ): ?Capture {
+    ): Capture | null | undefined {
         if (state.inline) {
-            // $FlowFixMe
             return regex.exec(source);
         } else {
             return null;
         }
     };
+    // @ts-expect-error [FEI-5003] - TS2339 - Property 'regex' does not exist on type '(source: string, state: State, prevCapture: string) => Capture | null | undefined'.
     match.regex = regex;
 
     return match;
@@ -479,7 +506,6 @@ var inlineRegex = function (regex: RegExp): MatchFunction {
 
 // Creates a match function for a block scoped element from a regex
 var blockRegex = function (regex: RegExp): MatchFunction {
-    // $FlowFixMe
     var match: MatchFunction = function (source, state) {
         if (state.inline) {
             return null;
@@ -493,7 +519,6 @@ var blockRegex = function (regex: RegExp): MatchFunction {
 
 // Creates a match function from a regex, ignoring block/inline scope
 var anyScopeRegex = function (regex: RegExp): MatchFunction {
-    // $FlowFixMe
     var match: MatchFunction = function (source, state) {
         return regex.exec(source);
     };
@@ -509,17 +534,19 @@ var TYPE_SYMBOL =
 
 var reactElement = function (
     type: string,
-    key: string | number | null | void,
-    props: {[string]: any},
+    key: string | number | null | undefined,
+    props: {
+        [key: string]: any;
+    },
 ): ReactElement {
-    var element: ReactElement = ({
+    var element: ReactElement = {
         $$typeof: TYPE_SYMBOL,
         type: type,
         key: key == null ? undefined : key,
         ref: null,
         props: props,
         _owner: null,
-    }: any);
+    } as any;
     return element;
 };
 
@@ -534,8 +561,8 @@ var reactElement = function (
 var htmlTag = function (
     tagName: string,
     content: string,
-    attributes: ?{[any]: ?Attr},
-    isClosed: ?boolean,
+    attributes?: Partial<Record<any, Attr | null | undefined>> | null,
+    isClosed?: boolean | null,
 ) {
     attributes = attributes || {};
     isClosed = typeof isClosed !== "undefined" ? isClosed : true;
@@ -563,13 +590,13 @@ var htmlTag = function (
     }
 };
 
-var EMPTY_PROPS = {};
+var EMPTY_PROPS: Record<string, any> = {};
 
 /**
  * @param {string | null | undefined} url - url to sanitize
  * @returns {string | null} - url if safe, or null if a safe url could not be made
  */
-var sanitizeUrl = function (url: ?string) {
+var sanitizeUrl = function (url?: string | null) {
     if (url == null) {
         return null;
     }
@@ -582,7 +609,7 @@ var sanitizeUrl = function (url: ?string) {
         ) {
             return null;
         }
-    } catch (e) {
+    } catch (e: any) {
         // invalid URLs should throw a TypeError
         // see for instance: `new URL("");`
         return null;
@@ -773,6 +800,7 @@ var TABLES = (function () {
                         "",
                     );
                 }
+                // @ts-expect-error [FEI-5003] - TS2345 - Argument of type 'SingleASTNode' is not assignable to parameter of type 'never'.
                 cells[cells.length - 1].push(node);
             }
         });
@@ -796,7 +824,6 @@ var TABLES = (function () {
         var rowsText = source.trim().split("\n");
 
         return rowsText.map(function (rowText) {
-            // $FlowFixMe
             return parseTableRow(rowText, parse, state, trimEndSeparators);
         });
     };
@@ -805,8 +832,8 @@ var TABLES = (function () {
      * @param {boolean} trimEndSeparators
      * @returns {SimpleMarkdown.SingleNodeParseFunction}
      */
-    var parseTable = function (trimEndSeparators) {
-        return function (capture, parse, state) {
+    var parseTable = function (trimEndSeparators: boolean) {
+        return function (capture: Capture, parse: Parser, state: State) {
             state.inline = true;
             var header = parseTableRow(
                 capture[1],
@@ -1085,6 +1112,7 @@ var defaultRules: DefaultRules = {
             var bullet = capture[2];
             var ordered = bullet.length > 1;
             var start = ordered ? +bullet : undefined;
+            // @ts-expect-error [FEI-5003] - TS2322 - Type 'RegExpMatchArray | null' is not assignable to type 'string[]'.
             var items: Array<string> = capture[0]
                 .replace(LIST_BLOCK_END_R, "\n")
                 .match(LIST_ITEM_R);
@@ -1248,7 +1276,7 @@ var defaultRules: DefaultRules = {
         parse: TABLES.parseTable,
         react: function (node, output, state) {
             var getStyle = function (colIndex: number): {
-                [attr: string]: Attr,
+                [attr: string]: Attr;
             } {
                 return node.align[colIndex] == null
                     ? {}
@@ -1719,10 +1747,10 @@ var defaultRules: DefaultRules = {
 };
 
 /** (deprecated) */
-var ruleOutput = function (
+var ruleOutput = function <Rule>(
     // $FlowFixMe
     rules: OutputRules<Rule>,
-    property: $Keys<Rule>,
+    property: keyof Rule,
 ) {
     if (!property && typeof console !== "undefined") {
         console.warn(
@@ -1736,6 +1764,8 @@ var ruleOutput = function (
         outputFunc: Output<any>,
         state: State,
     ) {
+        // @ts-expect-error [FEI-5003] - TS2349 - This expression is not callable.
+        //   Type 'unknown' has no call signatures.
         return rules[ast.type][property](ast, outputFunc, state);
     };
     return nestedRuleOutput;
@@ -1760,10 +1790,12 @@ var reactFor = function (outputFunc: ReactNodeOutput): ReactOutput {
                     typeof nodeOut === "string" &&
                     typeof lastResult === "string"
                 ) {
+                    // @ts-expect-error [FEI-5003] - TS2322 - Type 'string' is not assignable to type 'null'.
                     lastResult = lastResult + nodeOut;
                     result[result.length - 1] = lastResult;
                 } else {
                     result.push(nodeOut);
+                    // @ts-expect-error [FEI-5003] - TS2322 - Type 'ReactNode' is not assignable to type 'null'.
                     lastResult = nodeOut;
                 }
             }
@@ -1795,10 +1827,10 @@ var htmlFor = function (outputFunc: HtmlNodeOutput): HtmlOutput {
     return nestedOutput;
 };
 
-var outputFor = function (
+var outputFor = function <Rule>(
     rules: OutputRules<Rule>,
-    property: $Keys<Rule>,
-    defaultState: ?State = {},
+    property: keyof Rule,
+    defaultState: State | null = {},
 ) {
     if (!property) {
         throw new Error(
@@ -1810,14 +1842,15 @@ var outputFor = function (
     }
 
     var latestState: State;
-    // $FlowFixMe[incompatible-type]
     var arrayRule: ArrayRule = rules.Array || defaultRules.Array;
 
     // Tricks to convince tsc that this var is not null:
+    // @ts-expect-error [FEI-5003] - TS2538 - Type 'symbol' cannot be used as an index type.
     var arrayRuleCheck = arrayRule[property];
     if (!arrayRuleCheck) {
         throw new Error(
             "simple-markdown: outputFor: to join nodes of type `" +
+                // @ts-expect-error [FEI-5003] - TS2469 - The '+' operator cannot be applied to type 'symbol'.
                 property +
                 "` you must provide an `Array:` joiner rule with that type, " +
                 "Please see the docs for details on specifying an Array rule.",
@@ -1831,6 +1864,8 @@ var outputFor = function (
         if (Array.isArray(ast)) {
             return arrayRuleOutput(ast, nestedOutput, state);
         } else {
+            // @ts-expect-error [FEI-5003] - TS2349 - This expression is not callable.
+            //   Type 'unknown' has no call signatures.
             return rules[ast.type][property](ast, nestedOutput, state);
         }
     };
@@ -1842,12 +1877,12 @@ var outputFor = function (
     return outerOutput;
 };
 
-// $FlowFixMe[incompatible-call]
+// @ts-expect-error [FEI-5003] - TS2345 - Argument of type 'DefaultRules' is not assignable to parameter of type 'ParserRules'.
 var defaultRawParse = parserFor(defaultRules);
 
 var defaultBlockParse = function (
     source: string,
-    state: ?State,
+    state?: State | null,
 ): Array<SingleASTNode> {
     state = state || {};
     state.inline = false;
@@ -1856,7 +1891,7 @@ var defaultBlockParse = function (
 
 var defaultInlineParse = function (
     source: string,
-    state: ?State,
+    state?: State | null,
 ): Array<SingleASTNode> {
     state = state || {};
     state.inline = true;
@@ -1865,7 +1900,7 @@ var defaultInlineParse = function (
 
 var defaultImplicitParse = function (
     source: string,
-    state: ?State,
+    state?: State | null,
 ): Array<SingleASTNode> {
     var isBlock = BLOCK_END_R.test(source);
     state = state || {};
@@ -1873,23 +1908,26 @@ var defaultImplicitParse = function (
     return defaultRawParse(source, state);
 };
 
-// $FlowFixMe[incompatible-call]
 var defaultReactOutput: ReactOutput = outputFor(defaultRules, "react");
-// $FlowFixMe[incompatible-call]
 var defaultHtmlOutput: HtmlOutput = outputFor(defaultRules, "html");
 
-var markdownToReact = function (source: string, state: ?State): ReactElements {
+var markdownToReact = function (
+    source: string,
+    state?: State | null,
+): ReactElements {
     return defaultReactOutput(defaultBlockParse(source, state), state);
 };
 
-var markdownToHtml = function (source: string, state: ?State): string {
+var markdownToHtml = function (source: string, state?: State | null): string {
     return defaultHtmlOutput(defaultBlockParse(source, state), state);
 };
 
 // TODO: This needs definition
 type ReactMarkdownProps = any;
-var ReactMarkdown = function (props: ReactMarkdownProps): ReactElement {
-    var divProps = {};
+var ReactMarkdown: React.FC<ReactMarkdownProps> = function (
+    props,
+): React.ReactElement {
+    var divProps: Record<string, any> = {};
 
     for (var prop in props) {
         if (
@@ -1906,63 +1944,87 @@ var ReactMarkdown = function (props: ReactMarkdownProps): ReactElement {
 };
 
 type Exports = {
-    +defaultRules: DefaultRules,
-    +parserFor: (rules: ParserRules, defaultState?: ?State) => Parser,
-    +outputFor: <Rule: Object>(
+    readonly defaultRules: DefaultRules;
+    readonly parserFor: (
+        rules: ParserRules,
+        defaultState?: State | null | undefined,
+    ) => Parser;
+    readonly outputFor: <Rule>(
         rules: OutputRules<Rule>,
-        param: $Keys<Rule>,
-        defaultState?: ?State,
-    ) => Output<any>,
-
-    +ruleOutput: <Rule: Object>(
+        param: keyof Rule,
+        defaultState?: State | null | undefined,
+    ) => Output<any>;
+    readonly ruleOutput: <Rule>(
         rules: OutputRules<Rule>,
-        param: $Keys<Rule>,
-    ) => NodeOutput<any>,
-    +reactFor: (ReactNodeOutput) => ReactOutput,
-    +htmlFor: (HtmlNodeOutput) => HtmlOutput,
-
-    +inlineRegex: (regex: RegExp) => MatchFunction,
-    +blockRegex: (regex: RegExp) => MatchFunction,
-    +anyScopeRegex: (regex: RegExp) => MatchFunction,
-    +parseInline: (parse: Parser, content: string, state: State) => ASTNode,
-    +parseBlock: (parse: Parser, content: string, state: State) => ASTNode,
-
-    +markdownToReact: (source: string, state?: ?State) => ReactElements,
-    +markdownToHtml: (source: string, state?: ?State) => string,
-    +ReactMarkdown: (props: {source: string, [string]: any}) => ReactElement,
-
-    +defaultRawParse: (source: string, state?: ?State) => Array<SingleASTNode>,
-    +defaultBlockParse: (
+        param: keyof Rule,
+    ) => NodeOutput<any>;
+    readonly reactFor: (arg1: ReactNodeOutput) => ReactOutput;
+    readonly htmlFor: (arg1: HtmlNodeOutput) => HtmlOutput;
+    readonly inlineRegex: (regex: RegExp) => MatchFunction;
+    readonly blockRegex: (regex: RegExp) => MatchFunction;
+    readonly anyScopeRegex: (regex: RegExp) => MatchFunction;
+    readonly parseInline: (
+        parse: Parser,
+        content: string,
+        state: State,
+    ) => ASTNode;
+    readonly parseBlock: (
+        parse: Parser,
+        content: string,
+        state: State,
+    ) => ASTNode;
+    readonly markdownToReact: (
         source: string,
-        state?: ?State,
-    ) => Array<SingleASTNode>,
-    +defaultInlineParse: (
+        state?: State | null | undefined,
+    ) => ReactElements;
+    readonly markdownToHtml: (
         source: string,
-        state?: ?State,
-    ) => Array<SingleASTNode>,
-    +defaultImplicitParse: (
+        state?: State | null | undefined,
+    ) => string;
+    readonly ReactMarkdown: (props: {
+        source: string;
+        [key: string]: any;
+    }) => ReactElement;
+    readonly defaultRawParse: (
         source: string,
-        state?: ?State,
-    ) => Array<SingleASTNode>,
-
-    +defaultReactOutput: ReactOutput,
-    +defaultHtmlOutput: HtmlOutput,
-
-    +preprocess: (source: string) => string,
-    +sanitizeText: (text: Attr) => string,
-    +sanitizeUrl: (url: ?string) => ?string,
-    +unescapeUrl: (url: string) => string,
-    +htmlTag: (
+        state?: State | null | undefined,
+    ) => Array<SingleASTNode>;
+    readonly defaultBlockParse: (
+        source: string,
+        state?: State | null | undefined,
+    ) => Array<SingleASTNode>;
+    readonly defaultInlineParse: (
+        source: string,
+        state?: State | null | undefined,
+    ) => Array<SingleASTNode>;
+    readonly defaultImplicitParse: (
+        source: string,
+        state?: State | null | undefined,
+    ) => Array<SingleASTNode>;
+    readonly defaultReactOutput: ReactOutput;
+    readonly defaultHtmlOutput: HtmlOutput;
+    readonly preprocess: (source: string) => string;
+    readonly sanitizeText: (text: Attr) => string;
+    readonly sanitizeUrl: (
+        url?: string | null | undefined,
+    ) => string | null | undefined;
+    readonly unescapeUrl: (url: string) => string;
+    readonly htmlTag: (
         tagName: string,
         content: string,
-        attributes: ?{[any]: ?Attr},
-        isClosed: ?boolean,
-    ) => string,
-    +reactElement: (
+        attributes?:
+            | Partial<Record<any, Attr | null | undefined>>
+            | null
+            | undefined,
+        isClosed?: boolean | null | undefined,
+    ) => string;
+    readonly reactElement: (
         type: string,
         key: string | null,
-        props: {[string]: any},
-    ) => ReactElement,
+        props: {
+            [key: string]: any;
+        },
+    ) => ReactElement;
 };
 
 export type {
@@ -1997,7 +2059,6 @@ export type {
     SingleASTNode,
 };
 
-// $FlowFixMe
 var SimpleMarkdown: Exports = {
     defaultRules: defaultRules,
     parserFor: parserFor,
@@ -2012,6 +2073,7 @@ var SimpleMarkdown: Exports = {
     // default wrappers:
     markdownToReact: markdownToReact,
     markdownToHtml: markdownToHtml,
+    // @ts-expect-error [FEI-5003] - TS2322 - Type 'FC<any>' is not assignable to type '(props: { [key: string]: any; source: string; }) => ReactElement'.
     ReactMarkdown: ReactMarkdown,
 
     defaultBlockParse: defaultBlockParse,
@@ -2034,21 +2096,21 @@ var SimpleMarkdown: Exports = {
     reactFor: reactFor,
     htmlFor: htmlFor,
 
-    defaultParse: function () {
+    defaultParse: function (...args) {
         if (typeof console !== "undefined") {
             console.warn(
                 "defaultParse is deprecated, please use `defaultImplicitParse`",
             );
         }
-        return defaultImplicitParse.apply(null, (arguments: any));
+        return defaultImplicitParse.apply(null, args);
     },
-    defaultOutput: function () {
+    defaultOutput: function (...args) {
         if (typeof console !== "undefined") {
             console.warn(
                 "defaultOutput is deprecated, please use `defaultReactOutput`",
             );
         }
-        return defaultReactOutput.apply(null, (arguments: any));
+        return defaultReactOutput.apply(null, args);
     },
 };