@plebeiantech/lat.md 0.12.3-fork.2 → 0.12.3-fork.20

package/dist/src/view/markdown.d.ts

@@ -1,8 +1,13 @@
 import type { Root } from 'mdast';
+import type { ViewDocumentTree } from './protocol.js';
 export type WikiLinkContext = {
     line: number;
 };
-export type WikiLinkResolver = (target: string, context: WikiLinkContext) => string | null | Promise<string | null>;
+export type WikiLinkResolution = {
+    href: string;
+    referenceCount: number;
+};
+export type WikiLinkResolver = (target: string, context: WikiLinkContext) => WikiLinkResolution | null | Promise<WikiLinkResolution | null>;
 export type MarkdownRenderOptions = {
     activeMarkdownLink?: string;
     activeWikiLink?: string;
@@ -15,8 +20,8 @@ export type MarkdownRenderOptions = {
     lineOffset?: number;
     rewriteMarkdownLink?: (url: string) => string;
 };
-/** Render a lat.md file as safe HTML with resolved wiki links. */
+/** Normalize a lat.md file into the safe, parser-neutral view tree. */
 export declare function renderMarkdown(markdown: string, filePath: string, resolveWikiLink?: WikiLinkResolver, options?: MarkdownRenderOptions, parsedTree?: Root): Promise<{
-    html: string;
+    tree: ViewDocumentTree;
     title: string;
 }>;

package/dist/src/view/markdown.js

@@ -1,28 +1,82 @@
 import { basename, extname } from 'node:path';
 import rehypeSanitize, { defaultSchema } from 'rehype-sanitize';
+import rehypeRaw from 'rehype-raw';
+import rehypeKatex from 'rehype-katex';
 import rehypeSlug from 'rehype-slug';
-import rehypeStringify from 'rehype-stringify';
+import remarkEmoji from 'remark-emoji';
 import remarkRehype from 'remark-rehype';
 import { unified } from 'unified';
 import { visit } from 'unist-util-visit';
-import { parse } from '../parser.js';
+import { parse } from '@plebeiantech/lat.md-core/parser';
+import { decorateExternalSiteLinks, toViewDocumentTree, } from './document-tree.js';
+import { highlightCode } from './highlight.js';
 const CODE_LINK_CLASSES = [
     'wiki-link-code',
     'wiki-link-active',
     'code-link-language',
+    'code-link-leading',
     'code-language-ts',
     'code-language-js',
     'code-language-py',
+    'code-language-rb',
     'code-language-rs',
     'code-language-go',
     'code-language-c',
+    'code-language-dart',
+    'code-language-java',
 ];
 const ERROR_CLASS = 'markdown-error';
 const GIT_CLASSES = ['git-added', 'git-removed'];
-function classAttributes(tag) {
+const GEOJSON_SOURCE_CLASS = 'markdown-geojson-source';
+const HIGHLIGHT_CLASS = 'hljs';
+const MERMAID_SOURCE_CLASS = 'markdown-mermaid-source';
+const MATH_DIFF_BLOCK_CLASS = 'git-math-block';
+const RICH_FENCE_SOURCE_CLASS = 'markdown-diagram-source';
+const STL_SOURCE_CLASS = 'markdown-stl-source';
+const TOPOJSON_SOURCE_CLASS = 'markdown-topojson-source';
+const ALERT_KINDS = ['note', 'tip', 'important', 'warning', 'caution'];
+const ALERT_CLASSES = [
+    'markdown-alert',
+    'markdown-alert-title',
+    ...ALERT_KINDS.map((kind) => `markdown-alert-${kind}`),
+];
+const GITHUB_CUSTOM_EMOJI = new Set([
+    'atom',
+    'basecamp',
+    'basecampy',
+    'bowtie',
+    'electron',
+    'feelsgood',
+    'finnadie',
+    'fishsticks',
+    'fu',
+    'goberserk',
+    'godmode',
+    'hurtrealbad',
+    'neckbeard',
+    'octocat',
+    'rage1',
+    'rage2',
+    'rage3',
+    'rage4',
+    'shipit',
+    'suspect',
+    'trollface',
+]);
+function classAttributes(tag, extraClasses = []) {
+    const attributes = defaultSchema.attributes?.[tag] ?? [];
+    const allowedClasses = attributes.flatMap((attribute) => Array.isArray(attribute) && attribute[0] === 'className'
+        ? attribute.slice(1)
+        : []);
     return [
-        ...(defaultSchema.attributes?.[tag] ?? []),
-        ['className', ERROR_CLASS, ...GIT_CLASSES],
+        ...attributes.filter((attribute) => !(Array.isArray(attribute) && attribute[0] === 'className')),
+        [
+            'className',
+            ...allowedClasses,
+            ERROR_CLASS,
+            ...GIT_CLASSES,
+            ...extraClasses,
+        ],
     ];
 }
 const sanitizeSchema = {
@@ -43,39 +97,146 @@ const sanitizeSchema = {
             ],
         ],
         blockquote: classAttributes('blockquote'),
-        code: classAttributes('code'),
+        code: classAttributes('code', [
+            HIGHLIGHT_CLASS,
+            'math-display',
+            'math-inline',
+        ]),
         del: classAttributes('del'),
-        div: classAttributes('div'),
+        details: [...(defaultSchema.attributes?.details ?? []), ['open', true]],
+        div: classAttributes('div', [...ALERT_CLASSES, MATH_DIFF_BLOCK_CLASS]),
         h1: classAttributes('h1'),
         h2: classAttributes('h2'),
         h3: classAttributes('h3'),
         h4: classAttributes('h4'),
         h5: classAttributes('h5'),
         h6: classAttributes('h6'),
-        img: classAttributes('img'),
+        img: classAttributes('img', ['markdown-emoji']),
+        input: [...(defaultSchema.attributes?.input ?? []), ['checked', true]],
         ins: classAttributes('ins'),
         li: classAttributes('li'),
-        p: classAttributes('p'),
-        pre: classAttributes('pre'),
+        ol: classAttributes('ol'),
+        p: classAttributes('p', ALERT_CLASSES),
+        pre: classAttributes('pre', [
+            GEOJSON_SOURCE_CLASS,
+            MERMAID_SOURCE_CLASS,
+            RICH_FENCE_SOURCE_CLASS,
+            STL_SOURCE_CLASS,
+            TOPOJSON_SOURCE_CLASS,
+        ]),
         span: [
             ...(defaultSchema.attributes?.span ?? []),
             'ariaHidden',
+            'ariaLabel',
+            'role',
             [
                 'className',
                 'wiki-link-context',
                 'wiki-link-leaf',
+                'wiki-link-ref-count',
                 ...CODE_LINK_CLASSES.slice(2),
+                /^hljs-./,
                 ERROR_CLASS,
                 ...GIT_CLASSES,
             ],
         ],
+        table: classAttributes('table'),
+        tr: classAttributes('tr'),
+        ul: classAttributes('ul'),
     },
 };
