supamde 0.0.0-stage → 0.1.0

package/dist/commands/block.d.ts

@@ -0,0 +1,20 @@
+import type { SupaCommand } from './types';
+type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+/** Setzt ein absolutes Heading-Level; erneutes Setzen desselben Levels entfernt es. */
+export declare function setHeading(level: HeadingLevel): SupaCommand;
+/** Verkleinert die Überschrift (mehr #, Grenze 6); aus Klartext wird H1. */
+export declare const headingSmaller: SupaCommand;
+/** Vergrößert die Überschrift (weniger #); H1 → Klartext, bleibt bei Klartext. */
+export declare const headingBigger: SupaCommand;
+/** Blockzitat (`> `) je Zeile ein-/ausschalten. */
+export declare const quote: SupaCommand;
+/**
+ * Umschließt die Selektion mit ```-Fences (Codeblock) bzw. entfernt sie, wenn die
+ * Selektion bereits exakt von einem `` ```-Fence-Paar `` umschlossen ist (Toggle).
+ */
+export declare const codeBlock: SupaCommand;
+/** Fügt eine horizontale Trennlinie (`\n---\n`) an der Cursorzeile ein. */
+export declare const horizontalRule: SupaCommand;
+/** Entfernt erkannte Block-/Listen-Präfixe (#, >, -, 1., - [ ]) der selektierten Zeilen. */
+export declare const cleanBlock: SupaCommand;
+export {};

package/dist/commands/history.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Undo/Redo als dünne Re-Exports über `@codemirror/commands`. Der zugehörige
+ * History-State wird über die `history()`-Extension bereitgestellt (siehe
+ * `editor/extensions.ts`). Der CM6-`Command`-Typ ist zu `SupaCommand` kompatibel.
+ */
+export { undo, redo } from '@codemirror/commands';

package/dist/commands/indent.d.ts

@@ -0,0 +1,18 @@
+import type { SupaCommand } from './types';
+/**
+ * Rückt alle von der Hauptselektion berührten Zeilen um ein `indentUnit` ein
+ * (Leerzeichen, Default 2). Die Einrückung wird IMMER am Zeilenanfang eingefügt,
+ * unabhängig davon, wo der Cursor in der Zeile steht — anders als der CM6-
+ * Standard `indentWithTab`, der mitten im Text ein Tab-Zeichen setzen würde.
+ *
+ * In Markdown ergibt sich die Listen-Verschachtelung genau aus dieser
+ * Leerzeichen-Einrückung, deshalb braucht es keinen Listen-Sonderfall.
+ */
+export declare const indentLines: SupaCommand;
+/**
+ * Rückt alle von der Hauptselektion berührten Zeilen um bis zu ein `indentUnit`
+ * aus. Zeilen ohne führenden Whitespace bleiben unverändert — der Command gibt
+ * dennoch `true` zurück, damit `Shift-Tab` die Taste konsumiert und den Fokus
+ * nicht aus dem Editor bewegt.
+ */
+export declare const dedentLines: SupaCommand;

package/dist/commands/inline.d.ts

@@ -0,0 +1,9 @@
+import type { SupaCommand } from './types';
+/** Fettdruck (`**…**`) ein-/ausschalten. */
+export declare const bold: SupaCommand;
+/** Kursiv (`*…*`) ein-/ausschalten. */
+export declare const italic: SupaCommand;
+/** Durchstreichen (`~~…~~`) ein-/ausschalten. */
+export declare const strikethrough: SupaCommand;
+/** Inline-Code (`` `…` ``) ein-/ausschalten. */
+export declare const inlineCode: SupaCommand;

package/dist/commands/keymap.d.ts

@@ -0,0 +1,8 @@
+import type { KeyBinding } from '@codemirror/view';
+/**
+ * Default-Tastenkürzel aus easyMDE (Cmd → CM6 `Mod`, plattformgerecht). Der Großteil
+ * wird aus `BUILTIN_ACTIONS` (ui/actions.ts) abgeleitet — das ist die Single Source of
+ * Truth für Kürzel, die zu einem Toolbar-Button gehören. Nur Bindungen ohne Button
+ * (quote-Zweitkürzel, Sternchen-Liste, Listen-Fortsetzung) bleiben hier explizit.
+ */
+export declare const supaKeymap: KeyBinding[];

package/dist/commands/link-image.d.ts

