@gravity-ui/markdown-editor 13.0.0

package/build/esm/extensions/markdown/CodeBlock/CodeBlockHighlight/TooltipPlugin/index.js

@@ -0,0 +1,57 @@
+import React from 'react';
+import { TrashBin } from '@gravity-ui/icons';
+import { Select } from '@gravity-ui/uikit';
+import { i18n } from '../../../../../i18n/codeblock';
+import { i18n as i18nPlaceholder } from '../../../../../i18n/placeholder';
+import { BaseTooltipPluginView } from '../../../../../plugins/BaseTooltip';
+import { Toolbar, ToolbarDataType } from '../../../../../toolbar';
+import { removeNode } from '../../../../../utils/remove-node';
+import { CodeBlockNodeAttr, codeBlockType } from '../../CodeBlockSpecs';
+import './TooltipView.css';
+const CodeMenu = ({ view, pos, node, selectItems, mapping }) => {
+    var _a;
+    const lang = node.attrs[CodeBlockNodeAttr.Lang];
+    const value = (_a = mapping[lang]) !== null && _a !== void 0 ? _a : lang;
+    const handleClick = (type) => {
+        view.focus();
+        if (type === value)
+            return;
+        view.dispatch(view.state.tr.setNodeMarkup(pos, null, {
+            [CodeBlockNodeAttr.Lang]: type,
+        }));
+    };
+    return (React.createElement(Select, { size: "m", width: "max", value: [value], onUpdate: (v) => handleClick(v[0]), options: selectItems, filterable: true, filterPlaceholder: i18nPlaceholder('select_filter'), popupClassName: "g-md-code-block__select-popup", className: "g-md-code-block__select-button", renderEmptyOptions: () => (React.createElement("div", { className: "g-md-code-block__select-empty" }, i18n('empty_option'))) }));
+};
+export const codeLangSelectTooltipViewCreator = (view, langItems, mapping = {}) => {
+    return new BaseTooltipPluginView(view, {
+        idPrefix: 'code-block-tooltip',
+        nodeType: codeBlockType(view.state.schema),
+        popupPlacement: ['bottom', 'top'],
+        content: (view, { node, pos }) => (React.createElement(Toolbar, { editor: {}, focus: () => view.focus(), className: "g-md-code-block-toolbar", data: [
+                [
+                    {
+                        id: 'code-block-type',
+                        type: ToolbarDataType.ReactComponent,
+                        component: () => (React.createElement(CodeMenu, { view: view, pos: pos, node: node, selectItems: langItems, mapping: mapping })),
+                        width: 28,
+                    },
+                ],
+                [
+                    {
+                        id: 'code-block-remove',
+                        icon: { data: TrashBin },
+                        title: i18n('remove'),
+                        type: ToolbarDataType.SingleButton,
+                        isActive: () => false,
+                        isEnable: () => true,
+                        exec: () => removeNode({
+                            pos: pos,
+                            node: node,
+                            tr: view.state.tr,
+                            dispatch: view.dispatch.bind(view),
+                        }),
+                    },
+                ],
+            ] })),
+    });
+};

package/build/esm/extensions/markdown/CodeBlock/CodeBlockSpecs/index.d.ts

@@ -0,0 +1,13 @@
+import type { ExtensionAuto, ExtensionNodeSpec } from '../../../../core';
+export declare const CodeBlockNodeAttr: {
+    readonly Lang: "data-language";
+    readonly Markup: "data-markup";
+};
+export declare const codeBlockNodeName = "code_block";
+/** @deprecated Use __CodeBlockNodeAttr__ instead */
+export declare const codeBlockLangAttr: "data-language";
+export declare const codeBlockType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare type CodeBlockSpecsOptions = {
+    nodeview?: ExtensionNodeSpec['view'];
+};
+export declare const CodeBlockSpecs: ExtensionAuto<CodeBlockSpecsOptions>;

package/build/esm/extensions/markdown/CodeBlock/CodeBlockSpecs/index.js

