stilo-editor 0.1.0 → 0.2.1

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

@@ -21,6 +21,20 @@ export declare function setMark(type: MarkType, attrs?: Attrs | null): Command;
  *   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

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

@@ -12,3 +12,15 @@ export declare function insertBlockNode(tr: Transaction, node: Node): Transactio
  * 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/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

@@ -3,7 +3,7 @@
  * 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'];
+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];
 /**
@@ -27,6 +27,11 @@ export declare const UNSAFE_VALUE: RegExp;
  * - 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):
  *
@@ -59,6 +64,16 @@ export declare function normalizeFontFamily(value: string): string | null;
  * `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`.

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/serialize.d.ts

@@ -1,13 +1,13 @@
 import { DOMSerializer, type Fragment, type Schema } from 'prosemirror-model';
 /** Options of {@link serializeHTML}. */
 export interface SerializeOptions {
-    /** Unwrap the single paragraph of list items. Default: `true`. */
+    /** 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 unwrapped (docs/decisions/0001).
+ * list items and table cells unwrapped (docs/decisions/0001).
  */
 export declare function canonicalizeDOM(root: Element | DocumentFragment, options?: SerializeOptions): void;
 /**

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>>;

package/dist/extensions/default-extensions/index.d.ts

@@ -2,7 +2,9 @@ import type { Extension } from '../../core/extension';
 import { type DropCursorOptions } from '../drop-cursor';
 import { type HeadingOptions } from '../heading';
 import { type HistoryOptions } from '../history';
+import { type ImageOptions } from '../image';
 import { type PlaceholderOptions } from '../placeholder';
+import { type SearchOptions } from '../search';
 /**
  * Options of {@link defaultExtensions}, by extension name: `false` disables the extension, an object
  * configures it. Extensions without options accept only `false`.
@@ -13,11 +15,16 @@ export interface DefaultExtensionsOptions {
     paragraph?: false;
     heading?: false | Partial<HeadingOptions>;
     blockquote?: false;
+    codeBlock?: false;
     horizontalRule?: false;
+    image?: false | Partial<ImageOptions>;
+    table?: false;
     hardBreak?: false;
     bulletList?: false;
     orderedList?: false;
     listItem?: false;
+    taskList?: false;
+    taskItem?: false;
     bold?: false;
     italic?: false;
     underline?: false;
@@ -27,11 +34,15 @@ export interface DefaultExtensionsOptions {
     code?: false;
     link?: false;
     textStyle?: false;
+    textAlign?: false;
+    lineHeight?: false;
     highlight?: false;
     clearFormatting?: false;
+    textCase?: false;
     history?: false | Partial<HistoryOptions>;
     moveBlock?: false;
     placeholder?: false | Partial<PlaceholderOptions>;
+    search?: false | Partial<SearchOptions>;
     dropCursor?: false | Partial<DropCursorOptions>;
     gapCursor?: false;
 }

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

@@ -19,6 +19,7 @@ export interface HeadingOptions {
     levels: HeadingLevel[];
 }
 /**
- * The `heading` node (`<h1>`…`<h6>`), docs/SPEC.md F-302.
+ * The `heading` node (`<h1>`…`<h6>`, with `style` for its alignment and line height),
+ * docs/SPEC.md F-302.
  */
 export declare const Heading: (options?: Partial<HeadingOptions> | undefined) => import("../..").Extension<HeadingOptions>;

package/dist/extensions/image/image-view.d.ts

@@ -0,0 +1,27 @@
+import type { Node } from 'prosemirror-model';
+import type { EditorView, NodeView } from 'prosemirror-view';
+/** The HTML attributes of an `image` node, in output order, without the empty ones. */
+export declare function imageAttributes(node: Node): Record<string, string>;
+/**
+ * The `image` node in the editor: the `<img>` inside a `span.stilo-image` with two side handles,
+ * shown while the image is selected (docs/SPEC.md F-607). Dragging a handle changes the width
+ * and keeps the aspect ratio; releasing it sets `width` and `height` in one transaction.
+ */
+export declare class ImageView implements NodeView {
+    private readonly view;
+    private readonly getPos;
+    readonly dom: HTMLElement;
+    private readonly img;
+    private node;
+    constructor(node: Node, view: EditorView, getPos: () => number | undefined);
+    update(node: Node): boolean;
+    /** The handles handle their own pointer events: ProseMirror must not select or drag. */
+    stopEvent(event: Event): boolean;
+    /** The view changes only the inline width of the `<img>` while a handle is dragged. */
+    ignoreMutation(): boolean;
+    private render;
+    private createHandle;
+    private startResize;
+    /** Sets `width` and `height`; attribute steps keep the image selected. */
+    private setSize;
+}

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

@@ -0,0 +1,29 @@
+import type { Editor } from '../../core/editor';
+declare module '../../core/types' {
+    interface EditorEvents {
+        /**
+         * A pasted image file was not inserted: larger than `maxInlineBytes` (`tooLarge`), or not a
+         * PNG, JPEG, GIF or WebP image (`unsupportedType`).
+         */
+        imageRejected: {
+            editor: Editor;
+            file: File;
+            reason: 'tooLarge' | 'unsupportedType';
+        };
+    }
+}
+/** Options of {@link Image}. */
+export interface ImageOptions {
+    /** Largest image file, in bytes, that paste inserts as a data URL. Default: 5 MB. */
+    maxInlineBytes: number;
+}
+/**
+ * The `image` node (`<img src alt title width height>`, inline), docs/SPEC.md F-601, with the
+ * paste of image files (F-603, F-608) and the resize handles (F-607).
+ *
+ * Paste: when the clipboard has HTML, ProseMirror pastes it (an image copied from a web page keeps
+ * its URL); otherwise each image file becomes an `image` with a base64 `data:` URL, in place of
+ * the selection at the time the files have been read. A file larger than `maxInlineBytes` or of
+ * another type is skipped and reported with the `imageRejected` event.
+ */
+export declare const Image: (options?: Partial<ImageOptions> | undefined) => import("../..").Extension<ImageOptions>;

package/dist/extensions/index.d.ts

@@ -3,6 +3,7 @@ export { Bold } from './bold';
 export { BulletList } from './bullet-list';
 export { ClearFormatting } from './clear-formatting';
 export { Code } from './code';
+export { CodeBlock, type CodeBlockAttributes } from './code-block';
 export { type DefaultExtensionsOptions, defaultExtensions } from './default-extensions';
 export { Document } from './document';
 export { DropCursor, type DropCursorOptions } from './drop-cursor';
@@ -12,16 +13,24 @@ export { Heading, type HeadingLevel, type HeadingOptions } from './heading';
 export { Highlight, type HighlightAttributes } from './highlight';
 export { History, type HistoryOptions } from './history';
 export { HorizontalRule } from './horizontal-rule';
+export { Image, type ImageOptions } from './image';
 export { Italic } from './italic';
+export { LineHeight } from './line-height';
 export { Link, type LinkAttributes } from './link';
 export { ListItem } from './list-item';
 export { MoveBlock } from './move-block';
 export { OrderedList } from './ordered-list';
 export { Paragraph } from './paragraph';
 export { Placeholder, type PlaceholderOptions } from './placeholder';
+export { getSearchResults, Search, type SearchOptions, type SearchResults, type SearchTerm, } from './search';
 export { Strike } from './strike';
 export { Subscript } from './subscript';
 export { Superscript } from './superscript';
+export { getTableHeaders, type InsertTableOptions, Table, type TableHeaders, } from './table';
+export { TaskItem } from './task-item';
+export { TaskList } from './task-list';
 export { Text } from './text';
-export { TextStyle } from './text-style';
+export { TextAlign, type TextAlignment } from './text-align';
+export { type LetterCase, TextCase } from './text-case';
+export { type FontSizeUnit, getFontSize, TextStyle, toFontSize } from './text-style';
 export { Underline } from './underline';

package/dist/extensions/line-height/index.d.ts

@@ -0,0 +1,18 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /**
+         * Sets the line height of the selected paragraphs and headings: a number (`1.5`) or a
+         * percentage (`'150%'`). `false` for another value, or when no selected block has one.
+         */
+        setLineHeight: (lineHeight: number | string) => Command;
+        /** Removes the line height of the selected paragraphs and headings. */
+        unsetLineHeight: () => Command;
+    }
+}
+/**
+ * Line spacing of paragraphs and headings (docs/SPEC.md F-312): the commands. The `lineHeight`
+ * attribute itself belongs to the `paragraph` and `heading` nodes, so content keeps its line
+ * spacing without this extension.
+ */
+export declare const LineHeight: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

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

