omni-viewer-core 0.1.0

package/dist/viewers/jsonl/controller.js

@@ -0,0 +1,136 @@
+import { parseJsonl } from '../../parsers/jsonl/index.js';
+const concat = (a, b) => {
+    const result = new Uint8Array(a.length + b.length);
+    result.set(a);
+    result.set(b, a.length);
+    return result;
+};
+/** Only newline-terminated records are visible during preview; the trailing
+ * bytes are the JNL3 continuation buffer and become a record only at done. */
+const finalized = (data, done) => {
+    if (done)
+        return data;
+    for (let i = data.length - 1; i >= 0; i--)
+        if (data[i] === 0x0a)
+            return data.slice(0, i + 1);
+    return new Uint8Array();
+};
+export function createJsonlController(input) {
+    const paged = typeof input !== 'string' && 'initialData' in input ? input : null;
+    let bytes = paged ? paged.initialData : typeof input === 'string' ? new TextEncoder().encode(input) : input;
+    let nextId = 1;
+    const parsedInitial = parseJsonl(finalized(bytes, !paged?.loadMore)).result;
+    let entries = parsedInitial.status === 'failed' ? [] : parsedInitial.document.entries.map(entry => ({ ...entry, id: `source:${entry.line}` }));
+    const state = {
+        status: parsedInitial.status,
+        loadState: paged?.loadMore ? 'preview' : 'complete', entries, search: '', selected: new Set(), dirty: false,
+        diagnostics: parsedInitial.diagnostics, visibleCount: 5_000
+    };
+    const listeners = new Set();
+    const notify = () => listeners.forEach(listener => listener(state));
+    let selectionAnchor = null;
+    const editable = () => state.loadState === 'complete';
+    const renumber = () => entries.forEach((entry, index) => { entry.line = index + 1; });
+    const lineEnding = () => entries.find(e => e.lineEnding)?.lineEnding === '\r\n' ? '\r\n' : '\n';
+    const parseEntry = (raw, id, line) => {
+        const result = parseJsonl(raw).result;
+        const entry = result.status === 'failed' ? undefined : result.document.entries[0];
+        return entry ? { ...entry, id, line, lineEnding: lineEnding() } : { id, line, raw, lineEnding: lineEnding(), value: null, diagnostics: [] };
+    };
+    const reparseBytes = (done) => {
+        const result = parseJsonl(finalized(bytes, done)).result;
+        if (result.status === 'failed') {
+            state.status = 'failed';
+            state.diagnostics = result.diagnostics;
+            return;
+        }
+        const existing = new Map(entries.filter(e => e.id.startsWith('source:')).map(e => [`source:${e.line}`, e.id]));
+        entries = result.document.entries.map(entry => ({ ...entry, id: existing.get(`source:${entry.line}`) ?? `source:${entry.line}` }));
+        state.entries = entries;
+        state.status = result.status;
+        state.diagnostics = result.diagnostics;
+    };
+    const loadMore = async () => {
+        if (!paged?.loadMore || state.loadState !== 'preview')
+            return;
+        state.loadState = 'loading';
+        notify();
+        try {
+            const page = await paged.loadMore();
+            bytes = concat(bytes, page.data);
+            reparseBytes(page.done);
+            state.loadState = page.done ? 'complete' : 'preview';
+        }
+        catch {
+            state.diagnostics = [...state.diagnostics, { severity: 'error', code: 'jsonl.load-failed', messageKey: 'diag.jsonl.load-failed' }];
+            state.loadState = 'preview';
+        }
+        notify();
+    };
+    const loadAll = async () => { while (state.loadState === 'preview')
+        await loadMore(); };
+    return {
+        state,
+        subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+        serialize: () => entries.map((entry, i) => entry.raw + (i === entries.length - 1 ? entry.lineEnding : entry.lineEnding || lineEnding())).join(''),
+        canSave: () => editable() && entries.every(entry => !entry.raw.trim() || !entry.diagnostics.some(diagnostic => diagnostic.code === 'invalid-jsonl-line')),
+        dispatch(action) {
+            if (action.type === 'load-more')
+                return loadMore();
+            if (action.type === 'load-all')
+                return loadAll();
+            if (action.type === 'set-search')
+                state.search = action.search;
+            else if (action.type === 'select') {
+                const selected = action.additive ? new Set(state.selected) : new Set();
+                if (action.range && selectionAnchor) {
+                    const a = entries.findIndex(e => e.id === selectionAnchor), b = entries.findIndex(e => e.id === action.id);
+                    if (a >= 0 && b >= 0)
+                        for (let i = Math.min(a, b); i <= Math.max(a, b); i++)
+                            selected.add(entries[i].id);
+                }
+                else {
+                    selected.has(action.id) && action.additive ? selected.delete(action.id) : selected.add(action.id);
+                    selectionAnchor = action.id;
+                }
+                state.selected = selected;
+            }
+            else if (action.type === 'edit' && editable()) {
+                const index = entries.findIndex(e => e.id === action.id);
+                if (index >= 0) {
+                    const old = entries[index];
+                    entries[index] = parseEntry(action.raw, old.id, old.line);
+                    state.entries = entries;
+                    state.dirty = true;
+                }
+            }
+            else if (action.type === 'insert' && editable()) {
+                const id = `inserted:${nextId++}`;
+                entries.push(parseEntry(action.raw ?? '{}', id, entries.length + 1));
+                state.entries = entries;
+                state.dirty = true;
+            }
+            else if (action.type === 'delete-selected' && editable()) {
+                entries = entries.filter(e => !state.selected.has(e.id));
+                renumber();
+                state.entries = entries;
+                state.selected = new Set();
+                state.dirty = true;
+            }
+            else if (action.type === 'move' && editable()) {
+                const from = entries.findIndex(e => e.id === action.from);
+                const to = entries.findIndex(e => e.id === action.to);
+                if (from >= 0 && to >= 0) {
+                    const item = entries.splice(from, 1)[0];
+                    if (item) {
+                        entries.splice(to, 0, item);
+                        renumber();
+                        state.entries = entries;
+                        state.dirty = true;
+                    }
+                }
+            }
+            notify();
+        }
+    };
+}

