stilo-editor 0.0.0-stage → 0.1.0

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. 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).
+ */
+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/default-extensions/index.d.ts

@@ -0,0 +1,46 @@
+import type { Extension } from '../../core/extension';
+import { type DropCursorOptions } from '../drop-cursor';
+import { type HeadingOptions } from '../heading';
+import { type HistoryOptions } from '../history';
+import { type PlaceholderOptions } from '../placeholder';
+/**
+ * Options of {@link defaultExtensions}, by extension name: `false` disables the extension, an object
+ * configures it. Extensions without options accept only `false`.
+ */
+export interface DefaultExtensionsOptions {
+    doc?: false;
+    text?: false;
+    paragraph?: false;
+    heading?: false | Partial<HeadingOptions>;
+    blockquote?: false;
+    horizontalRule?: false;
+    hardBreak?: false;
+    bulletList?: false;
+    orderedList?: false;
+    listItem?: false;
+    bold?: false;
+    italic?: false;
+    underline?: false;
+    strike?: false;
+    subscript?: false;
+    superscript?: false;
+    code?: false;
+    link?: false;
+    textStyle?: false;
+    highlight?: false;
+    clearFormatting?: false;
+    history?: false | Partial<HistoryOptions>;
+    moveBlock?: false;
+    placeholder?: false | Partial<PlaceholderOptions>;
+    dropCursor?: false | Partial<DropCursorOptions>;
+    gapCursor?: false;
+}
+/**
+ * The default extension set (docs/ARCHITECTURE.md §6.3). M1 extensions are added here as they
+ * are implemented.
+ *
+ * ```ts
+ * new Editor({ element, extensions: [defaultExtensions({ bold: false })] });
+ * ```
+ */
+export declare function defaultExtensions(options?: DefaultExtensionsOptions): Extension[];

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

@@ -0,0 +1,17 @@
+import { type Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /**
+         * Selects the text from `from` to `to` (document positions; `to` defaults to `from`, a
+         * cursor). A position outside text moves to the nearest text position. Returns `false` when
+         * a position is outside the document.
+         */
+        select: (from: number, to?: number) => Command;
+        /** Selects the node that starts at `pos`. Returns `false` when there is no selectable node. */
+        selectNode: (pos: number) => Command;
+        /** Selects the whole document. */
+        selectAll: () => Command;
+    }
+}
+/** The top-level `doc` node: one or more blocks. Provides the selection commands. */
+export declare const Document: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

package/dist/extensions/drop-cursor/index.d.ts

@@ -0,0 +1,15 @@
+/** Options of {@link DropCursor}. */
+export interface DropCursorOptions {
+    /** CSS color of the cursor. `false` = no inline color; style with `class`. Default: `'currentColor'`. */
+    color: string | false;
+    /** Width in pixels. Default: `1`. */
+    width: number;
+    /** Extra CSS class of the cursor element. No default. */
+    class?: string;
+}
+/**
+ * Shows a line where a dragged item would be dropped, docs/SPEC.md F-012.
+ *
+ * Wraps `prosemirror-dropcursor`; everything is handled by the package.
+ */
+export declare const DropCursor: (options?: Partial<DropCursorOptions> | undefined) => import("../..").Extension<DropCursorOptions>;

package/dist/extensions/gap-cursor/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a gap cursor where no text cursor can go, docs/SPEC.md F-012.
+ *
+ * Wraps `prosemirror-gapcursor`; everything is handled by the package.
+ */
+export declare const GapCursor: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

package/dist/extensions/hard-break/index.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Inserts a hard break (`<br>`) at the cursor. */
+        setHardBreak: () => Command;
+    }
+}
+/**
+ * The `hardBreak` node (`<br>`), docs/SPEC.md F-305.
+ */
+export declare const HardBreak: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

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

@@ -0,0 +1,24 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Turns the selected textblocks into a heading of the given level. */
+        setHeading: (attrs: {
+            level: HeadingLevel;
+        }) => Command;
+        /** Toggles the heading level: removes it when the whole selection matches, otherwise sets it. */
+        toggleHeading: (attrs: {
+            level: HeadingLevel;
+        }) => Command;
+    }
+}
+/** A heading level. */
+export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+/** Options of {@link Heading}. */
+export interface HeadingOptions {
+    /** Allowed levels. Default: all six. */
+    levels: HeadingLevel[];
+}
+/**
+ * The `heading` node (`<h1>`…`<h6>`), docs/SPEC.md F-302.
+ */
+export declare const Heading: (options?: Partial<HeadingOptions> | undefined) => import("../..").Extension<HeadingOptions>;

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

