@seafile/comment-editor 0.0.1-alpha.0

package/dist/basic-sdk/extension/plugins/check-list/helpers.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setCheckListItemType = exports.isMenuDisabled = exports.getCheckListItemType = exports.convertToCheck = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../constants");
+var _core = require("../../core");
+const isMenuDisabled = (editor, readonly) => {
+  if (readonly) return true;
+  if (editor.selection == null) return true;
+  let selectedElements = [];
+  const nodeEntries = _slate.Editor.nodes(editor, {
+    universal: true
+  });
+  for (let nodeEntry of nodeEntries) {
+    const [node] = nodeEntry;
+    if (_slate.Element.isElement(node)) selectedElements.push(node);
+  }
+  const notMatch = selectedElements.some(element => {
+    if (_slate.Editor.isVoid(editor, element) && _slate.Editor.isBlock(editor, element)) return true;
+    const {
+      type
+    } = element;
+    if (type === _constants.ELEMENT_TYPE.CODE_LINE) return true;
+    if (type === _constants.ELEMENT_TYPE.CODE_BLOCK) return true;
+    if ([_constants.ORDERED_LIST, _constants.UNORDERED_LIST].includes(type) && (0, _core.isMultiLevelList)(element)) return true;
+    if (type === _constants.ELEMENT_TYPE.TABLE) return true;
+    if (type === _constants.ELEMENT_TYPE.TABLE_ROW) return true;
+    if (type === _constants.ELEMENT_TYPE.TABLE_CELL) return true;
+    return false;
+  });
+  if (notMatch) return true;
+  return false;
+};
+exports.isMenuDisabled = isMenuDisabled;
+const getCheckListItemType = editor => {
+  const node = (0, _core.getSelectedNodeByType)(editor, _constants.CHECK_LIST_ITEM);
+  if (!node) return _constants.PARAGRAPH;
+  return node.type;
+};
+exports.getCheckListItemType = getCheckListItemType;
+const convertToCheck = (editor, listNode, listPath) => {
+  const checkList = [];
+  const {
+    children
+  } = listNode || {};
+  children.forEach(item => {
+    const text = _slate.Node.string(item);
+    const checkNode = (0, _core.generateEmptyElement)(_constants.CHECK_LIST_ITEM, {}, text);
+    checkList.push(checkNode);
+  });
+  _slate.Transforms.removeNodes(editor, {
+    at: [listPath[0]]
+  });
+  _slate.Transforms.insertNodes(editor, checkList, {
+    at: [listPath[0]]
+  });
+  _slate.Transforms.select(editor, {
+    path: [listPath[0], 0],
+    offset: 0
+  });
+};
+exports.convertToCheck = convertToCheck;
+const setCheckListItemType = (editor, newType, insertPosition) => {
+  if (insertPosition === _constants.INSERT_POSITION.AFTER) {
+    const p = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+    const path = _slate.Editor.path(editor, editor.selection);
+    _slate.Transforms.insertNodes(editor, p, {
+      at: [path[0] + 1]
+    });
+    _slate.Transforms.select(editor, [path[0] + 1]);
+  }
+  if (!(0, _core.isRangeAcrossBlocks)(editor)) {
+    const path = _slate.Editor.path(editor, editor.selection);
+    const [currentNode] = (0, _core.getCurrentNode)(editor);
+    if (path) {
+      const [targetNode, targetPath] = _slate.Editor.node(editor, [path[0]]);
+      if (targetNode && [_constants.ORDERED_LIST, _constants.UNORDERED_LIST].includes(targetNode === null || targetNode === void 0 ? void 0 : targetNode.type)) {
+        convertToCheck(editor, targetNode, targetPath);
+        if (newType === _constants.CHECK_LIST_ITEM && !_slate.Node.string(currentNode)) {
+          (0, _core.focusEditor)(editor);
+        }
+        return;
+      }
+    }
+    _slate.Transforms.setNodes(editor, {
+      type: newType
+    });
+    // When currentNode is empty
+    if (newType === _constants.CHECK_LIST_ITEM && !_slate.Node.string(currentNode)) {
+      (0, _core.focusEditor)(editor, path);
+    }
+  } else {
+    const nodes = _slate.Editor.nodes(editor, {
+      match: n => {
+        const type = (0, _core.getNodeType)(n);
+        if (!type) return;
+        if (type === _constants.PARAGRAPH) return true;
+        if (type === _constants.CHECK_LIST_ITEM) return true;
+        if (type.startsWith(_constants.HEADER)) return true;
+        if (type === _constants.TITLE) return true;
+        if (type === _constants.SUBTITLE) return true;
+        return false;
+      },
+      universal: false,
+      mode: 'highest' // Match top level
+    });
+    const nodesEntry = Array.from(nodes);
+    if (nodesEntry.length === 0) return;
+    nodesEntry.forEach(nodeEntry => {
+      _slate.Transforms.setNodes(editor, {
+        type: newType
+      }, {
+        at: nodeEntry[1]
+      });
+    });
+  }
+};
+exports.setCheckListItemType = setCheckListItemType;