@@ -0,0 +1,13 @@
+import type { EditorView } from '@codemirror/view';
+import type { SupaCommand } from './types';
+/** Fügt `[text](url)` ein; ohne `text` wird die Selektion verwendet. */
+export declare function insertLink(url: string, text?: string): SupaCommand;
+/** Fügt `![alt](url)` ein; ohne `altText` wird die Selektion verwendet. */
+export declare function insertImage(url: string, altText?: string): SupaCommand;
+/**
+ * Toolbar-/Shortcut-Wrapper: fragt die URL per `window.prompt` ab und ruft den
+ * reinen `insertLink`. Der Seiteneffekt (Prompt) ist bewusst hier isoliert.
+ */
+export declare function drawLink(view: EditorView): boolean;
+/** Wie `drawLink`, aber für ein Bild (`insertImage`). */
+export declare function drawImage(view: EditorView): boolean;

package/dist/commands/list.d.ts

@@ -0,0 +1,20 @@
+import type { EditorView } from '@codemirror/view';
+import type { SupaCommand } from './types';
+/** Ungeordnete Liste mit Spiegelstrich (`- `) ein-/ausschalten (Default, Cmd+L). */
+export declare const unorderedList: SupaCommand;
+/** Ungeordnete Liste mit Sternchen (`* `) ein-/ausschalten (Shift+Alt+Cmd+L). */
+export declare const unorderedListStar: SupaCommand;
+/** Checkliste (`- [ ] `) je Zeile ein-/ausschalten. */
+export declare const checkList: SupaCommand;
+/** Geordnete Liste (`1. `, `2. `, …) fortlaufend setzen bzw. entfernen. */
+export declare const orderedList: SupaCommand;
+/**
+ * Enter-Handler für Listen: setzt Einrückung und Präfix in der neuen Zeile fort;
+ * ist die aktuelle Listenzeile leer (nur Einrückung + Präfix), wird die Liste
+ * beendet — die Zeile wird geleert, der Cursor bleibt an ihrem Anfang stehen.
+ * `false`, wenn die Cursorzeile keine Liste ist (Standard-Enter greift dann).
+ *
+ * Die Präfix-Erkennung teilt sich mit `cleanBlock` die zentrale `stripLinePrefix`
+ * (Task 1); nur die Fortsetzungs-Logik (Inkrement) ist listenspezifisch.
+ */
+export declare function continueList(view: EditorView): boolean;

package/dist/commands/prefixes.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Zentrale Definition aller markdown-Zeilen-Präfixe, die von mehreren Command-
+ * Modulen erkannt/entfernt werden. Eine einzige Quelle verhindert, dass sich
+ * `block.ts`, `list.ts` und `cleanBlock` in ihren Regexes auseinanderentwickeln.
+ * Reihenfolge ist bedeutsam: spezifischere Muster (Checkliste) VOR allgemeineren
+ * (Aufzählungsstrich) prüfen.
+ */
+export declare const LINE_PREFIXES: readonly RegExp[];
+/**
+ * Trennt ein erkanntes Zeilen-Präfix vom Rest der Zeile. Liefert `null`, wenn die
+ * Zeile mit keinem bekannten Präfix beginnt.
+ *
+ * Führender Whitespace (verschachtelte Listen) wird übersprungen und separat als
+ * `indent` zurückgegeben — `prefix` bleibt dadurch der reine Marker. Nur so kann
+ * `continueList` die Einrückung einer Unterliste fortführen, während `cleanBlock`
+ * unverändert ab `line.from + indent.length` genau den Marker entfernt.
+ */
+export declare function stripLinePrefix(text: string): {
+    indent: string;
+    prefix: string;
+    rest: string;
+} | null;
+/**
+ * Zählt den zu entfernenden führenden Whitespace einer Zeile: bis zu `unit`
+ * Leerzeichen, weniger wenn weniger vorhanden sind. Ein führendes Tab-Zeichen
+ * zählt als eine vollständige Einrückstufe und wird als Ganzes entfernt.
+ * `0`, wenn die Zeile nicht mit Whitespace beginnt.
+ */
+export declare function dedentWidth(text: string, unit: number): number;

package/dist/commands/queries.d.ts

@@ -0,0 +1,25 @@
+import type { EditorState } from '@codemirror/state';
+import type { SyntaxNode } from '@lezer/common';
+/**
+ * Die gemeinsame Syntaxbaum-Traversierung: liefert den Knoten namens `nodeName`,
+ * der die Hauptselektion umschließt (oder `null`). EINZIGE Quelle dieser
+ * Traversierung im Projekt — `inline.ts` setzt hierauf auf (es braucht die Node
+ * zum Entfernen der Marker), die Bool-Queries sind `!== null` darüber.
+ */
+export declare function resolveEnclosingNode(state: EditorState, nodeName: string): SyntaxNode | null;
+export declare function isBold(state: EditorState): boolean;
+export declare function isItalic(state: EditorState): boolean;
+export declare function isStrikethrough(state: EditorState): boolean;
+export declare function isInlineCode(state: EditorState): boolean;
+/**
+ * Aktuelle Heading-Ebene der ersten Selektionszeile (0 = keine). EINZIGE
+ * Heading-Regex im Projekt — `block.ts` (`setHeading`, `headingSmaller`,
+ * `headingBigger`) ruft diese Funktion statt einer eigenen `currentLevel`.
+ * `match[0].length - 1` = #-Zeichen ohne das trennende Leerzeichen (identisch
+ * zur bisherigen `currentLevel`-Semantik).
+ */
+export declare function activeHeadingLevel(state: EditorState): number;
+export declare function isQuote(state: EditorState): boolean;
+export declare function isInUnorderedList(state: EditorState): boolean;
+export declare function isInOrderedList(state: EditorState): boolean;
+export declare function isInCheckList(state: EditorState): boolean;

