/**
 * Every edit the editor can make, as pure text-in / text-out.
 *
 * Nothing here touches the DOM, so the whole formatting grammar —
 * what Ctrl+B does to a selection that already has asterisks
 * outside it, what Enter does at the end of an empty list item,
 * how an ordered list renumbers when you promote three paragraphs
 * — is a Node test rather than a browser one. That split is not
 * tidiness: the browser suite is where the expensive tests live,
 * and this is the half with all the edge cases.
 *
 * ### Everything is `{ selectionEnd, selectionStart, text }`
 *
 * The same three fields a `<textarea>` exposes, in and out. A
 * command takes the state the control is in and returns the state
 * it should be in, and the component's only job is to get from one
 * to the other without breaking undo.
 *
 * ### And that is what `getMinimalEdit` is for
 *
 * Writing `textarea.value = next` — or handing a controlled React
 * `value` a new string — **erases the browser's undo stack**. Ctrl+Z
 * after a toolbar click then jumps past everything the user typed,
 * or does nothing at all. The fix is to express the change as a
 * *replacement of a range*, select that range, and let the browser
 * apply it through its own editing pipeline
 * (`document.execCommand("insertText", …)`, which is deprecated and
 * is still the only API that appends to the native undo stack).
 *
 * So commands return whole strings, because that is the easy thing
 * to reason about and to test, and `getMinimalEdit` turns the pair
 * back into the range replacement the DOM wants. A bold toggle
 * becomes one undo step covering four characters instead of a
 * document-sized one.
 *
 * ### No HTML, anywhere
 *
 * Every function here returns markdown. There is no serialiser, no
 * intermediate document model, and no HTML string — which is the
 * mechanical reason `<b>` cannot reach the stored value: nothing in
 * this file can produce one, and the surface these run against is a
 * `<textarea>`, which takes `text/plain` off the clipboard and
 * nothing else.
 */
export type MarkdownSelection = {
    selectionEnd: number;
    selectionStart: number;
    text: string;
};
export type MarkdownLinePrefix = {
    /**
     * Matches a line that **already is** this kind, which is what
     * decides whether the toggle adds or removes.
     */
    pattern: RegExp;
    /**
     * What to take off before adding — wider than `pattern`, and the
     * two genuinely differ. A task list *detects* `- [ ] `, because a
     * plain bullet is not a task; but it *strips* the bare `- ` too,
     * so toggling a task on an existing bullet replaces the marker
     * instead of producing `- - [ ] `. Collapsing these into one
     * regex is how that bug gets written.
     */
    stripPattern: RegExp;
    /**
     * The prefix to add, given the line's zero-based position inside
     * the selection. Ordered lists are the only kind that uses the
     * argument, and it is why this is a function.
     */
    toPrefix: (indexInSelection: number) => string;
};
/**
 * The prefixes the toolbar and the shortcuts drive, written out
 * rather than derived.
 *
 * `task` deliberately matches a plain bullet's prefix *plus* the
 * checkbox, so toggling a task on an existing `- item` replaces the
 * bullet rather than nesting one inside the other.
 */
export declare const MARKDOWN_LINE_PREFIXES: {
    readonly blockquote: {
        readonly pattern: RegExp;
        readonly stripPattern: RegExp;
        readonly toPrefix: () => string;
    };
    readonly bulletList: {
        readonly pattern: RegExp;
        readonly stripPattern: RegExp;
        readonly toPrefix: () => string;
    };
    readonly orderedList: {
        readonly pattern: RegExp;
        readonly stripPattern: RegExp;
        readonly toPrefix: (indexInSelection: number) => string;
    };
    readonly taskList: {
        readonly pattern: RegExp;
        readonly stripPattern: RegExp;
        readonly toPrefix: () => string;
    };
};
/** The character range of the whole lines a selection touches. */
export declare const getLineRange: ({ selectionEnd, selectionStart, text, }: MarkdownSelection) => {
    end: number;
    start: number;
};
/** Type text over the selection, as if it had been typed. */
export declare const insertText: ({ selectionEnd, selectionStart, text }: MarkdownSelection, insertion: string) => MarkdownSelection;
/**
 * Wrap or unwrap a selection in `**`, `_`, `` ` `` or `~~`.
 *
 * Three cases, and the middle one is the one hand-rolled editors
 * miss: the markers may be **outside** the selection. Double-click
 * a word inside `**bold**` and the browser selects `bold`, not
 * `**bold**`, so a naive implementation adds a second pair and
 * produces `****bold****`. Looking just past both ends first is
 * what makes Ctrl+B genuinely a toggle.
 */
