stilo-editor 0.0.0-stage → 0.2.0

package/dist/core/helpers/block-style.d.ts

@@ -0,0 +1,25 @@
+import type { Attrs, DOMOutputSpec, Node, NodeType } from 'prosemirror-model';
+/** A text alignment (docs/SPEC.md F-308). `left` is the default and is stored as `null`. */
+export type TextAlignment = 'left' | 'center' | 'right' | 'justify';
+/** The `textAlign` and `lineHeight` attributes of a textblock spec, both `null` by default. */
+export declare function blockStyleAttrs(): {
+    textAlign: {
+        default: null;
+    };
+    lineHeight: {
+        default: null;
+    };
+};
+/**
+ * The style attributes of `node` that `type` also has, to keep them when a block becomes `type`
+ * (a centered paragraph stays centered as a heading).
+ */
+export declare function keptBlockStyles(type: NodeType, node: Node): Attrs;
+/**
+ * The style attributes of a parsed block: its `text-align` (`null` for left) and `line-height`.
+ * `null` when it has neither, so the block keeps the shared default attributes: one object per
+ * paragraph is a lot of memory in a large document.
+ */
+export declare function parseBlockStyle(element: HTMLElement): Attrs | null;
+/** The `toDOM` output of a textblock `tag` with its style attributes, if any. */
+export declare function blockStyleDOM(tag: string, node: Node): DOMOutputSpec;

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

@@ -0,0 +1,28 @@
+import { InputRule } from 'prosemirror-inputrules';
+import type { Attrs, MarkType, NodeType } from 'prosemirror-model';
+/**
+ * Creates an input rule that turns markdown-like syntax into a mark.
+ *
+ * Contract for `regexp`: it ends with `$`; capture group 1 is the text to mark; the syntax
+ * characters immediately around group 1 (e.g. `**`) are part of the match, and the opening and
+ * closing syntax have the same length; an optional leading context (e.g. `(?:^|[^*])`) may
+ * precede the syntax but must be a **non-capturing** group that consumes at most one character.
+ *
+ * When the rule fires: the opening and closing syntax are deleted and the mark is added to the
+ * text (its other marks are kept); the leading context character (if any) is left untouched;
+ * the mark is removed from the stored marks so that typing continues unmarked. Returns `null`
+ * (rule does not apply) if group 1 is empty or the parent node does not allow the mark.
+ *
+ * ```ts
+ * markInputRule(/(?:^|[^*])(\*\*([^*]+)\*\*)$/, schema.marks.bold!) // NOT this: group 1 = text
+ * markInputRule(/(?:^|[^*])\*\*([^*]+)\*\*$/, schema.marks.bold!)   // correct
+ * ```
+ */
+export declare function markInputRule(regexp: RegExp, type: MarkType, attrs?: Attrs | null): InputRule;
+/**
+ * Like `textblockTypeInputRule` from prosemirror-inputrules (turns the textblock where `regexp`
+ * matches at its start into `type` with `attrs`, or with the attributes `attrs` returns for the
+ * match), but the block keeps the style attributes (`textAlign`, `lineHeight`) that `type` also
+ * has, as `setTextblockType` does.
+ */
+export declare function textblockTypeInputRule(regexp: RegExp, type: NodeType, attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)): InputRule;

package/dist/core/helpers/lists.d.ts

@@ -0,0 +1,20 @@
+import type { Attrs, NodeType } from 'prosemirror-model';
+import { type Command } from 'prosemirror-state';
+/**
+ * Command: toggles a list of `listType` (whose items are `itemType`) at the selection. List
+ * nodes are recognized by the `list` group in their spec. Looking at the nearest list around
+ * the start of the selection:
+ *
+ * - a list of `listType`: the selected items are lifted out one level (`liftListItem`);
+ * - a list of another type: that list becomes a `listType` list with `attrs`, its items
+ *   `itemType` items (a task item loses its `checked` state);
+ * - no list: the selected blocks are wrapped in a new list (`wrapInList`).
+ */
+export declare function toggleList(listType: NodeType, itemType: NodeType, attrs?: Attrs | null): Command;
+/**
+ * Command for `Backspace` in lists whose items are `itemType`. At the start of the first
+ * textblock of an item, lifts the item (`liftListItem`). At the start of a textblock right after
+ * such a list, moves its content to the end of the list's last textblock and deletes it (an
+ * empty one just disappears); without this, ProseMirror wraps the textblock in a new item.
+ */
+export declare function backspaceInList(itemType: NodeType): Command;

