@kerebron/extension-codemirror 0.3.1 → 0.4.1

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

@@ -0,0 +1,325 @@
+import { NESTING_CLOSING } from './types.js';
+import { getTableTokensHandlers } from './token_handlers/table_token_handlers.js';
+import { getBasicTokensHandlers } from './token_handlers/basic_token_handlers.js';
+import { getInlineTokensHandlers } from './token_handlers/inline_token_handlers.js';
+import { getFootnoteTokensHandlers } from './token_handlers/footnote_token_handlers.js';
+import { getListsTokensHandlers } from './token_handlers/lists_token_handlers.js';
+import { TokenSource } from './TokenSource.js';
+import { SmartOutput } from '../../editor/src/utilities/mod.js';
+export function writeIndented(output, text, currentCtx, token) {
+    const lines = text.split('\n');
+    const typeIndent = {
+        ul: 2,
+        ol: 4,
+        dl: 2,
+        tl: 4,
+    };
+    let offset = 0;
+    const startPos = token
+        ? (token.map && token.map.length > 0 ? token.map[0] : 0)
+        : 0;
+    for (let lineNo = 0; lineNo < lines.length; lineNo++) {
+        const line = lines[lineNo];
+        if (lineNo === lines.length - 1 && line.length === 0) {
+            continue;
+        }
+        if (output.colPos === 0) {
+            output.log('> '.repeat(currentCtx.blockquoteCnt).trim());
+        }
+        if (output.colPos === 0 && line.length > 0) {
+            output.log('    '.repeat(currentCtx.footnoteCnt));
+            const indent = currentCtx.listPath
+                .slice(0, currentCtx.listPath.length - 1)
+                .map((type) => typeIndent[type])
+                .reduce((p, c) => p + c, 0);
+            if (currentCtx.listType === 'tl') {
+                output.log(' '.repeat(indent));
+                if (currentCtx.itemRow === 0) {
+                    output.log('- ');
+                    if (currentCtx.itemSymbol) {
+                        output.log('[x] ');
+                    }
+                    else {
+                        output.log('[ ] ');
+                    }
+                }
+                else {
+                    output.log('  ');
+                }
+            }
+            if (currentCtx.listType === 'ul') {
+                output.log(' '.repeat(indent));
+                if (currentCtx.itemRow === 0) {
+                    output.log(currentCtx.itemSymbol + ' ');
+                }
+                else {
+                    output.log('  ');
+                }
+            }
+            if (currentCtx.listType === 'ol') {
+                const no = currentCtx.itemSymbol;
+                output.log(' '.repeat(indent));
+                if (currentCtx.itemRow === 0) {
+                    output.log(no);
+                }
+                else {
+                    output.log(' '.repeat(4));
+                }
+            }
+            if (currentCtx.listType === 'dl') {
+                if (currentCtx.itemSymbol) {
+                    if (currentCtx.itemRow === 0) {
+                        output.log(`${currentCtx.itemSymbol}`);
+                    }
+                    else {
+                        output.log(' '.repeat(currentCtx.itemSymbol.length));
+                    }
+                }
+            }
+        }
+        const tok = structuredClone(token);
+        if (startPos && tok) {
+            tok.map = [startPos + offset];
+        }
+        if (line.length > 0) {
+            if (currentCtx.blockquoteCnt > 0 &&
+                output.colPos === currentCtx.blockquoteCnt * 2 - 1) {
+                output.log(' ');
+            }
+        }
+        output.log(line, tok);
+        offset += line.length;
+        if (lineNo < lines.length - 1) {
+            currentCtx.itemRow++;
+            const tok = structuredClone(token);
+            if (startPos && tok) {
+                tok.map = [startPos + offset];
+            }
+            output.log('\n', tok);
+            offset++;
+        }
+    }
+}
+export class ContextStash {
+    constructor(handlers) {
+        Object.defineProperty(this, "ctxStash", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "currentCtx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.output = new SmartOutput();
+        this.currentCtx = {
+            meta: {},
+            metaObj: {},
+            blockquoteCnt: 0,
+            footnoteCnt: 0,
+            itemRow: 0,
+            listPath: [],
+            itemNumber: 0,
+            itemSymbol: '',
+            handlers,
+            log: (txt, token) => this.output.log(txt, token),
+            debug: () => { },
+        };
+        this.stash('ContextStash.constructor()');
+    }
+    stash(reason) {
+        this.currentCtx.debug('  '.repeat(this.ctxStash.length) + 'stash: ' + reason);
+        this.ctxStash.push(this.currentCtx);
+        const funcs = {
+            log: this.currentCtx.log,
+            debug: this.currentCtx.debug,
+        };
+        const handlers = { ...this.currentCtx.handlers };
+        const metaObj = { ...this.currentCtx.metaObj };
+        this.currentCtx = {
+            ...structuredClone({
+                ...this.currentCtx,
+                log: undefined,
+                debug: undefined,
+                handlers: undefined,
+            }),
+            metaObj,
+            ...funcs,
+            handlers: handlers,
+        };
+        const rollbackPos = this.ctxStash.length - 1;
+        return rollbackPos;
+    }
+    unstash(reason) {
+        const ctx = this.ctxStash.pop();
+        this.currentCtx.debug('  '.repeat(this.ctxStash.length) + 'unstash: ' + reason);
+        if (!ctx) {
+            throw new Error('Unstash failed');
+        }
+        this.currentCtx = ctx;
+    }
+    rollback(rollbackPos, reason) {
+        const rollbackCtx = this.ctxStash[rollbackPos];
+        if (!rollbackCtx) {
+            throw new RangeError('Invalid rollbackPos: ' + rollbackPos);
+        }
+        this.currentCtx.debug('rollback ' + reason, rollbackPos);
+        this.ctxStash.splice(rollbackPos);
+        this.currentCtx = this.ctxStash[this.ctxStash.length - 1];
+    }
+    get current() {
+        return this.currentCtx;
+    }
+}
+export function serializeInlineTokens(ctx, tokenSource, tokens) {
+    const appendPos = tokenSource.append(tokens);
+    const oldPos = tokenSource.pos;
+    tokenSource.rewind(appendPos);
+    try {
+        tokenSource.iterate(appendPos, (token, i) => {
+            const tokenHandlers = ctx.current.handlers[token.type] || ctx.current.handlers['default'];
+            if (!tokenHandlers) {
+                throw new Error(`Unknown inline token: ${token.type} ` + JSON.stringify(token) +
+                    `, available hadlers: ${Object.keys(ctx.current.handlers)}`);
+            }
+            for (const handler of tokenHandlers) {
+                if (handler(token, ctx, tokenSource)) {
+                    break;
+                }
+            }
+            if (tokenSource.pos + 1 < appendPos) {
+                throw new RangeError('Rewinded before inline tokens');
+            }
+        });
+        tokenSource.rewind(oldPos);
+    }
+    finally {
+        tokenSource.trim(appendPos);
+    }
+}
+export class MarkdownSerializer {
+    constructor(config = {}) {
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.ctx = new ContextStash({
+            ...getInlineTokensHandlers(),
+            ...getTableTokensHandlers(),
+            ...getBasicTokensHandlers(),
+            ...getFootnoteTokensHandlers(),
+            ...getListsTokensHandlers(),
+        });
+        if (config.debug) {
+            this.ctx.current.debug = config.debug;
+        }
+    }
+    get endsWithEmptyLine() {
+        return this.ctx.output.endsWith('\n\n');
+    }
+    serialize(tokens) {
+        const prevLevelTokenType = {};
+        const tokenSource = new TokenSource(tokens);
+        tokenSource.iterate(0, (token, i) => {
+            if (!this.ctx.current.meta['html_mode']) {
+                if (token.level === 0 && token.nesting !== NESTING_CLOSING) {
+                    if (this.ctx.output.colPos !== 0) {
+                        this.ctx.current.log('\n');
+                    }
+                }
+                if (!this.endsWithEmptyLine) {
+                    if (token.nesting !== NESTING_CLOSING && token.level === 0) {
+                        const prevTopTokenType = prevLevelTokenType[token.level] || '';
+                        if ([
+                            'hr',
+                            'paragraph_close',
+                            'ordered_list_close',
+                            'bullet_list_close',
+                            'task_list_close',
+                            'dl_close',
+                            'table_close',
+                            'blockquote_close',
+                            'footnote_close',
+                            'code_block',
+                            'html_block',
+                        ].includes(prevTopTokenType)) {
+                            this.ctx.current.log('\n');
+                        }
+                        if ('heading_close' === prevTopTokenType &&
+                            token.tag !== 'heading_open') {
+                            this.ctx.current.log('\n');
+                        }
+                    }
+                    else if (token.nesting !== NESTING_CLOSING && token.level === 1 &&
+                        'dt_open' === token.type) {
+                        const prevTokenType = prevLevelTokenType[token.level] || '';
+                        if ([
+                            'dt_close',
+                            'dd_close',
+                        ].includes(prevTokenType)) {
+                            this.ctx.current.log('\n');
+                        }
+                    }
+                }
+            }
+            if (token.nesting !== NESTING_CLOSING && token.level > 0) {
+                const prevTopTokenType = prevLevelTokenType[token.level] || '';
+                if ([
+                    'paragraph_close',
+                ].includes(prevTopTokenType)) {
+                    if (this.ctx.current.blockquoteCnt === token.level) {
+                        writeIndented(this.ctx.output, '\n', this.ctx.current, token);
+                    }
+                }
+            }
+            const tokenHandlers = this.ctx.current.handlers[token.type] ||
+                this.ctx.current.handlers['default'];
+            if (token.type === 'inline') {
+                if (token.children) {
+                    this.ctx.stash('serializeInlineTokens()');
+                    this.ctx.current.log = (txt, token) => {
+                        writeIndented(this.ctx.output, txt, this.ctx.current, token);
+                    };
+                    try {
+                        serializeInlineTokens(this.ctx, tokenSource, token.children);
+                        this.ctx.unstash('serializeInlineTokens()');
+                    }
+                    catch (err) {
+                        this.ctx.current.debug(err.message);
+                        if (err.message === 'Rewinded before inline tokens') {
+                            return;
+                        }
+                        throw err;
+                    }
+                }
+            }
+            else if (!tokenHandlers) {
+                this.ctx.current.debug('current.handlers', Object.keys(this.ctx.current.handlers).sort());
+                throw new Error(`Unknown token: ${token.type} ` + JSON.stringify(token));
+            }
+            else {
+                for (const handler of tokenHandlers) {
+                    if (handler(token, this.ctx, tokenSource)) {
+                        break;
+                    }
+                }
+            }
+            prevLevelTokenType[token.level] = token.type;
+            if (token.nesting === NESTING_CLOSING) {
+                prevLevelTokenType[token.level + 1] = '';
+            }
+        });
+        return this.ctx.output;
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { Node } from 'prosemirror-model';
+import type { CoreEditor, RawTextMapEntry } from '../../editor/src/mod.js';
+export declare class PositionMapper {
+    readonly rawTextMap: Array<RawTextMapEntry>;
+    private readonly rawTextArr;
+    readonly doc: Node;
+    constructor(editor: CoreEditor, rawTextMap: Array<RawTextMapEntry>);
+    toRawTextPos(pos: number): number;
+    toRawTextLspPos(pos: number): {
+        line: number;
+        character: number;
+    };
+    fromLineChar(line: number, character: number): number;
+}
+//# sourceMappingURL=PositionMapper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PositionMapper.d.ts","sourceRoot":"","sources":["../../../src/extension-markdown/src/PositionMapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAiC3E,qBAAa,cAAc;aAMP,UAAU,EAAE,KAAK,CAAC,eAAe,CAAC;IALpD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;IAC9C,SAAgB,GAAG,EAAE,IAAI,CAAC;gBAGxB,MAAM,EAAE,UAAU,EACF,UAAU,EAAE,KAAK,CAAC,eAAe,CAAC;IA0BpD,YAAY,CAAC,GAAG,EAAE,MAAM;IAUxB,eAAe,CAAC,GAAG,EAAE,MAAM;;;;IAa3B,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAoB7C"}

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"}