stilo-editor 0.0.0-stage → 0.1.0

package/dist/content.css

@@ -0,0 +1,161 @@
+/* Stilo content styles: ProseMirror base CSS and defaults for the editable content. */
+
+/*
+ * prosemirror-view/style/prosemirror.css and prosemirror-gapcursor/style/gapcursor.css.
+ * Copyright (C) 2015-2017 by Marijn Haverbeke and others, MIT license. Adapted to the lint
+ * rules: no `white-space: pre-wrap` fallback before `break-spaces`, and the separator image
+ * rule gains specificity instead of `!important`.
+ */
+.ProseMirror {
+  position: relative;
+}
+
+.ProseMirror {
+  word-wrap: break-word;
+  white-space: break-spaces;
+  -webkit-font-variant-ligatures: none;
+  font-variant-ligatures: none;
+  font-feature-settings: "liga" 0; /* the above doesn't seem to work in Edge */
+}
+
+.ProseMirror pre {
+  white-space: pre-wrap;
+}
+
+.ProseMirror li {
+  position: relative;
+}
+
+.ProseMirror-hideselection *::selection {
+  background: transparent;
+}
+.ProseMirror-hideselection *::-moz-selection {
+  background: transparent;
+}
+.ProseMirror-hideselection {
+  caret-color: transparent;
+}
+
+/* See https://code.haverbeke.berlin/prosemirror/prosemirror/issues/1421#issuecomment-1759320191 */
+.ProseMirror [draggable][contenteditable="false"] {
+  user-select: text;
+}
+
+.ProseMirror-selectednode {
+  outline: 2px solid #8cf;
+}
+
+/* Make sure li selections wrap around markers */
+
+li.ProseMirror-selectednode {
+  outline: none;
+}
+
+li.ProseMirror-selectednode:after {
+  content: "";
+  position: absolute;
+  left: -32px;
+  right: -2px;
+  top: -2px;
+  bottom: -2px;
+  border: 2px solid #8cf;
+  pointer-events: none;
+}
+
+/* Protect against generic img rules */
+
+.ProseMirror img.ProseMirror-separator {
+  display: inline;
+  border: none;
+  margin: 0;
+}
+
+.ProseMirror-gapcursor {
+  display: none;
+  pointer-events: none;
+  position: absolute;
+}
+
+.ProseMirror-gapcursor:after {
+  content: "";
+  display: block;
+  position: absolute;
+  top: -2px;
+  width: 20px;
+  border-top: 1px solid black;
+  animation: ProseMirror-cursor-blink 1.1s steps(2, start) infinite;
+}
+
+@keyframes ProseMirror-cursor-blink {
+  to {
+    visibility: hidden;
+  }
+}
+
+.ProseMirror-focused .ProseMirror-gapcursor {
+  display: block;
+}
+
+/* Stilo content defaults */
+
+/* Lists: list items hold paragraphs, which must not add their own margins. */
+.stilo-content ul,
+.stilo-content ol {
+  margin: 0.5em 0;
+  padding-left: 1.75em;
+}
+
+.stilo-content li > p,
+.stilo-content li > ul,
+.stilo-content li > ol {
+  margin: 0;
+}
+
+.stilo-content blockquote {
+  margin: 0.5em 0;
+  padding-left: 1em;
+  border-left: 3px solid var(--stilo-color-border, #d1d9e0);
+  color: var(--stilo-color-muted, #59636e);
+}
+
+.stilo-content hr {
+  margin: 1em 0;
+  border: none;
+  border-top: 1px solid var(--stilo-color-border, #d1d9e0);
+}
+
+.stilo-content code {
+  padding: 0.1em 0.3em;
+  border-radius: 0.25em;
+  background: var(--stilo-color-hover, #eef1f4);
+  font-family: ui-monospace, monospace;
+  font-size: 0.9em;
+}
+
+/* Placeholder: shown only while the content is editable. */
+.stilo-content[contenteditable="true"] .stilo-placeholder::before {
+  content: attr(data-placeholder);
+  float: left;
+  height: 0;
+  color: var(--stilo-color-muted, #59636e);
+  pointer-events: none;
+}
+
+/*
+ * Large documents (ADR 0003): the browser skips style, layout and paint of the top-level blocks
+ * outside the viewport. Real typing in 10k paragraphs went from 144 ms to 24 ms per key (median,
+ * Chromium). A skipped block is 3em tall until it has been rendered once.
+ */
+.stilo-content > * {
+  content-visibility: auto;
+  contain-intrinsic-size: auto 3em;
+}
+
+/* Containment stops margins from collapsing through a block: trim them inside a blockquote. */
+.stilo-content blockquote > :first-child {
+  margin-top: 0;
+}
+
+.stilo-content blockquote > :last-child {
+  margin-bottom: 0;
+}

package/dist/core/drop.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'prosemirror-state';
+/**
+ * Makes a drag-and-drop move of whole textblocks behave as a move of blocks (ARCHITECTURE §8.2):
+ * dropped inside text they stay blocks, and the blocks they came from do not stay behind empty.
+ */
+export declare function createDropMovePlugin(): Plugin;

package/dist/core/editor.d.ts

@@ -0,0 +1,108 @@
+import type { Schema } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { type EventHandler } from './events';
+import type { CommandRunners, EditorEvents, EditorOptions, JSONContent, SetContentOptions } from './types';
+/**
+ * The Stilo editor. See docs/ARCHITECTURE.md §5.
+ *
+ * ```ts
+ * const editor = new Editor({
+ *   element: document.querySelector('#editor')!,
+ *   extensions: [defaultExtensions()],
+ *   content: '<p>Hello <strong>world</strong></p>',
+ * });
+ * ```
+ */
+export declare class Editor {
+    /** The ProseMirror view (escape hatch). */
+    readonly view: EditorView;
+    /** The schema built from the extensions. */
+    readonly schema: Schema;
+    /**
+     * Runs a command: `editor.commands.toggleBold()` returns whether it applied;
+     * `editor.commands.toggleBold.can()` tells whether it would apply, without applying it.
+     */
+    readonly commands: CommandRunners;
+    private readonly manager;
+    private readonly plugins;
+    private readonly emitter;
+    private readonly compactParagraphs;
+    private destroyed;
+    /**
+     * Creates the editor:
+     *
+     * 1. `ExtensionManager` from `options.extensions` → `schema`;
+     * 2. `createPlugins(this)`, then the core `createDropMovePlugin()`; command runners are built
+     *    from the manager's commands;
+     * 3. initial document from `parseHTML(schema, options.content ?? '')`;
+     * 4. `EditorView` mounted inside `options.element`, with attributes `class="stilo-content"`,
+     *    `role="textbox"`, `aria-multiline="true"`, `aria-label` (if given); `editable` from
+     *    options (default `true`); `transformPastedHTML` → `sanitizeToString`;
+     *    `clipboardSerializer` → `createClipboardSerializer`; transactions go
+     *    through the editor's dispatch (see events in `EditorEvents`);
+     * 5. `autofocus`: `true`/`'start'` → focus at start, `'end'` → focus at end.
+     */
+    constructor(options: EditorOptions);
+    /** Current editor state. */
+    get state(): EditorState;
+    /** `true` when the document is a single empty paragraph. */
+    get isEmpty(): boolean;
+    /** Whether the content is editable. */
+    get isEditable(): boolean;
+    /** Whether {@link destroy} has been called. */
+    get isDestroyed(): boolean;
+    /**
+     * Canonical HTML of the document (`serializeHTML`, honoring `compactParagraphs`). Empty
+     * document → `<p></p>`.
+     */
+    getHTML(): string;
+    /**
+     * Replaces the content with `html` (sanitized and parsed with `parseHTML`).
+     *
+     * - `resetHistory: false` (default): one transaction replacing the whole content
+     *   (`tr.replaceWith(0, doc.content.size, newDoc.content)`), selection at document start;
+     *   undoable as its own step (`closeHistory`: never grouped with the changes before it).
+     * - `resetHistory: true`: a new `EditorState` with the same plugins; `input` is emitted with
+     *   `transaction: null`.
+     * - `emitInput: false` suppresses the `input` event.
+     */
+    setHTML(html: string, options?: SetContentOptions): void;
+    /** The document as ProseMirror JSON (`doc.toJSON()`). */
+    getJSON(): JSONContent;
+    /** Same as {@link setHTML}, from ProseMirror JSON (`Node.fromJSON`). */
+    setJSON(json: JSONContent, options?: SetContentOptions): void;
+    /**
+     * Plain text: `doc.textBetween(0, doc.content.size, '\n\n')`. Leaf nodes provide their own
+     * text through `leafText` in their node spec (hard break → `\n`).
+     */
+    getText(): string;
+    /**
+     * Whether a mark or node named `name` is active (`isMarkActive` / `isNodeActive`).
+     * Unknown names return `false`.
+     */
+    isActive(name: string, attrs?: Record<string, unknown>): boolean;
+    /**
+     * Attributes of the mark or node named `name` at the selection (`getMarkAttributes` /
+     * `getNodeAttributes`), e.g. the `href` of the link at the cursor. `{}` when there is none or
+     * the name is unknown.
+     */
+    getAttributes(name: string): Record<string, unknown>;
+    /** Switches read-only mode on/off. */
+    setEditable(editable: boolean): void;
+    /** Focuses the editor; optionally moves the cursor to the start or end of the document. */
+    focus(position?: 'start' | 'end'): void;
+    /** Removes focus from the editor. */
+    blur(): void;
+    /** Registers an event handler. */
+    on<E extends keyof EditorEvents>(event: E, handler: EventHandler<EditorEvents[E]>): void;
+    /** Removes an event handler. */
+    off<E extends keyof EditorEvents>(event: E, handler: EventHandler<EditorEvents[E]>): void;
+    /** Emits `destroy`, destroys the view, removes all handlers. Calling it twice is a no-op. */
+    destroy(): void;
+    private createState;
+    /** Builds `commands` from the extension commands; `can` runs without `dispatch`. */
+    private createRunners;
+    private setContent;
+    private dispatch;
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,6 @@
+/** Error thrown by Stilo for invalid configuration or API misuse. */
+export declare class StiloError extends Error {
+    constructor(message: string);
+}
+/** Placeholder for functions whose implementation is assigned to a task. */
+export declare function notImplemented(name: string): never;

package/dist/core/events.d.ts

@@ -0,0 +1,19 @@
+/** A handler for an event payload. */
+export type EventHandler<T> = (payload: T) => void;
+/**
+ * Minimal typed event emitter.
+ *
+ * - `on` registers a handler; registering the same handler twice for the same event has no
+ *   additional effect.
+ * - `off` removes a handler; removing an unknown handler is a no-op.
+ * - `emit` calls the handlers of the event in registration order. Handlers added or removed
+ *   during an `emit` do not affect the current emit.
+ * - `clear` removes all handlers of all events.
+ */
+export declare class EventEmitter<Events extends object> {
+    private handlers;
+    on<E extends keyof Events>(event: E, handler: EventHandler<Events[E]>): void;
+    off<E extends keyof Events>(event: E, handler: EventHandler<Events[E]>): void;
+    emit<E extends keyof Events>(event: E, payload: Events[E]): void;
+    clear(): void;
+}

package/dist/core/extension-manager.d.ts

@@ -0,0 +1,57 @@
+import { Schema } from 'prosemirror-model';
+import type { Plugin } from 'prosemirror-state';
+import type { Editor } from './editor';
+import type { Extension } from './extension';
+import type { CommandFactory } from './types';
+/**
+ * Schema order of the built-in marks, outermost first. It defines how marks nest in the HTML
+ * output (docs/ARCHITECTURE.md §6.2). Marks not listed here come after these, in extension
+ * order.
+ */
+export declare const MARK_ORDER: readonly string[];
+/** Nodes every schema must contain. */
+export declare const REQUIRED_NODES: readonly string[];
+/**
+ * Flattens nested arrays one level and sorts extensions by `priority` (descending), keeping the
+ * order of appearance for equal priorities (stable sort).
+ */
+export declare function sortExtensions(extensions: Array<Extension | Extension[]>): Extension[];
+/**
+ * Builds the schema, plugins and commands from a list of extensions.
+ * See docs/ARCHITECTURE.md §6.2 for the rules.
+ */
+export declare class ExtensionManager {
+    /** The extensions, flattened and sorted with {@link sortExtensions}. */
+    readonly extensions: readonly Extension[];
+    readonly schema: Schema;
+    private readonly commandFactories;
+    /**
+     * Sorts the extensions and creates the schema:
+     *
+     * - duplicate extension names → `StiloError`;
+     * - nodes from `spec.nodes(options)` in extension order; duplicate node name → `StiloError`;
+     * - marks from `spec.marks(options)`, ordered by {@link MARK_ORDER} then extension order;
+     *   duplicate mark name → `StiloError`;
+     * - any of {@link REQUIRED_NODES} missing → `StiloError`;
+     * - `topNode` is `doc`.
+     */
+    constructor(extensions: Array<Extension | Extension[]>);
+    /**
+     * Command factories of all extensions, by command name. Empty until {@link createPlugins}
+     * has been called.
+     */
+    get commands(): ReadonlyMap<string, CommandFactory>;
+    /**
+     * Called once by the editor. For each extension in order, with context
+     * `{ options, schema, editor }`: collects `commands` (duplicate name → `StiloError`),
+     * `inputRules`, `keymap`, `plugins`. Returns, in this order:
+     *
+     * 1. one `inputRules({ rules })` plugin with all input rules;
+     * 2. `keymap({ Backspace: undoInputRule })`: it applies only right after an input rule, so it
+     *    takes precedence over the extensions (Backspace after `- ` gives back `- `);
+     * 3. one `keymap()` plugin per extension that defines a keymap, in extension order;
+     * 4. all extension plugins, in extension order;
+     * 5. `keymap(baseKeymap)` from prosemirror-commands.
+     */
+    createPlugins(editor: Editor): Plugin[];
+}

package/dist/core/extension.d.ts

@@ -0,0 +1,43 @@
+import type { InputRule } from 'prosemirror-inputrules';
+import type { MarkSpec, NodeSpec, Schema } from 'prosemirror-model';
+import type { Command, Plugin } from 'prosemirror-state';
+import type { Editor } from './editor';
+import type { CommandFactories } from './types';
+/** Context passed to the runtime parts of an extension. */
+export interface ExtensionContext<Options> {
+    options: Readonly<Options>;
+    schema: Schema;
+    editor: Editor;
+}
+/** Definition of an extension. See docs/ARCHITECTURE.md §6. */
+export interface ExtensionSpec<Options extends object = Record<string, never>> {
+    /** Unique camelCase name, equal to the main node/mark of the extension. */
+    name: string;
+    /** Default 100. Higher = earlier in schema order and higher keymap precedence. */
+    priority?: number;
+    defaultOptions?: Options;
+    nodes?(options: Readonly<Options>): Record<string, NodeSpec>;
+    marks?(options: Readonly<Options>): Record<string, MarkSpec>;
+    commands?(ctx: ExtensionContext<Options>): Partial<CommandFactories>;
+    keymap?(ctx: ExtensionContext<Options>): Record<string, Command>;
+    inputRules?(ctx: ExtensionContext<Options>): InputRule[];
+    plugins?(ctx: ExtensionContext<Options>): Plugin[];
+}
+/** A configured extension instance, created by the factory returned by {@link defineExtension}. */
+export interface Extension<Options extends object = object> {
+    readonly name: string;
+    readonly priority: number;
+    readonly options: Readonly<Options>;
+    readonly spec: ExtensionSpec<Options>;
+}
+/** Default extension priority. */
+export declare const DEFAULT_PRIORITY = 100;
+/**
+ * Defines an extension. Returns a factory that creates configured instances:
+ *
+ * ```ts
+ * export const Heading = defineExtension<{ levels: number[] }>({ name: 'heading', ... });
+ * const heading = Heading({ levels: [1, 2, 3] });
+ * ```
+ */
+export declare function defineExtension<Options extends object = Record<string, never>>(spec: ExtensionSpec<Options>): (options?: Partial<Options>) => Extension<Options>;

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

@@ -0,0 +1,33 @@
+import type { Attrs, MarkType, NodeType } from 'prosemirror-model';
+import { type EditorState } from 'prosemirror-state';
+/**
+ * Whether `actual` contains every key of `expected` with a strictly equal (`===`) value.
+ * `undefined` `expected` always matches.
+ */
+export declare function attrsMatch(actual: Attrs, expected?: Record<string, unknown>): boolean;
+/**
+ * Whether a mark of `type` (with matching `attrs`, see {@link attrsMatch}) is active:
+ *
+ * - empty selection: present in `state.storedMarks`, or if those are `null`, in
+ *   `selection.$from.marks()`;
+ * - non-empty selection: every text node between `from` and `to` has the mark, and there is at
+ *   least one text node. Traverse only the selected range (`doc.nodesBetween(from, to)`).
+ */
+export declare function isMarkActive(state: EditorState, type: MarkType, attrs?: Record<string, unknown>): boolean;
+/**
+ * Whether a node of `type` (with matching `attrs`) is active: the selection is a
+ * `NodeSelection` of such a node, or `selection.$from` has such an ancestor (any depth,
+ * including the document itself).
+ */
+export declare function isNodeActive(state: EditorState, type: NodeType, attrs?: Record<string, unknown>): boolean;
+/**
+ * Attributes of the mark of `type` at the selection, `{}` when there is none: for an empty
+ * selection the mark in `state.storedMarks` (or `$from.marks()`), otherwise the first one found
+ * in the selected range.
+ */
+export declare function getMarkAttributes(state: EditorState, type: MarkType): Attrs;
+/**
+ * Attributes of the node of `type` at the selection, `{}` when there is none: the selected node
+ * (`NodeSelection`), or the deepest ancestor of `selection.$from`.
+ */
+export declare function getNodeAttributes(state: EditorState, type: NodeType): Attrs;

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

@@ -0,0 +1,21 @@
+import { InputRule } from 'prosemirror-inputrules';
+import type { Attrs, MarkType } 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;

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

@@ -0,0 +1,12 @@
+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`, items unchanged;
+ * - no list: the selected blocks are wrapped in a new list (`wrapInList`).
+ */
+export declare function toggleList(listType: NodeType, itemType: NodeType, attrs?: Attrs | null): Command;

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

@@ -0,0 +1,38 @@
+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: {@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,14 @@
+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;

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

@@ -0,0 +1,91 @@
+/**
+ * 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'];
+/** 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>;
+/**
+ * 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 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;