@crewlethq/ui 0.29.0 → 0.31.0

package/dist/Markdown/grammar.d.ts

@@ -0,0 +1,170 @@
+/**
+ * The Markdown grammar every Crewlet surface reads and writes: a CommonMark
+ * subset, parsed into blocks and inline matches and never into markup.
+ *
+ * ONE GRAMMAR FOR READING AND EDITING. An application renders these blocks
+ * with its own renderer (which elements, which link schemes, where a picture
+ * is fetched from are decisions about its own content), and `RichEditor`
+ * builds its document from the same blocks. A page that reads one way and
+ * edits another is a page whose author cannot trust what they see, and two
+ * copies of a grammar drift the first time somebody fixes one of them.
+ *
+ * NOTHING HERE PRODUCES MARKUP. The parser answers plain objects and strings,
+ * so a renderer that builds elements from them never parses HTML, which is
+ * what lets a consumer enforce Trusted Types with no policy at all.
+ *
+ * WHAT IT READS: ATX headings, paragraphs, emphasis and strong, strikethrough,
+ * inline code, fenced code, links, images, autolinks, backslash escapes,
+ * bullet and ordered lists (nested), task list items, block quotes, callouts
+ * (`> [!NOTE]`, GitHub's alert syntax), tables, thematic breaks and hard line
+ * breaks.
+ *
+ * WHAT IT DELIBERATELY DOES NOT: raw HTML (read as its own text, never
+ * parsed), reference links, footnotes, bare autolink literals, setext
+ * headings and indented code. Each is a shape these documents do not use, and
+ * every one of them is a place a parser grows a branch nobody exercises.
+ */
+export type MarkdownAlign = 'left' | 'center' | 'right';
+/**
+ * A callout's tone, by GitHub's alert names: `> [!NOTE]`, `> [!TIP]`,
+ * `> [!IMPORTANT]`, `> [!WARNING]` and `> [!CAUTION]`. The syntax is
+ * GitHub's so a page reads as a callout on GitHub too, and anywhere else it
+ * degrades to a quote whose first line names its tone.
+ */
+export type MarkdownCalloutTone = 'note' | 'tip' | 'important' | 'warning' | 'caution';
+export declare const MARKDOWN_CALLOUT_TONES: readonly MarkdownCalloutTone[];
+/**
+ * Each tone's name as a reader sees it, on the callout's own label line: the
+ * one set of words a renderer and the editor both draw.
+ */
+export declare const MARKDOWN_CALLOUT_NAMES: Readonly<Record<MarkdownCalloutTone, string>>;
+/** One parsed block. */
+export type MarkdownBlock = {
+    kind: 'heading';
+    level: number;
+    text: string;
+} | {
+    kind: 'paragraph';
+    text: string;
+} | {
+    kind: 'code';
+    lang: string;
+    text: string;
+    fence: MarkdownFence;
+} | {
+    kind: 'quote';
+    blocks: MarkdownBlock[];
+} | {
+    kind: 'callout';
+    tone: MarkdownCalloutTone;
+    blocks: MarkdownBlock[];
+} | {
+    kind: 'list';
+    ordered: boolean;
+    start: number;
+    /** The bullet character (`-`, `*`, `+`) or the ordered delimiter (`.`, `)`). */
+    marker: string;
+    /** Whether a blank line separates any two of its items. */
+    loose: boolean;
+    items: MarkdownListItem[];
+} | {
+    kind: 'table';
+    head: string[];
+    align: MarkdownAlign[];
+    rows: string[][];
+} | {
+    kind: 'rule';
+};
+export type MarkdownFence = '```' | '~~~';
+export interface MarkdownListItem {
+    /** null when the item is not a task item, which is not "unticked". */
+    checked: boolean | null;
+    blocks: MarkdownBlock[];
+}
+/** A top-level block and the source lines it was read from, `[start, end)`. */
+export interface MarkdownSpan {
+    block: MarkdownBlock;
+    start: number;
+    end: number;
+}
+/**
+ * Whether a href may be followed at all, and in what form: `http:`, `https:`,
+ * `mailto:` and an application's own `#/` routes. Anything else is null.
+ *
+ * In-app routes (`#/work/ENG-1`) are allowed because they are how a page
+ * points at the company's own objects and they cannot leave the application.
+ * Everything else must carry an allowed scheme, including, deliberately, a
+ * bare `/path` or `guide.html`, which would resolve against whatever origin
+ * serves the page and mean nothing to a reader.
+ */
+export declare function safeHref(raw: string): string | null;
+/** Whether `line` closes a fence opened with `marker`. */
+export declare function markdownClosesFence(line: string, marker: MarkdownFence): boolean;
+/** The fence `line` opens, with its info string, or null when it opens none. */
+export declare function markdownFenceOf(line: string): {
+    marker: MarkdownFence;
+    lang: string;
+} | null;
+/** The ATX heading `line` is, or null. Closing hashes are decoration, not content. */
+export declare function markdownHeadingOf(line: string): {
+    level: number;
+    title: string;
+} | null;
+/** A document's lines, every line ending normalised to `\n`. */
+export declare function markdownLines(source: string): string[];
+/** Split a document into blocks. Pure, and the only thing that reads lines. */
+export declare function parseMarkdown(source: string): MarkdownBlock[];
+/**
+ * Split a document into its top-level blocks AND the lines each was read
+ * from, for an editor that keeps the source of every block it did not change.
+ */
+export declare function parseMarkdownSpans(source: string): {
+    lines: string[];
+    spans: MarkdownSpan[];
+};
+/** What one inline construct captured, by name. */
+export interface MarkdownInlineGroups {
+    /** An escaped ASCII punctuation character, without its backslash. */
+    esc?: string;
+    tick?: string;
+    code?: string;
+    alt?: string;
+    src?: string;
+    srcTitle?: string;
+    label?: string;
+    href?: string;
+    hrefTitle?: string;
+    auto?: string;
+    strong?: string;
+    strongUnder?: string;
+    em?: string;
+    emUnder?: string;
+    del?: string;
+}
+/** One inline construct: where it starts and ends in the text, and what it captured. */
+export interface MarkdownInlineMatch {
+    index: number;
+    end: number;
+    groups: MarkdownInlineGroups;
+}
+/**
+ * Every inline construct of `text`, in order: THE ONE WALK every reader of
+ * inline Markdown takes, so a renderer, a text flattener and an editor can
+ * never disagree about where a construct begins.
+ *
+ * A fresh pattern per walk: the walk is re-entered for a construct's own
+ * content before the outer one has finished, and a shared `g` pattern carries
+ * its position in `lastIndex`.
+ */
+export declare function markdownInline(text: string): Generator<MarkdownInlineMatch>;
+/**
+ * A code span's content as it reads: ONE leading and one trailing space go,
+ * which is how CommonMark lets a span start with a backtick of its own.
+ */
+export declare function markdownCodeText(code: string): string;
+/**
+ * The splits a run of text breaks at: two trailing spaces or a backslash
+ * before a newline is a HARD break; every other newline is soft. With
+ * `hard`, every newline is a break and the two markers are consumed with it.
+ */
+export declare function markdownBreaks(text: string, hard?: boolean): string[];

