@gravity-ui/markdown-editor 13.0.0

package/build/esm/core/markdown/MarkdownSerializer.js

@@ -0,0 +1,345 @@
+/* eslint-disable */
+// ::- A specification for serializing a ProseMirror document as
+// Markdown/CommonMark text.
+// prettier-ignore
+export class MarkdownSerializer {
+    // :: (Object<(state: MarkdownSerializerState, node: Node, parent: Node, index: number)>, Object)
+    // Construct a serializer with the given configuration. The `nodes`
+    // object should map node names in a given schema to function that
+    // take a serializer state and such a node, and serialize the node.
+    //
+    // The `marks` object should hold objects with `open` and `close`
+    // properties, which hold the strings that should appear before and
+    // after a piece of text marked that way, either directly or as a
+    // function that takes a serializer state and a mark, and returns a
+    // string. `open` and `close` can also be functions, which will be
+    // called as
+    //
+    //     (state: MarkdownSerializerState, mark: Mark,
+    //      parent: Fragment, index: number) → string
+    //
+    // Where `parent` and `index` allow you to inspect the mark's
+    // context to see which nodes it applies to.
+    //
+    // Mark information objects can also have a `mixable` property
+    // which, when `true`, indicates that the order in which the mark's
+    // opening and closing syntax appears relative to other mixable
+    // marks can be varied. (For example, you can say `**a *b***` and
+    // `*a **b***`, but not `` `a *b*` ``.)
+    //
+    // To disable character escaping in a mark, you can give it an
+    // `escape` property of `false`. Such a mark has to have the highest
+    // precedence (must always be the innermost mark).
+    //
+    // The `expelEnclosingWhitespace` mark property causes the
+    // serializer to move enclosing whitespace from inside the marks to
+    // outside the marks. This is necessary for emphasis marks as
+    // CommonMark does not permit enclosing whitespace inside emphasis
+    // marks, see: http://spec.commonmark.org/0.26/#example-330
+    constructor(nodes, marks) {
+        // :: Object<(MarkdownSerializerState, Node)> The node serializer
+        // functions for this serializer.
+        this.nodes = nodes;
+        // :: Object The mark serializer info.
+        this.marks = marks;
+    }
+    // :: (Node, ?Object) → string
+    // Serialize the content of the given node to
+    // [CommonMark](http://commonmark.org/).
+    serialize(content, options) {
+        const state = new MarkdownSerializerState(this.nodes, this.marks, options);
+        state.renderContent(content);
+        return state.out;
+    }
+    // for tests (implements SerializerTests interface)
+    containsNode(nodeName) {
+        return nodeName in this.nodes;
+    }
+    // for tests (implements SerializerTests interface)
+    containsMark(markName) {
+        return markName in this.marks;
+    }
+}
+// ::- This is an object used to track state and expose
+// methods related to markdown serialization. Instances are passed to
+// node and mark serialization methods (see `toMarkdown`).
+// prettier-ignore
+export class MarkdownSerializerState {
+    constructor(nodes, marks, options) {
+        this.nodes = nodes;
+        this.marks = marks;
+        this.delim = this.out = '';
+        this.closed = false;
+        this.inTightList = false;
+        this.noAutoBlank = false;
+        /** @type {Boolean|undefined} */
+        this.isAutolink = undefined;
+        /** @type {Boolean} */
+        this.escapeWhitespace = false;
+        // :: Object
+        // The options passed to the serializer.
+        //   tightLists:: ?bool
+        //   Whether to render lists in a tight style. This can be overridden
+        //   on a node level by specifying a tight attribute on the node.
+        //   Defaults to false.
+        this.options = options || {};
+        if (typeof this.options.tightLists === 'undefined') {
+            this.options.tightLists = false;
+        }
+    }
+    setNoAutoBlank() {
+        this.noAutoBlank = true;
+    }
+    unsetNoAutoBlank() {
+        this.noAutoBlank = false;
+    }
+    flushClose(size) {
+        if (this.closed) {
+            if (!this.atBlank() && !this.noAutoBlank)
+                this.out += '\n';
+            if (size == null)
+                size = 2;
+            if (size > 1) {
+                let delimMin = this.delim;
+                const trim = /\s+$/.exec(delimMin);
+                if (trim)
+                    delimMin = delimMin.slice(0, delimMin.length - trim[0].length);
+                if (!this.noAutoBlank) {
+                    for (let i = 1; i < size; i++) {
+                        this.out += delimMin + '\n';
+                    }
+                }
+            }
+            this.closed = false;
+        }
+    }
+    // :: (string, ?string, Node, ())
+    // Render a block, prefixing each line with `delim`, and the first
+    // line in `firstDelim`. `node` should be the node that is closed at
+    // the end of the block, and `f` is a function that renders the
+    // content of the block.
+    wrapBlock(delim, firstDelim, node, f) {
+        const old = this.delim;
+        this.write(firstDelim || delim);
+        this.delim += delim;
+        f();
+        this.delim = old;
+        this.closeBlock(node);
+    }
+    atBlank() {
+        return /(^|\n)$/.test(this.out);
+    }
+    // :: ()
+    // Ensure the current content ends with a newline.
+    ensureNewLine() {
+        if (!this.atBlank())
+            this.out += '\n';
+    }
+    // :: (?string)
+    // Prepare the state for writing output (closing closed paragraphs,
+    // adding delimiters, and so on), and then optionally add content
+    // (unescaped) to the output.
+    write(content) {
+        this.flushClose();
+        if (this.delim && this.atBlank()) {
+            this.out += this.delim;
+        }
+        if (content)
+            this.out += content;
+    }
+    // :: (Node)
+    // Close the block for the given node.
+    closeBlock(node) {
+        this.closed = node;
+    }
+    // :: (string, ?bool)
+    // Add the given text to the document. When escape is not `false`,
+    // it will be escaped.
+    text(text, escape) {
+        const lines = text.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const startOfLine = this.atBlank() || this.closed;
+            this.write();
+            let text = lines[i];
+            if (escape !== false)
+                text = this.esc(text, startOfLine);
+            if (this.escapeWhitespace)
+                text = this.escWhitespace(text);
+            this.out += text;
+            if (i != lines.length - 1)
+                this.out += '\n';
+        }
+    }
+    // :: (Node)
+    // Render the given node as a block.
+    render(node, parent, index) {
+        if (typeof parent === 'number')
+            throw new Error('!');
+        if (!this.nodes[node.type.name])
+            throw new Error('Token type `' + node.type.name + '` not supported by Markdown renderer');
+        this.nodes[node.type.name](this, node, parent, index);
+    }
+    // :: (Node)
+    // Render the contents of `parent` as block nodes.
+    renderContent(parent) {
+        parent.forEach((node, _, i) => this.render(node, parent, i));
+    }
+    // :: (Node)
+    // Render the contents of `parent` as inline content.
+    renderInline(parent) {
+        const active = [];
+        let trailing = '';
+        const progress = (node, _, index) => {
+            let marks = node ? node.marks : [];
+            // Remove marks from breaks (hard_break or soft_break) that are the last node inside
+            // that mark to prevent parser edge cases with new lines just
+            // before closing marks.
+            if (node && node.type.spec.isBreak) {
+                marks = marks.filter(m => {
+                    if (index + 1 == parent.childCount)
+                        return false;
+                    const next = parent.child(index + 1);
+                    return m.isInSet(next.marks) && (!next.isText || /\S/.test(next.text));
+                });
+            }
+            let leading = trailing;
+            trailing = '';
+            // If whitespace has to be expelled from the node, adjust
+            // leading and trailing accordingly.
+            if (node && node.isText && marks.some(mark => {
+                const info = this.marks[mark.type.name];
+                return info && info.expelEnclosingWhitespace;
+            })) {
+                const [_, lead, inner, trail] = /^(\s*)(.*?)(\s*)$/m.exec(node.text);
+                leading += lead;
+                trailing = trail;
+                if (lead || trail) {
+                    node = inner ? node.withText(inner) : null;
+                    if (!node)
+                        marks = active;
+                }
+            }
+            const inner = marks.length && marks[marks.length - 1];
+            const noEsc = inner && this.marks[inner.type.name].escape === false;
+            const 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++) {
+                const mark = marks[i];
+                if (!this.marks[mark.type.name].mixable)
+                    break;
+                for (let j = 0; j < active.length; j++) {
+                    const other = active[j];
+                    if (!this.marks[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) {
+                this.text(this.markString(active.pop(), false, parent, index), false);
+            }
+            // Output any previously expelled trailing whitespace outside the marks
+            if (leading)
+                this.text(leading);
+            // Open the marks that need to be opened
+            if (node) {
+                while (active.length < len) {
+                    const add = marks[active.length];
+                    active.push(add);
+                    this.text(this.markString(add, true, parent, index), false);
+                }
+                // Render the node. Special case code marks, since their content
+                // may not be escaped.
+                if (noEsc && node.isText) {
+                    this.text(this.markString(inner, true, parent, index) + node.text +
+                        this.markString(inner, false, parent, index + 1), false);
+                }
+                else {
+                    this.render(node, parent, index);
+                }
+            }
+        };
+        parent.forEach(progress);
+        progress(null, null, parent.childCount);
+    }
+    // :: (Node, string, (number) → string)
+    // Render a node's content as a list. `delim` should be the extra
+    // indentation added to all lines except the first in an item,
+    // `firstDelim` is a function going from an item index to a
+    // delimiter for the first line of the item.
+    renderList(node, delim, firstDelim) {
+        if (this.closed && this.closed.type == node.type) {
+            this.flushClose(3);
+        }
+        else if (this.inTightList) {
+            this.flushClose(1);
+        }
+        const isTight = typeof node.attrs.tight !== 'undefined' ? node.attrs.tight : this.options.tightLists;
+        const prevTight = this.inTightList;
+        this.inTightList = isTight;
+        node.forEach((child, _, i) => {
+            if (i && isTight)
+                this.flushClose(1);
+            this.wrapBlock(delim, firstDelim(i), node, () => this.render(child, node, i));
+        });
+        this.inTightList = prevTight;
+    }
+    // :: (string, ?bool) → string
+    // Escape the given string so that it can safely appear in Markdown
+    // content. If `startOfLine` is true, also escape characters that
+    // have special meaning only at the start of the line.
+    esc(str, startOfLine) {
+        // TODO: add a setting which characters need to be escaped
+        str = str.replace(/[`\^+*\\\|~\[\]\{\}<>\$]/g, '\\$&');
+        if (startOfLine)
+            str = str.replace(/^[:#\-*+>]/, '\\$&').replace(/^(\s*\d+)\./, '$1\\.');
+        return str;
+    }
+    escWhitespace(str) {
+        return str.replace(/ /g, '\\ ');
+    }
+    quote(str) {
+        const wrap = str.indexOf('"') == -1 ? '""' : str.indexOf("'") == -1 ? "''" : '()';
+        return wrap[0] + str + wrap[1];
+    }
+    // :: (string, number) → string
+    // Repeat the given string `n` times.
+    repeat(str, n) {
+        let out = '';
+        for (let i = 0; i < n; i++)
+            out += str;
+        return out;
+    }
+    // : (Mark, bool, string?) → string
+    // Get the markdown string for a given opening or closing mark.
+    markString(mark, open, parent, index) {
+        const info = this.marks[mark.type.name];
+        const value = open ? info.open : info.close;
+        return typeof value === 'string' ? value : value(this, mark, parent, index);
+    }
+    // :: (string) → { leading: ?string, trailing: ?string }
+    // Get leading and trailing whitespace from a string. Values of
+    // leading or trailing property of the return object will be undefined
+    // if there is no match.
+    getEnclosingWhitespace(text) {
+        return {
+            leading: (text.match(/^(\s+)/) || [])[0],
+            trailing: (text.match(/(\s+)$/) || [])[0],
+        };
+    }
+}

package/build/esm/core/types/actions.d.ts

@@ -0,0 +1,21 @@
+import type { EditorState, Transaction } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+export declare type CommandWithAttrs<T = Record<string, string>> = (state: EditorState, dispatch?: (tr: Transaction) => void, view?: EditorView, attrs?: T) => boolean;
+export interface ActionSpec {
+    /** @default () => false */
+    isActive?(state: EditorState): boolean;
+    isEnable(state: EditorState, dispatch: undefined, view: EditorView, attrs?: Record<string, unknown>): boolean;
+    run(state: EditorState, dispatch: EditorView['dispatch'], view: EditorView, attrs?: Record<string, unknown>): void;
+    /** @default () => {} */
+    meta?(state: EditorState): any;
+}
+export interface Action<A extends {} = never, M = unknown> {
+    isActive(): boolean;
+    isEnable(args?: Record<string, unknown>): boolean;
+    run(...args: A extends never ? [] : [A]): void;
+    meta(): M;
+}
+export interface ActionStorage {
+    actions: WysiwygEditor.Actions;
+    action<T extends keyof WysiwygEditor.Actions>(actionName: T): WysiwygEditor.Actions[T];
+}

package/build/esm/core/types/actions.js

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

package/build/esm/core/types/extension.d.ts

@@ -0,0 +1,44 @@
+import type MarkdownIt from 'markdown-it';
+import type OrderedMap from 'orderedmap';
+import type { MarkSpec, NodeSpec, Schema } from 'prosemirror-model';
+import type { Plugin } from 'prosemirror-state';
+import type { ExtensionBuilder } from '../ExtensionBuilder';
+import type { ActionSpec, ActionStorage } from './actions';
+import type { MarkViewConstructor, NodeViewConstructor } from './node-views';
+import type { Parser, ParserToken } from './parser';
+import type { Serializer, SerializerMarkToken, SerializerNodeToken } from './serializer';
+export declare type Extension = (builder: ExtensionBuilder) => void;
+export declare type ExtensionWithOptions<T> = (builder: ExtensionBuilder, options: T) => void;
+export declare type ExtensionAuto<T = void> = T extends void ? Extension : ExtensionWithOptions<T>;
+export declare type ExtensionSpec = {
+    configureMd(md: MarkdownIt, parserType: 'text' | 'markup'): MarkdownIt;
+    nodes(): OrderedMap<ExtensionNodeSpec>;
+    marks(): OrderedMap<ExtensionMarkSpec>;
+    plugins(deps: ExtensionDeps): Plugin[];
+    actions(deps: ExtensionDeps): Record<string, ActionSpec>;
+};
+export declare type ExtensionNodeSpec = {
+    spec: NodeSpec;
+    view?: (deps: ExtensionDeps) => NodeViewConstructor;
+    fromMd: {
+        tokenName?: string;
+        tokenSpec: ParserToken;
+    };
+    toMd: SerializerNodeToken;
+};
+export declare type ExtensionMarkSpec = {
+    spec: MarkSpec;
+    view?: (deps: ExtensionDeps) => MarkViewConstructor;
+    fromMd: {
+        tokenName?: string;
+        tokenSpec: ParserToken;
+    };
+    toMd: SerializerMarkToken;
+};
+export declare type ExtensionDeps = {
+    readonly schema: Schema;
+    readonly textParser: Parser;
+    readonly markupParser: Parser;
+    readonly serializer: Serializer;
+    readonly actions: ActionStorage;
+};

package/build/esm/core/types/extension.js

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

package/build/esm/core/types/keymap.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'prosemirror-state';
+export declare type Keymap = {
+    [key: string]: Command;
+};

package/build/esm/core/types/keymap.js

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

package/build/esm/core/types/node-views.d.ts

@@ -0,0 +1,2 @@
+import type { MarkViewConstructor, NodeViewConstructor } from 'prosemirror-view';
+export type { NodeViewConstructor, MarkViewConstructor };

package/build/esm/core/types/node-views.js

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

package/build/esm/core/types/parser.d.ts

@@ -0,0 +1,29 @@
+import type { Match } from 'linkify-it';
+import type Token from 'markdown-it/lib/token';
+import type { Node } from 'prosemirror-model';
+export interface Parser {
+    /** Parse raw markup to prosemirror's root node */
+    parse(markup: string): Node;
+    validateLink(url: string): boolean;
+    normalizeLink(url: string): string;
+    normalizeLinkText(url: string): string;
+    matchLinks(text: string): Readonly<Match>[] | null;
+}
+export interface ParserToken {
+    name: string;
+    type: 'node' | 'block' | 'mark';
+    attrs?: {
+        [name: string]: unknown;
+    };
+    getAttrs?: (token: Token, tokens: Token[], index: number) => NonNullable<ParserToken['attrs']>;
+    noCloseToken?: boolean;
+    ignore?: boolean;
+    code?: boolean;
+    /** only for tokens with type=block */
+    prepareContent?: (content: string) => string;
+    /**
+     * only for tokens with type=block and noCloseToken=true
+     * @default 'content'
+     */
+    contentField?: 'content' | 'children';
+}

package/build/esm/core/types/parser.js

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

package/build/esm/core/types/serializer.d.ts

@@ -0,0 +1,29 @@
+import type { Fragment, Mark, Node } from 'prosemirror-model';
+import type { MarkdownSerializerState as SerializerState } from '../markdown/MarkdownSerializer';
+export type { MarkdownSerializerState as SerializerState } from '../markdown/MarkdownSerializer';
+export interface Serializer {
+    /** Serialize the content of the given node to markup */
+    serialize(content: Node | Fragment, options?: object): string;
+}
+export interface SerializerTests extends Serializer {
+    containsNode(nodeName: string): boolean;
+    containsMark(markName: string): boolean;
+}
+/** see MarkdownSerializer */
+export interface SerializerNodeToken {
+    (state: SerializerState, node: Node, parent: Node, index: number): void;
+}
+/** see MarkdownSerializer */
+export interface SerializerMarkToken {
+    open: string | ((state: SerializerState, node: Mark, parent: Fragment, index: number) => string);
+    close: string | ((state: SerializerState, node: Mark, parent: Fragment, index: number) => string);
+    mixable?: boolean;
+    escape?: boolean;
+    expelEnclosingWhitespace?: boolean;
+}
+declare module 'prosemirror-model' {
+    interface NodeSpec {
+        /** Default false */
+        isBreak?: boolean;
+    }
+}

package/build/esm/core/types/serializer.js

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

package/build/esm/core/utils/actions.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from 'prosemirror-view';
+import type { Action, ActionSpec } from '../types/actions';
+export declare function bindActions<Keys extends string = string>(rawActions: Record<Keys, ActionSpec>): (view: EditorView) => Record<Keys, Action<Record<string, unknown>>>;

package/build/esm/core/utils/actions.js

@@ -0,0 +1,13 @@
+export function bindActions(rawActions) {
+    return function (view) {
+        return Object.entries(rawActions).reduce((acc, [key, spec]) => {
+            acc[key] = {
+                isActive: () => { var _a, _b; return (_b = (_a = spec.isActive) === null || _a === void 0 ? void 0 : _a.call(spec, view.state)) !== null && _b !== void 0 ? _b : false; },
+                isEnable: (arg) => spec.isEnable(view.state, undefined, view, arg),
+                run: (arg) => spec.run(view.state, view.dispatch, view, arg),
+                meta: () => { var _a; return (_a = spec.meta) === null || _a === void 0 ? void 0 : _a.call(spec, view.state); },
+            };
+            return acc;
+        }, {});
+    };
+}

package/build/esm/core/utils/metrics.d.ts

@@ -0,0 +1,3 @@
+import type { Transaction } from 'prosemirror-state';
+export declare const trackTransactionMetrics: (tr: Transaction, type: string, meta?: Record<string, any>) => Transaction;
+export declare const logTransactionMetrics: (tr: Transaction) => void;

package/build/esm/core/utils/metrics.js

@@ -0,0 +1,17 @@
+import { logger } from '../../logger';
+const METRICS_KEY = 'metrics';
+export const trackTransactionMetrics = (tr, type, meta) => {
+    tr.setMeta(METRICS_KEY, { type, meta });
+    return tr;
+};
+export const logTransactionMetrics = (tr) => {
+    const metrics = tr.getMeta(METRICS_KEY);
+    if (metrics) {
+        logger.metrics({
+            component: 'transaction',
+            event: metrics.type,
+            duration: Date.now() - tr.time,
+            meta: metrics.meta,
+        });
+    }
+};

package/build/esm/extensions/base/BaseInputRules/index.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAuto } from '../../../core';
+export declare const BaseInputRules: ExtensionAuto;

package/build/esm/extensions/base/BaseInputRules/index.js

@@ -0,0 +1,4 @@
+import { ellipsis, smartQuotes } from 'prosemirror-inputrules';
+export const BaseInputRules = (builder) => {
+    builder.addInputRules(() => ({ rules: [...smartQuotes, ellipsis] }));
+};

package/build/esm/extensions/base/BaseKeymap/index.d.ts

@@ -0,0 +1,5 @@
+import type { ExtensionAuto } from '../../../core';
+/**
+ * Add this extension after all other extensions with keymaps
+ */
+export declare const BaseKeymap: ExtensionAuto;

package/build/esm/extensions/base/BaseKeymap/index.js

@@ -0,0 +1,14 @@
+import { baseKeymap, lift, selectParentNode } from 'prosemirror-commands';
+import { undoInputRule } from 'prosemirror-inputrules';
+/**
+ * Add this extension after all other extensions with keymaps
+ */
+export const BaseKeymap = (builder) => {
+    builder
+        .addKeymap(() => ({
+        Backspace: undoInputRule,
+        'Mod-BracketLeft': lift,
+        'Alt-Shift-Escape': selectParentNode,
+    }), builder.PluginPriority.Lowest)
+        .addKeymap(() => baseKeymap, builder.PluginPriority.Lowest);
+};

package/build/esm/extensions/base/BaseSchema/BaseSchemaSpecs/index.d.ts

@@ -0,0 +1,12 @@
+import type { NodeSpec } from 'prosemirror-model';
+import type { ExtensionAuto } from '../../../../core';
+export declare enum BaseNode {
+    Doc = "doc",
+    Text = "text",
+    Paragraph = "paragraph"
+}
+export declare const pType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare type BaseSchemaSpecsOptions = {
+    paragraphPlaceholder?: NonNullable<NodeSpec['placeholder']>['content'];
+};
+export declare const BaseSchemaSpecs: ExtensionAuto<BaseSchemaSpecsOptions>;

package/build/esm/extensions/base/BaseSchema/BaseSchemaSpecs/index.js

@@ -0,0 +1,58 @@
+import { nodeTypeFactory } from '../../../../utils/schema';
+export var BaseNode;
+(function (BaseNode) {
+    BaseNode["Doc"] = "doc";
+    BaseNode["Text"] = "text";
+    BaseNode["Paragraph"] = "paragraph";
+})(BaseNode || (BaseNode = {}));
+const paragraphLineNumberAttr = 'data-line';
+export const pType = nodeTypeFactory(BaseNode.Paragraph);
+export const BaseSchemaSpecs = (builder, opts) => {
+    builder
+        .addNode(BaseNode.Doc, () => ({
+        spec: {
+            content: 'block+',
+        },
+        fromMd: { tokenSpec: { name: BaseNode.Doc, type: 'block', ignore: true } },
+        toMd: () => {
+            throw new Error('Unexpected toMd() call on doc node');
+        },
+    }))
+        .addNode(BaseNode.Text, () => ({
+        spec: {
+            group: 'inline',
+        },
+        fromMd: { tokenSpec: { name: BaseNode.Text, type: 'node', ignore: true } },
+        toMd: (state, node, parent) => {
+            const { escapeText } = parent.type.spec;
+            state.text(node.text, escapeText !== null && escapeText !== void 0 ? escapeText : !state.isAutolink);
+        },
+    }))
+        .addNode(BaseNode.Paragraph, () => ({
+        spec: {
+            attrs: { [paragraphLineNumberAttr]: { default: null } },
+            content: 'inline*',
+            group: 'block',
+            parseDOM: [{ tag: 'p' }],
+            toDOM(node) {
+                const lineNumber = node.attrs[paragraphLineNumberAttr];
+                return [
+                    'p',
+                    lineNumber === null ? {} : { [paragraphLineNumberAttr]: lineNumber },
+                    0,
+                ];
+            },
+            placeholder: opts.paragraphPlaceholder
+                ? {
+                    content: opts.paragraphPlaceholder,
+                    alwaysVisible: false,
+                }
+                : undefined,
+        },
+        fromMd: { tokenSpec: { name: BaseNode.Paragraph, type: 'block' } },
+        toMd: (state, node) => {
+            state.renderInline(node);
+            state.closeBlock(node);
+        },
+    }));
+};

package/build/esm/extensions/base/BaseSchema/index.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from 'prosemirror-state';
+import type { Action, ExtensionAuto } from '../../../core';
+import { BaseSchemaSpecsOptions } from './BaseSchemaSpecs';
+export { BaseNode, pType } from './BaseSchemaSpecs';
+declare const pAction = "toParagraph";
+export declare const toParagraph: Command;
+export declare type BaseSchemaOptions = BaseSchemaSpecsOptions & {
+    paragraphKey?: string | null;
+};
+export declare const BaseSchema: ExtensionAuto<BaseSchemaOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [pAction]: Action;
+        }
+    }
+}