package/dist/commands/table.d.ts

@@ -0,0 +1,7 @@
+import type { SupaCommand } from './types';
+/**
+ * Fügt ein GFM-Tabellengerüst (Header, Trennzeile, eine Datenzeile) am Cursor ein.
+ * Die Spaltenköpfe kommen aus dem Translator im State — ohne Provider englisch,
+ * damit der Command auch ohne SupaMDE-Instanz läuft.
+ */
+export declare const table: SupaCommand;

package/dist/commands/types.d.ts

@@ -0,0 +1,17 @@
+import type { EditorView } from '@codemirror/view';
+/**
+ * Ein SupaMDE-Command ist eine reine CM6-Command-Funktion: liest `view.state`,
+ * dispatcht bei Bedarf eine Transaktion und liefert `true`, wenn das Doc
+ * verändert wurde — sonst `false` (No-op). Testbar ohne DOM/Toolbar.
+ */
+export type SupaCommand = (view: EditorView) => boolean;
+/**
+ * Eine einzelne Doc-Änderung im CM6-`changes`-Format. Zentral definiert, damit
+ * die Command-Module (`text.ts`, `block.ts`, `list.ts`, `inline.ts`) nicht
+ * jeweils denselben Inline-Typ wiederholen.
+ */
+export interface DocChange {
+    from: number;
+    to: number;
+    insert: string;
+}

package/dist/editor/extensions.d.ts

@@ -0,0 +1,14 @@
+import { type Extension } from '@codemirror/state';
+import type { ResolvedOptions } from '../options';
+import { type UpdateSink } from '../ui/update-listener';
+/**
+ * Übersetzt normalisierte Optionen in die CM6-Extension-Liste. Jede easyMDE-
+ * Option wird hier zur echten Extension (kein Flag-Layer). `autofocus` ist
+ * bewusst nicht enthalten — es ist eine View-Konstruktor-Option, keine Extension.
+ * GFM-Extensions sind aktiviert, um GitHub Flavored Markdown (Strikethrough, Tabellen, etc.) zu parsen.
+ * `Math` erkennt `$…$`/`$$…$$` als eigene Knoten, damit LaTeX-Inhalt nicht als
+ * Markdown (Fett, Links, …) interpretiert wird.
+ * `livePreviewCompartment` hält die Live-Modus-Extension — im Source-Modus leer,
+ * per `reconfigure` zur Laufzeit umschaltbar.
+ */
+export declare function buildExtensions(resolved: ResolvedOptions, sink?: UpdateSink, extraExtensions?: Extension[]): Extension[];

package/dist/editor/highlight.d.ts

@@ -0,0 +1,11 @@
+import { HighlightStyle } from '@codemirror/language';
+import type { Extension } from '@codemirror/state';
+/**
+ * Kern-Formatierungen für die easyMDE-„Quasi-WYSIWYG"-Parität: der Markdown-
+ * Quelltext bleibt sichtbar, wird aber live formatiert. Farben stammen aus
+ * `tokens.ts`; exakte px/Farben sind bewusst NICHT Teil von M1 (Feinschliff
+ * folgt in M3/M6, dann nur an der Token-Quelle).
+ */
+export declare const supaHighlightStyle: HighlightStyle;
+/** Fertige Extension: Syntax-Highlighting mit dem SupaMDE-Stil. */
+export declare const highlightExtension: Extension;

package/dist/editor/link-click.d.ts

