@kerebron/extension-lsp 0.4.1

package/esm/extension-autocomplete/src/createDefaultMatcher.js

@@ -0,0 +1,58 @@
+// source: https://stackoverflow.com/a/6969486
+export function escapeForRegEx(string) {
+    return string.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+export function createDefaultMatcher(config = {}) {
+    const char = config.char || '@';
+    const allowToIncludeChar = config.allowToIncludeChar || false;
+    const allowedPrefixes = config.allowedPrefixes || [' '];
+    const startOfLine = config.startOfLine || false;
+    return ($position) => {
+        const allowSpaces = config.allowSpaces && !allowToIncludeChar;
+        const escapedChar = escapeForRegEx(char);
+        const suffix = new RegExp(`\\s${escapedChar}$`);
+        const prefix = startOfLine ? '^' : '';
+        const finalEscapedChar = allowToIncludeChar ? '' : escapedChar;
+        const regexp = allowSpaces
+            ? new RegExp(`${prefix}${escapedChar}.*?(?=\\s${finalEscapedChar}|$)`, 'gm')
+            : new RegExp(`${prefix}(?:^)?${escapedChar}[^\\s${finalEscapedChar}]*`, 'gm');
+        const text = $position.nodeBefore?.isText && $position.nodeBefore.text;
+        if (!text) {
+            return null;
+        }
+        const textFrom = $position.pos - text.length;
+        const match = Array.from(text.matchAll(regexp)).pop();
+        if (!match || match.input === undefined || match.index === undefined) {
+            return null;
+        }
+        // JavaScript doesn't have lookbehinds. This hacks a check that first character
+        // is a space or the start of the line
+        const matchPrefix = match.input.slice(Math.max(0, match.index - 1), match.index);
+        const matchPrefixIsAllowed = new RegExp(`^[${allowedPrefixes?.join('')}\0]?$`)
+            .test(matchPrefix);
+        if (allowedPrefixes !== null && !matchPrefixIsAllowed) {
+            return null;
+        }
+        // The absolute position of the match in the document
+        const from = textFrom + match.index;
+        let to = from + match[0].length;
+        // Edge case handling; if spaces are allowed and we're directly in between
+        // two triggers
+        if (allowSpaces && suffix.test(text.slice(to - 1, to + 1))) {
+            match[0] += ' ';
+            to += 1;
+        }
+        // If the $position is located within the matched substring, return that range
+        if (from < $position.pos && to >= $position.pos) {
+            return {
+                range: {
+                    from,
+                    to,
+                },
+                query: match[0],
+                text: match[0],
+            };
+        }
+        return null;
+    };
+}

package/esm/extension-autocomplete/src/createRegexMatcher.d.ts

@@ -0,0 +1,4 @@
+import { AutocompleteMatcher } from './types.js';
+export declare function ensureAnchor(expr: RegExp, start: boolean): RegExp;
+export declare function createRegexMatcher(regexes: RegExp[]): AutocompleteMatcher;
+//# sourceMappingURL=createRegexMatcher.d.ts.map

package/esm/extension-autocomplete/src/createRegexMatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRegexMatcher.d.ts","sourceRoot":"","sources":["../../../src/extension-autocomplete/src/createRegexMatcher.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAmB,MAAM,YAAY,CAAC;AAElE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,UASxD;AAqBD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EAAE,GAChB,mBAAmB,CAmCrB"}

package/esm/extension-autocomplete/src/createRegexMatcher.js

@@ -0,0 +1,50 @@
+export function ensureAnchor(expr, start) {
+    let { source } = expr;
+    let addStart = start && source[0] != '^', addEnd = source[source.length - 1] != '$';
+    if (!addStart && !addEnd)
+        return expr;
+    return new RegExp(`${addStart ? '^' : ''}(?:${source})${addEnd ? '$' : ''}`, expr.flags ?? (expr.ignoreCase ? 'i' : ''));
+}
+function matchBefore($position, expr) {
+    const text = $position.nodeBefore?.isText && $position.nodeBefore.text;
+    if (!text) {
+        return null;
+    }
+    const textFrom = $position.pos - text.length;
+    const start = Math.max(textFrom, $position.pos - 250);
+    const str = text.slice();
+    const found = str.search(ensureAnchor(expr, false));
+    return found < 0
+        ? null
+        : { from: start + found, to: $position.pos, text: str.slice(found) };
+}
+export function createRegexMatcher(regexes) {
+    return ($position) => {
+        const text = $position.nodeBefore?.isText && $position.nodeBefore.text;
+        if (!text) {
+            return null;
+        }
+        const textFrom = $position.pos - text.length;
+        const matches = regexes.map((regex) => matchBefore($position, regex))
+            .filter((m) => !!m);
+        if (matches.length === 0) {
+            return null;
+        }
+        matches.sort((a, b) => b.text.length - a.text.length);
+        let from = matches[0].from;
+        let matchedText = matches[0].text;
+        let to = matches[0].to;
+        while (matchedText.match(/^\s/)) {
+            matchedText = matchedText.substring(1);
+            from++;
+        }
+        return {
+            range: {
+                from,
+                to,
+            },
+            query: matchedText,
+            text: matchedText,
+        };
+    };
+}

package/esm/extension-autocomplete/src/mod.d.ts

@@ -0,0 +1,3 @@
+export * from './ExtensionAutocomplete.js';
+export { createRegexMatcher } from './createRegexMatcher.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/extension-autocomplete/src/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/extension-autocomplete/src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}

package/esm/extension-autocomplete/src/mod.js

@@ -0,0 +1,2 @@
+export * from './ExtensionAutocomplete.js';
+export { createRegexMatcher } from './createRegexMatcher.js';

package/esm/extension-autocomplete/src/types.d.ts

@@ -0,0 +1,60 @@
+import type { ResolvedPos } from 'prosemirror-model';
+import type { TextRange } from '../../editor/src/mod.js';
+import { EditorView } from 'prosemirror-view';
+export type SuggestionMatch = {
+    range: TextRange;
+    query: string;
+    text: string;
+} | null;
+export type AutocompleteMatcher = (pos: ResolvedPos) => SuggestionMatch;
+export interface SuggestionKeyDownProps {
+    view: EditorView;
+    event: KeyboardEvent;
+    range: TextRange;
+}
+export interface AutocompleteRenderer<I = any, TSelected = any> {
+    onBeforeStart?: (props: SuggestionProps<I, TSelected>) => void;
+    onStart?: (props: SuggestionProps<I, TSelected>) => void;
+    onBeforeUpdate?: (props: SuggestionProps<I, TSelected>) => void;
+    onUpdate?: (props: SuggestionProps<I, TSelected>) => void;
+    onExit?: (props: SuggestionProps<I, TSelected>) => void;
+    onKeyDown?: (props: SuggestionKeyDownProps) => boolean;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+}
+export interface SuggestionProps<I = any, TSelected = any> {
+    /**
+     * The range of the suggestion.
+     */
+    range: TextRange;
+    /**
+     * The current suggestion query.
+     */
+    query: string;
+    /**
+     * The current suggestion text.
+     */
+    text: string;
+    /**
+     * The suggestion items array.
+     */
+    items: I[];
+    /**
+     * A function that is called when a suggestion is selected.
+     * @param props The props object.
+     * @returns void
+     */
+    command: (props: TSelected) => void;
+    /**
+     * The decoration node HTML element
+     * @default null
+     */
+    decorationNode: Element | null;
+    /**
+     * The function that returns the client rect
+     * @default null
+     * @example () => new DOMRect(0, 0, 0, 0)
+     */
+    clientRect?: (() => DOMRect | null) | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/esm/extension-autocomplete/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/extension-autocomplete/src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,IAAI,CAAC;AAET,MAAM,MAAM,mBAAmB,GAAG,CAAC,GAAG,EAAE,WAAW,KAAK,eAAe,CAAC;AAExE,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,SAAS,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB,CAAC,CAAC,GAAG,GAAG,EAAE,SAAS,GAAG,GAAG;IAC5D,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,IAAI,CAAC;IAC/D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,IAAI,CAAC;IACzD,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,IAAI,CAAC;IAChE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,IAAI,CAAC;IAC1D,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,IAAI,CAAC;IACxD,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,OAAO,CAAC;IAEvD,gBAAgB,CACd,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,kCAAkC,EAC5C,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAC1C,IAAI,CAAC;IACR,mBAAmB,CACjB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,kCAAkC,GAAG,IAAI,EACnD,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,GACvC,IAAI,CAAC;CACT;AAED,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,GAAG,EAAE,SAAS,GAAG,GAAG;IACvD;;OAEG;IACH,KAAK,EAAE,SAAS,CAAC;IAEjB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,KAAK,EAAE,CAAC,EAAE,CAAC;IAEX;;;;OAIG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IAEpC;;;OAGG;IACH,cAAc,EAAE,OAAO,GAAG,IAAI,CAAC;IAE/B;;;;OAIG;IACH,UAAU,CAAC,EAAE,CAAC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;CAC5C"}

package/esm/extension-autocomplete/src/types.js

@@ -0,0 +1 @@
+export {};

package/esm/extension-basic-editor/src/ExtensionHtml.d.ts

@@ -0,0 +1,15 @@
+import { Fragment, Node, type ParseOptions, Schema } from 'prosemirror-model';
+import { type Converter, type CoreEditor, Extension } from '../../editor/src/mod.js';
+export type CreateNodeFromContentOptions = {
+    parseOptions?: ParseOptions;
+    errorOnInvalidContent?: boolean;
+};
+export declare function getHTMLFromFragment(fragment: Fragment, schema: Schema): string;
+export declare function elementFromString(value: string): HTMLElement;
+export declare function createNodeFromHTML(content: string, schema: Schema, options?: CreateNodeFromContentOptions): Node;
+export declare function createFragmentFromHTML(content: string, schema: Schema, options?: CreateNodeFromContentOptions): Fragment;
+export declare class ExtensionHtml extends Extension {
+    name: string;
+    getConverters(editor: CoreEditor, schema: Schema): Record<string, Converter>;
+}
+//# sourceMappingURL=ExtensionHtml.d.ts.map

package/esm/extension-basic-editor/src/ExtensionHtml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionHtml.d.ts","sourceRoot":"","sources":["../../../src/extension-basic-editor/src/ExtensionHtml.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,QAAQ,EACR,IAAI,EACJ,KAAK,YAAY,EACjB,MAAM,EACP,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAErF,MAAM,MAAM,4BAA4B,GAAG;IACzC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,GACb,MAAM,CAaR;AAqBD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAQ5D;AA+BD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,IAAI,CAgBN;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,QAAQ,CAiBV;AAED,qBAAa,aAAc,SAAQ,SAAS;IAC1C,IAAI,SAAU;IAEL,aAAa,CACpB,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC;CAe7B"}

package/esm/extension-basic-editor/src/ExtensionHtml.js

@@ -0,0 +1,108 @@
+import { DOMParser, DOMSerializer, Schema, } from 'prosemirror-model';
+import { Extension } from '../../editor/src/mod.js';
+export function getHTMLFromFragment(fragment, schema) {
+    const document = globalThis.document;
+    const documentFragment = DOMSerializer.fromSchema(schema).serializeFragment(fragment, { document });
+    const temporaryDocument = document.implementation.createHTMLDocument();
+    const container = temporaryDocument.createElement('div');
+    container.appendChild(documentFragment);
+    return container.innerHTML;
+}
+const removeWhitespaces = (node) => {
+    const children = node.childNodes;
+    for (let i = children.length - 1; i >= 0; i -= 1) {
+        const child = children[i];
+        if (child.nodeType === 3 && child.nodeValue &&
+            /^(\n\s\s|\n)$/.test(child.nodeValue)) {
+            node.removeChild(child);
+        }
+        else if (child.nodeType === 1) {
+            removeWhitespaces(child);
+        }
+    }
+    return node;
+};
+export function elementFromString(value) {
+    // add a wrapper to preserve leading and trailing whitespace
+    const wrappedValue = `<body>${value}</body>`;
+    const html = new globalThis.DOMParser().parseFromString(wrappedValue, 'text/html').body;
+    return removeWhitespaces(html);
+}
+function prepareContentCheckSchema(schema) {
+    const contentCheckSchema = new Schema({
+        topNode: schema.spec.topNode,
+        marks: schema.spec.marks,
+        // Prosemirror's schemas are executed such that: the last to execute, matches last
+        // This means that we can add a catch-all node at the end of the schema to catch any content that we don't know how to handle
+        nodes: schema.spec.nodes.append({
+            __unknown__catch__all__node: {
+                content: 'inline*',
+                group: 'block',
+                parseDOM: [
+                    {
+                        tag: '*',
+                        getAttrs: (e) => {
+                            // Try to stringify the element for a more helpful error message
+                            const invalidContent = typeof e === 'string' ? e : e.outerHTML;
+                            throw new Error('Invalid HTML content', {
+                                cause: new Error(`Invalid element found: ${invalidContent}`),
+                            });
+                        },
+                    },
+                ],
+            },
+        }),
+    });
+    return contentCheckSchema;
+}
+export function createNodeFromHTML(content, schema, options) {
+    options = {
+        parseOptions: {},
+        ...options,
+    };
+    if (options.errorOnInvalidContent) {
+        const contentCheckSchema = prepareContentCheckSchema(schema);
+        DOMParser.fromSchema(contentCheckSchema).parse(elementFromString(content), options.parseOptions);
+    }
+    const parser = DOMParser.fromSchema(schema);
+    return parser.parse(elementFromString(content), options.parseOptions);
+}
+export function createFragmentFromHTML(content, schema, options) {
+    options = {
+        parseOptions: {},
+        ...options,
+    };
+    if (options.errorOnInvalidContent) {
+        const contentCheckSchema = prepareContentCheckSchema(schema);
+        DOMParser.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
+    }
+    const parser = DOMParser.fromSchema(schema);
+    return parser.parseSlice(elementFromString(content), options.parseOptions)
+        .content;
+}
+export class ExtensionHtml extends Extension {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'html'
+        });
+    }
+    getConverters(editor, schema) {
+        const config = this.config;
+        return {
+            'text/html': {
+                fromDoc: async (document) => {
+                    const html = getHTMLFromFragment(document.content, editor.schema);
+                    return new TextEncoder().encode(html);
+                },
+                toDoc: async (buffer) => {
+                    const html = new TextDecoder().decode(buffer);
+                    return createNodeFromHTML(html, editor.schema);
+                },
+            },
+        };
+    }
+}

