@gravity-ui/markdown-editor 13.0.0

package/build/cjs/extensions/markdown/Lists/ListsSpecs/const.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListNode = void 0;
+var ListNode;
+(function (ListNode) {
+    ListNode["ListItem"] = "list_item";
+    ListNode["BulletList"] = "bullet_list";
+    ListNode["OrderedList"] = "ordered_list";
+})(ListNode = exports.ListNode || (exports.ListNode = {}));

package/build/cjs/extensions/markdown/Lists/ListsSpecs/index.d.ts

@@ -0,0 +1,6 @@
+import type { ExtensionAuto } from '../../../../core';
+export { ListNode } from './const';
+export declare const liType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const blType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const olType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const ListsSpecs: ExtensionAuto;

package/build/cjs/extensions/markdown/Lists/ListsSpecs/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListsSpecs = exports.olType = exports.blType = exports.liType = exports.ListNode = void 0;
+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, "ListNode", { enumerable: true, get: function () { return const_2.ListNode; } });
+exports.liType = (0, schema_1.nodeTypeFactory)(const_1.ListNode.ListItem);
+exports.blType = (0, schema_1.nodeTypeFactory)(const_1.ListNode.BulletList);
+exports.olType = (0, schema_1.nodeTypeFactory)(const_1.ListNode.OrderedList);
+const ListsSpecs = (builder) => {
+    builder
+        .addNode(const_1.ListNode.ListItem, () => ({
+        spec: schema_2.schemaSpecs[const_1.ListNode.ListItem],
+        toMd: serializer_1.serializerTokens[const_1.ListNode.ListItem],
+        fromMd: { tokenSpec: parser_1.parserTokens[const_1.ListNode.ListItem] },
+    }))
+        .addNode(const_1.ListNode.BulletList, () => ({
+        spec: schema_2.schemaSpecs[const_1.ListNode.BulletList],
+        toMd: serializer_1.serializerTokens[const_1.ListNode.BulletList],
+        fromMd: { tokenSpec: parser_1.parserTokens[const_1.ListNode.BulletList] },
+    }))
+        .addNode(const_1.ListNode.OrderedList, () => ({
+        spec: schema_2.schemaSpecs[const_1.ListNode.OrderedList],
+        toMd: serializer_1.serializerTokens[const_1.ListNode.OrderedList],
+        fromMd: { tokenSpec: parser_1.parserTokens[const_1.ListNode.OrderedList] },
+    }));
+};
+exports.ListsSpecs = ListsSpecs;

package/build/cjs/extensions/markdown/Lists/ListsSpecs/parser.d.ts

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

package/build/cjs/extensions/markdown/Lists/ListsSpecs/parser.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parserTokens = void 0;
+const const_1 = require("./const");
+exports.parserTokens = {
+    [const_1.ListNode.ListItem]: { name: const_1.ListNode.ListItem, type: 'block' },
+    [const_1.ListNode.BulletList]: {
+        name: const_1.ListNode.BulletList,
+        type: 'block',
+        getAttrs: (_, tokens, i) => ({ tight: listIsTight(tokens, i) }),
+    },
+    [const_1.ListNode.OrderedList]: {
+        name: const_1.ListNode.OrderedList,
+        type: 'block',
+        getAttrs: (tok, tokens, i) => ({
+            order: Number(tok.attrGet('start')) || 1,
+            tight: listIsTight(tokens, i),
+        }),
+    },
+};
+function listIsTight(tokens, i) {
+    while (++i < tokens.length) {
+        if (tokens[i].type !== 'list_item_open')
+            return tokens[i].hidden;
+    }
+    return false;
+}

package/build/cjs/extensions/markdown/Lists/ListsSpecs/schema.d.ts

@@ -0,0 +1,3 @@
+import type { NodeSpec } from 'prosemirror-model';
+import { ListNode } from './const';
+export declare const schemaSpecs: Record<ListNode, NodeSpec>;