@@ -0,0 +1,53 @@
+import type { EditorState, Extension } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+/**
+ * Normalisiert den Text eines nackten `URL`-Knotens (GFM-Autoerkennung ohne
+ * Link/Autolink-Elternknoten) zu einer vollständigen URL mit Schema.
+ *
+ * - Steht bereits ein Schema im Text (`http://`, `https://`, `mailto:`),
+ *   bleibt der Text unverändert (keine Verdopplung).
+ * - `www.example.com` bekommt das Schema `https://` vorangestellt.
+ * - Eine nackte E-Mail-Adresse (`@` enthalten, kein Schema) bekommt das
+ *   Präfix `mailto:` vorangestellt — ABER NUR, wenn `precedingChar` (das
+ *   Dokumentzeichen unmittelbar vor dem Knoten) keine Fortsetzung einer
+ *   größeren URL anzeigt (siehe `URL_CONTINUATION_CHARS`). Die Schema-Prüfung
+ *   läuft dabei ZUERST, damit z.B. `https://user@host/pfad` (URL mit
+ *   Benutzerteil, hier bereits vollständig im Knoten enthalten) nicht
+ *   fälschlich als E-Mail behandelt wird.
+ * - Erkennt die Kontextprüfung eine Fortsetzung, liefert die Funktion `null`
+ *   (konservativ: lieber kein Link öffnen als versehentlich das Mailprogramm).
+ * - Alles andere (z.B. bereits vollständige http/https-URLs) bleibt unverändert.
+ *
+ * Reine Funktion — ohne DOM/Editor-State testbar. `precedingChar` ist
+ * `undefined`, wenn der Knoten am Dokumentanfang steht.
+ */
+export declare function normalizeBareUrl(text: string, precedingChar: string | undefined): string | null;
+/**
+ * Liefert die Ziel-URL des Links an `pos`, oder `null`.
+ *
+ * Deckt drei Fälle ab: Markdown-Links (`[Text](url)`), Autolinks (`<url>`)
+ * und nackte URLs (GFM-Autoerkennung, `URL`-Knoten direkt unter `Paragraph`).
+ * Bei nackten URLs wird der Text normalisiert (`normalizeBareUrl`), bevor die
+ * Schema-Prüfung läuft.
+ *
+ * `null` bei: keinem Link an der Position, fehlendem URL-Knoten, oder einem
+ * normalisierten Schema außerhalb der Allowlist. Reine Funktion — ohne DOM
+ * testbar.
+ */
+export declare function linkUrlAt(state: EditorState, pos: number): string | null;
+/**
+ * Der mousedown-Handler als benannte Funktion: liefert `true`, wenn er den Klick
+ * behandelt hat (Link geöffnet), sonst `false`. Separat exportiert, damit sich
+ * die Entscheidungslogik ohne DOM-Layout testen lässt — `event.defaultPrevented`
+ * taugt dafür nicht, weil CodeMirror bei simuliertem mousedown selbst
+ * `preventDefault()` aufruft (auch mit leerer Extension-Liste).
+ */
+export declare function handleLinkMousedown(event: MouseEvent, view: EditorView): boolean;
+/**
+ * Cmd/Ctrl+Klick öffnet den Link unter dem Zeiger in einem neuen Tab.
+ *
+ * Bewusst MODUSUNABHÄNGIG (fest in der Extension-Liste, außerhalb des
+ * Live-Preview-Compartments) — es gibt keinen Grund, nützliche Navigation an den
+ * Darstellungsmodus zu koppeln.
+ */
+export declare const linkClickExtension: Extension;

package/dist/editor/link-hover-cursor.d.ts

@@ -0,0 +1,44 @@
+import { EditorView, ViewPlugin, type PluginValue, type ViewUpdate } from '@codemirror/view';
+/** CSS-Klasse auf `view.contentDOM`, die den Mauszeiger zur Klickhand macht. */
+export declare const LINK_HOVER_CLASS = "supamde-link-hover";
+/**
+ * Hält den Zustand "Zeiger steht auf einem klickbaren Link UND Modifier ist
+ * gedrückt" und spiegelt ihn als CSS-Klasse auf `view.contentDOM` — wie in
+ * VS Code soll der Mauszeiger dann zur Klickhand werden.
+ *
+ * Die Klasse muss laut Vorgabe SOFORT bei Tastendruck erscheinen (nicht erst
+ * bei der nächsten Mausbewegung) und sofort beim Loslassen verschwinden.
+ * Deshalb wird zusätzlich zu `mousemove` die zuletzt bekannte Mausposition
+ * vorgehalten und bei `keydown`/`keyup` sofort neu bewertet.
+ *
+ * `keydown`/`keyup` hängen bewusst am `window` und nicht am `view.contentDOM`:
+ * Modifier-Tasten sollen auch dann erkannt werden, wenn der Editor gerade
+ * nicht fokussiert ist (z.B. Fokus in einem Toolbar-Button), weil der Nutzer
+ * die Taste schon VOR dem Zurückbewegen der Maus in den Editor drücken kann.
+ * Ein Editor-lokaler Listener würde dieses Timing verpassen.
+ */
+declare class LinkHoverCursorPlugin implements PluginValue {
+    private view;
+    private lastX;
+    private lastY;
+    private hasMousePosition;
+    private modifierDown;
+    private readonly onMouseMove;
+    private readonly onKeyDown;
+    private readonly onKeyUp;
+    private readonly onBlur;
+    constructor(view: EditorView);
+    update(_update: ViewUpdate): void;
+    destroy(): void;
+    private updateState;
+    private pointerIsOverLink;
+}
+/**
+ * Zeigt beim Hover mit gedrücktem Cmd/Ctrl-Modifier über einem klickbaren
+ * Link den Mauszeiger als Klickhand (`cursor: pointer`) — wie in VS Code.
+ * Die CSS-Regel dazu steht in `theme.ts` (`.${LINK_HOVER_CLASS}`).
+ *
+ * Modusunabhängig einzuhängen, analog zu `linkClickExtension`.
+ */
+export declare const linkHoverCursorExtension: ViewPlugin<LinkHoverCursorPlugin, undefined>;
+export {};

