@dou-ui/editor 0.0.0-stage → 0.1.0-alpha.0

package/dist/types/core/commands.d.ts

@@ -0,0 +1,61 @@
+import { type Node as PMNode } from 'prosemirror-model';
+import { type Command, type EditorState, type Transaction } from 'prosemirror-state';
+import { type BlockInfo, type SiblingRange } from './blocks';
+import { type BlockProps } from './model';
+import type { ContentType } from './schema';
+/**
+ * Turn every block the selection touches into `type`. Text formatting is
+ * dropped when it can't be kept (in a code block); a type without text
+ * (a divider, an embed) replaces the content and adds an empty paragraph
+ * after it to keep typing in.
+ */
+export declare function setBlockType(type: ContentType, props?: BlockProps): Command;
+/** Set attributes on the content of the block at `pos`, e.g. tick a to-do. */
+export declare function setContentAttrs(pos: number, attrs: Record<string, unknown>): Command;
+/**
+ * Split the block at the cursor. An empty list item turns back into a
+ * paragraph, an empty nested paragraph moves up a level, and a block with
+ * children gets its new block as the first child.
+ */
+export declare const splitBlock: Command;
+/** `Shift+Enter`: a line break, or a newline in code. */
+export declare const insertBreak: Command;
+/** In a code block, `Enter` adds a newline. */
+export declare const newlineInCode: Command;
+/** `Mod+Enter` in a code block: leave it for a new paragraph below. */
+export declare const exitCode: Command;
+/**
+ * `Backspace` at the start of a block: first turn it into a paragraph, then
+ * move a nested block up a level, then join it with the block above.
+ */
+export declare const joinBackward: Command;
+/** `Delete` at the end of a block: pull the next block's text up. */
+export declare const joinForward: Command;
+/** With a divider selected, `Backspace` or `Delete` removes its block. */
+export declare const deleteSelectedAtom: Command;
+/** `Tab`: make the selected blocks children of the block above them. */
+export declare const sinkBlocks: Command;
+/**
+ * `Shift+Tab`: move the selected blocks up a level, right after their
+ * parent. The siblings that followed them become children of the last one,
+ * so nothing changes order.
+ */
+export declare const liftBlocks: Command;
+/** `Mod+Shift+↑/↓`: swap the selected blocks with their neighbour. */
+export declare function swapBlocks(direction: -1 | 1): Command;
+/**
+ * Drag and drop: move the blocks of `range` to `target`, a position right
+ * before or after a block, possibly at another level. Fails when the
+ * target is inside the moved blocks. The cursor goes to the first one.
+ */
+export declare function moveRangeTo(range: SiblingRange, target: number): Command;
+/** Remove blocks, keeping at least one empty paragraph in the document. */
+export declare function deleteBlocks(tr: Transaction, blocks: BlockInfo[]): Transaction;
+/** Copies of blocks with fresh ids (the id plugin assigns them). */
+export declare function withoutIds(node: PMNode): PMNode;
+/** Insert copies of the selected blocks right after them. */
+export declare const duplicateBlocks: Command;
+/** Insert an empty block of `type` after the block at `pos` and put the cursor in it. */
+export declare function insertBlockAfter(pos: number, type?: ContentType): Command;
+/** The selection's blocks, for menus and the block selection. */
+export declare function selectedBlocks(state: EditorState): BlockInfo[];

package/dist/types/core/comments.d.ts

