@kerebron/extension-lsp 0.4.1

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

@@ -0,0 +1,249 @@
+import { Mark, } from 'prosemirror-model';
+const __dirname = globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).dirname;
+function maybeMerge(a, b) {
+    if (a.isText && b.isText && Mark.sameSet(a.marks, b.marks)) {
+        return a.withText(a.text + b.text);
+    }
+}
+// Object used to track the context of a running parse.
+export class MarkdownParseState {
+    constructor(schema, tokenHandlers) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: schema
+        });
+        Object.defineProperty(this, "tokenHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tokenHandlers
+        });
+        Object.defineProperty(this, "stack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.stack = [{
+                type: schema.topNodeType,
+                attrs: null,
+                content: [],
+                marks: Mark.none,
+            }];
+    }
+    top() {
+        return this.stack[this.stack.length - 1];
+    }
+    push(elt) {
+        if (this.stack.length)
+            this.top().content.push(elt);
+    }
+    // Adds the given text to the current position in the document,
+    // using the current marks as styling.
+    addText(text) {
+        if (!text)
+            return;
+        let top = this.top(), nodes = top.content, last = nodes[nodes.length - 1];
+        let node = this.schema.text(text, top.marks), merged;
+        if (last && (merged = maybeMerge(last, node))) {
+            nodes[nodes.length - 1] = merged;
+        }
+        else
+            nodes.push(node);
+    }
+    // Adds the given mark to the set of active marks.
+    openMark(mark) {
+        let top = this.top();
+        top.marks = mark.addToSet(top.marks);
+    }
+    // Removes the given mark from the set of active marks.
+    closeMark(mark) {
+        let top = this.top();
+        top.marks = mark.removeFromSet(top.marks);
+    }
+    parseTokens(toks) {
+        for (let i = 0; i < toks.length; i++) {
+            let tok = toks[i];
+            let handler = this.tokenHandlers[tok.type];
+            if (!handler) {
+                console.log(Object.keys(this.tokenHandlers));
+                throw new Error('Token type `' + tok.type + '` not supported by Markdown parser');
+            }
+            handler(this, tok, toks, i);
+        }
+    }
+    // Add a node at the current position.
+    addNode(type, attrs, content) {
+        let top = this.top();
+        let node = type.createAndFill(attrs, content, top ? top.marks : []);
+        if (!node)
+            return null;
+        this.push(node);
+        return node;
+    }
+    // Wrap subsequent content in a node of the given type.
+    openNode(type, attrs) {
+        this.stack.push({
+            type: type,
+            attrs: attrs,
+            content: [],
+            marks: Mark.none,
+        });
+    }
+    // Close and return the node that is currently on top of the stack.
+    closeNode() {
+        let info = this.stack.pop();
+        return this.addNode(info.type, info.attrs, info.content);
+    }
+    importNodes(nodes) {
+        for (const node of nodes) {
+            this.push(node);
+        }
+    }
+}
+function attrs(spec, token, tokens, i) {
+    if (spec.getAttrs)
+        return spec.getAttrs(token, tokens, i);
+    // For backwards compatibility when `attrs` is a Function
+    else if (spec.attrs instanceof Function)
+        return spec.attrs(token);
+    else
+        return spec.attrs;
+}
+// Code content is represented as a single token with a `content`
+// property in Markdown-it.
+function noCloseToken(spec, type) {
+    return spec.noCloseToken || type == 'code_block' ||
+        type == 'fence';
+}
+function withoutTrailingNewline(str) {
+    return str[str.length - 1] == '\n' ? str.slice(0, str.length - 1) : str;
+}
+function noOp() { }
+function tokenHandlers(schema, tokens) {
+    let handlers = Object.create(null);
+    for (let type in tokens) {
+        let spec = tokens[type];
+        if (spec.block) {
+            let nodeType = schema.nodes[spec.block];
+            if (noCloseToken(spec, type)) {
+                handlers[type] = (state, tok, tokens, i) => {
+                    state.openNode(nodeType, attrs(spec, tok, tokens, i));
+                    state.addText(withoutTrailingNewline(tok.content));
+                    state.closeNode();
+                };
+            }
+            else {
+                handlers[type + '_open'] = (state, tok, tokens, i) => state.openNode(nodeType, attrs(spec, tok, tokens, i));
+                handlers[type + '_close'] = (state) => state.closeNode();
+            }
+        }
+        else if (spec.node) {
+            let nodeType = schema.nodes[spec.node];
+            handlers[type] = (state, tok, tokens, i) => state.addNode(nodeType, attrs(spec, tok, tokens, i));
+        }
+        else if (spec.mark) {
+            let markType = schema.marks[spec.mark];
+            if (noCloseToken(spec, type)) {
+                handlers[type] = (state, tok, tokens, i) => {
+                    state.openMark(markType.create(attrs(spec, tok, tokens, i)));
+                    state.addText(withoutTrailingNewline(tok.content));
+                    state.closeMark(markType);
+                };
+            }
+            else {
+                handlers[type + '_open'] = (state, tok, tokens, i) => state.openMark(markType.create(attrs(spec, tok, tokens, i)));
+                handlers[type + '_close'] = (state) => state.closeMark(markType);
+            }
+        }
+        else if (spec.custom) {
+            const custom = spec.custom;
+            handlers[type] = (state, tok, tokens, i) => {
+                custom(state, tok, tokens, i);
+            };
+        }
+        else if (spec.ignore) {
+            if (noCloseToken(spec, type)) {
+                handlers[type] = noOp;
+            }
+            else {
+                handlers[type + '_open'] = noOp;
+                handlers[type + '_close'] = noOp;
+            }
+        }
+        else {
+            throw new RangeError('Unrecognized parsing spec ' + JSON.stringify(spec));
+        }
+    }
+    handlers.text = (state, tok) => state.addText(tok.content);
+    handlers.inline = (state, tok) => state.parseTokens(tok.children);
+    handlers.softbreak = handlers.softbreak || ((state) => state.addText(' '));
+    return handlers;
+}
+/// A configuration of a Markdown parser. Such a parser uses
+/// [markdown-it](https://github.com/markdown-it/markdown-it) to
+/// tokenize a file, and then runs the custom rules it is given over
+/// the tokens to create a ProseMirror document tree.
+export class MarkdownParser {
+    /// Create a parser with the given configuration. You can configure
+    /// the markdown-it parser to parse the dialect you want, and provide
+    /// a description of the ProseMirror entities those tokens map to in
+    /// the `tokens` object, which maps token names to descriptions of
+    /// what to do with them. Such a description is an object, and may
+    /// have the following properties:
+    constructor(
+    /// The parser's document schema.
+    schema, 
+    /// This parser's markdown-it tokenizer.
+    tokenizer, 
+    /// The value of the `tokens` object used to construct this
+    /// parser. Can be useful to copy and modify to base other parsers
+    /// on.
+    tokens) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: schema
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tokenizer
+        });
+        Object.defineProperty(this, "tokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tokens
+        });
+        /// @internal
+        Object.defineProperty(this, "tokenHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tokenHandlers = tokenHandlers(schema, tokens);
+    }
+    /// Parse a string as [CommonMark](http://commonmark.org/) markup,
+    /// and create a ProseMirror document as prescribed by this parser's
+    /// rules.
+    ///
+    /// The second argument, when given, is passed through to the
+    /// [Markdown
+    /// parser](https://markdown-it.github.io/markdown-it/#MarkdownIt.parse).
+    parse(text, markdownEnv = {}) {
+        const state = new MarkdownParseState(this.schema, this.tokenHandlers);
+        const tokens = this.tokenizer.parse(text, markdownEnv);
+        state.parseTokens(tokens);
+        let doc;
+        do {
+            doc = state.closeNode();
+        } while (state.stack.length);
+        return doc || this.schema.topNodeType.createAndFill();
+    }
+}

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