package/build/cjs/extensions/markdown/Lists/ListsSpecs/schema.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaSpecs = void 0;
+const const_1 = require("./const");
+exports.schemaSpecs = {
+    [const_1.ListNode.ListItem]: {
+        attrs: { tight: { default: false } },
+        content: '(paragraph|block)+',
+        defining: true,
+        parseDOM: [{ tag: 'li' }],
+        toDOM() {
+            return ['li', 0];
+        },
+        selectable: true,
+        allowSelection: false,
+        disableGapCursor: true,
+        complex: 'leaf',
+    },
+    [const_1.ListNode.BulletList]: {
+        content: `${const_1.ListNode.ListItem}+`,
+        group: 'block',
+        attrs: { tight: { default: false } },
+        parseDOM: [
+            {
+                tag: 'ul',
+                getAttrs: (dom) => ({ tight: dom.hasAttribute('data-tight') }),
+            },
+        ],
+        toDOM(node) {
+            return ['ul', { 'data-tight': node.attrs.tight ? 'true' : null }, 0];
+        },
+        selectable: false,
+        allowSelection: false,
+        complex: 'root',
+    },
+    [const_1.ListNode.OrderedList]: {
+        attrs: { order: { default: 1 }, tight: { default: false } },
+        content: `${const_1.ListNode.ListItem}+`,
+        group: 'block',
+        parseDOM: [
+            {
+                tag: 'ol',
+                getAttrs(dom) {
+                    return {
+                        order: dom.hasAttribute('start')
+                            ? Number(dom.getAttribute('start'))
+                            : 1,
+                        tight: dom.hasAttribute('data-tight'),
+                    };
+                },
+            },
+        ],
+        toDOM(node) {
+            return [
+                'ol',
+                {
+                    start: node.attrs.order === 1 ? null : node.attrs.order,
+                    'data-tight': node.attrs.tight ? 'true' : null,
+                },
+                0,
+            ];
+        },
+        selectable: false,
+        allowSelection: false,
+        complex: 'root',
+    },
+};

package/build/cjs/extensions/markdown/Lists/ListsSpecs/serializer.d.ts

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

