@vizejs/ui 0.426.3 → 0.427.0

package/dist/rich-text-ePQBkrmN.d.mts

@@ -0,0 +1,767 @@
+import { v as Placement } from "./positioner-BYJVA3Uy.mjs";
+
+//#region src/families/editor/rich-text/rich-text-schema.d.ts
+/** Attribute values a node or mark may carry; serializable by design. */
+type RichTextAttrValue = boolean | number | string | null;
+/** Attribute record of a node or mark. */
+type RichTextAttrs = {
+  readonly [name: string]: RichTextAttrValue;
+};
+/**
+ * Structural role of a node type; commands work on roles, so custom node
+ * types participate in every command without special cases.
+ *
+ * - `textblock`: holds inline content (paragraph, heading, code block).
+ * - `container`: holds blocks (blockquote, callout).
+ * - `list`: holds `listItem` nodes (bullet and ordered lists).
+ * - `listItem`: holds blocks inside a list.
+ * - `inline`: an atomic inline leaf (image, hard break, mention chip).
+ */
+type RichTextNodeRole = "container" | "inline" | "list" | "listItem" | "textblock";
+/** Element produced when rendering a node or mark. */
+interface RichTextDomSpec {
+  /** Lower-case tag name. */
+  readonly tag: string;
+  /** Attributes; `null`/`undefined` values are omitted. */
+  readonly attrs?: {
+    readonly [name: string]: string | null | undefined;
+  };
+}
+/** How an HTML element maps onto a node or mark while parsing (pasting). */
+interface RichTextParseRule<Attrs extends RichTextAttrs> {
+  /** Lower-case tag name this rule matches. */
+  readonly tag: string;
+  /** Read attributes; return `null` to reject the element. @default defaults */
+  attrs?(element: Element): Partial<Attrs> | null;
+}
+/** Declaration of one node type. `Role` and `Attrs` flow into the document types. */
+interface RichTextNodeSpec<Role extends RichTextNodeRole = RichTextNodeRole, Attrs extends RichTextAttrs = RichTextAttrs> {
+  /** Structural role. */
+  readonly role: Role;
+  /** Default attributes; also the attribute type of this node. */
+  readonly defaults: Attrs;
+  /** Render one node. */
+  render(attrs: Attrs): RichTextDomSpec;
+  /** Parse rules for pasted HTML. */
+  readonly parse: readonly RichTextParseRule<Attrs>[];
+  /** Textblocks only: plain text without marks or inline leaves (code blocks). */
+  readonly code?: boolean;
+}
+/** Declaration of one mark type. */
+interface RichTextMarkSpec<Attrs extends RichTextAttrs = RichTextAttrs> {
+  /** Default attributes; also the attribute type of this mark. */
+  readonly defaults: Attrs;
+  /** Render one mark around its text. */
+  render(attrs: Attrs): RichTextDomSpec;
+  /** Parse rules for pasted HTML. */
+  readonly parse: readonly RichTextParseRule<Attrs>[];
+  /** Whether typing at the mark's end extends it. @default true */
+  readonly inclusive?: boolean;
+}
+/** Node specs by type name. */
+type RichTextNodeSpecs = {
+  readonly [name: string]: RichTextNodeSpec;
+};
+/** Mark specs by type name. */
+type RichTextMarkSpecs = {
+  readonly [name: string]: RichTextMarkSpec;
+};
+/** A validated schema. */
+interface RichTextSchema<Nodes extends RichTextNodeSpecs = RichTextNodeSpecs, Marks extends RichTextMarkSpecs = RichTextMarkSpecs> {
+  readonly nodes: Nodes;
+  readonly marks: Marks;
+  /** Textblock type used for new and split blocks. */
+  readonly defaultBlock: string;
+}
+/** Name of every node type with `Role`. */
+type RichTextNodeName<Schema extends RichTextSchema, Role extends RichTextNodeRole = RichTextNodeRole> = { [Name in keyof Schema["nodes"] & string]: Schema["nodes"][Name]["role"] extends Role ? Name : never }[keyof Schema["nodes"] & string];
+/** Name of every mark type. */
+type RichTextMarkName<Schema extends RichTextSchema> = keyof Schema["marks"] & string;
+/** Attributes of one node type. */
+type RichTextNodeAttrs<Schema extends RichTextSchema, Name extends keyof Schema["nodes"]> = Schema["nodes"][Name]["defaults"];
+/** Attributes of one mark type. */
+type RichTextMarkAttrs<Schema extends RichTextSchema, Name extends keyof Schema["marks"]> = Schema["marks"][Name]["defaults"];
+/**
+ * Validate and freeze a schema. Node and mark names, roles, and attribute
+ * types stay literal, so documents and commands are typed from it.
+ *
+ * ```ts
+ * const schema = defineRichTextSchema({
+ *   nodes: { paragraph: paragraphSpec(), heading: headingSpec(), image: imageSpec() },
+ *   marks: { bold: boldSpec(), link: linkSpec() },
+ * });
+ * ```
+ */
+declare function defineRichTextSchema<const Nodes extends RichTextNodeSpecs, const Marks extends RichTextMarkSpecs>(definition: {
+  readonly nodes: Nodes;
+  readonly marks: Marks;
+  readonly defaultBlock?: keyof Nodes & string;
+}): RichTextSchema<Nodes, Marks>;
+/** Declare a custom node type with inferred role and attributes. */
+declare function richTextNode<const Role extends RichTextNodeRole, const Attrs extends RichTextAttrs>(spec: RichTextNodeSpec<Role, Attrs>): RichTextNodeSpec<Role, Attrs>;
+/** Declare a custom mark type with inferred attributes. */
+declare function richTextMark<const Attrs extends RichTextAttrs>(spec: RichTextMarkSpec<Attrs>): RichTextMarkSpec<Attrs>;
+/** Whether a link target uses a safe scheme (http(s), mailto, tel, or relative). */
+declare function isSafeUrl(value: string): boolean;
+/** Whether an image source uses a safe scheme (http(s), raster data URLs, or relative). */
+declare function isSafeImageUrl(value: string): boolean;
+/** Paragraph textblock. */
+declare function paragraphSpec(): RichTextNodeSpec<"textblock", {}>;
+/** Heading textblock with a `level` attribute (1–6). */
+declare function headingSpec(): RichTextNodeSpec<"textblock", {
+  readonly level: number;
+}>;
+/** Code block textblock (plain text, no marks). */
+declare function codeBlockSpec(): RichTextNodeSpec<"textblock", {
+  readonly language: string | null;
+}>;
+/** Blockquote container. */
+declare function blockquoteSpec(): RichTextNodeSpec<"container", {}>;
+/** Bullet list. */
+declare function bulletListSpec(): RichTextNodeSpec<"list", {}>;
+/** Ordered list with a `start` attribute. */
+declare function orderedListSpec(): RichTextNodeSpec<"list", {
+  readonly start: number;
+}>;
+/** List item. */
+declare function listItemSpec(): RichTextNodeSpec<"listItem", {}>;
+/** Inline image with sanitized `src`. */
+declare function imageSpec(): RichTextNodeSpec<"inline", {
+  readonly src: string;
+  readonly alt: string;
+}>;
+/** Inline hard line break. */
+declare function hardBreakSpec(): RichTextNodeSpec<"inline", {}>;
+/** Bold mark. */
+declare function boldSpec(): RichTextMarkSpec<{}>;
+/** Italic mark. */
+declare function italicSpec(): RichTextMarkSpec<{}>;
+/** Underline mark. */
+declare function underlineSpec(): RichTextMarkSpec<{}>;
+/** Strikethrough mark. */
+declare function strikeSpec(): RichTextMarkSpec<{}>;
+/** Inline code mark. */
+declare function codeSpec(): RichTextMarkSpec<{}>;
+/** Link mark with a sanitized `href`; not inclusive, so typing after a link leaves it. */
+declare function linkSpec(): RichTextMarkSpec<{
+  readonly href: string;
+}>;
+/** A schema with every built-in node and mark. */
+declare function createDefaultRichTextSchema(): RichTextSchema<{
+  readonly paragraph: RichTextNodeSpec<"textblock", {}>;
+  readonly heading: RichTextNodeSpec<"textblock", {
+    readonly level: number;
+  }>;
+  readonly blockquote: RichTextNodeSpec<"container", {}>;
+  readonly codeBlock: RichTextNodeSpec<"textblock", {
+    readonly language: string | null;
+  }>;
+  readonly bulletList: RichTextNodeSpec<"list", {}>;
+  readonly orderedList: RichTextNodeSpec<"list", {
+    readonly start: number;
+  }>;
+  readonly listItem: RichTextNodeSpec<"listItem", {}>;
+  readonly image: RichTextNodeSpec<"inline", {
+    readonly src: string;
+    readonly alt: string;
+  }>;
+  readonly hardBreak: RichTextNodeSpec<"inline", {}>;
+}, {
+  readonly bold: RichTextMarkSpec<{}>;
+  readonly italic: RichTextMarkSpec<{}>;
+  readonly underline: RichTextMarkSpec<{}>;
+  readonly strike: RichTextMarkSpec<{}>;
+  readonly code: RichTextMarkSpec<{}>;
+  readonly link: RichTextMarkSpec<{
+    readonly href: string;
+  }>;
+}>;
+/** Type of {@link createDefaultRichTextSchema}. */
+type RichTextDefaultSchema = ReturnType<typeof createDefaultRichTextSchema>;
+//#endregion
+//#region src/families/editor/rich-text/rich-text-model.d.ts
+/** One applied mark. */
+type RichTextMark<Schema extends RichTextSchema> = { [Name in keyof Schema["marks"] & string]: {
+  readonly type: Name;
+  readonly attrs: Schema["marks"][Name]["defaults"];
+} }[keyof Schema["marks"] & string];
+/** A run of text with marks. */
+interface RichTextText<Schema extends RichTextSchema> {
+  readonly type: "text";
+  readonly text: string;
+  readonly marks: readonly RichTextMark<Schema>[];
+}
+/** Atomic inline leaf such as an image. */
+type RichTextInlineLeaf<Schema extends RichTextSchema> = { [Name in keyof Schema["nodes"] & string]: Schema["nodes"][Name]["role"] extends "inline" ? {
+  readonly type: Name;
+  readonly attrs: Schema["nodes"][Name]["defaults"];
+  readonly marks: readonly RichTextMark<Schema>[];
+} : never }[keyof Schema["nodes"] & string];
+/** Inline content of a textblock. */
+type RichTextInline<Schema extends RichTextSchema> = RichTextInlineLeaf<Schema> | RichTextText<Schema>;
+/** Any block node; textblocks hold inline content, the rest hold blocks. */
+type RichTextBlock<Schema extends RichTextSchema> = { [Name in keyof Schema["nodes"] & string]: Schema["nodes"][Name]["role"] extends "inline" ? never : {
+  readonly type: Name;
+  readonly attrs: Schema["nodes"][Name]["defaults"];
+  readonly content: Schema["nodes"][Name]["role"] extends "textblock" ? readonly RichTextInline<Schema>[] : readonly RichTextBlock<Schema>[];
+} }[keyof Schema["nodes"] & string];
+/** A complete document typed by its schema (assignable to {@link RtDoc}). */
+interface RichTextDoc<Schema extends RichTextSchema = RichTextSchema> {
+  readonly type: "doc";
+  readonly content: readonly RichTextBlock<Schema>[];
+}
+/** Erased mark. */
+interface RtMark {
+  readonly type: string;
+  readonly attrs: RichTextAttrs;
+}
+/** Erased text run. */
+interface RtText {
+  readonly type: "text";
+  readonly text: string;
+  readonly marks: readonly RtMark[];
+}
+/** Erased inline leaf. */
+interface RtLeaf {
+  readonly type: string;
+  readonly attrs: RichTextAttrs;
+  readonly marks: readonly RtMark[];
+}
+/** Erased inline node. */
+type RtInline = RtLeaf | RtText;
+/** Erased block. */
+interface RtBlock {
+  readonly type: string;
+  readonly attrs: RichTextAttrs;
+  readonly content: readonly (RtBlock | RtInline)[];
+}
+/** Erased document. */
+interface RtDoc {
+  readonly type: "doc";
+  readonly content: readonly RtBlock[];
+}
+/** Position inside a textblock: `path` indexes blocks from the doc, `offset` counts inline units. */
+interface RichTextPosition {
+  /** Child indexes from the document to a textblock. */
+  readonly path: readonly number[];
+  /** Characters (text) and leaves (1 each) before the position. */
+  readonly offset: number;
+}
+/** Selection between two positions; `head` moves with Shift+arrows. */
+interface RichTextSelection {
+  readonly anchor: RichTextPosition;
+  readonly head: RichTextPosition;
+}
+/** Plain text of a block tree (textblocks joined by newlines). */
+declare function textContent(node: RtBlock | RtDoc): string;
+/** Empty document with one default block. */
+declare function emptyRichTextDoc<Schema extends RichTextSchema>(schema: Schema): RichTextDoc<Schema>;
+/** Document of plain-text paragraphs (lines split on newlines). */
+declare function richTextDocFromText<Schema extends RichTextSchema>(schema: Schema, text: string): RichTextDoc<Schema>;
+/** Why a value is not a valid document for a schema, or `null` when it is. */
+declare function validateRichTextDoc(schema: RichTextSchema, value: unknown): string | null;
+/** Type guard backed by {@link validateRichTextDoc}. */
+declare function isRichTextDoc<Schema extends RichTextSchema>(schema: Schema, value: unknown): value is RichTextDoc<Schema>;
+/** Narrow to a typed document or throw a diagnostic describing the first problem. */
+declare function assertRichTextDoc<Schema extends RichTextSchema>(schema: Schema, value: unknown): RichTextDoc<Schema>;
+//#endregion
+//#region src/families/editor/rich-text/rich-text-state.d.ts
+/** Why a transaction happened; drives undo grouping. */
+type RichTextTransactionKind = "delete" | "format" | "history" | "input" | "paste" | "selection" | "structure";
+/** One undo/redo snapshot (validated when restored). */
+interface RichTextHistoryEntry {
+  readonly doc: RtDoc;
+  readonly selection: RichTextSelection;
+}
+/** Snapshot history; documents are immutable, so snapshots share structure. */
+interface RichTextHistory {
+  readonly done: readonly RichTextHistoryEntry[];
+  readonly undone: readonly RichTextHistoryEntry[];
+  /** Kind and time of the last recorded change, for grouping typing into one step. */
+  readonly last: {
+    readonly kind: RichTextTransactionKind;
+    readonly time: number;
+  } | null;
+}
+/** Immutable editor state typed by its schema. */
+interface RichTextState<Schema extends RichTextSchema = RichTextSchema> {
+  readonly schema: Schema;
+  readonly doc: RichTextDoc<Schema>;
+  readonly selection: RichTextSelection;
+  /** Marks applied to the next typed text (after toggling a mark at a caret). */
+  readonly storedMarks: readonly RtMark[] | null;
+  readonly history: RichTextHistory;
+}
+/**
+ * Schema-agnostic state that commands and transactions work on. Every typed
+ * {@link RichTextState} of a concrete schema is assignable to it.
+ */
+interface RtState {
+  readonly schema: RichTextSchema;
+  readonly doc: RtDoc;
+  readonly selection: RichTextSelection;
+  readonly storedMarks: readonly RtMark[] | null;
+  readonly history: RichTextHistory;
+}
+/** Immutable record of one state change. */
+interface RichTextTransaction {
+  readonly before: RtState;
+  readonly state: RtState;
+  readonly kind: RichTextTransactionKind;
+  readonly docChanged: boolean;
+}
+/** Receives transactions produced by commands. */
+type RichTextDispatch = (transaction: RichTextTransaction) => void;
+/**
+ * A command checks applicability without `dispatch` and applies itself with it,
+ * returning whether it applies. Commands work on the schema-agnostic state
+ * view, so one command type serves every schema (typed states are assignable);
+ * type safety comes from the typed command factories.
+ */
+type RichTextCommand = (state: RtState, dispatch?: RichTextDispatch) => boolean;
+/** Options for {@link createRichTextState}. */
+interface RichTextStateOptions<Schema extends RichTextSchema> {
+  /** Initial document. @default one empty default block */
+  readonly doc?: RichTextDoc<Schema>;
+  /** Initial selection. @default caret at the document start */
+  readonly selection?: RichTextSelection;
+  /** Maximum undo depth. @default 100 */
+  readonly historyDepth?: number;
+}
+/** Options for {@link createTransaction}. */
+interface RichTextTransactionOptions {
+  /** Record the change for undo. @default true when the document changed */
+  readonly addToHistory?: boolean;
+  /** Timestamp used for undo grouping. @default Date.now() */
+  readonly time?: number;
+  /** Keep typed input within this many milliseconds in one undo step. @default 500 */
+  readonly groupDelay?: number;
+  /** Maximum undo depth. @default 100 */
+  readonly historyDepth?: number;
+}
+/** Create an editor state; the document is validated against the schema. */
+declare function createRichTextState<Schema extends RichTextSchema>(schema: Schema, options?: RichTextStateOptions<Schema>): RichTextState<Schema>;
+/**
+ * Build a transaction from a state and the changed parts. The resulting
+ * document is re-validated, so a transaction can never produce a document the
+ * schema rejects.
+ */
+declare function createTransaction(before: RtState, change: {
+  readonly doc?: RtDoc;
+  readonly selection?: RichTextSelection;
+  readonly storedMarks?: readonly RtMark[] | null;
+  readonly history?: RichTextHistory;
+}, kind: RichTextTransactionKind, options?: RichTextTransactionOptions): RichTextTransaction;
+/** Re-type a state produced by commands for its schema (the document is re-validated, cached). */
+declare function toRichTextState<Schema extends RichTextSchema>(schema: Schema, state: RtState): RichTextState<Schema>;
+/** Erase a typed state for schema-agnostic code (the document is re-validated, cached). */
+declare function toRtState<Schema extends RichTextSchema>(state: RichTextState<Schema>): RtState;
+/** Undo the last recorded change. */
+declare function undo(state: RtState, dispatch?: RichTextDispatch): boolean;
+/** Redo the last undone change. */
+declare function redo(state: RtState, dispatch?: RichTextDispatch): boolean;
+//#endregion
+//#region src/families/editor/rich-text/rich-text-input-rules.d.ts
+/**
+ * Transforms typed text. `match` runs against the textblock text before the
+ * caret plus the inserted text and must end with `$`.
+ */
+interface RichTextInputRule {
+  readonly match: RegExp;
+  /** Build the replacement for the matched text `[start, end)` (offsets before the new text). */
+  readonly apply: (state: RtState, match: RegExpExecArray, start: number, end: number) => RichTextTransaction | null;
+}
+/** Remove the matched prefix, then run `command` on the result, as one undo step. */
+declare function blockInputRule(match: RegExp, command: (match: RegExpExecArray) => RichTextCommand): RichTextInputRule;
+/** Replace the matched text with its first capture group carrying a mark. */
+declare function markInputRule(match: RegExp, mark: string): RichTextInputRule;
+/** Markdown-style input rules for every built-in node and mark the schema declares. */
+declare function defaultRichTextInputRules<Schema extends RichTextSchema>(schema: Schema): RichTextInputRule[];
+/** Insert text, letting the first matching input rule transform it instead. */
+declare function insertTextWithRules(text: string, rules: readonly RichTextInputRule[]): RichTextCommand;
+//#endregion
+//#region src/families/editor/rich-text/rich-text-keymap.d.ts
+/** Key bindings: `Mod` is Ctrl or Cmd; modifiers are ordered `Mod-Alt-Shift-`. */
+type RichTextKeymap = Readonly<Record<string, RichTextCommand>>;
+/** Normalized binding name of a keyboard event, e.g. `Mod-Shift-z`. */
+declare function richTextKeyName(event: KeyboardEvent): string;
+/** Standard shortcuts for every built-in node and mark the schema declares. */
+declare function defaultRichTextKeymap<Schema extends RichTextSchema>(schema: Schema): RichTextKeymap;
+//#endregion
+//#region src/families/editor/rich-text/rich-text-types.d.ts
+/** Props of the RichTextRoot default slot. */
+interface RichTextSlotProps<Schema extends RichTextSchema> {
+  /** Current editor state. */
+  readonly state: RichTextState<Schema>;
+  /** Whether editing is enabled. */
+  readonly editable: boolean;
+  /** Whether the content has focus. */
+  readonly focused: boolean;
+  /** Run a command; returns whether it applied. */
+  readonly run: (command: RichTextCommand) => boolean;
+}
+/** Imperative surface of RichTextRoot. */
+interface RichTextRootExpose<Schema extends RichTextSchema> {
+  /** Current editor state. */
+  readonly state: RichTextState<Schema>;
+  /** Run a command; returns whether it applied. */
+  readonly run: (command: RichTextCommand) => boolean;
+  /** Focus the editable content. */
+  readonly focus: () => void;
+  /** Serialize the document to sanitized HTML. */
+  readonly toHtml: () => string;
+}
+/** State exposed to toolbar button slots. */
+interface RichTextToolbarButtonSlotProps {
+  /** Whether the button's `active` predicate holds. */
+  readonly active: boolean;
+  /** Whether the command cannot run now. */
+  readonly disabled: boolean;
+}
+/** Imperative surface of RichTextContent. */
+interface RichTextContentExpose {
+  /** Rendered editable element. */
+  readonly element: HTMLDivElement | null;
+  /** Focus the editable element. */
+  readonly focus: () => void;
+}
+//#endregion
+//#region src/families/editor/rich-text/rich-text-root.vue.d.ts
+declare const __VLS_export$4: <Schema extends RichTextSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+    /**
+     * Schema declaring node and mark types; documents and commands are typed from it.
+     *
+     * @default undefined
+     */
+    readonly schema: Schema;
+    /**
+     * Controlled document (`v-model`). `undefined` selects uncontrolled behavior.
+     *
+     * @default undefined
+     */
+    readonly modelValue?: RichTextDoc<Schema>;
+    /**
+     * Initial uncontrolled document.
+     *
+     * @default one empty default block
+     */
+    readonly defaultValue?: RichTextDoc<Schema>;
+    /**
+     * Consumer-owned editor id. `null` and `undefined` select a deterministic fallback.
+     *
+     * @default undefined
+     */
+    readonly id?: string | null;
+    /**
+     * Allow editing; `false` renders read-only content.
+     *
+     * @default true
+     */
+    readonly editable?: boolean;
+    /**
+     * Input rules applied to typed text.
+     *
+     * @default defaultRichTextInputRules(schema)
+     */
+    readonly inputRules?: readonly RichTextInputRule[];
+    /**
+     * Keyboard shortcuts.
+     *
+     * @default defaultRichTextKeymap(schema)
+     */
+    readonly keymap?: RichTextKeymap;
+    /**
+     * Maximum undo depth.
+     *
+     * @default 100
+     */
+    readonly historyDepth?: number;
+  } & {
+    "onUpdate:modelValue"?: (value: RichTextDoc<Schema>) => any;
+    onTransaction?: (transaction: RichTextTransaction) => any;
+  }> & (typeof globalThis extends {
+    __VLS_PROPS_FALLBACK: infer P;
+  } ? P : {});
+  expose: (exposed: import("vue").ShallowUnwrapRef<{
+    state: import("vue").ShallowRef<RichTextState<Schema>, RichTextState<Schema>>;
+    run: (command: RichTextCommand) => boolean;
+    focus: () => void;
+    toHtml: () => string;
+  }>) => void;
+  attrs: any;
+  slots: {
+    /** Editor parts (content, toolbars, bubble menus). Receives the live state and commands. */default?(props: RichTextSlotProps<Schema>): unknown;
+  };
+  emit: ((evt: "update:modelValue", value: RichTextDoc<Schema>) => void) & ((evt: "transaction", transaction: RichTextTransaction) => void);
+}>) => import("vue").VNode & {
+  __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default$4: typeof __VLS_export$4;
+type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
+//#endregion
+//#region src/families/editor/rich-text/rich-text-bubble-menu.vue.d.ts
+type __VLS_Props$3 = {
+  /**
+   * Accessible name of the floating toolbar.
+   *
+   * @default "Selection formatting"
+   */
+  readonly ariaLabel?: string;
+  /**
+   * Preferred placement relative to the selection.
+   *
+   * @default "top"
+   */
+  readonly placement?: Placement;
+  /**
+   * Gap between the selection and the menu in CSS pixels.
+   *
+   * @default 8
+   */
+  readonly offset?: number;
+  /**
+   * Force visibility; `undefined` shows the menu for a non-empty selection while editing.
+   *
+   * @default undefined
+   */
+  readonly open?: boolean;
+};
+type __VLS_Slots$2 = {
+  /** Toolbar buttons for the selection. */default?(): unknown;
+};
+declare const __VLS_base$2: import("vue").DefineComponent<__VLS_Props$3, {
+  element: Readonly<import("vue").ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$3> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$3: __VLS_WithSlots$2<typeof __VLS_base$2, __VLS_Slots$2>;
+declare const _default$3: typeof __VLS_export$3;
+type __VLS_WithSlots$2<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/families/editor/rich-text/rich-text-content.vue.d.ts
+type __VLS_Props$2 = {
+  /**
+   * Accessible name of the text box.
+   *
+   * @default undefined
+   */
+  readonly ariaLabel?: string;
+  /**
+   * Ids that label the text box.
+   *
+   * @default undefined
+   */
+  readonly ariaLabelledby?: string;
+  /**
+   * Ids that describe the text box.
+   *
+   * @default undefined
+   */
+  readonly ariaDescribedby?: string;
+  /**
+   * Placeholder published as `data-placeholder` (and `aria-placeholder`) while empty.
+   *
+   * @default undefined
+   */
+  readonly placeholder?: string;
+  /**
+   * Native spellchecking.
+   *
+   * @default true
+   */
+  readonly spellcheck?: boolean;
+};
+declare function focus(): void;
+declare const __VLS_export$2: import("vue").DefineComponent<__VLS_Props$2, {
+  element: Readonly<import("vue").ShallowRef<HTMLDivElement | null>>;
+  focus: typeof focus;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$2> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default$2: typeof __VLS_export$2;
+//#endregion
+//#region src/families/editor/rich-text/rich-text-toolbar.vue.d.ts
+type __VLS_Props$1 = {
+  /**
+   * Accessible name of the toolbar.
+   *
+   * @default "Formatting"
+   */
+  readonly ariaLabel?: string;
+};
+type __VLS_Slots$1 = {
+  /** RichTextToolbarButton children (and separators or groups). */default?(): unknown;
+};
+declare const __VLS_base$1: import("vue").DefineComponent<__VLS_Props$1, {
+  element: Readonly<import("vue").ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$1> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
+declare const _default$1: typeof __VLS_export$1;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/families/editor/rich-text/rich-text-toolbar-button.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Command run on activation; the button disables itself while it cannot run.
+   *
+   * @default undefined
+   */
+  readonly command: RichTextCommand;
+  /**
+   * Toggle-state predicate; when provided the button publishes `aria-pressed`.
+   *
+   * @default undefined
+   */
+  readonly active?: (state: RtState) => boolean;
+  /**
+   * Accessible name when the content is an icon.
+   *
+   * @default undefined
+   */
+  readonly ariaLabel?: string;
+  /**
+   * Force the disabled state.
+   *
+   * @default false
+   */
+  readonly disabled?: boolean;
+};
+type __VLS_Slots = {
+  /** Button contents. Receives active and disabled state. */default?(props: RichTextToolbarButtonSlotProps): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/families/editor/rich-text/rich-text-commands.d.ts
+/** Attributes accepted when applying a node or mark: any subset of its defaults. */
+type AttrsOf<Defaults> = Partial<Defaults>;
+/** Attribute overrides as accepted internally (typed at the public boundary). */
+type AttrsInput = {
+  readonly [name: string]: RichTextAttrValue | undefined;
+};
+/** Marks typed text receives at the current caret. */
+declare function activeMarks(state: RtState): readonly RtMark[];
+/** Whether the selection (or stored marks at a caret) carries a mark type. */
+declare function isMarkActive(state: RtState, type: string): boolean;
+/** Whether every selected textblock has `type` (and matching `attrs`). */
+declare function isBlockActive(state: RtState, type: string, attrs?: RichTextAttrs): boolean;
+/** Whether the selection sits inside a wrapper of `type`. */
+declare function isWrappedIn(state: RtState, type: string): boolean;
+/** Typed command set bound to one schema. */
+interface RichTextCommands<Schema extends RichTextSchema> {
+  readonly insertText: (text: string) => RichTextCommand;
+  readonly deleteSelection: RichTextCommand;
+  readonly deleteBackward: (unit?: "character" | "word") => RichTextCommand;
+  readonly deleteForward: (unit?: "character" | "word") => RichTextCommand;
+  readonly splitBlock: RichTextCommand;
+  readonly selectAll: RichTextCommand;
+  readonly undo: RichTextCommand;
+  readonly redo: RichTextCommand;
+  /** Add or remove a mark; at a caret it toggles the stored marks for the next input. */
+  readonly toggleMark: <Name extends RichTextMarkName<Schema>>(name: Name, attrs?: AttrsOf<Schema["marks"][Name]["defaults"]>) => RichTextCommand;
+  /** Apply a mark (replacing one of the same type) across the selection. */
+  readonly setMark: <Name extends RichTextMarkName<Schema>>(name: Name, attrs?: AttrsOf<Schema["marks"][Name]["defaults"]>) => RichTextCommand;
+  /** Remove a mark type across the selection. */
+  readonly removeMark: (name: RichTextMarkName<Schema>) => RichTextCommand;
+  /** Change the selected textblocks' type. */
+  readonly setBlockType: <Name extends RichTextNodeName<Schema, "textblock">>(name: Name, attrs?: AttrsOf<Schema["nodes"][Name]["defaults"]>) => RichTextCommand;
+  /** Set the block type, or reset to the default block when already active. */
+  readonly toggleBlockType: <Name extends RichTextNodeName<Schema, "textblock">>(name: Name, attrs?: AttrsOf<Schema["nodes"][Name]["defaults"]>) => RichTextCommand;
+  /** Wrap the selected blocks in a container or list. */
+  readonly wrapIn: <Name extends RichTextNodeName<Schema, "container" | "list">>(name: Name, attrs?: AttrsOf<Schema["nodes"][Name]["defaults"]>) => RichTextCommand;
+  /** Wrap, or unwrap when already inside that wrapper type. */
+  readonly toggleWrap: <Name extends RichTextNodeName<Schema, "container" | "list">>(name: Name, attrs?: AttrsOf<Schema["nodes"][Name]["defaults"]>) => RichTextCommand;
+  /** Insert an inline leaf (image, hard break) at the selection. */
+  readonly insertInline: <Name extends RichTextNodeName<Schema, "inline">>(name: Name, attrs?: AttrsOf<Schema["nodes"][Name]["defaults"]>) => RichTextCommand;
+  /** Link the selection to `href` (or insert `text` as a link at a caret); `null` unlinks. */
+  readonly setLink: (href: string | null, text?: string) => RichTextCommand;
+  /** Insert a document (for example parsed paste content) at the selection. */
+  readonly insertContent: (content: RichTextDoc<Schema>) => RichTextCommand;
+}
+/** Commands addressed by plain type names (used by keymaps and input rules). */
+interface RichTextUntypedCommands {
+  readonly insertText: (text: string) => RichTextCommand;
+  readonly deleteSelection: RichTextCommand;
+  readonly deleteBackward: (unit?: "character" | "word") => RichTextCommand;
+  readonly deleteForward: (unit?: "character" | "word") => RichTextCommand;
+  readonly splitBlock: RichTextCommand;
+  readonly selectAll: RichTextCommand;
+  readonly undo: RichTextCommand;
+  readonly redo: RichTextCommand;
+  readonly toggleMark: (name: string, attrs?: AttrsInput) => RichTextCommand;
+  readonly setMark: (name: string, attrs?: AttrsInput) => RichTextCommand;
+  readonly removeMark: (name: string) => RichTextCommand;
+  readonly setBlockType: (name: string, attrs?: AttrsInput) => RichTextCommand;
+  readonly toggleBlockType: (name: string, attrs?: AttrsInput) => RichTextCommand;
+  readonly wrapIn: (name: string, attrs?: AttrsInput) => RichTextCommand;
+  readonly toggleWrap: (name: string, attrs?: AttrsInput) => RichTextCommand;
+  readonly insertInline: (name: string, attrs?: AttrsInput) => RichTextCommand;
+  readonly setLink: (href: string | null, text?: string) => RichTextCommand;
+  readonly insertContent: (content: RtDoc) => RichTextCommand;
+}
+/** Create the typed command set for a schema. */
+declare function createRichTextCommands<Schema extends RichTextSchema>(schema: Schema): RichTextCommands<Schema>;
+/**
+ * Commands that take plain type names; they return `false` for names the
+ * schema does not declare. Prefer {@link createRichTextCommands} in app code.
+ */
+declare function createUntypedRichTextCommands(schema: RichTextSchema): RichTextUntypedCommands;
+//#endregion
+//#region src/families/editor/rich-text/rich-text-html.d.ts
+/** Options for {@link richTextToHtml}. */
+interface RichTextHtmlOptions {
+  /**
+   * Emit editor hooks (`data-rt-path`, `data-rt-textblock`, `data-rt-leaf`,
+   * caret fillers) used by `RichTextContent` for selection mapping.
+   *
+   * @default false
+   */
+  readonly editor?: boolean;
+}
+/** Escape text or attribute content for HTML. */
+declare function escapeHtml(value: string): string;
+/** Serialize a document to HTML (escaped text, sanitized attributes). */
+declare function richTextToHtml(schema: RichTextSchema, doc: RtDoc, options?: RichTextHtmlOptions): string;
+/** Options for {@link richTextFromHtml}. */
+interface RichTextParseOptions {
+  /**
+   * Document whose `DOMParser` parses the HTML.
+   *
+   * @default globalThis.document
+   */
+  readonly document?: Document;
+}
+/**
+ * Parse (untrusted) HTML into a document of the schema. Only elements the
+ * schema declares survive; scripts, styles, frames, forms, and event
+ * attributes are dropped and URLs are checked by each spec's parse rule.
+ */
+declare function richTextFromHtml<Schema extends RichTextSchema>(schema: Schema, html: string, options?: RichTextParseOptions): RichTextDoc<Schema>;
+//#endregion
+//#region src/families/editor/rich-text/rich-text-dom.d.ts
+/** Point in the DOM (a node and an offset within it). */
+interface RichTextDomPoint {
+  readonly node: Node;
+  readonly offset: number;
+}
+/** Map a DOM point inside the editable root to a model position. */
+declare function positionFromDom(root: Element, node: Node, offset: number): RichTextPosition | null;
+/** Map a model position to a DOM point, preferring text nodes. */
+declare function domFromPosition(root: Element, position: RichTextPosition): RichTextDomPoint | null;
+/** Read the document selection when it lies inside `root`. */
+declare function readDomSelection(root: Element): RichTextSelection | null;
+/** Write a model selection into the document selection. */
+declare function writeDomSelection(root: Element, selection: RichTextSelection): boolean;
+//#endregion
+export { RichTextDoc as $, underlineSpec as $t, richTextKeyName as A, RichTextNodeSpecs as At, RichTextState as B, hardBreakSpec as Bt, _default$4 as C, RichTextMarkName as Ct, RichTextToolbarButtonSlotProps as D, RichTextNodeName as Dt, RichTextSlotProps as E, RichTextNodeAttrs as Et, markInputRule as F, bulletListSpec as Ft, RtState as G, italicSpec as Gt, RichTextTransaction as H, imageSpec as Ht, RichTextCommand as I, codeBlockSpec as It, redo as J, orderedListSpec as Jt, createRichTextState as K, linkSpec as Kt, RichTextDispatch as L, codeSpec as Lt, blockInputRule as M, RichTextSchema as Mt, defaultRichTextInputRules as N, blockquoteSpec as Nt, RichTextKeymap as O, RichTextNodeRole as Ot, insertTextWithRules as P, boldSpec as Pt, RichTextBlock as Q, strikeSpec as Qt, RichTextHistory as R, createDefaultRichTextSchema as Rt, _default$3 as S, RichTextMarkAttrs as St, RichTextRootExpose as T, RichTextMarkSpecs as Tt, RichTextTransactionKind as U, isSafeImageUrl as Ut, RichTextStateOptions as V, headingSpec as Vt, RichTextTransactionOptions as W, isSafeUrl as Wt, toRtState as X, richTextMark as Xt, toRichTextState as Y, paragraphSpec as Yt, undo as Z, richTextNode as Zt, isMarkActive as _, validateRichTextDoc as _t, writeDomSelection as a, RichTextText as at, _default$1 as b, RichTextDefaultSchema as bt, escapeHtml as c, RtInline as ct, RichTextCommands as d, RtText as dt, RichTextInline as et, RichTextUntypedCommands as f, assertRichTextDoc as ft, isBlockActive as g, textContent as gt, createUntypedRichTextCommands as h, richTextDocFromText as ht, readDomSelection as i, RichTextSelection as it, RichTextInputRule as j, RichTextParseRule as jt, defaultRichTextKeymap as k, RichTextNodeSpec as kt, richTextFromHtml as l, RtLeaf as lt, createRichTextCommands as m, isRichTextDoc as mt, domFromPosition as n, RichTextMark as nt, RichTextHtmlOptions as o, RtBlock as ot, activeMarks as p, emptyRichTextDoc as pt, createTransaction as q, listItemSpec as qt, positionFromDom as r, RichTextPosition as rt, RichTextParseOptions as s, RtDoc as st, RichTextDomPoint as t, RichTextInlineLeaf as tt, richTextToHtml as u, RtMark as ut, isWrappedIn as v, RichTextAttrValue as vt, RichTextContentExpose as w, RichTextMarkSpec as wt, _default$2 as x, RichTextDomSpec as xt, _default as y, RichTextAttrs as yt, RichTextHistoryEntry as z, defineRichTextSchema as zt };