package/dist/viewers/jsonl/index.d.ts

@@ -0,0 +1,22 @@
+import type { ClipboardService, FileSaveService, FileWritebackService, HostContext } from '../../host/index.js';
+import type { JsonlPagedInput } from '../../parsers/jsonl/index.js';
+import type { MountOptions, ViewerHandle, ViewerInput } from '../types.js';
+export * from './controller.js';
+export { jsonlViewerCss } from './styles.js';
+export declare const JSONL_VIEWER_META: {
+    id: string;
+    displayNameKey: string;
+    extensions: string[];
+    priority: number;
+    requiredServices: readonly [];
+    optionalServices: readonly ["clipboard", "save", "writeback"];
+    inputOwnership: "borrows";
+};
+export interface JsonlMountOptions extends MountOptions {
+    pagedInput?: JsonlPagedInput;
+}
+export declare function mountJsonlViewer(input: ViewerInput, container: HTMLElement, ctx: HostContext & {
+    clipboard?: ClipboardService;
+    save?: FileSaveService;
+    writeback?: FileWritebackService;
+}, options?: JsonlMountOptions): Promise<ViewerHandle>;

package/dist/viewers/jsonl/index.js

@@ -0,0 +1,184 @@
+import { asciiLower } from '../../parsers/csv/index.js';
+import { VIEWER_ROOT_CLASS } from '../types.js';
+import { createJsonlController } from './controller.js';
+import { jsonlViewerCss } from './styles.js';
+export * from './controller.js';
+export { jsonlViewerCss } from './styles.js';
+export const JSONL_VIEWER_META = { id: 'jsonl', displayNameKey: 'jsonl.title', extensions: ['jsonl', 'ndjson', 'jsonlines'], priority: 10, requiredServices: [], optionalServices: ['clipboard', 'save', 'writeback'], inputOwnership: 'borrows' };
+export async function mountJsonlViewer(input, container, ctx, options = {}) {
+    let root;
+    if ((options.styleIsolation ?? 'shadow') === 'shadow' && typeof container.attachShadow === 'function') {
+        root = container.shadowRoot ?? container.attachShadow({ mode: 'open' });
+        const style = document.createElement('style');
+        style.textContent = jsonlViewerCss;
+        root.append(style);
+    }
+    else {
+        container.classList.add(VIEWER_ROOT_CLASS, 'omni-viewer--jsonl');
+        root = container;
+    }
+    const controller = createJsonlController(options.pagedInput ?? input.data);
+    const el = (tag, text) => { const n = document.createElement(tag); if (text !== undefined)
+        n.textContent = text; return n; };
+    const frame = el('div');
+    frame.className = 'omni-jsonl';
+    frame.tabIndex = 0;
+    root.append(frame);
+    let editing = null, detail = null, dragged = null, disposed = false;
+    const visible = { count: 5_000 };
+    const save = async () => { if (!controller.canSave())
+        return; const data = new TextEncoder().encode(controller.serialize()); if (ctx.writeback)
+        await ctx.writeback.write(data);
+    else if (ctx.save)
+        await ctx.save.saveFile(input.fileName, data, 'application/x-ndjson'); };
+    const selectedEntry = () => controller.state.entries.find(entry => controller.state.selected.has(entry.id));
+    const keydown = (event) => { if (event.target.matches('input,textarea'))
+        return; if (event.key === 'Escape') {
+        editing = detail = null;
+        controller.state.selected.forEach(() => undefined);
+        render();
+    }
+    else if ((event.key === 'Delete' || event.key === 'Backspace') && controller.state.loadState === 'complete') {
+        event.preventDefault();
+        controller.dispatch({ type: 'delete-selected' });
+    }
+    else if (event.key === 'Enter') {
+        const entry = selectedEntry();
+        if (entry) {
+            editing = entry.id;
+            render();
+        }
+    } };
+    frame.addEventListener('keydown', keydown);
+    const unsubscribe = controller.subscribe(() => { if (!disposed)
+        render(); });
+    function syntax(parent, raw) {
+        const pattern = /("(?:\\.|[^"\\])*"(?=\s*:))|("(?:\\.|[^"\\])*")|\b(true|false|null)\b|-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/gi;
+        let offset = 0;
+        for (const match of raw.matchAll(pattern)) {
+            const index = match.index;
+            parent.append(document.createTextNode(raw.slice(offset, index)));
+            const token = el('span', match[0]);
+            token.className = match[1] ? 'omni-jsonl__key' : match[2] ? 'omni-jsonl__string' : /true|false|null/i.test(match[0]) ? 'omni-jsonl__literal' : 'omni-jsonl__number';
+            parent.append(token);
+            offset = index + match[0].length;
+        }
+        parent.append(document.createTextNode(raw.slice(offset)));
+    }
+    function render() {
+        frame.replaceChildren();
+        const state = controller.state;
+        const bar = el('div');
+        bar.className = 'omni-jsonl__bar';
+        const search = el('input');
+        search.type = 'search';
+        search.placeholder = ctx.i18n.t('structured.search');
+        search.value = state.search;
+        search.addEventListener('input', () => controller.dispatch({ type: 'set-search', search: search.value }));
+        const add = el('button', ctx.i18n.t('jsonl.add'));
+        add.disabled = state.loadState !== 'complete';
+        add.addEventListener('click', () => controller.dispatch({ type: 'insert' }));
+        const remove = el('button', ctx.i18n.t('jsonl.delete'));
+        remove.disabled = state.loadState !== 'complete' || !state.selected.size;
+        remove.addEventListener('click', () => controller.dispatch({ type: 'delete-selected' }));
+        const more = el('button', ctx.i18n.t('jsonl.loadMore'));
+        more.disabled = state.loadState !== 'preview';
+        more.addEventListener('click', () => void controller.dispatch({ type: 'load-more' }));
+        const all = el('button', ctx.i18n.t('jsonl.loadAll'));
+        all.disabled = state.loadState !== 'preview';
+        all.addEventListener('click', () => void controller.dispatch({ type: 'load-all' }));
+        const saveButton = el('button', ctx.i18n.t('jsonl.save'));
+        saveButton.disabled = !controller.canSave() || (!ctx.writeback && !ctx.save);
+        saveButton.title = controller.canSave() ? '' : ctx.i18n.t('jsonl.invalidSave');
+        saveButton.addEventListener('click', () => void save());
+        bar.append(search, add, remove, more, all, saveButton);
+        frame.append(bar);
+        if (state.loadState !== 'complete') {
+            const banner = el('div', ctx.i18n.t('jsonl.preview'));
+            banner.className = 'omni-jsonl__banner';
+            frame.append(banner);
+        }
+        const rows = el('div');
+        rows.className = 'omni-jsonl__rows';
+        const query = asciiLower(state.search);
+        const filtered = state.entries.filter(entry => !query || asciiLower(`${entry.raw} ${pretty(entry)}`).includes(query));
+        for (const entry of filtered.slice(0, visible.count))
+            rows.append(renderRow(entry));
+        if (filtered.length > visible.count) {
+            const batch = el('button', ctx.i18n.t('jsonl.showMore'));
+            batch.addEventListener('click', () => { visible.count += 5_000; render(); });
+            rows.append(batch);
+        }
+        frame.append(rows);
+    }
+    function renderRow(entry) {
+        const row = el('div');
+        row.className = `omni-jsonl__row${entry.value ? '' : ' omni-jsonl__invalid'}`;
+        row.tabIndex = 0;
+        row.draggable = controller.state.loadState === 'complete';
+        row.dataset.id = entry.id;
+        row.setAttribute('aria-selected', String(controller.state.selected.has(entry.id)));
+        row.setAttribute('aria-label', ctx.i18n.t(entry.value ? 'jsonl.rowValid' : 'jsonl.rowInvalid', { line: entry.line }));
+        const line = el('span', String(entry.line));
+        const code = el('code');
+        syntax(code, entry.raw);
+        row.append(line, code);
+        const actions = el('span');
+        actions.className = 'omni-jsonl__actions';
+        const copy = el('button', ctx.i18n.t('structured.copyValue'));
+        copy.disabled = !ctx.clipboard;
+        copy.addEventListener('click', event => { event.stopPropagation(); void ctx.clipboard?.writeText(entry.raw); });
+        const edit = el('button', ctx.i18n.t('jsonl.edit'));
+        edit.disabled = controller.state.loadState !== 'complete';
+        edit.addEventListener('click', event => { event.stopPropagation(); editing = entry.id; render(); });
+        actions.append(copy, edit);
+        row.append(actions);
+        row.addEventListener('click', event => { controller.dispatch({ type: 'select', id: entry.id, additive: event.metaKey || event.ctrlKey, range: event.shiftKey }); detail = entry.id; });
+        row.addEventListener('focus', () => { detail = entry.id; renderDetail(row, entry); });
+        row.addEventListener('mouseenter', () => renderDetail(row, entry));
+        row.addEventListener('dragstart', () => { dragged = entry.id; });
+        row.addEventListener('dragover', event => event.preventDefault());
+        row.addEventListener('drop', event => { event.preventDefault(); if (dragged && dragged !== entry.id)
+            controller.dispatch({ type: 'move', from: dragged, to: entry.id }); dragged = null; });
+        if (editing === entry.id) {
+            const box = el('div');
+            box.className = 'omni-jsonl__editor';
+            const textarea = el('textarea');
+            textarea.value = entry.raw;
+            const error = el('div');
+            const apply = el('button', ctx.i18n.t('jsonl.apply'));
+            const cancel = el('button', ctx.i18n.t('jsonl.cancel'));
+            const validate = () => { try {
+                JSON.parse(textarea.value);
+                error.textContent = '';
+                apply.disabled = false;
+            }
+            catch (reason) {
+                error.textContent = String(reason);
+                apply.disabled = true;
+            } };
+            textarea.addEventListener('input', validate);
+            apply.addEventListener('click', () => { controller.dispatch({ type: 'edit', id: entry.id, raw: textarea.value }); editing = null; });
+            cancel.addEventListener('click', () => { editing = null; render(); });
+            validate();
+            box.append(textarea, error, apply, cancel);
+            row.append(box);
+        }
+        if (detail === entry.id)
+            renderDetail(row, entry);
+        return row;
+    }
+    function renderDetail(row, entry) { row.querySelector('.omni-jsonl__detail')?.remove(); const panel = el('pre', pretty(entry)); panel.className = 'omni-jsonl__detail'; row.append(panel); }
+    function pretty(entry) { if (!entry.raw.trim())
+        return ''; try {
+        return JSON.stringify(JSON.parse(entry.raw), null, 2);
+    }
+    catch {
+        return entry.raw;
+    } }
+    render();
+    return { dispose() { disposed = true; unsubscribe(); frame.removeEventListener('keydown', keydown); frame.remove(); if (root instanceof ShadowRoot)
+            root.replaceChildren();
+        else
+            container.classList.remove(VIEWER_ROOT_CLASS, 'omni-viewer--jsonl'); } };
+}

