@seafile/sdoc-editor 1.0.54 → 1.0.55

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

@@ -1,38 +1,45 @@
-import { Editor, Element, Node, Range, Text } from '@seafile/slate';
-import { CHECK_LIST_ITEM, CODE_BLOCK, CODE_LINE, LIST_ITEM, PARAGRAPH, TABLE } from '../../constants';
-import { toggleList } from './transforms';
-import { getListTypes } from './queries';
-export const isMenuDisabled = (editor, readonly) => {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setListType = exports.isMenuDisabled = exports.getListType = exports.getBeforeText = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../constants");
+var _transforms = require("./transforms");
+var _queries = require("./queries");
+const isMenuDisabled = (editor, readonly) => {
   if (readonly) return true;
   if (editor.selection == null) return true;
   let selectedElements = [];
-  const nodeEntries = Editor.nodes(editor, {
+  const nodeEntries = _slate.Editor.nodes(editor, {
     universal: true
   });
   for (let nodeEntry of nodeEntries) {
     const [node] = nodeEntry;
-    if (Element.isElement(node)) selectedElements.push(node);
+    if (_slate.Element.isElement(node)) selectedElements.push(node);
   }
   const notMatch = selectedElements.some(element => {
-    if (Editor.isVoid(editor, element) && Editor.isBlock(editor, element)) return true;
+    if (_slate.Editor.isVoid(editor, element) && _slate.Editor.isBlock(editor, element)) return true;
     const {
       type
     } = element;
-    if ([CODE_LINE, CODE_BLOCK, TABLE, CHECK_LIST_ITEM].includes(type)) return true;
+    if ([_constants.CODE_LINE, _constants.CODE_BLOCK, _constants.TABLE, _constants.CHECK_LIST_ITEM].includes(type)) return true;
     return false;
   });
   if (notMatch) return true;
   return false;
 };
-export const getListType = (editor, type) => {
+exports.isMenuDisabled = isMenuDisabled;
+const getListType = (editor, type) => {
   const {
     selection
   } = editor;
   if (!selection) return;
   let selectedListNodeEntry;
-  if (Range.isCollapsed(selection)) {
-    const [nodeEntry] = Editor.nodes(editor, {
-      match: node => getListTypes().includes(node.type),
+  if (_slate.Range.isCollapsed(selection)) {
+    const [nodeEntry] = _slate.Editor.nodes(editor, {
+      match: node => (0, _queries.getListTypes)().includes(node.type),
       mode: 'lowest'
     });
     selectedListNodeEntry = nodeEntry;
@@ -41,33 +48,35 @@ export const getListType = (editor, type) => {
       anchor,
       focus
     } = selection;
-    const commonNodeEntry = Node.common(editor, anchor.path, focus.path);
+    const commonNodeEntry = _slate.Node.common(editor, anchor.path, focus.path);
     //  Select condition:
     // 1. Select in one list
     // 2. Select in one list item
     // 3. Select in one line
-    if (getListTypes().includes(commonNodeEntry[0].type)) {
+    if ((0, _queries.getListTypes)().includes(commonNodeEntry[0].type)) {
       // Select in one list
       selectedListNodeEntry = commonNodeEntry;
-    } else if (commonNodeEntry[0].type === LIST_ITEM) {
+    } else if (commonNodeEntry[0].type === _constants.LIST_ITEM) {
       // Select in one list item
-      selectedListNodeEntry = Editor.parent(editor, commonNodeEntry[1]);
-    } else if (Text.isText(commonNodeEntry[0])) {
+      selectedListNodeEntry = _slate.Editor.parent(editor, commonNodeEntry[1]);
+    } else if (_slate.Text.isText(commonNodeEntry[0])) {
       // Select in one line
-      const [nodeEntry] = Editor.nodes(editor, {
+      const [nodeEntry] = _slate.Editor.nodes(editor, {
         at: commonNodeEntry[1],
-        match: node => getListTypes().includes(node.type),
+        match: node => (0, _queries.getListTypes)().includes(node.type),
         mode: 'lowest'
       });
       selectedListNodeEntry = nodeEntry;
     }
   }
-  return selectedListNodeEntry ? selectedListNodeEntry[0].type : PARAGRAPH;
+  return selectedListNodeEntry ? selectedListNodeEntry[0].type : _constants.PARAGRAPH;
 };
-export const setListType = (editor, type) => {
-  toggleList(editor, type);
+exports.getListType = getListType;
+const setListType = (editor, type) => {
+  (0, _transforms.toggleList)(editor, type);
 };
-export const getBeforeText = editor => {
+exports.setListType = setListType;
+const getBeforeText = editor => {
   const {
     selection
   } = editor;
@@ -79,15 +88,16 @@ export const getBeforeText = editor => {
     anchor
   } = selection;
   // Find the near text node above the current text
-  const [, aboveNodePath] = Editor.above(editor);
-  const aboveNodeStartPoint = Editor.start(editor, aboveNodePath); // The starting position of the text node
+  const [, aboveNodePath] = _slate.Editor.above(editor);
+  const aboveNodeStartPoint = _slate.Editor.start(editor, aboveNodePath); // The starting position of the text node
   const range = {
     anchor,
     focus: aboveNodeStartPoint
   };
-  const beforeText = Editor.string(editor, range) || '';
+  const beforeText = _slate.Editor.string(editor, range) || '';
   return {
     beforeText,
     range
   };
-};
+};
+exports.getBeforeText = getBeforeText;

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

@@ -1,11 +1,18 @@
-import ListMenu from './menu';
-import withList from './plugin';
-import { renderList, renderListItem, renderListLic } from './render-elem';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _menu = _interopRequireDefault(require("./menu"));
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = require("./render-elem");
 const ListPlugin = {
   type: 'list',
   nodeType: 'element',
-  editorMenus: [ListMenu],
-  editorPlugin: withList,
-  renderElements: [renderList, renderListItem, renderListLic]
+  editorMenus: [_menu.default],
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.renderList, _renderElem.renderListItem, _renderElem.renderListLic]
 };
-export default ListPlugin;
+var _default = exports.default = ListPlugin;

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

@@ -1,27 +1,34 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import React from 'react';
-import { MENUS_CONFIG_MAP, ORDERED_LIST, UNORDERED_LIST } from '../../../constants';
-import { focusEditor } from '../../../core';
-import { MenuItem } from '../../../commons';
-import { getListType, isMenuDisabled, setListType } from '../helpers';
-class ListMenu extends React.Component {
+"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 _constants = require("../../../constants");
+var _core = require("../../../core");
+var _commons = require("../../../commons");
+var _helpers = require("../helpers");
+class ListMenu extends _react.default.Component {
   constructor() {
     super(...arguments);
-    _defineProperty(this, "isActive", () => {
+    (0, _defineProperty2.default)(this, "isActive", () => {
       const {
         editor,
         type
       } = this.props;
-      return getListType(editor, type) === type;
+      return (0, _helpers.getListType)(editor, type) === type;
     });
-    _defineProperty(this, "isDisabled", () => {
+    (0, _defineProperty2.default)(this, "isDisabled", () => {
       const {
         editor,
         readonly
       } = this.props;
-      return isMenuDisabled(editor, readonly);
+      return (0, _helpers.isMenuDisabled)(editor, readonly);
     });
-    _defineProperty(this, "onMouseDown", e => {
+    (0, _defineProperty2.default)(this, "onMouseDown", e => {
       e.preventDefault();
       e.stopPropagation();
       if (this.isDisabled()) return;
@@ -31,8 +38,8 @@ class ListMenu extends React.Component {
       } = this.props;
 
       // 执行命令
-      setListType(editor, type);
-      focusEditor(editor);
+      (0, _helpers.setListType)(editor, type);
+      (0, _core.focusEditor)(editor);
     });
   }
   render() {
@@ -41,7 +48,7 @@ class ListMenu extends React.Component {
       className,
       type
     } = this.props;
-    const menuConfig = MENUS_CONFIG_MAP[type];
+    const menuConfig = _constants.MENUS_CONFIG_MAP[type];
     const props = {
       isRichEditor,
       className,
@@ -50,10 +57,10 @@ class ListMenu extends React.Component {
       isActive: this.isActive(),
       onMouseDown: this.onMouseDown
     };
-    return /*#__PURE__*/React.createElement(MenuItem, props);
+    return /*#__PURE__*/_react.default.createElement(_commons.MenuItem, props);
   }
 }
-_defineProperty(ListMenu, "defaultProps", {
-  type: UNORDERED_LIST
+(0, _defineProperty2.default)(ListMenu, "defaultProps", {
+  type: _constants.UNORDERED_LIST
 });
-export default ListMenu;
+var _default = exports.default = ListMenu;

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

@@ -1,29 +1,39 @@
-import slugid from 'slugid';
-import { LIST_ITEM, PARAGRAPH, UNORDERED_LIST } from '../../constants';
-import { generateEmptyElement } from '../../core';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateEmptyListItem = exports.generateEmptyListContent = exports.generateEmptyList = exports.default = void 0;
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../constants");
+var _core = require("../../core");
 class List {
   constructor(options) {
-    this.type = options.type || UNORDERED_LIST;
+    this.type = options.type || _constants.UNORDERED_LIST;
     this.children = options.children || [{
       text: ''
     }];
   }
 }
-export default List;
-export const generateEmptyListItem = () => {
+var _default = exports.default = List;
+const generateEmptyListItem = () => {
   return {
-    id: slugid.nice(),
-    type: LIST_ITEM,
+    id: _slugid.default.nice(),
+    type: _constants.LIST_ITEM,
     children: []
   };
 };
-export const generateEmptyListContent = () => {
-  return generateEmptyElement(PARAGRAPH);
+exports.generateEmptyListItem = generateEmptyListItem;
+const generateEmptyListContent = () => {
+  return (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
 };
-export const generateEmptyList = type => {
+exports.generateEmptyListContent = generateEmptyListContent;
+const generateEmptyList = type => {
   return {
-    id: slugid.nice(),
+    id: _slugid.default.nice(),
     type: type,
     children: []
   };
-};
+};
+exports.generateEmptyList = generateEmptyList;

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

@@ -1,13 +1,19 @@
-import { Editor, Range } from '@seafile/slate';
-import { insertBreakList } from './insert-break-list';
-import { onTabHandle } from './on-tab-handle';
-import { normalizeList } from './normalize-list';
-import { insertFragmentList } from './insert-fragment-list';
-import { handleShortcut } from './shortcut';
-import { focusEditor, getSelectedNodeEntryByType } from '../../../core';
-import { LIST_ITEM } from '../../../constants';
-import { isList } from '../../../toolbar/side-toolbar/helpers';
-import { unwrapList } from '../transforms';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("@seafile/slate");
+var _insertBreakList = require("./insert-break-list");
+var _onTabHandle = require("./on-tab-handle");
+var _normalizeList = require("./normalize-list");
+var _insertFragmentList = require("./insert-fragment-list");
+var _shortcut = require("./shortcut");
+var _core = require("../../../core");
+var _constants = require("../../../constants");
+var _helpers = require("../../../toolbar/side-toolbar/helpers");
+var _transforms = require("../transforms");
 const withList = editor => {
   const {
     insertBreak,
@@ -17,7 +23,7 @@ const withList = editor => {
   } = editor;
   const newEditor = editor;
   newEditor.insertBreak = () => {
-    if (insertBreakList(editor)) return;
+    if ((0, _insertBreakList.insertBreakList)(editor)) return;
     insertBreak();
     return;
   };
@@ -29,24 +35,24 @@ const withList = editor => {
       deleteBackward(unit);
       return;
     }
-    const listItemEntry = getSelectedNodeEntryByType(editor, LIST_ITEM);
+    const listItemEntry = (0, _core.getSelectedNodeEntryByType)(editor, _constants.LIST_ITEM);
     if (listItemEntry) {
       const [, listItemPath] = listItemEntry;
 
       // Transforms to paragraph when press backspace at the start of the list item, and the list item is the first child of the list
-      const isAtStartOfListItem = Editor.isStart(editor, selection.anchor, listItemPath);
-      const isCollapsed = Range.isCollapsed(selection);
+      const isAtStartOfListItem = _slate.Editor.isStart(editor, selection.anchor, listItemPath);
+      const isCollapsed = _slate.Range.isCollapsed(selection);
       if (isCollapsed && isAtStartOfListItem) {
-        const previous = Editor.previous(editor, {
+        const previous = _slate.Editor.previous(editor, {
           at: listItemPath
         });
         // previous is undefined when the list item is the first child of the list
         if (!previous) {
-          unwrapList(newEditor, {
+          (0, _transforms.unwrapList)(newEditor, {
             at: listItemPath
           });
-          const focusPoint = Editor.start(newEditor, listItemPath);
-          focusEditor(newEditor, focusPoint);
+          const focusPoint = _slate.Editor.start(newEditor, listItemPath);
+          (0, _core.focusEditor)(newEditor, focusPoint);
           return;
         }
       }
@@ -59,32 +65,32 @@ const withList = editor => {
       handleTab && handleTab();
       return;
     }
-    if (onTabHandle(newEditor, event)) return;
+    if ((0, _onTabHandle.onTabHandle)(newEditor, event)) return;
     handleTab && handleTab();
   };
-  newEditor.insertFragment = insertFragmentList(newEditor);
-  newEditor.normalizeNode = normalizeList(editor);
+  newEditor.insertFragment = (0, _insertFragmentList.insertFragmentList)(newEditor);
+  newEditor.normalizeNode = (0, _normalizeList.normalizeList)(editor);
   newEditor.insertText = text => {
-    const isPreventInsert = handleShortcut(newEditor, text);
+    const isPreventInsert = (0, _shortcut.handleShortcut)(newEditor, text);
     if (isPreventInsert) return;
     return insertText(text);
   };
   newEditor.onCopy = event => {
-    const path = Editor.path(newEditor, newEditor.selection, {
+    const path = _slate.Editor.path(newEditor, newEditor.selection, {
       edge: 'start'
     });
-    if (isList(newEditor, path)) {
+    if ((0, _helpers.isList)(newEditor, path)) {
       event.stopPropagation();
     }
   };
   newEditor.cut = event => {
-    const path = Editor.path(newEditor, newEditor.selection, {
+    const path = _slate.Editor.path(newEditor, newEditor.selection, {
       edge: 'start'
     });
-    if (isList(newEditor, path)) {
+    if ((0, _helpers.isList)(newEditor, path)) {
       event.stopPropagation();
     }
   };
   return newEditor;
 };
-export default withList;
+var _default = exports.default = withList;

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

@@ -1,23 +1,30 @@
-import { isBlockAboveEmpty } from '../../../core';
-import { getListItemEntry } from '../queries';
-import { insertListItem, movedListItemUp } from '../transforms';
-export const insertBreakList = editor => {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertBreakList = void 0;
+var _core = require("../../../core");
+var _queries = require("../queries");
+var _transforms = require("../transforms");
+const insertBreakList = editor => {
   if (!editor.selection) return;
 
   // moved | inserted
   let moved = false;
-  const res = getListItemEntry(editor, {});
+  const res = (0, _queries.getListItemEntry)(editor, {});
 
   // if selection is in a li, and li content is empty
   if (res) {
-    if (isBlockAboveEmpty(editor)) {
-      moved = movedListItemUp(editor, res);
+    if ((0, _core.isBlockAboveEmpty)(editor)) {
+      moved = (0, _transforms.movedListItemUp)(editor, res);
       if (moved) return true;
     }
   }
   if (!moved) {
-    const inserted = insertListItem(editor);
+    const inserted = (0, _transforms.insertListItem)(editor);
     if (inserted) return true;
   }
   return;
-};
+};
+exports.insertBreakList = insertBreakList;

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

@@ -1,25 +1,32 @@
-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';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertFragmentList = exports.getTextAndListItemNodes = void 0;
+var _slate = require("@seafile/slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _queries = require("../queries");
 const isListRoot = node => {
-  return Element.isElement(node) && getListTypes().includes(node.type);
+  return _slate.Element.isElement(node) && (0, _queries.getListTypes)().includes(node.type);
 };
 const getFirstAncestorOfType = (root, entry, _ref) => {
   let {
     type
   } = _ref;
-  let ancestor = Path.parent(entry[1]);
-  while (getNode(root, ancestor).type !== type) {
-    ancestor = Path.parent(ancestor);
+  let ancestor = _slate.Path.parent(entry[1]);
+  while ((0, _core.getNode)(root, ancestor).type !== type) {
+    ancestor = _slate.Path.parent(ancestor);
   }
-  return [getNode(root, ancestor), ancestor];
+  return [(0, _core.getNode)(root, ancestor), ancestor];
 };
 const findListItemsWithContent = first => {
   let prev = null;
   let node = first;
-  while (isListRoot(node) || node.type === LIST_ITEM && node.children[0].type !== PARAGRAPH) {
+  while (isListRoot(node) || node.type === _constants.LIST_ITEM && node.children[0].type !== _constants.PARAGRAPH) {
     prev = node;
     [node] = node.children;
   }
@@ -29,12 +36,12 @@ const trimList = listRoot => {
   if (!isListRoot(listRoot)) {
     return [listRoot];
   }
-  const _texts = Node.texts(listRoot);
+  const _texts = _slate.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]);
+    return _slate.Path.isAncestor(commonAncestor[1], textEntry[1]) ? commonAncestor : (0, _core.getCommonNode)(listRoot, textEntry[1], commonAncestor[1]);
   }, getFirstAncestorOfType(listRoot, textEntries[0], {
-    type: LIST_ITEM
+    type: _constants.LIST_ITEM
   }));
 
   // is ul/ol: return children
@@ -43,25 +50,25 @@ const trimList = listRoot => {
   return [...findListItemsWithContent(first), ...rest];
 };
 const wrapNodeIntoListItem = node => {
-  return node.type === LIST_ITEM ? node : {
-    id: slugid.nice(),
-    type: LIST_ITEM,
+  return node.type === _constants.LIST_ITEM ? node : {
+    id: _slugid.default.nice(),
+    type: _constants.LIST_ITEM,
     children: [node]
   };
 };
 const isSingleLic = fragment => {
   const isFragmentOnlyListRoot = fragment.length === 1 && isListRoot(fragment[0]);
-  return isFragmentOnlyListRoot && [...getNodes({
+  return isFragmentOnlyListRoot && [...(0, _core.getNodes)({
     children: fragment
-  })].filter(entry => Element.isElement(entry[0])).filter(_ref2 => {
+  })].filter(entry => _slate.Element.isElement(entry[0])).filter(_ref2 => {
     let [node] = _ref2;
-    return node.type === PARAGRAPH;
+    return node.type === _constants.PARAGRAPH;
   }).length === 1;
 };
-export const getTextAndListItemNodes = (editor, fragment, liEntry, licEntry) => {
+const getTextAndListItemNodes = (editor, fragment, liEntry, licEntry) => {
   const [, liPath] = liEntry;
   const [licNode, licPath] = licEntry;
-  const isEmptyNode = !Node.string(licNode);
+  const isEmptyNode = !_slate.Node.string(licNode);
   // format copied fragment
   // first: lic, path: [...liPath, 0, 0]
   // rest: children, path: [...liPath, 1, 0]
@@ -73,36 +80,36 @@ export const getTextAndListItemNodes = (editor, fragment, liEntry, licEntry) =>
       textNode = first;
       listItemNodes = rest;
     } else if (isEmptyNode) {
-      const li = getNode(editor, liPath);
+      const li = (0, _core.getNode)(editor, liPath);
       const [, ...currentSubLists] = li.children; // old
 
       const [newLic, ...newSubLists] = first.children; // copied
       // insert copied contents
-      Transforms.insertNodes(editor, newLic, {
-        at: Path.next(licPath),
+      _slate.Transforms.insertNodes(editor, newLic, {
+        at: _slate.Path.next(licPath),
         select: true
       });
-      Transforms.removeNodes(editor, {
+      _slate.Transforms.removeNodes(editor, {
         at: licPath
       });
       if (newSubLists.length) {
         if (currentSubLists.length) {
           const path = [...liPath, 1, 0];
-          Transforms.insertNodes(editor, newSubLists[0].children, {
+          _slate.Transforms.insertNodes(editor, newSubLists[0].children, {
             at: path,
             select: true
           });
         } else {
-          Transforms.insertNodes(editor, newSubLists, {
-            at: Path.next(licPath),
+          _slate.Transforms.insertNodes(editor, newSubLists, {
+            at: _slate.Path.next(licPath),
             select: true
           });
         }
       }
-      textNode = generateDefaultText();
+      textNode = (0, _core.generateDefaultText)();
       listItemNodes = rest;
     } else {
-      textNode = generateDefaultText();
+      textNode = (0, _core.generateDefaultText)();
       listItemNodes = [first, ...rest];
     }
   } else {
@@ -118,50 +125,52 @@ export const getTextAndListItemNodes = (editor, fragment, liEntry, licEntry) =>
     listItemNodes
   };
 };
-export const insertFragmentList = editor => {
+exports.getTextAndListItemNodes = getTextAndListItemNodes;
+const insertFragmentList = editor => {
   const {
     insertFragment: _insertFragment
   } = editor;
   return fragment => {
-    Editor.withoutNormalizing(editor, () => {
-      let liEntry = findNode(editor, {
+    _slate.Editor.withoutNormalizing(editor, () => {
+      let liEntry = (0, _core.findNode)(editor, {
         match: {
-          type: LIST_ITEM
+          type: _constants.LIST_ITEM
         },
         mode: 'lowest'
       });
       if (!liEntry) {
-        const nodes = isListRoot(fragment[0]) ? [generateDefaultText(), ...fragment] : fragment;
+        const nodes = isListRoot(fragment[0]) ? [(0, _core.generateDefaultText)(), ...fragment] : fragment;
         return _insertFragment(nodes);
       }
-      Transforms.insertFragment(editor, [generateDefaultText()]); // need ' '
+      _slate.Transforms.insertFragment(editor, [(0, _core.generateDefaultText)()]); // need ' '
 
-      liEntry = findNode(editor, {
+      liEntry = (0, _core.findNode)(editor, {
         match: {
-          type: LIST_ITEM
+          type: _constants.LIST_ITEM
         },
         mode: 'lowest'
       });
-      const licEntry = findNode(editor, {
+      const licEntry = (0, _core.findNode)(editor, {
         match: {
-          type: PARAGRAPH
+          type: _constants.PARAGRAPH
         },
         mode: 'lowest'
       });
       if (!licEntry) {
-        const nodes = isListRoot(fragment) ? [generateDefaultText(), ...fragment] : fragment;
+        const nodes = isListRoot(fragment) ? [(0, _core.generateDefaultText)(), ...fragment] : fragment;
         return _insertFragment(nodes);
       }
       const {
         textNode,
         listItemNodes
       } = getTextAndListItemNodes(editor, fragment, liEntry, licEntry);
-      Transforms.insertFragment(editor, [textNode]);
+      _slate.Transforms.insertFragment(editor, [textNode]);
       const [, liPath] = liEntry;
-      return Transforms.insertNodes(editor, listItemNodes, {
-        at: Path.next(liPath),
+      return _slate.Transforms.insertNodes(editor, listItemNodes, {
+        at: _slate.Path.next(liPath),
         select: true
       });
     });
   };
-};
+};
+exports.insertFragmentList = insertFragmentList;