@@ -0,0 +1,24 @@
+import type { Command } from 'prosemirror-state';
+/** Attributes of the `highlight` mark. */
+export interface HighlightAttributes {
+    /** Background color; omitted or `null` for a plain `<mark>` (the browser's yellow). */
+    color?: string | null;
+}
+declare module '../../core/types' {
+    interface Commands {
+        /** Highlights the selection. Returns `false` when `color` is not a valid CSS color. */
+        setHighlight: (attributes?: HighlightAttributes) => Command;
+        /** Removes the highlight from the selection. */
+        unsetHighlight: () => Command;
+        /**
+         * Removes the highlight if the whole selection is highlighted (with `attributes.color` when
+         * `attributes` is given), otherwise sets it.
+         */
+        toggleHighlight: (attributes?: HighlightAttributes) => Command;
+    }
+}
+/**
+ * The `highlight` mark (`<mark>`, or `<mark style="background-color: x">` with a color),
+ * docs/SPEC.md F-209. Also parsed from a `background-color` style.
+ */
+export declare const Highlight: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

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

@@ -0,0 +1,21 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Undoes the last change. */
+        undo: () => Command;
+        /** Redoes the last undone change. */
+        redo: () => Command;
+    }
+}
+/** Options of {@link History}. */
+export interface HistoryOptions {
+    /** Maximum number of undo steps kept (approximately). Default: 100. */
+    depth: number;
+    /** Changes closer in time than this (ms) and adjacent are grouped in one step. Default: 500. */
+    newGroupDelay: number;
+}
+/**
+ * Undo/redo with `prosemirror-history`, docs/SPEC.md F-101, F-102. Swappable: another extension
+ * (e.g. collaboration) may provide `undo`/`redo` instead.
+ */
+export declare const History: (options?: Partial<HistoryOptions> | undefined) => import("../..").Extension<HistoryOptions>;

package/dist/extensions/horizontal-rule/index.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Inserts a horizontal rule at the cursor. */
+        setHorizontalRule: () => Command;
+    }
+}
+/**
+ * The `horizontalRule` node (`<hr>`), docs/SPEC.md F-304.
+ */
+export declare const HorizontalRule: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

package/dist/extensions/index.d.ts

@@ -0,0 +1,27 @@
+export { Blockquote } from './blockquote';
+export { Bold } from './bold';
+export { BulletList } from './bullet-list';
+export { ClearFormatting } from './clear-formatting';
+export { Code } from './code';
+export { type DefaultExtensionsOptions, defaultExtensions } from './default-extensions';
+export { Document } from './document';
+export { DropCursor, type DropCursorOptions } from './drop-cursor';
+export { GapCursor } from './gap-cursor';
+export { HardBreak } from './hard-break';
+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 { Italic } from './italic';
+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 { Strike } from './strike';
+export { Subscript } from './subscript';
+export { Superscript } from './superscript';
+export { Text } from './text';
+export { TextStyle } from './text-style';
+export { Underline } from './underline';

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

@@ -0,0 +1,16 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Adds italic to the selection. */
+        setItalic: () => Command;
+        /** Removes italic from the selection. */
+        unsetItalic: () => Command;
+        /** Removes italic if the whole selection is italic, otherwise adds it. */
+        toggleItalic: () => Command;
+    }
+}
+/**
+ * The `italic` mark (`<em>`), docs/SPEC.md F-202. Also parsed from `<i>` and an italic
+ * `font-style`.
+ */
+export declare const Italic: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

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

