@kerebron/extension-lsp 0.4.1

package/esm/extension-markdown/src/PositionMapper.js

@@ -0,0 +1,100 @@
+function findFirstLetterPosition(node, startPos) {
+    let firstLetterPos = -1;
+    let textLen = 0;
+    node.descendants((child, posInParent) => {
+        if (child.isText && child.text && child.text.length > 0) {
+            firstLetterPos = startPos + posInParent + 1; // First char of first text node
+            textLen = child.text.length;
+            return false; // Stop
+        }
+        return true;
+    });
+    if (firstLetterPos === -1) {
+        return null;
+    }
+    return [firstLetterPos, textLen];
+}
+export class PositionMapper {
+    constructor(editor, rawTextMap) {
+        Object.defineProperty(this, "rawTextMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: rawTextMap
+        });
+        Object.defineProperty(this, "rawTextArr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "doc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.doc = editor.state.doc;
+        this.rawTextArr = [];
+        for (const item of rawTextMap) {
+            if (item.nodeIdx > 0) {
+                this.rawTextArr.push({
+                    nodeIdx: item.nodeIdx,
+                    maxNodeIdx: item.nodeIdx,
+                    targetPos: item.targetPos,
+                    targetRow: item.targetRow,
+                    targetCol: item.targetCol,
+                });
+            }
+        }
+        this.rawTextArr.sort((b, a) => b.nodeIdx - a.nodeIdx);
+        for (let i = 0; i < this.rawTextArr.length; i++) {
+            const next = i + 1;
+            if (next < this.rawTextArr.length) {
+                this.rawTextArr[i].maxNodeIdx = this.rawTextArr[next].nodeIdx - 1;
+            }
+            else {
+                this.rawTextArr[i].maxNodeIdx = this.doc.nodeSize;
+            }
+        }
+    }
+    toRawTextPos(pos) {
+        for (let i = 0; i < this.rawTextArr.length; i++) {
+            const item = this.rawTextArr[i];
+            if (pos >= item.nodeIdx && pos <= item.maxNodeIdx) {
+                return item.targetPos + pos - item.nodeIdx;
+            }
+        }
+        return -1;
+    }
+    toRawTextLspPos(pos) {
+        for (let i = 0; i < this.rawTextArr.length; i++) {
+            const item = this.rawTextArr[i];
+            if (pos >= item.nodeIdx && pos <= item.maxNodeIdx) {
+                return {
+                    line: item.targetRow,
+                    character: item.targetCol + pos - item.nodeIdx,
+                };
+            }
+        }
+        return { line: 0, character: 0 };
+    }
+    fromLineChar(line, character) {
+        for (let i = 0; i < this.rawTextArr.length; i++) {
+            const item = this.rawTextArr[i];
+            const len = item.maxNodeIdx - item.nodeIdx + 1;
+            if (item.targetRow === line) {
+                if (character >= item.targetCol && character < item.targetCol + len) {
+                    const offset = character - item.targetCol;
+                    return item.nodeIdx + offset;
+                }
+                const nextItem = this.rawTextArr[i + 1];
+                const isLastInRow = !nextItem || nextItem.targetRow > item.targetRow;
+                if (isLastInRow && character >= item.targetCol + len) {
+                    return item.maxNodeIdx;
+                }
+            }
+        }
+        return -1;
+    }
+}

package/esm/extension-markdown/src/TokenSource.d.ts

@@ -0,0 +1,11 @@
+export declare class TokenSource<K> {
+    private tokens;
+    private currentPos;
+    constructor(tokens: Array<K>);
+    get pos(): number;
+    iterate(start: number, callback: (token: K, tokenNo: number) => void): void;
+    append(tokens: Array<K>): number;
+    trim(pos: number): void;
+    rewind(tokenNo?: number): void;
+}
+//# sourceMappingURL=TokenSource.d.ts.map