-const htmlProcessor = unified()
-    .use(remarkRehype)
+const highlightedCodeHandler = (state, rawNode) => {
+    const node = rawNode;
+    const language = node.lang?.split(/\s+/, 1)[0];
+    const richSourceClass = language?.toLowerCase() === 'mermaid'
+        ? MERMAID_SOURCE_CLASS
+        : language?.toLowerCase() === 'geojson'
+            ? GEOJSON_SOURCE_CLASS
+            : language?.toLowerCase() === 'topojson'
+                ? TOPOJSON_SOURCE_CLASS
+                : language?.toLowerCase() === 'stl'
+                    ? STL_SOURCE_CLASS
+                    : null;
+    const highlighted = language && !richSourceClass ? highlightCode(language, node.value) : null;
+    const code = {
+        type: 'element',
+        tagName: 'code',
+        properties: {
+            className: [
+                ...(language ? [`language-${language}`] : []),
+                ...(highlighted === null ? [] : [HIGHLIGHT_CLASS]),
+            ],
+        },
+        children: highlighted === null
+            ? [
+                {
+                    type: 'text',
+                    value: node.value ? `${node.value}\n` : '',
+                },
+            ]
+            : [...highlighted.children, { type: 'text', value: '\n' }],
+        ...(node.meta ? { data: { meta: node.meta } } : {}),
+    };
+    state.patch(node, code);
+    const result = state.applyData(node, code);
+    const pre = {
+        type: 'element',
+        tagName: 'pre',
+        properties: {
+            className: richSourceClass
+                ? [RICH_FENCE_SOURCE_CLASS, richSourceClass]
+                : [],
+        },
+        children: [result],
+    };
+    state.patch(node, pre);
+    return pre;
+};
+const documentTreeProcessor = unified()
+    .use(remarkRehype, {
+    allowDangerousHtml: true,
+    handlers: { code: highlightedCodeHandler },
+})
+    .use(rehypeRaw)
     .use(rehypeSanitize, sanitizeSchema)