package/dist/viewers/jsonl/styles.d.ts

@@ -0,0 +1 @@
+export declare const jsonlViewerCss = ":host,.omni-viewer--jsonl{display:block;height:100%;color:var(--omni-fg,#ddd);background:var(--omni-bg,#1e1e1e);font:13px var(--omni-font,system-ui)}.omni-jsonl{height:100%;display:flex;flex-direction:column}.omni-jsonl__bar{display:flex;gap:5px;padding:6px;border-bottom:1px solid var(--omni-border,#444)}.omni-jsonl input,.omni-jsonl button,.omni-jsonl textarea{font:inherit;background:var(--omni-button-bg,#333);color:inherit;border:1px solid var(--omni-border,#555);padding:3px 7px}.omni-jsonl__banner{padding:6px;color:var(--omni-fg-muted,#999)}.omni-jsonl__rows{overflow:auto;font-family:var(--omni-font-mono,monospace)}.omni-jsonl__row{position:relative;display:grid;grid-template-columns:4em minmax(0,1fr) auto;gap:8px;padding:5px 8px;cursor:pointer}.omni-jsonl__row[aria-selected=true]{background:var(--omni-selection,#264f78)}.omni-jsonl__invalid{color:var(--omni-error,#f48771)}.omni-jsonl__actions{display:flex;gap:4px}.omni-jsonl__detail,.omni-jsonl__editor{grid-column:2/-1;white-space:pre-wrap;background:var(--omni-input-bg,#171717);padding:10px;z-index:2}.omni-jsonl__editor textarea{display:block;box-sizing:border-box;width:100%;min-height:8em}.omni-jsonl__key{color:#9cdcfe}.omni-jsonl__string{color:#ce9178}.omni-jsonl__number{color:#b5cea8}.omni-jsonl__literal{color:#569cd6}";