package/esm/extension-markdown/src/TokenSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TokenSource.d.ts","sourceRoot":"","sources":["../../../src/extension-markdown/src/TokenSource.ts"],"names":[],"mappings":"AAAA,qBAAa,WAAW,CAAC,CAAC;IAGZ,OAAO,CAAC,MAAM;IAF1B,OAAO,CAAC,UAAU,CAAS;gBAEP,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAIpC,IAAI,GAAG,WAEN;IAED,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI;IAWpE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAKvB,IAAI,CAAC,GAAG,EAAE,MAAM;IAIhB,MAAM,CAAC,OAAO,GAAE,MAAW;CAM5B"}

package/esm/extension-markdown/src/TokenSource.js

@@ -0,0 +1,39 @@
+export class TokenSource {
+    constructor(tokens) {
+        Object.defineProperty(this, "tokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tokens
+        });
+        Object.defineProperty(this, "currentPos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.currentPos = 0;
+    }
+    get pos() {
+        return this.currentPos;
+    }
+    iterate(start, callback) {
+        for (this.currentPos = start; this.currentPos < this.tokens.length; this.currentPos++) {
+            const token = this.tokens[this.currentPos];
+            callback(token, this.currentPos);
+        }
+    }
+    append(tokens) {
+        this.tokens.push(...tokens);
+        return this.tokens.length - tokens.length;
+    }
+    trim(pos) {
+        this.tokens.splice(pos);
+    }
+    rewind(tokenNo = -1) {
+        if (tokenNo < 0) {
+            throw new RangeError('Invalid rewind pos: ' + tokenNo);
+        }
+        this.currentPos = tokenNo;
+    }
+}

package/esm/extension-markdown/src/mdToPmConverter.d.ts

@@ -0,0 +1,5 @@
+import { Node, Schema } from 'prosemirror-model';
+import { MdConfig } from './ExtensionMarkdown.js';
+export declare function mdToPmConverter(buffer: Uint8Array, config: MdConfig, schema: Schema): Promise<Node>;
+export declare function mdToPmConverterText(content: string, config: MdConfig, schema: Schema): Promise<Node>;
+//# sourceMappingURL=mdToPmConverter.d.ts.map

package/esm/extension-markdown/src/mdToPmConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdToPmConverter.d.ts","sourceRoot":"","sources":["../../../src/extension-markdown/src/mdToPmConverter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAGjD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAelD,wBAAsB,eAAe,CACnC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CA2Gf"}

package/esm/extension-markdown/src/mdToPmConverter.js