@@ -1,4 +1,4 @@
-import { type Command } from 'prosemirror-state';
+import type { Command } from 'prosemirror-state';
 declare module '../../core/types' {
     interface Commands {
         /** Splits the list item at the cursor; in an empty item, lifts it out of the list. */

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

@@ -6,9 +6,9 @@ declare module '../../core/types' {
     }
 }
 /**
- * The `paragraph` node (`<p>`). Priority 1000 makes it the first block node, which ProseMirror
- * uses as the default block. `<div>` needs no parse rule: ProseMirror treats it as a block
- * wrapper and wraps its loose inline content in paragraphs (the `div` fallback of
- * docs/ARCHITECTURE.md §7.1).
+ * The `paragraph` node (`<p>`, with `style` for its alignment and line height). Priority 1000
+ * makes it the first block node, which ProseMirror uses as the default block. `<div>` needs no
+ * parse rule: ProseMirror treats it as a block wrapper and wraps its loose inline content in
+ * paragraphs (the `div` fallback of docs/ARCHITECTURE.md §7.1).
  */
 export declare const Paragraph: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

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

@@ -0,0 +1,55 @@
+import { type Command } from 'prosemirror-state';
+import type { Editor } from '../../core/editor';
+declare module '../../core/types' {
+    interface Commands {
+        /** Searches for `term` and highlights the matches; an empty `text` clears the search. */
+        setSearch: (term: SearchTerm) => Command;
+        /** Clears the search and its highlights. */
+        clearSearch: () => Command;
+        /** Selects the next match after the selection, wrapping at the end of the document. */
+        findNext: () => Command;
+        /** Selects the match before the selection, wrapping at the start of the document. */
+        findPrevious: () => Command;
+        /** Replaces the selected match with `replacement` and selects the next one. */
+        replaceNext: (replacement: string) => Command;
+        /** Replaces every match with `replacement`, in one undoable step. */
+        replaceAll: (replacement: string) => Command;
+    }
+}
+/** What {@link Search} looks for. */
+export interface SearchTerm {
+    /** The text to find, taken literally. */
+    text: string;
+    /** Default: `false`. */
+    caseSensitive?: boolean;
+    /** Matches only whole words. Default: `false`. */
+    wholeWord?: boolean;
+}
+/** Options of {@link Search}. */
+export interface SearchOptions {
+    /** Highlights at most the first this many matches; all are counted. Default: 1000. */
+    maxMatches: number;
+}
+/** The matches of the active search, from {@link getSearchResults}. */
+export interface SearchResults {
+    /** The number of matches in the document. */
+    count: number;
+    /** `true` when only the first `maxMatches` matches are highlighted. */
+    limited: boolean;
+    /** The 1-based index of the selected match; 0 when the selection is not a match. */
+    current: number;
+}
+/**
+ * The matches of the active search of `editor`: how many there are, whether only some are
+ * highlighted, and which one is selected. All zero without a search or without the
+ * {@link Search} extension.
+ */
+export declare function getSearchResults(editor: Editor): SearchResults;
+/**
+ * Find and replace, docs/SPEC.md F-902 (ADR 0004). Matching follows `SearchQuery` of
+ * `prosemirror-search` (literal text, case, whole word); the matches get
+ * `class="stilo-search-match"`, the selected one also `stilo-search-match--current`.
+ * Setting a search scans and counts the whole document once; later edits rescan only the
+ * changed textblocks.
+ */
+export declare const Search: (options?: Partial<SearchOptions> | undefined) => import("../..").Extension<SearchOptions>;

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

@@ -0,0 +1,70 @@
+import { type Command } from 'prosemirror-state';
+import { type Editor } from '../../core/editor';
+declare module '../../core/types' {
+    interface Commands {
+        /**
+         * Inserts a table in place of the selection, the cursor in its first cell. `false` inside a
+         * table, or for `rows` / `cols` that are not whole numbers ≥ 1.
+         */
+        insertTable: (options?: InsertTableOptions) => Command;
+        /** Deletes the table around the selection. */
+        deleteTable: () => Command;
+        /** Adds a row above the selected cells. */
+        addRowBefore: () => Command;
+        /** Adds a row below the selected cells. */
+        addRowAfter: () => Command;
+        /** Deletes the rows of the selected cells; `false` when they are all the rows. */
+        deleteRow: () => Command;
+        /** Adds a column left of the selected cells. */
+        addColumnBefore: () => Command;
+        /** Adds a column right of the selected cells. */
+        addColumnAfter: () => Command;
+        /** Deletes the columns of the selected cells; `false` when they are all the columns. */
+        deleteColumn: () => Command;
+        /** Merges the selected cells into one (a rectangle of at least two cells). */
+        mergeCells: () => Command;
+        /** Splits a merged cell back into single cells. */
+        splitCell: () => Command;
+        /** Turns the first row into header cells (`<th>`), or back. */
+        toggleHeaderRow: () => Command;
+        /** Turns the first column into header cells (`<th>`), or back. */
+        toggleHeaderColumn: () => Command;
+        /**
+         * Selects the cells of the row of the cell around `pos` (default: the selection's head);
+         * `false` outside a table.
+         */
+        selectRow: (pos?: number) => Command;
+        /** Selects the cells of the column of the cell around `pos`, as `selectRow`. */
+        selectColumn: (pos?: number) => Command;
+        /** Selects every cell of the table around `pos`, as `selectRow`. */
+        selectTable: (pos?: number) => Command;
+        /** Moves the cursor to the next cell; in the last cell, adds a row first. */
+        goToNextCell: () => Command;
+        /** Moves the cursor to the previous cell. */
+        goToPreviousCell: () => Command;
+    }
+}
+/** Options of the `insertTable` command. */
+export interface InsertTableOptions {
+    /** Number of rows, header row included. Default: 3. */
+    rows?: number;
+    /** Number of columns. Default: 3. */
+    cols?: number;
+    /** Makes the first row of header cells (`<th>`). Default: `true`. */
+    withHeaderRow?: boolean;
+}
+/** Whether the first row and the first column of a table are made of header cells. */
+export interface TableHeaders {
+    row: boolean;
+    column: boolean;
+}
+/**
+ * Whether the first row and the first column of the table around the selection are made of
+ * header cells; `null` outside a table. For a UI showing the state of the header toggles.
+ */
+export declare function getTableHeaders(editor: Editor): TableHeaders | null;
+/**
+ * The `table`, `tableRow`, `tableCell` and `tableHeader` nodes (`<table><tbody><tr><td|th>`),
+ * on `prosemirror-tables`, docs/SPEC.md F-501…F-507. Column widths: docs/decisions/0005.
+ */
+export declare const Table: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

package/dist/extensions/task-item/index.d.ts

@@ -0,0 +1,24 @@
+import { type Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /**
+         * Splits the task item at the cursor: the text keeps the item's state, a new empty item is
+         * unchecked. In an empty item, lifts it.
+         */
+        splitTaskItem: () => Command;
+        /** Nests the selected task items one level deeper. */
+        sinkTaskItem: () => Command;
+        /** Lifts the selected task items one level up (out of the list at the top level). */
+        liftTaskItem: () => Command;
+        /**
+         * Checks the selected task items, or unchecks them when all are checked. `false` outside a
+         * task item and in a code block.
+         */
+        toggleTaskChecked: () => Command;
+    }
+}
+/**
+ * The `taskItem` node (`<li data-checked="true|false">`), docs/SPEC.md F-406. Required by
+ * `TaskList`. In the editor, a node view draws the checkbox (`TaskItemView`).
+ */
+export declare const TaskItem: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