package/dist/viewers/jsonl/styles.js

@@ -0,0 +1 @@
+export const jsonlViewerCss = `:host,.omni-viewer--jsonl{display:block;height:100%;color:var(--omni-fg,#ddd);background:var(--omni-bg,#1e1e1e);font:13px var(--omni-font,system-ui)}.omni-jsonl{height:100%;display:flex;flex-direction:column}.omni-jsonl__bar{display:flex;gap:5px;padding:6px;border-bottom:1px solid var(--omni-border,#444)}.omni-jsonl input,.omni-jsonl button,.omni-jsonl textarea{font:inherit;background:var(--omni-button-bg,#333);color:inherit;border:1px solid var(--omni-border,#555);padding:3px 7px}.omni-jsonl__banner{padding:6px;color:var(--omni-fg-muted,#999)}.omni-jsonl__rows{overflow:auto;font-family:var(--omni-font-mono,monospace)}.omni-jsonl__row{position:relative;display:grid;grid-template-columns:4em minmax(0,1fr) auto;gap:8px;padding:5px 8px;cursor:pointer}.omni-jsonl__row[aria-selected=true]{background:var(--omni-selection,#264f78)}.omni-jsonl__invalid{color:var(--omni-error,#f48771)}.omni-jsonl__actions{display:flex;gap:4px}.omni-jsonl__detail,.omni-jsonl__editor{grid-column:2/-1;white-space:pre-wrap;background:var(--omni-input-bg,#171717);padding:10px;z-index:2}.omni-jsonl__editor textarea{display:block;box-sizing:border-box;width:100%;min-height:8em}.omni-jsonl__key{color:#9cdcfe}.omni-jsonl__string{color:#ce9178}.omni-jsonl__number{color:#b5cea8}.omni-jsonl__literal{color:#569cd6}`;

