planning

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/BreakToDefaultBlock.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function BreakToDefaultBlock({
+  defaultType
+}) {
+  return {
+    onKeyDown(event, editor, next) {
+      const {
+        selection,
+        startBlock
+      } = editor.value;
+      const isEnter = (0, _isHotkey.default)('enter', event);
+      if (!isEnter) {
+        return next();
+      }
+      if (selection.isExpanded) {
+        editor.delete();
+        return next();
+      }
+      if (selection.start.isAtEndOfNode(startBlock) && startBlock.type !== defaultType) {
+        return editor.insertBlock(defaultType);
+      }
+      return next();
+    }
+  };
+}
+var _default = exports.default = BreakToDefaultBlock;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/CloseBlock.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function CloseBlock({
+  defaultType
+}) {
+  return {
+    onKeyDown(event, editor, next) {
+      const {
+        selection,
+        startBlock
+      } = editor.value;
+      const isBackspace = (0, _isHotkey.default)('backspace', event);
+      if (!isBackspace) {
+        return next();
+      }
+      if (selection.isExpanded) {
+        return editor.delete();
+      }
+      if (!selection.start.isAtStartOfNode(startBlock) || startBlock.text.length > 0) {
+        return next();
+      }
+      if (startBlock.type !== defaultType) {
+        editor.setBlocks(defaultType);
+      }
+      return next();
+    }
+  };
+}
+var _default = exports.default = CloseBlock;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/CommandsAndQueries.js