@@ -0,0 +1,44 @@
+import { type Node as PMNode } from 'prosemirror-model';
+import { Plugin, PluginKey, type EditorState } from 'prosemirror-state';
+import { DecorationSet, type EditorView } from 'prosemirror-view';
+/** A range of the document, as positions. */
+export interface CommentRange {
+    from: number;
+    to: number;
+}
+/** Where a thread is anchored: the block and the text it is about. */
+export interface CommentAnchor {
+    /** The id of the (first) block holding the text. */
+    block: string;
+    /** The text the thread is about. */
+    text: string;
+    from: number;
+    to: number;
+}
+export interface CommentPluginState {
+    /** The text a thread is being started on, until its first comment is sent. */
+    pending: CommentRange | null;
+    decorations: DecorationSet;
+}
+export declare const commentKey: PluginKey<CommentPluginState>;
+export interface CommentPluginOptions {
+    /** The ids of the threads there are, or `null` when comments are off. */
+    known: () => ReadonlySet<string> | null;
+    /** A click on text that is in threads, with their ids, innermost first; `[]` elsewhere. */
+    onClick: (ids: string[]) => void;
+    onPending: (range: CommentRange | null) => void;
+    /** Text got selected (a range, not a cursor). */
+    onSelect: () => void;
+}
+/** The ids of the threads at `pos`, the shortest (innermost) first. */
+export declare function commentsAt(state: EditorState, pos: number): string[];
+/** Every thread's anchor in the document, by id: the first and last positions of its text. */
+export declare function commentAnchors(doc: PMNode): Map<string, CommentAnchor>;
+/** The text of `id`'s anchor that a thread card points at: its first and last positions. */
+export declare function commentRange(doc: PMNode, id: string): CommentRange | null;
+/** Marks `range` as the text of a new thread. Not undone with the edits around it. */
+export declare function anchorComment(view: EditorView, range: CommentRange, id: string): void;
+/** Takes a removed thread's anchor off the text. */
+export declare function unanchorComment(view: EditorView, id: string): void;
+export declare function setPendingComment(view: EditorView, range: CommentRange | null): void;
+export declare function commentPlugin(options: CommentPluginOptions): Plugin<CommentPluginState>;

package/dist/types/core/compare.d.ts

@@ -0,0 +1,10 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+import { type Block } from './model';
+export declare const compareKey: PluginKey<DecorationSet>;
+/** Draws the changes from `before()`; `null` draws none. */
+export declare function comparePlugin(options: {
+    before: () => readonly Block[] | null | undefined;
+    /** What to show for a removed block without text, such as a divider. */
+    label: (block: Block) => string;
+}): Plugin<DecorationSet>;

package/dist/types/core/convert.d.ts

@@ -0,0 +1,12 @@
+import { type EditorExtension, type ResolvedEditorExtensions } from './extension';
+import type { Block, PartialBlock } from './model';
+export type EditorExtensionList = readonly (EditorExtension | EditorExtension[])[];
+/** Resolve a list of extensions once; the same array gives the same result. */
+export declare function kitOf(extensions: EditorExtensionList): ResolvedEditorExtensions;
+/**
+ * Write blocks as HTML with the given extensions, e.g. to show a document
+ * outside the editor. Works without a browser.
+ */
+export declare function blocksToHTML(blocks: PartialBlock[], extensions: EditorExtensionList): string;
+/** Read HTML as blocks with the given extensions. Needs `DOMParser` (a browser, or a DOM library). */
+export declare function htmlToBlocks(html: string, extensions: EditorExtensionList): Block[];

package/dist/types/core/diff.d.ts

@@ -0,0 +1,49 @@
+import type { Block, InlineContent } from './model';
+/** One block that differs between two versions. */
+export type BlockVersionChange = {
+    type: 'added';
+    id: string;
+    after: Block;
+}
+/** `next`: the block of the newer version it stood before; `null` at the end. */
+ | {
+    type: 'removed';
+    id: string;
+    before: Block;
+    next: string | null;
+}
+/** Its text, type, attributes or rows changed. */
+ | {
+    type: 'updated';
+    id: string;
+    before: Block;
+    after: Block;
+};
+export interface BlocksDiff {
+    /** The changed blocks, in the order of the newer version, removed ones where they were. */
+    changes: BlockVersionChange[];
+    /** The ids of the blocks added, removed and updated, as the `transaction` event's `changes` has them. */
+    added: string[];
+    removed: string[];
+    updated: string[];
+}
+/** The blocks added, removed and changed from `before` to `after`. */
+export declare function diffBlocks(before: readonly Block[], after: readonly Block[]): BlocksDiff;
+/**
+ * A block's inline content as text, one character for each position it
+ * takes in the editor: a line break and an inline node (a mention) are
+ * one each.
+ */
+export declare function inlineText(content: readonly InlineContent[]): string;
+/** A piece of a text diff: kept, only in the newer text, or only in the older one. */
+export interface TextPart {
+    type: 'same' | 'added' | 'removed';
+    text: string;
+}
+/**
+ * The characters `after` added to `before` and those it removed: their
+ * longest common subsequence kept, the rest added or removed. Shared
+ * starts and ends are taken off first, so a small edit in a long text is
+ * cheap.
+ */
+export declare function diffText(before: string, after: string): TextPart[];