@@ -0,0 +1,111 @@
+import { nodeTypeFactory } from '../../../../utils/schema';
+export const CodeBlockNodeAttr = {
+    Lang: 'data-language',
+    Markup: 'data-markup',
+};
+export const codeBlockNodeName = 'code_block';
+/** @deprecated Use __CodeBlockNodeAttr__ instead */
+export const codeBlockLangAttr = CodeBlockNodeAttr.Lang;
+export const codeBlockType = nodeTypeFactory(codeBlockNodeName);
+const getLangOfNode = (node) => {
+    var _a, _b;
+    let result = node.getAttribute(CodeBlockNodeAttr.Lang) || '';
+    if (!result) {
+        const firstElementChild = node.firstElementChild;
+        if (firstElementChild &&
+            firstElementChild.nodeName.toLowerCase() === 'code' &&
+            firstElementChild.classList.contains('hljs')) {
+            result = ((_b = (_a = firstElementChild.getAttribute('class')) === null || _a === void 0 ? void 0 : _a.split(' ')) === null || _b === void 0 ? void 0 : _b[1]) || '';
+        }
+    }
+    return result;
+};
+export const CodeBlockSpecs = (builder, opts) => {
+    builder.addNode(codeBlockNodeName, () => ({
+        view: opts.nodeview,
+        spec: {
+            attrs: {
+                [CodeBlockNodeAttr.Lang]: { default: '' },
+                [CodeBlockNodeAttr.Markup]: { default: '```' },
+            },
+            content: 'text*',
+            group: 'block',
+            code: true,
+            marks: '',
+            selectable: true,
+            allowSelection: false,
+            parseDOM: [
+                {
+                    tag: 'pre',
+                    preserveWhitespace: 'full',
+                    getAttrs: (node) => {
+                        return {
+                            [CodeBlockNodeAttr.Lang]: getLangOfNode(node),
+                        };
+                    },
+                },
+            ],
+            toDOM({ attrs }) {
+                return ['pre', attrs, ['code', 0]];
+            },
+        },
+        fromMd: {
+            tokenSpec: {
+                name: codeBlockNodeName,
+                type: 'block',
+                noCloseToken: true,
+                prepareContent: removeNewLineAtEnd, // content of code blocks contains extra \n at the end
+            },
+        },
+        toMd: (state, node) => {
+            const lang = node.attrs[CodeBlockNodeAttr.Lang];
+            const markup = node.attrs[CodeBlockNodeAttr.Markup];
+            state.write(markup + lang + '\n');
+            state.text(node.textContent, false);
+            // Add a newline to the current content before adding closing marker
+            state.write('\n');
+            state.write(markup);
+            state.closeBlock(node);
+        },
+    }));
+    builder.addNode('fence', () => ({
+        //  we adding this node only for define specific 'fence' parser token,
+        //  which parse fence md token to code_block node
+        spec: {},
+        fromMd: {
+            tokenSpec: {
+                name: codeBlockNodeName,
+                type: 'block',
+                noCloseToken: true,
+                getAttrs: (tok) => {
+                    const attrs = {
+                        [CodeBlockNodeAttr.Markup]: tok.markup,
+                    };
+                    if (tok.info) {
+                        // like in markdown-it
+                        // https://github.com/markdown-it/markdown-it/blob/d07d585b6b15aaee2bc8f7a54b994526dad4dbc5/lib/renderer.mjs#L36-L37
+                        attrs[CodeBlockNodeAttr.Lang] = tok.info.split(/(\s+)/g)[0];
+                    }
+                    return attrs;
+                },
+                prepareContent: removeNewLineAtEnd, // content of fence blocks contains extra \n at the end
+            },
+        },
+        toMd: () => {
+            throw new Error('Unexpected toMd() call on fence node');
+        },
+    }));
+    builder.addKeymap(() => ({
+        Tab: (state, dispatch) => {
+            const { $anchor, $head } = state.selection;
+            if ($anchor.sameParent($head) && $anchor.parent.type.name === codeBlockNodeName) {
+                dispatch === null || dispatch === void 0 ? void 0 : dispatch(state.tr.replaceSelectionWith(state.schema.text('\t')).scrollIntoView());
+                return true;
+            }
+            return false;
+        },
+    }));
+};
+function removeNewLineAtEnd(content) {
+    return content.endsWith('\n') ? content.slice(0, content.length - 1) : content;
+}