package/dist/Markdown/index.d.ts

@@ -0,0 +1,2 @@
+export { MARKDOWN_CALLOUT_NAMES, MARKDOWN_CALLOUT_TONES, markdownBreaks, markdownClosesFence, markdownCodeText, markdownFenceOf, markdownHeadingOf, markdownInline, markdownLines, parseMarkdown, parseMarkdownSpans, safeHref, } from './grammar.js';
+export type { MarkdownAlign, MarkdownBlock, MarkdownCalloutTone, MarkdownFence, MarkdownInlineGroups, MarkdownInlineMatch, MarkdownListItem, MarkdownSpan, } from './grammar.js';

package/dist/Markdown/index.js

@@ -0,0 +1 @@
+export { MARKDOWN_CALLOUT_NAMES, MARKDOWN_CALLOUT_TONES, markdownBreaks, markdownClosesFence, markdownCodeText, markdownFenceOf, markdownHeadingOf, markdownInline, markdownLines, parseMarkdown, parseMarkdownSpans, safeHref } from '../chunk-SKOYC2CF.js';

package/dist/RichEditor/Editor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The editor itself: ProseMirror, drawn as the document it edits, with the
+ * slash menu, the selection toolbar, the link and picture panels and the
+ * table bar around it. Loaded lazily by `RichEditor`, so nothing here is
+ * fetched until somebody edits.
+ */
+import { EditorView } from 'prosemirror-view';
+import { type RichEditorHandle, type RichEditorProps } from './types.js';
+/**
+ * The engine's handle: the public one, and the view itself for this
+ * package's own suites, which drive ProseMirror where jsdom has no layout to
+ * drive a browser's input through.
+ */
+export interface EditorHandle extends RichEditorHandle {
+    view(): EditorView | null;
+}
+export declare const Editor: import("react").ForwardRefExoticComponent<RichEditorProps & import("react").RefAttributes<EditorHandle>>;