package/dist/viewers/markdown/controller.d.ts

@@ -0,0 +1,50 @@
+import type { MarkdownHeading } from '../../parsers/markdown/index.js';
+export type MarkdownViewMode = 'preview' | 'split' | 'source';
+export type MarkdownAction = {
+    type: 'set-mode';
+    mode: MarkdownViewMode;
+} | {
+    type: 'set-search';
+    query: string;
+} | {
+    type: 'next-match';
+} | {
+    type: 'select-heading';
+    id: string;
+} | {
+    type: 'edit-source';
+    source: string;
+} | {
+    type: 'undo';
+} | {
+    type: 'redo';
+} | {
+    type: 'mark-saved';
+} | {
+    type: 'copy-code';
+    code: string;
+};
+export interface MarkdownMatch {
+    start: number;
+    end: number;
+}
+export interface MarkdownViewState {
+    mode: MarkdownViewMode;
+    query: string;
+    matchIndex: number;
+    selectedHeading?: string;
+    source: string;
+    savedSource: string;
+    dirty: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+}
+export interface MarkdownController {
+    readonly state: MarkdownViewState;
+    dispatch(action: MarkdownAction): void;
+    matches(): readonly MarkdownMatch[];
+    subscribe(listener: () => void): () => void;
+}
+/** State shared by the preview and source editor. History is kept here rather
+ * than relying on a textarea's platform-specific undo implementation. */
+export declare function createMarkdownController(text: string, _headings: readonly MarkdownHeading[]): MarkdownController;