package/build/cjs/extensions/markdown/Lists/ListsSpecs/serializer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializerTokens = void 0;
+const const_1 = require("./const");
+exports.serializerTokens = {
+    [const_1.ListNode.ListItem]: (state, node) => {
+        state.renderContent(node);
+    },
+    [const_1.ListNode.BulletList]: (state, node) => {
+        state.renderList(node, '  ', () => (node.attrs.bullet || '*') + ' ');
+    },
+    [const_1.ListNode.OrderedList]: (state, node) => {
+        const start = node.attrs.order || 1;
+        const maxW = String(start + node.childCount - 1).length;
+        const space = state.repeat(' ', maxW + 2);
+        state.renderList(node, space, (i) => {
+            const nStr = String(start + i);
+            return state.repeat(' ', maxW - nStr.length) + nStr + '. ';
+        });
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { ActionSpec, ExtensionDeps } from '../../../core';
+export declare const actions: {
+    toBulletList: ({ schema }: ExtensionDeps) => ActionSpec;
+    toOrderedList: ({ schema }: ExtensionDeps) => ActionSpec;
+    liftListItem: ({ schema }: ExtensionDeps) => ActionSpec;
+    sinkListItem: ({ schema }: ExtensionDeps) => ActionSpec;
+};

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actions = void 0;
+const prosemirror_schema_list_1 = require("prosemirror-schema-list");
+const commands_1 = require("./commands");
+const const_1 = require("./const");
+const utils_1 = require("./utils");
+exports.actions = {
+    toBulletList: ({ schema }) => {
+        const toBulletList = (0, commands_1.toList)((0, utils_1.blType)(schema));
+        return {
+            isActive: (0, utils_1.isIntoListOfType)(const_1.ListNode.BulletList),
+            isEnable: toBulletList,
+            run: toBulletList,
+        };
+    },
+    toOrderedList: ({ schema }) => {
+        const toOrderedList = (0, commands_1.toList)((0, utils_1.olType)(schema));
+        return {
+            isActive: (0, utils_1.isIntoListOfType)(const_1.ListNode.OrderedList),
+            isEnable: toOrderedList,
+            run: toOrderedList,
+        };
+    },
+    liftListItem: ({ schema }) => {
+        return {
+            isEnable: (0, prosemirror_schema_list_1.liftListItem)((0, utils_1.liType)(schema)),
+            run: (0, prosemirror_schema_list_1.liftListItem)((0, utils_1.liType)(schema)),
+        };
+    },
+    sinkListItem: ({ schema }) => {
+        return {
+            isEnable: (0, prosemirror_schema_list_1.sinkListItem)((0, utils_1.liType)(schema)),
+            run: (0, prosemirror_schema_list_1.sinkListItem)((0, utils_1.liType)(schema)),
+        };
+    },
+};

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

@@ -0,0 +1,5 @@
+import type { NodeType } from 'prosemirror-model';
+import type { Command } from 'prosemirror-state';
+export declare function toList(listType: NodeType): Command;
+export declare const liftIfCursorIsAtBeginningOfItem: Command;
+export declare const joinPrevList: Command;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinPrevList = exports.liftIfCursorIsAtBeginningOfItem = exports.toList = void 0;
+const prosemirror_schema_list_1 = require("prosemirror-schema-list");
+const join_1 = require("../../../commands/join");
+const selection_1 = require("../../../utils/selection");
+const utils_1 = require("./utils");
+function toList(listType) {
+    return (state, dispatch) => {
+        const parentList = (0, utils_1.findAnyParentList)(state.schema)(state.selection);
+        if (parentList) {
+            if (listType === parentList.node.type)
+                return true;
+            dispatch === null || dispatch === void 0 ? void 0 : dispatch(state.tr.setNodeMarkup(parentList.pos, listType));
+            return true;
+        }
+        return (0, prosemirror_schema_list_1.wrapInList)(listType)(state, dispatch);
+    };
+}
+exports.toList = toList;
+const liftIfCursorIsAtBeginningOfItem = (state, dispatch) => {
+    const $cursor = (0, selection_1.get$CursorAtBlockStart)(state.selection);
+    if (!$cursor)
+        return false;
+    const { schema } = state;
+    const parentBlock = $cursor.node($cursor.depth - 1);
+    if (parentBlock.firstChild === $cursor.parent && (0, utils_1.isListItemNode)(parentBlock)) {
+        return (0, prosemirror_schema_list_1.liftListItem)((0, utils_1.liType)(schema))(state, dispatch);
+    }
+    return false;
+};
+exports.liftIfCursorIsAtBeginningOfItem = liftIfCursorIsAtBeginningOfItem;
+exports.joinPrevList = (0, join_1.joinPreviousBlock)({
+    checkPrevNode: utils_1.isListNode,
+    skipNode: utils_1.isListOrItemNode,
+});

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

@@ -0,0 +1,7 @@
+export { ListNode } from './ListsSpecs';
+export declare enum ListAction {
+    ToBulletList = "toBulletList",
+    ToOrderedList = "toOrderedList",
+    SinkListItem = "sinkListItem",
+    LiftListItem = "liftListItem"
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListAction = exports.ListNode = void 0;
+var ListsSpecs_1 = require("./ListsSpecs");
+Object.defineProperty(exports, "ListNode", { enumerable: true, get: function () { return ListsSpecs_1.ListNode; } });
+var ListAction;
+(function (ListAction) {
+    ListAction["ToBulletList"] = "toBulletList";
+    ListAction["ToOrderedList"] = "toOrderedList";
+    ListAction["SinkListItem"] = "sinkListItem";
+    ListAction["LiftListItem"] = "liftListItem";
+})(ListAction = exports.ListAction || (exports.ListAction = {}));

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

@@ -0,0 +1,20 @@
+import type { Action, ExtensionAuto } from '../../../core';
+import { ListAction } from './const';
+import { ListsInputRulesOptions } from './inputrules';
+export { ListNode, blType, liType, olType } from './ListsSpecs';
+export declare type ListsOptions = {
+    ulKey?: string | null;
+    olKey?: string | null;
+    ulInputRules?: ListsInputRulesOptions['bulletListInputRule'];
+};
+export declare const Lists: ExtensionAuto<ListsOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [ListAction.ToBulletList]: Action;
+            [ListAction.ToOrderedList]: Action;
+            [ListAction.SinkListItem]: Action;
+            [ListAction.LiftListItem]: Action;
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lists = exports.olType = exports.liType = exports.blType = exports.ListNode = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const prosemirror_schema_list_1 = require("prosemirror-schema-list");
+const keymap_1 = require("../../../utils/keymap");
+const ListsSpecs_1 = require("./ListsSpecs");
+const actions_1 = require("./actions");
+const commands_1 = require("./commands");
+const const_1 = require("./const");
+const inputrules_1 = require("./inputrules");
+const MergeListsPlugin_1 = require("./plugins/MergeListsPlugin");
+var ListsSpecs_2 = require("./ListsSpecs");
+Object.defineProperty(exports, "ListNode", { enumerable: true, get: function () { return ListsSpecs_2.ListNode; } });
+Object.defineProperty(exports, "blType", { enumerable: true, get: function () { return ListsSpecs_2.blType; } });
+Object.defineProperty(exports, "liType", { enumerable: true, get: function () { return ListsSpecs_2.liType; } });
+Object.defineProperty(exports, "olType", { enumerable: true, get: function () { return ListsSpecs_2.olType; } });
+const Lists = (builder, opts) => {
+    builder.use(ListsSpecs_1.ListsSpecs);
+    builder.addKeymap(({ schema }) => {
+        const { ulKey, olKey } = opts !== null && opts !== void 0 ? opts : {};
+        const bindings = {};
+        if (ulKey)
+            bindings[ulKey] = (0, keymap_1.withLogAction)('bulletList', (0, commands_1.toList)((0, ListsSpecs_1.blType)(schema)));
+        if (olKey)
+            bindings[olKey] = (0, keymap_1.withLogAction)('orderedList', (0, commands_1.toList)((0, ListsSpecs_1.olType)(schema)));
+        return Object.assign({ Tab: (0, prosemirror_schema_list_1.sinkListItem)((0, ListsSpecs_1.liType)(schema)), 'Shift-Tab': (0, prosemirror_schema_list_1.liftListItem)((0, ListsSpecs_1.liType)(schema)), 'Mod-[': (0, prosemirror_schema_list_1.liftListItem)((0, ListsSpecs_1.liType)(schema)), 'Mod-]': (0, prosemirror_schema_list_1.sinkListItem)((0, ListsSpecs_1.liType)(schema)) }, bindings);
+    }, builder.Priority.High);
+    builder.addKeymap(({ schema }) => ({
+        Enter: (0, prosemirror_schema_list_1.splitListItem)((0, ListsSpecs_1.liType)(schema)),
+        Backspace: (0, prosemirror_commands_1.chainCommands)(commands_1.liftIfCursorIsAtBeginningOfItem, commands_1.joinPrevList),
+    }), builder.Priority.Low);
+    builder.use(inputrules_1.ListsInputRulesExtension, { bulletListInputRule: opts === null || opts === void 0 ? void 0 : opts.ulInputRules });
+    builder.addPlugin(MergeListsPlugin_1.mergeListsPlugin);
+    builder
+        .addAction(const_1.ListAction.ToBulletList, actions_1.actions.toBulletList)
+        .addAction(const_1.ListAction.ToOrderedList, actions_1.actions.toOrderedList)
+        .addAction(const_1.ListAction.SinkListItem, actions_1.actions.sinkListItem)
+        .addAction(const_1.ListAction.LiftListItem, actions_1.actions.liftListItem);
+};
+exports.Lists = Lists;

package/build/cjs/extensions/markdown/Lists/inputrules.d.ts

@@ -0,0 +1,26 @@
+import type { NodeType } from 'prosemirror-model';
+import type { ExtensionWithOptions } from '../../../core';
+export declare type ListsInputRulesOptions = {
+    bulletListInputRule?: false | BulletListInputRuleConfig;
+};
+export declare const ListsInputRulesExtension: ExtensionWithOptions<ListsInputRulesOptions>;
+/**
+ * Given a list node type, returns an input rule that turns a number
+ * followed by a dot at the start of a textblock into an ordered list.
+ */
+export declare function orderedListRule(nodeType: NodeType): import("prosemirror-inputrules").InputRule;
+declare type BulletListInputRuleConfig = {
+    /** @default true */
+    dash?: boolean;
+    /** @default true */
+    plus?: boolean;
+    /** @default true */
+    asterisk?: boolean;
+};
+/**
+ * Given a list node type, returns an input rule that turns a bullet
+ * (dash, plus, or asterisk) at the start of a textblock into a
+ * bullet list.
+ */
+export declare function bulletListRule(nodeType: NodeType, config?: BulletListInputRuleConfig): import("prosemirror-inputrules").InputRule | null;
+export {};

package/build/cjs/extensions/markdown/Lists/inputrules.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulletListRule = exports.orderedListRule = exports.ListsInputRulesExtension = void 0;
+const inputrules_1 = require("../../../utils/inputrules");
+const utils_1 = require("./utils");
+const ListsInputRulesExtension = (builder, options) => {
+    builder.addInputRules(({ schema }) => {
+        const rules = [orderedListRule((0, utils_1.olType)(schema))];
+        if (options.bulletListInputRule !== false) {
+            const blRule = bulletListRule((0, utils_1.blType)(schema), options.bulletListInputRule);
+            if (blRule)
+                rules.push(blRule);
+        }
+        return { rules };
+    });
+};
+exports.ListsInputRulesExtension = ListsInputRulesExtension;
+/**
+ * Given a list node type, returns an input rule that turns a number
+ * followed by a dot at the start of a textblock into an ordered list.
+ */
+function orderedListRule(nodeType) {
+    return (0, inputrules_1.wrappingInputRule)(/^(\d+)\.\s$/, nodeType, (match) => ({ order: Number(match[1]) }), (match, node) => node.childCount + node.attrs.order === Number(match[1]));
+}
+exports.orderedListRule = orderedListRule;
+/**
+ * Given a list node type, returns an input rule that turns a bullet
+ * (dash, plus, or asterisk) at the start of a textblock into a
+ * bullet list.
+ */
+function bulletListRule(nodeType, config) {
+    const bullets = [];
+    if ((config === null || config === void 0 ? void 0 : config.dash) !== false)
+        bullets.push('-');
+    if ((config === null || config === void 0 ? void 0 : config.plus) !== false)
+        bullets.push('+');
+    if ((config === null || config === void 0 ? void 0 : config.asterisk) !== false)
+        bullets.push('*');
+    if (bullets.length === 0)
+        return null;
+    const regexp = new RegExp(`^\\s*([${bullets.join('')}])\\s$`); // same as /^\s*([-+*])\s$/
+    return (0, inputrules_1.wrappingInputRule)(regexp, nodeType);
+}
+exports.bulletListRule = bulletListRule;

package/build/cjs/extensions/markdown/Lists/plugins/MergeListsPlugin.d.ts

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

package/build/cjs/extensions/markdown/Lists/plugins/MergeListsPlugin.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeListsPlugin = void 0;
+const prosemirror_state_1 = require("prosemirror-state");
+const prosemirror_utils_1 = require("prosemirror-utils");
+const utils_1 = require("../utils");
+const mergeListsPlugin = () => new prosemirror_state_1.Plugin({
+    appendTransaction(trs, oldState, newState) {
+        const docChanged = trs.some((tr) => tr.docChanged);
+        if (!docChanged)
+            return null;
+        const hasParentList = (0, prosemirror_utils_1.hasParentNode)(utils_1.isListNode)(newState.selection) ||
+            (0, prosemirror_utils_1.hasParentNode)(utils_1.isListNode)(oldState.selection);
+        if (!hasParentList)
+            return null;
+        const { tr } = newState;
+        const listNodes = (0, prosemirror_utils_1.findChildren)(tr.doc, utils_1.isListNode, true);
+        mergeAdjacentNodesWithSameType(tr, listNodes);
+        return tr.docChanged ? tr : null;
+    },
+});
+exports.mergeListsPlugin = mergeListsPlugin;
+function mergeAdjacentNodesWithSameType(tr, nodes) {
+    for (let i = 0; i < nodes.length - 1; i++) {
+        const current = nodes[i];
+        const next = nodes[i + 1];
+        if (current.node.type === next.node.type &&
+            current.pos + current.node.nodeSize === next.pos) {
+            tr.join(next.pos);
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { Node, Schema } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { ListNode } from './ListsSpecs';
+export { liType, blType, olType } from './ListsSpecs';
+export declare const findAnyParentList: (schema: Schema) => (selection: import("prosemirror-state").Selection) => import("prosemirror-utils/dist/types").FindResult;
+export declare const isIntoListOfType: (nodeName: ListNode) => (state: EditorState) => boolean;
+export declare const isListNode: ({ type }: Node) => boolean;
+export declare const isListItemNode: (node: Node) => boolean;
+export declare const isListOrItemNode: (node: Node) => boolean;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isListOrItemNode = exports.isListItemNode = exports.isListNode = exports.isIntoListOfType = exports.findAnyParentList = exports.olType = exports.blType = exports.liType = void 0;
+const prosemirror_utils_1 = require("prosemirror-utils");
+const ListsSpecs_1 = require("./ListsSpecs");
+var ListsSpecs_2 = require("./ListsSpecs");
+Object.defineProperty(exports, "liType", { enumerable: true, get: function () { return ListsSpecs_2.liType; } });
+Object.defineProperty(exports, "blType", { enumerable: true, get: function () { return ListsSpecs_2.blType; } });
+Object.defineProperty(exports, "olType", { enumerable: true, get: function () { return ListsSpecs_2.olType; } });
+const findAnyParentList = (schema) => (0, prosemirror_utils_1.findParentNodeOfType)([(0, ListsSpecs_1.blType)(schema), (0, ListsSpecs_1.olType)(schema)]);
+exports.findAnyParentList = findAnyParentList;
+const isIntoListOfType = (nodeName) => (state) => { var _a; return ((_a = (0, exports.findAnyParentList)(state.schema)(state.selection)) === null || _a === void 0 ? void 0 : _a.node.type.name) === nodeName; };
+exports.isIntoListOfType = isIntoListOfType;
+const isListNode = ({ type }) => type === (0, ListsSpecs_1.blType)(type.schema) || type === (0, ListsSpecs_1.olType)(type.schema);
+exports.isListNode = isListNode;
+const isListItemNode = (node) => node.type === (0, ListsSpecs_1.liType)(node.type.schema);
+exports.isListItemNode = isListItemNode;
+const isListOrItemNode = (node) => (0, exports.isListNode)(node) || (0, exports.isListItemNode)(node);
+exports.isListOrItemNode = isListOrItemNode;

package/build/cjs/extensions/markdown/Mark/MarkSpecs/index.d.ts

@@ -0,0 +1,4 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare const markMarkName = "mark";
+export declare const markMarkType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").MarkType;
+export declare const MarkSpecs: ExtensionAuto;

package/build/cjs/extensions/markdown/Mark/MarkSpecs/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkSpecs = exports.markMarkType = exports.markMarkName = void 0;
+const tslib_1 = require("tslib");
+const markdown_it_mark_1 = tslib_1.__importDefault(require("markdown-it-mark"));
+const schema_1 = require("../../../../utils/schema");
+exports.markMarkName = 'mark';
+exports.markMarkType = (0, schema_1.markTypeFactory)(exports.markMarkName);
+const MarkSpecs = (builder) => {
+    builder
+        .configureMd((md) => md.use(markdown_it_mark_1.default))
+        .addMark(exports.markMarkName, () => ({
+        spec: {
+            parseDOM: [{ tag: 'mark' }],
+            toDOM() {
+                return ['mark'];
+            },
+        },
+        fromMd: {
+            tokenSpec: {
+                name: exports.markMarkName,
+                type: 'mark',
+            },
+        },
+        toMd: {
+            open: '==',
+            close: '==',
+            mixable: true,
+            expelEnclosingWhitespace: true,
+        },
+    }));
+};
+exports.MarkSpecs = MarkSpecs;

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

@@ -0,0 +1,13 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { markMarkName, markMarkType } from './MarkSpecs';
+/** @deprecated Use `markMarkName` instead  */
+export declare const mark = "mark";
+declare const mAction = "mark";
+export declare const Mark: ExtensionAuto;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [mAction]: Action;
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mark = exports.mark = exports.markMarkType = exports.markMarkName = void 0;
+const actions_1 = require("../../../utils/actions");
+const inputrules_1 = require("../../../utils/inputrules");
+const MarkSpecs_1 = require("./MarkSpecs");
+var MarkSpecs_2 = require("./MarkSpecs");
+Object.defineProperty(exports, "markMarkName", { enumerable: true, get: function () { return MarkSpecs_2.markMarkName; } });
+Object.defineProperty(exports, "markMarkType", { enumerable: true, get: function () { return MarkSpecs_2.markMarkType; } });
+/** @deprecated Use `markMarkName` instead  */
+exports.mark = MarkSpecs_1.markMarkName;
+const mAction = 'mark';
+const Mark = (builder) => {
+    builder.use(MarkSpecs_1.MarkSpecs);
+    builder
+        .addAction(mAction, ({ schema }) => (0, actions_1.createToggleMarkAction)((0, MarkSpecs_1.markMarkType)(schema)))
+        .addInputRules(({ schema }) => ({
+        rules: [
+            (0, inputrules_1.markInputRule)({ open: '==', close: '==', ignoreBetween: '=' }, (0, MarkSpecs_1.markMarkType)(schema)),
+        ],
+    }));
+};
+exports.Mark = Mark;

package/build/cjs/extensions/markdown/Strike/StrikeSpecs/index.d.ts

@@ -0,0 +1,4 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare const strikeMarkName = "strike";
+export declare const strikeType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").MarkType;
+export declare const StrikeSpecs: ExtensionAuto;

package/build/cjs/extensions/markdown/Strike/StrikeSpecs/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrikeSpecs = exports.strikeType = exports.strikeMarkName = void 0;
+const schema_1 = require("../../../../utils/schema");
+exports.strikeMarkName = 'strike';
+exports.strikeType = (0, schema_1.markTypeFactory)(exports.strikeMarkName);
+const StrikeSpecs = (builder) => {
+    builder.addMark(exports.strikeMarkName, () => ({
+        spec: {
+            parseDOM: [{ tag: 'strike' }, { tag: 's' }],
+            toDOM() {
+                return ['strike'];
+            },
+        },
+        fromMd: {
+            tokenSpec: {
+                name: exports.strikeMarkName,
+                type: 'mark',
+            },
+            tokenName: 's',
+        },
+        toMd: { open: '~~', close: '~~', mixable: true, expelEnclosingWhitespace: true },
+    }));
+};
+exports.StrikeSpecs = StrikeSpecs;

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

@@ -0,0 +1,16 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { strikeMarkName, strikeType } from './StrikeSpecs';
+/** @deprecated Use `strikeMarkName` instead */
+export declare const strike = "strike";
+declare const sAction = "strike";
+export declare type StrikeOptions = {
+    strikeKey?: string | null;
+};
+export declare const Strike: ExtensionAuto<StrikeOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [sAction]: Action;
+        }
+    }
+}