@@ -0,0 +1,42 @@
+import { type Token } from './types.js';
+import { TokenSource } from './TokenSource.js';
+import { SmartOutput } from '../../editor/src/utilities/mod.js';
+export declare function writeIndented(output: SmartOutput<Token>, text: string, currentCtx: SerializerContext, token?: Token): void;
+type ListType = 'ul' | 'ol' | 'dl' | 'tl';
+export interface SerializerContext {
+    meta: Record<string, any>;
+    metaObj: Record<string, any>;
+    blockquoteCnt: number;
+    footnoteCnt: number;
+    listPath: Array<ListType>;
+    listType?: ListType;
+    itemRow: number;
+    itemNumber: number;
+    itemSymbol: string;
+    handlers: Record<string, Array<TokenHandler>>;
+    log: (txt: string, token?: Token) => void;
+    debug: (...args: any[]) => void;
+}
+export declare class ContextStash {
+    private ctxStash;
+    private currentCtx;
+    readonly output: SmartOutput<Token>;
+    constructor(handlers: Record<string, Array<TokenHandler>>);
+    stash(reason: string): number;
+    unstash(reason: string): void;
+    rollback(rollbackPos: number, reason: string): void;
+    get current(): SerializerContext;
+}
+export declare function serializeInlineTokens(ctx: ContextStash, tokenSource: TokenSource<Token>, tokens: Token[]): void;
+export type TokenHandler = (token: Token, ctx: ContextStash, tokenSource: TokenSource<Token>) => boolean | void;
+export interface MarkdownSerializerConfig {
+    debug?: (...args: any[]) => void;
+}
+export declare class MarkdownSerializer {
+    private ctx;
+    constructor(config?: MarkdownSerializerConfig);
+    private get endsWithEmptyLine();
+    serialize(tokens: Token[]): SmartOutput<Token>;
+}
+export {};
+//# sourceMappingURL=MarkdownSerializer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownSerializer.d.ts","sourceRoot":"","sources":["../../../src/extension-markdown/src/MarkdownSerializer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAOzD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAEhE,wBAAgB,aAAa,CAC3B,MAAM,EAAE,WAAW,CAAC,KAAK,CAAC,EAC1B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,iBAAiB,EAC7B,KAAK,CAAC,EAAE,KAAK,QAmGd;AAED,KAAK,QAAQ,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAE1C,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC1B,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IAEnB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;IAC9C,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;IAC1C,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;CACjC;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,UAAU,CAAoB;IACtC,SAAgB,MAAM,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC;gBAE/B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;IAmBlD,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IA2B7B,OAAO,CAAC,MAAM,EAAE,MAAM;IAWtB,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAWnD,IAAI,OAAO,sBAEV;CACF;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,YAAY,EACjB,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,EAC/B,MAAM,EAAE,KAAK,EAAE,QAgChB;AAED,MAAM,MAAM,YAAY,GAAG,CACzB,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,YAAY,EACjB,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,KAC5B,OAAO,GAAG,IAAI,CAAC;AAEpB,MAAM,WAAW,wBAAwB;IACvC,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;CAClC;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,GAAG,CAAe;gBAEd,MAAM,GAAE,wBAA6B;IAcjD,OAAO,KAAK,iBAAiB,GAE5B;IAED,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,WAAW,CAAC,KAAK,CAAC;CAiH/C"}

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