package/dist/types/core/editor.d.ts

@@ -0,0 +1,64 @@
+import type { Node as PMNode } from 'prosemirror-model';
+import { EditorState, Plugin, type Command, type Transaction } from 'prosemirror-state';
+import { EditorView, type NodeViewConstructor } from 'prosemirror-view';
+import type { ResolvedEditorExtensions } from './extension';
+import { type KeymapOptions } from './keymap';
+import { type Block, type PartialBlock } from './model';
+import { type PlaceholderOptions } from './plugins';
+export interface CreateEditorOptions {
+    /** Where the editor goes. */
+    element: HTMLElement;
+    /** The resolved extensions: schema, plugins, node views. */
+    kit: ResolvedEditorExtensions;
+    /** More node views, e.g. ones that render Vue components. */
+    nodeViews?: Record<string, NodeViewConstructor>;
+    blocks?: PartialBlock[];
+    editable?: boolean;
+    placeholder: PlaceholderOptions;
+    /** Called after each change to the document, with the transaction and the state before it. */
+    onChange?: (view: EditorView, tr: Transaction, before: EditorState) => void;
+    /** Called after every state change, including the selection. */
+    onUpdate?: (view: EditorView, before: EditorState) => void;
+    /**
+     * Extra plugins, placed before the built-in ones so their keys win.
+     * The collaboration extension adds its sync and cursor plugins here.
+     */
+    plugins?: Plugin[];
+    /**
+     * Key plugins placed after the extensions' keys, so an extension can
+     * take one of their keys, and before the built-in ones.
+     */
+    keymaps?: Plugin[];
+    /** Leave out the built-in undo history (collaboration brings its own). */
+    history?: boolean;
+    undo?: KeymapOptions['undo'];
+    redo?: KeymapOptions['redo'];
+    /** Attributes for the editable element, e.g. an accessible name. */
+    attributes?: () => Record<string, string>;
+}
+/** The transaction meta that names who made a change, for the `transaction` event. */
+export declare const originKey = "douOrigin";
+/**
+ * The undo and redo the editor runs: the built-in history's, or those of
+ * the extension or props that replace it. For node views that edit their
+ * text themselves, so their undo is the document's.
+ */
+export declare function historyCommands(state: EditorState): {
+    undo: Command;
+    redo: Command;
+};
+export declare function createPlugins(options: Omit<CreateEditorOptions, 'element'>): Plugin[];
+export declare function createState(kit: ResolvedEditorExtensions, blocks: PartialBlock[] | undefined, plugins: Plugin[]): EditorState;
+export declare function createEditorView(options: CreateEditorOptions): EditorView;
+export declare function setEditable(view: EditorView, value: boolean): void;
+/** Replace the whole document, e.g. when `v-model` changes from outside. */
+export declare function replaceBlocks(view: EditorView, blocks: PartialBlock[]): void;
+/**
+ * Replace the document with `blocks` as one change undo takes back, e.g.
+ * an older version. Only what differs is replaced, so the blocks that stay
+ * keep their place, and with collaboration only they are written.
+ */
+export declare function restoreBlocks(view: EditorView, blocks: PartialBlock[]): boolean;
+export declare function getBlocks(view: EditorView): Block[];
+export declare function runCommand(view: EditorView, command: Command): boolean;
+export type { PMNode };

package/dist/types/core/extension.d.ts

