@seafile/sdoc-editor 0.3.6 → 0.3.7

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

@@ -1,39 +1,37 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _toArray from "@babel/runtime/helpers/esm/toArray";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { Element, Path, Transforms, Node, Editor } from '@seafile/slate';
 import slugid from 'slugid';
 import { LIST_ITEM, PARAGRAPH } from '../../../constants';
 import { findNode, generateDefaultText, getCommonNode, getNode, getNodes } from '../../../core';
 import { getListTypes } from '../queries';
-var isListRoot = function isListRoot(node) {
+const isListRoot = node => {
   return Element.isElement(node) && getListTypes().includes(node.type);
 };
-var getFirstAncestorOfType = function getFirstAncestorOfType(root, entry, _ref) {
-  var type = _ref.type;
-  var ancestor = Path.parent(entry[1]);
+const getFirstAncestorOfType = (root, entry, _ref) => {
+  let {
+    type
+  } = _ref;
+  let ancestor = Path.parent(entry[1]);
   while (getNode(root, ancestor).type !== type) {
     ancestor = Path.parent(ancestor);
   }
   return [getNode(root, ancestor), ancestor];
 };
-var findListItemsWithContent = function findListItemsWithContent(first) {
-  var prev = null;
-  var node = first;
+const findListItemsWithContent = first => {
+  let prev = null;
+  let node = first;
   while (isListRoot(node) || node.type === LIST_ITEM && node.children[0].type !== PARAGRAPH) {
     prev = node;
-    var _node$children = _slicedToArray(node.children, 1);
-    node = _node$children[0];
+    [node] = node.children;
   }
   return prev ? prev.children : [node];
 };
-var trimList = function trimList(listRoot) {
+const trimList = listRoot => {
   if (!isListRoot(listRoot)) {
     return [listRoot];
   }
-  var _texts = Node.texts(listRoot);
-  var textEntries = Array.from(_texts);
-  var commonAncestorEntry = textEntries.reduce(function (commonAncestor, textEntry) {
+  const _texts = Node.texts(listRoot);
+  const textEntries = Array.from(_texts);
+  const commonAncestorEntry = textEntries.reduce((commonAncestor, textEntry) => {
     return Path.isAncestor(commonAncestor[1], textEntry[1]) ? commonAncestor : getCommonNode(listRoot, textEntry[1], commonAncestor[1]);
   }, getFirstAncestorOfType(listRoot, textEntries[0], {
     type: LIST_ITEM
@@ -41,59 +39,44 @@ var trimList = function trimList(listRoot) {
 
   // is ul/ol: return children
   // is not ul/ol
-  var _ref2 = isListRoot(commonAncestorEntry[0]) ? commonAncestorEntry[0].children : [commonAncestorEntry[0]],
-    _ref3 = _toArray(_ref2),
-    first = _ref3[0],
-    rest = _ref3.slice(1);
-  return [].concat(_toConsumableArray(findListItemsWithContent(first)), _toConsumableArray(rest));
+  const [first, ...rest] = isListRoot(commonAncestorEntry[0]) ? commonAncestorEntry[0].children : [commonAncestorEntry[0]];
+  return [...findListItemsWithContent(first), ...rest];
 };
-var wrapNodeIntoListItem = function wrapNodeIntoListItem(node) {
+const wrapNodeIntoListItem = node => {
   return node.type === LIST_ITEM ? node : {
     id: slugid.nice(),
     type: LIST_ITEM,
     children: [node]
   };
 };
-var isSingleLic = function isSingleLic(fragment) {
-  var isFragmentOnlyListRoot = fragment.length === 1 && isListRoot(fragment[0]);
-  return isFragmentOnlyListRoot && _toConsumableArray(getNodes({
+const isSingleLic = fragment => {
+  const isFragmentOnlyListRoot = fragment.length === 1 && isListRoot(fragment[0]);
+  return isFragmentOnlyListRoot && [...getNodes({
     children: fragment
-  })).filter(function (entry) {
-    return Element.isElement(entry[0]);
-  }).filter(function (_ref4) {
-    var _ref5 = _slicedToArray(_ref4, 1),
-      node = _ref5[0];
+  })].filter(entry => Element.isElement(entry[0])).filter(_ref2 => {
+    let [node] = _ref2;
     return node.type === PARAGRAPH;
   }).length === 1;
 };
-export var getTextAndListItemNodes = function getTextAndListItemNodes(editor, fragment, liEntry, licEntry) {
-  var _liEntry = _slicedToArray(liEntry, 2),
-    liPath = _liEntry[1];
-  var _licEntry = _slicedToArray(licEntry, 2),
-    licNode = _licEntry[0],
-    licPath = _licEntry[1];
-  var isEmptyNode = !Node.string(licNode);
+export const getTextAndListItemNodes = (editor, fragment, liEntry, licEntry) => {
+  const [, liPath] = liEntry;
+  const [licNode, licPath] = licEntry;
+  const isEmptyNode = !Node.string(licNode);
   // format copied fragment
   // first: lic, path: [...liPath, 0, 0]
   // rest: children, path: [...liPath, 1, 0]
-  var _fragment$flatMap$map = fragment.flatMap(trimList).map(wrapNodeIntoListItem),
-    _fragment$flatMap$map2 = _toArray(_fragment$flatMap$map),
-    first = _fragment$flatMap$map2[0],
-    rest = _fragment$flatMap$map2.slice(1);
-  var textNode = null;
-  var listItemNodes = [];
+  const [first, ...rest] = fragment.flatMap(trimList).map(wrapNodeIntoListItem);
+  let textNode = null;
+  let listItemNodes = [];
   if (isListRoot(fragment[0])) {
     if (isSingleLic(fragment)) {
       textNode = first;
       listItemNodes = rest;
     } else if (isEmptyNode) {
-      var li = getNode(editor, liPath);
-      var _li$children = _toArray(li.children),
-        currentSubLists = _li$children.slice(1); // old
+      const li = getNode(editor, liPath);
+      const [, ...currentSubLists] = li.children; // old
 
-      var _first$children = _toArray(first.children),
-        newLic = _first$children[0],
-        newSubLists = _first$children.slice(1); // copied
+      const [newLic, ...newSubLists] = first.children; // copied
       // insert copied contents
       Transforms.insertNodes(editor, newLic, {
         at: Path.next(licPath),
@@ -104,7 +87,7 @@ export var getTextAndListItemNodes = function getTextAndListItemNodes(editor, fr
       });
       if (newSubLists.length) {
         if (currentSubLists.length) {
-          var path = [].concat(_toConsumableArray(liPath), [1, 0]);
+          const path = [...liPath, 1, 0];
           Transforms.insertNodes(editor, newSubLists[0].children, {
             at: path,
             select: true
@@ -120,33 +103,35 @@ export var getTextAndListItemNodes = function getTextAndListItemNodes(editor, fr
       listItemNodes = rest;
     } else {
       textNode = generateDefaultText();
-      listItemNodes = [first].concat(_toConsumableArray(rest));
+      listItemNodes = [first, ...rest];
     }
   } else {
     textNode = first;
     listItemNodes = rest;
     return {
-      textNode: textNode,
-      listItemNodes: listItemNodes
+      textNode,
+      listItemNodes
     };
   }
   return {
-    textNode: textNode,
-    listItemNodes: listItemNodes
+    textNode,
+    listItemNodes
   };
 };
-export var insertFragmentList = function insertFragmentList(editor) {
-  var _insertFragment = editor.insertFragment;
-  return function (fragment) {
-    Editor.withoutNormalizing(editor, function () {
-      var liEntry = findNode(editor, {
+export const insertFragmentList = editor => {
+  const {
+    insertFragment: _insertFragment
+  } = editor;
+  return fragment => {
+    Editor.withoutNormalizing(editor, () => {
+      let liEntry = findNode(editor, {
         match: {
           type: LIST_ITEM
         },
         mode: 'lowest'
       });
       if (!liEntry) {
-        var nodes = isListRoot(fragment) ? [generateDefaultText()].concat(_toConsumableArray(fragment)) : fragment;
+        const nodes = isListRoot(fragment) ? [generateDefaultText(), ...fragment] : fragment;
         return _insertFragment(nodes);
       }
       Transforms.insertFragment(editor, [generateDefaultText()]); // need ' '
@@ -157,23 +142,22 @@ export var insertFragmentList = function insertFragmentList(editor) {
         },
         mode: 'lowest'
       });
-      var licEntry = findNode(editor, {
+      const licEntry = findNode(editor, {
         match: {
           type: PARAGRAPH
         },
         mode: 'lowest'
       });
       if (!licEntry) {
-        var _nodes = isListRoot(fragment) ? [generateDefaultText()].concat(_toConsumableArray(fragment)) : fragment;
-        return _insertFragment(_nodes);
+        const nodes = isListRoot(fragment) ? [generateDefaultText(), ...fragment] : fragment;
+        return _insertFragment(nodes);
       }
-      var _getTextAndListItemNo = getTextAndListItemNodes(editor, fragment, liEntry, licEntry),
-        textNode = _getTextAndListItemNo.textNode,
-        listItemNodes = _getTextAndListItemNo.listItemNodes;
+      const {
+        textNode,
+        listItemNodes
+      } = getTextAndListItemNodes(editor, fragment, liEntry, licEntry);
       Transforms.insertFragment(editor, [textNode]);
-      var _liEntry2 = liEntry,
-        _liEntry3 = _slicedToArray(_liEntry2, 2),
-        liPath = _liEntry3[1];
+      const [, liPath] = liEntry;
       return Transforms.insertNodes(editor, listItemNodes, {
         at: Path.next(liPath),
         select: true

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

@@ -1,31 +1,29 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { Element, Transforms, Path } from '@seafile/slate';
 import { LIST_ITEM } from '../../../constants';
 import { getChildren, getNode, getPreviousPath, match } from '../../../core';
 import { getListTypes } from '../queries';
 import { moveListItemsToList, normalizeListItem, normalizeNestedList } from '../transforms';
 import { generateEmptyListItem } from '../model';
-export var normalizeList = function normalizeList(editor) {
-  var normalizeNode = editor.normalizeNode;
-  return function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-      node = _ref2[0],
-      path = _ref2[1];
+export const normalizeList = editor => {
+  const {
+    normalizeNode
+  } = editor;
+  return _ref => {
+    let [node, path] = _ref;
     if (!Element.isElement(node)) {
       return normalizeNode([node, path]);
     }
-    var listTypes = getListTypes();
+    const listTypes = getListTypes();
 
     // root
     if (listTypes.includes(node.type)) {
-      var children = getChildren([node, path]);
-      var nonLiChild = children.find(function (_ref3) {
-        var _ref4 = _slicedToArray(_ref3, 1),
-          child = _ref4[0];
+      const children = getChildren([node, path]);
+      const nonLiChild = children.find(_ref2 => {
+        let [child] = _ref2;
         return child.type !== LIST_ITEM;
       });
       if (nonLiChild) {
-        var listItem = generateEmptyListItem();
+        const listItem = generateEmptyListItem();
         Transforms.wrapNodes(editor, listItem, {
           at: nonLiChild[1]
         });
@@ -35,16 +33,14 @@ export var normalizeList = function normalizeList(editor) {
     if (match(node, [], {
       type: listTypes
     })) {
-      if (!node.children.length || !node.children.find(function (item) {
-        return item.type === LIST_ITEM;
-      })) {
+      if (!node.children.length || !node.children.find(item => item.type === LIST_ITEM)) {
         Transforms.removeNodes(editor, {
           at: path
         });
         return;
       }
-      var nextPath = Path.next(path);
-      var nextNode = getNode(editor, nextPath);
+      const nextPath = Path.next(path);
+      const nextNode = getNode(editor, nextPath);
       if ((nextNode === null || nextNode === void 0 ? void 0 : nextNode.type) === node.type) {
         moveListItemsToList(editor, {
           fromList: [nextNode, nextPath],
@@ -52,8 +48,8 @@ export var normalizeList = function normalizeList(editor) {
           deleteFromList: true
         });
       }
-      var prevPath = getPreviousPath(path);
-      var prevNode = getNode(editor, prevPath);
+      const prevPath = getPreviousPath(path);
+      const prevNode = getNode(editor, prevPath);
       if ((prevNode === null || prevNode === void 0 ? void 0 : prevNode.type) === node.type) {
         editor.normalizeNode([prevNode, prevPath]);
         return;

package/dist/basic-sdk/extension/plugins/list/plugin/on-tab-handle.js

@@ -4,35 +4,40 @@ import { Editor, Range, Transforms } from '@seafile/slate';
 import { LIST_ITEM } from '../../../constants';
 import { findNode } from '../../../core';
 import { moveListItems } from '../transforms';
-export var onTabHandle = function onTabHandle(editor, event) {
-  var selection = editor.selection;
+export const onTabHandle = (editor, event) => {
+  const {
+    selection
+  } = editor;
   if (!selection) return;
-  var listSelected = findNode(editor, {
+  const listSelected = findNode(editor, {
     type: [LIST_ITEM]
   });
   if (!listSelected) return false;
-  var workRange = editor.selection;
+  let workRange = editor.selection;
   if (!Range.isCollapsed(selection)) {
-    var anchor = selection.anchor,
-      focus = selection.focus;
+    let {
+      anchor,
+      focus
+    } = selection;
     if (Range.isBackward(selection)) {
-      var _anchor$focus = {
+      ({
+        anchor,
+        focus
+      } = {
         anchor: _objectSpread({}, selection.focus),
         focus: _objectSpread({}, selection.anchor)
-      };
-      anchor = _anchor$focus.anchor;
-      focus = _anchor$focus.focus;
+      });
     }
-    var unHungRange = Editor.unhangRange(editor, {
-      anchor: anchor,
-      focus: focus
+    const unHungRange = Editor.unhangRange(editor, {
+      anchor,
+      focus
     });
     if (unHungRange) {
       workRange = unHungRange;
       Transforms.select(editor, unHungRange);
     }
   }
-  var increase = isHotkey('shift+tab', event) ? false : true;
+  const increase = isHotkey('shift+tab', event) ? false : true;
   if (workRange && listSelected) {
     event.preventDefault();
     moveListItems(editor, {

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

@@ -1,4 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { Editor, Path, Range, Transforms } from '@seafile/slate';
 import { ORDERED_LIST, PARAGRAPH } from '../../../constants';
 import { getBeforeText, setListType } from '../helpers';
@@ -10,30 +9,27 @@ import { generateEmptyListItem } from '../model';
  * @param {String} text
  * @returns {Boolean} isPreventInsert
  */
-export var handleShortcut = function handleShortcut(editor, text) {
+export const handleShortcut = (editor, text) => {
   if (text !== ' ') return false;
-  var selection = editor.selection;
+  const {
+    selection
+  } = editor;
   if (!Range.isCollapsed(selection)) return false;
-  var _Editor$above = Editor.above(editor),
-    _Editor$above2 = _slicedToArray(_Editor$above, 2),
-    aboveNode = _Editor$above2[0],
-    aboveNodePath = _Editor$above2[1];
-  var aboveNodeRef = Editor.pathRef(editor, aboveNodePath);
+  let [aboveNode, aboveNodePath] = Editor.above(editor);
+  const aboveNodeRef = Editor.pathRef(editor, aboveNodePath);
   if (aboveNode.type !== PARAGRAPH) return false;
   // Match ordered list shortcut
-  var regShortcut = /^\s*[1-9]+\.\s*$/;
-  var _getBeforeText = getBeforeText(editor),
-    beforeText = _getBeforeText.beforeText,
-    range = _getBeforeText.range;
-  var matchResult = beforeText.match(regShortcut);
-  var matchedText = matchResult && matchResult[0];
+  const regShortcut = /^\s*[1-9]+\.\s*$/;
+  const {
+    beforeText,
+    range
+  } = getBeforeText(editor);
+  const matchResult = beforeText.match(regShortcut);
+  const matchedText = matchResult && matchResult[0];
   // If the match fails or the match is not at the beginning of the line, it is not a shortcut
   if (!matchResult || matchResult.index !== 0) return false;
-  var previousNodePath = getPreviousPath(aboveNodePath);
-  var _Editor$node = Editor.node(editor, previousNodePath),
-    _Editor$node2 = _slicedToArray(_Editor$node, 2),
-    previousNode = _Editor$node2[0],
-    previousPath = _Editor$node2[1];
+  const previousNodePath = getPreviousPath(aboveNodePath);
+  const [previousNode, previousPath] = Editor.node(editor, previousNodePath);
   // If the previous node is not an ordered list and is not start with `1.`,it is not a shortcut
   if (previousNode.type !== ORDERED_LIST && matchedText !== '1.') return false;
   // If the previous node is not an ordered list and is start with `1.`,transforms to ordered list
@@ -47,7 +43,7 @@ export var handleShortcut = function handleShortcut(editor, text) {
     return;
   }
   // Record the order number of the shortcut that will be inserted as a list item
-  var shortcutOrderNum = parseInt(matchResult[0].slice(0, -1));
+  const shortcutOrderNum = parseInt(matchResult[0].slice(0, -1));
 
   // Check If order number is continuous
   if (previousNode.children.length + 1 !== shortcutOrderNum) return false;
@@ -57,15 +53,11 @@ export var handleShortcut = function handleShortcut(editor, text) {
     at: range
   });
   // Update aboveNode after delete shortcut text
-  var _Editor$above3 = Editor.above(editor);
-  var _Editor$above4 = _slicedToArray(_Editor$above3, 1);
-  aboveNode = _Editor$above4[0];
-  var _getLastChild = getLastChild([previousNode, previousPath]),
-    _getLastChild2 = _slicedToArray(_getLastChild, 2),
-    lastListItemPath = _getLastChild2[1];
-  var targetInsertPath = Path.next(lastListItemPath);
+  [aboveNode] = Editor.above(editor);
+  const [, lastListItemPath] = getLastChild([previousNode, previousPath]);
+  const targetInsertPath = Path.next(lastListItemPath);
   // Wrap the paragraph in a list item
-  var insertedListItem = generateEmptyListItem();
+  const insertedListItem = generateEmptyListItem();
   insertedListItem.children.push(aboveNode);
   Transforms.insertNodes(editor, insertedListItem, {
     at: targetInsertPath

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

@@ -1,13 +1,13 @@
 import { Editor, Element, Range, Node } from '@seafile/slate';
 import { LIST_ITEM, ORDERED_LIST, UNORDERED_LIST } from '../../../constants';
-export var getListTypes = function getListTypes() {
+export const getListTypes = () => {
   return [ORDERED_LIST, UNORDERED_LIST];
 };
-export var getListItemEntry = function getListItemEntry(editor) {
-  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-    _ref$at = _ref.at,
-    at = _ref$at === void 0 ? editor.selection : _ref$at;
-  var _at = null;
+export const getListItemEntry = function (editor) {
+  let {
+    at = editor.selection
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let _at = null;
   if (Range.isRange(at) && !Range.isCollapsed(at)) {
     _at = at.focus.path;
   } else if (Range.isRange(at)) {
@@ -16,32 +16,30 @@ export var getListItemEntry = function getListItemEntry(editor) {
     _at = at;
   }
   if (_at) {
-    var node = Node.get(editor, _at);
+    const node = Node.get(editor, _at);
     if (node) {
-      var listItem = Editor.above(editor, {
+      const listItem = Editor.above(editor, {
         at: _at,
-        match: function match(n) {
-          return Element.isElement(n) && n.type === LIST_ITEM;
-        }
+        match: n => Element.isElement(n) && n.type === LIST_ITEM
       });
       if (listItem) {
-        var list = Editor.parent(editor, listItem[1]);
+        const list = Editor.parent(editor, listItem[1]);
         return {
-          list: list,
-          listItem: listItem
+          list,
+          listItem
         };
       }
     }
   }
   return null;
 };
-export var hasListChild = function hasListChild(node) {
-  return node.children.some(function (n) {
+export const hasListChild = node => {
+  return node.children.some(n => {
     return Element.isElement(n) && getListTypes().includes(n.type);
   });
 };
-export var isListNested = function isListNested(editor, listPath) {
+export const isListNested = (editor, listPath) => {
   var _Editor$parent;
-  var listParentNode = (_Editor$parent = Editor.parent(editor, listPath)) === null || _Editor$parent === void 0 ? void 0 : _Editor$parent[0];
+  const listParentNode = (_Editor$parent = Editor.parent(editor, listPath)) === null || _Editor$parent === void 0 ? void 0 : _Editor$parent[0];
   return (listParentNode === null || listParentNode === void 0 ? void 0 : listParentNode.type) === LIST_ITEM;
 };

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

@@ -1,22 +1,28 @@
 import React from 'react';
 import { ORDERED_LIST } from '../../constants';
-var renderList = function renderList(props, editor) {
-  var attributes = props.attributes,
-    children = props.children,
-    node = props.element;
-  var Tag = node.type === ORDERED_LIST ? 'ol' : 'ul';
+const renderList = (props, editor) => {
+  const {
+    attributes,
+    children,
+    element: node
+  } = props;
+  const Tag = node.type === ORDERED_LIST ? 'ol' : 'ul';
   return /*#__PURE__*/React.createElement(Tag, Object.assign({
     "data-id": node.id,
     "data-root": "true",
     className: "list-container d-flex flex-column"
   }, attributes), children);
 };
-var renderListItem = function renderListItem(props, editor) {
-  var attributes = props.attributes,
-    children = props.children,
-    element = props.element;
-  var align = element.children[0].align;
-  var className = '';
+const renderListItem = (props, editor) => {
+  const {
+    attributes,
+    children,
+    element
+  } = props;
+  const {
+    align
+  } = element.children[0];
+  let className = '';
   switch (align) {
     case 'center':
       className = 'align-self-center';
@@ -34,10 +40,12 @@ var renderListItem = function renderListItem(props, editor) {
     className: className
   }), children);
 };
-var renderListLic = function renderListLic(props, editor) {
-  var attributes = props.attributes,
-    children = props.children,
-    element = props.element;
+const renderListLic = (props, editor) => {
+  const {
+    attributes,
+    children,
+    element
+  } = props;
   return /*#__PURE__*/React.createElement("div", Object.assign({
     "data-id": element.id,
     "data-root": "true"

package/dist/basic-sdk/extension/plugins/list/transforms/insert-list-item.js

@@ -1,28 +1,24 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { Transforms, Editor, Path, Range } from '@seafile/slate';
 import { LIST_ITEM, PARAGRAPH } from '../../../constants';
 import { getAboveNode, isBlockTextEmptyAfterSelection, isStartPoint } from '../../../core';
 import { generateEmptyListContent, generateEmptyListItem } from '../model';
 
 // list > list_item > paragraph
-export var insertListItem = function insertListItem(editor) {
-  var paragraphEntry = getAboveNode(editor, {
+export const insertListItem = editor => {
+  const paragraphEntry = getAboveNode(editor, {
     match: {
       type: PARAGRAPH
     }
   });
   if (!paragraphEntry) return false;
-  var _paragraphEntry = _slicedToArray(paragraphEntry, 2),
-    paragraphPath = _paragraphEntry[1];
-  var listItemEntry = Editor.parent(editor, paragraphPath);
+  const [, paragraphPath] = paragraphEntry;
+  const listItemEntry = Editor.parent(editor, paragraphPath);
   if (!listItemEntry) return false;
-  var _listItemEntry = _slicedToArray(listItemEntry, 2),
-    listItemNode = _listItemEntry[0],
-    listItemPath = _listItemEntry[1];
+  const [listItemNode, listItemPath] = listItemEntry;
   if (listItemNode.type !== LIST_ITEM) return false;
-  var success = false;
-  Editor.withoutNormalizing(editor, function () {
+  let success = false;
+  Editor.withoutNormalizing(editor, () => {
     var _editor$selection;
     if (!Range.isCollapsed(editor.selection)) {
       // 删除选中的内容
@@ -30,17 +26,17 @@ export var insertListItem = function insertListItem(editor) {
         at: editor.selection
       });
     }
-    var _isStartPoint = isStartPoint(editor, (_editor$selection = editor.selection) === null || _editor$selection === void 0 ? void 0 : _editor$selection.focus, paragraphPath);
-    var isEndPoint = isBlockTextEmptyAfterSelection(editor);
-    var nextParagraphPath = Path.next(paragraphPath);
-    var nextListItemPath = Path.next(listItemPath);
+    const _isStartPoint = isStartPoint(editor, (_editor$selection = editor.selection) === null || _editor$selection === void 0 ? void 0 : _editor$selection.focus, paragraphPath);
+    const isEndPoint = isBlockTextEmptyAfterSelection(editor);
+    const nextParagraphPath = Path.next(paragraphPath);
+    const nextListItemPath = Path.next(listItemPath);
     if (_isStartPoint) {
       // listItem 有内容，光标在开始
-      var itemContent = generateEmptyListContent();
+      const itemContent = generateEmptyListContent();
       Transforms.insertNodes(editor, itemContent, {
         at: listItemPath
       });
-      var listItem = generateEmptyListItem();
+      const listItem = generateEmptyListItem();
       Transforms.wrapNodes(editor, listItem, {
         at: listItemPath
       });
@@ -50,8 +46,8 @@ export var insertListItem = function insertListItem(editor) {
     if (!isEndPoint) {
       // listItem 有内容，光标在中间
       Transforms.splitNodes(editor);
-      var _listItem = generateEmptyListItem();
-      Transforms.wrapNodes(editor, _listItem, {
+      const listItem = generateEmptyListItem();
+      Transforms.wrapNodes(editor, listItem, {
         at: nextParagraphPath
       });
       Transforms.moveNodes(editor, {
@@ -66,13 +62,13 @@ export var insertListItem = function insertListItem(editor) {
     } else {
       var _Editor$marks;
       // listItem 有内容，光标在结尾
-      var marks = (_Editor$marks = Editor.marks(editor)) === null || _Editor$marks === void 0 ? void 0 : _Editor$marks.key;
-      var _itemContent = generateEmptyListContent();
-      Transforms.insertNodes(editor, _objectSpread(_objectSpread({}, _itemContent), marks), {
+      const marks = (_Editor$marks = Editor.marks(editor)) === null || _Editor$marks === void 0 ? void 0 : _Editor$marks.key;
+      const itemContent = generateEmptyListContent();
+      Transforms.insertNodes(editor, _objectSpread(_objectSpread({}, itemContent), marks), {
         at: nextListItemPath
       });
-      var _listItem2 = generateEmptyListItem();
-      Transforms.wrapNodes(editor, _listItem2, {
+      const listItem = generateEmptyListItem();
+      Transforms.wrapNodes(editor, listItem, {
         at: nextListItemPath
       });
       Transforms.select(editor, nextListItemPath);