@gravity-ui/markdown-editor 13.0.0

package/build/cjs/extensions/markdown/CodeBlock/CodeBlockHighlight/CodeBlockHighlight.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeBlockHighlight = void 0;
+const prosemirror_state_1 = require("prosemirror-state");
+const prosemirror_utils_1 = require("prosemirror-utils");
+const prosemirror_view_1 = require("prosemirror-view");
+const lodash_1 = require("../../../../lodash");
+const logger_1 = require("../../../../logger");
+const CodeBlockSpecs_1 = require("../CodeBlockSpecs");
+const TooltipPlugin_1 = require("./TooltipPlugin");
+const key = new prosemirror_state_1.PluginKey('code_block_highlight');
+const CodeBlockHighlight = (builder, opts) => {
+    let langs;
+    let lowlight;
+    let hljs;
+    try {
+        hljs = require('highlight.js/lib/core');
+        const low = require('lowlight');
+        const all = low.all;
+        const create = low.createLowlight;
+        langs = Object.assign(Object.assign({}, all), opts.langs);
+        lowlight = create(langs);
+    }
+    catch (e) {
+        logger_1.logger.info('Skip code_block highlighting');
+        return;
+    }
+    builder.addPlugin(() => {
+        const selectItems = [];
+        const mapping = {};
+        for (const lang of Object.keys(langs)) {
+            const defs = langs[lang](hljs);
+            selectItems.push({
+                value: lang,
+                content: defs.name || (0, lodash_1.capitalize)(lang),
+            });
+            if (defs.aliases) {
+                for (const alias of defs.aliases) {
+                    mapping[alias] = lang;
+                }
+            }
+        }
+        // TODO: add TAB key handler
+        // TODO: Remove constant selection of block
+        return new prosemirror_state_1.Plugin({
+            key,
+            state: {
+                init: (_, state) => getDecorations(state.doc),
+                apply: (tr, decos, oldState, newState) => {
+                    if (tr.docChanged) {
+                        const oldNodeName = oldState.selection.$head.parent.type.name;
+                        const newNodeName = newState.selection.$head.parent.type.name;
+                        // Apply decorations if:
+                        if (oldNodeName === CodeBlockSpecs_1.codeBlockNodeName ||
+                            newNodeName === CodeBlockSpecs_1.codeBlockNodeName) {
+                            // selection includes codeblock node,
+                            return getDecorations(tr.doc);
+                        }
+                        else {
+                            const oldNodes = (0, prosemirror_utils_1.findChildrenByType)(oldState.doc, (0, CodeBlockSpecs_1.codeBlockType)(oldState.schema));
+                            const newNodes = (0, prosemirror_utils_1.findChildrenByType)(newState.doc, (0, CodeBlockSpecs_1.codeBlockType)(newState.schema));
+                            if (
+                            // OR transaction adds/removes codeblock nodes,
+                            newNodes.length !== oldNodes.length ||
+                                // OR transaction has changes that completely encapsulate a node
+                                // (for example, a transaction that affects the entire document).
+                                // Such transactions can happen during collab syncing via y-prosemirror, for example.
+                                tr.steps.some((step) => {
+                                    return (stepHasFromTo(step) &&
+                                        oldNodes.some((node) => node.pos >= step.from &&
+                                            node.pos + node.node.nodeSize <= step.to));
+                                })) {
+                                return getDecorations(tr.doc);
+                            }
+                        }
+                    }
+                    return decos.map(tr.mapping, tr.doc);
+                },
+            },
+            view: (view) => (0, TooltipPlugin_1.codeLangSelectTooltipViewCreator)(view, selectItems, mapping),
+            props: {
+                decorations: (state) => {
+                    return key.getState(state);
+                },
+                nodeViews: {
+                    [CodeBlockSpecs_1.codeBlockNodeName]: (node) => {
+                        let prevLang = node.attrs[CodeBlockSpecs_1.codeBlockLangAttr];
+                        const dom = document.createElement('pre');
+                        const contentDOM = document.createElement('code');
+                        contentDOM.classList.add('hljs');
+                        if (prevLang) {
+                            dom.setAttribute(CodeBlockSpecs_1.codeBlockLangAttr, prevLang);
+                            contentDOM.classList.add(prevLang);
+                        }
+                        dom.append(contentDOM);
+                        return {
+                            dom,
+                            contentDOM,
+                            update(newNode) {
+                                if (node.type !== newNode.type)
+                                    return false;
+                                const newLang = newNode.attrs[CodeBlockSpecs_1.codeBlockLangAttr];
+                                if (prevLang !== newLang) {
+                                    contentDOM.className = 'hljs';
+                                    if (newLang) {
+                                        dom.setAttribute(CodeBlockSpecs_1.codeBlockLangAttr, newLang);
+                                        contentDOM.classList.add(newLang);
+                                    }
+                                    else {
+                                        dom.removeAttribute(CodeBlockSpecs_1.codeBlockLangAttr);
+                                    }
+                                    prevLang = newLang;
+                                }
+                                return true;
+                            },
+                        };
+                    },
+                },
+            },
+        });
+    });
+    function getDecorations(doc) {
+        const decos = [];
+        for (const { node, pos } of (0, prosemirror_utils_1.findChildrenByType)(doc, (0, CodeBlockSpecs_1.codeBlockType)(doc.type.schema), true)) {
+            let from = pos + 1;
+            let nodes;
+            const lang = node.attrs[CodeBlockSpecs_1.codeBlockLangAttr];
+            if (!lang) {
+                nodes = lowlight.highlightAuto(node.textContent).children;
+            }
+            else if (lowlight.registered(lang)) {
+                nodes = lowlight.highlight(lang, node.textContent).children;
+            }
+            else {
+                continue;
+            }
+            for (const { text, classes } of parseNodes(nodes)) {
+                const to = from + text.length;
+                if (classes.length) {
+                    decos.push(prosemirror_view_1.Decoration.inline(from, to, {
+                        class: classes.join(' '),
+                    }));
+                }
+                from = to;
+            }
+        }
+        return prosemirror_view_1.DecorationSet.create(doc, decos);
+    }
+};
+exports.CodeBlockHighlight = CodeBlockHighlight;
+function parseNodes(nodes, className = []) {
+    return nodes
+        .map((node) => {
+        var _a;
+        let classes = className;
+        if (node.type === 'element') {
+            classes = classes.concat((_a = node.properties.className) !== null && _a !== void 0 ? _a : []);
+            return parseNodes(node.children, classes);
+        }
+        return {
+            text: node.type === 'comment' || node.type === 'text' ? node.value : '',
+            classes,
+        };
+    })
+        .flat();
+}
+function stepHasFromTo(step) {
+    // @ts-expect-error
+    return typeof step.from === 'number' && typeof step.to === 'number';
+}

