@promptctl/rich-js 0.24.0 → 0.24.1

package/dist/renderables/markdown-parse.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Markdown's parse, with no dependency: a source read into blocks, then the
+ * text of each block read into inlines — the two passes markdown-it, Rich's
+ * parser, makes. Nothing here reads a `RenderOptions`, so a `Markdown` parses
+ * its source once, when it is made, as Rich's does, and every render after
+ * only walks the tokens.
+ *
+ * Block structure is read as CommonMark reads it: a blockquote and a list
+ * item are both containers, their lines tokenized as Markdown of their own
+ * once the container's marker or indentation is cut off. A table, which
+ * CommonMark has none of, and an HTML block are read as markdown-it reads
+ * them.
+ */
+/** Where a table column's cells sit, from the colons on its delimiter cell. None is GFM's no alignment, which Rich leaves to its column: left. */
+export type CellAlign = "left" | "center" | "right" | undefined;
+interface TableColumn<Text> {
+    readonly header: Text;
+    readonly align: CellAlign;
+}
+/** A heading's level: an ATX heading's count of `#`s, or 1 and 2 for a setext heading's `=` and `-`. */
+export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+/**
+ * A block, its text as `Text`: the source's own text after the block pass,
+ * and that text read into inlines after the inline pass, which is what
+ * `parseMarkdown` hands back. `Mark` is what the block pass keeps besides:
+ * none, once the inline pass has dropped its marks.
+ */
+export type MdToken<Text = readonly Inline[], Mark = never> = {
+    type: "heading";
+    level: HeadingLevel;
+    text: Text;
+} | {
+    type: "paragraph";
+    text: Text;
+} | {
+    type: "code_block";
+    code: string;
+} | {
+    type: "hr";
+}
+/** `start` is an ordered list's first number, as its source writes it; a bullet list has none. Each item is its blocks. */
+ | {
+    type: "list";
+    start: number | undefined;
+    items: readonly (readonly MdToken<Text, Mark>[])[];
+} | {
+    type: "blockquote";
+    children: readonly MdToken<Text, Mark>[];
+}
+/** Each row holds one cell per column: a short row filled out with empty cells, a long one cut. */
+ | {
+    type: "table";
+    columns: readonly TableColumn<Text>[];
+    rows: readonly (readonly Text[])[];
+}
+/** Kept, though nothing draws it, as Rich exits it like any other block. */
+ | {
+    type: "html_block";
+} | Mark;
+/** The element markdown-it makes of a pair of delimiters. */
+type EmphasisTag = "em" | "strong" | "s";
+/**
+ * CommonMark's inlines, as one block's text reads: a code span, emphasis or a
+ * link holding inlines of its own, an autolink, an image, inline HTML, a line
+ * ending, and text — a backslash escape and a character reference already the
+ * characters they stand for. Emphasis is named by the element markdown-it
+ * makes of it, GFM's strikethrough `s` among them.
+ */
+export type Inline = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "code";
+    code: string;
+} | {
+    kind: "emphasis";
+    tag: EmphasisTag;
+    children: readonly Inline[];
+} | {
+    kind: "link";
+    children: readonly Inline[];
+    url: string;
+}
+/** `text` is the URL as written, normalized as markdown-it shows it, never read as Markdown. */
+ | {
+    kind: "autolink";
+    text: string;
+    url: string;
+}
+/** `alt` is as written, never read as Markdown. */
+ | {
+    kind: "image";
+    alt: string;
+    src: string;
+}
+/** `content` is the tag as written, markdown-it's `html_inline` content. */
+ | {
+    kind: "html";
+    content: string;
+}
+/** markdown-it's `softbreak` and `hardbreak`: tokens of their own, never joined to the text beside them. */
+ | {
+    kind: "softbreak";
+} | {
+    kind: "hardbreak";
+};
+/** `source` read as Markdown: its blocks, and the text in each read into inlines. A line ends at `\r\n`, `\r` or `\n`, as markdown-it normalizes them. */
+export declare function parseMarkdown(source: string): MdToken[];
+export {};