@gravity-ui/markdown-editor 13.0.0

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeflistSpecs = exports.defDescType = exports.defTermType = exports.defListType = exports.DeflistNode = void 0;
+const tslib_1 = require("tslib");
+const deflist_1 = tslib_1.__importDefault(require("@diplodoc/transform/lib/plugins/deflist"));
+const schema_1 = require("../../../../utils/schema");
+const const_1 = require("./const");
+const parser_1 = require("./parser");
+const schema_2 = require("./schema");
+const serializer_1 = require("./serializer");
+var const_2 = require("./const");
+Object.defineProperty(exports, "DeflistNode", { enumerable: true, get: function () { return const_2.DeflistNode; } });
+exports.defListType = (0, schema_1.nodeTypeFactory)(const_1.DeflistNode.List);
+exports.defTermType = (0, schema_1.nodeTypeFactory)(const_1.DeflistNode.Term);
+exports.defDescType = (0, schema_1.nodeTypeFactory)(const_1.DeflistNode.Desc);
+const DeflistSpecs = (builder, opts) => {
+    const schemaSpecs = (0, schema_2.getSchemaSpecs)(opts, builder.context.get('placeholder'));
+    builder.configureMd((md) => md.use(deflist_1.default));
+    builder
+        .addNode(const_1.DeflistNode.List, () => ({
+        spec: schemaSpecs[const_1.DeflistNode.List],
+        fromMd: { tokenSpec: parser_1.parserTokens[const_1.DeflistNode.List] },
+        toMd: serializer_1.serializerTokens[const_1.DeflistNode.List],
+    }))
+        .addNode(const_1.DeflistNode.Term, () => ({
+        spec: schemaSpecs[const_1.DeflistNode.Term],
+        fromMd: { tokenSpec: parser_1.parserTokens[const_1.DeflistNode.Term] },
+        toMd: serializer_1.serializerTokens[const_1.DeflistNode.Term],
+    }))
+        .addNode(const_1.DeflistNode.Desc, () => ({
+        spec: schemaSpecs[const_1.DeflistNode.Desc],
+        fromMd: { tokenSpec: parser_1.parserTokens[const_1.DeflistNode.Desc] },
+        toMd: serializer_1.serializerTokens[const_1.DeflistNode.Desc],
+    }));
+};
+exports.DeflistSpecs = DeflistSpecs;

package/build/cjs/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/cjs/extensions/markdown/Deflist/DeflistSpecs/parser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parserTokens = void 0;
+const const_1 = require("./const");
+exports.parserTokens = {
+    [const_1.DeflistNode.List]: { name: const_1.DeflistNode.List, type: 'block' },
+    [const_1.DeflistNode.Term]: { name: const_1.DeflistNode.Term, type: 'block' },
+    [const_1.DeflistNode.Desc]: { name: const_1.DeflistNode.Desc, type: 'block' },
+};