package/build/cjs/extensions/markdown/CodeBlock/CodeBlockHighlight/TooltipPlugin/TooltipView.css

@@ -0,0 +1,26 @@
+.g-md-code-block-toolbar {
+  margin: 2px 8px;
+}
+
+.g-md-code-tooltip-menu {
+  min-width: 150px;
+  border-radius: 4px;
+}
+
+.g-md-code-block__select-popup {
+  width: 175px;
+  max-height: 200px;
+}
+.g-md-code-block__select-popup .g-select-filter {
+  border-bottom: 1px solid var(--g-color-line-generic);
+}
+.g-md-code-block__select-popup .g-select-filter .g-text-input__content {
+  border: none;
+}
+.g-md-code-block__select-popup .g-md-code-block__select-empty {
+  margin-left: 4px;
+}
+
+.g-md-code-block__select-button {
+  margin: auto 0;
+}

package/build/cjs/extensions/markdown/CodeBlock/CodeBlockHighlight/TooltipPlugin/index.d.ts

@@ -0,0 +1,4 @@
+import { SelectOption } from '@gravity-ui/uikit';
+import { EditorView } from 'prosemirror-view';
+import { BaseTooltipPluginView } from '../../../../../plugins/BaseTooltip';
+export declare const codeLangSelectTooltipViewCreator: (view: EditorView, langItems: SelectOption[], mapping?: Record<string, string>) => BaseTooltipPluginView;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeLangSelectTooltipViewCreator = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const icons_1 = require("@gravity-ui/icons");
+const uikit_1 = require("@gravity-ui/uikit");
+const codeblock_1 = require("../../../../../i18n/codeblock");
+const placeholder_1 = require("../../../../../i18n/placeholder");
+const BaseTooltip_1 = require("../../../../../plugins/BaseTooltip");
+const toolbar_1 = require("../../../../../toolbar");
+const remove_node_1 = require("../../../../../utils/remove-node");
+const CodeBlockSpecs_1 = require("../../CodeBlockSpecs");
+const CodeMenu = ({ view, pos, node, selectItems, mapping }) => {
+    var _a;
+    const lang = node.attrs[CodeBlockSpecs_1.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, {
+            [CodeBlockSpecs_1.CodeBlockNodeAttr.Lang]: type,
+        }));
+    };
+    return (react_1.default.createElement(uikit_1.Select, { size: "m", width: "max", value: [value], onUpdate: (v) => handleClick(v[0]), options: selectItems, filterable: true, filterPlaceholder: (0, placeholder_1.i18n)('select_filter'), popupClassName: "g-md-code-block__select-popup", className: "g-md-code-block__select-button", renderEmptyOptions: () => (react_1.default.createElement("div", { className: "g-md-code-block__select-empty" }, (0, codeblock_1.i18n)('empty_option'))) }));
+};
+const codeLangSelectTooltipViewCreator = (view, langItems, mapping = {}) => {
+    return new BaseTooltip_1.BaseTooltipPluginView(view, {
+        idPrefix: 'code-block-tooltip',
+        nodeType: (0, CodeBlockSpecs_1.codeBlockType)(view.state.schema),
+        popupPlacement: ['bottom', 'top'],
+        content: (view, { node, pos }) => (react_1.default.createElement(toolbar_1.Toolbar, { editor: {}, focus: () => view.focus(), className: "g-md-code-block-toolbar", data: [
+                [
+                    {
+                        id: 'code-block-type',
+                        type: toolbar_1.ToolbarDataType.ReactComponent,
+                        component: () => (react_1.default.createElement(CodeMenu, { view: view, pos: pos, node: node, selectItems: langItems, mapping: mapping })),
+                        width: 28,
+                    },
+                ],
+                [
+                    {
+                        id: 'code-block-remove',
+                        icon: { data: icons_1.TrashBin },
+                        title: (0, codeblock_1.i18n)('remove'),
+                        type: toolbar_1.ToolbarDataType.SingleButton,
+                        isActive: () => false,
+                        isEnable: () => true,
+                        exec: () => (0, remove_node_1.removeNode)({
+                            pos: pos,
+                            node: node,
+                            tr: view.state.tr,
+                            dispatch: view.dispatch.bind(view),
+                        }),
+                    },
+                ],
+            ] })),
+    });
+};
+exports.codeLangSelectTooltipViewCreator = codeLangSelectTooltipViewCreator;