package/dist/extensions/task-item/task-item-view.d.ts

@@ -0,0 +1,24 @@
+import type { Node } from 'prosemirror-model';
+import type { EditorView, NodeView, ViewMutationRecord } from 'prosemirror-view';
+/**
+ * The `taskItem` node in the editor: `<li data-checked>` holding a checkbox
+ * (`input.stilo-task-item__checkbox`) and the content (`div.stilo-task-item__content`). Clicking
+ * the checkbox sets `checked`; it leaves the focus in the editor and does nothing when the editor
+ * is not editable.
+ */
+export declare class TaskItemView implements NodeView {
+    private readonly view;
+    private readonly getPos;
+    readonly dom: HTMLElement;
+    readonly contentDOM: HTMLElement;
+    private readonly checkbox;
+    private node;
+    constructor(node: Node, view: EditorView, getPos: () => number | undefined);
+    update(node: Node): boolean;
+    /** The checkbox handles its own events: ProseMirror must not move the selection. */
+    stopEvent(event: Event): boolean;
+    /** Only the content is ProseMirror's: the checkbox and the `data-checked` are the view's. */
+    ignoreMutation(mutation: ViewMutationRecord): boolean;
+    private render;
+    private setChecked;
+}

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

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

package/dist/extensions/text-align/index.d.ts