package/esm/extension-lsp/src/DiagnosticPlugin.d.ts

@@ -0,0 +1,32 @@
+import { Plugin } from 'prosemirror-state';
+import { ExtensionLsp } from './ExtensionLsp.js';
+import { PositionMapper } from '../../extension-markdown/src/PositionMapper.js';
+interface LspRange {
+    line: number;
+    character: number;
+}
+interface DiagnosticsItem {
+    severity: number;
+    range: {
+        start: LspRange;
+        end: LspRange;
+    };
+    message: string;
+    source: string;
+    code: string;
+    data: any;
+}
+interface DiagnosticPluginState {
+    diagnostics: DiagnosticsItem[];
+    mapper?: PositionMapper;
+}
+interface DiagnosticConfig {
+}
+export declare class DiagnosticPlugin extends Plugin<DiagnosticPluginState> {
+    diagListener: ((event: Event) => void) | undefined;
+    listenerDisconnect: ((event: Event) => void) | undefined;
+    listenerChange: ((event: Event) => void) | undefined;
+    constructor(config: DiagnosticConfig, extension: ExtensionLsp);
+}
+export {};
+//# sourceMappingURL=DiagnosticPlugin.d.ts.map

package/esm/extension-lsp/src/DiagnosticPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DiagnosticPlugin.d.ts","sourceRoot":"","sources":["../../../src/extension-lsp/src/DiagnosticPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA0B,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,gDAAgD,CAAC;AAEhF,UAAU,QAAQ;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,eAAe;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE;QACL,KAAK,EAAE,QAAQ,CAAC;QAChB,GAAG,EAAE,QAAQ,CAAC;KACf,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,GAAG,CAAC;CACX;AAED,UAAU,qBAAqB;IAC7B,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAED,UAAU,gBAAgB;CACzB;AAID,qBAAa,gBAAiB,SAAQ,MAAM,CAAC,qBAAqB,CAAC;IACjE,YAAY,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IACnD,kBAAkB,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IACzD,cAAc,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;gBAEzC,MAAM,EAAE,gBAAgB,EAAE,SAAS,EAAE,YAAY;CA8J9D"}