@@ -0,0 +1,187 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _castArray2 = _interopRequireDefault(require("lodash/castArray"));
+var _tail2 = _interopRequireDefault(require("lodash/tail"));
+var _isArray2 = _interopRequireDefault(require("lodash/isArray"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function CommandsAndQueries({
+  defaultType
+}) {
+  return {
+    queries: {
+      atStartOf(editor, node) {
+        const {
+          selection
+        } = editor.value;
+        return selection.isCollapsed && selection.start.isAtStartOfNode(node);
+      },
+      getAncestor(editor, firstKey, lastKey) {
+        if (firstKey === lastKey) {
+          return editor.value.document.getParent(firstKey);
+        }
+        return editor.value.document.getCommonAncestor(firstKey, lastKey);
+      },
+      getOffset(editor, node) {
+        const parent = editor.value.document.getParent(node.key);
+        return parent.nodes.indexOf(node);
+      },
+      getSelectedChildren(editor, node) {
+        return node.nodes.filter(child => editor.isSelected(child));
+      },
+      getCommonAncestor(editor) {
+        const {
+          startBlock,
+          endBlock,
+          document: doc
+        } = editor.value;
+        return doc.getCommonAncestor(startBlock.key, endBlock.key);
+      },
+      getClosestType(editor, node, type) {
+        const types = (0, _castArray2.default)(type);
+        return editor.value.document.getClosest(node.key, n => types.includes(n.type));
+      },
+      getBlockContainer(editor, node) {
+        const targetTypes = ['bulleted-list', 'numbered-list', 'list-item', 'quote', 'table-cell'];
+        const {
+          startBlock,
+          selection
+        } = editor.value;
+        const target = node ? editor.value.document.getParent(node.key) : selection.isCollapsed && startBlock || editor.getCommonAncestor();
+        if (!target) {
+          return editor.value.document;
+        }
+        if (targetTypes.includes(target.type)) {
+          return target;
+        }
+        return editor.getBlockContainer(target);
+      },
+      isSelected(editor, nodes) {
+        return (0, _castArray2.default)(nodes).every(node => {
+          return editor.value.document.isInRange(node.key, editor.value.selection);
+        });
+      },
+      isFirstChild(editor, node) {
+        return editor.value.document.getParent(node.key).nodes.first().key === node.key;
+      },
+      areSiblings(editor, nodes) {
+        if (!(0, _isArray2.default)(nodes) || nodes.length < 2) {
+          return true;
+        }
+        const parent = editor.value.document.getParent(nodes[0].key);
+        return (0, _tail2.default)(nodes).every(node => {
+          return editor.value.document.getParent(node.key).key === parent.key;
+        });
+      },
+      everyBlock(editor, type) {
+        return editor.value.blocks.every(block => block.type === type);
+      },
+      hasMark(editor, type) {
+        return editor.value.activeMarks.some(mark => mark.type === type);
+      },
+      hasBlock(editor, type) {
+        return editor.value.blocks.some(node => node.type === type);
+      },
+      hasInline(editor, type) {
+        return editor.value.inlines.some(node => node.type === type);
+      },
+      hasQuote(editor, quoteLabel) {
+        const {
+          value
+        } = editor;
+        const {
+          document,
+          blocks
+        } = value;
+        return blocks.some(node => {
+          const {
+            key: descendantNodeKey
+          } = node;
+          /* When focusing a quote block, the actual block that gets the focus is the paragraph block whose parent is a `quote` block.
+          Hence, we need to get its parent and check if its type is `quote`. This parent will always be defined because every block in the editor
+          has a Document object as parent by default.
+          */
+          const parent = document.getParent(descendantNodeKey);
+          return parent.type === quoteLabel;
+        });
+      },
+      hasListItems(editor, listType) {
+        const {
+          value
+        } = editor;
+        const {
+          document,
+          blocks
+        } = value;
+        return blocks.some(node => {
+          const {
+            key: lowestNodeKey
+          } = node;
+          /* A list block has the following structure:
+          <ol>
+            <li>
+              <p>Coffee</p>
+            </li>
+            <li>
+              <p>Tea</p>
+            </li>
+          </ol>
+          */
+          const parent = document.getParent(lowestNodeKey);
+          const grandparent = document.getParent(parent.key);
+          return parent.type === 'list-item' && (grandparent === null || grandparent === void 0 ? void 0 : grandparent.type) === listType;
+        });
+      }
+    },
+    commands: {
+      toggleBlock(editor, type) {
+        switch (type) {
+          case 'heading-one':
+          case 'heading-two':
+          case 'heading-three':
+          case 'heading-four':
+          case 'heading-five':
+          case 'heading-six':
+            return editor.setBlocks(editor.everyBlock(type) ? defaultType : type);
+          case 'quote':
+            return editor.toggleQuoteBlock();
+          case 'numbered-list':
+          case 'bulleted-list':
+            {
+              return editor.toggleList(type);
+            }
+        }
+      },
+      unwrapBlockChildren(editor, block) {
+        if (!block || block.object !== 'block') {
+          throw Error(`Expected block but received ${block}.`);
+        }
+        const index = editor.value.document.getPath(block.key).last();
+        const parent = editor.value.document.getParent(block.key);
+        editor.withoutNormalizing(() => {
+          block.nodes.forEach((node, idx) => {
+            editor.moveNodeByKey(node.key, parent.key, index + idx);
+          });
+          editor.removeNodeByKey(block.key);
+        });
+      },
+      unwrapNodeToDepth(editor, node, depth) {
+        let currentDepth = 0;
+        editor.withoutNormalizing(() => {
+          while (currentDepth < depth) {
+            editor.unwrapNodeByKey(node.key);
+            currentDepth += 1;
+          }
+        });
+      },
+      unwrapNodeFromAncestor(editor, node, ancestor) {
+        const depth = ancestor.getDepth(node.key);
+        editor.unwrapNodeToDepth(node, depth);
+      }
+    }
+  };
+}
+var _default = exports.default = CommandsAndQueries;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/ForceInsert.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function ForceInsert({
+  defaultType
+}) {
+  return {
+    queries: {
+      canInsertBeforeNode(editor, node) {
+        if (!editor.isVoid(node)) {
+          return true;
+        }
+        return !!editor.value.document.getPreviousSibling(node.key);
+      },
+      canInsertAfterNode(editor, node) {
+        if (!editor.isVoid(node)) {
+          return true;
+        }
+        const nextSibling = editor.value.document.getNextSibling(node.key);
+        return nextSibling && !editor.isVoid(nextSibling);
+      }
+    },
+    commands: {
+      forceInsertBeforeNode(editor, node) {
+        const block = {
+          type: defaultType,
+          object: 'block'
+        };
+        const parent = editor.value.document.getParent(node.key);
+        return editor.insertNodeByKey(parent.key, 0, block).moveToStartOfNode(parent).focus();
+      },
+      forceInsertAfterNode(editor, node) {
+        return editor.moveToEndOfNode(node).insertBlock(defaultType).focus();
+      },
+      moveToEndOfDocument(editor) {
+        const lastBlock = editor.value.document.nodes.last();
+        if (editor.isVoid(lastBlock)) {
+          editor.insertBlock(defaultType);
+        }
+        return editor.moveToEndOfNode(lastBlock).focus();
+      }
+    }
+  };
+}
+var _default = exports.default = ForceInsert;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/Hotkey.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.HOT_KEY_MAP = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const HOT_KEY_MAP = exports.HOT_KEY_MAP = {
+  bold: 'mod+b',
+  code: 'mod+shift+c',
+  italic: 'mod+i',
+  strikethrough: 'mod+shift+s',
+  'heading-one': 'mod+1',
+  'heading-two': 'mod+2',
+  'heading-three': 'mod+3',
+  'heading-four': 'mod+4',
+  'heading-five': 'mod+5',
+  'heading-six': 'mod+6',
+  link: 'mod+k'
+};
+function Hotkey(key, fn) {
+  return {
+    onKeyDown(event, editor, next) {
+      if (!(0, _isHotkey.default)(key, event)) {
+        return next();
+      }
+      event.preventDefault();
+      editor.command(fn);
+    }
+  };
+}
+var _default = exports.default = Hotkey;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/LineBreak.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function LineBreak() {
+  return {
+    onKeyDown(event, editor, next) {
+      const isShiftEnter = (0, _isHotkey.default)('shift+enter', event);
+      if (!isShiftEnter) {
+        return next();
+      }
+      return editor.insertInline('break').insertText('').moveToStartOfNextText();
+    }
+  };
+}
+var _default = exports.default = LineBreak;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/Link.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function Link({
+  type
+}) {
+  return {
+    commands: {
+      toggleLink(editor, getUrl) {
+        const selection = editor.value.selection;
+        const isCollapsed = selection && selection.isCollapsed;
+        if (editor.hasInline(type)) {
+          const inlines = editor.value.inlines.toJSON();
+          const link = inlines.find(item => item.type === type);
+          const url = getUrl(link.data.url);
+          if (url) {
+            // replace the old link
+            return editor.setInlines({
+              data: {
+                url
+              }
+            });
+          } else {
+            // remove url if it was removed by the user
+            return editor.unwrapInline(type);
+          }
+        } else {
+          const url = getUrl();
+          if (!url) {
+            return;
+          }
+          return isCollapsed ? editor.insertInline({
+            type,
+            data: {
+              url
+            },
+            nodes: [{
+              object: 'text',
+              text: url
+            }]
+          }) : editor.wrapInline({
+            type,
+            data: {
+              url
+            }
+          }).moveToEnd();
+        }
+      }
+    }
+  };
+}
+var _default = exports.default = Link;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/defaultEmptyBlock.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function defaultEmptyBlock(text = '') {
+  return {
+    type: 'paragraph',
+    children: [{
+      text
+    }]
+  };
+}
+var _default = exports.default = defaultEmptyBlock;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/events/keyDown.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _slate = require("slate");
+var _keyDownEnter = _interopRequireDefault(require("./keyDownEnter"));
+var _keyDownBackspace = _interopRequireDefault(require("./keyDownBackspace"));
+var _isCursorInNonDefaultBlock = _interopRequireDefault(require("../locations/isCursorInNonDefaultBlock"));
+var _toggleBlock = _interopRequireDefault(require("./toggleBlock"));
+var _isCursorCollapsedAfterSoftBreak = _interopRequireDefault(require("../locations/isCursorCollapsedAfterSoftBreak"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const HEADING_HOTKEYS = {
+  'mod+1': 'heading-one',
+  'mod+2': 'heading-two',
+  'mod+3': 'heading-three',
+  'mod+4': 'heading-four',
+  'mod+5': 'heading-five',
+  'mod+6': 'heading-six'
+};
+function keyDown(event, editor) {
+  if (!editor.selection) return;
+  for (const hotkey in HEADING_HOTKEYS) {
+    if ((0, _isHotkey.default)(hotkey, event)) {
+      (0, _toggleBlock.default)(editor, HEADING_HOTKEYS[hotkey]);
+      event.preventDefault();
+      return false;
+    }
+  }
+  if ((0, _isHotkey.default)('backspace', event) && (0, _isCursorCollapsedAfterSoftBreak.default)(editor)) {
+    const [, path] = _slate.Editor.previous(editor);
+    _slate.Transforms.removeNodes(editor, {
+      at: path
+    });
+    event.preventDefault();
+    return false;
+  }
+  if (!(0, _isCursorInNonDefaultBlock.default)(editor)) return;
+  if ((0, _isHotkey.default)('enter', event)) {
+    const eventIntercepted = (0, _keyDownEnter.default)(editor);
+    if (eventIntercepted) {
+      event.preventDefault();
+      return false;
+    }
+  }
+  if ((0, _isHotkey.default)('backspace', event)) {
+    const eventIntercepted = (0, _keyDownBackspace.default)(editor);
+    if (eventIntercepted) {
+      event.preventDefault();
+      return false;
+    }
+  }
+}
+var _default = exports.default = keyDown;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/events/keyDownBackspace.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _unwrapIfCursorAtStart = _interopRequireDefault(require("../transforms/unwrapIfCursorAtStart"));
+var _isCursorAtStartOfNonEmptyHeading = _interopRequireDefault(require("../locations/isCursorAtStartOfNonEmptyHeading"));
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+var _areCurrentAndPreviousBlocksOfType = _interopRequireDefault(require("../locations/areCurrentAndPreviousBlocksOfType"));
+var _isCursorAtStartOfBlockType = _interopRequireDefault(require("../locations/isCursorAtStartOfBlockType"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function keyDownBackspace(editor) {
+  if (!editor.selection) return;
+  if ((0, _isCursorAtStartOfNonEmptyHeading.default)(editor)) {
+    return;
+  }
+  if ((0, _isCursorAtStartOfBlockType.default)(editor, 'quote') && (0, _areCurrentAndPreviousBlocksOfType.default)(editor, 'quote')) {
+    _slate.Transforms.mergeNodes(editor, (0, _lowestMatchedAncestor.default)(editor, 'quote'));
+    return true;
+  }
+  return (0, _unwrapIfCursorAtStart.default)(editor, true);
+}
+var _default = exports.default = keyDownBackspace;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/events/keyDownEnter.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isCursorInBlockType = _interopRequireDefault(require("../locations/isCursorInBlockType"));
+var _splitIntoParagraph = _interopRequireDefault(require("../transforms/splitIntoParagraph"));
+var _unwrapIfCursorAtStart = _interopRequireDefault(require("../transforms/unwrapIfCursorAtStart"));
+var _isCursorAtEndOfParagraph = _interopRequireDefault(require("../locations/isCursorAtEndOfParagraph"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function keyDownEnter(editor) {
+  if (!editor.selection) return;
+  if ((0, _isCursorInBlockType.default)(editor, 'heading', true)) {
+    return handleHeading(editor);
+  }
+  return (0, _unwrapIfCursorAtStart.default)(editor);
+}
+function handleHeading(editor) {
+  if ((0, _isCursorAtEndOfParagraph.default)(editor)) {
+    // split into paragraph if cursor is at the end of heading
+    (0, _splitIntoParagraph.default)(editor);
+    return true;
+  }
+  return;
+}
+var _default = exports.default = keyDownEnter;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/events/toggleBlock.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _isCursorInBlockType = _interopRequireDefault(require("../locations/isCursorInBlockType"));
+var _getListTypeAtCursor = _interopRequireDefault(require("../locations/getListTypeAtCursor"));
+var _wrapListItemsInBlock = _interopRequireDefault(require("../transforms/wrapListItemsInBlock"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function toggleBlock(editor, type) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return;
+  const isHeading = type.startsWith('heading-');
+  const isActive = (0, _isCursorInBlockType.default)(editor, type, isHeading, _slate.Range.isExpanded(selection));
+  const listType = (0, _getListTypeAtCursor.default)(editor);
+
+  // headings do not contain paragraphs so they could be converted, not wrapped/unwrapped
+  if (isHeading) {
+    _slate.Transforms.setNodes(editor, {
+      type: isActive ? 'paragraph' : type
+    });
+    return;
+  }
+  const {
+    focus,
+    anchor
+  } = selection;
+  if (!isActive && listType && focus.path[focus.path.length - 3] != anchor.path[anchor.path.length - 3]) {
+    return (0, _wrapListItemsInBlock.default)(editor, type, listType);
+  }
+  if (!isActive) {
+    return _slate.Transforms.wrapNodes(editor, {
+      type
+    });
+  }
+  _slate.Transforms.unwrapNodes(editor, {
+    match: n => n.type === type
+  });
+  return;
+}
+var _default = exports.default = toggleBlock;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/locations/areCurrentAndPreviousBlocksOfType.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 areCurrentAndPreviousBlocksOfType(editor, type) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const [current] = _slate.Editor.nodes(editor, (0, _lowestMatchedAncestor.default)(editor, 'block'));
+  const previous = _slate.Editor.previous(editor, (0, _lowestMatchedAncestor.default)(editor, type));
+  return current && previous && current[0].type === previous[0].type;
+}
+var _default = exports.default = areCurrentAndPreviousBlocksOfType;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/locations/getListTypeAtCursor.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 getListTypeAtCursor(editor) {
+  const list = _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, 'list'));
+  if (!list) return null;
+  return list[0].type;
+}
+var _default = exports.default = getListTypeAtCursor;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorAfterSoftBreak.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isCursorAfterSoftBreak(editor) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const [previous] = _slate.Editor.previous(editor);
+  return previous && previous.type == 'break';
+}
+var _default = exports.default = isCursorAfterSoftBreak;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorAtEndOfParagraph.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 isCursorAtEndOfParagraph(editor) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const paragraph = _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, 'paragraph'));
+  return !!paragraph && _slate.Editor.isEnd(editor, editor.selection.focus, paragraph[1]);
+}
+var _default = exports.default = isCursorAtEndOfParagraph;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorAtStartOfBlockType.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 isCursorAtStartOfBlockType(editor, type) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const block = _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, type));
+  return !!block && _slate.Editor.isStart(editor, editor.selection.focus, block[1]);
+}
+var _default = exports.default = isCursorAtStartOfBlockType;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorAtStartOfNonEmptyHeading.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isCursorAtStartOfNonEmptyHeading(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}`.startsWith('heading-'),
+    mode: 'lowest'
+  }));
+  return !!match && _slate.Editor.isStart(editor, editor.selection.focus, match[1]) && !_slate.Editor.isEmpty(editor, match[0]);
+}
+var _default = exports.default = isCursorAtStartOfNonEmptyHeading;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorCollapsedAfterSoftBreak.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isCursorCollapsedAfterSoftBreak(editor) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  if (_slate.Range.isExpanded(selection)) return false;
+  const previous = _slate.Editor.previous(editor);
+  return previous && previous[0].type == 'break';
+}
+var _default = exports.default = isCursorCollapsedAfterSoftBreak;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorInBlockType.js

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

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorInNonDefaultBlock copy.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isCursorInNonDefaultBlock(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.isEditor(match[0]);
+}
+var _default = exports.default = isCursorInNonDefaultBlock;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorInNonDefaultBlock.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isCursorInNonDefaultBlock(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.isEditor(match[0]);
+}
+var _default = exports.default = isCursorInNonDefaultBlock;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/transforms/splitIntoParagraph.js

@@ -0,0 +1,22 @@
+"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 = exports.default = splitIntoParagraph;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/transforms/unwrapIfCursorAtStart.js

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

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/transforms/wrapListItemsInBlock.js

@@ -0,0 +1,26 @@
+"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 = exports.default = wrapListItemsInBlock;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/blocks/withBlocks.js

@@ -0,0 +1,18 @@
+"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 = exports.default = withBlocks;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/inlines/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 _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 = exports.default = keyDown;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/inlines/events/keyDownShiftEnter.js

@@ -0,0 +1,26 @@
+"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 = exports.default = keyDownShiftEnter;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/inlines/events/toggleLink.js

@@ -0,0 +1,23 @@
+"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 = exports.default = toggleLink;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/inlines/events/toggleMark.js

@@ -0,0 +1,17 @@
+"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 = exports.default = toggleMark;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/inlines/locations/isMarkActive.js

@@ -0,0 +1,16 @@
+"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 = exports.default = isMarkActive;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/inlines/selectors/getActiveLink.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 getActiveLink(editor) {
+  const [link] = _slate.Editor.nodes(editor, (0, _matchLink.default)(editor));
+  return link;
+}
+var _default = exports.default = getActiveLink;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/inlines/transforms/unwrapLink.js

@@ -0,0 +1,13 @@
+"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 = exports.default = unwrapLink;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/inlines/transforms/wrapLink.js

@@ -0,0 +1,44 @@
+"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 = exports.default = wrapLink;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/inlines/withInlines.js

@@ -0,0 +1,22 @@
+"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 = exports.default = withInlines;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/events/keyDown.js

@@ -0,0 +1,37 @@
+"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 = exports.default = keyDown;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/events/keyDownBackspace.js

@@ -0,0 +1,28 @@
+"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 = exports.default = keyDownBackspace;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/events/keyDownEnter.js

@@ -0,0 +1,43 @@
+"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 beginning 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 = exports.default = keyDownEnter;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/events/keyDownShiftTab.js

@@ -0,0 +1,31 @@
+"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(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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 = exports.default = keyDownShiftTab;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/events/keyDownTab.js

@@ -0,0 +1,56 @@
+"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(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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 = exports.default = keyDownTab;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/events/toggleListType.js

@@ -0,0 +1,28 @@
+"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 = exports.default = toggleListType;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/locations/isCursorAtListItemStart.js

@@ -0,0 +1,17 @@
+"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 = exports.default = isCursorAtListItemStart;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/locations/isCursorAtNoninitialParagraphStart.js

@@ -0,0 +1,16 @@
+"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 = exports.default = isCursorAtNoninitialParagraphStart;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/locations/isCursorInItemContainingNestedList.js

@@ -0,0 +1,13 @@
+"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 = exports.default = isCursorInItemContainingNestedList;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/locations/isCursorInListItem.js

@@ -0,0 +1,19 @@
+"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 = exports.default = isCursorInListItem;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/locations/isSelectionWithinNoninitialListItem.js

@@ -0,0 +1,17 @@
+"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 = exports.default = isSelectionWithinNoninitialListItem;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/selectors/getListContainedInListItem.js

@@ -0,0 +1,17 @@
+"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 = exports.default = getListContainedInListItem;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/selectors/getLowestAncestorList.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 getLowestAncestorList(editor) {
+  if (!editor.selection) return false;
+  return _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, 'list'));
+}
+var _default = exports.default = getLowestAncestorList;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/selectors/getLowestAncestorQuote.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 getLowestAncestorQuote(editor) {
+  if (!editor.selection) return false;
+  return _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, 'quote'));
+}
+var _default = exports.default = getLowestAncestorQuote;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/transforms/changeListType.js

@@ -0,0 +1,23 @@
+"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 = exports.default = changeListType;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/transforms/convertParagraphToListItem.js

@@ -0,0 +1,26 @@
+"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 = exports.default = convertParagraphToListItem;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/transforms/liftFirstMatchedParent.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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 = exports.default = liftFirstMatchedParent;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/transforms/liftListItem.js

@@ -0,0 +1,36 @@
+"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 = exports.default = liftListItem;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/transforms/mergeWithPreviousListItem.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 mergeWithPreviousListItem(editor) {
+  _slate.Editor.withoutNormalizing(editor, () => {
+    _slate.Transforms.mergeNodes(editor, (0, _lowestMatchedAncestor.default)(editor, 'list-item'));
+  });
+  _slate.Editor.normalize(editor, {
+    force: true
+  });
+}
+var _default = exports.default = mergeWithPreviousListItem;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/transforms/moveListToListItem.js

@@ -0,0 +1,17 @@
+"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 = exports.default = moveListToListItem;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/transforms/splitListItem.js

@@ -0,0 +1,36 @@
+"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 = exports.default = splitListItem;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/transforms/splitToNestedList.js

@@ -0,0 +1,36 @@
+"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 = exports.default = splitToNestedList;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/transforms/unwrapFirstMatchedParent.js

@@ -0,0 +1,13 @@
+"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 = exports.default = unwrapFirstMatchedParent;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/transforms/unwrapSelectionFromList.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 ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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 = exports.default = unwrapSelectionFromList;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/transforms/wrapFirstMatchedParent.js

@@ -0,0 +1,13 @@
+"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 = exports.default = wrapFirstMatchedParent;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/transforms/wrapSelectionInList.js

@@ -0,0 +1,26 @@
+"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 = exports.default = wrapSelectionInList;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/lists/withLists.js

@@ -0,0 +1,66 @@
+"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 = exports.default = withLists;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/matchers/lowestMatchedAncestor.js

@@ -0,0 +1,12 @@
+"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 = exports.default = lowestMatchedAncestor;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/matchers/matchLink.js

@@ -0,0 +1,13 @@
+"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 = exports.default = matchLink;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/matchers/matchedAncestors.js

@@ -0,0 +1,14 @@
+"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 = exports.default = matchedAncestors;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/shortcodes/insertShortcode.js

@@ -0,0 +1,30 @@
+"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'));
+  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);
+}
+var _default = exports.default = insertShortcode;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/shortcodes/locations/isCursorInEmptyParagraph.js

@@ -0,0 +1,19 @@
+"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 = exports.default = isCursorInEmptyParagraph;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/plugins/shortcodes/withShortcodes.js

@@ -0,0 +1,29 @@
+"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 = exports.default = withShortcodes;

node_modules/decap-cms-widget-markdown/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;
+}