package/build/cjs/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/cjs/extensions/markdown/CodeBlock/CodeBlockSpecs/index.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeBlockSpecs = exports.codeBlockType = exports.codeBlockLangAttr = exports.codeBlockNodeName = exports.CodeBlockNodeAttr = void 0;
+const schema_1 = require("../../../../utils/schema");
+exports.CodeBlockNodeAttr = {
+    Lang: 'data-language',
+    Markup: 'data-markup',
+};
+exports.codeBlockNodeName = 'code_block';
+/** @deprecated Use __CodeBlockNodeAttr__ instead */
+exports.codeBlockLangAttr = exports.CodeBlockNodeAttr.Lang;
+exports.codeBlockType = (0, schema_1.nodeTypeFactory)(exports.codeBlockNodeName);
+const getLangOfNode = (node) => {
+    var _a, _b;
+    let result = node.getAttribute(exports.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;
+};
+const CodeBlockSpecs = (builder, opts) => {
+    builder.addNode(exports.codeBlockNodeName, () => ({
+        view: opts.nodeview,
+        spec: {
+            attrs: {
+                [exports.CodeBlockNodeAttr.Lang]: { default: '' },
+                [exports.CodeBlockNodeAttr.Markup]: { default: '```' },
+            },
+            content: 'text*',
+            group: 'block',
+            code: true,
+            marks: '',
+            selectable: true,
+            allowSelection: false,
+            parseDOM: [
+                {
+                    tag: 'pre',
+                    preserveWhitespace: 'full',
+                    getAttrs: (node) => {
+                        return {
+                            [exports.CodeBlockNodeAttr.Lang]: getLangOfNode(node),
+                        };
+                    },
+                },
+            ],
+            toDOM({ attrs }) {
+                return ['pre', attrs, ['code', 0]];
+            },
+        },
+        fromMd: {
+            tokenSpec: {
+                name: exports.codeBlockNodeName,
+                type: 'block',
+                noCloseToken: true,
+                prepareContent: removeNewLineAtEnd, // content of code blocks contains extra \n at the end
+            },
+        },
+        toMd: (state, node) => {
+            const lang = node.attrs[exports.CodeBlockNodeAttr.Lang];
+            const markup = node.attrs[exports.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: exports.codeBlockNodeName,
+                type: 'block',
+                noCloseToken: true,
+                getAttrs: (tok) => {
+                    const attrs = {
+                        [exports.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[exports.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 === exports.codeBlockNodeName) {
+                dispatch === null || dispatch === void 0 ? void 0 : dispatch(state.tr.replaceSelectionWith(state.schema.text('\t')).scrollIntoView());
+                return true;
+            }
+            return false;
+        },
+    }));
+};
+exports.CodeBlockSpecs = CodeBlockSpecs;
+function removeNewLineAtEnd(content) {
+    return content.endsWith('\n') ? content.slice(0, content.length - 1) : content;
+}

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

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetCodeblock = void 0;
+const BaseSchema_1 = require("../../base/BaseSchema");
+const const_1 = require("./const");
+const resetCodeblock = (state, dispatch, view) => {
+    const { selection } = state;
+    if (selection.empty &&
+        selection.$from.parent.type === (0, const_1.cbType)(state.schema) &&
+        (view === null || view === void 0 ? void 0 : view.endOfTextblock('backward', state))) {
+        return (0, BaseSchema_1.toParagraph)(state, dispatch, view);
+    }
+    return false;
+};
+exports.resetCodeblock = resetCodeblock;

package/build/cjs/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/cjs/extensions/markdown/CodeBlock/const.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cbType = exports.cbAction = exports.CodeBlockAttr = exports.codeBlockLangAttr = exports.codeBlockNodeName = void 0;
+const CodeBlockSpecs_1 = require("./CodeBlockSpecs");
+var CodeBlockSpecs_2 = require("./CodeBlockSpecs");
+Object.defineProperty(exports, "codeBlockNodeName", { enumerable: true, get: function () { return CodeBlockSpecs_2.codeBlockNodeName; } });
+Object.defineProperty(exports, "codeBlockLangAttr", { enumerable: true, get: function () { return CodeBlockSpecs_2.codeBlockLangAttr; } });
+Object.defineProperty(exports, "CodeBlockAttr", { enumerable: true, get: function () { return CodeBlockSpecs_2.CodeBlockNodeAttr; } });
+exports.cbAction = 'toCodeBlock';
+/** @deprecated Use `codeBlockType` instead */
+exports.cbType = CodeBlockSpecs_1.codeBlockType;

package/build/cjs/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/cjs/extensions/markdown/CodeBlock/handle-paste.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePaste = void 0;
+const utils_1 = require("../../behavior/Clipboard/utils");
+const const_1 = require("./const");
+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 = (0, const_1.cbType)(schema).create({ [const_1.codeBlockLangAttr]: code.mode }, schema.text(code.value));
+    tr = tr.replaceSelectionWith(codeBlockNode);
+    view.dispatch(tr.scrollIntoView());
+    return true;
+};
+exports.handlePaste = handlePaste;
+function getCodeData(data) {
+    var _a;
+    if (data.getData(utils_1.DataTransferType.Text)) {
+        let editor = 'unknown';
+        let mode;
+        if (isVSCode(data)) {
+            editor = 'vscode';
+            mode = (_a = tryCatch(() => JSON.parse(data.getData(utils_1.DataTransferType.VSCodeData)))) === null || _a === void 0 ? void 0 : _a.mode;
+        }
+        else
+            return null;
+        return { editor, mode, value: data.getData(utils_1.DataTransferType.Text) };
+    }
+    return null;
+}
+function isVSCode(data) {
+    return data.types.includes(utils_1.DataTransferType.VSCodeData);
+}
+function tryCatch(fn) {
+    try {
+        return fn();
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return undefined;
+}

package/build/cjs/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/cjs/extensions/markdown/CodeBlock/index.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeBlock = exports.codeBlockType = exports.codeBlockLangAttr = exports.CodeBlockNodeAttr = exports.codeBlockNodeName = exports.resetCodeblock = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const prosemirror_model_1 = require("prosemirror-model");
+const prosemirror_utils_1 = require("prosemirror-utils");
+const lodash_1 = require("../../../lodash");
+const inputrules_1 = require("../../../utils/inputrules");
+const keymap_1 = require("../../../utils/keymap");
+const CodeBlockHighlight_1 = require("./CodeBlockHighlight/CodeBlockHighlight");
+const CodeBlockSpecs_1 = require("./CodeBlockSpecs");
+const commands_1 = require("./commands");
+const const_1 = require("./const");
+const codeBlockPastePlugin_1 = require("./plugins/codeBlockPastePlugin");
+var commands_2 = require("./commands");
+Object.defineProperty(exports, "resetCodeblock", { enumerable: true, get: function () { return commands_2.resetCodeblock; } });
+var CodeBlockSpecs_2 = require("./CodeBlockSpecs");
+Object.defineProperty(exports, "codeBlockNodeName", { enumerable: true, get: function () { return CodeBlockSpecs_2.codeBlockNodeName; } });
+Object.defineProperty(exports, "CodeBlockNodeAttr", { enumerable: true, get: function () { return CodeBlockSpecs_2.CodeBlockNodeAttr; } });
+Object.defineProperty(exports, "codeBlockLangAttr", { enumerable: true, get: function () { return CodeBlockSpecs_2.codeBlockLangAttr; } });
+Object.defineProperty(exports, "codeBlockType", { enumerable: true, get: function () { return CodeBlockSpecs_2.codeBlockType; } });
+const CodeBlock = (builder, opts) => {
+    var _a;
+    builder.use(CodeBlockSpecs_1.CodeBlockSpecs, opts);
+    builder.addKeymap((deps) => {
+        const { codeBlockKey } = opts;
+        const bindings = { Enter: prosemirror_commands_1.newlineInCode, Backspace: commands_1.resetCodeblock };
+        if (codeBlockKey) {
+            bindings[codeBlockKey] = (0, keymap_1.withLogAction)('code_block', (0, prosemirror_commands_1.setBlockType)((0, const_1.cbType)(deps.schema)));
+        }
+        return bindings;
+    });
+    builder.addInputRules(({ schema }) => ({ rules: [codeBlockRule((0, const_1.cbType)(schema))] }));
+    builder.addAction(const_1.cbAction, ({ schema, serializer }) => {
+        const cb = (0, const_1.cbType)(schema);
+        const cmd = (state, dispatch) => {
+            if (!(0, prosemirror_commands_1.setBlockType)(cb)(state))
+                return false;
+            if (dispatch) {
+                const markup = serializer.serialize(prosemirror_model_1.Fragment.from(state.selection.content().content));
+                dispatch(state.tr.replaceSelectionWith(cb.createAndFill({}, markup ? state.schema.text(markup) : null)));
+            }
+            return true;
+        };
+        return {
+            isActive: (state) => (0, prosemirror_utils_1.hasParentNodeOfType)(cb)(state.selection),
+            isEnable: cmd,
+            run: cmd,
+        };
+    });
+    builder.addPlugin(codeBlockPastePlugin_1.codeBlockPastePlugin, builder.Priority.High);
+    if ((0, lodash_1.isFunction)(opts.langs)) {
+        builder.use(opts.langs);
+    }
+    else {
+        builder.use(CodeBlockHighlight_1.CodeBlockHighlight, (_a = opts.langs) !== null && _a !== void 0 ? _a : {});
+    }
+};
+exports.CodeBlock = CodeBlock;
+// 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 (0, inputrules_1.textblockTypeInputRule)(/^```$/, nodeType);
+}

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeBlockPastePlugin = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const prosemirror_state_1 = require("prosemirror-state");
+const handle_paste_1 = require("../handle-paste");
+const codeBlockPastePlugin = () => new prosemirror_state_1.Plugin({
+    props: {
+        handleDOMEvents: {
+            paste(view, e) {
+                if ((0, handle_paste_1.handlePaste)(view, e, prosemirror_model_1.Slice.empty)) {
+                    e.preventDefault();
+                    return true;
+                }
+                return false;
+            },
+        },
+    },
+});
+exports.codeBlockPastePlugin = codeBlockPastePlugin;

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

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

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeflistNode = void 0;
+var DeflistNode;
+(function (DeflistNode) {
+    DeflistNode["List"] = "dl";
+    DeflistNode["Term"] = "dt";
+    DeflistNode["Desc"] = "dd";
+})(DeflistNode = exports.DeflistNode || (exports.DeflistNode = {}));

package/build/cjs/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>;