stilo-editor 0.0.0-stage → 0.2.0

package/dist/content.css

@@ -0,0 +1,398 @@
+/* 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;
+}
+
+/*
+ * prosemirror-tables/style/tables.css. Copyright (C) 2015-2016 by Marijn Haverbeke and others,
+ * MIT license. Adapted: one `cursor` value, the colors from the Stilo custom properties.
+ */
+.ProseMirror .tableWrapper {
+  overflow-x: auto;
+}
+
+.ProseMirror table {
+  border-collapse: collapse;
+  table-layout: fixed;
+  width: 100%;
+  overflow: hidden;
+}
+
+.ProseMirror td,
+.ProseMirror th {
+  vertical-align: top;
+  box-sizing: border-box;
+  position: relative;
+}
+
+.ProseMirror td:not([data-colwidth]):not(.column-resize-dragging),
+.ProseMirror th:not([data-colwidth]):not(.column-resize-dragging) {
+  min-width: var(--default-cell-min-width);
+}
+
+.ProseMirror .column-resize-handle {
+  position: absolute;
+  right: -2px;
+  top: 0;
+  bottom: 0;
+  width: 4px;
+  z-index: 20;
+  background-color: var(--stilo-color-focus, #0969da);
+  pointer-events: none;
+}
+
+.ProseMirror.resize-cursor {
+  cursor: col-resize;
+}
+
+.ProseMirror .selectedCell:after {
+  z-index: 2;
+  position: absolute;
+  content: "";
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  background: var(--stilo-color-selected-cell, rgb(9 105 218 / 0.12));
+  pointer-events: none;
+}
+
+/* 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,
+.stilo-content .stilo-task-item__content > p,
+.stilo-content .stilo-task-item__content > ul,
+.stilo-content .stilo-task-item__content > ol {
+  margin: 0;
+}
+
+/* Task lists: a checkbox in place of the bullet, done items struck through. In the editor the
+   item is a flex row: its <input> checkbox, then the content (ProseMirror needs a container that
+   holds only the content). Content shown elsewhere under the class stilo-content gets a box drawn
+   from data-checked instead. Either way the box is centered on the first line, not on the whole
+   item, which may hold more paragraphs and sub-lists. */
+.stilo-content ul[data-type="taskList"] {
+  list-style: none;
+}
+
+.stilo-content.ProseMirror ul[data-type="taskList"] {
+  padding-left: 0.25em;
+}
+
+.stilo-content.ProseMirror ul[data-type="taskList"] > li {
+  display: flex;
+  gap: 0.5em;
+}
+
+.stilo-task-item__content {
+  flex: 1;
+  min-width: 0;
+}
+
+/* Form controls have their own font: inherit it, so that em and lh are those of the text. */
+.stilo-task-item__checkbox {
+  flex: none;
+  width: 1em;
+  height: 1em;
+  margin: calc(0.5lh - 0.5em) 0 0;
+  font-size: inherit;
+  line-height: inherit;
+  accent-color: var(--stilo-color-focus, #0969da);
+  cursor: pointer;
+}
+
+.stilo-content:not(.ProseMirror) ul[data-type="taskList"] > li {
+  position: relative;
+}
+
+.stilo-content:not(.ProseMirror) ul[data-type="taskList"] > li::before {
+  content: "";
+  display: flex;
+  position: absolute;
+  top: calc(0.5lh - 0.5em);
+  left: -1.5em;
+  box-sizing: border-box;
+  width: 1em;
+  height: 1em;
+  align-items: center;
+  justify-content: center;
+  border: 1px solid var(--stilo-color-muted, #59636e);
+  border-radius: 0.2em;
+  color: #ffffff;
+}
+
+.stilo-content:not(.ProseMirror) ul[data-type="taskList"] > li[data-checked="true"]::before {
+  content: "\2713";
+  border-color: var(--stilo-color-focus, #0969da);
+  background: var(--stilo-color-focus, #0969da);
+}
+
+.stilo-content [data-checked="true"] > .stilo-task-item__content > p:first-child,
+.stilo-content:not(.ProseMirror) [data-checked="true"] > p:first-child,
+.stilo-content:not(.ProseMirror) [data-checked="true"]:not(:has(> p)) {
+  color: var(--stilo-color-muted, #59636e);
+  text-decoration: line-through;
+}
+
+.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;
+}
+
+/* Code block: the <code> inside it drops the inline code box. */
+.stilo-content pre {
+  margin: 0.5em 0;
+  padding: 0.75em 1em;
+  border-radius: 0.375em;
+  background: var(--stilo-color-hover, #eef1f4);
+  font-family: ui-monospace, monospace;
+  font-size: 0.9em;
+  line-height: 1.5;
+}
+
+.stilo-content pre code {
+  padding: 0;
+  border-radius: 0;
+  background: none;
+  font-size: inherit;
+}
+
+/* Tables: a cell holds blocks, whose outer margins would pad the cell twice. */
+.stilo-content .tableWrapper {
+  margin: 1em 0;
+}
+
+.stilo-content td,
+.stilo-content th {
+  padding: 6px 8px;
+  border: 1px solid var(--stilo-color-border, #d1d9e0);
+}
+
+.stilo-content th {
+  background: var(--stilo-color-table-header, #f6f8fa);
+  font-weight: 600;
+  text-align: start;
+}
+
+.stilo-content td > :first-child,
+.stilo-content th > :first-child {
+  margin-top: 0;
+}
+
+/* The resize handle shown on hover is the last child of its cell: the block before it is the last
+   block, otherwise its margin would come back and the table grow under the mouse. */
+.stilo-content td > :last-child,
+.stilo-content th > :last-child,
+.stilo-content td > :has(+ .column-resize-handle:last-child),
+.stilo-content th > :has(+ .column-resize-handle:last-child) {
+  margin-bottom: 0;
+}
+
+/* Images: never wider than the content; with width and height they keep their ratio. */
+.stilo-content img {
+  max-width: 100%;
+  height: auto;
+}
+
+/* Image in the editor: two side handles, inside the image (a top-level block clips what
+   overflows it, see "Large documents" below), shown while the image is selected. Only a selected
+   image is positioned: a positioned element paints over the caret placed right after it. */
+.stilo-image {
+  display: inline-block;
+  max-width: 100%;
+}
+
+.stilo-image.ProseMirror-selectednode {
+  position: relative;
+}
+
+.stilo-image img {
+  display: block;
+}
+
+.stilo-image__handle {
+  display: none;
+  position: absolute;
+  top: 50%;
+  width: 6px;
+  height: min(48px, 50%);
+  min-height: 16px;
+  transform: translateY(-50%);
+  border: 1px solid #ffffff;
+  border-radius: 3px;
+  background: var(--stilo-color-text, #1f2328);
+  opacity: 0.7;
+  cursor: ew-resize;
+  touch-action: none;
+}
+
+.stilo-image__handle--left {
+  left: 6px;
+}
+
+.stilo-image__handle--right {
+  right: 6px;
+}
+
+.stilo-content[contenteditable="true"] .stilo-image.ProseMirror-selectednode .stilo-image__handle {
+  display: block;
+}
+
+.stilo-image__handle:hover {
+  opacity: 1;
+}
+
+/* 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;
+}
+
+/* Find and replace (T-043): the matches and the selected one */
+.stilo-search-match {
+  background: var(--stilo-color-search-match, #fff1a8);
+}
+
+.stilo-search-match--current {
+  background: var(--stilo-color-search-current, #ffb347);
+}

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,120 @@
+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';
+/**
+ * Transaction meta key of the empty transaction applied to every new `EditorState`: plugins can
+ * normalize the loaded document in `appendTransaction` (e.g. the `Table` extension fixes
+ * irregular tables), before the view shows it and without an undo step.
+ */
+export declare const LOAD_META = "stiloLoad";
+/**
+ * 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, emit)`, 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` → `cleanPastedHTML`, then
+     *    `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;
+    /**
+     * Removes the DOM selection when it lies inside the editor. Replacing many nodes while the
+     * browser tracks a selection in them is much slower (Chromium, 50,000 paragraphs: 42 s →
+     * 1.6 s); ProseMirror puts the selection back after the update when the editor has focus.
+     */
+    private clearDOMSelection;
+    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, ExtensionContext } 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, emit }`: 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, emit: ExtensionContext<object>['emit']): Plugin[];
+}

package/dist/core/extension.d.ts

@@ -0,0 +1,48 @@
+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, EditorEvents } from './types';
+/** Context passed to the runtime parts of an extension. */
+export interface ExtensionContext<Options> {
+    options: Readonly<Options>;
+    schema: Schema;
+    editor: Editor;
+    /**
+     * Emits an editor event. An extension adds its own events to `EditorEvents` by module
+     * augmentation, as it does for `Commands`.
+     */
+    emit<E extends keyof EditorEvents>(event: E, payload: EditorEvents[E]): void;
+}
+/** 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;