package/dist/core/helpers/marks.d.ts

@@ -0,0 +1,52 @@
+import type { Attrs, MarkType, ResolvedPos } from 'prosemirror-model';
+import type { Command } from 'prosemirror-state';
+/**
+ * Command: adds a mark of `type` with `attrs` to the selection. A mark that `type` excludes
+ * and that excludes `type` is replaced (superscript becomes subscript).
+ *
+ * - Empty selection: adds the mark to the stored marks (applies to the next typed text).
+ *   Returns `false` if the parent node does not allow the mark, or a mark at the cursor
+ *   excludes it (e.g. bold inside code).
+ * - Non-empty selection: adds the mark to every selection range. Returns `false` if no text in
+ *   the selection accepts the mark (parent allows it, no existing mark excludes it). The
+ *   transaction scrolls into view.
+ */
+export declare function setMark(type: MarkType, attrs?: Attrs | null): Command;
+/**
+ * Command: removes marks of `type` from the selection.
+ *
+ * - Empty selection: removes the mark from the stored marks. Returns `false` if the mark is
+ *   not in the stored marks / cursor marks.
+ * - Non-empty selection: removes the mark from every range. Returns `false` if no range has the
+ *   mark. The transaction scrolls into view.
+ */
+export declare function unsetMark(type: MarkType): Command;
+/**
+ * Command: merges `attrs` into the mark of `type` on the selection, keeping its other
+ * attributes; a mark whose attributes all become `null` is removed. Lets one mark carry several
+ * independent attributes (`textStyle`: font family, size, color).
+ *
+ * - Setting (some value in `attrs` is not `null`): like {@link setMark}, applies to the stored
+ *   marks or to every selected text that accepts the mark; `false` when none does.
+ * - Clearing (every value is `null`): applies where the mark has one of these attributes;
+ *   `false` when none has.
+ *
+ * `attrs` can be a function of the position of each selected text (the cursor for an empty
+ * selection), for values that differ along the selection; `null` leaves that text alone.
+ */
+export declare function updateMarkAttrs(type: MarkType, attrs: Attrs | ((pos: number) => Attrs | null)): Command;
+/**
+ * Command: {@link unsetMark} when the mark is active (see `isMarkActive`), otherwise
+ * {@link setMark}. Unlike `toggleMark` from prosemirror-commands, a partially marked selection
+ * gets the mark added, consistently with `isActive`.
+ */
+export declare function toggleMark(type: MarkType, attrs?: Attrs | null): Command;
+/**
+ * The range of the mark of `type` at `$pos` (the one in `$pos.marks()`), extended over the
+ * adjacent inline nodes that carry the same mark with the same attributes. `null` if there is no
+ * such mark at `$pos`. Lets a command edit or remove a whole link with the cursor inside it.
+ */
+export declare function markRangeAt($pos: ResolvedPos, type: MarkType): {
+    from: number;
+    to: number;
+} | null;

package/dist/core/helpers/nodes.d.ts

