@seafile/sdoc-editor 1.0.54 → 1.0.56

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

@@ -1,67 +1,73 @@
-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 const normalizeList = editor => {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeList = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _queries = require("../queries");
+var _transforms = require("../transforms");
+var _model = require("../model");
+const normalizeList = editor => {
   const {
     normalizeNode
   } = editor;
   return _ref => {
     let [node, path] = _ref;
-    if (!Element.isElement(node)) {
+    if (!_slate.Element.isElement(node)) {
       return normalizeNode([node, path]);
     }
-    const listTypes = getListTypes();
+    const listTypes = (0, _queries.getListTypes)();
 
     // root
     if (listTypes.includes(node.type)) {
-      const children = getChildren([node, path]);
+      const children = (0, _core.getChildren)([node, path]);
       const nonLiChild = children.find(_ref2 => {
         let [child] = _ref2;
-        return child.type !== LIST_ITEM;
+        return child.type !== _constants.LIST_ITEM;
       });
       if (nonLiChild) {
-        const listItem = generateEmptyListItem();
-        Transforms.wrapNodes(editor, listItem, {
+        const listItem = (0, _model.generateEmptyListItem)();
+        _slate.Transforms.wrapNodes(editor, listItem, {
           at: nonLiChild[1]
         });
         return;
       }
     }
-    if (match(node, [], {
+    if ((0, _core.match)(node, [], {
       type: listTypes
     })) {
-      if (!node.children.length || !node.children.find(item => item.type === LIST_ITEM)) {
-        Transforms.removeNodes(editor, {
+      if (!node.children.length || !node.children.find(item => item.type === _constants.LIST_ITEM)) {
+        _slate.Transforms.removeNodes(editor, {
           at: path
         });
         return;
       }
-      const nextPath = Path.next(path);
-      const nextNode = getNode(editor, nextPath);
+      const nextPath = _slate.Path.next(path);
+      const nextNode = (0, _core.getNode)(editor, nextPath);
       if ((nextNode === null || nextNode === void 0 ? void 0 : nextNode.type) === node.type) {
-        moveListItemsToList(editor, {
+        (0, _transforms.moveListItemsToList)(editor, {
           fromList: [nextNode, nextPath],
           toList: [node, path],
           deleteFromList: true
         });
       }
-      const prevPath = getPreviousPath(path);
-      const prevNode = getNode(editor, prevPath);
+      const prevPath = (0, _core.getPreviousPath)(path);
+      const prevNode = (0, _core.getNode)(editor, prevPath);
       if ((prevNode === null || prevNode === void 0 ? void 0 : prevNode.type) === node.type) {
         editor.normalizeNode([prevNode, prevPath]);
         return;
       }
-      if (normalizeNestedList(editor, {
+      if ((0, _transforms.normalizeNestedList)(editor, {
         nestedListItem: [node, path]
       })) {
         return;
       }
     }
-    if (node.type === LIST_ITEM) {
-      if (normalizeListItem(editor, {
+    if (node.type === _constants.LIST_ITEM) {
+      if ((0, _transforms.normalizeListItem)(editor, {
         listItem: [node, path]
       })) {
         return;
@@ -69,4 +75,5 @@ export const normalizeList = editor => {
     }
     normalizeNode([node, path]);
   };
-};
+};
+exports.normalizeList = normalizeList;

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

@@ -1,24 +1,31 @@
-import isHotkey from 'is-hotkey';
-import { Editor, Range, Transforms } from '@seafile/slate';
-import { LIST_ITEM } from '../../../constants';
-import { findNode } from '../../../core';
-import { moveListItems } from '../transforms';
-export const onTabHandle = (editor, event) => {
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onTabHandle = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _transforms = require("../transforms");
+const onTabHandle = (editor, event) => {
   const {
     selection
   } = editor;
   if (!selection) return;
-  const listSelected = findNode(editor, {
-    type: [LIST_ITEM]
+  const listSelected = (0, _core.findNode)(editor, {
+    type: [_constants.LIST_ITEM]
   });
   if (!listSelected) return false;
   let workRange = editor.selection;
-  if (!Range.isCollapsed(selection)) {
+  if (!_slate.Range.isCollapsed(selection)) {
     let {
       anchor,
       focus
     } = selection;
-    if (Range.isBackward(selection)) {
+    if (_slate.Range.isBackward(selection)) {
       ({
         anchor,
         focus
@@ -31,23 +38,24 @@ export const onTabHandle = (editor, event) => {
         }
       });
     }
-    const unHungRange = Editor.unhangRange(editor, {
+    const unHungRange = _slate.Editor.unhangRange(editor, {
       anchor,
       focus
     });
     if (unHungRange) {
       workRange = unHungRange;
-      Transforms.select(editor, unHungRange);
+      _slate.Transforms.select(editor, unHungRange);
     }
   }
-  const increase = isHotkey('shift+tab', event) ? false : true;
+  const increase = (0, _isHotkey.default)('shift+tab', event) ? false : true;
   if (workRange && listSelected) {
     event.preventDefault();
-    moveListItems(editor, {
+    (0, _transforms.moveListItems)(editor, {
       at: workRange,
       increase: increase,
       enableResetOnShiftTab: true
     });
     return true;
   }
-};
+};
+exports.onTabHandle = onTabHandle;

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

@@ -1,57 +1,62 @@
-import { Editor, Path, Range, Transforms } from '@seafile/slate';
-import { ORDERED_LIST, PARAGRAPH } from '../../../constants';
-import { getBeforeText, setListType } from '../helpers';
-import { focusEditor, getLastChild, getPreviousPath } from '../../../core';
-import { generateEmptyListItem } from '../model';
-import { toggleList } from '../transforms';
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleShortcut = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _helpers = require("../helpers");
+var _core = require("../../../core");
+var _model = require("../model");
+var _transforms = require("../transforms");
 /**
  * @param {Editor} editor
  * @param {String} text
  * @returns {Boolean} isPreventInsert
  */
-export const handleShortcut = (editor, text) => {
+const handleShortcut = (editor, text) => {
   if (text !== ' ') return false;
   const {
     selection
   } = editor;
-  if (!Range.isCollapsed(selection)) return false;
-  let [aboveNode, aboveNodePath] = Editor.above(editor);
-  const aboveNodeRef = Editor.pathRef(editor, aboveNodePath);
-  if (aboveNode.type !== PARAGRAPH) return false;
+  if (!_slate.Range.isCollapsed(selection)) return false;
+  let [aboveNode, aboveNodePath] = _slate.Editor.above(editor);
+  const aboveNodeRef = _slate.Editor.pathRef(editor, aboveNodePath);
+  if (aboveNode.type !== _constants.PARAGRAPH) return false;
   // Match ordered list shortcut
   const regShortcut = /^\s*[1-9]+\.\s*$/;
   const {
     beforeText,
     range
-  } = getBeforeText(editor);
+  } = (0, _helpers.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;
-  const previousNodePath = getPreviousPath(aboveNodePath);
+  const previousNodePath = (0, _core.getPreviousPath)(aboveNodePath);
 
   // No previous node means that the current paragraph is the first paragraph in the container
   if (!previousNodePath) {
     if (matchedText !== '1.') return false;
     // Delete shortcut key text
-    Transforms.delete(editor, {
+    _slate.Transforms.delete(editor, {
       at: range
     });
-    toggleList(editor, ORDERED_LIST);
+    (0, _transforms.toggleList)(editor, _constants.ORDERED_LIST);
     return true;
   }
-  const [previousNode, previousPath] = Editor.node(editor, previousNodePath);
+  const [previousNode, previousPath] = _slate.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 (previousNode.type !== _constants.ORDERED_LIST && matchedText !== '1.') return false;
   // If the previous node is not an ordered list and is start with `1.`,transforms to ordered list
-  if (previousNode.type !== ORDERED_LIST && matchedText === '1.') {
+  if (previousNode.type !== _constants.ORDERED_LIST && matchedText === '1.') {
     // Delete shortcut key text
-    Transforms.delete(editor, {
+    _slate.Transforms.delete(editor, {
       at: range
     });
-    setListType(editor, ORDERED_LIST);
-    focusEditor(editor);
+    (0, _helpers.setListType)(editor, _constants.ORDERED_LIST);
+    (0, _core.focusEditor)(editor);
     return true;
   }
   // Record the order number of the shortcut that will be inserted as a list item
@@ -61,23 +66,24 @@ export const handleShortcut = (editor, text) => {
   if (previousNode.children.length + 1 !== shortcutOrderNum) return false;
 
   // Delete shortcut key text
-  Transforms.delete(editor, {
+  _slate.Transforms.delete(editor, {
     at: range
   });
   // Update aboveNode after delete shortcut text
-  [aboveNode] = Editor.above(editor);
-  const [, lastListItemPath] = getLastChild([previousNode, previousPath]);
-  const targetInsertPath = Path.next(lastListItemPath);
+  [aboveNode] = _slate.Editor.above(editor);
+  const [, lastListItemPath] = (0, _core.getLastChild)([previousNode, previousPath]);
+  const targetInsertPath = _slate.Path.next(lastListItemPath);
   // Wrap the paragraph in a list item
-  const insertedListItem = generateEmptyListItem();
+  const insertedListItem = (0, _model.generateEmptyListItem)();
   insertedListItem.children.push(aboveNode);
-  Transforms.insertNodes(editor, insertedListItem, {
+  _slate.Transforms.insertNodes(editor, insertedListItem, {
     at: targetInsertPath
   });
-  Transforms.removeNodes(editor, {
+  _slate.Transforms.removeNodes(editor, {
     at: aboveNodeRef.unref()
   });
   // Set the selection to the end of the inserted list item
-  Transforms.select(editor, Editor.end(editor, targetInsertPath));
+  _slate.Transforms.select(editor, _slate.Editor.end(editor, targetInsertPath));
   return true;
-};
+};
+exports.handleShortcut = handleShortcut;

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

@@ -1,29 +1,36 @@
-import { Editor, Element, Range, Node } from '@seafile/slate';
-import { LIST_ITEM, ORDERED_LIST, UNORDERED_LIST } from '../../../constants';
-export const getListTypes = () => {
-  return [ORDERED_LIST, UNORDERED_LIST];
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isListNested = exports.hasListChild = exports.getListTypes = exports.getListItemEntry = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+const getListTypes = () => {
+  return [_constants.ORDERED_LIST, _constants.UNORDERED_LIST];
 };
-export const getListItemEntry = function (editor) {
+exports.getListTypes = getListTypes;
+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)) {
+  if (_slate.Range.isRange(at) && !_slate.Range.isCollapsed(at)) {
     _at = at.focus.path;
-  } else if (Range.isRange(at)) {
+  } else if (_slate.Range.isRange(at)) {
     _at = at.anchor.path;
   } else {
     _at = at;
   }
   if (_at) {
-    const node = Node.get(editor, _at);
+    const node = _slate.Node.get(editor, _at);
     if (node) {
-      const listItem = Editor.above(editor, {
+      const listItem = _slate.Editor.above(editor, {
         at: _at,
-        match: n => Element.isElement(n) && n.type === LIST_ITEM
+        match: n => _slate.Element.isElement(n) && n.type === _constants.LIST_ITEM
       });
       if (listItem) {
-        const list = Editor.parent(editor, listItem[1]);
+        const list = _slate.Editor.parent(editor, listItem[1]);
         return {
           list,
           listItem
@@ -33,13 +40,16 @@ export const getListItemEntry = function (editor) {
   }
   return null;
 };
-export const hasListChild = node => {
+exports.getListItemEntry = getListItemEntry;
+const hasListChild = node => {
   return node.children.some(n => {
-    return Element.isElement(n) && getListTypes().includes(n.type);
+    return _slate.Element.isElement(n) && getListTypes().includes(n.type);
   });
 };
-export const isListNested = (editor, listPath) => {
+exports.hasListChild = hasListChild;
+const isListNested = (editor, listPath) => {
   var _Editor$parent;
-  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;
-};
+  const listParentNode = (_Editor$parent = _slate.Editor.parent(editor, listPath)) === null || _Editor$parent === void 0 ? void 0 : _Editor$parent[0];
+  return (listParentNode === null || listParentNode === void 0 ? void 0 : listParentNode.type) === _constants.LIST_ITEM;
+};
+exports.isListNested = isListNested;

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

@@ -1,18 +1,26 @@
-import React from 'react';
-import classnames from 'classnames';
-import { ORDERED_LIST } from '../../constants';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderListLic = exports.renderListItem = exports.renderList = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _constants = require("../../constants");
 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({
+  const Tag = node.type === _constants.ORDERED_LIST ? 'ol' : 'ul';
+  return /*#__PURE__*/_react.default.createElement(Tag, Object.assign({
     "data-id": node.id,
     className: "list-container d-flex flex-column"
   }, attributes), children);
 };
+exports.renderList = renderList;
 const renderListItem = (props, editor) => {
   const {
     attributes,
@@ -34,22 +42,23 @@ const renderListItem = (props, editor) => {
       className = '';
   }
   const isBold = element.children[0].children.every(item => item.bold === true);
-  return /*#__PURE__*/React.createElement("li", Object.assign({
+  return /*#__PURE__*/_react.default.createElement("li", Object.assign({
     "data-id": element.id
   }, attributes, {
-    className: classnames(className, {
+    className: (0, _classnames.default)(className, {
       'sdoc-li-bold': isBold
     })
   }), children);
 };
+exports.renderListItem = renderListItem;
 const renderListLic = (props, editor) => {
   const {
     attributes,
     children,
     element
   } = props;
-  return /*#__PURE__*/React.createElement("div", Object.assign({
+  return /*#__PURE__*/_react.default.createElement("div", Object.assign({
     "data-id": element.id
   }, attributes), children);
 };
-export { renderList, renderListItem, renderListLic };
+exports.renderListLic = renderListLic;

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

@@ -1,11 +1,76 @@
-import { insertListItem } from './insert-list-item';
-import { movedListItemDown } from './move-list-item-down';
-import { movedListItemUp } from './move-list-item-up';
-import { moveListItemsToList } from './move-list-items-to-list';
-import { moveListItems } from './move-list-items';
-import { removeFirstListItem } from './remove-first-list-item';
-import { unwrapList } from './unwrap-list';
-import { normalizeNestedList } from './normalize-nested-list';
-import { normalizeListItem } from './normalize-list-item';
-import toggleList from './toggle-list';
-export { toggleList, unwrapList, insertListItem, movedListItemDown, movedListItemUp, moveListItemsToList, moveListItems, removeFirstListItem, normalizeNestedList, normalizeListItem };
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "insertListItem", {
+  enumerable: true,
+  get: function () {
+    return _insertListItem.insertListItem;
+  }
+});
+Object.defineProperty(exports, "moveListItems", {
+  enumerable: true,
+  get: function () {
+    return _moveListItems.moveListItems;
+  }
+});
+Object.defineProperty(exports, "moveListItemsToList", {
+  enumerable: true,
+  get: function () {
+    return _moveListItemsToList.moveListItemsToList;
+  }
+});
+Object.defineProperty(exports, "movedListItemDown", {
+  enumerable: true,
+  get: function () {
+    return _moveListItemDown.movedListItemDown;
+  }
+});
+Object.defineProperty(exports, "movedListItemUp", {
+  enumerable: true,
+  get: function () {
+    return _moveListItemUp.movedListItemUp;
+  }
+});
+Object.defineProperty(exports, "normalizeListItem", {
+  enumerable: true,
+  get: function () {
+    return _normalizeListItem.normalizeListItem;
+  }
+});
+Object.defineProperty(exports, "normalizeNestedList", {
+  enumerable: true,
+  get: function () {
+    return _normalizeNestedList.normalizeNestedList;
+  }
+});
+Object.defineProperty(exports, "removeFirstListItem", {
+  enumerable: true,
+  get: function () {
+    return _removeFirstListItem.removeFirstListItem;
+  }
+});
+Object.defineProperty(exports, "toggleList", {
+  enumerable: true,
+  get: function () {
+    return _toggleList.default;
+  }
+});
+Object.defineProperty(exports, "unwrapList", {
+  enumerable: true,
+  get: function () {
+    return _unwrapList.unwrapList;
+  }
+});
+var _insertListItem = require("./insert-list-item");
+var _moveListItemDown = require("./move-list-item-down");
+var _moveListItemUp = require("./move-list-item-up");
+var _moveListItemsToList = require("./move-list-items-to-list");
+var _moveListItems = require("./move-list-items");
+var _removeFirstListItem = require("./remove-first-list-item");
+var _unwrapList = require("./unwrap-list");
+var _normalizeNestedList = require("./normalize-nested-list");
+var _normalizeListItem = require("./normalize-list-item");
+var _toggleList = _interopRequireDefault(require("./toggle-list"));

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

@@ -1,42 +1,47 @@
-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';
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertListItem = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _model = require("../model");
 // list > list_item > paragraph
-export const insertListItem = editor => {
-  const paragraphEntry = getAboveNode(editor, {
+const insertListItem = editor => {
+  const paragraphEntry = (0, _core.getAboveNode)(editor, {
     match: {
-      type: PARAGRAPH
+      type: _constants.PARAGRAPH
     }
   });
   if (!paragraphEntry) return false;
   const [, paragraphPath] = paragraphEntry;
-  const listItemEntry = Editor.parent(editor, paragraphPath);
+  const listItemEntry = _slate.Editor.parent(editor, paragraphPath);
   if (!listItemEntry) return false;
   const [listItemNode, listItemPath] = listItemEntry;
-  if (listItemNode.type !== LIST_ITEM) return false;
+  if (listItemNode.type !== _constants.LIST_ITEM) return false;
   let success = false;
-  Editor.withoutNormalizing(editor, () => {
+  _slate.Editor.withoutNormalizing(editor, () => {
     var _editor$selection;
-    if (!Range.isCollapsed(editor.selection)) {
+    if (!_slate.Range.isCollapsed(editor.selection)) {
       // 删除选中的内容
-      Transforms.delete(editor, {
+      _slate.Transforms.delete(editor, {
         at: editor.selection
       });
     }
-    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);
+    const _isStartPoint = (0, _core.isStartPoint)(editor, (_editor$selection = editor.selection) === null || _editor$selection === void 0 ? void 0 : _editor$selection.focus, paragraphPath);
+    const isEndPoint = (0, _core.isBlockTextEmptyAfterSelection)(editor);
+    const nextParagraphPath = _slate.Path.next(paragraphPath);
+    const nextListItemPath = _slate.Path.next(listItemPath);
     if (_isStartPoint) {
       // listItem 有内容，光标在开始
-      const itemContent = generateEmptyListContent();
-      Transforms.insertNodes(editor, itemContent, {
+      const itemContent = (0, _model.generateEmptyListContent)();
+      _slate.Transforms.insertNodes(editor, itemContent, {
         at: listItemPath
       });
-      const listItem = generateEmptyListItem();
-      Transforms.wrapNodes(editor, listItem, {
+      const listItem = (0, _model.generateEmptyListItem)();
+      _slate.Transforms.wrapNodes(editor, listItem, {
         at: listItemPath
       });
       success = true;
@@ -44,40 +49,40 @@ export const insertListItem = editor => {
     }
     if (!isEndPoint) {
       // listItem 有内容，光标在中间
-      Transforms.splitNodes(editor);
-      const listItem = generateEmptyListItem();
-      Transforms.wrapNodes(editor, listItem, {
+      _slate.Transforms.splitNodes(editor);
+      const listItem = (0, _model.generateEmptyListItem)();
+      _slate.Transforms.wrapNodes(editor, listItem, {
         at: nextParagraphPath
       });
-      Transforms.moveNodes(editor, {
+      _slate.Transforms.moveNodes(editor, {
         at: nextParagraphPath,
         to: nextListItemPath
       });
-      Transforms.select(editor, nextListItemPath);
-      Transforms.collapse(editor, {
+      _slate.Transforms.select(editor, nextListItemPath);
+      _slate.Transforms.collapse(editor, {
         edge: 'start'
       });
       success = true;
     } else {
       var _Editor$marks;
       // listItem 有内容，光标在结尾
-      const marks = (_Editor$marks = Editor.marks(editor)) === null || _Editor$marks === void 0 ? void 0 : _Editor$marks.key;
-      const itemContent = generateEmptyListContent();
-      Transforms.insertNodes(editor, {
+      const marks = (_Editor$marks = _slate.Editor.marks(editor)) === null || _Editor$marks === void 0 ? void 0 : _Editor$marks.key;
+      const itemContent = (0, _model.generateEmptyListContent)();
+      _slate.Transforms.insertNodes(editor, {
         ...itemContent,
         ...marks
       }, {
         at: nextListItemPath
       });
-      const listItem = generateEmptyListItem();
-      Transforms.wrapNodes(editor, listItem, {
+      const listItem = (0, _model.generateEmptyListItem)();
+      _slate.Transforms.wrapNodes(editor, listItem, {
         at: nextListItemPath
       });
-      Transforms.select(editor, nextListItemPath);
+      _slate.Transforms.select(editor, nextListItemPath);
       success = true;
     }
     if (listItemNode.children.length > 1) {
-      Transforms.moveNodes(editor, {
+      _slate.Transforms.moveNodes(editor, {
         at: nextParagraphPath,
         to: nextListItemPath.concat(1)
       });
@@ -85,4 +90,5 @@ export const insertListItem = editor => {
     }
   });
   return success;
-};
+};
+exports.insertListItem = insertListItem;