package/dist/basic-sdk/extension/plugins/check-list/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _constants = require("../../constants");
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = require("./render-elem");
+const CheckListPlugin = {
+  type: _constants.CHECK_LIST_ITEM,
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.renderCheckListItem]
+};
+var _default = exports.default = CheckListPlugin;

package/dist/basic-sdk/extension/plugins/check-list/menu/index.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _commons = require("../../../commons");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _helpers = require("../helpers");
+class CheckListMenu extends _react.default.Component {
+  constructor() {
+    super(...arguments);
+    (0, _defineProperty2.default)(this, "isActive", () => {
+      const {
+        editor
+      } = this.props;
+      return (0, _helpers.getCheckListItemType)(editor) === _constants.CHECK_LIST_ITEM;
+    });
+    (0, _defineProperty2.default)(this, "isDisabled", () => {
+      const {
+        editor,
+        readonly
+      } = this.props;
+      return (0, _helpers.isMenuDisabled)(editor, readonly);
+    });
+    (0, _defineProperty2.default)(this, "onMouseDown", () => {
+      const {
+        editor
+      } = this.props;
+      const active = this.isActive(editor);
+      const newType = active ? _constants.PARAGRAPH : _constants.CHECK_LIST_ITEM;
+      (0, _helpers.setCheckListItemType)(editor, newType);
+      (0, _core.focusEditor)(editor, editor.selection);
+    });
+  }
+  render() {
+    const {
+      isRichEditor,
+      className
+    } = this.props;
+    const menuConfig = _constants.MENUS_CONFIG_MAP[_constants.CHECK_LIST_ITEM];
+    const props = {
+      isRichEditor,
+      className,
+      ariaLabel: 'check list',
+      ...menuConfig,
+      disabled: this.isDisabled(),
+      isActive: this.isActive(),
+      onMouseDown: this.onMouseDown
+    };
+    return /*#__PURE__*/_react.default.createElement(_commons.MenuItem, props);
+  }
+}
+var _default = exports.default = CheckListMenu;

package/dist/basic-sdk/extension/plugins/check-list/model.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _constants = require("../../constants");
+class CheckListItem {
+  constructor(options) {
+    this.type = options.type || _constants.CHECK_LIST_ITEM;
+    this.checked = options.checked || false;
+    this.children = options.children || [{
+      text: ''
+    }];
+  }
+}
+var _default = exports.default = CheckListItem;

package/dist/basic-sdk/extension/plugins/check-list/plugin.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("@seafile/slate");
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _constants = require("../../constants");
+var _core = require("../../core");
+const withCheckList = editor => {
+  const {
+    insertBreak,
+    deleteBackward,
+    onHotKeyDown
+  } = editor;
+  const newEditor = editor;
+  newEditor.insertBreak = () => {
+    const {
+      selection
+    } = newEditor;
+    if (!selection) {
+      insertBreak();
+      return;
+    }
+    const node = (0, _core.getSelectedNodeByType)(editor, _constants.CHECK_LIST_ITEM);
+    if (!node) {
+      insertBreak();
+      return;
+    }
+    if (_slate.Node.string(node).length === 0) {
+      _slate.Transforms.setNodes(editor, {
+        type: _constants.PARAGRAPH,
+        children: [(0, _core.generateDefaultText)()]
+      }, {
+        at: node[1]
+      });
+      return;
+    }
+
+    // If it is check-list-item, handle your own business logic
+    if ((0, _core.isCursorAtBlockStart)(editor)) {
+      const path = (0, _core.findPath)(editor, node);
+      const newNode = (0, _core.generateEmptyElement)(_constants.CHECK_LIST_ITEM);
+      _slate.Transforms.insertNodes(editor, newNode, {
+        at: path
+      });
+      return;
+    }
+    _slate.Transforms.splitNodes(editor, {
+      always: true
+    });
+    _slate.Transforms.setNodes(editor, {
+      checked: false
+    }, {
+      at: node[1]
+    });
+  };
+  newEditor.deleteBackward = unit => {
+    const {
+      selection
+    } = newEditor;
+    if (selection && _slate.Range.isCollapsed(selection)) {
+      const selectedTodo = (0, _core.getSelectedNodeByType)(editor, _constants.CHECK_LIST_ITEM);
+      if (selectedTodo) {
+        // If the current todo has no text, it will be converted to a paragraph
+        if (_slate.Node.string(selectedTodo).length === 0) {
+          _slate.Transforms.setNodes(editor, {
+            type: _constants.PARAGRAPH,
+            children: [(0, _core.generateDefaultText)()]
+          }, {
+            at: selectedTodo[1]
+          });
+          return;
+        }
+      }
+    }
+    deleteBackward(unit);
+  };
+  newEditor.onHotKeyDown = event => {
+    const selectedTodo = (0, _core.getSelectedNodeByType)(editor, _constants.CHECK_LIST_ITEM);
+    if (selectedTodo) {
+      if ((0, _isHotkey.default)('shift+enter', event)) {
+        event.preventDefault();
+        const {
+          selection
+        } = newEditor;
+        const insertPoint = _slate.Editor.start(editor, selection);
+        _slate.Transforms.insertText(editor, '\n', {
+          at: insertPoint
+        });
+        (0, _core.focusEditor)(editor, {
+          anchor: {
+            path: insertPoint.path,
+            offset: insertPoint.offset + 1
+          },
+          focus: {
+            path: insertPoint.path,
+            offset: insertPoint.offset + 1
+          }
+        });
+      }
+      return true;
+    }
+    return onHotKeyDown && onHotKeyDown(event);
+  };
+  return newEditor;
+};
+var _default = exports.default = withCheckList;

