@khanacademy/simple-markdown 0.8.6 → 0.9.1

package/dist/index.d.ts

@@ -1,2 +1,187 @@
-// @flow
-export * from "../src/index.js";
+/**
+ * Simple-Markdown
+ * ===============
+ *
+ * Simple-Markdown's primary goal is to be easy to adapt. It aims
+ * to be compliant with John Gruber's [Markdown Syntax page][1],
+ * but compatiblity with other markdown implementations' edge-cases
+ * will be sacrificed where it conflicts with simplicity or
+ * extensibility.
+ *
+ * If your goal is to simply embed a standard markdown implementation
+ * in your website, simple-markdown is probably not the best library
+ * for you (although it should work). But if you have struggled to
+ * customize an existing library to meet your needs, simple-markdown
+ * might be able to help.
+ *
+ * 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";
+type Capture = (Array<string> & {
+    index: number;
+}) | (Array<string> & {
+    index?: number;
+});
+type Attr = string | number | boolean | null | undefined;
+type SingleASTNode = {
+    type: string;
+    [key: string]: any;
+};
+type UnTypedASTNode = {
+    [key: string]: any;
+};
+type ASTNode = SingleASTNode | Array<SingleASTNode>;
+type State = {
+    key?: string | number | undefined;
+    inline?: boolean | null | undefined;
+    [key: string]: any;
+};
+type ReactElement = React.ReactElement<any>;
+type ReactElements = React.ReactNode;
+type MatchFunction = {
+    regex?: RegExp;
+} & ((source: string, state: State, prevCapture: string) => Capture | null | undefined);
+type Parser = (source: string, state?: State | null | undefined) => Array<SingleASTNode>;
+type ParseFunction = (capture: Capture, nestedParse: Parser, state: State) => UnTypedASTNode | ASTNode;
+type SingleNodeParseFunction = (capture: Capture, nestedParse: Parser, state: State) => UnTypedASTNode;
+type Output<Result> = (node: ASTNode, state?: State | null | undefined) => Result;
+type NodeOutput<Result> = (node: SingleASTNode, nestedOutput: Output<Result>, state: State) => Result;
+type ArrayNodeOutput<Result> = (node: Array<SingleASTNode>, nestedOutput: Output<Result>, state: State) => Result;
+type ReactOutput = Output<ReactElements>;
+type ReactNodeOutput = NodeOutput<ReactElements>;
+type HtmlOutput = Output<string>;
+type HtmlNodeOutput = NodeOutput<string>;
+type ParserRule = {
+    readonly order: number;
+    readonly match: MatchFunction;
+    readonly quality?: (capture: Capture, state: State, prevCapture: string) => number;
+    readonly parse: ParseFunction;
+};
+type SingleNodeParserRule = {
+    readonly order: number;
+    readonly match: MatchFunction;
+    readonly quality?: (capture: Capture, state: State, prevCapture: string) => number;
+    readonly parse: SingleNodeParseFunction;
+};
+type ReactOutputRule = {
+    readonly react: ReactNodeOutput | null;
+};
+type HtmlOutputRule = {
+    readonly html: HtmlNodeOutput | null;
+};
+type ArrayRule = {
+    readonly react?: ArrayNodeOutput<ReactElements>;
+    readonly html?: ArrayNodeOutput<string>;
+    readonly [key: string]: ArrayNodeOutput<any>;
+};
+type ParserRules = {
+    readonly Array?: ArrayRule;
+    readonly [type: string]: ParserRule;
+};
+type OutputRules<Rule> = {
+    readonly Array?: ArrayRule;
+    readonly [type: string]: Rule;
+};
+type Rules<OutputRule> = {
+    readonly Array?: ArrayRule;
+    readonly [type: string]: ParserRule & OutputRule;
+};
+type ReactRules = {
+    readonly Array?: {
+        readonly react: ArrayNodeOutput<ReactElements>;
+    };
+    readonly [type: string]: ParserRule & ReactOutputRule;
+};
+type HtmlRules = {
+    readonly Array?: {
+        readonly html: ArrayNodeOutput<string>;
+    };
+    readonly [type: string]: ParserRule & HtmlOutputRule;
+};
+type NonNullReactOutputRule = {
+    readonly react: ReactNodeOutput;
+};
+type ElementReactOutputRule = {
+    readonly react: NodeOutput<ReactElement>;
+};
+type TextReactOutputRule = {
+    readonly react: NodeOutput<string>;
+};
+type NonNullHtmlOutputRule = {
+    readonly html: HtmlNodeOutput;
+};
+type DefaultInRule = SingleNodeParserRule & ReactOutputRule & HtmlOutputRule;
+type TextInOutRule = SingleNodeParserRule & TextReactOutputRule & NonNullHtmlOutputRule;
+type LenientInOutRule = SingleNodeParserRule & NonNullReactOutputRule & NonNullHtmlOutputRule;
+type DefaultInOutRule = SingleNodeParserRule & ElementReactOutputRule & NonNullHtmlOutputRule;
+type DefaultRules = {
+    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 Exports = {
+    readonly defaultRules: DefaultRules;
+    readonly parserFor: (rules: ParserRules, defaultState?: State | null | undefined) => Parser;
+    readonly outputFor: <Rule>(rules: OutputRules<Rule>, param: keyof Rule, defaultState?: State | null | undefined) => Output<any>;
+    readonly ruleOutput: <Rule>(rules: OutputRules<Rule>, 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 | null | undefined) => ReactElements;
+    readonly markdownToHtml: (source: string, state?: State | null | undefined) => string;
+    readonly ReactMarkdown: (props: {
+        source: string;
+        [key: string]: any;
+    }) => ReactElement;
+    readonly defaultRawParse: (source: string, 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?: Partial<Record<any, Attr | null | undefined>> | null | undefined, isClosed?: boolean | null | undefined) => string;
+    readonly reactElement: (type: string, key: string | null, props: {
+        [key: string]: any;
+    }) => ReactElement;
+};
+export type { State, Parser, Output, ReactOutput, HtmlOutput, Capture, MatchFunction, ParseFunction, NodeOutput, ArrayNodeOutput, ReactNodeOutput, ParserRule, ReactOutputRule, HtmlOutputRule, ParserRules, OutputRules, Rules, ReactRules, HtmlRules, SingleASTNode, };
+declare var SimpleMarkdown: Exports;
+export default SimpleMarkdown;