@kerebron/editor-kits 0.4.1

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

@@ -0,0 +1,240 @@
+import { Token } from './types.js';
+const blankMark = { open: '', close: '', mixable: true };
+const blankNode = { open: '', close: '' };
+function generateInlineTokens(input) {
+    const tokens = [];
+    let currentPos = -1;
+    let currentText = '';
+    for (const [text, inlinePos] of input) {
+        if (true || currentPos !== inlinePos) {
+            if (currentText.length > 0) {
+                const token = new Token('text', '', 0);
+                token.meta = 'generateInline1';
+                token.map = [currentPos];
+                token.content = currentText;
+                tokens.push(token);
+            }
+            currentText = '';
+            currentPos = inlinePos;
+        }
+        currentText += text;
+    }
+    if (currentText.length > 0) {
+        const token = new Token('text', '', 0);
+        token.meta = 'generateInline2';
+        token.map = [currentPos];
+        token.content = currentText;
+        tokens.push(token);
+    }
+    return tokens;
+}
+export class DocumentMarkdownInlineTokenizer {
+    constructor(nodes, marks, options) {
+        Object.defineProperty(this, "nodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: nodes
+        });
+        Object.defineProperty(this, "marks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: marks
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+    }
+    getMark(name) {
+        let info = this.marks[name];
+        if (!info) {
+            // if (this.options.strict !== false) {
+            //   throw new Error(
+            //     `Mark type \`${name}\` not supported by Markdown renderer`,
+            //   );
+            // }
+            return blankMark;
+        }
+        return info;
+    }
+    renderInline(parent, currentPos, level) {
+        const active = [];
+        const trailing = [];
+        const inlineTokens = [];
+        const progress = (node, offset, index) => {
+            const inlinePos = currentPos + offset;
+            let marks = node ? node.marks : [];
+            // Remove marks from `hard_break` that are the last node inside
+            // that mark to prevent parser edge cases with new lines just
+            // before closing marks.
+            // TODO:
+            if (node && node.type.name === this.options.hardBreakNodeName) {
+                marks = marks.filter((m) => {
+                    if (index + 1 == parent.childCount)
+                        return false;
+                    let next = parent.child(index + 1);
+                    return m.isInSet(next.marks) &&
+                        (!next.isText || /\S/.test(next.text));
+                });
+            }
+            const leading = trailing.splice(0, trailing.length);
+            // If whitespace has to be expelled from the node, adjust
+            // leading and trailing accordingly.
+            if (node.isText && marks.some((mark) => {
+                let info = this.getMark(mark.type.name);
+                return info && info.expelEnclosingWhitespace && !mark.isInSet(active);
+            })) {
+                let [_, lead, rest] = /^(\s*)(.*)$/m.exec(node.text);
+                if (lead) {
+                    leading.push([lead, inlinePos]);
+                    node = rest ? node.withText(rest) : null;
+                    if (!node)
+                        marks = active;
+                }
+            }
+            if (node.isText && marks.some((mark) => {
+                let info = this.getMark(mark.type.name);
+                return info && info.expelEnclosingWhitespace &&
+                    (index == parent.childCount - 1 ||
+                        !mark.isInSet(parent.child(index + 1).marks));
+            })) {
+                let [_, rest, trail] = /^(.*?)(\s*)$/m.exec(node.text);
+                if (trail) {
+                    trailing.push([trail, inlinePos]);
+                    node = rest ? node.withText(rest) : null;
+                    if (!node)
+                        marks = active;
+                }
+            }
+            let inner = marks.length ? marks[marks.length - 1] : null;
+            let noEsc = inner && this.getMark(inner.type.name).escape === false;
+            let len = marks.length - (noEsc ? 1 : 0);
+            // Try to reorder 'mixable' marks, such as em and strong, which
+            // in Markdown may be opened and closed in different order, so
+            // that order of the marks for the token matches the order in
+            // active.
+            outer: for (let i = 0; i < len; i++) {
+                let mark = marks[i];
+                if (!this.getMark(mark.type.name).mixable)
+                    break;
+                for (let j = 0; j < active.length; j++) {
+                    let other = active[j];
+                    if (!this.getMark(other.type.name).mixable)
+                        break;
+                    if (mark.eq(other)) {
+                        if (i > j) {
+                            marks = marks.slice(0, j).concat(mark).concat(marks.slice(j, i))
+                                .concat(marks.slice(i + 1, len));
+                        }
+                        else if (j > i) {
+                            marks = marks.slice(0, i).concat(marks.slice(i + 1, j)).concat(mark).concat(marks.slice(j, len));
+                        }
+                        continue outer;
+                    }
+                }
+            }
+            // Find the prefix of the mark set that didn't change
+            let keep = 0;
+            while (keep < Math.min(active.length, len) && marks[keep].eq(active[keep]))
+                ++keep;
+            // Close the marks that need to be closed
+            while (keep < active.length) {
+                const x = active.pop();
+                this.markString(x, false, inlineTokens);
+            }
+            // Output any previously expelled trailing whitespace outside the marks
+            inlineTokens.push(...generateInlineTokens(leading.splice(0, leading.length)));
+            // Open the marks that need to be opened
+            while (active.length < len) {
+                let add = marks[active.length];
+                active.push(add);
+                this.markString(add, true, inlineTokens);
+            }
+            // Render the node. Special case code marks, since their content
+            // may not be escaped.
+            if (noEsc && node.isText) {
+                this.markString(inner, true, inlineTokens);
+                if (node.text) {
+                    const token = new Token('text', '', 0);
+                    token.meta = 'noEscText';
+                    token.map = [inlinePos];
+                    token.content = node.text;
+                    inlineTokens.push(token);
+                }
+                this.markString(inner, false, inlineTokens);
+            }
+            else {
+                const nodeSpec = this.nodes[node.type.name]
+                    ? this.nodes[node.type.name](node, currentPos)
+                    : blankNode;
+                let tag = '';
+                if (node.type.spec.toDOM) {
+                    const dom = node.type.spec.toDOM(node);
+                    if (Array.isArray(dom) && dom.length > 0) {
+                        tag = dom[0];
+                    }
+                }
+                if (nodeSpec.selfClose) {
+                    if (typeof nodeSpec.selfClose === 'string') {
+                        const token = new Token(nodeSpec.selfClose, tag, 0);
+                        token.meta = 'nodeSpec.selfClose';
+                        token.level = level;
+                        token.map = [inlinePos];
+                        inlineTokens.push(token);
+                    }
+                    else {
+                        const token = nodeSpec.selfClose(node);
+                        token.meta = '!nodeSpec.selfClose';
+                        token.level = level;
+                        token.map = [inlinePos];
+                        inlineTokens.push(token);
+                    }
+                }
+            }
+        };
+        parent.forEach((child, offset, index) => progress(child, offset, index));
+        // Close the marks that need to be closed
+        while (active.length > 0) {
+            const x = active.pop();
+            this.markString(x, false, inlineTokens);
+        }
+        // Output any previously expelled trailing whitespace outside the marks
+        inlineTokens.push(...generateInlineTokens(trailing.splice(0, trailing.length)));
+        return inlineTokens;
+    }
+    markString(mark, open, tokens) {
+        let info = this.getMark(mark.type.name);
+        let value = open ? info.open : info.close;
+        if (!value) {
+            /** Skip unknown marks (like textColor, highlight) - they'll be lost in markdown but won't crash */
+            console.warn('Unsupported mark type for markdown: ' + mark.type.name +
+                ', available types: ' +
+                Object.keys(this.marks).join(', ') + '. Mark will be ignored.');
+            return;
+        }
+        const token = typeof value == 'string' ? value : value(mark);
+        let tag = '';
+        if (mark.type.spec.toDOM) {
+            const dom = mark.type.spec.toDOM(mark, true);
+            if (Array.isArray(dom) && dom.length > 0) {
+                tag = dom[0];
+            }
+        }
+        if (typeof value === 'string') {
+            const token = new Token(value, tag, open ? 1 : -1);
+            token.meta = 'markString';
+            tokens.push(token);
+        }
+        else {
+            const token = value(mark);
+            if (token) {
+                token.meta = token.meta || 'markString()';
+                tokens.push(token);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+import type { Node } from 'prosemirror-model';
+import { Token } from './types.js';
+import { DocumentMarkdownInlineTokenizer, DocumentMarkdownTokenizerSpec, MarkTokenizerSpec } from './DocumentMarkdownInlineTokenizer.js';
+export declare class DocumentMarkdownTokenizer {
+    readonly nodes: {
+        [node: string]: (node: Node, index: number) => DocumentMarkdownTokenizerSpec;
+    };
+    readonly marks: {
+        [mark: string]: MarkTokenizerSpec;
+    };
+    readonly options: {
+        hardBreakNodeName: string;
+    };
+    private tokens;
+    inlineTokenizer: DocumentMarkdownInlineTokenizer;
+    constructor(nodes: {
+        [node: string]: (node: Node, index: number) => DocumentMarkdownTokenizerSpec;
+    }, marks: {
+        [mark: string]: MarkTokenizerSpec;
+    }, options?: {
+        hardBreakNodeName: string;
+    });
+    iterateNode(node: Node, currentPos: number, level?: number): void;
+    serialize(content: Node, options?: {}): Token[];
+}
+//# sourceMappingURL=DocumentMarkdownTokenizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DocumentMarkdownTokenizer.d.ts","sourceRoot":"","sources":["../../../src/extension-markdown/src/DocumentMarkdownTokenizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EACL,+BAA+B,EAC/B,6BAA6B,EAC7B,iBAAiB,EAClB,MAAM,sCAAsC,CAAC;AAI9C,qBAAa,yBAAyB;IAKlC,QAAQ,CAAC,KAAK,EAAE;QACd,CAAC,IAAI,EAAE,MAAM,GAAG,CACd,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,KACV,6BAA6B,CAAC;KACpC;IACD,QAAQ,CAAC,KAAK,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAAA;KAAE;IACrD,QAAQ,CAAC,OAAO,EAAE;QAAE,iBAAiB,EAAE,MAAM,CAAA;KAAE;IAXjD,OAAO,CAAC,MAAM,CAAoB;IAClC,eAAe,EAAE,+BAA+B,CAAC;gBAGtC,KAAK,EAAE;QACd,CAAC,IAAI,EAAE,MAAM,GAAG,CACd,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,KACV,6BAA6B,CAAC;KACpC,EACQ,KAAK,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAAA;KAAE,EAC5C,OAAO,GAAE;QAAE,iBAAiB,EAAE,MAAM,CAAA;KAE5C;IASH,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,SAAK;IA8EtD,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,GAAE,EAAO,GAAG,KAAK,EAAE;CAIpD"}

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

@@ -0,0 +1,115 @@
+import { Token } from './types.js';
+import { DocumentMarkdownInlineTokenizer, } from './DocumentMarkdownInlineTokenizer.js';
+const blankNode = { open: '', close: '' };
+export class DocumentMarkdownTokenizer {
+    constructor(nodes, marks, options = {
+        hardBreakNodeName: 'hard_break',
+    }) {
+        Object.defineProperty(this, "nodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: nodes
+        });
+        Object.defineProperty(this, "marks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: marks
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        Object.defineProperty(this, "tokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "inlineTokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.inlineTokenizer = new DocumentMarkdownInlineTokenizer(nodes, marks, options);
+    }
+    iterateNode(node, currentPos, level = -1) {
+        const nodeSpec = this.nodes[node.type.name]
+            ? this.nodes[node.type.name](node, currentPos)
+            : blankNode;
+        let tag = '';
+        if (node.type.spec.toDOM) {
+            const dom = node.type.spec.toDOM(node);
+            if (Array.isArray(dom) && dom.length > 0) {
+                tag = dom[0];
+            }
+        }
+        if (nodeSpec.open) {
+            if (typeof nodeSpec.open === 'string') {
+                const token = new Token(nodeSpec.open, tag, 1);
+                token.level = level;
+                token.meta = 'nodeSpec.open';
+                token.map = [currentPos];
+                this.tokens.push(token);
+            }
+            else {
+                const token = nodeSpec.open(node);
+                token.level = level;
+                token.meta = 'nodeSpec.open()';
+                token.map = [currentPos];
+                this.tokens.push(token);
+            }
+        }
+        if (nodeSpec.selfClose) {
+            if (typeof nodeSpec.selfClose === 'string') {
+                const token = new Token(nodeSpec.selfClose, tag, 0);
+                token.level = level;
+                token.map = [currentPos];
+                this.tokens.push(token);
+            }
+            else {
+                const token = nodeSpec.selfClose(node);
+                token.level = level;
+                token.map = [currentPos];
+                this.tokens.push(token);
+            }
+            return;
+        }
+        if (node.inlineContent) {
+            const token = new Token('inline', '', 0);
+            token.level = level + 1;
+            token.map = [currentPos];
+            this.tokens.push(token);
+            token.children = this.inlineTokenizer.renderInline(node, currentPos + 1, level + 1);
+        }
+        else if (node.childCount > 0) {
+            node.forEach((child, offset) => {
+                this.iterateNode(child, currentPos + offset + 1, level + 1);
+            });
+        }
+        if (nodeSpec.close) {
+            if (typeof nodeSpec.close === 'string') {
+                const token = new Token(nodeSpec.close, tag, -1);
+                token.meta = 'nodeSpec.close';
+                token.level = level;
+                // token.map = [currentPos];
+                this.tokens.push(token);
+            }
+            else {
+                const token = nodeSpec.close(node);
+                token.meta = 'nodeSpec.close()';
+                token.level = level;
+                // token.map = [currentPos];
+                this.tokens.push(token);
+            }
+        }
+    }
+    serialize(content, options = {}) {
+        this.iterateNode(content, -1); // doc does not have index, so I put -1 for correct calculation
+        return this.tokens;
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { Node, Schema } from 'prosemirror-model';
+import { Slice } from 'prosemirror-model';
+import { type Converter, type CoreEditor, Extension } from '../../editor/src/mod.js';
+import { MarkdownResult } from './pmToMdConverter.js';
+import type { Token } from './types.js';
+export interface MdConfig {
+    sourceMap?: boolean;
+    dispatchSourceMap?: boolean;
+    debugTokens?: boolean;
+    serializerDebug?: (...args: any[]) => void;
+    cdnUrl?: string;
+}
+export type { Token };
+export declare class ExtensionMarkdown extends Extension {
+    protected config: Partial<MdConfig>;
+    name: string;
+    constructor(config?: Partial<MdConfig>);
+    getConverters(editor: CoreEditor, schema: Schema): Record<string, Converter>;
+    toMarkdown(source: Node): MarkdownResult;
+    fromMarkdown(source: string): Promise<Slice>;
+}
+//# sourceMappingURL=ExtensionMarkdown.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionMarkdown.d.ts","sourceRoot":"","sources":["../../../src/extension-markdown/src/ExtensionMarkdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAErF,OAAO,EACL,cAAc,EAGf,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,QAAQ;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,YAAY,EAAE,KAAK,EAAE,CAAC;AAEtB,qBAAa,iBAAkB,SAAQ,SAAS;cAGR,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC;IAF/D,IAAI,SAAc;gBAEoB,MAAM,GAAE,OAAO,CAAC,QAAQ,CAAM;IAI3D,aAAa,CACpB,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC;IAmB5B,UAAU,CAAC,MAAM,EAAE,IAAI,GAAG,cAAc;IAWlC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;CAiBnD"}

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

@@ -0,0 +1,48 @@
+import { Slice } from 'prosemirror-model';
+import { Extension } from '../../editor/src/mod.js';
+import { pmToMdConverter, syncPmToMdConverter, } from './pmToMdConverter.js';
+import { mdToPmConverter, mdToPmConverterText } from './mdToPmConverter.js';
+export class ExtensionMarkdown 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: 'markdown'
+        });
+    }
+    getConverters(editor, schema) {
+        return {
+            'text/x-markdown': {
+                fromDoc: (source) => pmToMdConverter(source, { cdnUrl: this.editor.config.cdnUrl, ...this.config }, schema, editor),
+                toDoc: (source) => mdToPmConverter(source, {
+                    cdnUrl: this.editor.config.cdnUrl,
+                    ...this.config,
+                }, schema),
+            },
+        };
+    }
+    toMarkdown(source) {
+        return syncPmToMdConverter(source, {
+            sourceMap: true,
+        }, this.editor.schema, this.editor);
+    }
+    async fromMarkdown(source) {
+        const doc = await mdToPmConverterText(source, { cdnUrl: this.editor.config.cdnUrl, ...this.config }, this.editor.schema);
+        const fragment = doc.content;
+        if (fragment.content.length === 1) {
+            const first = fragment.content[0];
+            if (first.type.name === 'paragraph') {
+                return new Slice(first.content, 0, 0);
+            }
+        }
+        return new Slice(fragment, 0, 0);
+    }
+}

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

@@ -0,0 +1,61 @@
+import type { Token } from './types.js';
+import { Attrs, Mark, MarkType, Node, NodeType, Schema } from 'prosemirror-model';
+export declare class MarkdownParseState {
+    readonly schema: Schema;
+    readonly tokenHandlers: {
+        [token: string]: (stat: MarkdownParseState, token: Token, tokens: Token[], i: number) => void;
+    };
+    stack: {
+        type: NodeType;
+        attrs: Attrs | null;
+        content: Node[];
+        marks: readonly Mark[];
+    }[];
+    constructor(schema: Schema, tokenHandlers: {
+        [token: string]: (stat: MarkdownParseState, token: Token, tokens: Token[], i: number) => void;
+    });
+    top(): {
+        type: NodeType;
+        attrs: Attrs | null;
+        content: Node[];
+        marks: readonly Mark[];
+    };
+    push(elt: Node): void;
+    addText(text: string): void;
+    openMark(mark: Mark): void;
+    closeMark(mark: MarkType): void;
+    parseTokens(toks: Token[]): void;
+    addNode(type: NodeType, attrs: Attrs | null, content?: readonly Node[]): Node | null;
+    openNode(type: NodeType, attrs: Attrs | null): void;
+    closeNode(): Node | null;
+    importNodes(nodes: readonly Node[]): void;
+}
+export interface ParseSpec {
+    node?: string;
+    block?: string;
+    mark?: string;
+    custom?: (stat: MarkdownParseState, token: Token, tokens: Token[], i: number) => void;
+    attrs?: Attrs | null;
+    getAttrs?: (token: Token, tokenStream: Token[], index: number) => Attrs | null;
+    noCloseToken?: boolean;
+    ignore?: boolean;
+}
+interface MarkdownTokenizer {
+    parse(markdown: string, markdownEnv?: Record<string, any>): Array<Token>;
+}
+export declare class MarkdownParser {
+    readonly schema: Schema;
+    readonly tokenizer: MarkdownTokenizer;
+    readonly tokens: {
+        [name: string]: ParseSpec;
+    };
+    tokenHandlers: {
+        [token: string]: (stat: MarkdownParseState, token: Token, tokens: Token[], i: number) => void;
+    };
+    constructor(schema: Schema, tokenizer: MarkdownTokenizer, tokens: {
+        [name: string]: ParseSpec;
+    });
+    parse(text: string, markdownEnv?: Record<string, any>): Node;
+}
+export {};
+//# sourceMappingURL=MarkdownParser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownParser.d.ts","sourceRoot":"","sources":["../../../src/extension-markdown/src/MarkdownParser.ts"],"names":[],"mappings":"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"}