@@ -0,0 +1,26 @@
+import type { Attrs, Node, NodeType } from 'prosemirror-model';
+import { type Command, type Transaction } from 'prosemirror-state';
+/**
+ * Inserts a block `node` in place of the selection and puts the cursor at the start of the
+ * textblock after it, creating a paragraph when no textblock follows. Used by commands and
+ * input rules that insert atom blocks (horizontal rule, figure).
+ */
+export declare function insertBlockNode(tr: Transaction, node: Node): Transaction;
+/**
+ * Command: inserts a block of `type` with {@link insertBlockNode}. Returns `false` where the
+ * container of the selection (the parent of the selected textblock, or the parent of a selected
+ * block node) does not allow `type`.
+ */
+export declare function insertBlock(type: NodeType, attrs?: Attrs | null): Command;
+/**
+ * Command: like `setBlockType` from prosemirror-commands (turns the selected textblocks into
+ * `type` with `attrs`), but a block keeps the style attributes (`textAlign`, `lineHeight`) that
+ * `type` also has, so a centered heading stays centered as a paragraph. `false` when no selected
+ * textblock changes.
+ */
+export declare function setTextblockType(type: NodeType, attrs?: Attrs): Command;
+/**
+ * Command: sets the attribute `name` to `value` on every selected textblock whose type has that
+ * attribute (`textAlign`, `lineHeight`). `false` when no selected textblock has it.
+ */
+export declare function setTextblockAttr(name: string, value: unknown): Command;

package/dist/core/helpers/parse-rules.d.ts

@@ -0,0 +1,8 @@
+import type { StyleParseRule } from 'prosemirror-model';
+/**
+ * Parse rules that match a `text-decoration` / `text-decoration-line` style containing
+ * `keyword` (e.g. `underline`). Both properties are listed because ProseMirror reads only the
+ * properties named in rules. The rules are not consuming, so several marks can match one
+ * declaration (`text-decoration: underline line-through`).
+ */
+export declare function textDecorationRules(keyword: string): StyleParseRule[];

package/dist/core/helpers/word-count.d.ts

@@ -0,0 +1,14 @@
+import type { Editor } from '../editor';
+/** Words and characters of a document, from {@link getWordCount}. */
+export interface WordCount {
+    /** Runs of non-space characters with at least one letter or digit. */
+    words: number;
+    /** Characters of the text, spaces included, line and paragraph breaks excluded. */
+    characters: number;
+}
+/**
+ * Counts the words and characters of the document, docs/SPEC.md F-901. The first call reads the
+ * whole document, later calls only the changed top-level blocks: call it on demand or debounced,
+ * never on every transaction (ADR 0003).
+ */
+export declare function getWordCount(editor: Editor): WordCount;