@@ -0,0 +1,18 @@
+import type { Command } from 'prosemirror-state';
+import type { TextAlignment } from '../../core/helpers/block-style';
+declare module '../../core/types' {
+    interface Commands {
+        /**
+         * Aligns the selected paragraphs and headings. `false` for another value, or when no
+         * selected block can be aligned.
+         */
+        setTextAlign: (alignment: TextAlignment) => Command;
+    }
+}
+/**
+ * Text alignment of paragraphs and headings (docs/SPEC.md F-308): the command and its
+ * shortcuts. The `textAlign` attribute itself belongs to the `paragraph` and `heading` nodes, so
+ * aligned content keeps its alignment without this extension.
+ */
+export declare const TextAlign: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;
+export type { TextAlignment } from '../../core/helpers/block-style';

package/dist/extensions/text-case/index.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from 'prosemirror-state';
+/**
+ * A letter case: `upper` (UPPERCASE), `lower` (lowercase), `title` (Title Case), `sentence`
+ * (Sentence case), `toggle` (tOGGLE cASE).
+ */
+export type LetterCase = 'upper' | 'lower' | 'title' | 'sentence' | 'toggle';
+declare module '../../core/types' {
+    interface Commands {
+        /** Changes the case of the characters of the selection; marks are kept. */
+        setTextCase: (letterCase: LetterCase) => Command;
+    }
+}
+/** The `setTextCase` command, docs/SPEC.md F-213: changes the characters, not a style. */
+export declare const TextCase: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