package/dist/editor/math.d.ts

@@ -0,0 +1,8 @@
+import type { MarkdownConfig } from '@lezer/markdown';
+/**
+ * Lezer-Markdown-Extension, die LaTeX-Bereiche (`$…$`, `$$…$$`) als eigene,
+ * in sich geschlossene Knoten erkennt. Ohne dies parst der Standard-Parser
+ * den Inhalt als normalen Markdown-Fließtext, wodurch z. B. `**…**` oder
+ * `[…]()` innerhalb einer Formel fälschlich als Fett/Link interpretiert wird.
+ */
+export declare const Math: MarkdownConfig;

package/dist/editor/setup.d.ts

@@ -0,0 +1,26 @@
+import { EditorView } from '@codemirror/view';
+import type { Extension } from '@codemirror/state';
+import type { SupaMDEOptions } from '../options';
+import { type ResolvedOptions } from '../options';
+import type { UpdateSink } from '../ui/update-listener';
+/** Steuerungs-Handle über den erzeugten Editor inkl. Rückbau. */
+export interface EditorHandle {
+    /** Die zugrunde liegende CM6-EditorView. */
+    view: EditorView;
+    /** Baut den Editor zurück und liefert die wiederhergestellte Textarea. */
+    toTextArea(): HTMLTextAreaElement;
+    /** Schreibt den aktuellen Doc-Inhalt sofort in die Textarea. */
+    forceSync(): void;
+    /**
+     * Die normalisierten Optionen dieser Instanz. Herausgegeben, damit die Fassade
+     * (`src/index.ts`) sie NICHT erneut auflösen muss — `resolveOptions` läuft pro
+     * Instanz genau einmal, Warnungen erscheinen daher genau einmal.
+     */
+    resolved: ResolvedOptions;
+}
+/**
+ * CM6-Nachbau von `fromTextArea`: erzeugt eine EditorView aus dem Textarea-
+ * Inhalt, fügt sie davor ein, versteckt die Textarea und hält den Form-Submit-
+ * Wert synchron. Der Textarea-Wert ist die Quelle NUR bei Konstruktion.
+ */
+export declare function editorFromTextArea(options: SupaMDEOptions, sink?: UpdateSink, extraExtensions?: Extension[]): EditorHandle;

package/dist/editor/theme.d.ts

@@ -0,0 +1,7 @@
+import type { Extension } from '@codemirror/state';
+/**
+ * Basis-Erscheinungsbild des SupaMDE-Editors (Container, Font, Padding).
+ * Ersetzt das CM5-'easymde'-Theme. Farben/Font stammen aus `tokens.ts`;
+ * Feinschliff (Farben/Abstände) folgt in M3/M6, dann nur an der Token-Quelle.
+ */
+export declare const supaTheme: Extension;

package/dist/editor/tokens.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Geteilte Style-Tokens für Highlight (`highlight.ts`) und Theme (`theme.ts`).
+ * EINE Quelle für Farben und Font-Stack, damit der Feinschliff in M3/M6 nur hier
+ * ansetzt. Exakte Werte sind bewusst vorläufig (easyMDE-Look, keine px-Parität).
+ */
+/** Kern-Farbwerte des SupaMDE-Basis-Looks. */
+export declare const colors: {
+    /** Blockquote-Text (gedämpftes Grau). */
+    readonly quote: "#6a737d";
+    /** Links (GitHub-Blau). */
+    readonly link: "#0366d6";
+    /** Container-Rahmen. */
+    readonly border: "#ddd";
+};
+/** System-Font-Stack (kein Web-Font-Load in M1). */
+export declare const fontStack = "system-ui, -apple-system, \"Segoe UI\", Roboto, sans-serif";