package/dist/RichEditor/RichEditor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `RichEditor`: Markdown edited in place, as the document it reads as.
+ *
+ * # Loaded when somebody edits
+ *
+ * The editor is ProseMirror and everything around it, which is more than a
+ * reader of a page needs, so this component is a SHELL: it fetches the engine
+ * (`Editor.tsx`) with `import()` the first time one is drawn, and a bundler
+ * splits that into a chunk of its own. While the chunk loads the shell draws
+ * the caller's `fallback` (the body as it reads, so nothing moves) or a
+ * skeleton.
+ *
+ * A LOAD THAT FAILED IS FORGOTTEN, so the next attempt asks the server again
+ * rather than replaying the failure for the life of the page: the usual
+ * cause is a deploy that renamed the chunk while the page was open, and the
+ * other is one dropped request, which a retry fixes.
+ */
+import { type RefAttributes } from 'react';
+import { type RichEditorHandle, type RichEditorProps } from './types.js';
+/**
+ * Fetch the editor's code ahead of the first edit, on a press that is about
+ * to open one. It settles once the code is there, or once fetching it has
+ * failed, which the editor itself then says where it is drawn.
+ */
+export declare function preloadRichEditor(): Promise<void>;
+export declare const RichEditor: import("react").ForwardRefExoticComponent<RichEditorProps & RefAttributes<RichEditorHandle>>;

package/dist/RichEditor/codec.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Markdown in, Markdown out: the editor's document read from a body, and the
+ * body written back from the document.
+ *
+ * # A save with no edit changes nothing, by construction
+ *
+ * Storage is Markdown, and the bytes are the record: a Knowledge page is
+ * merged line by line against somebody else's save, and a doc's version is a
+ * patch of the lines that moved. An editor that wrote every body back in its
+ * own canonical spelling would turn opening a page and pressing Save into a
+ * rewrite of every line, and every concurrent save into a conflict.
+ *
+ * So the document REMEMBERS THE SOURCE OF EVERY TOP-LEVEL BLOCK it read
+ * ([LoadedMarkdown]). ProseMirror shares every node a transaction did not
+ * touch, so a block nobody edited is the very node that was read, and it is
+ * written back as the lines it came from, with the blank lines that stood
+ * between it and its neighbour. A block an edit replaced is looked up by
+ * value too, so a change that was undone writes back its original lines.
+ * Only a block that really changed is written in the canonical spelling
+ * below, and it keeps the markers it was read with.
+ *
+ * # A changed block is checked before it is written
+ *
+ * The canonical spelling is read back through the same grammar and compared
+ * with what the writer sees ([signature]); a spelling that would read
+ * differently (an asterisk that would open emphasis, a `_` inside a word that
+ * cannot close one) is written again with plainer markers and then with every
+ * punctuation character escaped. What the editor shows is what the next
+ * reader sees.
+ */
+import { type Node as PMNode } from 'prosemirror-model';
+/** One top-level block as it was read: its lines, and what stood before it. */
+interface SourceBlock {
+    index: number;
+    node: PMNode;
+    text: string;
+    /** The text between the previous block's last line and this block's first. */
+    sep: string;
+}
+/** A document and the source it was read from. */
+export interface LoadedMarkdown {
+    doc: PMNode;
+    source: MarkdownSource;
+}
+/** What a document remembers of the body it was read from. */
+export interface MarkdownSource {
+    original: string;
+    doc: PMNode;
+    lead: string;
+    trail: string;
+    blocks: SourceBlock[];
+    byNode: WeakMap<PMNode, SourceBlock>;
+    /** Whether every line of the original ends in CRLF, which a changed body keeps. */
+    crlf: boolean;
+}
+/** Read a Markdown body into the editor's document. */
+export declare function readMarkdown(markdown: string): LoadedMarkdown;
+/**
+ * The body a document is saved as.
+ *
+ * With the source it was read from, every block nobody changed is written as
+ * the lines it was read from; a document nobody changed at all is the source,
+ * byte for byte, line endings included.
+ */
+export declare function writeMarkdown(doc: PMNode, source?: MarkdownSource): string;
+/**
+ * One block in the canonical spelling, checked: the first spelling that reads
+ * back as what the writer sees, or the plainest when none does.
+ */
+export declare function writeBlock(node: PMNode): string;
+/**
+ * What a block SAYS: its structure and the attributes a reader sees, and its
+ * text character by character with the marks each carries. The spelling (a
+ * `*` or a `_`, a fence's marker, whether a space sat inside the strong or
+ * after it) is not part of it, because the reader cannot see it either.
+ */
+export declare function signature(node: PMNode): string;
+export {};