@@ -0,0 +1,23 @@
+import type { Command } from 'prosemirror-state';
+/** Attributes of the `link` mark. */
+export interface LinkAttributes {
+    href: string;
+    /** `'_blank'` opens the link in a new tab; omitted or `null` for none. */
+    target?: '_blank' | null;
+}
+declare module '../../core/types' {
+    interface Commands {
+        /**
+         * Links the selection, or updates the whole link at the cursor. Returns `false` when `href`
+         * is empty or not allowed, or with a cursor outside a link.
+         */
+        setLink: (attributes: LinkAttributes) => Command;
+        /** Removes links from the selection, or the whole link at the cursor. */
+        unsetLink: () => Command;
+    }
+}
+/**
+ * The `link` mark (`<a href target rel>`), docs/SPEC.md F-206. `rel="noopener noreferrer
+ * nofollow"` is written when `target="_blank"`. No shortcut: `Mod-k` belongs to the link popover.
+ */
+export declare const Link: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

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

@@ -0,0 +1,16 @@
+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. */
+        splitListItem: () => Command;
+        /** Nests the selected list items one level deeper. */
+        sinkListItem: () => Command;
+        /** Lifts the selected list items one level up (out of the list at the top level). */
+        liftListItem: () => Command;
+    }
+}
+/**
+ * The `listItem` node (`<li>`), docs/SPEC.md F-403, F-404. Required by `BulletList` and
+ * `OrderedList`.
+ */
+export declare const ListItem: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

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

@@ -0,0 +1,17 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Moves the block (or list item) at the selection one place up among its siblings. */
+        moveBlockUp: () => Command;
+        /** Moves the block (or list item) at the selection one place down among its siblings. */
+        moveBlockDown: () => Command;
+    }
+}
+/**
+ * Move block up / down among siblings (F-309).
+ *
+ * The movable unit is the innermost ancestor that is a list or container:
+ * the children of that ancestor covered by the selection.
+ * Uses the "move the neighbor" approach to keep the selection intact.
+ */
+export declare const MoveBlock: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

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

@@ -0,0 +1,12 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Wraps the selection in an ordered list, lifts it out, or converts another list type. */
+        toggleOrderedList: () => Command;
+    }
+}
+/**
+ * The `orderedList` node (`<ol start="n">`, `start` omitted when 1), docs/SPEC.md F-402, F-405.
+ * Requires `ListItem`.
+ */
+export declare const OrderedList: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

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

@@ -0,0 +1,14 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Turns the selected textblocks into paragraphs. */
+        setParagraph: () => Command;
+    }
+}
+/**
+ * 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).
+ */
+export declare const Paragraph: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

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

@@ -0,0 +1,13 @@
+/** Options of {@link Placeholder}. */
+export interface PlaceholderOptions {
+    /** The hint text shown when the document is empty. Default: `''` (no placeholder). */
+    placeholder: string;
+}
+/**
+ * Shows a hint text when the document is empty, docs/SPEC.md F-011.
+ *
+ * The empty paragraph gets a node decoration with `class="stilo-placeholder"` and
+ * `data-placeholder="<the text>"`. "Empty" follows `Editor.isEmpty`: one child,
+ * a `paragraph`, with content size 0.
+ */
+export declare const Placeholder: (options?: Partial<PlaceholderOptions> | undefined) => import("../..").Extension<PlaceholderOptions>;

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

@@ -0,0 +1,16 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Adds strike-through to the selection. */
+        setStrike: () => Command;
+        /** Removes strike-through from the selection. */
+        unsetStrike: () => Command;
+        /** Removes strike-through if the whole selection is struck through, otherwise adds it. */
+        toggleStrike: () => Command;
+    }
+}
+/**
+ * The `strike` mark (`<s>`), docs/SPEC.md F-204. Also parsed from `<del>`, `<strike>` and a
+ * `text-decoration: line-through`.
+ */
+export declare const Strike: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;

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

@@ -0,0 +1,16 @@
+import type { Command } from 'prosemirror-state';
+declare module '../../core/types' {
+    interface Commands {
+        /** Makes the selection subscript (replacing superscript). */
+        setSubscript: () => Command;
+        /** Removes subscript from the selection. */
+        unsetSubscript: () => Command;
+        /** Removes subscript if the whole selection is subscript, otherwise adds it. */
+        toggleSubscript: () => Command;
+    }
+}
+/**
+ * The `subscript` mark (`<sub>`), docs/SPEC.md F-207. Also parsed from `vertical-align: sub`.
+ * Subscript and superscript exclude each other through the mark group `script`.
+ */
+export declare const Subscript: (options?: Partial<Record<string, never>> | undefined) => import("../..").Extension<Record<string, never>>;