@aicayzer/inkkit 0.3.5 → 0.3.6

package/dist/chunks/{highlight-Caqd0kqu.js → highlight-wulvkYDg.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-DtLNFuDg.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, 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-DtLNFuDg.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 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';
@@ -27,7 +27,7 @@ export interface CaretState {
     /** One quote holds the whole selection; the block is what sits inside it. */
     quoted: boolean;
 }
-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', 'link'];
 /** A command for `format`. */
 export type FormatCommand = (typeof formatCommands)[number];
 /** `destination` goes only with `link`, and `language` only with `codeBlock`. */
@@ -65,8 +65,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. */
+/** Mount options. Adapters, `formats`, `labels`, `linkSchemes` and `rendering` are fixed at mount;
+ *  the rest can change. */
 export interface EditorOptions {
+    /** The formats the host offers, listed by `formats`. Defaults to `['md', 'txt']`. Fixed at mount. */
+    formats?: readonly DocumentFormat[];
     /** 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 +97,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. */
@@ -187,6 +190,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();
@@ -237,6 +243,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. */

package/dist/formats/index.d.ts

@@ -0,0 +1,6 @@
+import type { DocumentFormat } from '../types';
+import type { FormatHandler } from './types';
+export type { FormatHandler, FormatSource, FormatOutput } from './types';
+/** Every format Inkkit can open, and the list a host is offered when it chooses none. */
+export declare const documentFormats: 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/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,84 @@
+import type { Ctx } from '@milkdown/kit/ctx';
+import type { Fragment, Node as ProseNode } from '@milkdown/kit/prose/model';
+import type { DiagramStore } from '../mermaid';
+import type { ClipboardInput, ClipboardOutput, DocumentContext, DocumentFormat, DocumentSnapshot, DocumentVersion, EditorLabels, FileAdapter, FormatPromise, ImageAdapter, PrintableDocument } from '../types';
+/** 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;
+    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 snapshot's 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: DocumentSnapshot;
+    /** 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 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;
+    /** 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-DtLNFuDg.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,14 @@
 /** `md` is Markdown; `txt` is literal text, shown and saved as typed. */
 export type DocumentFormat = '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 {

package/package.json

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