package/dist/extensions/text-style/font-size.d.ts

@@ -0,0 +1,21 @@
+import type { Editor } from '../../core/editor';
+/**
+ * The unit of a font size control: the number it shows and the unit it writes. `rem` shows px
+ * and writes rem, so the text follows the base size of the page that displays it.
+ */
+export type FontSizeUnit = 'pt' | 'px' | 'rem';
+/**
+ * The font size of the text at `pos` in `unit`, rounded to one decimal: the size the browser
+ * renders, so it includes headings, `em` and the page's own base size. Without `pos`, the size
+ * at the start of the selection; for an empty selection, the size stored for the next typed text
+ * when there is one (the page does not show it yet). Where nothing can be measured (no layout, as
+ * in jsdom) it counts 16px (12pt).
+ */
+export declare function getFontSize(editor: Editor, unit?: FontSizeUnit, pos?: number): number;
+/** The CSS font size for `value` in `unit`: `12` → `12pt`; for `rem`, px divided by the base. */
+export declare function toFontSize(editor: Editor, value: number, unit?: FontSizeUnit): string;
+/**
+ * The size after a step of `delta` from `size`: up to the next whole number, or down to the
+ * previous one (`13.5` + 1 → `14`), kept between 1 and 400.
+ */
+export declare function stepFontSizeValue(size: number, delta: number): number;