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

package/dist/esm/MarkdownControl/plugins/blocks/transforms/splitIntoParagraph.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function splitIntoParagraph(editor) {
+  _slate.Editor.withoutNormalizing(editor, () => {
+    _slate.Transforms.splitNodes(editor, {
+      always: true
+    });
+    _slate.Transforms.setNodes(editor, {
+      type: 'paragraph'
+    });
+  });
+  _slate.Editor.normalize(editor, {
+    force: true
+  });
+  return true;
+}
+var _default = splitIntoParagraph;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/transforms/unwrapIfCursorAtStart.js

@@ -0,0 +1,36 @@
+"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 unwrapIfCursorAtStart(editor, mergeWithPrevious = false) {
+  if (editor.selection.anchor.offset !== 0) return false;
+  const node = _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, 'non-default'));
+  if (node[1].length == 0) return false;
+  const isHeading = `${node[0].type}`.startsWith('heading-');
+  if (isHeading) {
+    _slate.Transforms.setNodes(editor, {
+      type: 'paragraph'
+    });
+    return false;
+  }
+  _slate.Editor.withoutNormalizing(editor, () => {
+    _slate.Transforms.unwrapNodes(editor, {
+      match: n => n.type === node[0].type,
+      split: true
+    });
+    if (mergeWithPrevious) {
+      _slate.Transforms.mergeNodes(editor);
+    }
+  });
+  _slate.Editor.normalize(editor, {
+    force: true
+  });
+  return true;
+}
+var _default = unwrapIfCursorAtStart;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/transforms/wrapListItemsInBlock.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function wrapListItemsInBlock(editor, blockType, listType) {
+  _slate.Editor.withoutNormalizing(editor, () => {
+    _slate.Transforms.wrapNodes(editor, {
+      type: listType
+    });
+    _slate.Transforms.wrapNodes(editor, {
+      type: blockType
+    }, {
+      match: n => n.type === listType
+    });
+    _slate.Transforms.liftNodes(editor, {
+      match: n => n.type === blockType
+    });
+  });
+  _slate.Editor.normalize(editor, {
+    force: true
+  });
+}
+var _default = wrapListItemsInBlock;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/withBlocks.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _keyDown = _interopRequireDefault(require("./events/keyDown"));
+var _toggleBlock = _interopRequireDefault(require("./events/toggleBlock"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function withBlocks(editor) {
+  if (editor.keyDownHandlers === undefined) {
+    editor.keyDownHandlers = [];
+  }
+  editor.keyDownHandlers.push((event, editor) => (0, _keyDown.default)(event, editor));
+  editor.toggleBlock = type => (0, _toggleBlock.default)(editor, type);
+  return editor;
+}
+var _default = withBlocks;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/inlines/events/keyDown.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _toggleMark = _interopRequireDefault(require("./toggleMark"));
+var _keyDownShiftEnter = _interopRequireDefault(require("./keyDownShiftEnter"));
+var _toggleLink = _interopRequireDefault(require("./toggleLink"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const MARK_HOTKEYS = {
+  'mod+b': 'bold',
+  'mod+i': 'italic',
+  'mod+u': 'underline',
+  'mod+`': 'code',
+  'mod+shift+s': 'delete',
+  'mod+shift+c': 'code'
+};
+function keyDown(event, editor) {
+  if (!editor.selection) return;
+  for (const hotkey in MARK_HOTKEYS) {
+    if ((0, _isHotkey.default)(hotkey, event)) {
+      (0, _toggleMark.default)(editor, MARK_HOTKEYS[hotkey]);
+      event.preventDefault();
+      return false;
+    }
+  }
+  if ((0, _isHotkey.default)('mod+k', event)) {
+    event.preventDefault();
+    return (0, _toggleLink.default)(editor);
+  }
+  if ((0, _isHotkey.default)('shift+enter', event)) {
+    event.preventDefault();
+    return (0, _keyDownShiftEnter.default)(editor);
+  }
+}
+var _default = keyDown;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/inlines/events/keyDownShiftEnter.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function keyDownShiftEnter(editor) {
+  if (!editor.selection) return;
+  const focus = {
+    path: [...editor.selection.focus.path.slice(0, -1), editor.selection.focus.path[editor.selection.focus.path.length - 1] + 2],
+    offset: 0
+  };
+  _slate.Transforms.insertNodes(editor, {
+    type: 'break',
+    children: [{
+      text: ''
+    }]
+  });
+  _slate.Editor.normalize(editor, {
+    force: true
+  });
+  _slate.Transforms.select(editor, focus);
+  return false;
+}
+var _default = keyDownShiftEnter;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/inlines/events/toggleLink.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _getActiveLink = _interopRequireDefault(require("../selectors/getActiveLink"));
+var _unwrapLink = _interopRequireDefault(require("../transforms/unwrapLink"));
+var _wrapLink = _interopRequireDefault(require("../transforms/wrapLink"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function toggleLink(editor, promptText) {
+  var _activeLink$, _activeLink$$data;
+  const activeLink = (0, _getActiveLink.default)(editor);
+  const activeUrl = activeLink ? (_activeLink$ = activeLink[0]) === null || _activeLink$ === void 0 ? void 0 : (_activeLink$$data = _activeLink$.data) === null || _activeLink$$data === void 0 ? void 0 : _activeLink$$data.url : '';
+  const url = window.prompt(promptText, activeUrl);
+  if (url == null) return;
+  if (url === '') {
+    (0, _unwrapLink.default)(editor);
+    return;
+  }
+  (0, _wrapLink.default)(editor, url);
+}
+var _default = toggleLink;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/inlines/events/toggleMark.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _isMarkActive = _interopRequireDefault(require("../locations/isMarkActive"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function toggleMark(editor, format) {
+  if ((0, _isMarkActive.default)(editor, format)) {
+    _slate.Editor.removeMark(editor, format);
+  } else {
+    _slate.Editor.addMark(editor, format, true);
+  }
+}
+var _default = toggleMark;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/inlines/locations/isMarkActive.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isMarkActive(editor, format) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const marks = _slate.Editor.marks(editor);
+  return marks ? marks[format] === true : false;
+}
+var _default = isMarkActive;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/inlines/selectors/getActiveLink.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _matchLink = _interopRequireDefault(require("../../matchers/matchLink"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getActiveLink(editor) {
+  const [link] = _slate.Editor.nodes(editor, (0, _matchLink.default)(editor));
+  return link;
+}
+var _default = getActiveLink;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/inlines/transforms/unwrapLink.js

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

package/dist/esm/MarkdownControl/plugins/inlines/transforms/wrapLink.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _getActiveLink = _interopRequireDefault(require("../selectors/getActiveLink"));
+var _matchLink = _interopRequireDefault(require("../../matchers/matchLink"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function wrapLink(editor, url) {
+  if ((0, _getActiveLink.default)(editor)) {
+    _slate.Transforms.setNodes(editor, {
+      data: {
+        url
+      }
+    }, (0, _matchLink.default)());
+    return;
+  }
+  const {
+    selection
+  } = editor;
+  const isCollapsed = selection && _slate.Range.isCollapsed(selection);
+  const link = {
+    type: 'link',
+    data: {
+      url
+    },
+    children: isCollapsed ? [{
+      text: url
+    }] : []
+  };
+  if (isCollapsed) {
+    _slate.Transforms.insertNodes(editor, link);
+  } else {
+    _slate.Transforms.wrapNodes(editor, link, {
+      split: true
+    });
+    _slate.Transforms.collapse(editor, {
+      edge: 'end'
+    });
+  }
+}
+var _default = wrapLink;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/inlines/withInlines.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _keyDown = _interopRequireDefault(require("./events/keyDown"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function withInlines(editor) {
+  const {
+    isInline,
+    isVoid
+  } = editor;
+  editor.isInline = element => ['link', 'button', 'break', 'image'].includes(element.type) || isInline(element);
+  editor.isVoid = element => ['break', 'image', 'thematic-break'].includes(element.type) || isVoid(element);
+  if (editor.keyDownHandlers === undefined) {
+    editor.keyDownHandlers = [];
+  }
+  editor.keyDownHandlers.push((event, editor) => (0, _keyDown.default)(event, editor));
+  return editor;
+}
+var _default = withInlines;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/events/keyDown.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _keyDownEnter = _interopRequireDefault(require("./keyDownEnter"));
+var _keyDownTab = _interopRequireDefault(require("./keyDownTab"));
+var _keyDownShiftTab = _interopRequireDefault(require("./keyDownShiftTab"));
+var _keyDownBackspace = _interopRequireDefault(require("./keyDownBackspace"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function keyDown(event, editor) {
+  if (!editor.isListItem()) return;
+  if ((0, _isHotkey.default)('enter', event)) {
+    event.preventDefault();
+    (0, _keyDownEnter.default)(editor);
+    return false;
+  }
+  if ((0, _isHotkey.default)('backspace', event)) {
+    const eventIntercepted = (0, _keyDownBackspace.default)(editor);
+    if (eventIntercepted === false) {
+      event.preventDefault();
+      return false;
+    }
+    return;
+  }
+  if ((0, _isHotkey.default)('tab', event)) {
+    event.preventDefault();
+    return (0, _keyDownTab.default)(editor);
+  }
+  if ((0, _isHotkey.default)('shift+tab', event)) {
+    event.preventDefault();
+    return (0, _keyDownShiftTab.default)(editor);
+  }
+}
+var _default = keyDown;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/events/keyDownBackspace.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _isCursorInListItem = _interopRequireDefault(require("../locations/isCursorInListItem"));
+var _isSelectionWithinNoninitialListItem = _interopRequireDefault(require("../locations/isSelectionWithinNoninitialListItem"));
+var _unwrapSelectionFromList = _interopRequireDefault(require("../transforms/unwrapSelectionFromList"));
+var _mergeWithPreviousListItem = _interopRequireDefault(require("../transforms/mergeWithPreviousListItem"));
+var _isCursorAtNoninitialParagraphStart = _interopRequireDefault(require("../locations/isCursorAtNoninitialParagraphStart"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function keyDownBackspace(editor) {
+  if (!editor.selection) return;
+
+  // ignore if selection is expanded, cursor is not at the beginning or not immediately in a list item, or cursor is at the beginning of a non-initial paragraph
+  if (!_slate.Range.isCollapsed(editor.selection) || editor.selection.anchor.offset !== 0 || !(0, _isCursorInListItem.default)(editor, true) || (0, _isCursorAtNoninitialParagraphStart.default)(editor)) {
+    return;
+  }
+  if ((0, _isSelectionWithinNoninitialListItem.default)(editor)) {
+    (0, _mergeWithPreviousListItem.default)(editor);
+  } else {
+    (0, _unwrapSelectionFromList.default)(editor);
+  }
+  return false;
+}
+var _default = keyDownBackspace;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/events/keyDownEnter.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _splitListItem = _interopRequireDefault(require("../transforms/splitListItem"));
+var _isCursorAtListItemStart = _interopRequireDefault(require("../locations/isCursorAtListItemStart"));
+var _liftListItem = _interopRequireDefault(require("../transforms/liftListItem"));
+var _convertParagraphToListItem = _interopRequireDefault(require("../transforms/convertParagraphToListItem"));
+var _isCursorAtNoninitialParagraphStart = _interopRequireDefault(require("../locations/isCursorAtNoninitialParagraphStart"));
+var _splitToNestedList = _interopRequireDefault(require("../transforms/splitToNestedList"));
+var _getListContainedInListItem = _interopRequireDefault(require("../selectors/getListContainedInListItem"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function keyDownEnter(editor) {
+  if (!editor.selection) return;
+
+  // Pressing enter will delete current selection in any case
+  if (_slate.Range.isExpanded(editor.selection)) {
+    _slate.Transforms.delete(editor);
+  }
+
+  // if edge of selection is in the begining of the first text node in list-item
+  if ((0, _isCursorAtListItemStart.default)(editor)) {
+    return (0, _liftListItem.default)(editor);
+  }
+
+  // if list has a nested list, insert new item to the beginning of the nested list
+  const nestedList = (0, _getListContainedInListItem.default)(editor);
+  if (!!nestedList && `${nestedList[0].type}`.endsWith('-list')) {
+    return (0, _splitToNestedList.default)(editor, nestedList[0].type);
+  }
+
+  // if a paragraph in a list and has previous siblings, convert it to a list item
+  if ((0, _isCursorAtNoninitialParagraphStart.default)(editor)) {
+    return (0, _convertParagraphToListItem.default)(editor);
+  }
+
+  // otherwise create a new list item
+  (0, _splitListItem.default)(editor);
+}
+var _default = keyDownEnter;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/events/keyDownShiftTab.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+var _matchedAncestors = _interopRequireDefault(require("../../matchers/matchedAncestors"));
+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 keyDownShiftTab(editor) {
+  if (!editor.selection) return;
+  if (Array.from(_slate.Editor.nodes(editor, (0, _matchedAncestors.default)(editor, 'list'))).length < 2) {
+    return;
+  }
+  _slate.Editor.withoutNormalizing(editor, () => {
+    _slate.Transforms.liftNodes(editor, _objectSpread(_objectSpread({}, (0, _lowestMatchedAncestor.default)(editor, 'list-item')), {}, {
+      split: true
+    }));
+    _slate.Transforms.liftNodes(editor, _objectSpread(_objectSpread({}, (0, _lowestMatchedAncestor.default)(editor, 'list-item')), {}, {
+      split: true
+    }));
+  });
+  _slate.Editor.normalize(editor);
+}
+var _default = keyDownShiftTab;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/events/keyDownTab.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _isSelectionWithinNoninitialListItem = _interopRequireDefault(require("../locations/isSelectionWithinNoninitialListItem"));
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+var _moveListToListItem = _interopRequireDefault(require("../transforms/moveListToListItem"));
+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 keyDownTab(editor) {
+  if (!editor.selection) return;
+  if (!(0, _isSelectionWithinNoninitialListItem.default)(editor)) return;
+
+  // In a case where one edge of the range is within a nested list item, we need to even the selection to the outer most level
+  const {
+    focus,
+    anchor
+  } = editor.selection;
+  const pathLength = focus.path.length > anchor.path.length ? anchor.path.length : focus.path.length;
+  const at = {
+    anchor: {
+      offset: 0,
+      path: [...anchor.path.slice(0, pathLength - 2), 0, 0]
+    },
+    focus: {
+      offset: 0,
+      path: [...focus.path.slice(0, pathLength - 2), 0, 0]
+    }
+  };
+  _slate.Editor.withoutNormalizing(editor, () => {
+    // wrap selected list items into a new bulleted list
+    _slate.Transforms.wrapNodes(editor, {
+      type: 'bulleted-list'
+    }, _objectSpread(_objectSpread({}, (0, _lowestMatchedAncestor.default)(editor, 'list-item')), {}, {
+      at
+    }));
+
+    // get the new bulleted list position
+    const [, newListPath] = _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, 'list'));
+
+    // get the new parent node (previous list item)
+    const parentNode = _slate.Editor.previous(editor, {
+      at: newListPath
+    });
+    (0, _moveListToListItem.default)(editor, newListPath, parentNode);
+  });
+  _slate.Editor.normalize(editor);
+}
+var _default = keyDownTab;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/lists/events/toggleListType.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isCursorInListItem = _interopRequireDefault(require("../locations/isCursorInListItem"));
+var _getLowestAncestorList = _interopRequireDefault(require("../selectors/getLowestAncestorList"));
+var _wrapSelectionInList = _interopRequireDefault(require("../transforms/wrapSelectionInList"));
+var _changeListType = _interopRequireDefault(require("../transforms/changeListType"));
+var _unwrapSelectionFromList = _interopRequireDefault(require("../transforms/unwrapSelectionFromList"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function toggleListType(editor, type) {
+  // list being active means that we are in a paragraph or heading whose parent is a list
+  // if no list is active, wrap selection in a new list of the given type
+  if (!(0, _isCursorInListItem.default)(editor)) {
+    return (0, _wrapSelectionInList.default)(editor, type);
+  }
+  // if a list is active but the type doesn't match, change selection to the given list type
+  const currentList = (0, _getLowestAncestorList.default)(editor);
+  if (currentList && currentList[0].type !== type) {
+    return (0, _changeListType.default)(editor, type);
+  }
+
+  // if a list is active and the type matches, unwrap selection from the list
+  return (0, _unwrapSelectionFromList.default)(editor);
+}
+var _default = toggleListType;
+exports.default = _default;

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isCursorAtListItemStart(editor) {
+  if (!editor.selection) return false;
+  const {
+    offset,
+    path
+  } = _slate.Range.start(editor.selection);
+  // todo: this will break when there are marks inside list items, use Edior.isStart on first block parent instead (see isCursorAtEndOfParagraph)
+  return offset === 0 && path.length >= 2 && path[path.length - 1] === 0 && path[path.length - 2] === 0;
+}
+var _default = isCursorAtListItemStart;
+exports.default = _default;

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isCursorAtNoninitialParagraphStart(editor) {
+  if (!editor.selection) return false;
+  const {
+    offset,
+    path
+  } = _slate.Range.start(editor.selection);
+  return offset == 0 && path.length > 2 && path[path.length - 2] > 0;
+}
+var _default = isCursorAtNoninitialParagraphStart;
+exports.default = _default;

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

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _getListContainedInListItem = _interopRequireDefault(require("../selectors/getListContainedInListItem"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function isCursorInItemContainingNestedList(editor) {
+  const nestedList = (0, _getListContainedInListItem.default)(editor);
+  return !!nestedList && `${nestedList[0].type}`.endsWith('-list');
+}
+var _default = isCursorInItemContainingNestedList;
+exports.default = _default;

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

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isCursorInListItem(editor, immediate) {
+  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' && (immediate || !`${n.type}`.startsWith('heading-')),
+    mode: 'lowest'
+  }));
+  return !!match && match[0].type === 'list-item';
+}
+var _default = isCursorInListItem;
+exports.default = _default;