package/dist/basic-sdk/extension/plugins/check-list/render-elem.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderCheckListItem = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+class CheckListItem extends _react.default.PureComponent {
+  constructor() {
+    super(...arguments);
+    (0, _defineProperty2.default)(this, "onChange", event => {
+      const {
+        editor,
+        element,
+        readOnly
+      } = this.props;
+      if (readOnly) return;
+      const checked = event.target.checked;
+      const path = _slateReact.ReactEditor.findPath(editor, element);
+      _slate.Transforms.setNodes(editor, {
+        checked
+      }, {
+        at: path
+      });
+    });
+  }
+  render() {
+    const {
+      attributes,
+      children,
+      element
+    } = this.props;
+    const {
+      id,
+      align,
+      checked = false
+    } = element || {};
+    const style = {
+      textAlign: align
+    };
+    return /*#__PURE__*/_react.default.createElement("div", Object.assign({
+      "data-id": id
+    }, attributes, {
+      className: `sdoc-checkbox-container ${attributes.className}`,
+      style: style
+    }), /*#__PURE__*/_react.default.createElement("div", {
+      className: "sdoc-checkbox-input-wrapper"
+    }, /*#__PURE__*/_react.default.createElement("input", {
+      contentEditable: false,
+      className: "sdoc-checkbox-input",
+      type: "checkbox",
+      onChange: this.onChange,
+      checked: checked
+    }), /*#__PURE__*/_react.default.createElement("p", {
+      className: "sdoc-checkbox-content-container"
+    }, children)));
+  }
+}
+const renderCheckListItem = (props, editor) => {
+  // eslint-disable-next-line react-hooks/rules-of-hooks
+  const readOnly = (0, _slateReact.useReadOnly)();
+  return /*#__PURE__*/_react.default.createElement(CheckListItem, Object.assign({}, props, {
+    editor: editor,
+    readOnly: readOnly
+  }));
+};
+exports.renderCheckListItem = renderCheckListItem;

package/dist/basic-sdk/extension/plugins/clear-format/helpers.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMenuDisabled = exports.clearStyles = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../constants");
+var _core = require("../../core");
+const isMenuDisabled = function (editor) {
+  let readonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (readonly) return true;
+  if (editor.selection == null) return true;
+  const [match] = _slate.Editor.nodes(editor, {
+    match: n => {
+      const type = (0, _core.getNodeType)(n);
+      if ([_constants.CODE_BLOCK, _constants.CODE_LINE].includes(type)) return true; // code-block
+      if (_slate.Editor.isVoid(editor, n)) return true; // void node
+
+      return false;
+    },
+    universal: true
+  });
+  if (match) return true;
+  return false;
+};
+exports.isMenuDisabled = isMenuDisabled;
+const removeMarks = (editor, textNode) => {
+  // Iterate text node properties, clearing styles
+  const keys = Object.keys(textNode);
+  keys.forEach(key => {
+    if (key === 'text') {
+      // Keep only the text attribute （Text attributes are necessary）
+      return;
+    }
+    // All other attributes are deleted
+    _slate.Editor.removeMark(editor, key);
+  });
+};
+const clearStyles = editor => {
+  _slate.Transforms.unwrapNodes(editor, {
+    match: n => (0, _core.getNodeType)(n) === 'link'
+  });
+  const nodeEntries = _slate.Editor.nodes(editor, {
+    match: n => _slate.Text.isText(n),
+    universal: true
+  });
+  for (const nodeEntry of nodeEntries) {
+    // single text node
+    const n = nodeEntry[0];
+    removeMarks(editor, n);
+  }
+};
+exports.clearStyles = clearStyles;

