/**
 * Markdown → the ranges a live-preview surface decorates, as pure
 * tree-in / descriptors-out.
 *
 * This is the half of the CodeMirror editor that decides what a
 * document *looks* like, and it is deliberately the half with no
 * `@codemirror/view` import in it. Descriptors are plain
 * `{ from, to, type }` objects; turning them into `Decoration`s is
 * `livePreview.ts`'s job. The split buys two things:
 *
 *  - **These tests run in Node.** `packages/ui`'s Vitest project is
 *    `.ts`-only and has no DOM, on purpose. A test here parses real
 *    markdown with the real GFM parser and asserts real offsets —
 *    no jsdom, no mount, no story.
 *  - **The runtime stays incremental.** Tests hand in
 *    `markdownLanguage.parser.parse(text)`; the view hands in
 *    `syntaxTree(state)`, which CodeMirror has already reparsed
 *    incrementally. Same function, same offsets, and the expensive
 *    path is never the one under test.
 *
 * ### What separates this from `markdownSpans.ts`
 *
 * The sibling `MarkdownEditor` paints *behind* a `<textarea>`, so
 * every span it emits has to be metric-neutral — same glyph
 * advances, or the caret shears away from the letters. That is the
 * constraint this module does **not** have. CodeMirror owns the
 * caret and reflows around decorations, so a heading can genuinely
 * be larger, `**` can genuinely be hidden, and an image can
 * genuinely replace its own markup.
 *
 * That is the entire reason this subpath exists, and it is also why
 * it is a subpath: the capability costs ~176 KB gz of optional peer
 * and only a consumer that opts in should pay it.
 *
 * ### The one invariant
 *
 * **Concealment never touches the document.** Every descriptor here
 * describes a *view* over an unmodified markdown string. Hiding
 * `**` does not delete it; replacing `![alt](url)` with an image
 * does not rewrite it. The stored value stays byte-for-byte what
 * the user typed, which is the same no-HTML-in-the-data guarantee
 * the textarea version gets structurally — kept here by never
 * having a serialiser at all.
 */
import type { Tree } from "@lezer/common";
/**
 * A block-level treatment applied to a whole line.
 *
 * Headings carry their level because size is the point: this is the
 * "block-level type scaling" the textarea version had to give up.
 */
export type LivePreviewLineKind = "blockquote" | "code" | "heading1" | "heading2" | "heading3" | "heading4" | "heading5" | "heading6" | "table";
/** An inline treatment applied to a character range. */
export type LivePreviewMarkKind = "autolink" | "code" | "emphasis" | "linkText" | "strikethrough" | "strong" | "url";
/**
 * A column's alignment, as the delimiter row spells it.
 *
 * Logical rather than left/right, because everything else in this
 * fleet is: a table in an RTL locale should flip with the text, and
 * `text-align: start` is the property that does it for free.
 */
export type LivePreviewTableAlignment = "center" | "end" | "start";
/**
 * A run of cell content that shares one treatment.
 *
 * A rendered table cell is built from these rather than from the
 * raw slice, so a cell keeps everything the rest of the surface
 * gives a line: `**bold**` is bold, a link is a link, `` `code` ``
 * is monospaced, and the markers that said so are gone.
 */
export type LivePreviewTableSegment = {
    alt: string;
    type: "image";
    url: string;
} | {
    markKinds: readonly LivePreviewMarkKind[];
    text: string;
    type: "text";
    /** Present when the run is link text; the click target. */
    url?: string;
};
export type LivePreviewTableCell = {
    alignment: LivePreviewTableAlignment;
    /**
     * Where a click in this cell puts the caret.
     *
     * The rendered table is a view, so the only way back into the
     * markdown is to move the caret into it — and landing in the cell
     * the reader aimed at is the difference between "editable" and
     * "editable somewhere in there".
     */
    from: number;
    segments: readonly LivePreviewTableSegment[];
    to: number;
};
export type LivePreviewTableRow = {
    cells: readonly LivePreviewTableCell[];
    from: number;
    isHeader: boolean;
    to: number;
};
export type LivePreviewRange = {
    from: number;
    to: number;
} & ({
    /** A rendered image, standing in for its own `![alt](url)`. */
    alt: string;
    type: "image";
    url: string;
} | {
    /** A rendered task checkbox, standing in for `[ ]` / `[x]`. */
    isChecked: boolean;
    /**
     * The item's own text, which becomes the checkbox's
     * accessible name — a checkbox inside a `contenteditable` has
     * no `<label>` to inherit one from.
     */
    label: string;
    type: "task";
} | {
    /**
     * Syntax the reader does not need: `**`, `#`, `[`, `](…)`.
     *
     * `isConcealed` is the caret's answer, not the parser's. When
     * the selection is inside the construct — or the whole
     * surface is in raw mode — the marker stays in the flow and
     * is merely dimmed, which is what makes the syntax editable
     * at all.
     */
    isConcealed: boolean;
    type: "marker";
} | {
    lineKind: LivePreviewLineKind;
    type: "line";
} | {
    markKind: LivePreviewMarkKind;
    type: "mark";
    /** Present on `linkText` and `autolink`; the click target. */
    url?: string;
});
/**
 * A whole table, rendered — header row first, every row padded to
 * the same width so the widget has no geometry decisions left.
 *
 * Its own type, and its own pass, because of a hard CodeMirror
 * rule: **a block decoration may not come from a `ViewPlugin`.**
 * Replacing four lines with one element changes the document's
 * block structure, which the view has to know before it can decide
 * what the viewport even contains — so it has to come from a
 * `StateField`, which sees the whole document and no viewport.
 * Everything else here is viewport-limited and stays in the plugin.
 * The split is CodeMirror's, not ours.
 */