package/dist/RichEditor/commands.d.ts

@@ -0,0 +1,89 @@
+/**
+ * What the editor can do to a document, as ProseMirror commands: each takes a
+ * state and, given a dispatch, applies itself, and without one answers
+ * whether it could. The slash menu, the selection toolbar, the shortcuts and
+ * the table bar all call these, so a block is made one way whichever of them
+ * made it.
+ */
+import { type Mark, type MarkType, type Node as PMNode } from 'prosemirror-model';
+import { type Command, type EditorState } from 'prosemirror-state';
+import type { MarkdownAlign, MarkdownCalloutTone } from '../Markdown/index.js';
+/** Whether a mark is on across the selection, or stored for the next keystroke. */
+export declare function markActive(state: EditorState, type: MarkType): boolean;
+/** The heading level the selection sits in, or 0 for any other block. */
+export declare function headingLevel(state: EditorState): number;
+/** Whether the selection is inside a code block, where no formatting applies. */
+export declare function inCode(state: EditorState): boolean;
+export declare const toggleStrong: Command;
+export declare const toggleEm: Command;
+export declare const toggleStrike: Command;
+export declare const toggleCode: Command;
+/** The link the selection is on: its whole range, and the mark. */
+export declare function linkAt(state: EditorState): {
+    from: number;
+    to: number;
+    mark: Mark;
+} | null;
+/**
+ * Link the selection to `href`, or the link the caret is on; with nothing
+ * selected and no link under the caret, insert `text` linked.
+ */
+export declare function setLink(href: string, text?: string): Command;
+/** Remove the link under the caret or across the selection. */
+export declare const removeLink: Command;
+/** A heading of `level`, or back to a paragraph when the block already is one. */
+export declare function toggleHeading(level: number): Command;
+export declare const setParagraph: Command;
+export declare function setCodeBlock(lang?: string): Command;
+export declare const wrapQuote: Command;
+export declare function wrapCallout(tone?: MarkdownCalloutTone): Command;
+export type ListKind = 'bullet' | 'ordered' | 'task';
+/**
+ * Make the selection a list of `kind`. In a list of that kind already, the
+ * items come out of it; in a list of another kind, the list changes kind.
+ */
+export declare function setList(kind: ListKind): Command;
+/** Enter in a list item: a new item, a task when this one is a task. */
+export declare const splitItem: Command;
+/** Tick or untick the task item at `pos`. */
+export declare function toggleTask(pos: number): Command;
+export declare const insertRule: Command;
+export declare function insertImage(src: string, alt: string): Command;
+/** The table the caret is in, and the cell. */
+export interface TableAt {
+    table: PMNode;
+    pos: number;
+    row: number;
+    col: number;
+}
+export declare function tableAt(state: EditorState): TableAt | null;
+/** A table of `rows` by `cols`, header included, with the caret in its first cell. */
+export declare function insertTable(rows?: number, cols?: number): Command;
+export declare const addRowBefore: Command;
+export declare const addRowAfter: Command;
+export declare const addColumnBefore: Command;
+export declare const addColumnAfter: Command;
+export declare const deleteRow: Command;
+export declare const deleteColumn: Command;
+export declare const deleteTable: Command;
+export declare function alignColumn(align: MarkdownAlign): Command;
+/** The alignment of the column the caret is in. */
+export declare function columnAlign(state: EditorState): MarkdownAlign | null;
+/**
+ * Tab and Shift-Tab between cells, and Enter to the cell below: past the last
+ * cell (or the last row, for Enter) a row is added, as a spreadsheet does.
+ */
+export declare function moveCell(direction: 'next' | 'previous' | 'down'): Command;
+/**
+ * Enter on the third blank line at the end of a code block leaves it: the
+ * two blank lines go, and a paragraph opens after the block.
+ */
+export declare const exitCodeOnBlankLines: Command;
+/** Enter after ```` ```lang ```` in a paragraph opens a code block in that language. */
+export declare const fenceToCode: Command;
+/** Select a whole node: an image the writer clicked, a rule. */
+export declare function selectNode(pos: number): Command;
+export declare function setCalloutTone(pos: number, tone: MarkdownCalloutTone): Command;
+export declare function setCodeLanguage(pos: number, lang: string): Command;
+/** Take the callout or quote at `pos` away, keeping what it holds. */
+export declare function unwrapAt(pos: number): Command;

