planning

node_modules/decap-cms-widget-markdown/dist/decap-cms-widget-markdown.js.LICENSE.txt

@@ -0,0 +1,48 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+/*!
+ * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+/*!
+ * repeat-string <https://github.com/jonschlinkert/repeat-string>
+ *
+ * Copyright (c) 2014-2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+/*! @license DOMPurify 2.4.7 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.4.7/LICENSE */
+
+/**
+ * @license React
+ * react-dom-server-legacy.browser.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * react-dom-server.browser.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */

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

node_modules/decap-cms-widget-markdown/dist/esm/MarkdownPreview.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _decapCmsUiDefault = require("decap-cms-ui-default");
+var _dompurify = _interopRequireDefault(require("dompurify"));
+var _serializers = require("./serializers");
+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); }
+class MarkdownPreview extends _react.default.Component {
+  render() {
+    const {
+      value,
+      getAsset,
+      resolveWidget,
+      field,
+      getRemarkPlugins
+    } = this.props;
+    if (value === null) {
+      return null;
+    }
+    const html = (0, _serializers.markdownToHtml)(value, {
+      getAsset,
+      resolveWidget
+    }, getRemarkPlugins === null || getRemarkPlugins === void 0 ? void 0 : getRemarkPlugins());
+    const toRender = field !== null && field !== void 0 && field.get('sanitize_preview', false) ? _dompurify.default.sanitize(html) : html;
+    return (0, _react2.jsx)(_decapCmsUiDefault.WidgetPreviewContainer, {
+      dangerouslySetInnerHTML: {
+        __html: toRender
+      }
+    });
+  }
+}
+_defineProperty(MarkdownPreview, "propTypes", {
+  getAsset: _propTypes.default.func.isRequired,
+  resolveWidget: _propTypes.default.func.isRequired,
+  value: _propTypes.default.string
+});
+var _default = exports.default = MarkdownPreview;

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

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.DecapCmsWidgetMarkdown = void 0;
+var _MarkdownControl = _interopRequireDefault(require("./MarkdownControl"));
+var _MarkdownPreview = _interopRequireDefault(require("./MarkdownPreview"));
+var _schema = _interopRequireDefault(require("./schema"));
+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 Widget(opts = {}) {
+  return _objectSpread({
+    name: 'markdown',
+    controlComponent: _MarkdownControl.default,
+    previewComponent: _MarkdownPreview.default,
+    schema: _schema.default
+  }, opts);
+}
+const DecapCmsWidgetMarkdown = exports.DecapCmsWidgetMarkdown = {
+  Widget,
+  controlComponent: _MarkdownControl.default,
+  previewComponent: _MarkdownPreview.default
+};
+var _default = exports.default = DecapCmsWidgetMarkdown;

