/**
 * CommonMark's block structure, line by line — just enough of it to say which
 * lines Markdown shows as code, or hides in a raw HTML block or a multi-line
 * comment. faf uses it to tell its own marker lines from marker examples.
 *
 * The algorithm is the reference implementation's (commonmark.js, spec 0.31):
 * each line first continues the open containers (block quotes, list items —
 * a list item's lines sit at its content column, a tab after the marker
 * advancing to the next multiple of 4), then may open new blocks, then is
 * added to the innermost open block or continues a paragraph lazily. Only
 * what decides block structure is kept: no inline parsing, no link reference
 * definitions, no tables.
 *
 * A reader made with `containers: false` reads every line at column 0 with no
 * block quotes and no list items — the plain reading a text editor, an older
 * faf or another tool may apply. faf takes a block as its own only when both
 * readings agree (see inject.ts).
 *
 * What a line counts as hidden in:
 *   - fenced code (its opening and closing lines included) and indented code;
 *   - an HTML block of types 1-5 — <pre>/<script>/<style>/<textarea> up to the
 *     closing tag, a comment up to `-->`, <?…?>, <!X…>, <![CDATA[…]]> — except
 *     a comment that opens and closes on the one line (faf's own marker
 *     lines are such comments);
 *   - not an HTML block of types 6 or 7 (<div>, <details>, any lone tag): a
 *     comment inside raw HTML is still a comment. No fence or other block
 *     opens inside one until a blank line ends it.
 *
 * Speed: each line costs time in proportion to its length, however deep the
 * nesting — the reader never re-reads the rest of a line per nesting level.
 * Past MAX_OPEN_CONTAINERS open block quotes, lists and list items the reader
 * stops reading (`tooDeep`): faf cannot say for sure where such a file's
 * regions are, so the file is the user's — faf's block goes on top and every
 * byte stays.
 */
/** More open block quotes, lists and list items than this, and a reader stops
 *  reading (see {@link BlockReader.tooDeep}). */
export declare const MAX_OPEN_CONTAINERS = 100;
/** What hides a line: its region, as faf names it to the user. */
export type HiddenIn = 'code fence' | 'indented code' | 'html' | 'comment' | `<${string}>`;
/** Feeds a text line by line (terminators removed) and says which lines are hidden. */
export declare class BlockReader {
    private readonly containers;
    private stack;
    private ln;
    private offset;
    private column;
    private nextNonspace;
    private nextNonspaceColumn;
    private indent;
    private indented;
    private blank;
    private allClosed;
    private matched;
    private htmlStarted;
    private hiddenIn;
    /** Where the last whitespace scan of this line started (-1: none yet). */
    private scannedFrom;
    /** Per line, lazily: 1 where the rest of the line is a thematic break. */
    private breaks;
    private deep;
    /** With a limit (see {@link overflowAt}): open containers allowed, and
     *  where the line first opened one past it (-1: nowhere yet). */
    private limit;
    private overflow;
    private readonly starts;
    /** `containers: false` — the plain column-0 reading: no block quotes, no list items. */
    constructor(containers?: boolean);
    /** An independent copy, for trying lines out. */
    clone(): BlockReader;
    /**
     * Where in `ln` a reader in this state would open a block quote, list or
     * list item past `limit` open ones — the offset of that quote's `>` or that
     * item's marker — or -1 when the line leaves at most `limit` open. This
     * reader does not move: a copy reads the line.
     */
    overflowAt(ln: string, limit: number): number;
    /** True once more than MAX_OPEN_CONTAINERS block quotes, lists and list
     *  items were open at once. The reader then stops reading: what it says
     *  about that line and every later one means nothing, and a caller treats
     *  the file as one it cannot read for sure. */
    get tooDeep(): boolean;
    /** Read one line (no terminator). Returns what hides it, or null when it is shown as text. */
    line(ln: string): HiddenIn | null;
    /** The line that would close the region a column-0 line would now be hidden
     *  in (a fence or an HTML block of types 1-5 at the top level), or null. */
    closer(): string | null;
    private get tip();
    /** Step 1: the open containers the line continues. Returns the index of the
     *  last one it continues, or -1 when it closed a fence. */
    private continueContainers;
    /** Step 2: the blocks the line opens, from the container at `index`. Returns the block the rest of the line goes to. */
    private openBlocks;
    /** A block just opened at `at` (`res` 1: a container): with a limit set,
     *  remember the first place the line went past it (below the document
     *  only containers are open when a container is added). */
    private noteOverflow;
    /** Step 3: the rest of the line goes to `block`. */
    private addText;
    private addHtmlLine;
    /** Does the line continue the open block `b` (at `index`)? 0 yes, 1 no, 2 it closed a fence. */
    private continues;
    /** The document and a list always continue; a heading or a break never
     *  does; a paragraph and an HTML block of type 6 or 7 end at a blank line. */
    private continueOther;
    private continueQuote;
    private continueItem;
    private continueFence;
    private continueIndentedCode;
    /** The character at the next non-space position ('' at the line's end). */
    private get ch();
    /** True when the rest of the line, from the next non-space position, is a
     *  thematic break (see {@link thematicBreaks}; worked out once per line). */
    private breakAhead;
    private startQuote;
    private startHeading;
    private startFence;
    private startHtml;
    private startSetext;
    private startBreak;
    private startItem;
    private startIndentedCode;
    /** The list marker at the reader's position: its kind, where it sits and
     *  its content column (padding); null when there is none. */
    private listMarker;
    /** A bullet or an ordered marker followed by a space, a tab or the line's end. */
    private markerAt;
    private markerKind;
    /** The columns from the marker to the item's content: 1-4 spaces (or tabs
     *  to that many columns) after it; with 5 or more, or none (a blank item),
     *  the content starts one column after the marker. */
    private paddingAfter;
    private addChild;
    private closeUnmatched;
    /** The next non-space position from where the reader stands, its column,
     *  and the indent to it. A second call from inside the same run of spaces
     *  and tabs reuses the first scan (the column a run ends at does not depend
     *  on where in the run the scan starts), so a line is scanned once however
     *  many containers it continues. */
    private findNextNonspace;
    private advanceNextNonspace;
    /** Move `count` characters on (or, with `columns`, `count` columns: a tab may be taken in part). */
    private advanceOffset;
}