@@ -0,0 +1,167 @@
+import type { InputRule } from 'prosemirror-inputrules';
+import type { MarkSpec, NodeSpec, Schema } from 'prosemirror-model';
+import type { Command, Plugin } from 'prosemirror-state';
+import type { NodeViewConstructor } from 'prosemirror-view';
+import { type CommentAction, type CommentThread } from 'dou-ui';
+import type { Component, Ref } from 'vue';
+import type { EditorMessages } from '../locale';
+import type { BlockProps } from './model';
+import type { EditorExtensionOutput } from './output';
+/** Text shown in a menu: fixed, or read from the editor's messages so it follows the locale. */
+export type Label = string | ((messages: EditorMessages) => string);
+export declare const labelOf: (label: Label | undefined, messages: EditorMessages) => string;
+/** An entry of the slash menu and of the “turn into” menus. */
+export interface BlockOption {
+    /** Unique among the options. */
+    key: string;
+    /** The block type it inserts or turns blocks into. */
+    type: string;
+    props?: BlockProps;
+    label: Label;
+    /** A short description under the label in the slash menu. */
+    hint?: Label;
+    icon: Component;
+    /** Extra words the slash menu matches, besides the label (pinyin works well). */
+    keywords?: string[];
+    /** The Markdown shortcut, shown as a hint. */
+    shortcut?: string;
+}
+/** A toggle in the formatting toolbar for a mark. */
+export interface FormatOption {
+    mark: string;
+    label: Label;
+    icon: Component;
+    /** The shortcut shown in its tooltip, written as in `useHotkey`, e.g. `mod+b`. */
+    hotkey?: string;
+}
+/** Where the comment threads live, when not in `v-model:comments`. */
+export interface CommentsProvider {
+    /** The threads, kept up to date. */
+    threads: Readonly<Ref<readonly CommentThread[]>>;
+    /** Make a change this user asked for. */
+    apply: (action: CommentAction) => void;
+}
+export interface EditorExtensionContext {
+    schema: Schema;
+}
+/** What the extension replacing the undo history provides (e.g. collaboration). */
+export interface HistoryProvider {
+    plugins: Plugin[];
+    undo: Command;
+    redo: Command;
+}
+/**
+ * A piece of the editor: block types, marks, behaviour and menu entries.
+ * The built-in blocks are extensions too (see `editorKit`).
+ */
+export interface EditorExtension {
+    name: string;
+    /** Higher runs first: its keys, input rules and plugins win. Defaults to 100. */
+    priority?: number;
+    /**
+     * Content node specs for new block types, by type name. They join the
+     * `blockContent` group. Extra spec fields the editor reads:
+     * `continues` (Enter continues the same type, like a list) and
+     * `component` (a Vue component that renders the block).
+     */
+    blocks?: Record<string, NodeSpec>;
+    /**
+     * Nodes that only live inside the extension's blocks, e.g. a table's
+     * rows and cells. They join no group.
+     */
+    nodes?: Record<string, NodeSpec>;
+    /** Inline nodes, e.g. a mention. */
+    inlines?: Record<string, NodeSpec>;
+    marks?: Record<string, MarkSpec>;
+    nodeViews?: Record<string, NodeViewConstructor>;
+    /**
+     * Node views that draw Vue components, by node type. Each is made with
+     * `mount`, which renders a component into an element inside the editor's
+     * app, so it can call `useEditor()` and follows the ConfigProvider.
+     */
+    componentViews?: Record<string, (mount: MountComponent) => NodeViewConstructor>;
+    inputRules?: (context: EditorExtensionContext) => InputRule[];
+    /**
+     * Keys, written as in `useHotkey` (e.g. `mod+shift+h`, `shift+tab`,
+     * `enter`), while the editor has focus. A command returning `false` lets
+     * the key through to the next extension.
+     */
+    keymap?: (context: EditorExtensionContext) => Record<string, Command>;
+    plugins?: (context: EditorExtensionContext) => Plugin[];
+    /**
+     * The document lives outside the editor (e.g. in a Yjs document): the
+     * initial `modelValue` and later outside changes to it are ignored, and
+     * `v-model` only mirrors the document.
+     */
+    externalDocument?: boolean;
+    /** Replace the built-in undo history. Only one extension may. */
+    history?: (context: EditorExtensionContext) => HistoryProvider;
+    /**
+     * Keep the comment threads somewhere else than `v-model:comments`, e.g.
+     * in a shared document. `v-model:comments` then only mirrors them.
+     * Only one extension may.
+     */
+    comments?: (context: EditorExtensionContext) => CommentsProvider;
+    /** Entries for the slash menu and the “turn into” menus. */
+    blockOptions?: BlockOption[];
+    /** Toggles for the formatting toolbar. */
+    formats?: FormatOption[];
+    /**
+     * Components rendered next to the editing area while it is editable,
+     * e.g. a popup of suggestions. They can call `useEditor()`.
+     */
+    overlays?: Component[];
+    /**
+     * Controls added to the formatting toolbar, after the marks (e.g. a
+     * color menu). They can call `useEditor()`.
+     */
+    toolbar?: Component[];
+    /**
+     * Entries added to the block menu of the handle, usually a
+     * `DouDropdownSub` or `DouDropdownItem`s. Each gets the block the menu is
+     * for as the `block` prop (a `Block`) and can call `useEditor()`.
+     */
+    blockMenu?: Component[];
+    /**
+     * How the extension's blocks, inline nodes and marks are written as HTML
+     * and Markdown (`blocksToHTML`, `blocksToMarkdown`).
+     */
+    output?: EditorExtensionOutput;
+    /**
+     * Rewrite HTML before it is read as blocks (when pasting, and in
+     * `htmlToBlocks` and `markdownToBlocks`), e.g. turn a `<details>`
+     * element into a toggle with its children. `blockElement` and
+     * `splitContainer` help build the editor's markup.
+     */
+    prepareHTML?: (root: HTMLElement) => void;
+}
+/**
+ * Renders `component` into `element` with `props` (a reactive object stays
+ * live), inside the editor's app. Returns a function that removes it.
+ */
+export type MountComponent = (component: Component, props: Record<string, unknown>, element: HTMLElement) => () => void;
+/** Declare an extension; only gives it a type. */
+export declare function defineEditorExtension(extension: EditorExtension): EditorExtension;
+/** Everything the extensions contribute, gathered once per list of extensions. */
+export interface ResolvedEditorExtensions {
+    extensions: EditorExtension[];
+    schema: Schema;
+    context: EditorExtensionContext;
+    nodeViews: Record<string, NodeViewConstructor>;
+    componentViews: Record<string, (mount: MountComponent) => NodeViewConstructor>;
+    blockOptions: BlockOption[];
+    formats: FormatOption[];
+    overlays: Component[];
+    toolbar: Component[];
+    blockMenu: Component[];
+    inputRules: InputRule[];
+    keymaps: Record<string, Command>[];
+    plugins: Plugin[];
+    history: HistoryProvider | null;
+    comments: CommentsProvider | null;
+    externalDocument: boolean;
+}
+/** `mod+shift+h` → `Mod-Shift-h`, the way the ProseMirror keymap names keys. */
+export declare function toEditorKey(hotkey: string): string;
+/** Sort the extensions by priority, build the schema and collect what they add. */
+export declare function resolveEditorExtensions(list: readonly (EditorExtension | EditorExtension[])[]): ResolvedEditorExtensions;