package/build/esm/extensions/markdown/CodeBlock/commands.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'prosemirror-state';
+export declare const resetCodeblock: Command;

package/build/esm/extensions/markdown/CodeBlock/commands.js

@@ -0,0 +1,11 @@
+import { toParagraph } from '../../base/BaseSchema';
+import { cbType } from './const';
+export const resetCodeblock = (state, dispatch, view) => {
+    const { selection } = state;
+    if (selection.empty &&
+        selection.$from.parent.type === cbType(state.schema) &&
+        (view === null || view === void 0 ? void 0 : view.endOfTextblock('backward', state))) {
+        return toParagraph(state, dispatch, view);
+    }
+    return false;
+};

package/build/esm/extensions/markdown/CodeBlock/const.d.ts

@@ -0,0 +1,4 @@
+export { codeBlockNodeName, codeBlockLangAttr, CodeBlockNodeAttr as CodeBlockAttr, } from './CodeBlockSpecs';
+export declare const cbAction = "toCodeBlock";
+/** @deprecated Use `codeBlockType` instead */
+export declare const cbType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;

package/build/esm/extensions/markdown/CodeBlock/const.js

@@ -0,0 +1,5 @@
+import { codeBlockType } from './CodeBlockSpecs';
+export { codeBlockNodeName, codeBlockLangAttr, CodeBlockNodeAttr as CodeBlockAttr, } from './CodeBlockSpecs';
+export const cbAction = 'toCodeBlock';
+/** @deprecated Use `codeBlockType` instead */
+export const cbType = codeBlockType;

package/build/esm/extensions/markdown/CodeBlock/handle-paste.d.ts

@@ -0,0 +1,2 @@
+import type { EditorProps } from 'prosemirror-view';
+export declare const handlePaste: NonNullable<EditorProps['handlePaste']>;

package/build/esm/extensions/markdown/CodeBlock/handle-paste.js

@@ -0,0 +1,42 @@
+import { DataTransferType } from '../../behavior/Clipboard/utils';
+import { cbType, codeBlockLangAttr } from './const';
+export const handlePaste = (view, e) => {
+    if (!e.clipboardData || view.state.selection.$from.parent.type.spec.code)
+        return false;
+    const code = getCodeData(e.clipboardData);
+    if (!code)
+        return false;
+    let tr = view.state.tr;
+    const { schema } = tr.doc.type;
+    const codeBlockNode = cbType(schema).create({ [codeBlockLangAttr]: code.mode }, schema.text(code.value));
+    tr = tr.replaceSelectionWith(codeBlockNode);
+    view.dispatch(tr.scrollIntoView());
+    return true;
+};
+function getCodeData(data) {
+    var _a;
+    if (data.getData(DataTransferType.Text)) {
+        let editor = 'unknown';
+        let mode;
+        if (isVSCode(data)) {
+            editor = 'vscode';
+            mode = (_a = tryCatch(() => JSON.parse(data.getData(DataTransferType.VSCodeData)))) === null || _a === void 0 ? void 0 : _a.mode;
+        }
+        else
+            return null;
+        return { editor, mode, value: data.getData(DataTransferType.Text) };
+    }
+    return null;
+}
+function isVSCode(data) {
+    return data.types.includes(DataTransferType.VSCodeData);
+}
+function tryCatch(fn) {
+    try {
+        return fn();
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return undefined;
+}

package/build/esm/extensions/markdown/CodeBlock/index.d.ts

@@ -0,0 +1,18 @@
+import type { Action, ExtensionAuto } from '../../../core';
+import { HighlightLangMap } from './CodeBlockHighlight/CodeBlockHighlight';
+import { CodeBlockSpecsOptions } from './CodeBlockSpecs';
+import { cbAction } from './const';
+export { resetCodeblock } from './commands';
+export { codeBlockNodeName, CodeBlockNodeAttr, codeBlockLangAttr, codeBlockType, } from './CodeBlockSpecs';
+export declare type CodeBlockOptions = CodeBlockSpecsOptions & {
+    codeBlockKey?: string | null;
+    langs?: HighlightLangMap;
+};
+export declare const CodeBlock: ExtensionAuto<CodeBlockOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [cbAction]: Action;
+        }
+    }
+}