@@ -0,0 +1,111 @@
+import { DOMParser } from 'prosemirror-model';
+import { elementFromString } from '../../extension-basic-editor/src/ExtensionHtml.js';
+import { MarkdownParser } from './MarkdownParser.js';
+import { sitterTokenizer } from './treeSitterTokenizer.js';
+function listIsTight(tokens, i) {
+    while (++i < tokens.length) {
+        if (tokens[i].type != 'list_item_open')
+            return tokens[i].hidden;
+    }
+    return false;
+}
+export async function mdToPmConverter(buffer, config, schema) {
+    const content = new TextDecoder().decode(buffer);
+    return mdToPmConverterText(content, config, schema);
+}
+export async function mdToPmConverterText(content, config, schema) {
+    const tokenizer = await sitterTokenizer(config.cdnUrl);
+    const defaultMarkdownParser = new MarkdownParser(schema, tokenizer, {
+        frontmatter: {
+            node: 'frontmatter',
+        },
+        blockquote: { block: 'blockquote' },
+        paragraph: { block: 'paragraph' },
+        task_item: { block: 'task_item' },
+        task_list: {
+            block: 'task_list',
+        },
+        list_item: { block: 'list_item' },
+        bullet_list: {
+            block: 'bullet_list',
+            getAttrs: (_, tokens, i) => ({ tight: listIsTight(tokens, i) }),
+        },
+        ordered_list: {
+            block: 'ordered_list',
+            getAttrs: (tok, tokens, i) => ({
+                start: +tok.attrGet('start') || 1,
+                tight: listIsTight(tokens, i),
+            }),
+        },
+        dl: {
+            block: 'dl',
+        },
+        dt: {
+            block: 'dt',
+        },
+        dd: {
+            block: 'dd',
+        },
+        heading: {
+            block: 'heading',
+            getAttrs: (tok) => ({ level: +tok.tag.slice(1) }),
+        },
+        code_block: { block: 'code_block', noCloseToken: true },
+        fence: {
+            block: 'code_block',
+            getAttrs: (tok) => ({ lang: tok.attrGet('lang') || undefined }),
+            noCloseToken: true,
+        },
+        hr: { node: 'hr' },
+        image: {
+            node: 'image',
+            getAttrs: (tok) => {
+                const firstChild = tok.children ? tok.children[0] : undefined;
+                return {
+                    src: tok.attrGet('src'),
+                    title: tok.attrGet('title') || null,
+                    alt: firstChild?.content || null,
+                };
+            },
+        },
+        hardbreak: { node: 'br' },
+        em: { mark: 'em' },
+        underline: { mark: 'underline' },
+        strong: { mark: 'strong' },
+        strike: { mark: 'strike' },
+        link: {
+            mark: 'link',
+            getAttrs: (tok) => ({
+                href: tok.attrGet('href'),
+                title: tok.attrGet('title') || null,
+            }),
+        },
+        code: { mark: 'code' },
+        html_block: {
+            custom: (state, token, tokens, i) => {
+                const parser = DOMParser.fromSchema(schema);
+                const parsed = parser.parse(elementFromString(token.content));
+                // state.importNodes(parsed.children); // breaks lsptoy example
+            },
+        },
+        footnote_ref: {
+            block: 'code_block',
+        },
+        table: {
+            block: 'table',
+        },
+        tr: {
+            block: 'table_row',
+        },
+        td: {
+            block: 'table_cell',
+        },
+        th: {
+            block: 'table_header',
+        },
+        thead: {
+            ignore: true,
+        },
+    });
+    return defaultMarkdownParser.parse(content);
+}

package/esm/extension-markdown/src/pmToMdConverter.d.ts

@@ -0,0 +1,16 @@
+import { Node, Schema } from 'prosemirror-model';
+import { type CoreEditor, RawTextResult, SourceMap } from '../../editor/src/mod.js';
+import { MdConfig } from './ExtensionMarkdown.js';
+export interface MdContext {
+    meta: Record<string, any>;
+}
+export declare function pmToMdConverter(document: Node, config: MdConfig, schema: Schema, editor: CoreEditor): Promise<Uint8Array>;
+export interface MarkdownResult extends RawTextResult {
+    debugMap: Record<number, {
+        targetRow: number;
+        targetCol: number;
+    }>;
+    sourceMap?: SourceMap;
+}
+export declare function syncPmToMdConverter(document: Node, config: MdConfig, schema: Schema, editor: CoreEditor): MarkdownResult;
+//# sourceMappingURL=pmToMdConverter.d.ts.map

package/esm/extension-markdown/src/pmToMdConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pmToMdConverter.d.ts","sourceRoot":"","sources":["../../../src/extension-markdown/src/pmToMdConverter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,IAAI,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAIjE,OAAO,EACL,KAAK,UAAU,EAIf,aAAa,EACb,SAAS,EACV,MAAM,yBAAyB,CAAC;AAKjC,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AA+ClD,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC3B;AAkCD,wBAAsB,eAAe,CACnC,QAAQ,EAAE,IAAI,EACd,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,UAAU,GACjB,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED,MAAM,WAAW,cAAe,SAAQ,aAAa;IACnD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnE,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,IAAI,EACd,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,UAAU,GACjB,cAAc,CA+ahB"}