package/dist/types/core/file-drop.d.ts

@@ -0,0 +1,19 @@
+import { Plugin } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+/** A block type that takes pasted and dropped files, e.g. images or attachments. */
+export interface FileDropTarget {
+    /** Whether the target takes this file. */
+    accepts: (file: File) => boolean;
+    /** Takes files no other target accepts (attachments): asked last. */
+    fallback?: boolean;
+    /** Insert blocks for the files after the block at `pos`; returns a position in the last one. */
+    insert: (view: EditorView, files: File[], pos: number) => number;
+    /** Leave a paste to the browser, e.g. an image copied from a page comes with its address. */
+    skipPaste?: (event: ClipboardEvent, files: File[]) => boolean;
+}
+/**
+ * A plugin that hands pasted and dropped files to the targets. However many
+ * extensions take files, the first such plugin sorts all of them out, so
+ * an image and a PDF pasted together both arrive.
+ */
+export declare function fileDropPlugin(target: FileDropTarget): Plugin;

package/dist/types/core/highlight.d.ts

@@ -0,0 +1,32 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { DecorationSet, type EditorView } from 'prosemirror-view';
+/**
+ * Turns code into highlighted HTML, the same function `DouCodeBlock` takes:
+ * `(code, lang) => codeToHtml(code, { lang, themes, defaultColor: false })`
+ * with shiki works as is.
+ */
+export type CodeHighlighter = (code: string, lang: string) => string | Promise<string>;
+/** A highlighted stretch of a code block's text. */
+interface Token {
+    from: number;
+    to: number;
+    style: string;
+    className: string;
+}
+interface HighlightState {
+    decorations: DecorationSet;
+    /** The highlighter the editor falls back on, e.g. one set up in ConfigProvider. */
+    fallback: CodeHighlighter | null;
+}
+export declare const highlightKey: PluginKey<HighlightState>;
+/** Read the tokens from highlighted HTML: the text of each `<span>` with its style and class. */
+export declare function readTokens(html: string, code: string): Token[] | null;
+/**
+ * Highlights code blocks with a highlighter that returns HTML. It runs
+ * after each change (asynchronous highlighters are fine) and the colors
+ * are laid over the text as decorations, so the document keeps plain text.
+ */
+export declare function highlightPlugin(highlight?: CodeHighlighter): Plugin<HighlightState>;
+/** Set the highlighter used when the code block was not given one. */
+export declare function setFallbackHighlighter(view: EditorView, highlight: CodeHighlighter | null): void;
+export {};