package/dist/RichEditor/index.d.ts

@@ -0,0 +1,4 @@
+import './RichEditor.css';
+export { RichEditor, preloadRichEditor } from './RichEditor.js';
+export { RICH_EDITOR_LABELS, richEditorLabels } from './types.js';
+export type { RichEditorBlock, RichEditorCommand, RichEditorHandle, RichEditorLabelOverrides, RichEditorLabels, RichEditorPanelApi, RichEditorProps, } from './types.js';

package/dist/RichEditor/index.js

@@ -0,0 +1,8 @@
+export { RichEditor, preloadRichEditor } from '../chunk-VOX3YRFO.js';
+export { RICH_EDITOR_LABELS, richEditorLabels } from '../chunk-A4E5YLXO.js';
+import '../chunk-W5J7R5EB.js';
+import '../chunk-SKOYC2CF.js';
+import '../chunk-SVSCLHHI.js';
+import '../chunk-OG6CL3EB.js';
+import '../chunk-BZFWDIV6.js';
+import '../chunk-ODEQTPFM.js';

package/dist/RichEditor/keys.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The keyboard: Markdown typed as Markdown becomes the block or the format it
+ * spells (`# `, `- `, `1. `, `[ ] `, `> `, ```` ``` ````, `---`, `**bold**`),
+ * and the shortcuts every editor shares.
+ *
+ * AN INPUT RULE IS UNDONE BY BACKSPACE: a writer who meant a literal `# ` or
+ * `**` presses it once right after, and has the characters they typed.
+ */
+import { type Plugin } from 'prosemirror-state';
+export declare function buildInputRules(): Plugin;
+export interface KeyHooks {
+    submit: () => boolean;
+    link: () => boolean;
+    toolbar: () => boolean;
+}
+export declare function buildKeymap(hooks: KeyHooks): Plugin[];

package/dist/RichEditor/nodeviews.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The blocks that draw more than their element while they are edited: a code
+ * block's language, a callout's tone, a task's box, a picture's file, a
+ * table's scroller.
+ *
+ * Each is the element shape the reader's renderer emits, so `Document` sets it
+ * the same way, plus a CONTROL SLOT that is not part of the content
+ * (`contenteditable="false"`). The editor draws its React controls into those
+ * slots through portals ([SlotStore]), so a code block's language field is a
+ * design system field rather than markup built here.
+ */
+import type { Node as PMNode } from 'prosemirror-model';
+import type { EditorView, NodeView } from 'prosemirror-view';
+/** A control slot a node view opened, for the editor to draw into. */
+export interface Slot {
+    kind: 'code' | 'callout';
+    element: HTMLElement;
+    node: PMNode;
+    getPos: () => number | undefined;
+}
+/** The open slots, which the editor subscribes to and draws portals into. */
+export declare class SlotStore {
+    private slots;
+    private listeners;
+    private snapshot;
+    add(slot: Slot): void;
+    remove(slot: Slot): void;
+    changed(): void;
+    subscribe: (listener: () => void) => (() => void);
+    get: () => Slot[];
+    private emit;
+}
+export declare function codeBlockView(store: SlotStore): (node: PMNode, _view: EditorView, getPos: () => number | undefined) => NodeView;
+export declare function calloutView(store: SlotStore): (node: PMNode, _view: EditorView, getPos: () => number | undefined) => NodeView;
+/**
+ * A list item, and a task item's box. The box is the same native checkbox
+ * the reader's renderer draws, and here it can be pressed: a press ticks the
+ * task without moving the caret.
+ */
+export declare function listItemView(labels: () => {
+    done: string;
+    notDone: string;
+}): (node: PMNode, view: EditorView, getPos: () => number | undefined) => NodeView;
+/** A table inside the scroller the reader's renderer wraps it in. */
+export declare function tableView(node: PMNode): NodeView;
+/** How a picture's address is shown: a doc's are files of its version. */
+export type ImageResolver = (src: string) => string | null;
+/**
+ * A picture, shown from where the application says (a doc's file, through an
+ * object URL) or, without a resolver, from an address a reader may follow.
+ * One it cannot show reads as its alt text, as it does to a reader.
+ */
+export declare class ImageViews {
+    private resolve;
+    private views;
+    constructor(resolve: () => ImageResolver | undefined);
+    /** Paint every picture again, when what the resolver can answer has changed. */
+    refresh(): void;
+    view: (node: PMNode) => NodeView;
+}

package/dist/RichEditor/paste.d.ts

@@ -0,0 +1,47 @@
+/**
+ * What a paste or a drop becomes: Markdown, HTML or plain text, read into the
+ * editor's document WITHOUT EVER PARSING MARKUP THROUGH A SINK.
+ *
+ * # Why HTML is tokenized here
+ *
+ * ProseMirror reads pasted HTML by assigning it to `innerHTML` on a detached
+ * document, behind a pass-through Trusted Types policy it creates for itself.
+ * A page that enforces Trusted Types with `trusted-types 'none'` allows no
+ * policy at all, so that path throws; and a pass-through policy, where one is
+ * allowed, is exactly the hole Trusted Types exists to close. So the editor
+ * takes the paste and the drop itself (`handleDOMEvents`), and reads HTML
+ * with the small tokenizer below, which builds elements one by one in an
+ * inert document (`createElement`, `setAttribute` and `createTextNode`, none
+ * of them a sink), keeping only the elements and attributes the editor has a
+ * meaning for. ProseMirror's own `DOMParser` then reads that tree, so every
+ * rule about what an element becomes is the schema's.
+ *
+ * NOTHING IN THE TREE LOADS ANYTHING: it lives in a document with no browsing
+ * context, a picture's address is kept in `data-src` rather than `src`, and a
+ * link whose scheme is not allowed is dropped to its text.
+ */
+import { Slice, type ResolvedPos } from 'prosemirror-model';
+/**
+ * The paste as an element tree in an inert document, kept to what the
+ * editor understands. Unclosed `p`, `li`, `tr`, `td` and `th` close where a
+ * browser would close them, which is how real clipboard HTML is written.
+ */
+export declare function htmlTree(html: string, doc?: Document): HTMLElement;
+/** A slice of the editor's document from pasted HTML. */
+export declare function htmlSlice(html: string, $context: ResolvedPos): Slice;
+/**
+ * Whether plain text is written in Markdown: a block's syntax at a line's
+ * start, or a span's (strong, a link, a code span) anywhere. Text with
+ * neither is pasted line by line, as it was written.
+ */
+export declare function looksLikeMarkdown(text: string): boolean;
+/** A slice from Markdown text. */
+export declare function markdownSlice(text: string): Slice;
+/** A slice from plain text: one paragraph per line. */
+export declare function textSlice(text: string): Slice;
+/**
+ * Whether clipboard HTML carries structure worth keeping. A code editor puts
+ * its text on the clipboard as HTML too, every line a styled `div`, and
+ * reading that as HTML would lose the Markdown the text was written in.
+ */
+export declare function richHtml(html: string, types: readonly string[]): boolean;

package/dist/RichEditor/plugins.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The editor's plugins: the slash trigger, the placeholder, and the clipboard.
+ */
+import { Slice, type Node as PMNode } from 'prosemirror-model';
+import { Plugin, PluginKey } from 'prosemirror-state';
+/** Where the slash the writer typed is, and what they have typed after it. */
+export interface SlashState {
+    open: boolean;
+    /** The position of the `/`. */
+    from: number;
+    query: string;
+}
+export declare const slashKey: PluginKey<SlashState>;
+/**
+ * The slash trigger: a `/` typed at the start of a line or after a space
+ * opens the block menu, and the menu follows what is typed after it until
+ * the caret leaves, a space ends the word, or Escape closes it.
+ *
+ * ONLY A TYPED SLASH OPENS IT. A caret moved into an address that holds one
+ * (`https://…`) is not asking for a block.
+ */
+export declare function slashPlugin(keys: {
+    current: ((event: KeyboardEvent) => boolean) | null;
+}): Plugin<SlashState>;
+export declare const focusKey: PluginKey<boolean>;
+/** Whether the editor has focus, kept as state so a decoration can follow it. */
+export declare const focusPlugin: Plugin<boolean>;
+/**
+ * The words an empty editor shows, and the hint an empty line shows while the
+ * caret is on it. Both are a decoration's attribute drawn by the stylesheet,
+ * never text in the document, so neither can be saved.
+ */
+export declare function placeholderPlugin(text: () => {
+    empty: string;
+    line: string;
+}): Plugin;
+/** A slice's content as Markdown, for a paste into anything that reads text. */
+export declare function sliceMarkdown(slice: Slice): string;
+/**
+ * The clipboard, taken whole: copy writes Markdown as the text a plain field
+ * receives, and paste and drop read Markdown, HTML and text through
+ * `paste.ts` rather than through ProseMirror's own HTML path, which assigns
+ * markup to `innerHTML` and cannot run under Trusted Types.
+ */
+export declare function clipboardPlugin(shift: {
+    current: boolean;
+}): Plugin;
+/** Whether a document is the single empty paragraph an empty body reads as. */
+export declare function isEmptyDoc(doc: PMNode): boolean;

package/dist/RichEditor/roundtrip.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The editor's Markdown round trip, as plain functions: what a load and a
+ * save with no edit write, and the spelling a changed block is written in.
+ * An application holds its own bodies to them (a Knowledge page's fixtures, a
+ * doc's), so a body the editor would rewrite is found by a test rather than
+ * by somebody's diff.
+ *
+ * Importing these brings the document model with them; the editor's shell
+ * does not, so a screen that only draws `RichEditor` pays for neither.
+ */
+/** The body a load and a save with no edit write: the body itself, byte for byte. */
+export declare function roundTripMarkdown(markdown: string): string;
+/** The body as the editor writes it when every block has changed. */
+export declare function canonicalMarkdown(markdown: string): string;

package/dist/RichEditor/schema.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The document model `RichEditor` edits: exactly what the Markdown grammar
+ * (`../Markdown`) reads, and nothing it cannot write back.
+ *
+ * EVERY NODE DRAWS WHAT THE READER SEES. The editor's DOM is the element shape
+ * an application's renderer emits for the same block (an `h2` for a `#`
+ * heading, a list item whose first child is a checkbox, a table inside a
+ * scrolling wrapper), inside `Document`, so the page looks the same while it
+ * is edited as when it is read, and one stylesheet sets both.
+ *
+ * A NODE CARRIES THE SPELLING IT WAS READ WITH (a bullet's character, a
+ * fence's marker, emphasis by `*` or `_`), so a block somebody edits is
+ * written back in the hand it was written in rather than in the editor's.
+ *
+ * NO STYLE ATTRIBUTE IS EVER WRITTEN. A strict Content-Security-Policy refuses
+ * `style-src 'unsafe-inline'`, which covers a `style` attribute set through
+ * `setAttribute`, so a cell's alignment is a data attribute the stylesheet
+ * reads.
+ */
+import { Schema } from 'prosemirror-model';
+/** A heading's element: a body's `#` is an `h2`, because the page's title is its `h1`. */
+export declare function headingTag(level: number): string;
+export declare const schema: Schema<"blockquote" | "table" | "image" | "text" | "heading" | "doc" | "paragraph" | "callout" | "code_block" | "horizontal_rule" | "bullet_list" | "ordered_list" | "list_item" | "table_row" | "table_header" | "table_cell" | "hard_break", "code" | "em" | "link" | "strong" | "strike">;