package/dist/core/html/css.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Inline style handling: allowlist, parsing, normalization and building of `style` strings.
+ * See docs/ARCHITECTURE.md §7.3. Extensions never handle raw style strings themselves.
+ */
+/** CSS properties allowed in the HTML output, in output order. */
+export declare const STYLE_PROPERTIES: readonly ['font-family', 'font-size', 'color', 'background-color', 'text-align', 'line-height', 'width'];
+/** A property allowed in the HTML output. */
+export type StyleProperty = (typeof STYLE_PROPERTIES)[number];
+/**
+ * Properties accepted on input only: parse rules read them (e.g. `font-weight` → bold), but they
+ * never appear in the output.
+ */
+export declare const INPUT_ONLY_STYLE_PROPERTIES: readonly ['font-weight', 'font-style', 'text-decoration', 'text-decoration-line', 'vertical-align'];
+/** CSS-wide keywords rejected as color values. */
+export declare const CSS_WIDE_KEYWORDS: readonly string[];
+/**
+ * Values containing any of these are always rejected: `url(`, `expression(` (case-insensitive,
+ * optional spaces before `(`), `javascript:`, and the characters `<`, `>`, `{`, `}`, `\`.
+ */
+export declare const UNSAFE_VALUE: RegExp;
+/**
+ * Parses a `style` attribute into a map of property → value.
+ *
+ * - Declarations are separated by `;`; property and value by the first `:`.
+ * - Properties are trimmed and lowercased; values are trimmed and `!important` is removed.
+ * - Declarations without `:` or with an empty property/value are skipped.
+ * - When a property appears twice, the last one wins.
+ */
+export declare function parseStyle(style: string): Map<string, string>;
+/**
+ * Formats declarations (as returned by {@link parseStyle}) as `prop: value` joined with `; `.
+ * Returns `null` when there are none.
+ */
+export declare function formatStyle(declarations: ReadonlyMap<string, string>): string | null;
+/**
+ * Normalizes a color value (input is trimmed and lowercased first):
+ *
+ * - `#rgb` → `#rrggbb`; `#rrggbb` kept (lowercase).
+ * - `rgb(r, g, b)` (channels 0–255, any spacing) → `#rrggbb`.
+ * - `rgba(r, g, b, a)` with `a` = 1 (or 100%) → `#rrggbb`; with 0 ≤ `a` < 1 →
+ *   `rgba(r, g, b, a)` with `, ` separators and `a` rounded to 3 decimals.
+ * - A keyword matching `^[a-z]{3,20}$` is kept, unless it is in {@link CSS_WIDE_KEYWORDS}.
+ * - Anything else (channel > 255, alpha out of range, other formats) → `null`.
+ */
+export declare function normalizeColor(value: string): string | null;
+/**
+ * Normalizes a font size: trimmed and lowercased, it must match
+ * `^\d+(\.\d+)?(px|pt|em|rem|%)$`, otherwise `null`.
+ */
+export declare function normalizeFontSize(value: string): string | null;
+/**
+ * Normalizes a font family list:
+ *
+ * - split by `,`; each name trimmed, surrounding `"` or `'` removed, inner whitespace collapsed;
+ * - empty names and names containing `"`, `'`, `<`, `>`, `;` are dropped;
+ * - names made only of letters, digits and `-` stay unquoted, others are wrapped in `'`;
+ * - joined with `, `. Returns `null` if no name remains.
+ *
+ * Example: `"Times New Roman" ,serif` → `'Times New Roman', serif`.
+ */
+export declare function normalizeFontFamily(value: string): string | null;
+/**
+ * Normalizes `text-align` (trimmed, lowercased): `left`, `center`, `right`, `justify` kept;
+ * `start` → `left`; anything else → `null`.
+ */
+export declare function normalizeTextAlign(value: string): string | null;
+/**
+ * Normalizes `line-height` (trimmed): a number `^\d+(\.\d+)?$` or a percentage of it (`115%` →
+ * `1.15`), rounded to 2 decimals without trailing zeros; zero, `normal` and lengths → `null`.
+ */
+export declare function normalizeLineHeight(value: string): string | null;
+/**
+ * Normalizes a `width` (trimmed, lowercased): whole pixels, `^\d+(\.\d+)?px$` rounded
+ * (`120.4px` → `120px`); zero, other units and keywords → `null` (docs/decisions/0005).
+ */
+export declare function normalizeWidth(value: string): string | null;
+/**
+ * Normalizes the value of an output property with the matching normalizer above.
+ * Returns `null` if the value matches {@link UNSAFE_VALUE} or the normalizer returns `null`.
+ */
+export declare function normalizeStyleValue(property: StyleProperty, value: string): string | null;
+/**
+ * Builds a canonical `style` string: only {@link STYLE_PROPERTIES}, in that order, values
+ * normalized with {@link normalizeStyleValue} (invalid ones skipped), formatted as
+ * `prop: value` joined with `; ` and no trailing `;`. `null`/`undefined` values are skipped.
+ * Returns `null` if nothing remains.
+ *
+ * Example: `{ color: 'RGB(255,0,0)', 'font-size': '12PT' }` → `font-size: 12pt; color: #ff0000`.
+ */
+export declare function buildStyle(values: Partial<Record<StyleProperty, string | null | undefined>>): string | null;
+/**
+ * Reads one output property from an element's `style` attribute (via {@link parseStyle}) and
+ * normalizes it (via {@link normalizeStyleValue}). Returns `null` if absent or invalid.
+ * Use this in parse rules (`getAttrs`).
+ */
+export declare function readStyle(element: HTMLElement, property: StyleProperty): string | null;
+/**
+ * Filters a `style` attribute for sanitization:
+ *
+ * 1. the output properties, normalized, in {@link STYLE_PROPERTIES} order (invalid dropped);
+ * 2. then the {@link INPUT_ONLY_STYLE_PROPERTIES}, in that order, kept only if the value matches
+ *    `^[a-z0-9 .,%#()-]+$` (case-insensitive) and not {@link UNSAFE_VALUE}; value lowercased.
+ *
+ * Formatted like {@link buildStyle}. Returns `null` if nothing remains.
+ */
+export declare function sanitizeStyle(style: string): string | null;