package/dist/types/core/input-rules.d.ts

@@ -0,0 +1,21 @@
+import { InputRule } from 'prosemirror-inputrules';
+import { type Plugin } from 'prosemirror-state';
+/**
+ * A Markdown-style shortcut typed at the start of a block, e.g. `# ` for a
+ * heading. It only applies to paragraphs, so typing `# ` inside a heading
+ * or code stays literal. Input rules never run during IME composition.
+ */
+export declare function blockInputRule(pattern: RegExp, type: string, attrs?: (match: RegExpMatchArray) => Record<string, unknown>): InputRule;
+/**
+ * A shortcut that fills an empty paragraph with a block without text (e.g.
+ * `---` for a divider) and opens a paragraph below. The pattern matches the
+ * whole paragraph, the character just typed included.
+ */
+export declare function atomInputRule(pattern: RegExp, type: string): InputRule;
+/**
+ * Formatting typed inline, e.g. `**bold**`. The pattern's first group is
+ * the marked text with its markers, the second the text alone. The
+ * character just typed (the last marker) is not in the document yet.
+ */
+export declare function markInputRule(pattern: RegExp, mark: string): InputRule;
+export declare function editorInputRules(rules: InputRule[]): Plugin;

package/dist/types/core/keymap.d.ts

@@ -0,0 +1,8 @@
+import type { Command, Plugin } from 'prosemirror-state';
+export interface KeymapOptions {
+    /** Undo and redo; the collaboration extension swaps in its own. */
+    undo?: Command;
+    redo?: Command;
+}
+/** The keys every editor has; marks and block types bring their own. */
+export declare function editorKeymap(options?: KeymapOptions): Plugin;

package/dist/types/core/model.d.ts