package/dist/viewers/markdown/controller.js

@@ -0,0 +1,62 @@
+/** State shared by the preview and source editor. History is kept here rather
+ * than relying on a textarea's platform-specific undo implementation. */
+export function createMarkdownController(text, _headings) {
+    let state = {
+        mode: 'preview', query: '', matchIndex: 0, source: text, savedSource: text,
+        dirty: false, canUndo: false, canRedo: false
+    };
+    const undo = [];
+    const redo = [];
+    const listeners = new Set();
+    const emit = () => listeners.forEach(listener => listener());
+    const setSource = (source) => {
+        state = { ...state, source, dirty: source !== state.savedSource, canUndo: undo.length > 0, canRedo: redo.length > 0 };
+    };
+    const matches = () => {
+        const needle = state.query.toLocaleLowerCase();
+        if (!needle)
+            return [];
+        const haystack = state.source.toLocaleLowerCase();
+        const result = [];
+        for (let at = haystack.indexOf(needle); at >= 0; at = haystack.indexOf(needle, at + Math.max(1, needle.length))) {
+            result.push({ start: at, end: at + needle.length });
+        }
+        return result;
+    };
+    return {
+        get state() { return state; },
+        dispatch(action) {
+            if (action.type === 'set-mode')
+                state = { ...state, mode: action.mode };
+            else if (action.type === 'set-search')
+                state = { ...state, query: action.query, matchIndex: 0 };
+            else if (action.type === 'next-match') {
+                const count = matches().length;
+                state = { ...state, matchIndex: count ? (state.matchIndex + 1) % count : 0 };
+            }
+            else if (action.type === 'select-heading')
+                state = { ...state, selectedHeading: action.id };
+            else if (action.type === 'edit-source' && action.source !== state.source) {
+                undo.push(state.source);
+                if (undo.length > 100)
+                    undo.shift();
+                redo.length = 0;
+                setSource(action.source);
+            }
+            else if (action.type === 'undo' && undo.length) {
+                redo.push(state.source);
+                setSource(undo.pop());
+            }
+            else if (action.type === 'redo' && redo.length) {
+                undo.push(state.source);
+                setSource(redo.pop());
+            }
+            else if (action.type === 'mark-saved') {
+                state = { ...state, savedSource: state.source, dirty: false };
+            }
+            emit();
+        },
+        matches,
+        subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); }
+    };
+}