package/esm/extension-lsp/src/DiagnosticPlugin.js

@@ -0,0 +1,131 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+const DiagnosticPluginKey = new PluginKey('lsp-diagnostic');
+export class DiagnosticPlugin extends Plugin {
+    constructor(config, extension) {
+        super({
+            key: DiagnosticPluginKey,
+            view(view) {
+                return {
+                    destroy: () => {
+                        const client = extension.getClient(extension.mainLang);
+                        if (this.listener && client) {
+                            client.removeEventListener('textDocument/publishDiagnostics', this.listener);
+                        }
+                        if (this.listenerDisconnect && client) {
+                            client.removeEventListener('close', this.listenerDisconnect);
+                        }
+                        if (this.changeListener) {
+                            extension.getEditor().removeEventListener('change', this.changeListener);
+                        }
+                    },
+                };
+            },
+            state: {
+                init() {
+                    return {
+                        diagnostics: [],
+                    };
+                },
+                apply(tr, prev, oldState, newState) {
+                    const next = { ...prev };
+                    const meta = tr.getMeta(DiagnosticPluginKey);
+                    if (meta?.diagnostics) {
+                        next.diagnostics = meta.diagnostics;
+                    }
+                    if (meta?.mapper) {
+                        next.mapper = meta.mapper;
+                    }
+                    return next;
+                },
+            },
+            props: {
+                decorations(state) {
+                    const decorations = [];
+                    const pluginState = this.getState(state);
+                    if (pluginState) {
+                        const { diagnostics, mapper } = pluginState;
+                        if (mapper) {
+                            for (const diag of diagnostics) {
+                                const from = mapper.fromLineChar(diag.range.start.line, diag.range.start.character);
+                                const end = mapper.fromLineChar(diag.range.end.line, diag.range.end.character);
+                                if (from > -1 && end > -1) {
+                                    const decoration = Decoration.inline(from, end, { class: 'kb-lsp__error', title: diag.message });
+                                    decorations.push(decoration);
+                                }
+                            }
+                        }
+                    }
+                    return DecorationSet.create(state.doc, decorations);
+                },
+            },
+        });
+        Object.defineProperty(this, "diagListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listenerDisconnect", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listenerChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        let lastDiag = 0;
+        const editor = extension.getEditor();
+        const uri = editor.config.uri;
+        if (uri) {
+            const client = extension.getClient(extension.mainLang);
+            this.diagListener = (event) => {
+                const detail = event.detail;
+                if (detail.params.uri !== uri) {
+                    return;
+                }
+                event.preventDefault();
+                lastDiag = +Date();
+                if (client) {
+                    const file = client.workspace.getFile(uri);
+                    if (file) {
+                        const { mapper } = file;
+                        const tr = editor.view.state.tr.setMeta(DiagnosticPluginKey, {
+                            diagnostics: detail.params.diagnostics,
+                            mapper,
+                        });
+                        editor.view.dispatch(tr);
+                    }
+                }
+            };
+            if (client) {
+                client.addEventListener('textDocument/publishDiagnostics', this.diagListener);
+            }
+            this.listenerDisconnect = (event) => {
+                const tr = editor.view.state.tr.setMeta(DiagnosticPluginKey, {
+                    diagnostics: [],
+                    mapper: undefined,
+                });
+                editor.view.dispatch(tr);
+            };
+            if (client) {
+                client.addEventListener('close', this.listenerDisconnect);
+            }
+            this.listenerChange = (event) => {
+                if (lastDiag === 0 && +Date() - lastDiag > 10_1000) {
+                    return;
+                }
+                const tr = editor.view.state.tr.setMeta(DiagnosticPluginKey, {
+                    diagnostics: [],
+                    mapper: undefined,
+                });
+                editor.view.dispatch(tr);
+            };
+            // extension.getEditor().addEventListener('changed', this.listenerChange);
+        }
+    }
+}

package/esm/extension-lsp/src/ExtensionLsp.d.ts

@@ -0,0 +1,25 @@
+import { Plugin } from 'prosemirror-state';
+import { Extension } from '../../editor/src/mod.js';
+import { type ExtensionMarkdown } from '../../extension-markdown/src/ExtensionMarkdown.js';
+import { type ExtensionAutocomplete } from '../../extension-autocomplete/src/mod.js';
+import { LSPClient, Transport } from './LSPClient.js';
+import { LspSource } from './workspace.js';
+export type LspTransportGetter = (lang: string) => Transport | undefined;
+export interface LspConfig {
+    getLspTransport: LspTransportGetter;
+}
+export declare class ExtensionLsp extends Extension {
+    protected config: LspConfig;
+    name: string;
+    clients: Record<string, LSPClient>;
+    uri: string | undefined;
+    extensionMarkdown: ExtensionMarkdown;
+    extensionAutocomplete: ExtensionAutocomplete;
+    mainLang: string;
+    source: LspSource;
+    constructor(config: LspConfig);
+    getProseMirrorPlugins(): Plugin[];
+    created(): void;
+    getClient(lang: string): LSPClient | undefined;
+}
+//# sourceMappingURL=ExtensionLsp.d.ts.map

package/esm/extension-lsp/src/ExtensionLsp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionLsp.d.ts","sourceRoot":"","sources":["../../../src/extension-lsp/src/ExtensionLsp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,mDAAmD,CAAC;AAC3F,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAGrF,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAItD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,MAAM,MAAM,kBAAkB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,GAAG,SAAS,CAAC;AAEzE,MAAM,WAAW,SAAS;IACxB,eAAe,EAAE,kBAAkB,CAAC;CACrC;AAED,qBAAa,YAAa,SAAQ,SAAS;cASV,MAAM,EAAE,SAAS;IARhD,IAAI,SAAS;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAM;IACxC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,iBAAiB,EAAG,iBAAiB,CAAC;IACtC,qBAAqB,EAAG,qBAAqB,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAc;IAC9B,MAAM,EAAG,SAAS,CAAC;gBAEY,MAAM,EAAE,SAAS;IAIvC,qBAAqB,IAAI,MAAM,EAAE;IAWjC,OAAO;IA6DhB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;CAW/C"}

package/esm/extension-lsp/src/ExtensionLsp.js

@@ -0,0 +1,126 @@
+import { Extension } from '../../editor/src/mod.js';
+import { PositionMapper } from '../../extension-markdown/src/PositionMapper.js';
+import { LSPClient } from './LSPClient.js';
+import { AutocompletePlugin } from '../../extension-autocomplete/src/AutocompletePlugin.js';
+import { DiagnosticPlugin } from './DiagnosticPlugin.js';
+import { createLspAutocomplete } from './createLspAutocomplete.js';
+export class ExtensionLsp extends Extension {
+    constructor(config) {
+        super(config);
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'lsp'
+        });
+        Object.defineProperty(this, "clients", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "uri", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extensionMarkdown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extensionAutocomplete", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mainLang", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'markdown'
+        });
+        Object.defineProperty(this, "source", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    getProseMirrorPlugins() {
+        const plugins = [];
+        const { autocompleteConfig } = createLspAutocomplete(this);
+        plugins.push(new AutocompletePlugin(autocompleteConfig, this.editor));
+        plugins.push(new DiagnosticPlugin({}, this));
+        return plugins;
+    }
+    created() {
+        this.mainLang = this.editor.config.languageID || 'markdown';
+        this.source = {
+            ui: this.editor.ui,
+            getMappedContent: () => {
+                const editor = this.editor;
+                const result = this.extensionMarkdown.toMarkdown(editor.state.doc);
+                const mapper = new PositionMapper(editor, result.rawTextMap);
+                return {
+                    ...result,
+                    mapper,
+                };
+            },
+        };
+        const extensionMarkdown = this.editor
+            .getExtension('markdown');
+        if (!extensionMarkdown) {
+            throw new Error('No markdown extension');
+        }
+        this.extensionMarkdown = extensionMarkdown;
+        this.editor.addEventListener('doc:loaded', async () => {
+            const languageID = this.mainLang;
+            this.uri = this.editor.config.uri;
+            if (this.uri) {
+                const client = this.getClient(this.mainLang);
+                if (client) {
+                    client.connect(this.uri, this.source);
+                    await client.restart();
+                    client.workspace.openFile(this.uri, languageID, this.source);
+                }
+            }
+        });
+        this.editor.addEventListener('changed', () => {
+            if (this.editor.config.uri) {
+                const client = this.getClient(this.mainLang);
+                if (client) {
+                    client.workspace.changedFile(this.editor.config.uri);
+                }
+            }
+        });
+        this.editor.addEventListener('beforeDestroy', () => {
+            if (this.uri) {
+                const client = this.getClient(this.mainLang);
+                if (client) {
+                    client.disconnect(this.uri);
+                }
+            }
+        });
+    }
+    getClient(lang) {
+        if (!this.clients[lang]) {
+            const transport = this.config.getLspTransport(lang);
+            if (!transport) {
+                console.warn(`No lsp transport for ${lang}`);
+                return undefined;
+            }
+            this.clients[lang] = new LSPClient(transport, { rootUri: 'file:///' });
+        }
+        return this.clients[lang];
+    }
+}