package/dist/editor/value.d.ts

@@ -0,0 +1,10 @@
+import type { EditorView } from '@codemirror/view';
+/**
+ * Headless value-Logik über einer `EditorView`. Bewusst aus der `SupaMDE`-
+ * Fassade herausgezogen: so ist sie ohne Textarea/Konstruktor testbar (Spec
+ * Abschnitt 3) und in M2 (Commands) wiederverwendbar.
+ */
+/** Liefert den aktuellen Editor-Inhalt als String. */
+export declare function readValue(view: EditorView): string;
+/** Ersetzt den gesamten Editor-Inhalt durch `val`. */
+export declare function writeValue(view: EditorView, val: string): void;

package/dist/features/autosave.d.ts

@@ -0,0 +1,31 @@
+import { type SupaStorage } from './storage';
+/** Konfiguration des Autosave. */
+export interface AutosaveOptions {
+    /** Aktiviert Autosave. Default: false. */
+    enabled?: boolean;
+    /** Pflicht. Identifiziert das Dokument im Speicher. */
+    key: string;
+    /** Debounce nach der letzten Änderung, in ms. Default: 1000. */
+    delay?: number;
+    /** Eigener Speicher. Default: localStorage unter `supamde:<key>`. */
+    storage?: SupaStorage;
+    /** Wird gerufen, wenn beim Start ein Entwurf geladen wurde. */
+    onRestore?: (saved: string) => void;
+}
+/** Die Hooks, über die Autosave das Dokument erreicht — ohne CM6-Abhängigkeit. */
+export interface AutosaveHooks {
+    getValue(): string;
+    setValue(value: string): void;
+    onSaved(time: Date): void;
+}
+/** Das Steuerungs-Handle über eine Autosave-Instanz. */
+export interface Autosave {
+    start(): Promise<void>;
+    schedule(): void;
+    clear(): Promise<void>;
+    stop(): void;
+    isActive(): boolean;
+}
+/** Default-Debounce in Millisekunden. */
+export declare const DEFAULT_AUTOSAVE_DELAY = 1000;
+export declare function createAutosave(options: AutosaveOptions, hooks: AutosaveHooks): Autosave;

package/dist/features/image-upload.d.ts

@@ -0,0 +1,73 @@
+import type { EditorView } from '@codemirror/view';
+import { type Translator } from '../i18n/translator';
+/**
+ * Ein Upload-Fehler — strukturiert statt vorformatiert, damit der Host selbst
+ * darstellen und übersetzen kann.
+ */
+export interface UploadError {
+    kind: 'too-large' | 'type-not-allowed' | 'upload-failed';
+    file: File;
+    /** Der ursprüngliche Fehler aus `upload()`, bei `kind === 'upload-failed'`. */
+    cause?: unknown;
+}
+/** Konfiguration des Bild-Uploads. */
+export interface UploadImageOptions {
+    /** Aktiviert den Bild-Upload. Default: false. */
+    enabled?: boolean;
+    /** Pflicht. Lädt die Datei hoch und liefert die URL; wirft bei Fehler. */
+    upload: (file: File) => Promise<string>;
+    /** Maximale Dateigröße in Bytes. Default: 2 MB. */
+    maxSize?: number;
+    /** Erlaubte MIME-Typen. */
+    accept?: string[];
+    /** Wird bei jedem Fehler gerufen. Default: keiner (nur Statusbar). */
+    onError?: (error: UploadError) => void;
+}
+/** Das Steuerungs-Handle über den Uploader. */
+export interface ImageUploader {
+    uploadFiles(files: FileList | File[]): void;
+    /** Die erlaubten MIME-Typen — für das `accept`-Attribut des File-Inputs. */
+    accept(): string[];
+    isActive(): boolean;
+    /**
+     * Räumt den Rückfall-Timer ab. Beim Rückbau des Editors zu rufen — sonst
+     * feuerte er nach `toTextArea()` gegen eine bereits zerstörte Statusbar.
+     * Laufende Uploads werden NICHT abgebrochen: Ihre `upload()`-Promise gehört
+     * dem Host, und ihr Ergebnis findet über den dann leeren Platzhalter-Bereich
+     * ohnehin kein Ziel mehr.
+     */
+    destroy(): void;
+}
+/** Default-Obergrenze: 2 MB. */
+export declare const DEFAULT_UPLOAD_MAX_SIZE: number;
+/** Default-Liste erlaubter MIME-Typen. */
+export declare const DEFAULT_UPLOAD_ACCEPT: string[];
+/** Anzeigedauer der Erfolgsmeldung, bevor auf `statusInit` zurückgefallen wird. */
+export declare const STATUS_DONE_MS = 2000;
+/** Anzeigedauer der Fehlermeldung. Länger, weil sie gelesen werden muss. */
+export declare const STATUS_ERROR_MS = 6000;
+/**
+ * Die Markdown-Textform eines fertigen Bildes.
+ *
+ * Bewusst NICHT über `insertImage()` aus `commands/link-image.ts`: Jenes fügt an
+ * der aktuellen SELEKTION ein — genau der Weg, den die Positionsregel verbietet.
+ * Der Upload muss an der gemappten Platzhalter-Position ersetzen, nicht an der
+ * Cursorposition. Geteilt wird deshalb nur die Textform, hier als eine Zeile.
+ */
+export declare function imageMarkdown(alt: string, url: string): string;
+/**
+ * Prüft eine Datei. `null` heißt: in Ordnung. Größe zuerst — eine zu große
+ * Datei ist auch dann zu groß, wenn ihr Typ zusätzlich nicht passt, und die
+ * Größe ist die häufigere Ursache.
+ */
+export declare function validateFile(file: File, opts: {
+    maxSize: number;
+    accept: string[];
+}): UploadError['kind'] | null;
+/**
+ * Erzeugt den Uploader. `translator` liefert Platzhalter und Statusmeldungen
+ * (`upload.*`-Schlüssel); ohne Angabe englisch.
+ */
+export declare function createImageUploader(view: EditorView, options: UploadImageOptions, hooks: {
+    setStatus(text: string): void;
+}, translator?: Translator): ImageUploader;