-    .use(rehypeSlug)
-    .use(rehypeStringify);
+    .use(rehypeKatex)
+    .use(rehypeSlug);
+const emojiProcessor = unified().use(remarkEmoji, { accessible: true });
+function transformCustomEmoji(tree) {
+    visit(tree, 'text', (node, index, parent) => {
+        if (index === undefined || !parent || !node.value.includes(':'))
+            return;
+        const pattern = /:([a-z0-9_+-]+):/g;
+        const children = [];
+        let cursor = 0;
+        let match;
+        while ((match = pattern.exec(node.value))) {
+            if (!GITHUB_CUSTOM_EMOJI.has(match[1]))
+                continue;
+            if (match.index > cursor) {
+                children.push({
+                    type: 'text',
+                    value: node.value.slice(cursor, match.index),
+                });
+            }
+            children.push({
+                type: 'image',
+                url: `https://github.githubassets.com/images/icons/emoji/${match[1]}.png?v8`,
+                alt: match[0],
+                title: null,
+                data: { hProperties: { className: ['markdown-emoji'] } },
+            });
+            cursor = match.index + match[0].length;
+        }
+        if (children.length === 0)
+            return;
+        if (cursor < node.value.length) {
+            children.push({ type: 'text', value: node.value.slice(cursor) });
+        }
+        parent.children.splice(index, 1, ...children);
+        return index + children.length;
+    });
+}
 function nodeText(node) {
     if (typeof node.value === 'string')
         return node.value;
@@ -85,6 +246,38 @@ function nodeText(node) {
         .map((child) => nodeText(child))
         .join('');
 }
+function transformAlerts(tree) {
+    visit(tree, 'blockquote', (node) => {
+        const firstBlock = node.children[0];
+        if (firstBlock?.type !== 'paragraph')
+            return;
+        const firstInline = firstBlock.children[0];
+        if (firstInline?.type !== 'alertMarker')
+            return;
+        const label = firstInline.value;
+        const kind = label.toLowerCase();
+        firstBlock.children.shift();
+        if (firstBlock.children.length === 0)
+            node.children.shift();
+        node.data = {
+            ...node.data,
+            hName: 'div',
+            hProperties: {
+                ...(node.data?.hProperties ?? {}),
+                className: ['markdown-alert', `markdown-alert-${kind}`],
+            },
+        };
+        node.children.unshift({
+            type: 'paragraph',
+            data: {
+                hProperties: { className: ['markdown-alert-title'] },
+            },
+            children: [
+                { type: 'text', value: label[0] + label.slice(1).toLowerCase() },
+            ],
+        });
+    });
+}
 function wikiLinkContent(node) {
     if (node.data.alias) {
         return {
@@ -131,6 +324,10 @@ function codeLanguage(target) {
             return { className: 'code-language-js', label: 'JS' };
         case '.py':
             return { className: 'code-language-py', label: 'PY' };
+        case '.erb':
+        case '.rake':
+        case '.rb':
+            return { className: 'code-language-rb', label: 'RB' };
         case '.rs':
             return { className: 'code-language-rs', label: 'RS' };
         case '.go':
@@ -138,6 +335,10 @@ function codeLanguage(target) {
         case '.c':
         case '.h':
             return { className: 'code-language-c', label: 'C' };
+        case '.dart':
+            return { className: 'code-language-dart', label: 'DART' };
+        case '.java':
+            return { className: 'code-language-java', label: 'JAVA' };
         default:
             return null;
     }
@@ -155,6 +356,45 @@ function languageIcon(language) {
         children: [{ type: 'text', value: language.label }],
     };
 }
+function codeLinkContent(language, children) {
+    const [first, ...rest] = children;
+    if (!first)
+        return [languageIcon(language)];
+    let leading = first;
+    let remainder = null;
+    if (first.type === 'text') {
+        const breakAt = first.value.search(/\s/);
+        if (breakAt > 0) {
+            leading = { ...first, value: first.value.slice(0, breakAt) };
+            remainder = { ...first, value: first.value.slice(breakAt) };
+        }
+    }
+    return [
+        {
+            type: 'emphasis',
+            data: {
+                hName: 'span',
+                hProperties: { className: ['code-link-leading'] },
+            },
+            children: [languageIcon(language), leading],
+        },
+        ...(remainder ? [remainder] : []),
+        ...rest,
+    ];
+}
+function referenceCountBadge(count) {
+    return {
+        type: 'emphasis',
+        data: {
+            hName: 'span',
+            hProperties: {
+                className: ['wiki-link-ref-count'],
+                ariaLabel: `${count} ${count === 1 ? 'reference' : 'references'}`,
+            },
+        },
+        children: [{ type: 'text', value: String(count) }],
+    };
+}
 function targetMatches(node, target) {
     if (node.type === 'wikiLink') {
         return node.value.toLowerCase() === target.toLowerCase();
@@ -223,30 +463,41 @@ function markMarkdownErrors(tree, errors) {
         };
     }
 }
-/** Render a lat.md file as safe HTML with resolved wiki links. */
+/** Normalize a lat.md file into the safe, parser-neutral view tree. */
 export async function renderMarkdown(markdown, filePath, resolveWikiLink, options = {}, parsedTree) {
     const tree = parsedTree ? structuredClone(parsedTree) : parse(markdown);
     tree.children = tree.children.filter((node) => node.type !== 'yaml');
+    await emojiProcessor.run(tree);
+    transformCustomEmoji(tree);
+    transformAlerts(tree);
     if (options.errors)
         markMarkdownErrors(tree, options.errors);
-    if (options.rewriteMarkdownLink || options.activeMarkdownLink) {
-        visit(tree, 'link', (node) => {
-            const authoredUrl = node.url;
-            if (options.activeMarkdownLink &&
-                authoredUrl === options.activeMarkdownLink) {
-                node.data = {
-                    ...node.data,
-                    hProperties: {
-                        ...(node.data?.hProperties ?? {}),
-                        className: ['wiki-link-active'],
-                    },
-                };
-            }
-            if (options.rewriteMarkdownLink) {
-                node.url = options.rewriteMarkdownLink(authoredUrl);
-            }
-        });
-    }
+    visit(tree, 'link', (node) => {
+        const authoredUrl = node.url;
+        if (options.activeMarkdownLink &&
+            authoredUrl === options.activeMarkdownLink) {
+            node.data = {
+                ...node.data,
+                hProperties: {
+                    ...(node.data?.hProperties ?? {}),
+                    className: ['wiki-link-active'],
+                },
+            };
+        }
+        if (options.rewriteMarkdownLink) {
+            node.url = options.rewriteMarkdownLink(authoredUrl);
+        }
+    });
+    visit(tree, 'image', (node) => {
+        if (options.rewriteMarkdownLink) {
+            node.url = options.rewriteMarkdownLink(node.url);
+        }
+    });
+    visit(tree, 'definition', (node) => {
+        if (options.rewriteMarkdownLink) {
+            node.url = options.rewriteMarkdownLink(node.url);
+        }
+    });
     const firstHeading = tree.children.find((node) => node.type === 'heading');
     const title = firstHeading
         ? nodeText(firstHeading)
@@ -266,11 +517,12 @@ export async function renderMarkdown(markdown, filePath, resolveWikiLink, option
     visit(tree, 'wikiLink', (node, index, parent) => {
         if (index === undefined || !parent || !('children' in parent))
             return;
-        const href = resolvedLinks.get(node);
+        const resolution = resolvedLinks.get(node);
         const markedProperties = node.data?.hProperties;
-        if (href) {
+        if (resolution) {
+            const { href, referenceCount } = resolution;
             const content = wikiLinkContent(node);
-            const language = href.startsWith('/code/')
+            const language = href.startsWith('/code/') || href.startsWith('/external/')
                 ? codeLanguage(node.value)
                 : null;
             const classes = content.segmented ? ['wiki-link-segmented'] : [];
@@ -296,9 +548,12 @@ export async function renderMarkdown(markdown, filePath, resolveWikiLink, option
                         },
                     }
                     : undefined,
-                children: language
-                    ? [languageIcon(language), ...content.children]
-                    : content.children,
+                children: [
+                    ...(language
+                        ? codeLinkContent(language, content.children)
+                        : content.children),
+                    ...(referenceCount > 1 ? [referenceCountBadge(referenceCount)] : []),
+                ],
             };
             return;
         }
@@ -317,6 +572,18 @@ export async function renderMarkdown(markdown, filePath, resolveWikiLink, option
                 value: `[[${node.value}${alias}]]`,
             };
     });
-    const hast = await htmlProcessor.run(tree);
-    return { html: htmlProcessor.stringify(hast), title };
+    const hast = await documentTreeProcessor.run(tree);
+    // Attach source ranges after sanitization, before positions are discarded.
+    visit(hast, 'element', (node) => {
+        if (!/^(p|pre|li|tr|h[1-6])$/.test(node.tagName) || !node.position)
+            return;
+        node.properties['data-source-start-line'] =
+            node.position.start.line + (options.lineOffset ?? 0);
+        node.properties['data-source-end-line'] =
+            node.position.end.line + (options.lineOffset ?? 0);
+    });
+    return {
+        tree: decorateExternalSiteLinks(toViewDocumentTree(hast)),
+        title,
+    };
 }

package/dist/src/view/preindexed-search.d.ts

@@ -0,0 +1,15 @@
+import type { Section } from '@plebeiantech/lat.md-core/lattice-model';
+import type { CreateSearchEngine } from '../search/embedder.js';
+import { type IndexedSearchSession } from '../search/query.js';
+import type { ViewSearchResponse } from './protocol.js';
+export type PreindexedViewSearchDependencies = {
+    openSearchSession: (latDir: string, options: {
+        cacheDir?: string;
+        createSearchEngine?: CreateSearchEngine;
+    }) => Promise<IndexedSearchSession>;
+};
+export type PreindexedViewSearch = ((query: string) => Promise<ViewSearchResponse>) & {
+    close: () => Promise<void>;
+};
+/** Serve a built search index without importing indexing or Markdown parsers. */
+export declare function createPreindexedViewSearch(latDir: string, cacheDir: string, sections: readonly Section[], documentPaths: ReadonlyMap<string, string>, dependencies?: PreindexedViewSearchDependencies, createSearchEngine?: CreateSearchEngine): Promise<PreindexedViewSearch>;

package/dist/src/view/preindexed-search.js

@@ -0,0 +1,25 @@
+import { openIndexedSearchSession, resolveSearchMatches, } from '../search/query.js';
+import { viewSearchResult } from './search-result.js';
+const VIEW_SEARCH_LIMIT = 10;
+/** Serve a built search index without importing indexing or Markdown parsers. */
+export async function createPreindexedViewSearch(latDir, cacheDir, sections, documentPaths, dependencies = {
+    openSearchSession: openIndexedSearchSession,
+}, createSearchEngine) {
+    const sectionById = new Map(sections.map((section) => [section.id.toLowerCase(), section]));
+    const session = await dependencies.openSearchSession(latDir, {
+        cacheDir,
+        createSearchEngine,
+    });
+    const search = async (rawQuery) => {
+        const query = rawQuery.trim();
+        if (!query)
+            return { query: '', results: [] };
+        const results = await session.search(query, VIEW_SEARCH_LIMIT);
+        return {
+            query,
+            results: resolveSearchMatches(results, sectionById).map((match) => viewSearchResult(latDir, match, documentPaths)),
+        };
+    };
+    search.close = session.close;
+    return search;
+}

package/dist/src/view/protocol.d.ts

@@ -1,13 +1,24 @@
+import type { SearchEvidence } from '../search/types.js';
 export type ViewGitFileStatus = 'modified' | 'new';
 export type ViewGitState = {
     files: Record<string, ViewGitFileStatus>;
 };
+export type ViewExternalFile = {
+    handle: string;
+    path: string;
+    target: string;
+};
 export type ViewIndex = {
     files: string[];
+    /** Authored directory-index entries, keyed by vault-relative directory ('' at root). */
+    directoryOrder: Record<string, string[]>;
+    externalFiles: ViewExternalFile[];
     entry: string;
     errorCounts: Record<string, number>;
     git: ViewGitState | null;
+    logoText: string;
 };
+export declare const DEFAULT_VIEW_LOGO_TEXT = "lat.md";
 export type ViewDocumentError = {
     anchor: string;
     line: number;
@@ -22,32 +33,101 @@ export type ViewSearchResult = {
     breadcrumbs: string[];
     description: string;
     url: string;
+    rankScore: number;
+    introduction: string;
+    evidence: SearchEvidence[];
+    semanticSimilarity?: number;
+    semanticRank?: number;
+    lexicalRank?: number;
 };
 export type ViewSearchResponse = {
     query: string;
     results: ViewSearchResult[];
 };
-export type ViewProjectChange = {
+import type { ViewDocumentTree } from '@plebeiantech/lat.md-core/document-tree';
+export type { ViewDocumentProperty, ViewDocumentText, ViewDocumentElement, ViewDocumentNode, ViewDocumentTree, } from '@plebeiantech/lat.md-core/document-tree';
+export type ViewSectionCommandOutput = {
+    output: string;
+    tree: ViewDocumentTree;
+    isError: boolean;
+};
+export type ViewProjectGeneration = {
     generation: number;
     markdownGeneration: number;
 };
+export type ViewProjectChange = ViewProjectGeneration & {
+    instanceId: string;
+};
+export type ViewGraphNodeKind = 'document' | 'source' | 'code-reference';
+export type ViewGraphNode = {
+    id: string;
+    kind: ViewGraphNodeKind;
+    label: string;
+    url: string;
+    breadcrumbs: string[];
+    /** Local documents sum direct backlink counts across every heading. Other nodes use incoming edge weights. */
+    inDegree: number;
+    outDegree: number;
+    documentPath?: string;
+    sectionId?: string;
+    sourcePath?: string;
+    symbol?: string;
+    line?: number;
+    snippet?: string;
+    externalTarget?: string;
+    gitStatus?: ViewGitFileStatus;
+    errorCount?: number;
+};
+export type ViewGraphEdgeKind = 'wiki' | 'markdown' | 'source' | 'code-mention';
+export type ViewGraphEdge = {
+    id: string;
+    from: string;
+    to: string;
+    kind: ViewGraphEdgeKind;
+    weight: number;
+};
+export type ViewGraph = {
+    generation: number;
+    nodes: ViewGraphNode[];
+    edges: ViewGraphEdge[];
+};
+export type ViewDocumentTocItem = {
+    id: string;
+    title: string;
+    depth: number;
+    errorCount: number;
+    hasGitChanges: boolean;
+};
 export type ViewDocument = {
     path: string;
     title: string;
-    html: string;
-    gitHtml: string | null;
+    tree: ViewDocumentTree;
+    gitTree: ViewDocumentTree | null;
+    graphNodeIds: Record<string, string>;
+    tableOfContents: ViewDocumentTocItem[];
     errors: ViewDocumentError[];
     backReferences: ViewSectionBackReferences[];
     frontmatter: {
         requireCodeMention: boolean;
     };
 };
+export type ViewDocumentSource = {
+    path: string;
+    content: string;
+};
+export type ViewDocumentEditRequest = {
+    baseContent: string;
+    content: string;
+};
+export type ViewDocumentEditResponse = ViewDocumentSource & {
+    merged: boolean;
+};
 export type ViewMarkdownBackReference = {
     kind: 'markdown';
     sectionId: string;
     breadcrumbs: string[];
     paragraph: string;
-    paragraphHtml: string;
+    paragraphTree: ViewDocumentTree;
     url: string;
 };
 export type ViewCodeBackReference = {
@@ -67,13 +147,13 @@ export type ViewSourceReference = {
     sectionId: string;
     breadcrumbs: string[];
     paragraph: string;
-    paragraphHtml: string;
+    paragraphTree: ViewDocumentTree;
     url: string;
 };
 export type ViewSourceDocument = {
     path: string;
     content: string;
-    highlightedHtmlLines: string[];
+    highlightedLines: ViewDocumentTree[];
     focus: {
         symbol: string;
         kind: string;
@@ -84,6 +164,15 @@ export type ViewSourceDocument = {
     context: ViewSourceReference | null;
     otherReferences: ViewSourceReference[];
 };
+export type ViewExternalDocument = {
+    kind: 'markdown';
+    target: string;
+    document: ViewDocument;
+} | {
+    kind: 'source';
+    target: string;
+    source: ViewSourceDocument;
+};
 export type ViewError = {
     error: string;
 };