package/dist/basic-sdk/extension/plugins/clear-format/menu/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _commons = require("../../../commons");
+var _constants = require("../../../constants");
+var _helpers = require("../helpers");
+const menuConfig = _constants.MENUS_CONFIG_MAP[_constants.CLEAR_FORMAT];
+const ClearFormatMenu = _ref => {
+  let {
+    isRichEditor,
+    className,
+    editor,
+    readonly
+  } = _ref;
+  const onMouseDown = (0, _react.useCallback)(() => {
+    (0, _helpers.clearStyles)(editor);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const props = {
+    isRichEditor,
+    className,
+    ariaLabel: 'clear',
+    ...menuConfig,
+    disabled: (0, _helpers.isMenuDisabled)(editor, readonly),
+    isActive: false,
+    'onMouseDown': onMouseDown
+  };
+  return /*#__PURE__*/_react.default.createElement(_commons.MenuItem, props);
+};
+var _default = exports.default = ClearFormatMenu;

package/dist/basic-sdk/extension/plugins/code-block/helpers.js

@@ -0,0 +1,206 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setClipboardCodeBlockData = exports.isMenuDisabled = exports.getValidLang = exports.getSelectedLangOption = exports.getSelectCodeElem = exports.getCodeBlockNode = exports.deleteBackwardByLength = exports.changeToPlainText = exports.changeToCodeBlock = void 0;
+var _slate = require("@seafile/slate");
+var _copyToClipboard = _interopRequireDefault(require("copy-to-clipboard"));
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../constants");
+var _core = require("../../core");
+var _helper = require("../callout/helper");
+var _prismjs = require("./prismjs");
+const isMenuDisabled = (editor, readonly) => {
+  if (readonly) return true;
+  const {
+    selection
+  } = editor;
+  if (selection === null) return true;
+  if ((0, _helper.getCalloutEntry)(editor)) return true;
+  const selectedElems = (0, _core.getSelectedElems)(editor);
+  const hasVoid = selectedElems.some(elem => editor.isVoid(elem));
+  if (hasVoid) return true;
+  const isMatch = selectedElems.every(elem => {
+    const type = (0, _core.getNodeType)(elem);
+    if (type === _constants.PARAGRAPH) return true;
+    return false;
+  });
+  if (isMatch) return false; // enable
+  return true; // disable
+};
+exports.isMenuDisabled = isMenuDisabled;
+const getSelectCodeElem = editor => {
+  const codeNode = (0, _core.getSelectedNodeByType)(editor, _constants.CODE_BLOCK);
+  if (codeNode == null) return null;
+  return codeNode;
+};
+exports.getSelectCodeElem = getSelectCodeElem;
+const getCodeBlockNode = language => {
+  const node = {
+    id: _slugid.default.nice(),
+    type: _constants.CODE_BLOCK,
+    language,
+    style: {
+      white_space: 'nowrap'
+    },
+    // default nowrap
+    children: [{
+      id: _slugid.default.nice(),
+      type: _constants.CODE_LINE,
+      children: [{
+        text: '',
+        id: _slugid.default.nice()
+      }]
+    }]
+  };
+  return node;
+};
+exports.getCodeBlockNode = getCodeBlockNode;
+const changeToCodeBlock = function (editor) {
+  let language = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _constants.INSERT_POSITION.CURRENT;
+  let isQuickMenu = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  if (!editor.selection) return;
+  let strArr = []; // Summarizes the strings for the selected highest-level node
+  const path = _slate.Editor.path(editor, editor.selection, {
+    edge: 'start'
+  });
+  const newCodeBlockNode = getCodeBlockNode(language); // New code-block node
+
+  // Insert after
+  if (position === _constants.INSERT_POSITION.AFTER) {
+    strArr = [''];
+    newCodeBlockNode.children[0].children[0].text = strArr.join('\n');
+    _slate.Transforms.insertNodes(editor, newCodeBlockNode, {
+      mode: 'highest',
+      at: [path[0] + 1]
+    });
+    _slate.Transforms.select(editor, [path[0] + 1, 0, 0]);
+    return;
+  }
+
+  // Insert current
+  if (position === _constants.INSERT_POSITION.CURRENT) {
+    // Insert codeblock in multi_column
+    const currentMultiColumnEntry = (0, _core.getSelectedNodeEntryByType)(editor, _constants.MULTI_COLUMN);
+    if (currentMultiColumnEntry) {
+      const currentParagraphPath = editor.selection.anchor.path.slice(0, 3);
+      const nodeEntry = _slate.Editor.node(editor, currentParagraphPath);
+      if (nodeEntry) {
+        strArr.push(_slate.Node.string(nodeEntry[0]));
+      }
+      _slate.Transforms.removeNodes(editor, {
+        at: currentParagraphPath
+      });
+      newCodeBlockNode.children[0].children[0].text = strArr.join('\n');
+      _slate.Transforms.insertNodes(editor, newCodeBlockNode, {
+        at: currentParagraphPath
+      });
+      _slate.Transforms.select(editor, _slate.Editor.start(editor, currentParagraphPath));
+      return;
+    }
+    // Select the plain text of the node
+    const nodeEntries = _slate.Editor.nodes(editor, {
+      match: n => editor.children.includes(n),
+      // Matches the selected node at the highest level
+      universal: true
+    });
+    for (let nodeEntry of nodeEntries) {
+      const [n] = nodeEntry;
+      if (n) strArr.push(_slate.Node.string(n));
+    }
+    // Deletes the selected node at the highest level
+    _slate.Transforms.removeNodes(editor, {
+      mode: 'highest'
+    });
+
+    // Modify location
+    const atPath = [path[0]];
+    const atPoint = {
+      anchor: {
+        offset: 0,
+        path: [path[0], 0, 0]
+      },
+      focus: {
+        offset: 0,
+        path: [path[0], 0, 0]
+      }
+    };
+    // Insert new node
+    newCodeBlockNode.children[0].children[0].text = strArr.join('\n');
+    _slate.Transforms.insertNodes(editor, newCodeBlockNode, {
+      mode: 'highest',
+      at: atPath
+    });
+    queueMicrotask(() => {
+      if (!isQuickMenu) {
+        _slate.Transforms.select(editor, atPoint);
+      } else {
+        (0, _core.focusEditor)(editor, atPoint);
+      }
+    });
+  }
+};
+exports.changeToCodeBlock = changeToCodeBlock;
+const changeToPlainText = editor => {
+  const elem = getSelectCodeElem(editor);
+  if (elem == null) return;
+
+  // Get code text
+  const str = _slate.Node.string(elem);
+
+  // Delete the highest level node, -> "the code-block node"
+  _slate.Transforms.removeNodes(editor, {
+    mode: 'highest'
+  });
+
+  // Insert p node
+  const pList = str.split('\n').map(s => {
+    return {
+      id: elem.id,
+      type: _constants.PARAGRAPH,
+      children: [{
+        text: s,
+        id: _slugid.default.nice()
+      }]
+    };
+  });
+  _slate.Transforms.insertNodes(editor, pList, {
+    mode: 'highest'
+  });
+};
+exports.changeToPlainText = changeToPlainText;
+const setClipboardCodeBlockData = value => {
+  // Insert text into the clipboard for use on other pages
+  // Empty string cannot apply in `copy`
+  const text = value.children.map(line => _slate.Node.string(line)).join('\n') || ' ';
+  (0, _copyToClipboard.default)(text, {
+    format: 'text/plain',
+    onCopy: data => {
+      // Set the sdoc editor to format the data
+      data.setData('text/code-block', JSON.stringify(value));
+    }
+  });
+};
+exports.setClipboardCodeBlockData = setClipboardCodeBlockData;
+const deleteBackwardByLength = (editor, len) => {
+  let i = len >= 4 ? 4 : len;
+  while (i > 0) {
+    _slate.Editor.deleteBackward(editor, 'word');
+    i--;
+  }
+};
+exports.deleteBackwardByLength = deleteBackwardByLength;
+const getSelectedLangOption = lang => {
+  const langs = (0, _prismjs.genCodeLangs)();
+  const selectedLangOption = langs.find(item => item.value === lang);
+  return selectedLangOption || langs[0];
+};
+exports.getSelectedLangOption = getSelectedLangOption;
+const getValidLang = lang => {
+  const langOption = getSelectedLangOption(lang);
+  return langOption.value;
+};
+exports.getValidLang = getValidLang;