package/build/cjs/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/cjs/extensions/markdown/Deflist/DeflistSpecs/schema.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaSpecs = void 0;
+const const_1 = require("./const");
+const DEFAULT_PLACEHOLDERS = {
+    Term: 'Definition term',
+    Desc: 'Definition description',
+};
+const getSchemaSpecs = (opts, placeholder) => {
+    var _a, _b, _c, _d;
+    return ({
+        [const_1.DeflistNode.List]: {
+            group: 'block',
+            content: `(${const_1.DeflistNode.Term} ${const_1.DeflistNode.Desc})+`,
+            parseDOM: [{ tag: 'dl' }],
+            toDOM() {
+                return ['dl', 0];
+            },
+            selectable: true,
+            allowSelection: true,
+            complex: 'root',
+        },
+        [const_1.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[const_1.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',
+        },
+        [const_1.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[const_1.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',
+        },
+    });
+};
+exports.getSchemaSpecs = getSchemaSpecs;

package/build/cjs/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/cjs/extensions/markdown/Deflist/DeflistSpecs/serializer.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializerTokens = void 0;
+const const_1 = require("./const");
+exports.serializerTokens = {
+    [const_1.DeflistNode.List]: (state, node) => {
+        state.renderContent(node);
+    },
+    [const_1.DeflistNode.Term]: (state, node) => {
+        state.renderInline(node);
+        state.ensureNewLine();
+    },
+    [const_1.DeflistNode.Desc]: (state, node) => {
+        state.wrapBlock('  ', ': ', node, () => {
+            state.renderContent(node);
+        });
+    },
+};

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitDeflist = exports.wrapToDeflist = void 0;
+const prosemirror_utils_1 = require("prosemirror-utils");
+const selection_1 = require("../../../utils/selection");
+const utils_1 = require("./utils");
+const wrapToDeflist = (state, dispatch) => {
+    const parent = (0, prosemirror_utils_1.findParentNode)((node) => node.isTextblock)(state.selection);
+    if (!parent)
+        return false;
+    dispatch === null || dispatch === void 0 ? void 0 : dispatch((0, prosemirror_utils_1.replaceParentNodeOfType)(parent.node.type, (0, utils_1.listType)(state.schema).create(null, [
+        (0, utils_1.termType)(state.schema).create(),
+        (0, utils_1.descType)(state.schema).create(null, parent.node.copy(parent.node.content)),
+    ]))(state.tr).scrollIntoView());
+    return true;
+};
+exports.wrapToDeflist = wrapToDeflist;
+const splitDeflist = (state, dispatch) => {
+    const { selection } = state;
+    if ((0, selection_1.isNodeSelection)(selection))
+        return false;
+    const parentTextblock = (0, prosemirror_utils_1.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 !== (0, utils_1.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;
+};
+exports.splitDeflist = splitDeflist;

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

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

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dlAction = exports.DeflistNode = void 0;
+var DeflistSpecs_1 = require("./DeflistSpecs");
+Object.defineProperty(exports, "DeflistNode", { enumerable: true, get: function () { return DeflistSpecs_1.DeflistNode; } });
+exports.dlAction = 'toDefList';

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deflist = exports.defDescType = exports.defTermType = exports.defListType = exports.DeflistNode = void 0;
+const DeflistSpecs_1 = require("./DeflistSpecs");
+const commands_1 = require("./commands");
+const const_1 = require("./const");
+var DeflistSpecs_2 = require("./DeflistSpecs");
+Object.defineProperty(exports, "DeflistNode", { enumerable: true, get: function () { return DeflistSpecs_2.DeflistNode; } });
+Object.defineProperty(exports, "defListType", { enumerable: true, get: function () { return DeflistSpecs_2.defListType; } });
+Object.defineProperty(exports, "defTermType", { enumerable: true, get: function () { return DeflistSpecs_2.defTermType; } });
+Object.defineProperty(exports, "defDescType", { enumerable: true, get: function () { return DeflistSpecs_2.defDescType; } });
+const Deflist = (builder, opts) => {
+    builder.use(DeflistSpecs_1.DeflistSpecs, opts);
+    builder.addKeymap(() => ({ Enter: commands_1.splitDeflist }));
+    builder.addAction(const_1.dlAction, () => {
+        return {
+            isEnable: commands_1.wrapToDeflist,
+            run: commands_1.wrapToDeflist,
+        };
+    });
+};
+exports.Deflist = Deflist;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defTermType = exports.defListType = exports.defDescType = exports.descType = exports.termType = exports.listType = void 0;
+const DeflistSpecs_1 = require("./DeflistSpecs");
+/** @deprecated Use `defListType` instead */
+exports.listType = DeflistSpecs_1.defListType;
+/** @deprecated Use `defTermType` instead */
+exports.termType = DeflistSpecs_1.defTermType;
+/** @deprecated Use `defDescType` instead */
+exports.descType = DeflistSpecs_1.defDescType;
+var DeflistSpecs_2 = require("./DeflistSpecs");
+Object.defineProperty(exports, "defDescType", { enumerable: true, get: function () { return DeflistSpecs_2.defDescType; } });
+Object.defineProperty(exports, "defListType", { enumerable: true, get: function () { return DeflistSpecs_2.defListType; } });
+Object.defineProperty(exports, "defTermType", { enumerable: true, get: function () { return DeflistSpecs_2.defTermType; } });

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

package/build/cjs/extensions/markdown/Heading/HeadingSpecs/index.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeadingSpecs = exports.headingType = exports.headingLineNumberAttr = exports.headingLevelAttr = exports.headingNodeName = void 0;
+const schema_1 = require("../../../../utils/schema");
+exports.headingNodeName = 'heading';
+exports.headingLevelAttr = 'level';
+exports.headingLineNumberAttr = 'data-line';
+exports.headingType = (0, schema_1.nodeTypeFactory)(exports.headingNodeName);
+const DEFAULT_PLACEHOLDER = (node) => 'Heading ' + node.attrs[exports.headingLevelAttr];
+const HeadingSpecs = (builder, opts) => {
+    builder.addNode(exports.headingNodeName, () => {
+        var _a, _b, _c;
+        return ({
+            spec: {
+                attrs: { [exports.headingLevelAttr]: { default: 1 }, [exports.headingLineNumberAttr]: { default: null } },
+                content: '(text | inline)*',
+                group: 'block',
+                defining: true,
+                parseDOM: [
+                    { tag: 'h1', attrs: { [exports.headingLevelAttr]: 1 } },
+                    { tag: 'h2', attrs: { [exports.headingLevelAttr]: 2 } },
+                    { tag: 'h3', attrs: { [exports.headingLevelAttr]: 3 } },
+                    { tag: 'h4', attrs: { [exports.headingLevelAttr]: 4 } },
+                    { tag: 'h5', attrs: { [exports.headingLevelAttr]: 5 } },
+                    { tag: 'h6', attrs: { [exports.headingLevelAttr]: 6 } },
+                ],
+                toDOM(node) {
+                    const lineNumber = node.attrs[exports.headingLineNumberAttr];
+                    return [
+                        'h' + node.attrs[exports.headingLevelAttr],
+                        lineNumber === null ? {} : { [exports.headingLineNumberAttr]: lineNumber },
+                        0,
+                    ];
+                },
+                placeholder: {
+                    content: (_c = (_b = (_a = builder.context.get('placeholder')) === null || _a === void 0 ? void 0 : _a.heading) !== null && _b !== void 0 ? _b : opts.headingPlaceholder) !== null && _c !== void 0 ? _c : DEFAULT_PLACEHOLDER,
+                    alwaysVisible: true,
+                },
+            },
+            fromMd: {
+                tokenSpec: {
+                    name: exports.headingNodeName,
+                    type: 'block',
+                    getAttrs: (tok) => ({ [exports.headingLevelAttr]: Number(tok.tag.slice(1)) }),
+                },
+            },
+            toMd: (state, node) => {
+                state.write(state.repeat('#', node.attrs[exports.headingLevelAttr]) + ' ');
+                state.renderInline(node);
+                state.closeBlock(node);
+            },
+        });
+    });
+};
+exports.HeadingSpecs = HeadingSpecs;

package/build/cjs/extensions/markdown/Heading/actions.d.ts

@@ -0,0 +1,4 @@
+import type { NodeType } from 'prosemirror-model';
+import type { ActionSpec } from '../../../core';
+import { HeadingLevel } from './const';
+export declare const headingAction: (nodeType: NodeType, level: HeadingLevel) => ActionSpec;

package/build/cjs/extensions/markdown/Heading/actions.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headingAction = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const const_1 = require("./const");
+const utils_1 = require("./utils");
+const headingAction = (nodeType, level) => {
+    const cmd = (0, prosemirror_commands_1.setBlockType)(nodeType, { [const_1.headingLevelAttr]: level });
+    return {
+        isActive: (0, utils_1.hasParentHeading)(level),
+        isEnable: cmd,
+        run: cmd,
+    };
+};
+exports.headingAction = headingAction;

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

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

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

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

package/build/cjs/extensions/markdown/Heading/const.d.ts

@@ -0,0 +1,10 @@
+export { headingNodeName, headingLevelAttr } from './HeadingSpecs';
+export declare type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export declare enum HeadingAction {
+    ToH1 = "toH1",
+    ToH2 = "toH2",
+    ToH3 = "toH3",
+    ToH4 = "toH4",
+    ToH5 = "toH5",
+    ToH6 = "toH6"
+}

package/build/cjs/extensions/markdown/Heading/const.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeadingAction = exports.headingLevelAttr = exports.headingNodeName = void 0;
+var HeadingSpecs_1 = require("./HeadingSpecs");
+Object.defineProperty(exports, "headingNodeName", { enumerable: true, get: function () { return HeadingSpecs_1.headingNodeName; } });
+Object.defineProperty(exports, "headingLevelAttr", { enumerable: true, get: function () { return HeadingSpecs_1.headingLevelAttr; } });
+var HeadingAction;
+(function (HeadingAction) {
+    HeadingAction["ToH1"] = "toH1";
+    HeadingAction["ToH2"] = "toH2";
+    HeadingAction["ToH3"] = "toH3";
+    HeadingAction["ToH4"] = "toH4";
+    HeadingAction["ToH5"] = "toH5";
+    HeadingAction["ToH6"] = "toH6";
+})(HeadingAction = exports.HeadingAction || (exports.HeadingAction = {}));

package/build/cjs/extensions/markdown/Heading/index.d.ts

@@ -0,0 +1,27 @@
+import type { Action, ExtensionAuto } from '../../../core';
+import { HeadingSpecsOptions } from './HeadingSpecs';
+import { HeadingAction } from './const';
+export { headingNodeName, headingType } from './HeadingSpecs';
+export { HeadingAction } from './const';
+export { hType } from './utils';
+export declare type HeadingOptions = HeadingSpecsOptions & {
+    h1Key?: string | null;
+    h2Key?: string | null;
+    h3Key?: string | null;
+    h4Key?: string | null;
+    h5Key?: string | null;
+    h6Key?: string | null;
+};
+export declare const Heading: ExtensionAuto<HeadingOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [HeadingAction.ToH1]: Action;
+            [HeadingAction.ToH2]: Action;
+            [HeadingAction.ToH3]: Action;
+            [HeadingAction.ToH4]: Action;
+            [HeadingAction.ToH5]: Action;
+            [HeadingAction.ToH6]: Action;
+        }
+    }
+}

package/build/cjs/extensions/markdown/Heading/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Heading = exports.hType = exports.HeadingAction = exports.headingType = exports.headingNodeName = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const keymap_1 = require("../../../utils/keymap");
+const HeadingSpecs_1 = require("./HeadingSpecs");
+const actions_1 = require("./actions");
+const commands_1 = require("./commands");
+const const_1 = require("./const");
+const utils_1 = require("./utils");
+var HeadingSpecs_2 = require("./HeadingSpecs");
+Object.defineProperty(exports, "headingNodeName", { enumerable: true, get: function () { return HeadingSpecs_2.headingNodeName; } });
+Object.defineProperty(exports, "headingType", { enumerable: true, get: function () { return HeadingSpecs_2.headingType; } });
+var const_2 = require("./const");
+Object.defineProperty(exports, "HeadingAction", { enumerable: true, get: function () { return const_2.HeadingAction; } });
+var utils_2 = require("./utils");
+Object.defineProperty(exports, "hType", { enumerable: true, get: function () { return utils_2.hType; } });
+const Heading = (builder, opts) => {
+    builder.use(HeadingSpecs_1.HeadingSpecs, opts);
+    builder
+        .addKeymap(({ schema }) => {
+        const { h1Key, h2Key, h3Key, h4Key, h5Key, h6Key } = opts !== null && opts !== void 0 ? opts : {};
+        const cmd4lvl = (level) => (0, prosemirror_commands_1.setBlockType)((0, utils_1.hType)(schema), { [const_1.headingLevelAttr]: level });
+        const bindings = { Backspace: commands_1.resetHeading };
+        if (h1Key)
+            bindings[h1Key] = (0, keymap_1.withLogAction)('heading1', cmd4lvl(1));
+        if (h2Key)
+            bindings[h2Key] = (0, keymap_1.withLogAction)('heading2', cmd4lvl(2));
+        if (h3Key)
+            bindings[h3Key] = (0, keymap_1.withLogAction)('heading3', cmd4lvl(3));
+        if (h4Key)
+            bindings[h4Key] = (0, keymap_1.withLogAction)('heading4', cmd4lvl(4));
+        if (h5Key)
+            bindings[h5Key] = (0, keymap_1.withLogAction)('heading5', cmd4lvl(5));
+        if (h6Key)
+            bindings[h6Key] = (0, keymap_1.withLogAction)('heading6', cmd4lvl(6));
+        return bindings;
+    })
+        .addInputRules(({ schema }) => ({ rules: [(0, utils_1.headingRule)((0, utils_1.hType)(schema), 6)] }));
+    builder
+        .addAction(const_1.HeadingAction.ToH1, ({ schema }) => (0, actions_1.headingAction)((0, utils_1.hType)(schema), 1))
+        .addAction(const_1.HeadingAction.ToH2, ({ schema }) => (0, actions_1.headingAction)((0, utils_1.hType)(schema), 2))
+        .addAction(const_1.HeadingAction.ToH3, ({ schema }) => (0, actions_1.headingAction)((0, utils_1.hType)(schema), 3))
+        .addAction(const_1.HeadingAction.ToH4, ({ schema }) => (0, actions_1.headingAction)((0, utils_1.hType)(schema), 4))
+        .addAction(const_1.HeadingAction.ToH5, ({ schema }) => (0, actions_1.headingAction)((0, utils_1.hType)(schema), 5))
+        .addAction(const_1.HeadingAction.ToH6, ({ schema }) => (0, actions_1.headingAction)((0, utils_1.hType)(schema), 6));
+};
+exports.Heading = Heading;

package/build/cjs/extensions/markdown/Heading/utils.d.ts

@@ -0,0 +1,7 @@
+import type { NodeType } from 'prosemirror-model';
+import type { EditorState } from 'prosemirror-state';
+import { HeadingLevel } from './const';
+/** @deprecated Use `headingType` instead */
+export declare const hType: (schema: import("prosemirror-model").Schema<any, any>) => NodeType;
+export declare const hasParentHeading: (level: HeadingLevel) => (state: EditorState) => boolean;
+export declare function headingRule(nodeType: NodeType, maxLevel: HeadingLevel): import("prosemirror-inputrules").InputRule;

package/build/cjs/extensions/markdown/Heading/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headingRule = exports.hasParentHeading = exports.hType = void 0;
+const prosemirror_utils_1 = require("prosemirror-utils");
+const inputrules_1 = require("../../../utils/inputrules");
+const HeadingSpecs_1 = require("./HeadingSpecs");
+const const_1 = require("./const");
+/** @deprecated Use `headingType` instead */
+exports.hType = HeadingSpecs_1.headingType;
+const hasParentHeading = (level) => (state) => (0, prosemirror_utils_1.hasParentNode)((node) => {
+    return node.type === (0, HeadingSpecs_1.headingType)(state.schema) && node.attrs[const_1.headingLevelAttr] === level;
+})(state.selection);
+exports.hasParentHeading = hasParentHeading;
+// Given a node type and a maximum level, creates an input rule that
+// turns up to that number of `#` characters followed by a space at
+// the start of a textblock into a heading whose level corresponds to
+// the number of `#` signs.
+function headingRule(nodeType, maxLevel) {
+    return (0, inputrules_1.textblockTypeInputRule)(new RegExp('^(#{1,' + maxLevel + '})\\s$'), nodeType, (match) => ({ [const_1.headingLevelAttr]: match[1].length }));
+}
+exports.headingRule = headingRule;

package/build/cjs/extensions/markdown/HorizontalRule/HorizontalRuleSpecs/index.d.ts

@@ -0,0 +1,5 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare const horizontalRuleNodeName = "horizontal_rule";
+export declare const horizontalRuleMarkupAttr = "markup";
+export declare const horizontalRuleType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const HorizontalRuleSpecs: ExtensionAuto;

package/build/cjs/extensions/markdown/HorizontalRule/HorizontalRuleSpecs/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HorizontalRuleSpecs = exports.horizontalRuleType = exports.horizontalRuleMarkupAttr = exports.horizontalRuleNodeName = void 0;
+const schema_1 = require("../../../../utils/schema");
+exports.horizontalRuleNodeName = 'horizontal_rule';
+exports.horizontalRuleMarkupAttr = 'markup';
+exports.horizontalRuleType = (0, schema_1.nodeTypeFactory)(exports.horizontalRuleNodeName);
+const HorizontalRuleSpecs = (builder) => {
+    builder.addNode(exports.horizontalRuleNodeName, () => ({
+        spec: {
+            attrs: { [exports.horizontalRuleMarkupAttr]: { default: '---' } },
+            group: 'block',
+            parseDOM: [{ tag: 'hr' }],
+            toDOM() {
+                return ['div', ['hr']];
+            },
+        },
+        fromMd: {
+            tokenName: 'hr',
+            tokenSpec: {
+                name: exports.horizontalRuleNodeName,
+                type: 'node',
+                getAttrs: (token) => ({ [exports.horizontalRuleMarkupAttr]: token.markup }),
+            },
+        },
+        toMd: (state, node) => {
+            state.write(node.attrs[exports.horizontalRuleMarkupAttr]);
+            state.closeBlock(node);
+        },
+    }));
+};
+exports.HorizontalRuleSpecs = HorizontalRuleSpecs;

package/build/cjs/extensions/markdown/HorizontalRule/index.d.ts

@@ -0,0 +1,15 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { horizontalRuleMarkupAttr, horizontalRuleNodeName, horizontalRuleType, } from './HorizontalRuleSpecs';
+/** @deprecated Use `horizontalRuleNodeName` instead */
+export declare const horizontalRule = "horizontal_rule";
+declare const hrAction = "hRule";
+/** @deprecated Use `horizontalRuleMarkupAttr` instead */
+export declare const markupAttr = "markup";
+export declare const HorizontalRule: ExtensionAuto;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [hrAction]: Action;
+        }
+    }
+}