package/build/esm/extensions/markdown/CodeBlock/index.js

@@ -0,0 +1,55 @@
+import { newlineInCode, setBlockType } from 'prosemirror-commands';
+import { Fragment } from 'prosemirror-model';
+import { hasParentNodeOfType } from 'prosemirror-utils';
+import { isFunction } from '../../../lodash';
+import { textblockTypeInputRule } from '../../../utils/inputrules';
+import { withLogAction } from '../../../utils/keymap';
+import { CodeBlockHighlight } from './CodeBlockHighlight/CodeBlockHighlight';
+import { CodeBlockSpecs } from './CodeBlockSpecs';
+import { resetCodeblock } from './commands';
+import { cbAction, cbType } from './const';
+import { codeBlockPastePlugin } from './plugins/codeBlockPastePlugin';
+export { resetCodeblock } from './commands';
+export { codeBlockNodeName, CodeBlockNodeAttr, codeBlockLangAttr, codeBlockType, } from './CodeBlockSpecs';
+export const CodeBlock = (builder, opts) => {
+    var _a;
+    builder.use(CodeBlockSpecs, opts);
+    builder.addKeymap((deps) => {
+        const { codeBlockKey } = opts;
+        const bindings = { Enter: newlineInCode, Backspace: resetCodeblock };
+        if (codeBlockKey) {
+            bindings[codeBlockKey] = withLogAction('code_block', setBlockType(cbType(deps.schema)));
+        }
+        return bindings;
+    });
+    builder.addInputRules(({ schema }) => ({ rules: [codeBlockRule(cbType(schema))] }));
+    builder.addAction(cbAction, ({ schema, serializer }) => {
+        const cb = cbType(schema);
+        const cmd = (state, dispatch) => {
+            if (!setBlockType(cb)(state))
+                return false;
+            if (dispatch) {
+                const markup = serializer.serialize(Fragment.from(state.selection.content().content));
+                dispatch(state.tr.replaceSelectionWith(cb.createAndFill({}, markup ? state.schema.text(markup) : null)));
+            }
+            return true;
+        };
+        return {
+            isActive: (state) => hasParentNodeOfType(cb)(state.selection),
+            isEnable: cmd,
+            run: cmd,
+        };
+    });
+    builder.addPlugin(codeBlockPastePlugin, builder.Priority.High);
+    if (isFunction(opts.langs)) {
+        builder.use(opts.langs);
+    }
+    else {
+        builder.use(CodeBlockHighlight, (_a = opts.langs) !== null && _a !== void 0 ? _a : {});
+    }
+};
+// Given a code block node type, returns an input rule that turns a
+// textblock starting with three backticks into a code block.
+function codeBlockRule(nodeType) {
+    return textblockTypeInputRule(/^```$/, nodeType);
+}

package/build/esm/extensions/markdown/CodeBlock/plugins/codeBlockPastePlugin.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from 'prosemirror-state';
+export declare const codeBlockPastePlugin: () => Plugin<any>;

package/build/esm/extensions/markdown/CodeBlock/plugins/codeBlockPastePlugin.js

@@ -0,0 +1,16 @@
+import { Slice } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import { handlePaste } from '../handle-paste';
+export const codeBlockPastePlugin = () => new Plugin({
+    props: {
+        handleDOMEvents: {
+            paste(view, e) {
+                if (handlePaste(view, e, Slice.empty)) {
+                    e.preventDefault();
+                    return true;
+                }
+                return false;
+            },
+        },
+    },
+});

package/build/esm/extensions/markdown/Deflist/DeflistSpecs/const.d.ts

@@ -0,0 +1,5 @@
+export declare enum DeflistNode {
+    List = "dl",
+    Term = "dt",
+    Desc = "dd"
+}

package/build/esm/extensions/markdown/Deflist/DeflistSpecs/const.js

@@ -0,0 +1,6 @@
+export var DeflistNode;
+(function (DeflistNode) {
+    DeflistNode["List"] = "dl";
+    DeflistNode["Term"] = "dt";
+    DeflistNode["Desc"] = "dd";
+})(DeflistNode || (DeflistNode = {}));

package/build/esm/extensions/markdown/Deflist/DeflistSpecs/index.d.ts

@@ -0,0 +1,17 @@
+import type { NodeSpec } from 'prosemirror-model';
+import type { ExtensionAuto } from '../../../../core';
+export { DeflistNode } from './const';
+export declare const defListType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const defTermType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const defDescType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare type DeflistSpecsOptions = {
+    /**
+     * @deprecated: use placeholder option in BehaviorPreset instead.
+     */
+    deflistTermPlaceholder?: NonNullable<NodeSpec['placeholder']>['content'];
+    /**
+     * @deprecated: use placeholder option in BehaviorPreset instead.
+     */
+    deflistDescPlaceholder?: NonNullable<NodeSpec['placeholder']>['content'];
+};
+export declare const DeflistSpecs: ExtensionAuto<DeflistSpecsOptions>;

package/build/esm/extensions/markdown/Deflist/DeflistSpecs/index.js

@@ -0,0 +1,30 @@
+import deflistPlugin from '@diplodoc/transform/lib/plugins/deflist';
+import { nodeTypeFactory } from '../../../../utils/schema';
+import { DeflistNode } from './const';
+import { parserTokens } from './parser';
+import { getSchemaSpecs } from './schema';
+import { serializerTokens } from './serializer';
+export { DeflistNode } from './const';
+export const defListType = nodeTypeFactory(DeflistNode.List);
+export const defTermType = nodeTypeFactory(DeflistNode.Term);
+export const defDescType = nodeTypeFactory(DeflistNode.Desc);
+export const DeflistSpecs = (builder, opts) => {
+    const schemaSpecs = getSchemaSpecs(opts, builder.context.get('placeholder'));
+    builder.configureMd((md) => md.use(deflistPlugin));
+    builder
+        .addNode(DeflistNode.List, () => ({
+        spec: schemaSpecs[DeflistNode.List],
+        fromMd: { tokenSpec: parserTokens[DeflistNode.List] },
+        toMd: serializerTokens[DeflistNode.List],
+    }))
+        .addNode(DeflistNode.Term, () => ({
+        spec: schemaSpecs[DeflistNode.Term],
+        fromMd: { tokenSpec: parserTokens[DeflistNode.Term] },
+        toMd: serializerTokens[DeflistNode.Term],
+    }))
+        .addNode(DeflistNode.Desc, () => ({
+        spec: schemaSpecs[DeflistNode.Desc],
+        fromMd: { tokenSpec: parserTokens[DeflistNode.Desc] },
+        toMd: serializerTokens[DeflistNode.Desc],
+    }));
+};

package/build/esm/extensions/markdown/Deflist/DeflistSpecs/parser.d.ts

@@ -0,0 +1,3 @@
+import type { ParserToken } from '../../../../core';
+import { DeflistNode } from './const';
+export declare const parserTokens: Record<DeflistNode, ParserToken>;

package/build/esm/extensions/markdown/Deflist/DeflistSpecs/parser.js

@@ -0,0 +1,6 @@
+import { DeflistNode } from './const';
+export const parserTokens = {
+    [DeflistNode.List]: { name: DeflistNode.List, type: 'block' },
+    [DeflistNode.Term]: { name: DeflistNode.Term, type: 'block' },
+    [DeflistNode.Desc]: { name: DeflistNode.Desc, type: 'block' },
+};

package/build/esm/extensions/markdown/Deflist/DeflistSpecs/schema.d.ts

@@ -0,0 +1,5 @@
+import type { NodeSpec } from 'prosemirror-model';
+import { PlaceholderOptions } from '../../../../utils/placeholder';
+import { DeflistNode } from './const';
+import type { DeflistSpecsOptions } from './index';
+export declare const getSchemaSpecs: (opts?: DeflistSpecsOptions, placeholder?: PlaceholderOptions) => Record<DeflistNode, NodeSpec>;

package/build/esm/extensions/markdown/Deflist/DeflistSpecs/schema.js

@@ -0,0 +1,53 @@
+import { DeflistNode } from './const';
+const DEFAULT_PLACEHOLDERS = {
+    Term: 'Definition term',
+    Desc: 'Definition description',
+};
+export const getSchemaSpecs = (opts, placeholder) => {
+    var _a, _b, _c, _d;
+    return ({
+        [DeflistNode.List]: {
+            group: 'block',
+            content: `(${DeflistNode.Term} ${DeflistNode.Desc})+`,
+            parseDOM: [{ tag: 'dl' }],
+            toDOM() {
+                return ['dl', 0];
+            },
+            selectable: true,
+            allowSelection: true,
+            complex: 'root',
+        },
+        [DeflistNode.Term]: {
+            defining: true,
+            group: 'block',
+            content: 'inline*',
+            parseDOM: [{ tag: 'dt' }],
+            toDOM() {
+                return ['dt', 0];
+            },
+            placeholder: {
+                content: (_b = (_a = placeholder === null || placeholder === void 0 ? void 0 : placeholder[DeflistNode.Term]) !== null && _a !== void 0 ? _a : opts === null || opts === void 0 ? void 0 : opts.deflistTermPlaceholder) !== null && _b !== void 0 ? _b : DEFAULT_PLACEHOLDERS.Term,
+                alwaysVisible: true,
+            },
+            selectable: false,
+            allowSelection: false,
+            complex: 'leaf',
+        },
+        [DeflistNode.Desc]: {
+            defining: true,
+            group: 'block',
+            content: 'block+',
+            parseDOM: [{ tag: 'dd' }],
+            toDOM() {
+                return ['dd', 0];
+            },
+            placeholder: {
+                content: (_d = (_c = placeholder === null || placeholder === void 0 ? void 0 : placeholder[DeflistNode.Desc]) !== null && _c !== void 0 ? _c : opts === null || opts === void 0 ? void 0 : opts.deflistDescPlaceholder) !== null && _d !== void 0 ? _d : DEFAULT_PLACEHOLDERS.Desc,
+                alwaysVisible: true,
+            },
+            selectable: false,
+            allowSelection: false,
+            complex: 'leaf',
+        },
+    });
+};

package/build/esm/extensions/markdown/Deflist/DeflistSpecs/serializer.d.ts

@@ -0,0 +1,3 @@
+import type { SerializerNodeToken } from '../../../../core';
+import { DeflistNode } from './const';
+export declare const serializerTokens: Record<DeflistNode, SerializerNodeToken>;

package/build/esm/extensions/markdown/Deflist/DeflistSpecs/serializer.js

@@ -0,0 +1,15 @@
+import { DeflistNode } from './const';
+export const serializerTokens = {
+    [DeflistNode.List]: (state, node) => {
+        state.renderContent(node);
+    },
+    [DeflistNode.Term]: (state, node) => {
+        state.renderInline(node);
+        state.ensureNewLine();
+    },
+    [DeflistNode.Desc]: (state, node) => {
+        state.wrapBlock('  ', ': ', node, () => {
+            state.renderContent(node);
+        });
+    },
+};

package/build/esm/extensions/markdown/Deflist/commands.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'prosemirror-state';
+export declare const wrapToDeflist: Command;
+export declare const splitDeflist: Command;

package/build/esm/extensions/markdown/Deflist/commands.js

@@ -0,0 +1,39 @@
+import { findParentNode, replaceParentNodeOfType } from 'prosemirror-utils';
+import { isNodeSelection } from '../../../utils/selection';
+import { descType, listType, termType } from './utils';
+export const wrapToDeflist = (state, dispatch) => {
+    const parent = findParentNode((node) => node.isTextblock)(state.selection);
+    if (!parent)
+        return false;
+    dispatch === null || dispatch === void 0 ? void 0 : dispatch(replaceParentNodeOfType(parent.node.type, listType(state.schema).create(null, [
+        termType(state.schema).create(),
+        descType(state.schema).create(null, parent.node.copy(parent.node.content)),
+    ]))(state.tr).scrollIntoView());
+    return true;
+};
+export const splitDeflist = (state, dispatch) => {
+    const { selection } = state;
+    if (isNodeSelection(selection))
+        return false;
+    const parentTextblock = findParentNode((node) => node.isTextblock)(selection);
+    if (!parentTextblock)
+        return false; // check if parent is textblock
+    const isParentEmpty = parentTextblock.node.textContent === '';
+    if (!isParentEmpty)
+        return false; // check if parent textblock is empty
+    // check if parent textblock is inside description node
+    const desc = selection.$from.node(parentTextblock.depth - 1);
+    if (!desc || desc.type !== descType(state.schema))
+        return false;
+    // check if parent is last child and desc has other children
+    const isParentLastChild = desc.lastChild === parentTextblock.node;
+    if (desc.childCount < 2 || !isParentLastChild)
+        return false; // 5 || 4
+    const tr = state.tr;
+    dispatch === null || dispatch === void 0 ? void 0 : dispatch(tr
+        // remove parent text block
+        .delete(parentTextblock.pos, parentTextblock.pos + parentTextblock.node.nodeSize)
+        // insert empty textblock after deflist node
+        .insert(tr.mapping.map(selection.$from.after(parentTextblock.depth - 2)), parentTextblock.node.type.create(parentTextblock.node.attrs)));
+    return true;
+};

package/build/esm/extensions/markdown/Deflist/const.d.ts

@@ -0,0 +1,2 @@
+export { DeflistNode } from './DeflistSpecs';
+export declare const dlAction = "toDefList";

package/build/esm/extensions/markdown/Deflist/const.js

@@ -0,0 +1,2 @@
+export { DeflistNode } from './DeflistSpecs';
+export const dlAction = 'toDefList';

package/build/esm/extensions/markdown/Deflist/index.d.ts

@@ -0,0 +1,13 @@
+import type { Action, ExtensionAuto } from '../../../core';
+import { DeflistSpecsOptions } from './DeflistSpecs';
+import { dlAction } from './const';
+export { DeflistNode, defListType, defTermType, defDescType } from './DeflistSpecs';
+export declare type DeflistOptions = DeflistSpecsOptions & {};
+export declare const Deflist: ExtensionAuto<DeflistOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [dlAction]: Action;
+        }
+    }
+}

package/build/esm/extensions/markdown/Deflist/index.js

@@ -0,0 +1,14 @@
+import { DeflistSpecs } from './DeflistSpecs';
+import { splitDeflist, wrapToDeflist } from './commands';
+import { dlAction } from './const';
+export { DeflistNode, defListType, defTermType, defDescType } from './DeflistSpecs';
+export const Deflist = (builder, opts) => {
+    builder.use(DeflistSpecs, opts);
+    builder.addKeymap(() => ({ Enter: splitDeflist }));
+    builder.addAction(dlAction, () => {
+        return {
+            isEnable: wrapToDeflist,
+            run: wrapToDeflist,
+        };
+    });
+};

package/build/esm/extensions/markdown/Deflist/utils.d.ts

@@ -0,0 +1,7 @@
+/** @deprecated Use `defListType` instead */
+export declare const listType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+/** @deprecated Use `defTermType` instead */
+export declare const termType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+/** @deprecated Use `defDescType` instead */
+export declare const descType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export { defDescType, defListType, defTermType } from './DeflistSpecs';

package/build/esm/extensions/markdown/Deflist/utils.js

@@ -0,0 +1,8 @@
+import { defDescType, defListType, defTermType } from './DeflistSpecs';
+/** @deprecated Use `defListType` instead */
+export const listType = defListType;
+/** @deprecated Use `defTermType` instead */
+export const termType = defTermType;
+/** @deprecated Use `defDescType` instead */
+export const descType = defDescType;
+export { defDescType, defListType, defTermType } from './DeflistSpecs';

package/build/esm/extensions/markdown/Heading/HeadingSpecs/index.d.ts

@@ -0,0 +1,13 @@
+import type { NodeSpec } from 'prosemirror-model';
+import type { ExtensionAuto } from '../../../../core';
+export declare const headingNodeName = "heading";
+export declare const headingLevelAttr = "level";
+export declare const headingLineNumberAttr = "data-line";
+export declare const headingType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare type HeadingSpecsOptions = {
+    /**
+     * @deprecated: use placeholder option in BehaviorPreset instead.
+     */
+    headingPlaceholder?: NonNullable<NodeSpec['placeholder']>['content'];
+};
+export declare const HeadingSpecs: ExtensionAuto<HeadingSpecsOptions>;