package/dist/core/html/parse.d.ts

@@ -0,0 +1,7 @@
+import { type Node, type Schema } from 'prosemirror-model';
+/**
+ * Parses HTML into a ProseMirror document: the HTML is sanitized with `sanitizeToDOM` and the
+ * resulting element is parsed with `DOMParser.fromSchema(schema)` from prosemirror-model.
+ * An empty string produces the empty document (one empty paragraph).
+ */
+export declare function parseHTML(schema: Schema, html: string): Node;

package/dist/core/html/paste/base-styles.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Removes the base style of a document pasted from a word processor: for each of
+ * {@link BASE_PROPERTIES}, the value that covers most of the pasted text (Arial, 11pt, black)
+ * is removed everywhere, so only the text that differs keeps its value. `font-size` is also
+ * removed inside headings, whose level gives the size.
+ */
+export declare function removeBaseStyles(body: HTMLElement): void;

package/dist/core/html/paste/google-docs.d.ts

@@ -0,0 +1,7 @@
+/** The element that wraps the HTML Google Docs puts on the clipboard. */
+export declare const GOOGLE_DOCS_WRAPPER = "[id^=\"docs-internal-guid-\"]";
+/**
+ * Cleans the HTML of Google Docs: an empty paragraph arrives as a `<br>` between the blocks of the
+ * wrapper and becomes an empty `<p>`.
+ */
+export declare function cleanGoogleDocs(wrapper: Element): void;

package/dist/core/html/paste/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Cleans pasted HTML before it is sanitized (docs/ARCHITECTURE.md §8). The HTML is parsed with an
+ * inert `DOMParser` (no scripts run, no images load), then:
+ *
+ * - from Microsoft Word or Google Docs: their own cleanup, then {@link removeBaseStyles};
+ * - a heading that starts a list item becomes a paragraph (a list item starts with one);
+ * - tables keep the column widths they carry ({@link readTableWidths}).
+ */
+export declare function cleanPastedHTML(html: string): string;

package/dist/core/html/paste/table-widths.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Writes the column widths a pasted table carries as `data-colwidth` on its cells
+ * (docs/decisions/0005): from its `<col>` elements (`width` attribute or `style="width"`), else
+ * from the cells that span one column. Only pixel widths count; a table without them, or whose
+ * cells already have `data-colwidth`, is left as it is.
+ */
+export declare function readTableWidths(body: HTMLElement): void;

package/dist/core/html/paste/word.d.ts

@@ -0,0 +1,8 @@
+/** Markers of the HTML that Microsoft Word puts on the clipboard. */
+export declare const WORD_HTML: RegExp;
+/**
+ * Cleans the HTML of Microsoft Word: removes the `<o:p>` paragraph ends and turns its list
+ * paragraphs (`style="mso-list: l0 level1 lfo1"`, the marker in a `mso-list: Ignore` span) into
+ * nested `<ul>` / `<ol>`.
+ */
+export declare function cleanWord(body: HTMLElement): void;

package/dist/core/html/sanitize.d.ts