package/dist/viewers/markdown/index.d.ts

@@ -0,0 +1,64 @@
+import type { ClipboardService, DocumentAssetsService, FileWritebackService, HostContext, NavigationService } from '../../host/index.js';
+import { type MarkdownParseOptions } from '../../parsers/markdown/index.js';
+import type { ResourceLimits } from '../../parsers/types.js';
+import { type MountOptions, type ViewerHandle, type ViewerInput } from '../types.js';
+export { parseMarkdown, type MarkdownDocument } from '../../parsers/markdown/index.js';
+export { markdownViewerCss } from './styles.js';
+export { createMarkdownController, type MarkdownAction, type MarkdownController, type MarkdownViewMode, type MarkdownViewState } from './controller.js';
+export { maskMathSegments, mathSegmentLiteral, type MathSegment, type MaskedMathSource } from './math.js';
+export declare const MARKDOWN_VIEWER_META: {
+    id: string;
+    displayNameKey: string;
+    extensions: string[];
+    priority: number;
+    requiredServices: readonly [];
+    optionalServices: readonly ["clipboard", "navigation", "documentAssets", "writeback"];
+    inputOwnership: "borrows";
+};
+export interface MarkdownRenderer {
+    parse(markdown: string): string;
+}
+export interface DomPurify {
+    sanitize(html: string, options: Record<string, unknown>): string;
+}
+export interface MarkdownHighlighter {
+    highlight(source: string, options: {
+        language: string;
+        ignoreIllegals: boolean;
+    }): {
+        value: string;
+        language?: string;
+    };
+    highlightAuto(source: string): {
+        value: string;
+        language?: string;
+    };
+    getLanguage(language: string): unknown;
+}
+export interface MarkdownDiagramRenderer {
+    renderMermaid?(id: string, source: string): Promise<string>;
+    renderPlantUml?(source: string, document: Document): SVGElement;
+}
+/** TeX → HTML (KaTeX renderToString shape). The output is sanitized before
+ *  insertion, so the renderer does not need to be trusted with the DOM. */
+export interface MarkdownMathRenderer {
+    renderToHtml(source: string, displayMode: boolean): string;
+}
+export interface MarkdownViewerDeps {
+    render: MarkdownRenderer;
+    createDOMPurify(window: Window): DomPurify;
+    highlighter?: MarkdownHighlighter;
+    diagrams?: MarkdownDiagramRenderer;
+    math?: MarkdownMathRenderer;
+}
+export type MarkdownViewerContext = HostContext & {
+    clipboard?: ClipboardService;
+    navigation?: NavigationService;
+    documentAssets?: DocumentAssetsService;
+    writeback?: FileWritebackService;
+};
+export interface MarkdownMountOptions extends MountOptions {
+    limits?: ResourceLimits;
+    markdownLimits?: MarkdownParseOptions['markdownLimits'];
+}
+export declare function mountMarkdownViewer(input: ViewerInput, container: HTMLElement, ctx: MarkdownViewerContext, deps: MarkdownViewerDeps, options?: MarkdownMountOptions): Promise<ViewerHandle>;