export declare const toggleInlineMarker: ({ selectionEnd, selectionStart, text }: MarkdownSelection, marker: string) => MarkdownSelection;
/**
 * Add or remove a line prefix across every line the selection
 * touches.
 *
 * Removal wins when **every** line already has the prefix, which is
 * the behaviour that makes the toolbar button a toggle rather than
 * a one-way trip. A mixed block — two bullets and a paragraph —
 * gets the prefix added to all three, because the alternative is a
 * button whose effect depends on invisible state.
 */
export declare const toggleLinePrefix: (state: MarkdownSelection, { pattern, stripPattern, toPrefix }: MarkdownLinePrefix) => MarkdownSelection;
/**
 * `#` … `######`, and pressing the same level twice removes it.
 *
 * A heading replaces any heading already on the line rather than
 * stacking, so H2-then-H3 is H3 and not `## ### `.
 */
export declare const toggleHeading: (state: MarkdownSelection, level: number) => MarkdownSelection;
/**
 * Markdown-safe `![alt](url)`.
 *
 * The alt text is escaped rather than stripped — a filename with a
 * bracket in it is legal, and silently deleting characters out of
 * somebody's caption is worse than the escape being visible. The
 * destination goes inside angle brackets when it contains anything
 * that would end the destination early, which is the CommonMark
 * spelling for "this whole thing is the URL".
 */
export declare const toMarkdownImage: ({ alt, url, }: {
    alt?: string;
    url: string;
}) => string;
/** Insert an image at the caret, replacing any selection. */
export declare const insertImage: (state: MarkdownSelection, image: {
    alt?: string;
    url: string;
}) => MarkdownSelection;
/**
 * `[selected](url)`, with the caret parked in the destination when
 * there is nothing to put there yet — which is the only reason this
 * is not `toggleInlineMarker` with a funny marker.
 */
export declare const insertLink: (state: MarkdownSelection, url?: string) => MarkdownSelection;
/**
 * Does this pasted string want to become a link?
 *
 * Deliberately strict. A paste that is *mostly* a URL — a sentence
 * with one in it, two URLs on two lines — is left alone, because
 * the cost of guessing wrong is silently mangling something the
 * user meant to paste literally. One absolute `http(s)` URL, no
 * inner whitespace, nothing either side of it.
 *
 * `mailto:` and bare `www.` are excluded on the same principle:
 * they are the cases where "did they mean a link?" genuinely has
 * two answers.
 */
export declare const isLinkPaste: (pasted: string) => boolean;
/**
 * Paste a URL over selected text and get `[selected](url)`.
 *
 * Every editor the owner uses does this — Outline, Notion, Slack,
 * GitHub — and its absence is why a link pasted into Docket stayed
 * flat text nobody could click. It is the one paste behaviour worth
 * intercepting, and it is still markdown in and markdown out.
 *
 * Unlike `insertLink`, the caret lands **after** the whole
 * insertion rather than inside the destination: the URL is already
 * known, so parking the selection in it would ask the user to
 * replace what they just pasted.
 *
 * With an empty selection this is a plain insertion of the URL —
 * autolink renders a bare URL as a link anyway, so wrapping it in
 * `[](…)` with no text would produce an empty link instead.
 */
export declare const wrapSelectionInLink: (state: MarkdownSelection, url: string) => MarkdownSelection;
/**
 * What Enter should do inside a list, a task list or a blockquote —
 * or `null` when it should do the ordinary thing and the component
 * must not call `preventDefault`.
 *
 * Two behaviours, and the second is the one people notice when it
 * is missing: continuing the marker onto the next line, and
 * **clearing** it when the item is empty. Without the second, an
 * empty bullet is a trap — every Enter makes another empty bullet
 * and the only way out is Backspace.
 *
 * Returning `null` rather than the unchanged state is deliberate.
 * A plain Enter has to fall through to the browser so it lands on
 * the native undo stack as a normal typing step.
 */
export declare const continueList: ({ selectionEnd, selectionStart, text, }: MarkdownSelection) => MarkdownSelection | null;
/** Two spaces onto every line the selection touches. */
export declare const indentLines: (state: MarkdownSelection) => MarkdownSelection;
/** Up to two spaces, or one tab, off every line. */
export declare const outdentLines: (state: MarkdownSelection) => MarkdownSelection;
/**
 * The smallest range replacement that turns `before` into `after`.
 *
 * Whole-string commands are easy to write and easy to test; whole
 * string *assignments* destroy undo. This closes the gap between
 * the two by finding the common prefix and the common suffix and
 * reporting only what is left, so a bold toggle on one word is one
 * four-character edit and one undo step — not a document-sized one
 * that swallows the paragraph the user typed before it.
 *
 * The prefix scan runs first and the suffix scan is bounded by what
 * it left, so the two can never overlap on a repetitive string
 * (`aaaa` → `aaaaa` reports an insert, not a negative range).
 */
export declare const getMinimalEdit: (before: string, after: string) => {
    end: number;
    start: number;
    text: string;
};
//# sourceMappingURL=markdownCommands.d.ts.map