planning

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

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _base = _interopRequireDefault(require("@emotion/styled/base"));
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _reactImmutableProptypes = _interopRequireDefault(require("react-immutable-proptypes"));
+var _react2 = require("@emotion/react");
+var _decapCmsUiDefault = require("decap-cms-ui-default");
+var _slate = require("slate");
+var _slateReact = require("slate-react");
+var _slateHistory = require("slate-history");
+var _styles = require("../styles");
+var _Toolbar = _interopRequireDefault(require("./Toolbar"));
+var _defaultEmptyBlock = _interopRequireDefault(require("./plugins/blocks/defaultEmptyBlock"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+function rawEditorStyles({
+  minimal
+}) {
+  return `
+  position: relative;
+  overflow: hidden;
+  overflow-x: auto;
+  min-height: ${minimal ? 'auto' : _decapCmsUiDefault.lengths.richTextEditorMinHeight};
+  font-family: ${_decapCmsUiDefault.fonts.mono};
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+  border-top: 0;
+  margin-top: -${_styles.editorStyleVars.stickyDistanceBottom};
+`;
+}
+const RawEditorContainer = /*#__PURE__*/(0, _base.default)("div", {
+  target: "e12tj7710",
+  label: "RawEditorContainer"
+})(process.env.NODE_ENV === "production" ? {
+  name: "bjn8wh",
+  styles: "position:relative"
+} : {
+  name: "bjn8wh",
+  styles: "position:relative",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+function RawEditor(props) {
+  const {
+    className,
+    field,
+    isShowModeToggle,
+    t,
+    onChange
+  } = props;
+  const editor = (0, _react.useMemo)(() => (0, _slateReact.withReact)((0, _slateHistory.withHistory)((0, _slate.createEditor)())), []);
+  const [value, setValue] = (0, _react.useState)(props.value ? props.value.split('\n').map(line => (0, _defaultEmptyBlock.default)(line)) : [(0, _defaultEmptyBlock.default)()]);
+  (0, _react.useEffect)(() => {
+    if (props.pendingFocus) {
+      _slateReact.ReactEditor.focus(editor);
+    }
+  }, []);
+  function handleToggleMode() {
+    props.onMode('rich_text');
+  }
+  function handleChange(value) {
+    onChange(value.map(line => line.children[0].text).join('\n'));
+    setValue(value);
+  }
+  return (0, _react2.jsx)(_slateReact.Slate, {
+    editor: editor,
+    value: value,
+    onChange: handleChange
+  }, (0, _react2.jsx)(RawEditorContainer, null, (0, _react2.jsx)(_styles.EditorControlBar, null, (0, _react2.jsx)(_Toolbar.default, {
+    onToggleMode: handleToggleMode,
+    buttons: field.get('buttons'),
+    disabled: true,
+    rawMode: true,
+    isShowModeToggle: isShowModeToggle,
+    t: t
+  })), (0, _react2.jsx)(_react2.ClassNames, null, ({
+    css,
+    cx
+  }) => (0, _react2.jsx)(_slateReact.Editable, {
+    className: cx(className, css`
+                  ${rawEditorStyles({
+      minimal: field.get('minimal')
+    })}
+                `),
+    value: value,
+    onChange: handleChange
+  }))));
+}
+RawEditor.propTypes = {
+  onChange: _propTypes.default.func.isRequired,
+  onMode: _propTypes.default.func.isRequired,
+  className: _propTypes.default.string.isRequired,
+  value: _propTypes.default.string,
+  field: _reactImmutableProptypes.default.map.isRequired,
+  isShowModeToggle: _propTypes.default.bool.isRequired,
+  t: _propTypes.default.func.isRequired
+};
+var _default = exports.default = RawEditor;

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

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _base = _interopRequireDefault(require("@emotion/styled/base"));
+var _react = _interopRequireDefault(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _decapCmsUiDefault = require("decap-cms-ui-default");
+var _react2 = require("@emotion/react");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const StyledToolbarButton = /*#__PURE__*/(0, _base.default)("button", {
+  target: "e1ps9s9m0",
+  label: "StyledToolbarButton"
+})(_decapCmsUiDefault.buttons.button, ";display:inline-block;padding:6px;border:none;background-color:transparent;font-size:16px;color:", props => props.isActive ? '#1e2532' : 'inherit', ";cursor:pointer;&:disabled{cursor:auto;opacity:0.5;}", _decapCmsUiDefault.Icon, "{display:block;}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9NYXJrZG93bkNvbnRyb2wvVG9vbGJhckJ1dHRvbi5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLeUMiLCJmaWxlIjoiLi4vLi4vLi4vc3JjL01hcmtkb3duQ29udHJvbC9Ub29sYmFyQnV0dG9uLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcbmltcG9ydCBQcm9wVHlwZXMgZnJvbSAncHJvcC10eXBlcyc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5pbXBvcnQgeyBJY29uLCBidXR0b25zIH0gZnJvbSAnZGVjYXAtY21zLXVpLWRlZmF1bHQnO1xuXG5jb25zdCBTdHlsZWRUb29sYmFyQnV0dG9uID0gc3R5bGVkLmJ1dHRvbmBcbiAgJHtidXR0b25zLmJ1dHRvbn07XG4gIGRpc3BsYXk6IGlubGluZS1ibG9jaztcbiAgcGFkZGluZzogNnB4O1xuICBib3JkZXI6IG5vbmU7XG4gIGJhY2tncm91bmQtY29sb3I6IHRyYW5zcGFyZW50O1xuICBmb250LXNpemU6IDE2cHg7XG4gIGNvbG9yOiAke3Byb3BzID0+IChwcm9wcy5pc0FjdGl2ZSA/ICcjMWUyNTMyJyA6ICdpbmhlcml0Jyl9O1xuICBjdXJzb3I6IHBvaW50ZXI7XG5cbiAgJjpkaXNhYmxlZCB7XG4gICAgY3Vyc29yOiBhdXRvO1xuICAgIG9wYWNpdHk6IDAuNTtcbiAgfVxuXG4gICR7SWNvbn0ge1xuICAgIGRpc3BsYXk6IGJsb2NrO1xuICB9XG5gO1xuXG5mdW5jdGlvbiBUb29sYmFyQnV0dG9uKHsgdHlwZSwgbGFiZWwsIGljb24sIG9uQ2xpY2ssIGlzQWN0aXZlLCBkaXNhYmxlZCB9KSB7XG4gIHJldHVybiAoXG4gICAgPFN0eWxlZFRvb2xiYXJCdXR0b25cbiAgICAgIGlzQWN0aXZlPXtpc0FjdGl2ZX1cbiAgICAgIG9uQ2xpY2s9e2UgPT4gb25DbGljayAmJiBvbkNsaWNrKGUsIHR5cGUpfVxuICAgICAgdGl0bGU9e2xhYmVsfVxuICAgICAgZGlzYWJsZWQ9e2Rpc2FibGVkfVxuICAgID5cbiAgICAgIHtpY29uID8gPEljb24gdHlwZT17aWNvbn0gLz4gOiBsYWJlbH1cbiAgICA8L1N0eWxlZFRvb2xiYXJCdXR0b24+XG4gICk7XG59XG5cblRvb2xiYXJCdXR0b24ucHJvcFR5cGVzID0ge1xuICB0eXBlOiBQcm9wVHlwZXMuc3RyaW5nLFxuICBsYWJlbDogUHJvcFR5cGVzLnN0cmluZy5pc1JlcXVpcmVkLFxuICBpY29uOiBQcm9wVHlwZXMuc3RyaW5nLFxuICBvbkNsaWNrOiBQcm9wVHlwZXMuZnVuYyxcbiAgaXNBY3RpdmU6IFByb3BUeXBlcy5ib29sLFxuICBkaXNhYmxlZDogUHJvcFR5cGVzLmJvb2wsXG59O1xuXG5leHBvcnQgZGVmYXVsdCBUb29sYmFyQnV0dG9uO1xuIl19 */"));
+function ToolbarButton({
+  type,
+  label,
+  icon,
+  onClick,
+  isActive,
+  disabled
+}) {
+  return (0, _react2.jsx)(StyledToolbarButton, {
+    isActive: isActive,
+    onClick: e => onClick && onClick(e, type),
+    title: label,
+    disabled: disabled
+  }, icon ? (0, _react2.jsx)(_decapCmsUiDefault.Icon, {
+    type: icon
+  }) : label);
+}
+ToolbarButton.propTypes = {
+  type: _propTypes.default.string,
+  label: _propTypes.default.string.isRequired,
+  icon: _propTypes.default.string,
+  onClick: _propTypes.default.func,
+  isActive: _propTypes.default.bool,
+  disabled: _propTypes.default.bool
+};
+var _default = exports.default = ToolbarButton;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/components/Shortcode.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _omit2 = _interopRequireDefault(require("lodash/omit"));
+var _react = _interopRequireWildcard(require("react"));
+var _react2 = require("@emotion/react");
+var _immutable = require("immutable");
+var _slateReact = require("slate-react");
+var _slate = require("slate");
+var _index = require("../index");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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 _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; } /* eslint-disable react/prop-types */
+var _ref = process.env.NODE_ENV === "production" ? {
+  name: "1xfnuhy-Shortcode",
+  styles: "margin-top:0;margin-bottom:16px;&:first-of-type{margin-top:0;};label:Shortcode;"
+} : {
+  name: "1xfnuhy-Shortcode",
+  styles: "margin-top:0;margin-bottom:16px;&:first-of-type{margin-top:0;};label:Shortcode;",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+function Shortcode(props) {
+  const editor = (0, _slateReact.useSlate)();
+  const {
+    element,
+    dataKey = 'shortcodeData',
+    children
+  } = props;
+  const EditorControl = (0, _index.getEditorControl)();
+  const plugin = (0, _index.getEditorComponents)().get(element.data.shortcode);
+  const fieldKeys = ['id', 'fromBlock', 'toBlock', 'toPreview', 'pattern', 'icon'];
+  const field = (0, _immutable.fromJS)((0, _omit2.default)(plugin, fieldKeys));
+  const [value, setValue] = (0, _react.useState)((0, _immutable.fromJS)(element.data[dataKey]));
+  function handleChange(fieldName, value, metadata) {
+    const path = _slateReact.ReactEditor.findPath(editor, element);
+    const newProperties = {
+      data: _objectSpread(_objectSpread({}, element.data), {}, {
+        [dataKey]: value.toJS(),
+        metadata
+      })
+    };
+    _slate.Transforms.setNodes(editor, newProperties, {
+      at: path
+    });
+    setValue(value);
+  }
+  function handleFocus() {
+    const path = _slateReact.ReactEditor.findPath(editor, element);
+    _slate.Transforms.select(editor, path);
+  }
+  const path = _slateReact.ReactEditor.findPath(editor, element);
+  const isSelected = editor.selection && path && _slate.Range.isRange(editor.selection) && _slate.Range.includes(editor.selection, path);
+  return !field.isEmpty() && (0, _react2.jsx)("div", {
+    onClick: handleFocus,
+    onFocus: handleFocus
+  }, (0, _react2.jsx)(EditorControl, {
+    css: _ref,
+    value: value,
+    field: field,
+    onChange: handleChange,
+    isEditorComponent: true,
+    onValidateObject: () => {},
+    isNewEditorComponent: element.data.shortcodeNew,
+    isSelected: isSelected
+  }), children);
+}
+var _default = exports.default = Shortcode;

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownControl/components/VoidBlock.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@emotion/react");
+var _decapCmsUiDefault = require("decap-cms-ui-default");
+var _slateReact = require("slate-react");
+var _slate = require("slate");
+var _defaultEmptyBlock = _interopRequireDefault(require("../plugins/blocks/defaultEmptyBlock"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); } /* eslint-disable react/prop-types */
+function InsertionPoint(props) {
+  return (0, _react2.jsx)("div", _extends({
+    css: /*#__PURE__*/(0, _react2.css)("height:32px;cursor:text;position:relative;z-index:", _decapCmsUiDefault.zIndex.zIndex1, ";margin-top:-16px;;label:InsertionPoint;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"))
+  }, props));
+}
+function VoidBlock({
+  attributes,
+  children,
+  element
+}) {
+  const editor = (0, _slateReact.useSlate)();
+  const path = _slateReact.ReactEditor.findPath(editor, element);
+  function insertAtPath(at) {
+    _slate.Transforms.insertNodes(editor, (0, _defaultEmptyBlock.default)(), {
+      select: true,
+      at
+    });
+  }
+  function handleClick(event) {
+    event.stopPropagation();
+  }
+  function handleInsertBefore() {
+    insertAtPath(path);
+  }
+  function handleInsertAfter() {
+    insertAtPath([...path.slice(0, -1), path[path.length - 1] + 1]);
+  }
+  const insertBefore = path[0] === 0;
+  const nextElement = editor.children[path[0] + 1];
+  const insertAfter = path[0] === editor.children.length - 1 || editor.isVoid(nextElement);
+  return (0, _react2.jsx)("div", _extends({}, attributes, {
+    onClick: handleClick,
+    contentEditable: false
+  }), insertBefore && (0, _react2.jsx)(InsertionPoint, {
+    onClick: handleInsertBefore
+  }), children, insertAfter && (0, _react2.jsx)(InsertionPoint, {
+    onClick: handleInsertAfter
+  }));
+}
+var _default = exports.default = VoidBlock;

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

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getEditorComponents = getEditorComponents;
+exports.getEditorControl = getEditorControl;
+var _react = _interopRequireDefault(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _reactImmutableProptypes = _interopRequireDefault(require("react-immutable-proptypes"));
+var _immutable = require("immutable");
+var _RawEditor = _interopRequireDefault(require("./RawEditor"));
+var _VisualEditor = _interopRequireDefault(require("./VisualEditor"));
+var _react2 = require("@emotion/react");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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); }
+const MODE_STORAGE_KEY = 'cms.md-mode';
+
+// TODO: passing the editorControl and components like this is horrible, should
+// be handled through Redux and a separate registry store for instances
+let editorControl;
+// eslint-disable-next-line func-style
+let _getEditorComponents = () => (0, _immutable.Map)();
+function getEditorControl() {
+  return editorControl;
+}
+function getEditorComponents() {
+  return _getEditorComponents();
+}
+class MarkdownControl extends _react.default.Component {
+  constructor(props) {
+    var _localStorage$getItem;
+    super(props);
+    _defineProperty(this, "handleMode", mode => {
+      this.setState({
+        mode,
+        pendingFocus: true
+      });
+      localStorage.setItem(MODE_STORAGE_KEY, mode);
+    });
+    _defineProperty(this, "processRef", ref => this.ref = ref);
+    _defineProperty(this, "setFocusReceived", () => {
+      this.setState({
+        pendingFocus: false
+      });
+    });
+    _defineProperty(this, "getAllowedModes", () => this.props.field.get('modes', (0, _immutable.List)(['rich_text', 'raw'])).toArray());
+    editorControl = props.editorControl;
+    const preferredMode = (_localStorage$getItem = localStorage.getItem(MODE_STORAGE_KEY)) !== null && _localStorage$getItem !== void 0 ? _localStorage$getItem : 'rich_text';
+    _getEditorComponents = props.getEditorComponents;
+    this.state = {
+      mode: this.getAllowedModes().indexOf(preferredMode) !== -1 ? preferredMode : this.getAllowedModes()[0],
+      pendingFocus: false
+    };
+  }
+  render() {
+    const {
+      onChange,
+      onAddAsset,
+      getAsset,
+      value,
+      classNameWrapper,
+      field,
+      getEditorComponents,
+      getRemarkPlugins,
+      resolveWidget,
+      t,
+      isDisabled
+    } = this.props;
+    const {
+      mode,
+      pendingFocus
+    } = this.state;
+    const isShowModeToggle = this.getAllowedModes().length > 1;
+    const visualEditor = (0, _react2.jsx)("div", {
+      className: "cms-editor-visual",
+      ref: this.processRef
+    }, (0, _react2.jsx)(_VisualEditor.default, {
+      onChange: onChange,
+      onAddAsset: onAddAsset,
+      isShowModeToggle: isShowModeToggle,
+      onMode: this.handleMode,
+      getAsset: getAsset,
+      className: classNameWrapper,
+      value: value,
+      field: field,
+      getEditorComponents: getEditorComponents,
+      getRemarkPlugins: getRemarkPlugins,
+      resolveWidget: resolveWidget,
+      pendingFocus: pendingFocus && this.setFocusReceived,
+      t: t,
+      isDisabled: isDisabled
+    }));
+    const rawEditor = (0, _react2.jsx)("div", {
+      className: "cms-editor-raw",
+      ref: this.processRef
+    }, (0, _react2.jsx)(_RawEditor.default, {
+      onChange: onChange,
+      onAddAsset: onAddAsset,
+      isShowModeToggle: isShowModeToggle,
+      onMode: this.handleMode,
+      getAsset: getAsset,
+      className: classNameWrapper,
+      value: value,
+      field: field,
+      pendingFocus: pendingFocus && this.setFocusReceived,
+      t: t
+    }));
+    return mode === 'rich_text' ? visualEditor : rawEditor;
+  }
+}
+exports.default = MarkdownControl;
+_defineProperty(MarkdownControl, "propTypes", {
+  onChange: _propTypes.default.func.isRequired,
+  onAddAsset: _propTypes.default.func.isRequired,
+  getAsset: _propTypes.default.func.isRequired,
+  classNameWrapper: _propTypes.default.string.isRequired,
+  editorControl: _propTypes.default.elementType.isRequired,
+  value: _propTypes.default.string,
+  field: _reactImmutableProptypes.default.map.isRequired,
+  getEditorComponents: _propTypes.default.func,
+  t: _propTypes.default.func.isRequired
+});
+_defineProperty(MarkdownControl, "defaultProps", {
+  value: ''
+});

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;
+}