@@ -0,0 +1,49 @@
+/**
+ * HTML sanitization with DOMPurify. See docs/ARCHITECTURE.md §8 and docs/SPEC.md NFR-2.
+ *
+ * Implementation requirements:
+ *
+ * - Use a **Stilo-owned DOMPurify instance**, created lazily with `DOMPurify(window)` and cached
+ *   per `window` (WeakMap). Never add hooks to the default DOMPurify export: it may be shared
+ *   with the host application. No DOM access at module top level.
+ * - Config: `ALLOWED_TAGS`, `ALLOWED_ATTR` below, `ALLOW_DATA_ATTR: false`. Unknown tags are
+ *   unwrapped with their content kept (DOMPurify default).
+ * - One `uponSanitizeAttribute` hook filters attribute values; when the filter returns `null`
+ *   the attribute is removed (`keepAttr = false`), otherwise `attrValue` is replaced:
+ *   - `style` → `sanitizeStyle(value)` from `./css`;
+ *   - `class` → only tokens matching `^language-[\w-]+$`, joined with a space;
+ *   - `href` → kept (trimmed) if {@link isAllowedHref};
+ *   - `src` → kept (trimmed) if {@link isAllowedImageSrc};
+ *   - `target` → kept only if exactly `_blank`;
+ *   - any other allowed attribute → unchanged.
+ */
+/** Tags kept by the sanitizer. */
+export declare const ALLOWED_TAGS: readonly string[];
+/** Attributes kept by the sanitizer (values further filtered by the hook). */
+export declare const ALLOWED_ATTR: readonly string[];
+/** Schemes allowed in `href`. */
+export declare const LINK_PROTOCOLS: readonly string[];
+/** Schemes allowed in `img src` (besides the data URLs matched by {@link IMAGE_DATA_URL}). */
+export declare const IMAGE_PROTOCOLS: readonly string[];
+/** Image data URLs allowed in `img src`. No SVG. */
+export declare const IMAGE_DATA_URL: RegExp;
+/**
+ * Extracts the lowercased URL scheme (`"https"` for `https://x`), or `null` for relative URLs
+ * and fragments. Whitespace and control characters (U+0000–U+001F) are removed first, because
+ * browsers ignore them inside schemes (`java\tscript:` is `javascript:`).
+ */
+export declare function urlScheme(url: string): string | null;
+/** Whether a URL is allowed in `href`: relative, fragment, or scheme in {@link LINK_PROTOCOLS}. */
+export declare function isAllowedHref(url: string): boolean;
+/**
+ * Whether a URL is allowed in `img src`: non-empty relative URL, scheme in
+ * {@link IMAGE_PROTOCOLS}, or a `data:` URL matching {@link IMAGE_DATA_URL}.
+ */
+export declare function isAllowedImageSrc(url: string): boolean;
+/** Sanitizes HTML and returns it as a string. Used for paste (`transformPastedHTML`). */
+export declare function sanitizeToString(html: string): string;
+/**
+ * Sanitizes HTML and returns a detached `<body>` element (DOMPurify `RETURN_DOM: true`), which
+ * avoids a serialize/parse round trip. Used by `parseHTML`.
+ */
+export declare function sanitizeToDOM(html: string): HTMLElement;

package/dist/core/html/serialize.d.ts

@@ -0,0 +1,31 @@
+import { DOMSerializer, type Fragment, type Schema } from 'prosemirror-model';
+/** Options of {@link serializeHTML}. */
+export interface SerializeOptions {
+    /** Unwrap the single paragraph of list items and table cells. Default: `true`. */
+    compactParagraphs?: boolean;
+}
+/**
+ * Canonical post-processing of serialized HTML, in place (docs/ARCHITECTURE.md §8.1): styles
+ * rewritten with `sanitizeStyle`, and with `compactParagraphs` (default) the single paragraph of
+ * list items and table cells unwrapped (docs/decisions/0001).
+ */
+export declare function canonicalizeDOM(root: Element | DocumentFragment, options?: SerializeOptions): void;
+/**
+ * Serializes a fragment (usually `doc.content`) to a canonical HTML string
+ * (docs/ARCHITECTURE.md §7): `DOMSerializer.fromSchema(schema).serializeFragment()` into a
+ * container element of a detached document (`document.implementation.createHTMLDocument('')`),
+ * then the container's `innerHTML`. Before that:
+ *
+ * - every `style` attribute is rewritten with `sanitizeStyle`: ProseMirror sets styles through
+ *   `style.cssText`, and the browser re-serializes them (trailing `;`, `rgb()` colors);
+ * - with `compactParagraphs` (default), a `<p>` without attributes that is the only child of a
+ *   {@link COMPACT_CONTAINERS} element is replaced by its content (docs/decisions/0001).
+ *
+ * Post-processing is now handled by {@link canonicalizeDOM}.
+ */
+export declare function serializeHTML(schema: Schema, fragment: Fragment, options?: SerializeOptions): string;
+/**
+ * A `DOMSerializer` for the clipboard (`clipboardSerializer` prop): same output as
+ * `DOMSerializer.fromSchema(schema)`, post-processed with `canonicalizeDOM`.
+ */
+export declare function createClipboardSerializer(schema: Schema, options?: SerializeOptions): DOMSerializer;