export type LivePreviewTableRange = {
    from: number;
    rows: readonly LivePreviewTableRow[];
    to: number;
    type: "table";
};
/** A selection range, in the two fields this module needs. */
export type LivePreviewSelection = {
    from: number;
    to: number;
};
export type ToLivePreviewRangesOptions = {
    /**
     * Limit the walk to a slice of the document — the view passes its
     * visible ranges, so a long description costs what is on screen
     * rather than what is stored. Omit both and the whole tree is
     * walked, which is what the tests do.
     */
    from?: number;
    /**
     * Raw mode — the "edit Markdown" toggle.
     *
     * Nothing is concealed, nothing is replaced by a widget, and no
     * line is rescaled. Syntax colouring stays, because the point of
     * the toggle is to see the markup, not to lose the highlighting.
     */
    isRawMode?: boolean;
    /**
     * Re-point a link before it becomes an `href`.
     *
     * The document's own URL goes through `toSafeLinkUrl` first, so
     * what arrives here has already been refused if it named an
     * executable scheme. What comes BACK is the consumer's own string
     * and is used as given — an app that returns a route is trusted
     * about its own routes.
     *
     * Return `undefined` to leave the link alone, which is also what
     * omitting this does. **Links only**: an image's `src` is not
     * offered, because a consumer that maps a document path to a page
     * URL would turn a working image into a broken one.
     *
     * The case it exists for: a relative path in a fetched or imported
     * document. `[the runbook](../docs/runbook.md)` resolves against
     * the page the reader is on, which is the consuming app, and lands
     * on nothing. Only the app knows what that path means.
     */
    resolveUrl?: (url: string) => string | undefined;
    selections: readonly LivePreviewSelection[];
    text: string;
    to?: number;
    tree: Tree;
};
/**
 * Inline ranges over a slice → the runs a renderer can build DOM
 * from, flattened.
 *
 * Everywhere else in this module a decoration is *applied* to text
 * CodeMirror is already drawing, so overlapping ranges are free —
 * the browser composes them. A widget draws its own text, so they
 * are not: `**a [b](c) d**` is one strong run overlapping one link
 * run, and something has to decide where the spans break. That is
 * this function, and the answer is per character, which is the only
 * version that cannot be defeated by a nesting nobody predicted.
 *
 * Concealed markers are dropped rather than split around, so a run
 * of bold text stays a single segment with its `**` gone from both
 * ends.
 */
export declare const toInlineSegments: ({ from, ranges, text, to, }: {
    from: number;
    ranges: readonly LivePreviewRange[];
    text: string;
    to: number;
}) => LivePreviewTableSegment[];
/**
 * Every decoration the document wants that a plugin may provide, in
 * tree order.
 *
 * Order is not sorted here on purpose — `Decoration.set(ranges,
 * true)` sorts, and doing it twice is the sort of thing that looks
 * free until a document is long.
 */
export declare const toLivePreviewRanges: ({ from, isRawMode, resolveUrl, selections, text, to, tree, }: ToLivePreviewRangesOptions) => LivePreviewRange[];
/**
 * The tables the document renders, whole-document.
 *
 * Separate from `toLivePreviewRanges` because CodeMirror requires
 * it: block decorations come from a `StateField`, inline ones from
 * a viewport-limited `ViewPlugin`, and the two passes agree via
 * `isTableRendered`.
 */
export declare const toLivePreviewTableRanges: ({ isRawMode, resolveUrl, selections, text, tree, }: Omit<ToLivePreviewRangesOptions, "from" | "to">) => LivePreviewTableRange[];
//# sourceMappingURL=livePreviewRanges.d.ts.map