decap-cms-widget-markdown 2.16.0-beta.0

package/dist/esm/MarkdownControl/plugins/lists/locations/isSelectionWithinNoninitialListItem.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isSelectionWithinNoninitialListItem(editor) {
+  if (!editor.selection) return false;
+  const [, path] = _slate.Editor.above(editor, {
+    match: n => n.type === 'list-item',
+    mode: 'lowest',
+    at: _slate.Range.start(editor.selection)
+  });
+  if (path && path.length > 0 && path[path.length - 1] > 0) return true;
+}
+var _default = isSelectionWithinNoninitialListItem;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/selectors/getListContainedInListItem.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getListContainedInListItem(editor) {
+  if (!editor.selection) return false;
+  const [, paragraphPath] = _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, 'paragraph'));
+  return _slate.Editor.next(editor, {
+    at: paragraphPath
+  });
+}
+var _default = getListContainedInListItem;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/selectors/getLowestAncestorList.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getLowestAncestorList(editor) {
+  if (!editor.selection) return false;
+  return _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, 'list'));
+}
+var _default = getLowestAncestorList;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/selectors/getLowestAncestorQuote.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getLowestAncestorQuote(editor) {
+  if (!editor.selection) return false;
+  return _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, 'quote'));
+}
+var _default = getLowestAncestorQuote;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/transforms/changeListType.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function changeListType(editor, type) {
+  _slate.Editor.withoutNormalizing(editor, () => {
+    // wrap selected list items into new type
+    _slate.Transforms.wrapNodes(editor, {
+      type
+    }, (0, _lowestMatchedAncestor.default)(editor, 'list-item'));
+    // lift the new list of the current list, split if necessary
+    _slate.Transforms.liftNodes(editor, (0, _lowestMatchedAncestor.default)(editor, type));
+  });
+  _slate.Editor.normalize(editor, {
+    force: true
+  });
+}
+var _default = changeListType;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/transforms/convertParagraphToListItem.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _liftFirstMatchedParent = _interopRequireDefault(require("./liftFirstMatchedParent"));
+var _wrapFirstMatchedParent = _interopRequireDefault(require("./wrapFirstMatchedParent"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function convertParagraphToListItem(editor) {
+  _slate.Editor.withoutNormalizing(editor, () => {
+    // wrap the paragraph in a list item
+    (0, _wrapFirstMatchedParent.default)(editor, 'paragraph', {
+      type: 'list-item'
+    });
+    // lift the new list-item of the current list-item, split if necessary
+    (0, _liftFirstMatchedParent.default)(editor, 'list-item', {
+      split: true
+    });
+  });
+  _slate.Editor.normalize(editor, {
+    force: true
+  });
+}
+var _default = convertParagraphToListItem;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/transforms/liftFirstMatchedParent.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function liftFirstMatchedParent(editor, format, options) {
+  _slate.Transforms.liftNodes(editor, _objectSpread({
+    match: n => n.type === format || format === 'paragraph' && `${n.type}`.startsWith('heading'),
+    mode: 'lowest'
+  }, options));
+}
+var _default = liftFirstMatchedParent;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/transforms/liftListItem.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _unwrapFirstMatchedParent = _interopRequireDefault(require("./unwrapFirstMatchedParent"));
+var _liftFirstMatchedParent = _interopRequireDefault(require("./liftFirstMatchedParent"));
+var _getLowestAncestorList = _interopRequireDefault(require("../selectors/getLowestAncestorList"));
+var _getLowestAncestorQuote = _interopRequireDefault(require("../selectors/getLowestAncestorQuote"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function liftListItem(editor) {
+  _slate.Editor.withoutNormalizing(editor, () => {
+    // lift the paragraph out of the list and split if necessary
+    (0, _liftFirstMatchedParent.default)(editor, 'list-item', {
+      split: true
+    });
+
+    // if list is nested and not wrapped in quote, lift into the parent list, unwrap otherwise
+    const parentList = (0, _getLowestAncestorList.default)(editor);
+    const parentQuote = (0, _getLowestAncestorQuote.default)(editor);
+    if (parentList && !parentQuote || parentList && parentQuote && parentList[1].length > parentQuote[1].length) {
+      (0, _liftFirstMatchedParent.default)(editor, 'list-item', {
+        split: true
+      });
+    } else {
+      // unwrap the paragraph from list-item element
+      (0, _unwrapFirstMatchedParent.default)(editor, 'list-item');
+    }
+  });
+  _slate.Editor.normalize(editor, {
+    force: true
+  });
+}
+var _default = liftListItem;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/transforms/mergeWithPreviousListItem.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function mergeWithPreviousListItem(editor) {
+  _slate.Editor.withoutNormalizing(editor, () => {
+    _slate.Transforms.mergeNodes(editor, (0, _lowestMatchedAncestor.default)(editor, 'list-item'));
+  });
+  _slate.Editor.normalize(editor, {
+    force: true
+  });
+}
+var _default = mergeWithPreviousListItem;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/transforms/moveListToListItem.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function moveListToListItem(editor, listPath, targetListItem) {
+  const [targetItem, targetPath] = targetListItem;
+
+  // move the node to the last child position of the parent node
+  _slate.Transforms.moveNodes(editor, {
+    at: listPath,
+    to: [...targetPath, targetItem.children.length]
+  });
+}
+var _default = moveListToListItem;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/transforms/splitListItem.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _liftFirstMatchedParent = _interopRequireDefault(require("./liftFirstMatchedParent"));
+var _wrapFirstMatchedParent = _interopRequireDefault(require("./wrapFirstMatchedParent"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function splitListItem(editor) {
+  if (!editor.selection) return false;
+  if (_slate.Range.isExpanded(editor.selection)) {
+    _slate.Transforms.delete(editor);
+  }
+  _slate.Editor.withoutNormalizing(editor, () => {
+    // split even if at the end of current text
+    _slate.Transforms.splitNodes(editor, {
+      always: true
+    });
+    // set the new node to paragraph (to avoid splitting headings)
+    _slate.Transforms.setNodes(editor, {
+      type: 'paragraph'
+    });
+    // wrap the paragraph in a list item
+    (0, _wrapFirstMatchedParent.default)(editor, 'paragraph', {
+      type: 'list-item'
+    });
+    // lift new list item out the paragraph
+    (0, _liftFirstMatchedParent.default)(editor, 'list-item');
+  });
+  _slate.Editor.normalize(editor, {
+    force: true
+  });
+}
+var _default = splitListItem;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/transforms/splitToNestedList.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _wrapFirstMatchedParent = _interopRequireDefault(require("./wrapFirstMatchedParent"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function splitToNestedList(editor, listType) {
+  if (!editor.selection) return false;
+  if (_slate.Range.isExpanded(editor.selection)) {
+    _slate.Transforms.delete(editor);
+  }
+  _slate.Editor.withoutNormalizing(editor, () => {
+    // split even if at the end of current text
+    _slate.Transforms.splitNodes(editor, {
+      always: true
+    });
+    // set the new node to paragraph (to avoid splitting headings)
+    _slate.Transforms.setNodes(editor, {
+      type: 'paragraph'
+    });
+    // wrap the paragraph in a list item
+    (0, _wrapFirstMatchedParent.default)(editor, 'paragraph', {
+      type: 'list-item'
+    });
+    (0, _wrapFirstMatchedParent.default)(editor, 'list-item', {
+      type: listType
+    });
+  });
+  _slate.Editor.normalize(editor, {
+    force: true
+  });
+}
+var _default = splitToNestedList;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/transforms/unwrapFirstMatchedParent.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function unwrapFirstMatchedParent(editor, format) {
+  _slate.Transforms.unwrapNodes(editor, (0, _lowestMatchedAncestor.default)(editor, format));
+}
+var _default = unwrapFirstMatchedParent;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/transforms/unwrapSelectionFromList.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function unwrapSelectionFromList(editor) {
+  _slate.Editor.withoutNormalizing(editor, () => {
+    _slate.Transforms.unwrapNodes(editor, _objectSpread(_objectSpread({}, (0, _lowestMatchedAncestor.default)(editor, 'list')), {}, {
+      split: true
+    }));
+    _slate.Transforms.unwrapNodes(editor, (0, _lowestMatchedAncestor.default)(editor, 'list-item'));
+  });
+  _slate.Editor.normalize(editor);
+}
+var _default = unwrapSelectionFromList;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/transforms/wrapFirstMatchedParent.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function wrapFirstMatchedParent(editor, format, node) {
+  _slate.Transforms.wrapNodes(editor, node, (0, _lowestMatchedAncestor.default)(editor, format));
+}
+var _default = wrapFirstMatchedParent;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/transforms/wrapSelectionInList.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function wrapSelectionInList(editor, type) {
+  _slate.Editor.withoutNormalizing(editor, () => {
+    _slate.Transforms.wrapNodes(editor, {
+      type
+    });
+    const listItems = _slate.Editor.nodes(editor, (0, _lowestMatchedAncestor.default)(editor, 'paragraph'));
+    for (const listItem of listItems) {
+      _slate.Transforms.wrapNodes(editor, {
+        type: 'list-item'
+      }, {
+        at: listItem[1]
+      });
+    }
+  });
+  _slate.Editor.normalize(editor);
+}
+var _default = wrapSelectionInList;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/withLists.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _keyDown = _interopRequireDefault(require("./events/keyDown"));
+var _moveListToListItem = _interopRequireDefault(require("./transforms/moveListToListItem"));
+var _toggleListType = _interopRequireDefault(require("./events/toggleListType"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function withLists(editor) {
+  const {
+    normalizeNode
+  } = editor;
+  if (editor.keyDownHandlers === undefined) {
+    editor.keyDownHandlers = [];
+  }
+  editor.keyDownHandlers.push((event, editor) => (0, _keyDown.default)(event, editor));
+  editor.toggleList = type => (0, _toggleListType.default)(editor, type);
+  editor.isListItem = () => {
+    const {
+      selection
+    } = editor;
+    if (!selection) return false;
+    const [match] = Array.from(_slate.Editor.nodes(editor, {
+      at: _slate.Editor.unhangRange(editor, selection),
+      match: n => !_slate.Editor.isEditor(n) && _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n) && n.type !== 'paragraph' && !`${n.type}`.startsWith('heading-'),
+      mode: 'lowest'
+    }));
+    return !!match && match[0].type === 'list-item';
+  };
+  editor.normalizeNode = entry => {
+    normalizeNode(entry);
+    const [node, path] = entry;
+    let previousType = null;
+    if (_slate.Element.isElement(node) || _slate.Editor.isEditor(node)) {
+      for (const [child, childPath] of _slate.Node.children(editor, path)) {
+        if (`${child.type}`.endsWith('-list') && child.type === previousType) {
+          _slate.Transforms.mergeNodes(editor, {
+            at: childPath
+          });
+          break;
+        }
+        previousType = child.type;
+      }
+    }
+    if (_slate.Element.isElement(node) && `${node.type}`.endsWith('-list')) {
+      const previousNode = _slate.Editor.previous(editor, {
+        at: path
+      });
+      const [parentNode, parentNodePath] = _slate.Editor.parent(editor, path);
+      if (!previousNode && parentNode.type === 'list-item') {
+        const previousListItem = _slate.Editor.previous(editor, {
+          at: parentNodePath
+        });
+        (0, _moveListToListItem.default)(editor, path, previousListItem);
+        _slate.Transforms.removeNodes(editor, {
+          at: parentNodePath
+        });
+      }
+    }
+  };
+  return editor;
+}
+var _default = withLists;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/matchers/lowestMatchedAncestor.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _matchedAncestors = _interopRequireDefault(require("./matchedAncestors"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function lowestMatchedAncestor(editor, format) {
+  return (0, _matchedAncestors.default)(editor, format, 'lowest');
+}
+var _default = lowestMatchedAncestor;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/matchers/matchLink.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function matchLink() {
+  return {
+    match: n => !_slate.Editor.isEditor(n) && _slate.Element.isElement(n) && n.type === 'link'
+  };
+}
+var _default = matchLink;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/matchers/matchedAncestors.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function matchedAncestors(editor, format, mode) {
+  return {
+    match: n => !_slate.Editor.isEditor(n) && _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n) && (n.type === format || format === 'heading' && `${n.type}`.startsWith('heading-') || format === 'paragraph' && `${n.type}`.startsWith('heading-') || format === 'block' && !`${n.type}`.startsWith('heading-') && n.type !== 'paragraph' || format === 'list' && `${n.type}`.endsWith('-list')) || format === 'non-default' && n.type !== 'paragraph',
+    mode
+  };
+}
+var _default = matchedAncestors;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/shortcodes/insertShortcode.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _isCursorInEmptyParagraph = _interopRequireDefault(require("./locations/isCursorInEmptyParagraph"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function insertShortcode(editor, pluginConfig) {
+  const defaultValues = pluginConfig.fields.toMap().mapKeys((_, field) => field.get('name')).filter(field => field.has('default')).map(field => field.get('default'));
+
+  // console.log(defaultValues);
+
+  const nodeData = {
+    type: 'shortcode',
+    id: pluginConfig.id,
+    data: {
+      shortcode: pluginConfig.id,
+      shortcodeNew: true,
+      shortcodeData: defaultValues.toJS()
+    },
+    children: [{
+      text: ''
+    }]
+  };
+  if ((0, _isCursorInEmptyParagraph.default)(editor)) {
+    _slate.Transforms.setNodes(editor, nodeData);
+    return;
+  }
+  _slate.Transforms.insertNodes(editor, nodeData);
+  console.log('handleInsertShortcode', pluginConfig);
+}
+var _default = insertShortcode;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/shortcodes/locations/isCursorInEmptyParagraph.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isCursorInEmptyParagraph(editor) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const [match] = Array.from(_slate.Editor.nodes(editor, {
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n) && n.type === 'paragraph',
+    mode: 'lowest'
+  }));
+  return !!match && _slate.Editor.isEmpty(editor, match[0]);
+}
+var _default = isCursorInEmptyParagraph;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/shortcodes/withShortcodes.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _defaultEmptyBlock = _interopRequireDefault(require("../blocks/defaultEmptyBlock"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function withShortcodes(editor) {
+  const {
+    isVoid,
+    normalizeNode
+  } = editor;
+  editor.isVoid = element => {
+    return element.type === 'shortcode' ? true : isVoid(element);
+  };
+
+  // Prevent empty editor after deleting shortcode theat was only child
+  editor.normalizeNode = entry => {
+    const [node] = entry;
+    if (_slate.Editor.isEditor(node) && node.children.length == 0) {
+      _slate.Transforms.insertNodes(editor, (0, _defaultEmptyBlock.default)());
+    }
+    normalizeNode(entry);
+  };
+  return editor;
+}
+var _default = withShortcodes;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/util.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertType = assertType;
+var _isArray2 = _interopRequireDefault(require("lodash/isArray"));
+var _castArray2 = _interopRequireDefault(require("lodash/castArray"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function assertType(nodes, type) {
+  const nodesArray = (0, _castArray2.default)(nodes);
+  const validate = (0, _isArray2.default)(type) ? node => type.includes(node.type) : node => type === node.type;
+  const invalidNode = nodesArray.find(node => !validate(node));
+  if (invalidNode) {
+    throw Error(`Expected node of type "${type}", received "${invalidNode.type}".`);
+  }
+  return true;
+}