package/dist/core/types.d.ts

@@ -0,0 +1,107 @@
+import type { Command, Transaction } from 'prosemirror-state';
+import type { Editor } from './editor';
+import type { Extension } from './extension';
+/**
+ * Registry of all editor commands. Each extension adds its own entries through module
+ * augmentation:
+ *
+ * ```ts
+ * declare module '../../core/types' {
+ *   interface Commands {
+ *     toggleBold: () => Command;
+ *   }
+ * }
+ * ```
+ */
+export interface Commands {
+}
+/** Name of a registered command. */
+export type CommandName = keyof Commands;
+/** A function that receives command arguments and returns a ProseMirror command. */
+export type CommandFactory = (...args: never[]) => Command;
+/** The command factories an extension provides. */
+export type CommandFactories = {
+    [K in CommandName]: Commands[K];
+};
+/**
+ * An executable command: same arguments as its factory, returns whether the command applied.
+ * `can(...args)` runs it without dispatching: whether it would apply.
+ */
+export type CommandRunner<A extends unknown[]> = ((...args: A) => boolean) & {
+    can: (...args: A) => boolean;
+};
+/** Executable commands, by name. */
+export type CommandRunners = {
+    [K in CommandName]: Commands[K] extends (...args: infer A) => Command ? CommandRunner<A> : never;
+};
+/** ProseMirror JSON representation of a document or node. */
+export interface JSONContent {
+    type: string;
+    attrs?: Record<string, unknown>;
+    content?: JSONContent[];
+    marks?: Array<{
+        type: string;
+        attrs?: Record<string, unknown>;
+    }>;
+    text?: string;
+}
+/** Options of the {@link Editor} constructor. */
+export interface EditorOptions {
+    /** Container element; the editor appends its own DOM inside it. */
+    element: HTMLElement;
+    /** Extensions to load. Nested arrays (e.g. `defaultExtensions()`) are flattened. */
+    extensions: Array<Extension | Extension[]>;
+    /** Initial HTML content. Default: empty document. */
+    content?: string;
+    /** Whether the content is editable. Default: `true`. */
+    editable?: boolean;
+    /** Focus the editor after creation. Default: `false`. */
+    autofocus?: boolean | 'start' | 'end';
+    /** `aria-label` of the editable area. */
+    ariaLabel?: string;
+    /**
+     * Write a list item (and, from M2, a table cell) whose only content is one paragraph without
+     * attributes without its `<p>`: `<li>text</li>`. `false` keeps ProseMirror's standard output,
+     * `<li><p>text</p></li>`. Default: `true`. See docs/decisions/0001-tight-list-items.md.
+     */
+    compactParagraphs?: boolean;
+}
+/** Options of `setHTML` / `setJSON`. */
+export interface SetContentOptions {
+    /**
+     * `false` (default): replace the content with one undoable transaction.
+     * `true`: create a fresh state; history and all plugin states start from scratch.
+     */
+    resetHistory?: boolean;
+    /** Emit the `input` event. Default: `true`. */
+    emitInput?: boolean;
+}
+/** Events emitted by the {@link Editor}. */
+export interface EditorEvents {
+    /** Every applied transaction. */
+    transaction: {
+        editor: Editor;
+        transaction: Transaction;
+    };
+    /** The document changed. `transaction` is `null` when the state was replaced (`resetHistory`). */
+    input: {
+        editor: Editor;
+        transaction: Transaction | null;
+    };
+    /** The selection changed while the document did not. */
+    selectionchange: {
+        editor: Editor;
+        transaction: Transaction;
+    };
+    focus: {
+        editor: Editor;
+        event: FocusEvent;
+    };
+    blur: {
+        editor: Editor;
+        event: FocusEvent;
+    };
+    destroy: {
+        editor: Editor;
+    };
+}