package/dist/features/storage.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Der Speicher-Vertrag des Autosave. Async-fähig, damit ein Server-Backend oder
+ * IndexedDB ohne Zusatzschicht passt — die eingebaute localStorage-Variante ist
+ * synchron, SupaMDE behandelt beide Fälle über `await` gleich.
+ */
+export interface SupaStorage {
+    load(key: string): string | null | Promise<string | null>;
+    save(key: string, value: string): void | Promise<void>;
+    clear(key: string): void | Promise<void>;
+}
+/** Default-Prefix im localStorage: Einträge liegen unter `supamde:<key>`. */
+export declare const STORAGE_PREFIX = "supamde:";
+/** localStorage-Implementierung. Synchron; wirft bei Quota/Private Mode durch. */
+export declare function createLocalStorage(prefix?: string): SupaStorage;
+/**
+ * In-Memory-Speicher. Primär als Testdouble gedacht, aber auch als bewusste
+ * Host-Wahl brauchbar ("nur für diese Sitzung merken").
+ */
+export declare function createMemoryStorage(): SupaStorage;
+/**
+ * Probe-Schreibvorgang: schreibt einen Wegwerf-Eintrag, liest ihn zurück und
+ * räumt ihn wieder ab. Fängt JEDEN Wurf — im Private Mode wirft schon der
+ * Zugriff auf `localStorage`, nicht erst `setItem`.
+ *
+ * Wichtig: Die Verfügbarkeit ist nur die halbe Miete. Der spätere `save()` mit
+ * echtem Inhalt läuft trotzdem in `try/catch` (siehe `autosave.ts`) — easyMDE
+ * prüfte nur mit einem Ein-Byte-Probeschreiben und ließ die echte
+ * Quota-Exception beim Speichern großer Inhalte ungefangen durchschlagen.
+ */
+export declare function isStorageAvailable(storage: SupaStorage): Promise<boolean>;

package/dist/features/upload-dom.d.ts

@@ -0,0 +1,20 @@
+import type { Extension } from '@codemirror/state';
+/**
+ * Die Bilddateien aus einem DataTransfer. Nicht-Bilder werden hier bereits
+ * ausgesiebt: Ein Drop mit einem PDF darf NICHT als Bild-Upload gelten und soll
+ * ungestört den Standardweg gehen.
+ */
+export declare function imageFilesFrom(data: DataTransfer | null): File[];
+/**
+ * Drop- und Paste-Handler. Greift NUR ein, wenn Bilddateien im Spiel sind —
+ * reiner Text-Drop und Text-Paste laufen unverändert durch den CM6-Standardweg.
+ */
+export declare function uploadDropPasteExtension(onFiles: (files: File[]) => void): Extension;
+/**
+ * Öffnet die Dateiauswahl über einen bei Bedarf erzeugten, versteckten Input.
+ *
+ * Bewusst NICHT in der Toolbar geparkt: So funktioniert `openBrowseFileWindow()`
+ * auch bei `toolbar: false` — bei easyMDE warf derselbe Aufruf ohne Toolbar
+ * einen Fehler, weil der Input am Toolbar-DOM hing.
+ */
+export declare function openFilePicker(accept: string[], onFiles: (files: File[]) => void): void;

