@tabnas/markdown 0.6.2 → 0.7.2

package/dist/inline.d.ts

@@ -1,5 +1,245 @@
 import { MdNode } from './node.ts';
 import type { ParserOptions, RefMap } from './options.ts';
+/** One `*`, `_` or `~` run on the delimiter stack (§6.4). */
+type Delimiter = {
+    /** Character code of the delimiter character. */
+    cc: number;
+    /** Delimiters still unused; drops as pairs are consumed. */
+    numdelims: number;
+    /** Run length as originally scanned — what the rule of three is computed on. */
+    origdelims: number;
+    node: MdNode;
+    previous: Delimiter | null;
+    next: Delimiter | null;
+    canOpen: boolean;
+    canClose: boolean;
+};
+/** One `[` or `![` on the bracket stack (§6.3). */
+type Bracket = {
+    node: MdNode;
+    previous: Bracket | null;
+    /** Top of the delimiter stack when this bracket opened — the emphasis floor. */
+    previousDelimiter: Delimiter | null;
+    /** Offset of the `[` in the subject. */
+    index: number;
+    image: boolean;
+    /** Cleared on earlier openers once a link is built: no links in links. */
+    active: boolean;
+    /** Another bracket opened after this one, so its text contains a `[`. */
+    bracketAfter: boolean;
+};
+export type DelimScan = {
+    numdelims: number;
+    canOpen: boolean;
+    canClose: boolean;
+};
+/**
+ * The whole code point ending at `end`, so an astral character is classified
+ * as one character by the flanking rules rather than as a lone surrogate.
+ * Start of subject counts as a line ending (§6.4).
+ */
+export declare function codePointBefore(subject: string, end: number): string;
+/** The whole code point at `i`; end of subject counts as a line ending. */
+export declare function codePointAt(subject: string, i: number): string;
+/** End of the run of spaces starting at `pos`. */
+export declare function skipInitialSpaces(subject: string, pos: number): number;
+/** End of "spaces, and at most one line ending" starting at `pos` (§6.3). */
+export declare function matchSpnl(subject: string, pos: number): number;
+export type CodeSpanScan = {
+    closed: true;
+    end: number;
+    literal: string;
+} | {
+    closed: false;
+    end: number;
+    ticks: string;
+};
+/**
+ * §6.3: a code span runs from a backtick string to the next backtick string
+ * of *exactly* the same length. `closed: false` reports an unmatched opener,
+ * which is literal text; null means no backtick run starts at `pos`.
+ */
+export declare function scanCodeSpan(subject: string, pos: number): CodeSpanScan | null;
+export type EscapeScan = {
+    kind: 'linebreak' | 'char' | 'literal';
+    literal: string;
+    end: number;
+};
+/**
+ * §6.1/§6.7: a backslash escape, with `pos` at the backslash. Always
+ * succeeds: a backslash before anything unescapable is a literal backslash.
+ * The `linebreak` form consumes the following line's leading spaces.
+ */
+export declare function scanEscape(subject: string, pos: number): EscapeScan;
+export type AngleAutolinkScan = {
+    dest: string;
+    label: string;
+    end: number;
+};
+/** §6.5: an email or URI autolink in angle brackets. */
+export declare function scanAngleAutolink(subject: string, pos: number): AngleAutolinkScan | null;
+/** §6.6: a raw HTML tag (open, close, comment, PI, declaration or CDATA). */
+export declare function scanHtmlTag(subject: string, pos: number): {
+    raw: string;
+    end: number;
+} | null;
+/** §6.2: an entity or numeric character reference, decoded. */
+export declare function scanEntity(subject: string, pos: number): {
+    literal: string;
+    end: number;
+} | null;
+/**
+ * §6.4: classify the run of `cc` starting at `pos` without consuming it.
+ *
+ * A run is left-flanking iff it is not followed by Unicode whitespace and
+ * either not followed by Unicode punctuation or else preceded by whitespace
+ * or punctuation; right-flanking is the mirror image. `_` additionally may
+ * not open inside a word (rules 2, 4, 6, 8), which is what keeps
+ * `snake_case_words` intact; `*` has no such restriction.
+ */
+export declare function scanDelimiterRun(subject: string, pos: number, cc: number): DelimScan | null;
+/**
+ * §6.7/§6.8: how a line ending resolves, given the literal of the text node
+ * immediately before it. Two or more trailing spaces make a hard break;
+ * `trim` says the trailing spaces must be dropped from that node either way.
+ */
+export declare function classifyBreak(prevTextLiteral: string | null): {
+    hard: boolean;
+    trim: boolean;
+};
+/** §6.3: a link title at `pos`, without its delimiters, unescaped. */
+export declare function scanLinkTitle(subject: string, pos: number): {
+    title: string;
+    end: number;
+} | null;
+/**
+ * §6.3: a link destination at `pos` — either `<...>`, or a bare run with
+ * balanced unescaped parentheses and no ASCII control characters or spaces.
+ *
+ * The destination is backslash-unescaped and entity-decoded, but **not**
+ * percent-encoded: `[l](/ä)` yields `/ä`, not `/%C3%A4`. Encoding is a
+ * rendering concern and `html.ts` applies `normalizeURI` when it writes the
+ * attribute; the public AST promises the decoded form.
+ */
+export declare function scanLinkDestination(subject: string, pos: number): {
+    dest: string;
+    end: number;
+} | null;
+/**
+ * §4.7/§6.3: a link label at `pos`, including brackets. `rawLength` is what
+ * was consumed; `length` is 0 when the label is too long to be valid (§4.7:
+ * at most 999 characters between the brackets).
+ */
+export declare function scanLinkLabel(subject: string, pos: number): {
+    rawLength: number;
+    length: number;
+} | null;
+export type LinkTailScan = {
+    dest: string;
+    title: string | null;
+    end: number;
+};
+/**
+ * §6.3: the `(destination "title")` tail of an inline link, with `pos` just
+ * after the `]`. Null unless the whole tail — through the closing paren —
+ * is present.
+ */
+export declare function scanInlineLinkTail(subject: string, pos: number): LinkTailScan | null;
+export declare class InlineParser {
+    subject: string;
+    pos: number;
+    delimiters: Delimiter | null;
+    brackets: Bracket | null;
+    refmap: RefMap;
+    options: ParserOptions;
+    constructor(refmap: RefMap, options: ParserOptions);
+    /** Character code at `pos`, or -1 at the end of the subject. */
+    peek(): number;
+    /** Match a sticky regex at `pos`; on success advance past it. */
+    match(re: RegExp): string | null;
+    /** Spaces, and at most one line ending, between the parts of a link. */
+    spnl(): void;
+    /**
+     * The whole code point ending at `end`, so an astral character is
+     * classified as one character by the flanking rules rather than as a lone
+     * surrogate. Start of subject counts as a line ending (§6.4).
+     */
+    charBefore(end: number): string;
+    /** The whole code point at `i`; end of subject counts as a line ending. */
+    charAtPos(i: number): string;
+    /**
+     * A code span runs from a backtick string to the next backtick string of
+     * *exactly* the same length. Unmatched opening backticks are literal text.
+     */
+    parseBackticks(block: MdNode): boolean;
+    parseBackslash(block: MdNode): boolean;
+    parseAutolink(block: MdNode): boolean;
+    makeAutolink(destination: string, label: string): MdNode;
+    parseHtmlTag(block: MdNode): boolean;
+    /** Classify the run of `cc` starting at `pos` without consuming it. */
+    scanDelims(cc: number): DelimScan | null;
+    /** Emit a delimiter run as text and push it on the delimiter stack. */
+    handleDelim(cc: number, block: MdNode): boolean;
+    removeDelimiter(delim: Delimiter): void;
+    /**
+     * The spec's "process emphasis" procedure. `stackBottom` is the floor: for
+     * the whole-block call it is null, and for the inlines of a link it is the
+     * delimiter that was on top when the link's `[` opened.
+     */
+    processEmphasis(stackBottom: Delimiter | null): void;
+    /** Link title without its delimiters, unescaped; null if none here. */
+    parseLinkTitle(): string | null;
+    /**
+     * Link destination: either `<...>`, or a bare run with balanced unescaped
+     * parentheses and no ASCII control characters or spaces. See
+     * `scanLinkDestination` for why the value is decoded but not
+     * percent-encoded.
+     */
+    parseLinkDestination(): string | null;
+    /** Length of the link label at `pos`, including brackets; 0 if invalid. */
+    parseLinkLabel(): number;
+    addBracket(node: MdNode, index: number, image: boolean): void;
+    removeBracket(): void;
+    parseOpenBracket(block: MdNode): boolean;
+    /** `!` only matters when it introduces an image. */
+    parseBang(block: MdNode): boolean;
+    /**
+     * The spec's "look for link or image" procedure. On a `]`, walk back to
+     * the newest bracket opener and try, in order: an inline `(dest "title")`,
+     * a full `[label]`, a collapsed `[]` or a shortcut reference. Anything that
+     * fails backtracks to just after the `]` and leaves a literal `]`.
+     */
+    parseCloseBracket(block: MdNode): boolean;
+    parseEntity(block: MdNode): boolean;
+    parseString(block: MdNode): boolean;
+    /**
+     * §6.7/§6.8: two or more spaces before the line ending make a hard break,
+     * anything else a soft one. Trailing spaces are dropped either way, as is
+     * the indentation of the next line.
+     */
+    parseNewline(block: MdNode): boolean;
+    /** One inline construct at `pos`; false only at the end of the subject. */
+    parseInline(block: MdNode): boolean;
+    /** Nothing claimed the character at `pos`: consume it as literal text. */
+    parseLiteralChar(block: MdNode): boolean;
+    /**
+     * Reset for one block's raw content; false when the trimmed subject is
+     * empty. Trimming is what stops trailing spaces at the end of a block
+     * from making a hard break, and drops the leading indentation of the
+     * first line.
+     */
+    beginBlock(block: MdNode): boolean;
+    /** The tail of a block's inline parse: clear the raw content, resolve
+     * emphasis over the whole delimiter stack. */
+    finishBlock(block: MdNode): void;
+    /** Parse one paragraph or heading's raw content into inline children. */
+    parse(block: MdNode): void;
+    /**
+     * §4.7: consume leading link reference definitions. Called by the block
+     * phase while finalizing a paragraph, repeatedly, until it returns 0.
+     */
+    parseReference(s: string): number;
+}
 /**
  * Recognise GFM autolink literals throughout one finished block's inlines.
  *
@@ -11,9 +251,19 @@ export declare function linkifyAutolinks(block: MdNode): void;
  * every paragraph, heading and table cell into inline children.
  */
 export declare function parseInlines(doc: MdNode, refmap: RefMap, options: ParserOptions): void;
+/**
+ * Walk the finished block tree, handing every inline content block
+ * (paragraphs, headings, table cells) to `fn` and running the GFM
+ * autolink-literal post-pass after it. This is the one iteration both
+ * inline drivers share — the hand scanner above and the engine path — so
+ * which blocks get inline parsing, and when linkify runs, is decided
+ * exactly once.
+ */
+export declare function forEachInlineBlock(doc: MdNode, options: ParserOptions, fn: (block: MdNode) => void): void;
 /**
  * Consume link reference definitions from the front of a paragraph's raw
  * content, adding them to `refmap`. Returns the number of characters
  * consumed, or 0 if `s` does not start with a definition.
  */
 export declare function parseReference(s: string, refmap: RefMap): number;
+export {};