package/dist/extensions/blockquote/index.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Turns the selected textblocks into a blockquote. */
+        setBlockquote: () => Command;
+        /** Removes the blockquote from the selected textblocks. */
+        unsetBlockquote: () => Command;
+        /** Removes the blockquote if active, otherwise adds it. */
+        toggleBlockquote: () => Command;
+    }
+}
+/**
+ * The `blockquote` node (`<blockquote>`), docs/SPEC.md F-303.
+ */
+export declare const Blockquote: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

package/dist/extensions/bold/index.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Adds bold to the selection. */
+        setBold: () => Command;
+        /** Removes bold from the selection. */
+        unsetBold: () => Command;
+        /** Removes bold if the whole selection is bold, otherwise adds it. */
+        toggleBold: () => Command;
+    }
+}
+/**
+ * The `bold` mark (`<strong>`), docs/SPEC.md F-201. Also parsed from `<b>` (except the Google Docs
+ * wrapper `<b style="font-weight: normal">`) and from a bold `font-weight` style.
+ * Reference extension: every extension has this shape.
+ */
+export declare const Bold: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

package/dist/extensions/bullet-list/index.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Wraps the selection in a bullet list, lifts it out, or converts another list type. */
+        toggleBulletList: () => Command;
+    }
+}
+/** The `bulletList` node (`<ul>`), docs/SPEC.md F-401, F-405. Requires `ListItem`. */
+export declare const BulletList: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

package/dist/extensions/clear-formatting/index.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Removes every formatting mark (all marks except links) from the selection. */
+        clearFormatting: () => Command;
+    }
+}
+/**
+ * The `clearFormatting` command, docs/SPEC.md F-212: removes the marks of the `formatting`
+ * group (docs/ARCHITECTURE.md §7.2), so links stay.
+ */
+export declare const ClearFormatting: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

package/dist/extensions/code/index.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Adds inline code to the selection. */
+        setCode: () => Command;
+        /** Removes inline code from the selection. */
+        unsetCode: () => Command;
+        /** Removes inline code if the whole selection is code, otherwise adds it. */
+        toggleCode: () => Command;
+    }
+}
+/**
+ * The `code` mark (`<code>`), docs/SPEC.md F-205.
+ */
+export declare const Code: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

package/dist/extensions/code-block/index.d.ts

@@ -0,0 +1,24 @@
+import { type Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /**
+         * Turns the selected textblocks into one code block (sibling blocks are joined, one line
+         * each), or sets the language of the code block.
+         */
+        setCodeBlock: (attrs?: CodeBlockAttributes) => Command;
+        /** Turns the selected code blocks into paragraphs, one per line. */
+        unsetCodeBlock: () => Command;
+        /** Removes the code block if active, otherwise adds it. */
+        toggleCodeBlock: (attrs?: CodeBlockAttributes) => Command;
+    }
+}
+/** Attributes of the `codeBlock` node. */
+export interface CodeBlockAttributes {
+    /** The language, written as `class="language-<language>"`; `null` for none. */
+    language?: string | null;
+}
+/**
+ * The `codeBlock` node (`<pre><code class="language-x">`), plain text without marks,
+ * docs/SPEC.md F-306.
+ */
+export declare const CodeBlock: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;