package/dist/features/upload-placeholder.d.ts

@@ -0,0 +1,35 @@
+import { StateField, type EditorState } from '@codemirror/state';
+/** Der aktuelle Bereich eines offenen Platzhalters im Dokument. */
+export interface PlaceholderRange {
+    from: number;
+    to: number;
+}
+/** Nimmt einen neuen Platzhalter unter `id` in die Verfolgung auf. */
+export declare const addPlaceholder: import("@codemirror/state").StateEffectType<{
+    id: number;
+    from: number;
+    to: number;
+}>;
+/** Nimmt den Platzhalter mit dieser `id` wieder heraus. */
+export declare const removePlaceholder: import("@codemirror/state").StateEffectType<number>;
+/**
+ * Hält die offenen Platzhalter und mappt sie bei JEDER Transaktion durch
+ * `tr.changes`. Bewusst ein StateField und kein Instanzfeld mit gemerkten
+ * Zahlen: Genau daran scheiterte easyMDE — dort wurde das fertige Bild
+ * nachträglich am dann-aktuellen Cursor eingefügt, sodass es bei Weitertippen
+ * an falscher Stelle landete.
+ */
+export declare const uploadPlaceholderField: StateField<Map<number, PlaceholderRange>>;
+/**
+ * Der AKTUELLE Bereich eines Platzhalters, oder `null`, wenn er nicht mehr
+ * existiert. Die einzige erlaubte Quelle für die Ersetzungsposition.
+ */
+export declare function placeholderRange(state: EditorState, id: number): PlaceholderRange | null;
+/**
+ * Erzeugt eine unabhängige ID-Quelle. Bewusst eine Factory statt eines
+ * modul-globalen Zählers: Der wäre gemeinsamer Zustand über alle Instanzen und
+ * alle Testdateien hinweg und machte jeden Test auf eine konkrete ID von der
+ * Ausführungsreihenfolge abhängig. Eindeutigkeit ist nur PRO View nötig — die
+ * IDs sind Schlüssel in der Map genau eines `uploadPlaceholderField`.
+ */
+export declare function createIdSource(): () => number;

package/dist/features/word-count.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Zählt Wörter in `text`: durch Whitespace getrennte, nicht-leere Tokens.
+ * Reine Funktion — das neue Sicherheitsnetz, das easyMDE fehlt.
+ */
+export declare function wordCount(text: string): number;

package/dist/i18n/de.d.ts

@@ -0,0 +1,3 @@
+import type { Locale } from './types';
+/** Deutsch — die bis zur Internationalisierung fest verdrahteten Texte. Reine Daten. */
+export declare const de: Locale;

package/dist/i18n/en.d.ts

@@ -0,0 +1,3 @@
+import type { Locale } from './types';
+/** Englisch — Default-Sprache und Rückfall für fehlende Schlüssel. Reine Daten. */
+export declare const en: Locale;

package/dist/i18n/facet.d.ts

@@ -0,0 +1,9 @@
+import { Facet } from '@codemirror/state';
+import { type Translator } from './translator';
+/**
+ * Der Translator im Editor-State. Commands sind reine `(view) => boolean`-
+ * Funktionen ohne Zugriff auf die SupaMDE-Instanz; die Facet ist der
+ * idiomatische CM6-Weg, ihnen Konfiguration mitzugeben. Ohne Provider (z. B. in
+ * Unit-Tests ohne Instanz) gilt Englisch.
+ */
+export declare const translatorFacet: Facet<Translator, Translator>;

package/dist/i18n/translator.d.ts

@@ -0,0 +1,17 @@
+import type { Locale, LocaleTexts, PluralTextKey, SimpleTextKey } from './types';
+/** Liefert die UI-Texte einer Instanz. Einmal pro Instanz erzeugt, danach unveränderlich. */
+export interface Translator {
+    /** Effektiver Locale-Code (nach Gültigkeitsprüfung). */
+    readonly code: string;
+    /** Einfacher Text mit Platzhaltern. */
+    t(key: SimpleTextKey, params?: Record<string, string>): string;
+    /** Pluralform zu `count`; setzt `{count}` und weitere Platzhalter ein. */
+    plural(key: PluralTextKey, count: number, params?: Record<string, string>): string;
+    /** Uhrzeit HH:MM im Format des Locale-Codes. */
+    formatTime(date: Date): string;
+}
+/**
+ * Baut den Translator einer Instanz. Rangfolge pro Schlüssel:
+ * `texts` → `locale.texts` → `en.texts`.
+ */
+export declare function createTranslator(locale?: Locale, texts?: Partial<LocaleTexts>): Translator;