node_modules/decap-cms-widget-markdown/dist/esm/regexHelper.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.combinePatterns = combinePatterns;
+exports.joinPatternSegments = joinPatternSegments;
+exports.replaceWhen = replaceWhen;
+var _last2 = _interopRequireDefault(require("lodash/last"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Joins an array of regular expressions into a single expression, without
+ * altering the received expressions.
+ */
+function joinPatternSegments(patterns) {
+  return patterns.map(p => p.source).join('');
+}
+
+/**
+ * Combines an array of regular expressions into a single expression, wrapping
+ * each in a non-capturing group and interposing alternation characters (|) so
+ * that each expression is executed separately.
+ */
+function combinePatterns(patterns) {
+  return patterns.map(p => `(?:${p.source})`).join('|');
+}
+
+/**
+ * Modify substrings within a string if they match a (global) pattern. Can be
+ * inverted to only modify non-matches.
+ *
+ * params:
+ * matchPattern - regexp - a regular expression to check for matches
+ * replaceFn - function - a replacement function that receives a matched
+ *   substring and returns a replacement substring
+ * text - string - the string to process
+ * invertMatchPattern - boolean - if true, non-matching substrings are modified
+ *   instead of matching substrings
+ */
+function replaceWhen(matchPattern, replaceFn, text, invertMatchPattern) {
+  /**
+   * Splits the string into an array of objects with the following shape:
+   *
+   * {
+   *   index: number - the index of the substring within the string
+   *   text: string - the substring
+   *   match: boolean - true if the substring matched `matchPattern`
+   * }
+   *
+   * Loops through matches via recursion (`RegExp.exec` tracks the loop
+   * internally).
+   */
+  function split(exp, text, acc) {
+    /**
+     * Get the next match starting from the end of the last match or start of
+     * string.
+     */
+    const match = exp.exec(text);
+    const lastEntry = (0, _last2.default)(acc);
+
+    /**
+     * `match` will be null if there are no matches.
+     */
+    if (!match) return acc;
+
+    /**
+     * If the match is at the beginning of the input string, normalize to a data
+     * object with the `match` flag set to `true`, and add to the accumulator.
+     */
+    if (match.index === 0) {
+      addSubstring(acc, 0, match[0], true);
+    } else if (!lastEntry) {
+      /**
+       * If there are no entries in the accumulator, convert the substring before
+       * the match to a data object (without the `match` flag set to true) and
+       * push to the accumulator, followed by a data object for the matching
+       * substring.
+       */
+      addSubstring(acc, 0, match.input.slice(0, match.index));
+      addSubstring(acc, match.index, match[0], true);
+    } else if (match.index === lastEntry.index + lastEntry.text.length) {
+      /**
+       * If the last entry in the accumulator immediately preceded the current
+       * matched substring in the original string, just add the data object for
+       * the matching substring to the accumulator.
+       */
+      addSubstring(acc, match.index, match[0], true);
+    } else {
+      /**
+       * Convert the substring before the match to a data object (without the
+       * `match` flag set to true), followed by a data object for the matching
+       * substring.
+       */
+      const nextIndex = lastEntry.index + lastEntry.text.length;
+      const nextText = match.input.slice(nextIndex, match.index);
+      addSubstring(acc, nextIndex, nextText);
+      addSubstring(acc, match.index, match[0], true);
+    }
+
+    /**
+     * Continue executing the expression.
+     */
+    return split(exp, text, acc);
+  }
+
+  /**
+   * Factory for converting substrings to data objects and adding to an output
+   * array.
+   */
+  function addSubstring(arr, index, text, match = false) {
+    arr.push({
+      index,
+      text,
+      match
+    });
+  }
+
+  /**
+   * Split the input string to an array of data objects, each representing a
+   * matching or non-matching string.
+   */
+  const acc = split(matchPattern, text, []);
+
+  /**
+   * Process the trailing substring after the final match, if one exists.
+   */
+  const lastEntry = (0, _last2.default)(acc);
+  if (!lastEntry) return replaceFn(text);
+  const nextIndex = lastEntry.index + lastEntry.text.length;
+  if (text.length > nextIndex) {
+    acc.push({
+      index: nextIndex,
+      text: text.slice(nextIndex)
+    });
+  }
+
+  /**
+   * Map the data objects in the accumulator to their string values, modifying
+   * matched strings with the replacement function. Modifies non-matches if
+   * `invertMatchPattern` is truthy.
+   */
+  const replacedText = acc.map(entry => {
+    const isMatch = invertMatchPattern ? !entry.match : entry.match;
+    return isMatch ? replaceFn(entry.text) : entry.text;
+  });
+
+  /**
+   * Return the joined string.
+   */
+  return replacedText.join('');
+}

node_modules/decap-cms-widget-markdown/dist/esm/schema.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = exports.default = {
+  properties: {
+    minimal: {
+      type: 'boolean'
+    },
+    buttons: {
+      type: 'array',
+      items: {
+        type: 'string',
+        enum: ['bold', 'italic', 'code', 'link', 'heading-one', 'heading-two', 'heading-three', 'heading-four', 'heading-five', 'heading-six', 'quote', 'bulleted-list', 'numbered-list']
+      }
+    },
+    editor_components: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    },
+    modes: {
+      type: 'array',
+      items: {
+        type: 'string',
+        enum: ['raw', 'rich_text']
+      },
+      minItems: 1
+    }
+  }
+};

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

@@ -0,0 +1,233 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.htmlToSlate = htmlToSlate;
+exports.markdownToHtml = markdownToHtml;
+exports.markdownToRemark = markdownToRemark;
+exports.markdownToSlate = markdownToSlate;
+exports.remarkToMarkdown = remarkToMarkdown;
+exports.slateToMarkdown = slateToMarkdown;
+var _trimEnd2 = _interopRequireDefault(require("lodash/trimEnd"));
+var _unified = _interopRequireDefault(require("unified"));
+var _unistBuilder = _interopRequireDefault(require("unist-builder"));
+var _remarkParse = _interopRequireDefault(require("remark-parse"));
+var _remarkStringify = _interopRequireDefault(require("remark-stringify"));
+var _remarkRehype = _interopRequireDefault(require("remark-rehype"));
+var _rehypeStringify = _interopRequireDefault(require("rehype-stringify"));
+var _rehypeParse = _interopRequireDefault(require("rehype-parse"));
+var _rehypeRemark = _interopRequireDefault(require("rehype-remark"));
+var _remarkRehypeShortcodes = _interopRequireDefault(require("./remarkRehypeShortcodes"));
+var _rehypePaperEmoji = _interopRequireDefault(require("./rehypePaperEmoji"));
+var _remarkAssertParents = _interopRequireDefault(require("./remarkAssertParents"));
+var _remarkPaddedLinks = _interopRequireDefault(require("./remarkPaddedLinks"));
+var _remarkWrapHtml = _interopRequireDefault(require("./remarkWrapHtml"));
+var _remarkSlate = _interopRequireDefault(require("./remarkSlate"));
+var _remarkSquashReferences = _interopRequireDefault(require("./remarkSquashReferences"));
+var _remarkShortcodes = require("./remarkShortcodes");
+var _remarkEscapeMarkdownEntities = _interopRequireDefault(require("./remarkEscapeMarkdownEntities"));
+var _remarkStripTrailingBreaks = _interopRequireDefault(require("./remarkStripTrailingBreaks"));
+var _remarkAllowHtmlEntities = _interopRequireDefault(require("./remarkAllowHtmlEntities"));
+var _slateRemark = _interopRequireDefault(require("./slateRemark"));
+var _MarkdownControl = require("../MarkdownControl");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * This module contains all serializers for the Markdown widget.
+ *
+ * The value of a Markdown widget is transformed to various formats during
+ * editing, and these formats are referenced throughout serializer source
+ * documentation. Below is brief glossary of the formats used.
+ *
+ * - Markdown {string}
+ *   The stringified Markdown value. The value of the field is persisted
+ *   (stored) in this format, and the stringified value is also used when the
+ *   editor is in "raw" Markdown mode.
+ *
+ * - MDAST {object}
+ *   Also loosely referred to as "Remark". MDAST stands for MarkDown AST
+ *   (Abstract Syntax Tree), and is an object representation of a Markdown
+ *   document. Underneath, it's a Unist tree with a Markdown-specific schema.
+ *   MDAST syntax is a part of the Unified ecosystem, and powers the Remark
+ *   processor, so Remark plugins may be used.
+ *
+ * - HAST {object}
+ *   Also loosely referred to as "Rehype". HAST, similar to MDAST, is an object
+ *   representation of an HTML document.  The field value takes this format
+ *   temporarily before the document is stringified to HTML.
+ *
+ * - HTML {string}
+ *   The field value is stringified to HTML for preview purposes - the HTML value
+ *   is never parsed, it is output only.
+ *
+ * - Slate Raw AST {object}
+ *   Slate's Raw AST is a very simple and unopinionated object representation of
+ *   a document in a Slate editor. We define our own Markdown-specific schema
+ *   for serialization to/from Slate's Raw AST and MDAST.
+ */
+
+/**
+ * Deserialize a Markdown string to an MDAST.
+ */
+function markdownToRemark(markdown, remarkPlugins) {
+  const processor = (0, _unified.default)().use(_remarkParse.default, {
+    fences: true,
+    commonmark: true
+  }).use(markdownToRemarkRemoveTokenizers, {
+    inlineTokenizers: ['url']
+  }).use(_remarkShortcodes.remarkParseShortcodes, {
+    plugins: (0, _MarkdownControl.getEditorComponents)()
+  }).use(_remarkAllowHtmlEntities.default).use(_remarkSquashReferences.default).use(remarkPlugins);
+
+  /**
+   * Parse the Markdown string input to an MDAST.
+   */
+  const parsed = processor.parse(markdown);
+
+  /**
+   * Further transform the MDAST with plugins.
+   */
+  const result = processor.runSync(parsed);
+  return result;
+}
+
+/**
+ * Remove named tokenizers from the parser, effectively deactivating them.
+ */
+function markdownToRemarkRemoveTokenizers({
+  inlineTokenizers
+}) {
+  inlineTokenizers && inlineTokenizers.forEach(tokenizer => {
+    delete this.Parser.prototype.inlineTokenizers[tokenizer];
+  });
+}
+
+/**
+ * Serialize an MDAST to a Markdown string.
+ */
+function remarkToMarkdown(obj, remarkPlugins) {
+  /**
+   * Rewrite the remark-stringify text visitor to simply return the text value,
+   * without encoding or escaping any characters. This means we're completely
+   * trusting the markdown that we receive.
+   */
+  function remarkAllowAllText() {
+    const Compiler = this.Compiler;
+    const visitors = Compiler.prototype.visitors;
+    visitors.text = node => node.value;
+  }
+
+  /**
+   * Provide an empty MDAST if no value is provided.
+   */
+  const mdast = obj || (0, _unistBuilder.default)('root', [(0, _unistBuilder.default)('paragraph', [(0, _unistBuilder.default)('text', '')])]);
+  const remarkToMarkdownPluginOpts = {
+    commonmark: true,
+    fences: true,
+    listItemIndent: '1',
+    /**
+     * Use asterisk for everything, it's the most versatile. Eventually using
+     * other characters should be an option.
+     */
+    bullet: '*',
+    emphasis: '*',
+    strong: '*',
+    rule: '-'
+  };
+  const processor = (0, _unified.default)().use({
+    settings: remarkToMarkdownPluginOpts
+  }).use(_remarkEscapeMarkdownEntities.default).use(_remarkStripTrailingBreaks.default).use(_remarkStringify.default).use(remarkAllowAllText).use((0, _remarkShortcodes.createRemarkShortcodeStringifier)({
+    plugins: (0, _MarkdownControl.getEditorComponents)()
+  })).use(remarkPlugins);
+
+  /**
+   * Transform the MDAST with plugins.
+   */
+  const processedMdast = processor.runSync(mdast);
+
+  /**
+   * Serialize the MDAST to markdown.
+   */
+  const markdown = processor.stringify(processedMdast).replace(/\r?/g, '');
+
+  /**
+   * Return markdown with trailing whitespace removed.
+   */
+  return (0, _trimEnd2.default)(markdown);
+}
+
+/**
+ * Convert Markdown to HTML.
+ */
+function markdownToHtml(markdown, {
+  getAsset,
+  resolveWidget,
+  remarkPlugins = []
+} = {}) {
+  const mdast = markdownToRemark(markdown, remarkPlugins);
+  const hast = (0, _unified.default)().use(_remarkRehypeShortcodes.default, {
+    plugins: (0, _MarkdownControl.getEditorComponents)(),
+    getAsset,
+    resolveWidget
+  }).use(_remarkRehype.default, {
+    allowDangerousHTML: true
+  }).runSync(mdast);
+  const html = (0, _unified.default)().use(_rehypeStringify.default, {
+    allowDangerousHtml: true,
+    allowDangerousCharacters: true,
+    closeSelfClosing: true,
+    entities: {
+      useNamedReferences: true
+    }
+  }).stringify(hast);
+  return html;
+}
+
+/**
+ * Deserialize an HTML string to Slate's Raw AST. Currently used for HTML
+ * pastes.
+ */
+function htmlToSlate(html) {
+  const hast = (0, _unified.default)().use(_rehypeParse.default, {
+    fragment: true
+  }).parse(html);
+  const mdast = (0, _unified.default)().use(_rehypePaperEmoji.default).use(_rehypeRemark.default, {
+    minify: false
+  }).runSync(hast);
+  const slateRaw = (0, _unified.default)().use(_remarkAssertParents.default).use(_remarkPaddedLinks.default).use(_remarkWrapHtml.default).use(_remarkSlate.default).runSync(mdast);
+  return slateRaw;
+}
+
+/**
+ * Convert Markdown to Slate's Raw AST.
+ */
+function markdownToSlate(markdown, {
+  voidCodeBlock,
+  remarkPlugins = []
+} = {}) {
+  const mdast = markdownToRemark(markdown, remarkPlugins);
+  const slateRaw = (0, _unified.default)().use(_remarkWrapHtml.default).use(_remarkSlate.default, {
+    voidCodeBlock
+  }).runSync(mdast);
+  return slateRaw.children;
+}
+
+/**
+ * Convert a Slate Raw AST to Markdown.
+ *
+ * Requires shortcode plugins to parse shortcode nodes back to text.
+ *
+ * Note that Unified is not utilized for the conversion from Slate's Raw AST to
+ * MDAST. The conversion is manual because Unified can only operate on Unist
+ * trees.
+ */
+function slateToMarkdown(raw, {
+  voidCodeBlock,
+  remarkPlugins = []
+} = {}) {
+  const mdast = (0, _slateRemark.default)(raw, {
+    voidCodeBlock
+  });
+  const markdown = remarkToMarkdown(mdast, remarkPlugins);
+  return markdown;
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/rehypePaperEmoji.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = rehypePaperEmoji;
+/**
+ * Dropbox Paper outputs emoji characters as images, and stores the actual
+ * emoji character in a `data-emoji-ch` attribute on the image. This plugin
+ * replaces the images with the emoji characters.
+ */
+function rehypePaperEmoji() {
+  function transform(node) {
+    if (node.tagName === 'img' && node.properties.dataEmojiCh) {
+      return {
+        type: 'text',
+        value: node.properties.dataEmojiCh
+      };
+    }
+    node.children = node.children ? node.children.map(transform) : node.children;
+    return node;
+  }
+  return transform;
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/remarkAllowHtmlEntities.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remarkAllowHtmlEntities;
+function remarkAllowHtmlEntities() {
+  this.Parser.prototype.inlineTokenizers.text = text;
+
+  /**
+   * This is a port of the `remark-parse` text tokenizer, adapted to exclude
+   * HTML entity decoding.
+   */
+  function text(eat, value, silent) {
+    var self = this;
+    var methods;
+    var tokenizers;
+    var index;
+    var length;
+    var subvalue;
+    var position;
+    var tokenizer;
+    var name;
+    var min;
+
+    /* istanbul ignore if - never used (yet) */
+    if (silent) {
+      return true;
+    }
+    methods = self.inlineMethods;
+    length = methods.length;
+    tokenizers = self.inlineTokenizers;
+    index = -1;
+    min = value.length;
+    while (++index < length) {
+      name = methods[index];
+      if (name === 'text' || !tokenizers[name]) {
+        continue;
+      }
+      tokenizer = tokenizers[name].locator;
+      if (!tokenizer) {
+        eat.file.fail('Missing locator: `' + name + '`');
+      }
+      position = tokenizer.call(self, value, 1);
+      if (position !== -1 && position < min) {
+        min = position;
+      }
+    }
+    subvalue = value.slice(0, min);
+    eat(subvalue)({
+      type: 'text',
+      value: subvalue
+    });
+  }
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/remarkAssertParents.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remarkUnwrapInvalidNest;
+var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));
+var _nth2 = _interopRequireDefault(require("lodash/nth"));
+var _last2 = _interopRequireDefault(require("lodash/last"));
+var _concat2 = _interopRequireDefault(require("lodash/concat"));
+var _unistUtilVisitParents = _interopRequireDefault(require("unist-util-visit-parents"));
+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); }
+/**
+ * remarkUnwrapInvalidNest
+ *
+ * Some MDAST node types can only be nested within specific node types - for
+ * example, a paragraph can't be nested within another paragraph, and a heading
+ * can't be nested in a "strong" type node. This kind of invalid MDAST can be
+ * generated by rehype-remark from invalid HTML.
+ *
+ * This plugin finds instances of invalid nesting, and unwraps the invalidly
+ * nested nodes as far up the parental line as necessary, splitting parent nodes
+ * along the way. The resulting node has no invalidly nested nodes, and all
+ * validly nested nodes retain their ancestry. Nodes that are emptied as a
+ * result of unnesting nodes are removed from the tree.
+ */
+function remarkUnwrapInvalidNest() {
+  return transform;
+  function transform(tree) {
+    const invalidNest = findInvalidNest(tree);
+    if (!invalidNest) return tree;
+    splitTreeAtNest(tree, invalidNest);
+    return transform(tree);
+  }
+
+  /**
+   * visitParents uses unist-util-visit-parent to check every node in the
+   * tree while having access to every ancestor of the node. This is ideal
+   * for determining whether a block node has an ancestor that should not
+   * contain a block node. Note that it operates in a mutable fashion.
+   */
+  function findInvalidNest(tree) {
+    /**
+     * Node types that are considered "blocks".
+     */
+    const blocks = ['paragraph', 'heading', 'code', 'blockquote', 'list', 'table', 'thematicBreak'];
+
+    /**
+     * Node types that can contain "block" nodes as direct children. We check
+     */
+    const canContainBlocks = ['root', 'blockquote', 'listItem', 'tableCell'];
+    let invalidNest;
+    (0, _unistUtilVisitParents.default)(tree, (node, parents) => {
+      const parentType = !(0, _isEmpty2.default)(parents) && (0, _last2.default)(parents).type;
+      const isInvalidNest = blocks.includes(node.type) && !canContainBlocks.includes(parentType);
+      if (isInvalidNest) {
+        invalidNest = (0, _concat2.default)(parents, node);
+        return false;
+      }
+    });
+    return invalidNest;
+  }
+  function splitTreeAtNest(tree, nest) {
+    const grandparent = (0, _nth2.default)(nest, -3) || tree;
+    const parent = (0, _nth2.default)(nest, -2);
+    const node = (0, _last2.default)(nest);
+    const splitIndex = grandparent.children.indexOf(parent);
+    const splitChildren = grandparent.children;
+    const splitChildIndex = parent.children.indexOf(node);
+    const childrenBefore = parent.children.slice(0, splitChildIndex);
+    const childrenAfter = parent.children.slice(splitChildIndex + 1);
+    const nodeBefore = !(0, _isEmpty2.default)(childrenBefore) && _objectSpread(_objectSpread({}, parent), {}, {
+      children: childrenBefore
+    });
+    const nodeAfter = !(0, _isEmpty2.default)(childrenAfter) && _objectSpread(_objectSpread({}, parent), {}, {
+      children: childrenAfter
+    });
+    const childrenToInsert = [nodeBefore, node, nodeAfter].filter(val => !(0, _isEmpty2.default)(val));
+    const beforeChildren = splitChildren.slice(0, splitIndex);
+    const afterChildren = splitChildren.slice(splitIndex + 1);
+    const newChildren = (0, _concat2.default)(beforeChildren, childrenToInsert, afterChildren);
+    grandparent.children = newChildren;
+  }
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/remarkEscapeMarkdownEntities.js

@@ -0,0 +1,271 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remarkEscapeMarkdownEntities;
+var _map2 = _interopRequireDefault(require("lodash/map"));
+var _partial2 = _interopRequireDefault(require("lodash/partial"));
+var _flow2 = _interopRequireDefault(require("lodash/flow"));
+var _has2 = _interopRequireDefault(require("lodash/has"));
+var _regexHelper = require("../regexHelper");
+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); }
+/**
+ * Reusable regular expressions segments.
+ */
+const patternSegments = {
+  /**
+   * Matches zero or more HTML attributes followed by the tag close bracket,
+   * which may be prepended by zero or more spaces.  The attributes can use
+   * single or double quotes and may be prepended by zero or more spaces.
+   */
+  htmlOpeningTagEnd: /(?: *\w+=(?:(?:"[^"]*")|(?:'[^']*')))* *>/
+};
+
+/**
+ * Patterns matching substrings that should not be escaped. Array values must be
+ * joined before use.
+ */
+const nonEscapePatterns = {
+  /**
+   * HTML Tags
+   *
+   * Matches HTML opening tags and any attributes. Does not check for contents
+   * between tags or closing tags.
+   */
+  htmlTags: [
+  /**
+   * Matches the beginning of an HTML tag, excluding preformatted tag types.
+   */
+  /<(?!pre|style|script)[\w]+/,
+  /**
+   * Matches attributes.
+   */
+  patternSegments.htmlOpeningTagEnd],
+  /**
+   * Preformatted HTML Blocks
+   *
+   * Matches HTML blocks with preformatted content. The content of these blocks,
+   * including the tags and attributes, should not be escaped at all.
+   */
+  preformattedHtmlBlocks: [
+  /**
+   * Matches the names of tags known to have preformatted content. The capture
+   * group is reused when matching the closing tag.
+   *
+   * NOTE: this pattern reuses a capture group, and could break if combined with
+   * other expressions using capture groups.
+   */
+  /<(pre|style|script)/,
+  /**
+   * Matches attributes.
+   */
+  patternSegments.htmlOpeningTagEnd,
+  /**
+   * Allow zero or more of any character (including line breaks) between the
+   * tags. Match lazily in case of subsequent blocks.
+   */
+  /(.|[\n\r])*?/,
+  /**
+   * Match closing tag via first capture group.
+   */
+  /<\/\1>/]
+};
+
+/**
+ * Escape patterns
+ *
+ * Each escape pattern matches a markdown entity and captures up to two
+ * groups. These patterns must use one of the following formulas:
+ *
+ * - Single capture group followed by match content - /(...).../
+ *   The captured characters should be escaped and the remaining match should
+ *   remain unchanged.
+ *
+ * - Two capture groups surrounding matched content - /(...)...(...)/
+ *   The captured characters in both groups should be escaped and the matched
+ *   characters in between should remain unchanged.
+ */
+const escapePatterns = [
+/**
+ * Emphasis/Bold - Asterisk
+ *
+ * Match strings surrounded by one or more asterisks on both sides.
+ */
+/(\*+)[^*]*(\1)/g,
+/**
+ * Emphasis - Underscore
+ *
+ * Match strings surrounded by a single underscore on both sides followed by
+ * a word boundary. Remark disregards whether a word boundary exists at the
+ * beginning of an emphasis node.
+ */
+/(_)[^_]+(_)\b/g,
+/**
+ * Bold - Underscore
+ *
+ * Match strings surrounded by multiple underscores on both sides. Remark
+ * disregards the absence of word boundaries on either side of a bold node.
+ */
+/(_{2,})[^_]*(\1)/g,
+/**
+ * Strikethrough
+ *
+ * Match strings surrounded by multiple tildes on both sides.
+ */
+/(~+)[^~]*(\1)/g,
+/**
+ * Inline Code
+ *
+ * Match strings surrounded by backticks.
+ */
+/(`+)[^`]*(\1)/g,
+/**
+ * Links and Images
+ *
+ * Match strings surrounded by square brackets, except when the opening
+ * bracket is followed by a caret. This could be improved to specifically
+ * match only the exact syntax of each covered entity, but doing so through
+ * current approach would incur a considerable performance penalty.
+ */
+/(\[(?!\^)+)[^\]]*]/g];
+
+/**
+ * Generate new non-escape expression. The non-escape expression matches
+ * substrings whose contents should not be processed for escaping.
+ */
+const joinedNonEscapePatterns = (0, _map2.default)(nonEscapePatterns, pattern => {
+  return new RegExp((0, _regexHelper.joinPatternSegments)(pattern));
+});
+const nonEscapePattern = (0, _regexHelper.combinePatterns)(joinedNonEscapePatterns);
+
+/**
+ * Create chain of successive escape functions for various markdown entities.
+ */
+const escapeFunctions = escapePatterns.map(pattern => (0, _partial2.default)(escapeDelimiters, pattern));
+const escapeAll = (0, _flow2.default)(escapeFunctions);
+
+/**
+ * Executes both the `escapeCommonChars` and `escapeLeadingChars` functions.
+ */
+function escapeAllChars(text) {
+  const partiallyEscapedMarkdown = escapeCommonChars(text);
+  return escapeLeadingChars(partiallyEscapedMarkdown);
+}
+
+/**
+ * escapeLeadingChars
+ *
+ * Handles escaping for characters that must be positioned at the beginning of
+ * the string, such as headers and list items.
+ *
+ * Escapes '#', '*', '-', '>', '=', '|', and sequences of 3+ backticks or 4+
+ * spaces when found at the beginning of a string, preceded by zero or more
+ * whitespace characters.
+ */
+function escapeLeadingChars(text) {
+  return text.replace(/^\s*([-#*>=|]| {4,}|`{3,})/, '$`\\$1');
+}
+
+/**
+ * escapeCommonChars
+ *
+ * Escapes active markdown entities. See escape pattern groups for details on
+ * which entities are replaced.
+ */
+function escapeCommonChars(text) {
+  /**
+   * Generate new non-escape expression (must happen at execution time because
+   * we use `RegExp.exec`, which tracks it's own state internally).
+   */
+  const nonEscapeExpression = new RegExp(nonEscapePattern, 'gm');
+
+  /**
+   * Use `replaceWhen` to escape markdown entities only within substrings that
+   * are eligible for escaping.
+   */
+  return (0, _regexHelper.replaceWhen)(nonEscapeExpression, escapeAll, text, true);
+}
+
+/**
+ * escapeDelimiters
+ *
+ * Executes `String.replace` for a given pattern, but only on the first two
+ * capture groups. Specifically intended for escaping opening (and optionally
+ * closing) markdown entities without escaping the content in between.
+ */
+function escapeDelimiters(pattern, text) {
+  return text.replace(pattern, (match, start, end) => {
+    const hasEnd = typeof end === 'string';
+    const matchSliceEnd = hasEnd ? match.length - end.length : match.length;
+    const content = match.slice(start.length, matchSliceEnd);
+    return `${escape(start)}${content}${hasEnd ? escape(end) : ''}`;
+  });
+}
+
+/**
+ * escape
+ *
+ * Simple replacement function for escaping markdown entities. Prepends every
+ * character in the received string with a backslash.
+ */
+function escape(delim) {
+  let result = '';
+  for (const char of delim) {
+    result += `\\${char}`;
+  }
+  return result;
+}
+
+/**
+ * A Remark plugin for escaping markdown entities.
+ *
+ * When markdown entities are entered in raw markdown, they don't appear as
+ * characters in the resulting AST; for example, dashes surrounding a piece of
+ * text cause the text to be inserted in a special node type, but the asterisks
+ * themselves aren't present as text. Therefore, we generally don't expect to
+ * encounter markdown characters in text nodes.
+ *
+ * However, the CMS visual editor does not interpret markdown characters, and
+ * users will expect these characters to be represented literally. In that case,
+ * we need to escape them, otherwise they'll be interpreted during
+ * stringification.
+ */
+function remarkEscapeMarkdownEntities() {
+  function transform(node, index) {
+    /**
+     * Shortcode nodes will intentionally inject markdown entities in text node
+     * children not be escaped.
+     */
+    if ((0, _has2.default)(node.data, 'shortcode')) return node;
+    const children = node.children ? {
+      children: node.children.map(transform)
+    } : {};
+
+    /**
+     * Escape characters in text and html nodes only. We store a lot of normal
+     * text in html nodes to keep Remark from escaping html entities.
+     */
+    if (['text', 'html'].includes(node.type) && node.value) {
+      /**
+       * Escape all characters if this is the first child node, otherwise only
+       * common characters.
+       */
+      const value = index === 0 ? escapeAllChars(node.value) : escapeCommonChars(node.value);
+      return _objectSpread(_objectSpread({}, node), {}, {
+        value
+      }, children);
+    }
+
+    /**
+     * Always return nodes with recursively mapped children.
+     */
+    return _objectSpread(_objectSpread({}, node), children);
+  }
+  return transform;
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/remarkImagesToText.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remarkImagesToText;
+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); }
+/**
+ * Images must be parsed as shortcodes for asset proxying. This plugin converts
+ * MDAST image nodes back to text to allow shortcode pattern matching. Note that
+ * this transformation only occurs for images that are the sole child of a top
+ * level paragraph - any other image is left alone and treated as an inline
+ * image.
+ */
+function remarkImagesToText() {
+  return transform;
+  function transform(node) {
+    const children = node.children.map(child => {
+      if (child.type === 'paragraph' && child.children.length === 1 && child.children[0].type === 'image') {
+        const {
+          alt,
+          url,
+          title
+        } = child.children[0];
+        const value = `![${alt || ''}](${url || ''}${title ? ` "${title}"` : ''})`;
+        child.children = [{
+          type: 'text',
+          value
+        }];
+      }
+      return child;
+    });
+    return _objectSpread(_objectSpread({}, node), {}, {
+      children
+    });
+  }
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/remarkPaddedLinks.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remarkPaddedLinks;
+var _flatMap2 = _interopRequireDefault(require("lodash/flatMap"));
+var _trimEnd2 = _interopRequireDefault(require("lodash/trimEnd"));
+var _trimStart2 = _interopRequireDefault(require("lodash/trimStart"));
+var _endsWith2 = _interopRequireDefault(require("lodash/endsWith"));
+var _startsWith2 = _interopRequireDefault(require("lodash/startsWith"));
+var _findLast2 = _interopRequireDefault(require("lodash/findLast"));
+var _find2 = _interopRequireDefault(require("lodash/find"));
+var _unistBuilder = _interopRequireDefault(require("unist-builder"));
+var _mdastUtilToString = _interopRequireDefault(require("mdast-util-to-string"));
+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); }
+/**
+ * Convert leading and trailing spaces in a link to single spaces outside of the
+ * link. MDASTs derived from pasted Google Docs HTML require this treatment.
+ *
+ * Note that, because we're potentially replacing characters in a link node's
+ * children with character's in a link node's siblings, we have to operate on a
+ * parent (link) node and its children at once, rather than just processing
+ * children one at a time.
+ */
+function remarkPaddedLinks() {
+  function transform(node) {
+    /**
+     * Because we're operating on link nodes and their children at once, we can
+     * exit if the current node has no children.
+     */
+    if (!node.children) return node;
+
+    /**
+     * Process a node's children if any of them are links. If a node is a link
+     * with leading or trailing spaces, we'll get back an array of nodes instead
+     * of a single node, so we use `flatMap` to keep those nodes as siblings
+     * with the other children.
+     *
+     * If performance improvements are found desirable, we could change this to
+     * only pass in the link nodes instead of the entire array of children, but
+     * this seems unlikely to produce a noticeable perf gain.
+     */
+    const hasLinkChild = node.children.some(child => child.type === 'link');
+    const processedChildren = hasLinkChild ? (0, _flatMap2.default)(node.children, transformChildren) : node.children;
+
+    /**
+     * Run all children through the transform recursively.
+     */
+    const children = processedChildren.map(transform);
+    return _objectSpread(_objectSpread({}, node), {}, {
+      children
+    });
+  }
+  function transformChildren(node) {
+    if (node.type !== 'link') return node;
+
+    /**
+     * Get the node's complete string value, check for leading and trailing
+     * whitespace, and get nodes from each edge where whitespace is found.
+     */
+    const text = (0, _mdastUtilToString.default)(node);
+    const leadingWhitespaceNode = (0, _startsWith2.default)(text, ' ') && getEdgeTextChild(node);
+    const trailingWhitespaceNode = (0, _endsWith2.default)(text, ' ') && getEdgeTextChild(node, true);
+    if (!leadingWhitespaceNode && !trailingWhitespaceNode) return node;
+
+    /**
+     * Trim the edge nodes in place. Unified handles everything in a mutable
+     * fashion, so it's often simpler to do the same when working with Unified
+     * ASTs.
+     */
+    if (leadingWhitespaceNode) {
+      leadingWhitespaceNode.value = (0, _trimStart2.default)(leadingWhitespaceNode.value);
+    }
+    if (trailingWhitespaceNode) {
+      trailingWhitespaceNode.value = (0, _trimEnd2.default)(trailingWhitespaceNode.value);
+    }
+
+    /**
+     * Create an array of nodes. The first and last child will either be `false`
+     * or a text node. We filter out the false values before returning.
+     */
+    const nodes = [leadingWhitespaceNode && (0, _unistBuilder.default)('text', ' '), node, trailingWhitespaceNode && (0, _unistBuilder.default)('text', ' ')];
+    return nodes.filter(val => val);
+  }
+
+  /**
+   * Get the first or last non-blank text child of a node, regardless of
+   * nesting. If `end` is truthy, get the last node, otherwise first.
+   */
+  function getEdgeTextChild(node, end) {
+    /**
+     * This was changed from a ternary to a long form if due to issues with istanbul's instrumentation and babel's code
+     * generation.
+     * TODO: watch https://github.com/istanbuljs/babel-plugin-istanbul/issues/95
+     * when it is resolved then revert to ```const findFn = end ? findLast : find;```
+     */
+    let findFn;
+    if (end) {
+      findFn = _findLast2.default;
+    } else {
+      findFn = _find2.default;
+    }
+    let edgeChildWithValue;
+    setEdgeChildWithValue(node);
+    return edgeChildWithValue;
+
+    /**
+     * searchChildren checks a node and all of it's children deeply to find a
+     * non-blank text value. When the text node is found, we set it in an outside
+     * variable, as it may be deep in the tree and therefore wouldn't be returned
+     * by `find`/`findLast`.
+     */
+    function setEdgeChildWithValue(child) {
+      if (!edgeChildWithValue && child.value) {
+        edgeChildWithValue = child;
+      }
+      findFn(child.children, setEdgeChildWithValue);
+    }
+  }
+  return transform;
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/remarkRehypeShortcodes.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remarkToRehypeShortcodes;
+var _has2 = _interopRequireDefault(require("lodash/has"));
+var _map2 = _interopRequireDefault(require("lodash/map"));
+var _react = _interopRequireDefault(require("react"));
+var _server = require("react-dom/server");
+var _unistBuilder = _interopRequireDefault(require("unist-builder"));
+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); }
+/**
+ * This plugin doesn't actually transform Remark (MDAST) nodes to Rehype
+ * (HAST) nodes, but rather, it prepares an MDAST shortcode node for HAST
+ * conversion by replacing the shortcode text with stringified HTML for
+ * previewing the shortcode output.
+ */
+function remarkToRehypeShortcodes({
+  plugins,
+  getAsset,
+  resolveWidget
+}) {
+  return transform;
+  function transform(root) {
+    const transformedChildren = (0, _map2.default)(root.children, processShortcodes);
+    return _objectSpread(_objectSpread({}, root), {}, {
+      children: transformedChildren
+    });
+  }
+
+  /**
+   * Mapping function to transform nodes that contain shortcodes.
+   */
+  function processShortcodes(node) {
+    /**
+     * If the node doesn't contain shortcode data, return the original node.
+     */
+    if (!(0, _has2.default)(node, ['data', 'shortcode'])) return node;
+
+    /**
+     * Get shortcode data from the node, and retrieve the matching plugin by
+     * key.
+     */
+    const {
+      shortcode,
+      shortcodeData
+    } = node.data;
+    const plugin = plugins.get(shortcode);
+
+    /**
+     * Run the shortcode plugin's `toPreview` method, which will return either
+     * an HTML string or a React component. If a React component is returned,
+     * render it to an HTML string.
+     */
+    const value = getPreview(plugin, shortcodeData);
+    const valueHtml = typeof value === 'string' ? value : (0, _server.renderToString)(value);
+
+    /**
+     * Return a new 'html' type node containing the shortcode preview markup.
+     */
+    const textNode = (0, _unistBuilder.default)('html', valueHtml);
+    const children = [textNode];
+    return _objectSpread(_objectSpread({}, node), {}, {
+      children
+    });
+  }
+
+  /**
+   * Retrieve the shortcode preview component.
+   */
+  function getPreview(plugin, shortcodeData) {
+    const {
+      toPreview,
+      widget,
+      fields
+    } = plugin;
+    if (toPreview) {
+      return toPreview(shortcodeData, getAsset, fields);
+    }
+    const preview = resolveWidget(widget);
+    return /*#__PURE__*/_react.default.createElement(preview.preview, {
+      value: shortcodeData,
+      field: plugin,
+      getAsset
+    });
+  }
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/remarkShortcodes.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRemarkShortcodeStringifier = createRemarkShortcodeStringifier;
+exports.getLinesWithOffsets = getLinesWithOffsets;
+exports.remarkParseShortcodes = remarkParseShortcodes;
+function remarkParseShortcodes({
+  plugins
+}) {
+  const Parser = this.Parser;
+  const tokenizers = Parser.prototype.blockTokenizers;
+  const methods = Parser.prototype.blockMethods;
+  tokenizers.shortcode = createShortcodeTokenizer({
+    plugins
+  });
+  methods.unshift('shortcode');
+}
+function getLinesWithOffsets(value) {
+  const SEPARATOR = '\n\n';
+  const splitted = value.split(SEPARATOR);
+  const trimmedLines = splitted.reduce((acc, line) => {
+    const {
+      start: previousLineStart,
+      originalLength: previousLineOriginalLength
+    } = acc[acc.length - 1];
+    return [...acc, {
+      line: line.trimEnd(),
+      start: previousLineStart + previousLineOriginalLength + SEPARATOR.length,
+      originalLength: line.length
+    }];
+  }, [{
+    start: -SEPARATOR.length,
+    originalLength: 0
+  }]).slice(1).map(({
+    line,
+    start
+  }) => ({
+    line,
+    start
+  }));
+  return trimmedLines;
+}
+function matchFromLines({
+  trimmedLines,
+  plugin
+}) {
+  for (const {
+    line,
+    start
+  } of trimmedLines) {
+    const match = line.match(plugin.pattern);
+    if (match) {
+      match.index += start;
+      return match;
+    }
+  }
+}
+function createShortcodeTokenizer({
+  plugins
+}) {
+  return function tokenizeShortcode(eat, value, silent) {
+    // Plugin patterns may rely on `^` and `$` tokens, even if they don't
+    // use the multiline flag. To support this, we fall back to searching
+    // through each line individually, trimming trailing whitespace and
+    // newlines, if we don't initially match on a pattern. We keep track of
+    // the starting position of each line so that we can sort correctly
+    // across the full multiline matches.
+    const trimmedLines = getLinesWithOffsets(value);
+
+    // Attempt to find a regex match for each plugin's pattern, and then
+    // select the first by its occurrence in `value`. This ensures we won't
+    // skip a plugin that occurs later in the plugin registry, but earlier
+    // in the `value`.
+    const [{
+      plugin,
+      match
+    } = {}] = plugins.toArray().map(plugin => ({
+      match: value.match(plugin.pattern) || matchFromLines({
+        trimmedLines,
+        plugin
+      }),
+      plugin
+    })).filter(({
+      match
+    }) => !!match).sort((a, b) => a.match.index - b.match.index);
+    if (match) {
+      if (silent) {
+        return true;
+      }
+      const shortcodeData = plugin.fromBlock(match);
+      try {
+        return eat(match[0])({
+          type: 'shortcode',
+          data: {
+            shortcode: plugin.id,
+            shortcodeData
+          }
+        });
+      } catch (e) {
+        console.warn(`Sent invalid data to remark. Plugin: ${plugin.id}. Value: ${match[0]}. Data: ${JSON.stringify(shortcodeData)}`);
+        return false;
+      }
+    }
+  };
+}
+function createRemarkShortcodeStringifier({
+  plugins
+}) {
+  return function remarkStringifyShortcodes() {
+    const Compiler = this.Compiler;
+    const visitors = Compiler.prototype.visitors;
+    visitors.shortcode = shortcode;
+    function shortcode(node) {
+      const {
+        data
+      } = node;
+      const plugin = plugins.find(plugin => data.shortcode === plugin.id);
+      return plugin.toBlock(data.shortcodeData);
+    }
+  };
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/remarkSlate.js

@@ -0,0 +1,527 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remarkToSlate;
+exports.mergeAdjacentTexts = mergeAdjacentTexts;
+var _isEqual2 = _interopRequireDefault(require("lodash/isEqual"));
+var _flatten2 = _interopRequireDefault(require("lodash/flatten"));
+var _map2 = _interopRequireDefault(require("lodash/map"));
+var _flatMap2 = _interopRequireDefault(require("lodash/flatMap"));
+var _isArray2 = _interopRequireDefault(require("lodash/isArray"));
+var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));
+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); }
+/**
+ * Map of MDAST node types to Slate node types.
+ */
+const typeMap = {
+  root: 'root',
+  paragraph: 'paragraph',
+  blockquote: 'quote',
+  code: 'code-block',
+  listItem: 'list-item',
+  table: 'table',
+  tableRow: 'table-row',
+  tableCell: 'table-cell',
+  thematicBreak: 'thematic-break',
+  link: 'link',
+  image: 'image',
+  shortcode: 'shortcode'
+};
+
+/**
+ * Map of MDAST node types to Slate mark types.
+ */
+const markMap = {
+  strong: 'bold',
+  emphasis: 'italic',
+  delete: 'delete',
+  inlineCode: 'code'
+};
+function isText(node) {
+  return !!node.text;
+}
+function isMarksEqual(node1, node2) {
+  return (0, _isEqual2.default)(node1.marks, node2.marks);
+}
+function mergeAdjacentTexts(children) {
+  if (children.length <= 0) {
+    return children;
+  }
+  const mergedChildren = [];
+  let isMerging = false;
+  let current;
+  for (let i = 0; i < children.length - 1; i++) {
+    if (!isMerging) {
+      current = children[i];
+    }
+    const next = children[i + 1];
+    if (isText(current) && isText(next) && isMarksEqual(current, next)) {
+      isMerging = true;
+      current = _objectSpread(_objectSpread({}, current), {}, {
+        text: `${current.text}${next.text}`
+      });
+    } else {
+      mergedChildren.push(current);
+      isMerging = false;
+    }
+  }
+  if (isMerging) {
+    mergedChildren.push(current);
+  } else {
+    mergedChildren.push(children[children.length - 1]);
+  }
+  return mergedChildren;
+}
+
+/**
+ * A Remark plugin for converting an MDAST to Slate Raw AST. Remark plugins
+ * return a `transformNode` function that receives the MDAST as it's first argument.
+ */
+function remarkToSlate({
+  voidCodeBlock
+} = {}) {
+  return transformNode;
+  function transformNode(node) {
+    /**
+     * Call `transformNode` recursively on child nodes.
+     *
+     * If a node returns a falsey value, filter it out. Some nodes do not
+     * translate from MDAST to Slate, such as definitions for link/image
+     * references or footnotes.
+     */
+    let children = !['strong', 'emphasis', 'delete'].includes(node.type) && !(0, _isEmpty2.default)(node.children) && (0, _flatMap2.default)(node.children, transformNode).filter(val => val);
+    if (Array.isArray(children)) {
+      // Merge adjacent text nodes with the same marks to conform to slate schema
+      children = mergeAdjacentTexts(children);
+    }
+
+    /**
+     * Run individual nodes through the conversion factory.
+     */
+    const output = convertNode(node, children || undefined);
+    return output;
+  }
+
+  /**
+   * Add nodes to a parent node only if `nodes` is truthy.
+   */
+  function addNodes(parent, nodes) {
+    return nodes ? _objectSpread(_objectSpread({}, parent), {}, {
+      children: nodes
+    }) : parent;
+  }
+
+  /**
+   * Create a Slate Block node.
+   */
+  function createBlock(type, nodes, props = {}) {
+    if (!(0, _isArray2.default)(nodes)) {
+      props = nodes;
+      nodes = undefined;
+    }
+
+    // Ensure block nodes have at least one text child to conform to slate schema
+    const children = (0, _isEmpty2.default)(nodes) ? [createText('')] : nodes;
+    const node = _objectSpread({
+      type
+    }, props);
+    return addNodes(node, children);
+  }
+
+  /**
+   * Create a Slate Inline node.
+   */
+  function createInline(type, props = {}, nodes) {
+    const node = _objectSpread({
+      type
+    }, props);
+
+    // Ensure inline nodes have at least one text child to conform to slate schema
+    const children = (0, _isEmpty2.default)(nodes) ? [createText('')] : nodes;
+    return addNodes(node, children);
+  }
+
+  /**
+   * Create a Slate Raw text node.
+   */
+  function createText(node) {
+    const newNode = {};
+    if (typeof node === 'string') {
+      return _objectSpread(_objectSpread({}, newNode), {}, {
+        text: node
+      });
+    }
+    const {
+      text,
+      marks
+    } = node;
+    return normalizeMarks(_objectSpread(_objectSpread({}, newNode), {}, {
+      text,
+      marks
+    }));
+  }
+  function processMarkChild(childNode, marks) {
+    switch (childNode.type) {
+      /**
+       * If a text node is a direct child of the current node, it should be
+       * set aside as a text, and all marks that have been collected in the
+       * `marks` array should apply to that specific text.
+       */
+      case 'html':
+      case 'text':
+        return _objectSpread(_objectSpread({}, convertNode(childNode)), {}, {
+          marks
+        });
+
+      /**
+       * MDAST inline code nodes don't have children, just a text value, similar
+       * to a text node, so it receives the same treatment as a text node, but we
+       * first add the inline code mark to the marks array.
+       */
+      case 'inlineCode':
+        {
+          return _objectSpread(_objectSpread({}, convertNode(childNode)), {}, {
+            marks: [...marks, {
+              type: 'code'
+            }]
+          });
+        }
+
+      /**
+       * Process nested style nodes. The recursive results should be pushed into
+       * the texts array. This way, every MDAST nested text structure becomes a
+       * flat array of texts that can serve as the value of a single Slate Raw
+       * text node.
+       */
+      case 'strong':
+      case 'emphasis':
+      case 'delete':
+        return processMarkNode(childNode, marks);
+      case 'link':
+        {
+          const nodes = (0, _map2.default)(childNode.children, child => normalizeMarks(processMarkChild(child, marks)));
+          const result = convertNode(childNode, (0, _flatten2.default)(nodes));
+          return result;
+        }
+
+      /**
+       * Remaining nodes simply need mark data added to them, and to then be
+       * added into the cumulative children array.
+       */
+      default:
+        return transformNode(_objectSpread(_objectSpread({}, childNode), {}, {
+          data: _objectSpread(_objectSpread({}, childNode.data), {}, {
+            marks
+          })
+        }));
+    }
+  }
+  function processMarkNode(node, parentMarks = []) {
+    /**
+     * Add the current node's mark type to the marks collected from parent
+     * mark nodes, if any.
+     */
+    const markType = markMap[node.type];
+    const marks = markType ? [...parentMarks.filter(({
+      type
+    }) => type !== markType), {
+      type: markType
+    }] : parentMarks;
+    const children = (0, _flatMap2.default)(node.children, child => normalizeMarks(processMarkChild(child, marks)));
+    return children;
+  }
+  function normalizeMarks(node) {
+    if (node.marks) {
+      node.marks.forEach(mark => {
+        node[mark.type] = true;
+      });
+    }
+    return node;
+  }
+
+  /**
+   * Convert a single MDAST node to a Slate Raw node. Uses local node factories
+   * that mimic the unist-builder function utilized in the slateRemark
+   * transformer.
+   */
+  function convertNode(node, nodes) {
+    switch (node.type) {
+      /**
+       * General
+       *
+       * Convert simple cases that only require a type and children, with no
+       * additional properties.
+       */
+      case 'paragraph':
+      case 'blockquote':
+      case 'tableRow':
+      case 'tableCell':
+        {
+          return createBlock(typeMap[node.type], nodes);
+        }
+
+      /**
+       * Root element
+       * If the root node is empty, we need to add a paragraph node to it.
+       */
+      case 'root':
+        {
+          const children = (0, _isEmpty2.default)(nodes) ? [createBlock('paragraph')] : nodes;
+          return createBlock(typeMap[node.type], children);
+        }
+
+      /**
+       * List Items
+       *
+       * Markdown list items can be empty, but a list item in the Slate schema
+       * should at least have an empty paragraph node.
+       */
+      case 'listItem':
+        {
+          const children = (0, _isEmpty2.default)(nodes) ? [createBlock('paragraph')] : nodes;
+          return createBlock(typeMap[node.type], children);
+        }
+
+      /**
+       * Shortcodes
+       *
+       * Shortcode nodes are represented as "void" blocks in the Slate AST. They
+       * maintain the same data as MDAST shortcode nodes. Slate void blocks must
+       * contain a blank text node.
+       */
+      case 'shortcode':
+        {
+          const nodes = [createText('')];
+          const data = _objectSpread(_objectSpread({}, node.data), {}, {
+            id: node.data.shortcode,
+            shortcodeNew: true
+          });
+          return createBlock(typeMap[node.type], nodes, {
+            data
+          });
+        }
+      case 'text':
+        {
+          const text = node.value;
+          return createText(text);
+        }
+
+      /**
+       * HTML
+       *
+       * HTML nodes contain plain text like text nodes, except they only contain
+       * HTML. Our serialization results in non-HTML being placed in HTML nodes
+       * sometimes to ensure that we're never escaping HTML from the rich text
+       * editor. We do not replace line feeds in HTML because the HTML is raw
+       * in the rich text editor, so the writer knows they're writing HTML, and
+       * should expect soft breaks to be visually absent in the rendered HTML.
+       */
+      case 'html':
+        {
+          return createText(node.value);
+        }
+
+      /**
+       * Inline Code
+       *
+       * Inline code nodes from an MDAST are represented in our Slate schema as
+       * text nodes with a "code" mark. We manually create the text containing
+       * the inline code value and a "code" mark, and place it in an array for use
+       * as a Slate text node's children array.
+       */
+      case 'inlineCode':
+        {
+          return createText({
+            text: node.value,
+            code: true,
+            marks: [{
+              type: 'code'
+            }]
+          });
+        }
+
+      /**
+       * Marks
+       *
+       * Marks are typically decorative sub-types that apply to text nodes. In an
+       * MDAST, marks are nodes that can contain other nodes. This nested
+       * hierarchy has to be flattened and split into distinct text nodes with
+       * their own set of marks.
+       */
+      case 'strong':
+      case 'emphasis':
+      case 'delete':
+        {
+          return processMarkNode(node);
+        }
+
+      /**
+       * Headings
+       *
+       * MDAST headings use a single type with a separate "depth" property to
+       * indicate the heading level, while the Slate schema uses a separate node
+       * type for each heading level. Here we get the proper Slate node name based
+       * on the MDAST node depth.
+       */
+      case 'heading':
+        {
+          const depthMap = {
+            1: 'one',
+            2: 'two',
+            3: 'three',
+            4: 'four',
+            5: 'five',
+            6: 'six'
+          };
+          const slateType = `heading-${depthMap[node.depth]}`;
+          return createBlock(slateType, nodes);
+        }
+
+      /**
+       * Code Blocks
+       *
+       * MDAST code blocks are a distinct node type with a simple text value. We
+       * convert that value into a nested child text node for Slate. If a void
+       * node is required due to a custom code block handler, the value is
+       * stored in the "code" data property instead. We also carry over the "lang"
+       * data property if it's defined.
+       */
+      case 'code':
+        {
+          const data = _objectSpread(_objectSpread({
+            lang: node.lang
+          }, voidCodeBlock ? {
+            code: node.value
+          } : {}), {}, {
+            shortcode: 'code-block',
+            shortcodeData: {
+              code: node.value,
+              lang: node.lang
+            }
+          });
+          const text = createText(voidCodeBlock ? '' : node.value);
+          const nodes = [text];
+          const block = createBlock('shortcode', nodes, {
+            data
+          });
+          return block;
+        }
+
+      /**
+       * Lists
+       *
+       * MDAST has a single list type and an "ordered" property. We derive that
+       * information into the Slate schema's distinct list node types. We also
+       * include the "start" property, which indicates the number an ordered list
+       * starts at, if defined.
+       */
+      case 'list':
+        {
+          const slateType = node.ordered ? 'numbered-list' : 'bulleted-list';
+          const data = {
+            start: node.start
+          };
+          return createBlock(slateType, nodes, {
+            data
+          });
+        }
+
+      /**
+       * Breaks
+       *
+       * MDAST soft break nodes represent a trailing double space or trailing
+       * slash from a Markdown document. In Slate, these are simply transformed to
+       * line breaks within a text node.
+       */
+      case 'break':
+        {
+          const {
+            data
+          } = node;
+          return createInline('break', {
+            data
+          });
+        }
+
+      /**
+       * Thematic Breaks
+       *
+       * Thematic breaks are void nodes in the Slate schema.
+       */
+      case 'thematicBreak':
+        {
+          return createBlock(typeMap[node.type]);
+        }
+
+      /**
+       * Links
+       *
+       * MDAST stores the link attributes directly on the node, while our Slate
+       * schema references them in the data object.
+       */
+      case 'link':
+        {
+          const {
+            title,
+            url,
+            data
+          } = node;
+          const newData = _objectSpread(_objectSpread({}, data), {}, {
+            title,
+            url
+          });
+          return createInline(typeMap[node.type], {
+            data: newData
+          }, nodes);
+        }
+
+      /**
+       * Images
+       *
+       * Identical to link nodes except for the lack of child nodes and addition
+       * of alt attribute data MDAST stores the link attributes directly on the
+       * node, while our Slate schema references them in the data object.
+       */
+      case 'image':
+        {
+          const {
+            title,
+            url,
+            alt,
+            data
+          } = node;
+          const newData = _objectSpread(_objectSpread({}, data), {}, {
+            title,
+            alt,
+            url
+          });
+          return createInline(typeMap[node.type], {
+            data: newData
+          });
+        }
+
+      /**
+       * Tables
+       *
+       * Tables are parsed separately because they may include an "align"
+       * property, which should be passed to the Slate node.
+       */
+      case 'table':
+        {
+          const data = {
+            align: node.align
+          };
+          return createBlock(typeMap[node.type], nodes, {
+            data
+          });
+        }
+    }
+  }
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/remarkSquashReferences.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remarkSquashReferences;
+var _flatten2 = _interopRequireDefault(require("lodash/flatten"));
+var _without2 = _interopRequireDefault(require("lodash/without"));
+var _unistBuilder = _interopRequireDefault(require("unist-builder"));
+var _mdastUtilDefinitions = _interopRequireDefault(require("mdast-util-definitions"));
+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); }
+/**
+ * Raw markdown may contain image references or link references. Because there
+ * is no way to maintain these references within the Slate AST, we convert image
+ * and link references to standard images and links by putting their url's
+ * inline. The definitions are then removed from the document.
+ *
+ * For example, the following markdown:
+ *
+ * ```
+ * ![alpha][bravo]
+ *
+ * [bravo]: http://example.com/example.jpg
+ * ```
+ *
+ * Yields:
+ *
+ * ```
+ * ![alpha](http://example.com/example.jpg)
+ * ```
+ *
+ */
+function remarkSquashReferences() {
+  return getTransform;
+  function getTransform(node) {
+    const getDefinition = (0, _mdastUtilDefinitions.default)(node);
+    return transform.call(null, getDefinition, node);
+  }
+  function transform(getDefinition, node) {
+    /**
+     * Bind the `getDefinition` function to `transform` and recursively map all
+     * nodes.
+     */
+    const boundTransform = transform.bind(null, getDefinition);
+    const children = node.children ? node.children.map(boundTransform) : node.children;
+
+    /**
+     * Combine reference and definition nodes into standard image and link
+     * nodes.
+     */
+    if (['imageReference', 'linkReference'].includes(node.type)) {
+      const type = node.type === 'imageReference' ? 'image' : 'link';
+      const definition = getDefinition(node.identifier);
+      if (definition) {
+        const {
+          title,
+          url
+        } = definition;
+        return (0, _unistBuilder.default)(type, {
+          title,
+          url,
+          alt: node.alt
+        }, children);
+      }
+      const pre = (0, _unistBuilder.default)('text', node.type === 'imageReference' ? '![' : '[');
+      const post = (0, _unistBuilder.default)('text', ']');
+      const nodes = children || [(0, _unistBuilder.default)('text', node.alt)];
+      return [pre, ...nodes, post];
+    }
+
+    /**
+     * Remove definition nodes and filter the resulting null values from the
+     * filtered children array.
+     */
+    if (node.type === 'definition') {
+      return null;
+    }
+    const filteredChildren = (0, _without2.default)(children, null);
+    return _objectSpread(_objectSpread({}, node), {}, {
+      children: (0, _flatten2.default)(filteredChildren)
+    });
+  }
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/remarkStripTrailingBreaks.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remarkStripTrailingBreaks;
+var _mdastUtilToString = _interopRequireDefault(require("mdast-util-to-string"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Removes break nodes that are at the end of a block.
+ *
+ * When a trailing double space or backslash is encountered at the end of a
+ * markdown block, Remark will interpret the character(s) literally, as only
+ * break entities followed by text qualify as breaks. A manually created MDAST,
+ * however, may have such entities, and users of visual editors shouldn't see
+ * these artifacts in resulting markdown.
+ */
+function remarkStripTrailingBreaks() {
+  function transform(node) {
+    if (node.children) {
+      node.children = node.children.map((child, idx, children) => {
+        /**
+         * Only touch break nodes. Convert all subsequent nodes to their text
+         * value and exclude the break node if no non-whitespace characters
+         * are found.
+         */
+        if (child.type === 'break') {
+          const subsequentNodes = children.slice(idx + 1);
+
+          /**
+           * Create a small MDAST so that mdastToString can process all
+           * siblings as children of one node rather than making multiple
+           * calls.
+           */
+          const fragment = {
+            type: 'root',
+            children: subsequentNodes
+          };
+          const subsequentText = (0, _mdastUtilToString.default)(fragment);
+          return subsequentText.trim() ? child : null;
+        }
+
+        /**
+         * Always return the child if not a break.
+         */
+        return child;
+      })
+
+      /**
+       * Because some break nodes may be excluded, we filter out the resulting
+       * null values.
+       */.filter(child => child)
+
+      /**
+       * Recurse through the MDAST by transforming each individual child node.
+       */.map(transform);
+    }
+    return node;
+  }
+  return transform;
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/remarkWrapHtml.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remarkWrapHtml;
+var _unistBuilder = _interopRequireDefault(require("unist-builder"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Ensure that top level 'html' type nodes are wrapped in paragraphs. Html nodes
+ * are used for text nodes that we don't want Remark or Rehype to parse.
+ */
+function remarkWrapHtml() {
+  function transform(tree) {
+    tree.children = tree.children.map(node => {
+      if (node.type === 'html') {
+        return (0, _unistBuilder.default)('paragraph', [node]);
+      }
+      return node;
+    });
+    return tree;
+  }
+  return transform;
+}

node_modules/decap-cms-widget-markdown/dist/esm/serializers/slateRemark.js

@@ -0,0 +1,512 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = slateToRemark;
+var _omit2 = _interopRequireDefault(require("lodash/omit"));
+var _intersection2 = _interopRequireDefault(require("lodash/intersection"));
+var _map2 = _interopRequireDefault(require("lodash/map"));
+var _last2 = _interopRequireDefault(require("lodash/last"));
+var _without2 = _interopRequireDefault(require("lodash/without"));
+var _get4 = _interopRequireDefault(require("lodash/get"));
+var _unistBuilder = _interopRequireDefault(require("unist-builder"));
+var _mdastUtilToString = _interopRequireDefault(require("mdast-util-to-string"));
+const _excluded = ["lang", "code"],
+  _excluded2 = ["url", "title", "alt"];
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+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); }
+/**
+ * Map of Slate node types to MDAST/Remark node types.
+ */
+const typeMap = {
+  root: 'root',
+  paragraph: 'paragraph',
+  'heading-one': 'heading',
+  'heading-two': 'heading',
+  'heading-three': 'heading',
+  'heading-four': 'heading',
+  'heading-five': 'heading',
+  'heading-six': 'heading',
+  quote: 'blockquote',
+  'code-block': 'code',
+  'numbered-list': 'list',
+  'bulleted-list': 'list',
+  'list-item': 'listItem',
+  table: 'table',
+  'table-row': 'tableRow',
+  'table-cell': 'tableCell',
+  break: 'break',
+  'thematic-break': 'thematicBreak',
+  link: 'link',
+  image: 'image',
+  shortcode: 'shortcode'
+};
+
+/**
+ * Map of Slate mark types to MDAST/Remark node types.
+ */
+const markMap = {
+  bold: 'strong',
+  italic: 'emphasis',
+  delete: 'delete',
+  code: 'inlineCode'
+};
+const blockTypes = ['paragraph', 'quote', 'heading-one', 'heading-two', 'heading-three', 'heading-four', 'heading-five', 'heading-six', 'bulleted-list', 'numbered-list', 'list-item', 'shortcode', 'table', 'table-row', 'table-cell'];
+const inlineTypes = ['link', 'image', 'break'];
+const leadingWhitespaceExp = /^\s+\S/;
+const trailingWhitespaceExp = /(?!\S)\s+$/;
+function slateToRemark(value, {
+  voidCodeBlock
+}) {
+  /**
+   * The Slate Raw AST generally won't have a top level type, so we set it to
+   * "root" for clarity.
+   */
+  const root = {
+    type: 'root',
+    children: value
+  };
+  return transform(root);
+
+  /**
+   * The transform function mimics the approach of a Remark plugin for
+   * conformity with the other serialization functions. This function converts
+   * Slate nodes to MDAST nodes, and recursively calls itself to process child
+   * nodes to arbitrary depth.
+   */
+  function transform(node) {
+    /**
+     * Combine adjacent text and inline nodes before processing so they can
+     * share marks.
+     */
+    const hasBlockChildren = node.children && node.children[0] && blockTypes.includes(node.children[0].type);
+    const children = hasBlockChildren ? node.children.map(transform).filter(v => v) : convertInlineAndTextChildren(node.children);
+    const output = convertBlockNode(node, children);
+    //console.log(JSON.stringify(output, null, 2));
+    return output;
+  }
+  function removeMarkFromNodes(nodes, markType) {
+    return nodes.map(node => {
+      const newNode = _objectSpread({}, node);
+      switch (node.type) {
+        case 'link':
+          {
+            const updatedNodes = removeMarkFromNodes(node.children, markType);
+            return _objectSpread(_objectSpread({}, node), {}, {
+              children: updatedNodes
+            });
+          }
+        case 'image':
+        case 'break':
+          {
+            const data = (0, _omit2.default)(node.data, 'marks');
+            return _objectSpread(_objectSpread({}, node), {}, {
+              data
+            });
+          }
+        default:
+          delete newNode[markType];
+          newNode.marks = newNode.marks ? newNode.marks.filter(({
+            type
+          }) => type !== markType) : [];
+          if (newNode.marks.length === 0) {
+            delete newNode.marks;
+          }
+          return newNode;
+      }
+    });
+  }
+  function getNodeMarks(node) {
+    switch (node.type) {
+      case 'link':
+        {
+          // Code marks can't always be condensed together. If all text in a link
+          // is wrapped in a mark, this function returns that mark and the node
+          // ends up nested inside of that mark. Code marks sometimes can't do
+          // that, like when they wrap all of the text content of a link. Here we
+          // remove code marks before processing so that they stay put.
+          const nodesWithoutCode = node.children.map(n => {
+            const newNode = _objectSpread({}, n);
+            newNode.marks = n.marks ? n.marks.filter(({
+              type
+            }) => type !== 'code') : n.marks, delete newNode.code;
+            return newNode;
+          });
+          const childMarks = (0, _map2.default)(nodesWithoutCode, getNodeMarks);
+          return (0, _intersection2.default)(...childMarks);
+        }
+      case 'break':
+      case 'image':
+        return (0, _map2.default)((0, _get4.default)(node, ['data', 'marks']), mark => mark.type);
+      default:
+        return getNodeMarkArray(node);
+    }
+  }
+  function getNodeMarkArray(node) {
+    return Object.keys(markMap).filter(mark => !!node[mark]);
+  }
+  function getSharedMarks(marks, node) {
+    const nodeMarks = getNodeMarks(node);
+    const sharedMarks = (0, _intersection2.default)(marks, nodeMarks);
+    if (sharedMarks[0] === 'code') {
+      return nodeMarks.length === 1 ? marks : [];
+    }
+    return sharedMarks;
+  }
+  function extractFirstMark(nodes) {
+    let firstGroupMarks = getNodeMarks(nodes[0]) || [];
+
+    // If code mark is present, but there are other marks, process others first.
+    // If only the code mark is present, don't allow it to be shared with other
+    // nodes.
+    if (firstGroupMarks[0] === 'code' && firstGroupMarks.length > 1) {
+      firstGroupMarks = [...(0, _without2.default)('firstGroupMarks', 'code'), 'code'];
+    }
+    let splitIndex = 1;
+    if (firstGroupMarks.length > 0) {
+      while (splitIndex < nodes.length) {
+        if (nodes[splitIndex]) {
+          const sharedMarks = getSharedMarks(firstGroupMarks, nodes[splitIndex]);
+          if (sharedMarks.length > 0) {
+            firstGroupMarks = sharedMarks;
+          } else {
+            break;
+          }
+        }
+        splitIndex += 1;
+      }
+    }
+    const markType = firstGroupMarks[0];
+    const childNodes = nodes.slice(0, splitIndex);
+    const updatedChildNodes = markType ? removeMarkFromNodes(childNodes, markType) : childNodes;
+    const remainingNodes = nodes.slice(splitIndex);
+    return [markType, updatedChildNodes, remainingNodes];
+  }
+
+  /**
+   * Converts the strings returned from `splitToNamedParts` to Slate nodes.
+   */
+  function splitWhitespace(node, {
+    trailing
+  } = {}) {
+    if (!node.text) {
+      return {
+        trimmedNode: node
+      };
+    }
+    const exp = trailing ? trailingWhitespaceExp : leadingWhitespaceExp;
+    const index = node.text.search(exp);
+    if (index > -1) {
+      const substringIndex = trailing ? index : index + 1;
+      const firstSplit = node.text.slice(0, substringIndex);
+      const secondSplit = node.text.slice(substringIndex);
+      const whitespace = trailing ? secondSplit : firstSplit;
+      const text = trailing ? firstSplit : secondSplit;
+      return {
+        whitespace,
+        trimmedNode: _objectSpread(_objectSpread({}, node), {}, {
+          text
+        })
+      };
+    }
+    return {
+      trimmedNode: node
+    };
+  }
+  function collectCenterNodes(nodes, leadingNode, trailingNode) {
+    switch (nodes.length) {
+      case 0:
+        return [];
+      case 1:
+        return [trailingNode];
+      case 2:
+        return [leadingNode, trailingNode];
+      default:
+        return [leadingNode, ...nodes.slice(1, -1), trailingNode];
+    }
+  }
+  function normalizeFlankingWhitespace(nodes) {
+    const {
+      whitespace: leadingWhitespace,
+      trimmedNode: leadingNode
+    } = splitWhitespace(nodes[0]);
+    const lastNode = nodes.length > 1 ? (0, _last2.default)(nodes) : leadingNode;
+    const trailingSplitResult = splitWhitespace(lastNode, {
+      trailing: true
+    });
+    const {
+      whitespace: trailingWhitespace,
+      trimmedNode: trailingNode
+    } = trailingSplitResult;
+    const centerNodes = collectCenterNodes(nodes, leadingNode, trailingNode).filter(val => val);
+    return {
+      leadingWhitespace,
+      centerNodes,
+      trailingWhitespace
+    };
+  }
+  function createText(text) {
+    return text && (0, _unistBuilder.default)('html', text);
+  }
+  function isNodeInline(node) {
+    return inlineTypes.includes(node.type);
+  }
+  function convertInlineAndTextChildren(nodes = []) {
+    const convertedNodes = [];
+    let remainingNodes = [...nodes];
+    while (remainingNodes.length > 0) {
+      const nextNode = remainingNodes[0];
+      if (isNodeInline(nextNode) || getNodeMarkArray(nextNode).length > 0) {
+        const [markType, markNodes, remainder] = extractFirstMark(remainingNodes);
+        /**
+         * A node with a code mark will be a text node, and will not be adjacent
+         * to a sibling code node as the Slate schema requires them to be
+         * merged. Markdown also requires at least a space between inline code
+         * nodes.
+         */
+        if (markType === 'code') {
+          const node = markNodes[0];
+          convertedNodes.push((0, _unistBuilder.default)(markMap[markType], node.data, node.text));
+        } else if (!markType && markNodes.length === 1 && isNodeInline(nextNode)) {
+          const node = markNodes[0];
+          convertedNodes.push(convertInlineNode(node, convertInlineAndTextChildren(node.children)));
+        } else {
+          const {
+            leadingWhitespace,
+            trailingWhitespace,
+            centerNodes
+          } = normalizeFlankingWhitespace(markNodes);
+          const children = convertInlineAndTextChildren(centerNodes);
+          const markNode = (0, _unistBuilder.default)(markMap[markType], children);
+
+          // Filter out empty marks, otherwise their output literally by
+          // remark-stringify, eg. an empty bold node becomes "****"
+          if ((0, _mdastUtilToString.default)(markNode) === '') {
+            remainingNodes = remainder;
+            continue;
+          }
+          const normalizedNodes = [createText(leadingWhitespace), markNode, createText(trailingWhitespace)].filter(val => val);
+          convertedNodes.push(...normalizedNodes);
+        }
+        remainingNodes = remainder;
+      } else if (nextNode.type === 'break') {
+        remainingNodes = remainingNodes.slice(1);
+        convertedNodes.push(convertInlineNode(nextNode));
+      } else {
+        remainingNodes.shift();
+        convertedNodes.push((0, _unistBuilder.default)('html', nextNode.text));
+      }
+    }
+    return convertedNodes;
+  }
+  function convertCodeBlock(node) {
+    return _objectSpread(_objectSpread({}, node), {}, {
+      type: 'code-block',
+      data: _objectSpread(_objectSpread({}, node.data), node.data.shortcodeData)
+    });
+  }
+  function convertBlockNode(node, children) {
+    if (node.type == 'shortcode' && node.data.shortcode == 'code-block') {
+      node = convertCodeBlock(node);
+    }
+    switch (node.type) {
+      /**
+       * General
+       *
+       * Convert simple cases that only require a type and children, with no
+       * additional properties.
+       */
+      case 'root':
+      case 'paragraph':
+      case 'quote':
+      case 'list-item':
+      case 'table':
+      case 'table-row':
+      case 'table-cell':
+        {
+          return (0, _unistBuilder.default)(typeMap[node.type], children);
+        }
+
+      /**
+       * Lists
+       *
+       * Enclose list items in paragraphs
+       */
+      // case 'list-item':
+      //   return u(typeMap[node.type], [{ type: 'paragraph', children }]);
+
+      /**
+       * Shortcodes
+       *
+       * Shortcode nodes only exist in Slate's Raw AST if they were inserted
+       * via the plugin toolbar in memory, so they should always have
+       * shortcode data attached. The "shortcode" data property contains the
+       * name of the registered shortcode plugin, and the "shortcodeData" data
+       * property contains the data received from the shortcode plugin's
+       * `fromBlock` method when the shortcode node was created.
+       *
+       * Here we create a `shortcode` MDAST node that contains only the shortcode
+       * data.
+       */
+      case 'shortcode':
+        {
+          const {
+            data
+          } = node;
+          return (0, _unistBuilder.default)(typeMap[node.type], {
+            data
+          });
+        }
+
+      /**
+       * Headings
+       *
+       * Slate schemas don't usually infer basic type info from data, so each
+       * level of heading is a separately named type. The MDAST schema just
+       * has a single "heading" type with the depth stored in a "depth"
+       * property on the node. Here we derive the depth from the Slate node
+       * type - e.g., for "heading-two", we need a depth value of "2".
+       */
+      case 'heading-one':
+      case 'heading-two':
+      case 'heading-three':
+      case 'heading-four':
+      case 'heading-five':
+      case 'heading-six':
+        {
+          const depthMap = {
+            one: 1,
+            two: 2,
+            three: 3,
+            four: 4,
+            five: 5,
+            six: 6
+          };
+          const depthText = node.type.split('-')[1];
+          const depth = depthMap[depthText];
+          const mdastNode = (0, _unistBuilder.default)(typeMap[node.type], {
+            depth
+          }, children);
+          if ((0, _mdastUtilToString.default)(mdastNode)) {
+            return mdastNode;
+          }
+          return;
+        }
+
+      /**
+       * Code Blocks
+       *
+       * Code block nodes may have a single text child, or instead be void and
+       * store their value in `data.code`. They also may have a code language
+       * stored in the "lang" data property. Here we transfer both the node value
+       * and the "lang" data property to the new MDAST node, and spread any
+       * remaining data as `data`.
+       */
+      case 'code-block':
+        {
+          var _children$;
+          const _get2 = (0, _get4.default)(node, 'data', {}),
+            {
+              lang,
+              code
+            } = _get2,
+            data = _objectWithoutProperties(_get2, _excluded);
+          const value = voidCodeBlock ? code : (_children$ = children[0]) === null || _children$ === void 0 ? void 0 : _children$.value;
+          return (0, _unistBuilder.default)(typeMap[node.type], {
+            lang,
+            data
+          }, value || '');
+        }
+
+      /**
+       * Lists
+       *
+       * Our Slate schema has separate node types for ordered and unordered
+       * lists, but the MDAST spec uses a single type with a boolean "ordered"
+       * property to indicate whether the list is numbered. The MDAST spec also
+       * allows for a "start" property to indicate the first number used for an
+       * ordered list. Here we translate both values to our Slate schema.
+       */
+      case 'numbered-list':
+      case 'bulleted-list':
+        {
+          const ordered = node.type === 'numbered-list';
+          const props = {
+            ordered,
+            start: (0, _get4.default)(node.data, 'start') || 1
+          };
+          return (0, _unistBuilder.default)(typeMap[node.type], props, children);
+        }
+
+      /**
+       * Thematic Break
+       *
+       * Thematic break is a block level break. They cannot have children.
+       */
+      case 'thematic-break':
+        {
+          return (0, _unistBuilder.default)(typeMap[node.type]);
+        }
+    }
+  }
+  function convertInlineNode(node, children) {
+    switch (node.type) {
+      /**
+       * Break
+       *
+       * Breaks are phrasing level breaks. They cannot have children.
+       */
+      case 'break':
+        {
+          return (0, _unistBuilder.default)(typeMap[node.type]);
+        }
+
+      /**
+       * Links
+       *
+       * Url is now stored in data for slate, so we need to pull it out.
+       */
+      case 'link':
+        {
+          const {
+            title,
+            data
+          } = node;
+          return (0, _unistBuilder.default)(typeMap[node.type], _objectSpread({
+            url: data === null || data === void 0 ? void 0 : data.url,
+            title
+          }, data), children);
+        }
+
+      /**
+       * Images
+       *
+       * This transformation is almost identical to that of links, except for the
+       * lack of child nodes and addition of `alt` attribute data.
+       */
+      case 'image':
+        {
+          const _get3 = (0, _get4.default)(node, 'data', {}),
+            {
+              url,
+              title,
+              alt
+            } = _get3,
+            data = _objectWithoutProperties(_get3, _excluded2);
+          return (0, _unistBuilder.default)(typeMap[node.type], {
+            url,
+            title,
+            alt,
+            data
+          });
+        }
+    }
+  }
+}

node_modules/decap-cms-widget-markdown/dist/esm/styles.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.editorStyleVars = exports.EditorControlBar = void 0;
+var _base = _interopRequireDefault(require("@emotion/styled/base"));
+var _decapCmsUiDefault = require("decap-cms-ui-default");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const editorStyleVars = exports.editorStyleVars = {
+  stickyDistanceBottom: '100px'
+};
+const EditorControlBar = exports.EditorControlBar = /*#__PURE__*/(0, _base.default)("div", {
+  target: "ehaqqzm0",
+  label: "EditorControlBar"
+})("z-index:", _decapCmsUiDefault.zIndex.zIndex200, ";position:sticky;top:0;margin-bottom:", editorStyleVars.stickyDistanceBottom, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdHlsZXMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBTzBDIiwiZmlsZSI6Ii4uLy4uL3NyYy9zdHlsZXMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5pbXBvcnQgeyB6SW5kZXggfSBmcm9tICdkZWNhcC1jbXMtdWktZGVmYXVsdCc7XG5cbmV4cG9ydCBjb25zdCBlZGl0b3JTdHlsZVZhcnMgPSB7XG4gIHN0aWNreURpc3RhbmNlQm90dG9tOiAnMTAwcHgnLFxufTtcblxuZXhwb3J0IGNvbnN0IEVkaXRvckNvbnRyb2xCYXIgPSBzdHlsZWQuZGl2YFxuICB6LWluZGV4OiAke3pJbmRleC56SW5kZXgyMDB9O1xuICBwb3NpdGlvbjogc3RpY2t5O1xuICB0b3A6IDA7XG4gIG1hcmdpbi1ib3R0b206ICR7ZWRpdG9yU3R5bGVWYXJzLnN0aWNreURpc3RhbmNlQm90dG9tfTtcbmA7XG4iXX0= */"));

node_modules/decap-cms-widget-markdown/dist/esm/types.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SLATE_DEFAULT_BLOCK_TYPE = exports.SLATE_BLOCK_PARENT_TYPES = void 0;
+const SLATE_DEFAULT_BLOCK_TYPE = exports.SLATE_DEFAULT_BLOCK_TYPE = 'paragraph';
+const SLATE_BLOCK_PARENT_TYPES = exports.SLATE_BLOCK_PARENT_TYPES = ['list-item', 'quote'];