@@ -0,0 +1,158 @@
+import { type NodeType, type Node as PMNode, type Schema } from 'prosemirror-model';
+import { type TextColor } from './colors';
+import type { ContentType, MarkType } from './schema';
+/** A run of text with its formatting. */
+export interface TextContent {
+    type: 'text';
+    text: string;
+    /** Formatting, in a fixed order: bold, italic, underline, strike, code. */
+    marks?: MarkType[];
+    /** The link target, when the text is a link. */
+    link?: string;
+    /** The text color, by palette name (e.g. `red`), with the `colors` extension. */
+    color?: TextColor;
+    /** The background color, by palette name (e.g. `yellow`), with the `colors` extension. */
+    highlight?: TextColor;
+    /** The ids of the comment threads about this text. */
+    comments?: string[];
+}
+/**
+ * For the `colors` extension's marks (internal): a mark that carries one
+ * color is stored on the text run under this name, e.g.
+ * `{ text, color: 'red' }`, and keeps it in its `value` attribute.
+ */
+export type MarkField = 'color' | 'highlight';
+/** A line break inside a block (`Shift+Enter`). */
+export interface BreakContent {
+    type: 'break';
+}
+/** An inline node an extension adds, e.g. a mention. */
+export interface InlineNodeContent {
+    type: 'inline';
+    /** The node's name, e.g. `mention`. */
+    name: string;
+    props: Record<string, unknown>;
+}
+export type InlineContent = TextContent | BreakContent | InlineNodeContent;
+/** A block's attributes: those of the built-in types, and any an extension declares. */
+export interface BlockProps {
+    /** Heading level, `1` to `3`. */
+    level?: number;
+    /** Whether a to-do item is done. */
+    checked?: boolean;
+    /** The language of a code block. */
+    language?: string;
+    /** The tone of a callout: `info`, `tip`, `warning` or `danger`. */
+    tone?: string;
+    /** How a paragraph, heading or quote lines up; left out when it follows the reading direction. */
+    align?: 'left' | 'center' | 'right';
+    [name: string]: unknown;
+}
+/** A table cell: formatted text, and how far it reaches when merged. */
+export interface TableCell {
+    content: InlineContent[];
+    /** Columns the cell spans, when more than one. */
+    colspan?: number;
+    /** Rows the cell spans, when more than one. */
+    rowspan?: number;
+}
+/** A table row: one cell for every column, including those a merged cell covers. */
+export interface TableRow {
+    /** Stable across edits, like a block's id. */
+    id: string;
+    cells: TableCell[];
+}
+export interface PartialTableCell {
+    content?: InlineContent[] | string;
+    colspan?: number;
+    rowspan?: number;
+}
+export interface PartialTableRow {
+    id?: string;
+    cells: (PartialTableCell | string)[];
+}
+/** One block of the document, as `v-model` reads and writes it. */
+export interface Block {
+    /** Stable across edits; a random UUID unless you provide your own. */
+    id: string;
+    type: ContentType;
+    props: BlockProps;
+    content: InlineContent[];
+    /** The rows of a table; other blocks have none. */
+    rows?: TableRow[];
+    children: Block[];
+}
+/**
+ * The document the editor edits, bound with `v-model`: plain JSON to store
+ * and send as it is. The editor writes full blocks; it reads partial ones.
+ */
+export interface EditorDocument<B extends PartialBlock = Block> {
+    /** The version of the format; see `migrateDocument`. */
+    version: 1;
+    blocks: B[];
+}
+/** A block to insert: everything but the type is optional. */
+export interface PartialBlock {
+    id?: string;
+    type?: ContentType;
+    props?: BlockProps;
+    /** Inline content, or plain text. */
+    content?: InlineContent[] | string;
+    rows?: PartialTableRow[];
+    children?: PartialBlock[];
+}
+/**
+ * A content node spec field for blocks whose content is rows rather than
+ * text (a table): how to read them into a block and build them back.
+ */
+export interface RowsSpec {
+    read: (node: PMNode) => {
+        props: BlockProps;
+        rows: TableRow[];
+    };
+    write: (type: NodeType, props: BlockProps, rows: PartialTableRow[]) => PMNode;
+    /** The node as a grid of ids and cell nodes, for collaboration. */
+    grid: (node: PMNode) => TableGrid;
+}
+/** A table node laid out by ids. */
+export interface TableGrid {
+    /** The props other than `columns`. */
+    props: BlockProps;
+    /** Each column's id and its other fields (width, alignment). */
+    columns: {
+        id: string;
+        width?: number;
+        align?: string;
+    }[];
+    /** Row ids, top to bottom. */
+    rows: string[];
+    /** The cells that are shown, merged ones by their top-left place. */
+    cells: GridCell[];
+}
+export interface GridCell {
+    row: number;
+    col: number;
+    rowspan: number;
+    colspan: number;
+    /** The cell node; its content is inline. */
+    node: PMNode;
+    /** Where the cell starts, counted from the start of the table's content. */
+    offset: number;
+}
+/** A random id; UUIDs keep blocks created at the same time on two devices apart. */
+export declare function createId(): string;
+export declare function inlineOf(node: PMNode): InlineContent[];
+/** A block of the document; shared between reads, so frozen. */
+export declare function blockFromNode(node: PMNode): Block;
+export declare function docToBlocks(doc: PMNode): Block[];
+export declare function inlineNodes(schema: Schema, content: PartialBlock['content'], code: boolean): PMNode[];
+/**
+ * The attributes a content type declares, taken from `props` where given.
+ * A spec's `normalizeProps` can clamp them, e.g. a heading's level.
+ */
+export declare function contentAttrs(type: NodeType, props?: BlockProps): Record<string, unknown>;
+export declare function createContentNode(schema: Schema, type: ContentType, props?: BlockProps, content?: PartialBlock['content'], rows?: PartialTableRow[]): PMNode;
+export declare function nodeFromBlock(schema: Schema, block: PartialBlock): PMNode;
+export declare function blocksToDoc(schema: Schema, blocks: PartialBlock[]): PMNode;
+/** A development warning, once per message. */
+export declare function warnOnce(message: string): void;