@seafile/sdoc-editor 0.3.6 → 0.3.7

package/dist/basic-sdk/extension/core/transforms/focus-editor.js

@@ -1,8 +1,8 @@
 import { Editor, Transforms } from '@seafile/slate';
 import { ReactEditor } from '@seafile/slate-react';
-export var focusEditor = function focusEditor(editor, target) {
+export const focusEditor = (editor, target) => {
   if (target) {
-    Editor.withoutNormalizing(editor, function () {
+    Editor.withoutNormalizing(editor, () => {
       Transforms.deselect(editor);
       Transforms.select(editor, target);
     });

package/dist/basic-sdk/extension/core/transforms/move-children.js

@@ -1,25 +1,25 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import { Editor, Path, Transforms } from '@seafile/slate';
 import { getNode } from '../queries';
-export var moveChildren = function moveChildren(editor, _ref) {
-  var at = _ref.at,
-    to = _ref.to,
-    match = _ref.match,
-    _ref$fromStartIndex = _ref.fromStartIndex,
-    fromStartIndex = _ref$fromStartIndex === void 0 ? 0 : _ref$fromStartIndex;
-  var moved = 0;
-  var parentPath = Path.isPath(at) ? at : at[1];
-  var parentNode = Path.isPath(at) ? getNode(editor, parentPath) : at[0];
+export const moveChildren = (editor, _ref) => {
+  let {
+    at,
+    to,
+    match,
+    fromStartIndex = 0
+  } = _ref;
+  let moved = 0;
+  const parentPath = Path.isPath(at) ? at : at[1];
+  const parentNode = Path.isPath(at) ? getNode(editor, parentPath) : at[0];
   if (!parentNode) return moved;
   // There have none children in a not block element
   if (!Editor.isBlock(editor, parentNode)) return moved;
-  for (var i = parentNode.children.length - 1; i >= fromStartIndex; i--) {
-    var childPath = [].concat(_toConsumableArray(parentPath), [i]);
-    var childNode = getNode(editor, childPath);
+  for (let i = parentNode.children.length - 1; i >= fromStartIndex; i--) {
+    const childPath = [...parentPath, i];
+    const childNode = getNode(editor, childPath);
     if (!match || childNode && match([childNode, childPath])) {
       Transforms.moveNodes(editor, {
         at: childPath,
-        to: to
+        to
       });
       moved++;
     }

package/dist/basic-sdk/extension/core/transforms/remove-node-children.js

@@ -1,24 +1,12 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import { Transforms, Node } from '@seafile/slate';
-export var removeNodeChildren = function removeNodeChildren(editor, path, options) {
-  var nodeChildren = Node.children(editor, path, {
+export const removeNodeChildren = (editor, path, options) => {
+  const nodeChildren = Node.children(editor, path, {
     reverse: true
   });
-  var _iterator = _createForOfIteratorHelper(nodeChildren),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _step$value = _slicedToArray(_step.value, 2),
-        childPath = _step$value[1];
-      Transforms.removeNodes(editor, _objectSpread(_objectSpread({}, options), {}, {
-        at: childPath
-      }));
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  for (const [, childPath] of nodeChildren) {
+    Transforms.removeNodes(editor, _objectSpread(_objectSpread({}, options), {}, {
+      at: childPath
+    }));
   }
 };

package/dist/basic-sdk/extension/core/transforms/replace-node.js

@@ -1,37 +1,40 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import { Editor, Transforms } from '@seafile/slate';
 import { removeNodeChildren } from './remove-node-children';
-export var replaceNodeChildren = function replaceNodeChildren(editor, _ref) {
-  var at = _ref.at,
-    nodes = _ref.nodes,
-    insertOptions = _ref.insertOptions,
-    removeOptions = _ref.removeOptions;
-  Editor.withoutNormalizing(editor, function () {
+export const replaceNodeChildren = (editor, _ref) => {
+  let {
+    at,
+    nodes,
+    insertOptions,
+    removeOptions
+  } = _ref;
+  Editor.withoutNormalizing(editor, () => {
     removeNodeChildren(editor, at, removeOptions);
     Transforms.insertNodes(editor, nodes, _objectSpread(_objectSpread({}, insertOptions), {}, {
       at: at.concat([0])
     }));
   });
 };
-export var replaceNode = function replaceNode(editor) {
-  var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-    at = _ref2.at,
-    nodes = _ref2.nodes,
-    insertOptions = _ref2.insertOptions,
-    removeOptions = _ref2.removeOptions;
-  Editor.withoutNormalizing(editor, function () {
+export const replaceNode = function (editor) {
+  let {
+    at,
+    nodes,
+    insertOptions,
+    removeOptions
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  Editor.withoutNormalizing(editor, () => {
     Transforms.removeNodes(editor, _objectSpread({
-      at: at
+      at
     }, removeOptions));
     Transforms.insertNodes(editor, nodes, _objectSpread(_objectSpread({}, insertOptions), {}, {
-      at: at
+      at
     }));
   });
 };
-export var deleteNodeMark = function deleteNodeMark(editor, path, element) {
-  var marks = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
-  var newElement = _objectSpread({}, element);
-  marks.forEach(function (markItem) {
+export const deleteNodeMark = function (editor, path, element) {
+  let marks = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  const newElement = _objectSpread({}, element);
+  marks.forEach(markItem => {
     newElement[markItem] && delete newElement[markItem];
   });
   replaceNode(editor, {

package/dist/basic-sdk/extension/core/transforms/update-parent-node.js

@@ -2,17 +2,15 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import { REBASE_MARK_KEY } from '../../../constants';
 import { getNode } from '../queries';
 import { replaceNode } from './replace-node';
-export var updateRebaseParentNodeByPath = function updateRebaseParentNodeByPath(editor, path) {
-  var parentPath = path.slice(0, -1);
-  var parentNode = getNode(editor, parentPath);
-  if (parentNode.children.filter(function (item) {
-    return item[REBASE_MARK_KEY.REBASE_TYPE];
-  }).length !== 0) return;
-  var newParentElement = _objectSpread({}, parentNode);
+export const updateRebaseParentNodeByPath = (editor, path) => {
+  const parentPath = path.slice(0, -1);
+  const parentNode = getNode(editor, parentPath);
+  if (parentNode.children.filter(item => item[REBASE_MARK_KEY.REBASE_TYPE]).length !== 0) return;
+  const newParentElement = _objectSpread({}, parentNode);
   newParentElement[REBASE_MARK_KEY.REBASE_TYPE] && delete newParentElement[REBASE_MARK_KEY.REBASE_TYPE];
   newParentElement[REBASE_MARK_KEY.OLD_ELEMENT] && delete newParentElement[REBASE_MARK_KEY.OLD_ELEMENT];
   newParentElement[REBASE_MARK_KEY.ORIGIN] && delete newParentElement[REBASE_MARK_KEY.ORIGIN];
-  newParentElement['children'] = newParentElement['children'].map(function (item) {
+  newParentElement['children'] = newParentElement['children'].map(item => {
     item[REBASE_MARK_KEY.REBASE_TYPE] && delete item[REBASE_MARK_KEY.REBASE_TYPE];
     item[REBASE_MARK_KEY.OLD_ELEMENT] && delete item[REBASE_MARK_KEY.OLD_ELEMENT];
     item[REBASE_MARK_KEY.ORIGIN] && delete item[REBASE_MARK_KEY.ORIGIN];

package/dist/basic-sdk/extension/core/utils/index.js

@@ -1,14 +1,11 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import React from 'react';
 import slugid from 'slugid';
 import { useTranslation } from 'react-i18next';
-export var match = function match(node, path, predicate) {
+export const match = (node, path, predicate) => {
   if (!predicate) return true;
   if (typeof predicate === 'object') {
-    return Object.entries(predicate).every(function (_ref) {
-      var _ref2 = _slicedToArray(_ref, 2),
-        key = _ref2[0],
-        value = _ref2[1];
+    return Object.entries(predicate).every(_ref => {
+      let [key, value] = _ref;
       if (value && !Array.isArray(value)) {
         return node[key] === value;
       }
@@ -18,23 +15,26 @@ export var match = function match(node, path, predicate) {
   }
   return predicate(node, path);
 };
-export var generateDefaultText = function generateDefaultText() {
+export const generateDefaultText = () => {
   return {
     id: slugid.nice(),
     text: ''
   };
 };
-export var generateEmptyElement = function generateEmptyElement(type) {
+export const generateEmptyElement = type => {
   return {
     id: slugid.nice(),
-    type: type,
+    type,
     children: [generateDefaultText()]
   };
 };
 export function Placeholder(props) {
-  var title = props.title;
-  var _useTranslation = useTranslation(),
-    t = _useTranslation.t;
+  const {
+    title
+  } = props;
+  const {
+    t
+  } = useTranslation();
   return /*#__PURE__*/React.createElement("span", {
     style: {
       position: 'absolute',

package/dist/basic-sdk/extension/index.js

@@ -5,17 +5,17 @@ import Plugins from './plugins';
 import renderElement from './render/render-element';
 import renderLeaf from './render/render-leaf';
 import { HeaderToolbar, ContextToolbar, SideToolbar } from './toolbar';
-var baseEditor = withHistory(withReact(createEditor()));
-var defaultEditor = Plugins === null || Plugins === void 0 ? void 0 : Plugins.reduce(function (editor, pluginItem) {
-  var withPlugin = pluginItem.editorPlugin;
+const baseEditor = withHistory(withReact(createEditor()));
+const defaultEditor = Plugins === null || Plugins === void 0 ? void 0 : Plugins.reduce((editor, pluginItem) => {
+  const withPlugin = pluginItem.editorPlugin;
   if (withPlugin) {
     return withPlugin(editor);
   }
   return editor;
 }, baseEditor);
-export var createDefaultEditor = function createDefaultEditor() {
-  var defaultEditor = Plugins === null || Plugins === void 0 ? void 0 : Plugins.reduce(function (editor, pluginItem) {
-    var withPlugin = pluginItem.editorPlugin;
+export const createDefaultEditor = () => {
+  const defaultEditor = Plugins === null || Plugins === void 0 ? void 0 : Plugins.reduce((editor, pluginItem) => {
+    const withPlugin = pluginItem.editorPlugin;
     if (withPlugin) {
       return withPlugin(editor);
     }

package/dist/basic-sdk/extension/plugins/blockquote/helpers.js

@@ -1,32 +1,28 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { Editor, Transforms, Element } from '@seafile/slate';
 import slugid from 'slugid';
 import { BLOCKQUOTE, CHECK_LIST_ITEM, IMAGE, ORDERED_LIST, PARAGRAPH, UNORDERED_LIST, CODE_BLOCK, TABLE } from '../../constants';
 import { focusEditor, getNodeType } from '../../core';
-export var isMenuDisabled = function isMenuDisabled(editor, readonly) {
+export const isMenuDisabled = (editor, readonly) => {
   if (readonly) return true;
   if (editor.selection == null) return true;
-  var _Editor$nodes = Editor.nodes(editor, {
-      match: function match(n) {
-        var type = getNodeType(n);
+  const [nodeEntry] = Editor.nodes(editor, {
+    match: n => {
+      const type = getNodeType(n);
 
-        // Only available for p and blockquote
-        if (type === PARAGRAPH) return true;
-        if (type === BLOCKQUOTE) return true;
-        if (type === UNORDERED_LIST) return true;
-        if (type === ORDERED_LIST) return true;
-        if (type === CHECK_LIST_ITEM) return true;
-        if (type && type.startWith && type.startWith('header')) return true;
-        if (type === IMAGE) return true;
-        return false;
-      },
-      universal: true,
-      mode: 'highest' // Match top level
-    }),
-    _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),
-    nodeEntry = _Editor$nodes2[0];
+      // Only available for p and blockquote
+      if (type === PARAGRAPH) return true;
+      if (type === BLOCKQUOTE) return true;
+      if (type === UNORDERED_LIST) return true;
+      if (type === ORDERED_LIST) return true;
+      if (type === CHECK_LIST_ITEM) return true;
+      if (type && type.startWith && type.startWith('header')) return true;
+      if (type === IMAGE) return true;
+      return false;
+    },
+    universal: true,
+    mode: 'highest' // Match top level
+  });
 
   // Match to p blockquote, do not disable
   if (nodeEntry) {
@@ -35,50 +31,41 @@ export var isMenuDisabled = function isMenuDisabled(editor, readonly) {
   // 未匹配到，则禁用
   return true;
 };
-export var getBlockQuoteType = function getBlockQuoteType(editor) {
-  var _Editor$nodes3 = Editor.nodes(editor, {
-      match: function match(n) {
-        return getNodeType(n) === BLOCKQUOTE;
-      },
-      universal: true
-    }),
-    _Editor$nodes4 = _slicedToArray(_Editor$nodes3, 1),
-    match = _Editor$nodes4[0];
+export const getBlockQuoteType = editor => {
+  const [match] = Editor.nodes(editor, {
+    match: n => getNodeType(n) === BLOCKQUOTE,
+    universal: true
+  });
   if (!match) return PARAGRAPH;
-  var _match = _slicedToArray(match, 1),
-    n = _match[0];
+  const [n] = match;
   return getNodeType(n);
 };
-export var setBlockQuoteType = function setBlockQuoteType(editor, active) {
+export const setBlockQuoteType = (editor, active) => {
   if (!active) {
-    var blockquoteNode = {
+    const blockquoteNode = {
       id: slugid.nice(),
       type: BLOCKQUOTE
     };
     Transforms.wrapNodes(editor, blockquoteNode, {
       mode: 'highest',
-      match: function match(n) {
-        return Element.isElement(n) && Editor.isBlock(editor, n);
-      }
+      match: n => Element.isElement(n) && Editor.isBlock(editor, n)
     });
   } else {
     Transforms.unwrapNodes(editor, {
       mode: 'highest',
-      match: function match(n) {
-        return Element.isElement(n) && Editor.isBlock(editor, n);
-      }
+      match: n => Element.isElement(n) && Editor.isBlock(editor, n)
     });
   }
   focusEditor(editor);
 };
-export var getFormattedElements = function getFormattedElements(data) {
-  var elements = [];
-  var arr = [];
-  data.forEach(function (item) {
+export const getFormattedElements = data => {
+  const elements = [];
+  let arr = [];
+  data.forEach(item => {
     if ([CODE_BLOCK, TABLE, BLOCKQUOTE].includes(item === null || item === void 0 ? void 0 : item.type)) {
       // Insert quote block
       if (arr.length !== 0) {
-        var blockquoteNode = {
+        const blockquoteNode = {
           id: slugid.nice(),
           type: BLOCKQUOTE
         };
@@ -87,10 +74,10 @@ export var getFormattedElements = function getFormattedElements(data) {
         arr = [];
       }
       // Merge quote block
-      var preElement = elements[elements.length - 1];
+      let preElement = elements[elements.length - 1];
       if ((preElement === null || preElement === void 0 ? void 0 : preElement.type) === BLOCKQUOTE && (item === null || item === void 0 ? void 0 : item.type) === BLOCKQUOTE) {
         elements[elements.length - 1] = _objectSpread(_objectSpread({}, preElement), {}, {
-          children: [].concat(_toConsumableArray(preElement.children), _toConsumableArray(item.children))
+          children: [...preElement.children, ...item.children]
         });
       } else {
         elements.push(item);
@@ -101,15 +88,13 @@ export var getFormattedElements = function getFormattedElements(data) {
   });
   return elements;
 };
-export var getFormattedRestElements = function getFormattedRestElements(data) {
-  var restElements = data.slice(0);
+export const getFormattedRestElements = data => {
+  const restElements = data.slice(0);
   // Contains quote block type elements
-  if (data.find(function (item) {
-    return (item === null || item === void 0 ? void 0 : item.type) === BLOCKQUOTE;
-  })) {
-    data.forEach(function (item, index) {
+  if (data.find(item => (item === null || item === void 0 ? void 0 : item.type) === BLOCKQUOTE)) {
+    data.forEach((item, index) => {
       if ((item === null || item === void 0 ? void 0 : item.type) === BLOCKQUOTE) {
-        restElements.splice.apply(restElements, [index, 1].concat(_toConsumableArray(item.children)));
+        restElements.splice(index, 1, ...item.children);
       }
     });
   }

package/dist/basic-sdk/extension/plugins/blockquote/index.js

@@ -3,7 +3,7 @@ import QuoteMenu from './menu';
 import Blockquote from './model';
 import withBlockquote from './plugin';
 import renderBlockquote from './render-elem';
-var BlockquotePlugin = {
+const BlockquotePlugin = {
   type: BLOCKQUOTE,
   nodeType: 'element',
   model: Blockquote,

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

@@ -1,57 +1,47 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import React from 'react';
 import { BLOCKQUOTE, MENUS_CONFIG_MAP } from '../../../constants';
 import { MenuItem } from '../../../commons';
 import { getBlockQuoteType, isMenuDisabled, setBlockQuoteType } from '../helpers';
-var QuoteMenu = /*#__PURE__*/function (_React$Component) {
-  _inherits(QuoteMenu, _React$Component);
-  var _super = _createSuper(QuoteMenu);
-  function QuoteMenu() {
-    var _this;
-    _classCallCheck(this, QuoteMenu);
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    _this = _super.call.apply(_super, [this].concat(args));
-    _this.isActive = function () {
-      var editor = _this.props.editor;
+class QuoteMenu extends React.Component {
+  constructor() {
+    super(...arguments);
+    this.isActive = () => {
+      const {
+        editor
+      } = this.props;
       return getBlockQuoteType(editor) === BLOCKQUOTE;
     };
-    _this.isDisabled = function () {
-      var _this$props = _this.props,
-        editor = _this$props.editor,
-        readonly = _this$props.readonly;
+    this.isDisabled = () => {
+      const {
+        editor,
+        readonly
+      } = this.props;
       return isMenuDisabled(editor, readonly);
     };
-    _this.onMouseDown = function (e) {
-      var editor = _this.props.editor;
-      var active = _this.isActive(editor);
+    this.onMouseDown = e => {
+      const {
+        editor
+      } = this.props;
+      const active = this.isActive(editor);
       setBlockQuoteType(editor, active);
     };
-    return _this;
   }
-  _createClass(QuoteMenu, [{
-    key: "render",
-    value: function render() {
-      var _this$props2 = this.props,
-        isRichEditor = _this$props2.isRichEditor,
-        className = _this$props2.className;
-      var menuConfig = MENUS_CONFIG_MAP[BLOCKQUOTE];
-      var props = _objectSpread(_objectSpread({
-        isRichEditor: isRichEditor,
-        className: className
-      }, menuConfig), {}, {
-        disabled: this.isDisabled(),
-        isActive: this.isActive(),
-        onMouseDown: this.onMouseDown
-      });
-      return /*#__PURE__*/React.createElement(MenuItem, props);
-    }
-  }]);
-  return QuoteMenu;
-}(React.Component);
+  render() {
+    const {
+      isRichEditor,
+      className
+    } = this.props;
+    const menuConfig = MENUS_CONFIG_MAP[BLOCKQUOTE];
+    const props = _objectSpread(_objectSpread({
+      isRichEditor,
+      className
+    }, menuConfig), {}, {
+      disabled: this.isDisabled(),
+      isActive: this.isActive(),
+      onMouseDown: this.onMouseDown
+    });
+    return /*#__PURE__*/React.createElement(MenuItem, props);
+  }
+}
 export default QuoteMenu;

package/dist/basic-sdk/extension/plugins/blockquote/model.js

@@ -1,11 +1,10 @@
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import { BLOCKQUOTE } from '../../constants';
-var Blockquote = /*#__PURE__*/_createClass(function Blockquote(options) {
-  _classCallCheck(this, Blockquote);
-  this.type = options.type || BLOCKQUOTE;
-  this.children = options.children || [{
-    text: ''
-  }];
-});
+class Blockquote {
+  constructor(options) {
+    this.type = options.type || BLOCKQUOTE;
+    this.children = options.children || [{
+      text: ''
+    }];
+  }
+}
 export default Blockquote;

package/dist/basic-sdk/extension/plugins/blockquote/plugin.js

@@ -1,40 +1,39 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { Editor, Element, Point, Transforms, Node, Range } from '@seafile/slate';
 import { ReactEditor } from '@seafile/slate-react';
 import { generateEmptyElement, getSelectedNodeByType, isSelectionAtBlockStart } from '../../core';
 import { BLOCKQUOTE, PARAGRAPH, CODE_BLOCK, TABLE } from '../../constants';
 import { setBlockQuoteType, getFormattedElements, getFormattedRestElements } from './helpers';
-var withBlockquote = function withBlockquote(editor) {
-  var insertBreak = editor.insertBreak,
-    insertText = editor.insertText,
-    deleteBackward = editor.deleteBackward,
-    insertFragment = editor.insertFragment;
-  var newEditor = editor;
-  newEditor.insertBreak = function () {
-    var selection = editor.selection;
+const withBlockquote = editor => {
+  const {
+    insertBreak,
+    insertText,
+    deleteBackward,
+    insertFragment
+  } = editor;
+  const newEditor = editor;
+  newEditor.insertBreak = () => {
+    const {
+      selection
+    } = editor;
     if (selection == null) return insertBreak();
-    var _Editor$nodes = Editor.nodes(editor, {
-        match: function match(n) {
-          return Element.isElement(n) && n.type === BLOCKQUOTE;
-        },
-        universal: true
-      }),
-      _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),
-      nodeEntry = _Editor$nodes2[0];
+    const [nodeEntry] = Editor.nodes(editor, {
+      match: n => Element.isElement(n) && n.type === BLOCKQUOTE,
+      universal: true
+    });
     if (!nodeEntry) return insertBreak();
-    var quoteElem = nodeEntry[0];
-    var quotePath = ReactEditor.findPath(editor, quoteElem);
-    var quoteEndLocation = Editor.end(editor, quotePath);
+    const quoteElem = nodeEntry[0];
+    const quotePath = ReactEditor.findPath(editor, quoteElem);
+    const quoteEndLocation = Editor.end(editor, quotePath);
     if (Point.equals(quoteEndLocation, selection.focus)) {
       // Cursor is at the end of blockquote
-      var str = Node.string(quoteElem);
+      const str = Node.string(quoteElem);
       // The last of the blockquote text is \n;
       if (str && str.slice(-1) === '\n') {
         // Step 1: Remove the last \n
         editor.deleteBackward('character');
         // Step 2: Insert a paragraph
-        var p = generateEmptyElement(PARAGRAPH);
+        const p = generateEmptyElement(PARAGRAPH);
         Transforms.insertNodes(newEditor, p, {
           mode: 'highest'
         });
@@ -45,24 +44,26 @@ var withBlockquote = function withBlockquote(editor) {
     // In other cases, insert a newline
     insertText('\n');
   };
-  newEditor.deleteBackward = function (unit) {
-    var selection = newEditor.selection;
+  newEditor.deleteBackward = unit => {
+    const {
+      selection
+    } = newEditor;
     if (selection === null) {
       deleteBackward(unit);
       return;
     }
-    var node = getSelectedNodeByType(editor, BLOCKQUOTE);
+    const node = getSelectedNodeByType(editor, BLOCKQUOTE);
     if (node) {
       if (isSelectionAtBlockStart(editor)) {
         setBlockQuoteType(editor, PARAGRAPH);
         return;
       }
       if (unit === 'line' && Range.isCollapsed(selection)) {
-        var quoteString = Node.string(node);
-        for (var index = selection.anchor.offset; index > 1; index--) {
-          var char = quoteString.slice(index - 1, index);
+        const quoteString = Node.string(node);
+        for (let index = selection.anchor.offset; index > 1; index--) {
+          const char = quoteString.slice(index - 1, index);
           if (char === '\n') {
-            var deleteRange = selection.anchor.offset === index ? _objectSpread(_objectSpread({}, selection), {}, {
+            const deleteRange = selection.anchor.offset === index ? _objectSpread(_objectSpread({}, selection), {}, {
               anchor: _objectSpread(_objectSpread({}, selection.anchor), {}, {
                 offset: index - 1
               })
@@ -83,21 +84,19 @@ var withBlockquote = function withBlockquote(editor) {
     }
     deleteBackward(unit);
   };
-  newEditor.insertFragment = function (data) {
+  newEditor.insertFragment = data => {
     // Paste into quote block
     if (getSelectedNodeByType(newEditor, BLOCKQUOTE)) {
-      var lastIndex = data.findLastIndex(function (item) {
-        return [CODE_BLOCK, TABLE].includes(item === null || item === void 0 ? void 0 : item.type);
-      });
-      var elements = getFormattedElements(data.slice(0, lastIndex + 1));
-      var restElements = getFormattedRestElements(data.slice(lastIndex + 1));
-      var path = Editor.path(newEditor, newEditor.selection);
+      const lastIndex = data.findLastIndex(item => [CODE_BLOCK, TABLE].includes(item === null || item === void 0 ? void 0 : item.type));
+      let elements = getFormattedElements(data.slice(0, lastIndex + 1));
+      let restElements = getFormattedRestElements(data.slice(lastIndex + 1));
+      const path = Editor.path(newEditor, newEditor.selection);
 
       // Insert elements of quote block
       if (restElements.length !== 0) {
         // Insert text when inserting a single line paragraph
         if (restElements.length === 1 && restElements[0].type === PARAGRAPH) {
-          var string = Node.string(restElements[0]);
+          const string = Node.string(restElements[0]);
           Editor.insertText(newEditor, string);
         } else {
           Transforms.insertNodes(newEditor, restElements, {