@aicayzer/inkkit 0.3.5 → 0.4.0

package/dist/chunks/{highlight-Caqd0kqu.js → highlight-4lYN38Zo.js}

@@ -1,4 +1,4 @@
-import { a as Decoration, c as PluginKey, d as __toESM, i as $prose, o as DecorationSet, s as Plugin, u as __commonJSMin } from "./core-BjnsFL5-.js";
+import { a as Decoration, c as PluginKey, d as __toESM, i as $prose, o as DecorationSet, s as Plugin, u as __commonJSMin } from "./core-Dl4jPn_d.js";
 //#region node_modules/.pnpm/highlight.js@11.11.2/node_modules/highlight.js/es/languages/arduino.js
 /** @type LanguageFn */
 function cPlusPlus(hljs) {

package/dist/core.d.ts

@@ -1,5 +1,5 @@
 export { InkKitEditor } from './editor.js';
 export type { EditorEvents, EditorOptions, TextInputPreferences, CommandState, EditingMode, CaretState, Mark, Block, FormatCommand, FormatOptions, KeyInput, ImageInsertion, ShortcutName, Keymap, } from './editor.js';
 export { InkKitError } from './types.js';
-export type { DocumentFormat, EditorLabels, Heading, TableCommand, TableOptions, BlockMoveDirection, DocumentContext, DocumentInput, DocumentSnapshot, DocumentVersion, EditorErrorCode, ImageAdapter, ImageImportContext, WikiLinkReference, WikiLinkAdapter, FileReference, ClientPoint, FileContext, FilePresentation, FileAdapter, CapturedImage, PortableImage, ClipboardInput, ClipboardOutput, ClipboardScope, ClipboardImage, ClipboardDiagram, PrintableDocument, PrintableWarning, TextRange, ReadableTextSnapshot, TextRect, ViewportInsets, ViewportOptions, ViewportSnapshot, } from './types.js';
+export type { DocumentFormat, TextDocumentFormat, TextDocumentInput, RichTextDocumentInput, TextDocumentSnapshot, RichTextDocumentSnapshot, RichTextDocument, RichTextBlock, RichTextListItem, RichTextTableCell, RichTextInline, RichTextMark, FormatLoss, FormatLossCode, ConvertedDocument, FormatPromise, OfferedFormat, EditorLabels, Heading, TableCommand, TableOptions, BlockMoveDirection, DocumentContext, DocumentInput, DocumentSnapshot, DocumentVersion, EditorErrorCode, ImageAdapter, ImageImportContext, WikiLinkReference, WikiLinkAdapter, FileReference, ClientPoint, FileContext, FilePresentation, FileAdapter, CapturedImage, PortableImage, ClipboardInput, ClipboardOutput, ClipboardScope, ClipboardImage, ClipboardDiagram, PrintableDocument, PrintableWarning, TextRange, ReadableTextSnapshot, TextRect, ViewportInsets, ViewportOptions, ViewportSnapshot, } from './types.js';
 export type { SlashMenuOptions, SlashCommandName, SlashCommand } from './types.js';

package/dist/core.js

@@ -1,2 +1,2 @@
-import { r as InkKitError, t as InkKitEditor } from "./chunks/core-BjnsFL5-.js";
+import { r as InkKitError, t as InkKitEditor } from "./chunks/core-Dl4jPn_d.js";
 export { InkKitEditor, InkKitError };

package/dist/editor.d.ts

@@ -1,7 +1,7 @@
 import type { SlashMenuOptions } from './types.js';
-import { InkKitError, type ClientPoint, type DocumentInput, type DocumentSnapshot, type ImageAdapter, type FileAdapter, type WikiLinkAdapter, type ClipboardInput, type ClipboardOutput, type ClipboardScope, type DocumentVersion, type PrintableDocument, type TextRange, type ReadableTextSnapshot, type TextRect, type ViewportOptions, type ViewportSnapshot, type EditorLabels, type Heading, type TableCommand, type TableOptions, type BlockMoveDirection } from './types.js';
+import { InkKitError, type ClientPoint, type DocumentFormat, type DocumentInput, type DocumentSnapshot, type ConvertedDocument, type TextDocumentFormat, type ImageAdapter, type FileAdapter, type WikiLinkAdapter, type ClipboardInput, type ClipboardOutput, type ClipboardScope, type DocumentVersion, type PrintableDocument, type TextRange, type ReadableTextSnapshot, type TextRect, type ViewportOptions, type ViewportSnapshot, type EditorLabels, type Heading, type TableCommand, type TableOptions, type BlockMoveDirection, type OfferedFormat } from './types.js';
 /** An inline format that `CaretState` can report. */
-export type Mark = 'bold' | 'italic' | 'strikethrough' | 'highlight' | 'code' | 'link';
+export type Mark = 'bold' | 'italic' | 'strikethrough' | 'highlight' | 'underline' | 'superscript' | 'subscript' | 'code' | 'link';
 /** The kind of block that holds the start of the selection. Any other block reports `paragraph`. */
 export type Block = {
     type: 'paragraph';
@@ -26,8 +26,10 @@ export interface CaretState {
     block: Block;
     /** One quote holds the whole selection; the block is what sits inside it. */
     quoted: boolean;
+    /** In an RTF document, the alignment of the paragraph that holds the start of the selection. */
+    align?: 'left' | 'center' | 'right' | 'justify';
 }
-declare const formatCommands: readonly ['heading1', 'heading2', 'heading3', 'heading4', 'heading5', 'heading6', 'paragraph', 'bold', 'italic', 'strikethrough', 'highlight', 'code', 'codeBlock', 'quote', 'bulletList', 'orderedList', 'taskList', 'toggleTask', 'link'];
+declare const formatCommands: readonly ['heading1', 'heading2', 'heading3', 'heading4', 'heading5', 'heading6', 'paragraph', 'bold', 'italic', 'strikethrough', 'highlight', 'underline', 'superscript', 'subscript', 'code', 'codeBlock', 'quote', 'bulletList', 'orderedList', 'taskList', 'toggleTask', 'alignLeft', 'alignCenter', 'alignRight', 'alignJustify', 'link'];
 /** A command for `format`. */
 export type FormatCommand = (typeof formatCommands)[number];
 /** `destination` goes only with `link`, and `language` only with `codeBlock`. */
@@ -65,8 +67,11 @@ export interface TextInputPreferences {
     /** Typing a quote or `--` gives a curly quote or a dash, in formatted mode. Off unless true. */
     smartPunctuation?: boolean;
 }
-/** Mount options. Adapters, `labels`, `linkSchemes` and `rendering` are fixed at mount; the rest can change. */
-export interface EditorOptions {
+/** Mount options. Adapters, `formats`, `labels`, `linkSchemes` and `rendering` are fixed at mount;
+ *  the rest can change. `F` is the formats offered. */
+export interface EditorOptions<F extends DocumentFormat = TextDocumentFormat> {
+    /** The formats the host offers, listed by `formats`. Defaults to `['md', 'txt']`. Fixed at mount. */
+    formats?: readonly F[];
     /** Shows, imports and exports images. Without it and `files`, image Markdown stays literal. */
     images?: ImageAdapter;
     /** Opt-in block suggestions on an empty line. Fixed at mount. */
@@ -94,7 +99,7 @@ export interface EditorOptions {
 }
 /** What the editor can do now. Availability is the state at the time of the call, not a promise. */
 export interface CommandState extends DocumentVersion {
-    format: 'md' | 'txt';
+    format: DocumentFormat;
     mode: EditingMode;
     editable: boolean;
     /** Text composition (IME) is in progress. */
@@ -127,10 +132,10 @@ export interface CommandState extends DocumentVersion {
         moveBlockDown: boolean;
     };
 }
-/** The host's handlers, passed to `mount`. Only `changed` is required. */
-export interface EditorEvents {
-    /** The document's text changed. Not sent for a load, a reload or a refused edit. */
-    changed(snapshot: DocumentSnapshot): void;
+/** The host's handlers, passed to `mount`. Only `changed` is required. `F` is the formats offered. */
+export interface EditorEvents<F extends DocumentFormat = TextDocumentFormat> {
+    /** The document changed. Not sent for a load, a reload or a refused edit. */
+    changed(snapshot: DocumentSnapshot<F>): void;
     /** Availability or the caret changed, and once after each load. */
     commandStateChanged?(state: CommandState): void;
     /** A primary click with Mod on a link. Without it, links don't open. */
@@ -149,7 +154,7 @@ export declare const editorEvents: readonly ["changed", "commandStateChanged", "
  * The editor. Create it with `InkKitEditor.mount`, load a document, and read it back with
  * `snapshot`. The reference is https://inkkit.cyzr.me/reference/editor.
  */
-export declare class InkKitEditor {
+export declare class InkKitEditor<F extends DocumentFormat = TextDocumentFormat> {
     private readonly options;
     private editor;
     private readonly document;
@@ -187,6 +192,9 @@ export declare class InkKitEditor {
     private readonly events;
     /** The host's extra link schemes, in lower case. */
     private readonly linkSchemes;
+    /** The formats the host offered, in its order. */
+    private readonly offered;
+    private readonly formatList;
     /** How many of each state event the host has been sent. */
     private readonly sentEvents;
     private constructor();
@@ -195,6 +203,9 @@ export declare class InkKitEditor {
     private get generation();
     /** What `changed` reports for the document's new text. */
     private changeSnapshot;
+    private saved;
+    /** The current text, as `snapshot` checks and reads it. */
+    private savedText;
     /** Throws unless the document `captured` describes is still current, alive, not composing and
      *  has no import pending. */
     private assertCaptured;
@@ -237,6 +248,8 @@ export declare class InkKitEditor {
      *  `events.error`, unless a host call such as `keyDown` is waiting for it. */
     private forPerson;
     private get composing();
+    /** The formats the host offered at mount, in its order, with what saving each promises. */
+    get formats(): readonly OfferedFormat[];
     /** Whether the person can edit. A read-only editor still permits selection, copying and find. */
     get editable(): boolean;
     /** Turns editing on or off for both surfaces. Throws `composition` during text composition. */
@@ -251,7 +264,8 @@ export declare class InkKitEditor {
     /** What the editor can do now, for enabling host controls. Unlike `snapshot`, it works during
      *  composition. */
     commandState(expectedGeneration?: number): CommandState;
-    /** An image adapter shows and exports an inserted reference, and so does a file adapter. */
+    /** An image adapter shows and exports an inserted reference, and so does a file adapter. An RTF
+     *  document holds no images. */
     private get canInsertImages();
     private historyInputPlugin;
     private policyPlugin;
@@ -268,9 +282,15 @@ export declare class InkKitEditor {
     undo(expectedGeneration?: number): boolean;
     /** Returns whether a history step applied. */
     redo(expectedGeneration?: number): boolean;
-    /** The complete current text, which is what a host saves. It throws rather than return partial
-     *  text. */
-    snapshot(expectedGeneration?: number): DocumentSnapshot;
+    /** The complete current document, which is what a host saves. It throws rather than return a
+     *  partial document. */
+    snapshot(expectedGeneration?: number): DocumentSnapshot<F>;
+    /**
+     * The loaded document converted to `format`, which must be offered, with what the conversion
+     * lost. It changes nothing: load the result as a new generation. Markdown converts to RTF and
+     * RTF to Markdown; the same format returns a copy. Throws `invalid-argument` for any other pair.
+     */
+    convertDocument(format: DocumentFormat, expectedGeneration?: number): ConvertedDocument;
     /** The whole document as standalone HTML for printing. Rejects rather than return partial
      *  output. */
     printableSnapshot(expectedGeneration?: number): Promise<PrintableDocument>;
@@ -287,6 +307,8 @@ export declare class InkKitEditor {
     setCommentsVisible(visible: boolean): void;
     /** Inserts `text` literally at the selection and returns whether the document changed. */
     pasteAsPlainText(text: string, expectedGeneration?: number): boolean;
+    /** Whether an RTF edit that should have changed `before` was refused. */
+    private refusedRichEdit;
     private insertPlainText;
     /** Runs a table command and returns whether it applied. False in source and TXT modes, outside a
      *  table for commands that need one, and at a boundary a move can't cross. */
@@ -302,17 +324,21 @@ export declare class InkKitEditor {
     private indentPlugin;
     private dispatchTransaction;
     /** Builds the editor in `root`. It has no document until `loadDocument`. Rejects with
-     *  `invalid-argument` for a bad root, handler or option. */
+     *  `invalid-argument` for a bad root, handler or option. The editor's type follows `formats`:
+     *  without `rtf` among them, its documents are text. */
+    static mount<F extends DocumentFormat>(root: HTMLElement, events: EditorEvents<F>, options: EditorOptions<F> & {
+        formats: readonly F[];
+    }): Promise<InkKitEditor<F>>;
     static mount(root: HTMLElement, events: EditorEvents, options?: EditorOptions): Promise<InkKitEditor>;
     /** Replaces the document. The generation must be greater than the loaded one. A failed load
      *  changes nothing. */
-    loadDocument(input: DocumentInput): void;
+    loadDocument(document: DocumentInput<F>): void;
     /** Moves focus off whichever of InkKit's text surfaces holds it; other focus is left alone. */
     private releaseFocus;
     /** Replaces the document with a newer version of it, keeping the selection, focus, scroll
      *  position and Markdown editing mode. With `expectedGeneration`, the loaded document must be
      *  that generation. */
-    reloadDocument(input: DocumentInput, expectedGeneration?: number): void;
+    reloadDocument(document: DocumentInput<F>, expectedGeneration?: number): void;
     /** Names the scroll container and the host chrome that overlaps the editor. It replaces earlier
      *  settings. */
     setViewport(options: ViewportOptions): void;
@@ -390,8 +416,8 @@ export declare class InkKitEditor {
     format(command: FormatCommand, options?: FormatOptions, expectedGeneration?: number): boolean;
     /**
      * Refuses a link destination that is empty, that opens anything but a web, mail or phone address
-     * or a scheme the host listed, or that the Markdown writer cannot save so that it reads back the
-     * same.
+     * or a scheme the host listed, or, in Markdown, that the writer cannot save so that it reads back
+     * the same. In RTF, it also refuses what the rich text link rule refuses.
      */
     private checkDestination;
     /**

package/dist/formats/convert.d.ts

@@ -0,0 +1,17 @@
+import type { Ctx } from '@milkdown/kit/ctx';
+import { type Slice, type Node as ProseNode } from '@milkdown/kit/prose/model';
+import { type FormatLoss, type RichTextDocument } from '../types';
+/** A formatted Markdown document as rich text, with what RTF could not hold. */
+export declare function markdownToRichText(doc: ProseNode): {
+    document: RichTextDocument;
+    lost: readonly FormatLoss[];
+};
+/** A rich text document as Markdown, with what Markdown could not hold: alignment. Underline,
+ *  superscript and subscript are written as `<u>`, `<sup>` and `<sub>`. */
+export declare function richTextToMarkdown(ctx: Ctx, document: RichTextDocument): {
+    text: string;
+    lost: readonly FormatLoss[];
+};
+/** Markdown for content copied from a rich text document. Unlike a conversion it reports no
+ *  losses and isn't read back: a copy may lose alignment. */
+export declare function richContentMarkdown(ctx: Ctx, content: Slice): string;

package/dist/formats/index.d.ts

@@ -0,0 +1,8 @@
+import type { DocumentFormat } from '../types';
+import type { FormatHandler } from './types';
+export type { FormatHandler, FormatSource, FormatOutput, SavedText, } from './types';
+/** Every format Inkkit can open. */
+export declare const documentFormats: readonly ["md", "txt", "rtf"];
+/** The formats a host is offered when it chooses none. */
+export declare const defaultFormats: readonly ["md", "txt"];
+export declare const formatHandlers: Readonly<Record<DocumentFormat, FormatHandler>>;

package/dist/formats/markdown.d.ts

@@ -0,0 +1,4 @@
+import type { FormatHandler } from './types';
+/** Markdown, read and saved through source preservation, so an unedited file saves exactly and an
+ *  edit changes only the bytes it touched. */
+export declare const markdownFormat: FormatHandler;

package/dist/formats/rich-text-import.d.ts

@@ -0,0 +1,11 @@
+import { Slice } from '@milkdown/kit/prose/model';
+import type { EditorState } from '@milkdown/kit/prose/state';
+import type { ClipboardInput, RichTextBlock } from '../types';
+/** Blocks for pasted HTML. */
+export declare function htmlBlocks(html: string, schemes: ReadonlySet<string>): RichTextBlock[];
+/**
+ * The slice that `input` pastes into an RTF document at the selection. Explicit Markdown pastes as
+ * its text, unparsed; HTML keeps what RTF can hold; plain text gives a paragraph for each line.
+ * Plain text takes the marks of the text it replaces, as typing would.
+ */
+export declare function richTextPaste(input: ClipboardInput, state: EditorState, schemes: ReadonlySet<string>): Slice;

package/dist/formats/rich-text-model.d.ts

@@ -0,0 +1,56 @@
+import type { RichTextBlock, RichTextDocument, RichTextInline, RichTextMark } from '../types';
+/** The deepest list nesting RTF can hold (`\ilvl` 0 to 8). */
+export declare const maximumListDepth = 9;
+/** The largest first number of an ordered list that RTF writes and reads back unchanged, as
+ *  measured with the host's converter. */
+export declare const maximumListStart = 2147483647;
+/** Why a run cannot hold `text`, or undefined. Loading and editing share the rule. */
+export declare function textProblem(text: string): string | undefined;
+/** Why `href` cannot be a link's address, or undefined. Any address that is not empty and holds
+ *  no control character is kept, as the host's converter keeps it; loading, editing, paste and the
+ *  converter share the rule. Edits and paste also apply Inkkit's link safety. */
+export declare function linkProblem(href: string): string | undefined;
+/** The canonical order of marks. */
+export declare const markRank: {
+    readonly bold: 0;
+    readonly italic: 1;
+    readonly underline: 2;
+    readonly strikethrough: 3;
+    readonly superscript: 4;
+    readonly subscript: 5;
+    readonly code: 6;
+    readonly link: 7;
+};
+type Path = string;
+/** Collects inline content in canonical form: adjacent runs with equal marks merge, and each run
+ *  is NFC after merging, because joining two NFC strings can leave a sequence that composes. */
+export declare class InlineBuilder {
+    readonly content: RichTextInline[];
+    private marksKey?;
+    text(text: string, marks: readonly RichTextMark[]): void;
+    break(): void;
+    finish(): RichTextInline[];
+}
+/** Marks in canonical order. A link's run never also has underline: a link's underline is how it
+ *  is drawn, so RTF readers report it on every link. */
+export declare function canonicalMarks(marks: readonly RichTextMark[]): RichTextMark[];
+/**
+ * Checks `value` as a version 1 document and returns its canonical form: marks sorted, a link's
+ * underline removed, adjacent equal runs merged, runs in NFC, and `start` of 1 left out. Throws
+ * `invalid-argument` naming the first problem, under `path`.
+ */
+export declare function readRichTextDocument(value: unknown, path: Path): RichTextDocument;
+/** The text that stands for a canonical document inside the editor: its JSON. Two documents are
+ *  the same exactly when their texts are. */
+export declare function richTextText(document: RichTextDocument): string;
+/** The document a text from `richTextText` stands for, as a new object. */
+export declare function richTextFromText(text: string): RichTextDocument;
+/** Text from outside a document, such as a paste or another format, as canonical runs: a line or
+ *  paragraph separator inside a paragraph becomes a line break, and characters RTF cannot hold as
+ *  text become U+FFFD, so that no character disappears. */
+export declare function appendText(builder: InlineBuilder, text: string, marks: readonly RichTextMark[]): void;
+/** Typed or pasted text as paragraphs: each paragraph separator ends one, including a final one,
+ *  so inserting `'a\n'` leaves the caret in a new paragraph. A line separator is a line break.
+ *  Unlike the host's `RichTextDocument(plainText:)`, which reads a file, nothing is trimmed. */
+export declare function textBlocks(text: string): RichTextBlock[];
+export {};

package/dist/formats/rich-text-prose.d.ts

@@ -0,0 +1,23 @@
+import type { Mark, Node as ProseNode, Schema } from '@milkdown/kit/prose/model';
+import type { EditorState, Transaction } from '@milkdown/kit/prose/state';
+import { type RichTextBlock, type RichTextDocument } from '../types';
+/** The editor block for a rich text block. Its text also takes `around`, the marks of text that a
+ *  paste replaces. */
+export declare function proseBlock(schema: Schema, block: RichTextBlock, around?: readonly Mark[]): ProseNode;
+/** The editor document for a canonical rich text document. */
+export declare function richTextToProse(schema: Schema, document: RichTextDocument): ProseNode;
+/** The canonical rich text document for an editor document. Throws `preservation` when the
+ *  document holds something RTF cannot. The editor always holds a block, so its one empty
+ *  paragraph is an empty document when `emptyAsNone`, as it is when the document loaded empty. */
+export declare function proseToRichText(doc: ProseNode, emptyAsNone?: boolean): RichTextDocument;
+/** Whether the document a transaction reaches holds only what RTF can, read in the part it
+ *  changed and that part's ancestors. */
+export declare function richTextAllows(tr: Transaction, before: EditorState): boolean;
+/** The ranges of runs that have both a link and underline, which canonical form removes the
+ *  underline from, in the part of `doc` from `from` to `to`. */
+export declare function linkedUnderlines(doc: ProseNode, from: number, to: number): {
+    from: number;
+    to: number;
+}[];
+/** Whether every character from `from` to `to`, or the caret's marks, is in a link. */
+export declare function inLink(state: EditorState): boolean;

package/dist/formats/rich-text.d.ts

@@ -0,0 +1,5 @@
+import type { FormatHandler } from './types';
+/** Rich text, which the host converts to and from RTF. The editor holds the canonical JSON as the
+ *  document's text. It reaches no Markdown parsing or preservation;
+ *  `test/formats/boundary.test.ts` checks its imports. */
+export declare const richTextFormat: FormatHandler;

package/dist/formats/text.d.ts

@@ -0,0 +1,4 @@
+import type { FormatHandler } from './types';
+/** Literal text, edited only on the literal surface and saved as typed. It reaches no Markdown
+ *  parsing or preservation; `test/formats/boundary.test.ts` checks its imports. */
+export declare const textFormat: FormatHandler;

package/dist/formats/types.d.ts

@@ -0,0 +1,120 @@
+import type { Ctx } from '@milkdown/kit/ctx';
+import type { Fragment, Node as ProseNode, Slice } from '@milkdown/kit/prose/model';
+import type { EditorState, Transaction } from '@milkdown/kit/prose/state';
+import type { DiagramStore } from '../mermaid';
+import type { ClipboardInput, ClipboardOutput, DocumentContext, DocumentFormat, DocumentVersion, EditorLabels, FileAdapter, FormatPromise, ImageAdapter, PrintableDocument } from '../types';
+/** The current document as the editor holds it: its text, which for RTF is the canonical JSON of
+ *  its `RichTextDocument`. */
+export interface SavedText extends DocumentVersion {
+    readonly format: DocumentFormat;
+    readonly text: string;
+    readonly dirty: boolean;
+}
+/** What a format whose document is not source text adds to formatted editing. */
+export interface RichTextBehaviour {
+    /** Whether the document that `tr` reaches from `before` holds only what the format can. */
+    allows(tr: Transaction, before: EditorState): boolean;
+    /** Runs in `from` to `to` that hold both a link and underline, which the format cannot keep. */
+    linkedUnderlines(doc: ProseNode, from: number, to: number): {
+        from: number;
+        to: number;
+    }[];
+    /** Whether the selection is all link text, where underline does nothing. */
+    inLink(state: EditorState): boolean;
+    /** The slice a formatted paste inserts. */
+    paste(input: ClipboardInput, state: EditorState, linkSchemes: ReadonlySet<string>): Slice;
+    /** What copying the selection writes. */
+    copy(state: EditorState, linkSchemes: ReadonlySet<string>): {
+        text: string;
+        html: string;
+    };
+}
+/** What a format keeps from reading a text, to save edits to the document it read. */
+export interface FormatSource {
+    /** The document read from the text. */
+    readonly baseline: ProseNode;
+    /** The text to save for `doc`, which is `baseline` after edits. `carried` holds nodes that block
+     *  moves carried. Absent for a format that saves its literal surface's text. */
+    serialize?(doc: ProseNode, carried?: WeakSet<ProseNode>): string;
+}
+/** What a format's output reads from the editor. Each call reads the current value, and
+ *  `context()` names a new operation, so call it only when an adapter needs it. */
+export interface FormatOutput {
+    ctx(): Ctx;
+    element(): HTMLTextAreaElement;
+    sourceMode(): boolean;
+    exportDocument(text: string): ProseNode;
+    images(): ImageAdapter | undefined;
+    files(): FileAdapter | undefined;
+    linkSchemes(): ReadonlySet<string>;
+    context(): DocumentContext;
+    diagrams(): DiagramStore;
+    root(): HTMLElement;
+    /** Markdown for rich content copied from a document that is not Markdown. A copy may lose what
+     *  Markdown can't hold, such as alignment. */
+    richTextMarkdown(content: Slice): string;
+    remember<T extends {
+        text: string;
+        html: string;
+    }>(output: T, markdown: string, content: Fragment, privateSource?: boolean): T;
+}
+export type PrintableContent = Pick<PrintableDocument, 'html' | 'styles' | 'assets' | 'warnings'>;
+export interface PrintRequest {
+    /** The current text. */
+    readonly text: string;
+    /** The document to print, which holds source typed but not yet settled. */
+    readonly doc: ProseNode;
+    readonly signal: AbortSignal;
+    readonly output: FormatOutput;
+}
+export interface ClipboardRequest {
+    readonly snapshot: SavedText;
+    /** The whole document, rather than the selection. */
+    readonly all: boolean;
+    readonly version: DocumentVersion;
+    readonly output: FormatOutput;
+    /** Runs asynchronous output work, and throws `stale-document` when the document, its revision or
+     *  the editing mode changed meanwhile. */
+    run<T>(operation: (signal: AbortSignal) => Promise<T>): Promise<T>;
+    /** Throws unless the captured document is still current. */
+    assertCurrent(): void;
+}
+/**
+ * Everything that differs between document formats. The editor sets one handler on each load and
+ * reads its fields directly, so a keystroke does no lookup.
+ */
+export interface FormatHandler {
+    readonly format: DocumentFormat;
+    readonly promise: FormatPromise;
+    /** The person edits only the literal surface: there is no formatted mode, and no format, table
+     *  or block commands. */
+    readonly literalOnly: boolean;
+    /** A source mode exists beside formatted mode. */
+    readonly sourceMode: boolean;
+    /** The label that names the formatted surface. */
+    readonly formattedLabel: keyof Pick<EditorLabels, 'formattedEditor' | 'richTextEditor'>;
+    /** The label that names the literal surface. */
+    readonly literalLabel: keyof Pick<EditorLabels, 'plainTextEditor' | 'sourceEditor'>;
+    /** `headings` lists the document's headings. */
+    readonly headings: boolean;
+    /** Copying from the literal surface is left to the browser. */
+    readonly nativeCopy: boolean;
+    /** Text inserted on the literal surface keeps its own line endings, rather than taking the
+     *  document's. */
+    readonly keepsInsertedLineEndings: boolean;
+    /** Markdown input rules and bare-address links apply while typing in formatted mode. */
+    readonly markdownInput: boolean;
+    /** Present for a format that is not Markdown source but edits in formatted mode. */
+    readonly richText?: RichTextBehaviour;
+    /** Reads loaded text into the formatted document. Throws when it cannot be shown. */
+    load(ctx: Ctx, text: string): FormatSource;
+    /** Reads text from the literal surface into the formatted document. */
+    parse(ctx: Ctx, text: string): FormatSource;
+    /** The document that output reads while text from the literal surface has not reached the
+     *  formatted document, or `undefined` to read the formatted document. */
+    pendingExport(ctx: Ctx, text: string): ProseNode | undefined;
+    /** The text that a paste on the literal surface inserts. */
+    literalPaste(input: ClipboardInput): string;
+    print(request: PrintRequest): Promise<PrintableContent>;
+    clipboard(request: ClipboardRequest): Promise<ClipboardOutput>;
+}

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as registerDiagram, r as InkKitError, t as InkKitEditor } from "./chunks/core-BjnsFL5-.js";
+import { n as registerDiagram, r as InkKitError, t as InkKitEditor } from "./chunks/core-Dl4jPn_d.js";
 //#region node_modules/.pnpm/dompurify@3.4.17/node_modules/dompurify/dist/purify.es.mjs
 /*! @license DOMPurify 3.4.17 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.17/LICENSE */
 function _OverloadYield(e, d) {

package/dist/style.css

@@ -912,6 +912,30 @@
   color: inherit;
 }
 
+.inkkit-root .ProseMirror u {
+  text-decoration-line: underline;
+  text-decoration-thickness: var(--inkkit-underline-thickness, auto);
+  text-underline-offset: var(--inkkit-underline-offset, auto);
+}
+
+/* Shifted rather than vertically aligned, so a line holding them keeps its
+   height. A footnote reference is also a `sup` and keeps its own style. */
+.inkkit-root .ProseMirror sup:not([data-inkkit-footnote-reference]),
+.inkkit-root .ProseMirror sub {
+  position: relative;
+  font-size: var(--inkkit-script-size, 0.75em);
+  line-height: 0;
+  vertical-align: baseline;
+}
+
+.inkkit-root .ProseMirror sup:not([data-inkkit-footnote-reference]) {
+  top: calc(var(--inkkit-superscript-shift, 0.5em) * -1);
+}
+
+.inkkit-root .ProseMirror sub {
+  bottom: calc(var(--inkkit-subscript-shift, 0.25em) * -1);
+}
+
 .inkkit-root .ProseMirror .inkkit-callout {
   --_inkkit-callout-color: var(--_inkkit-accent);
   border-inline-start: 3px solid var(--_inkkit-callout-color);

package/dist/types.d.ts

@@ -1,5 +1,18 @@
-/** `md` is Markdown; `txt` is literal text, shown and saved as typed. */
-export type DocumentFormat = 'md' | 'txt';
+/** `md` is Markdown; `txt` is literal text, shown and saved as typed; `rtf` is rich text, which the
+ *  host converts to and from a `RichTextDocument`. */
+export type DocumentFormat = 'md' | 'txt' | 'rtf';
+/** The formats whose document is text: Markdown and TXT. An editor mounted without `rtf` in its
+ *  `formats` has only these. */
+export type TextDocumentFormat = 'md' | 'txt';
+/** What saving promises for a format. `exact` saves the file exactly. `structure` keeps the
+ *  structure and marks and replaces fonts, colors and sizes with Inkkit's style. `lossy` is a
+ *  conversion that drops something and says what. */
+export type FormatPromise = 'exact' | 'structure' | 'lossy';
+/** A format the host offered at mount, with what saving it promises. */
+export interface OfferedFormat {
+    format: DocumentFormat;
+    promise: FormatPromise;
+}
 /** What every adapter call receives, to tell which document, load and call it belongs to. The
  *  operation ID is opaque and differs for each call from one editor. */
 export interface DocumentContext {
@@ -7,13 +20,87 @@ export interface DocumentContext {
     generation: number;
     operationId: string;
 }
-/** A document to load. `generation` must be greater than the loaded one. */
-export interface DocumentInput {
+/** A document to load. `generation` must be greater than the loaded one. Markdown and TXT carry
+ *  their `text`; RTF carries the `document` the host read from the file. `F` is the formats the
+ *  editor was mounted with; without `rtf` among them, every input is text. */
+export type DocumentInput<F extends DocumentFormat = TextDocumentFormat> = F extends 'rtf' ? RichTextDocumentInput : TextDocumentInput;
+/** A Markdown or TXT document to load. */
+export interface TextDocumentInput {
     documentId: string;
     generation: number;
-    format: DocumentFormat;
+    format: TextDocumentFormat;
     text: string;
 }
+/** An RTF document to load, as the host's converter read it. */
+export interface RichTextDocumentInput {
+    documentId: string;
+    generation: number;
+    format: 'rtf';
+    document: RichTextDocument;
+}
+/** A rich text document: the JSON form of an RTF file that the host converts. Version 1 is the
+ *  only version. */
+export interface RichTextDocument {
+    version: 1;
+    blocks: RichTextBlock[];
+}
+/** A paragraph, a list or a table. A list item holds a paragraph and then only lists. */
+export type RichTextBlock = {
+    type: 'paragraph';
+    /** Absent for left alignment. */
+    align?: 'center' | 'right' | 'justify';
+    content: RichTextInline[];
+} | {
+    type: 'list';
+    ordered: boolean;
+    /** An ordered list's first number, 1 or more. Absent for 1. */
+    start?: number;
+    items: RichTextListItem[];
+} | {
+    type: 'table';
+    /** Every row has the same number of cells. */
+    rows: RichTextTableCell[][];
+};
+export interface RichTextListItem {
+    blocks: RichTextBlock[];
+}
+export interface RichTextTableCell {
+    content: RichTextInline[];
+}
+/** A run of text, never empty and without line or paragraph separators, or a line break. */
+export type RichTextInline = {
+    type: 'text';
+    text: string;
+    marks?: RichTextMark[];
+} | {
+    type: 'break';
+};
+/** An inline mark. A run holds each type at most once, and never both superscript and
+ *  subscript. */
+export type RichTextMark = {
+    type: 'bold' | 'italic' | 'underline' | 'strikethrough' | 'superscript' | 'subscript' | 'code';
+} | {
+    type: 'link';
+    href: string;
+};
+/** Something a conversion between formats could not keep. `count` is how many places lost it. */
+export interface FormatLoss {
+    code: FormatLossCode;
+    count: number;
+}
+/** The closed list of what a conversion can lose. The API reference describes each one. */
+export declare const formatLossCodes: readonly ['heading', 'code-block', 'diagram', 'quote', 'callout', 'task', 'rule', 'footnote', 'comment', 'highlight', 'image', 'file', 'wiki-link', 'literal', 'link', 'table-alignment', 'list-start', 'list-item-blocks', 'list-depth', 'link-underline', 'invalid-character', 'alignment', 'mark-spaces', 'empty-line'];
+export type FormatLossCode = (typeof formatLossCodes)[number];
+/** A document converted to another format, for the host to load as a new generation. */
+export type ConvertedDocument = {
+    format: 'md' | 'txt';
+    text: string;
+    lost: readonly FormatLoss[];
+} | {
+    format: 'rtf';
+    document: RichTextDocument;
+    lost: readonly FormatLoss[];
+};
 /** Which document an output describes: the load, named by its generation, and the revision of
  *  its content within that load. */
 export interface DocumentVersion {
@@ -21,8 +108,15 @@ export interface DocumentVersion {
     generation: number;
     revision: number;
 }
-/** The complete current text. `dirty` is true when it differs from the text of the last load. */
-export interface DocumentSnapshot extends DocumentInput, DocumentVersion {
+/** The complete current document. `dirty` is true when it differs from the last load. `F` is the
+ *  formats the editor was mounted with; without `rtf` among them, every snapshot is text. */
+export type DocumentSnapshot<F extends DocumentFormat = TextDocumentFormat> = F extends 'rtf' ? RichTextDocumentSnapshot : TextDocumentSnapshot;
+/** The complete current text of a Markdown or TXT document. */
+export interface TextDocumentSnapshot extends TextDocumentInput, DocumentVersion {
+    dirty: boolean;
+}
+/** The complete current RTF document, in canonical form, for the host to write as RTF. */
+export interface RichTextDocumentSnapshot extends RichTextDocumentInput, DocumentVersion {
     dirty: boolean;
 }
 /** The closed list of failure codes. The API reference describes each one. */
@@ -262,6 +356,8 @@ export interface EditorLabels {
     slashWarning: string;
     slashCaution: string;
     formattedEditor: string;
+    /** Accessible name of the formatted surface while an RTF document is loaded. */
+    richTextEditor: string;
     plainTextEditor: string;
     sourceEditor: string;
     placeholder: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aicayzer/inkkit",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "description": "A preserving Markdown editor for offline web views and the web",
   "license": "MIT",
   "type": "module",