@seafile/seafile-editor 1.0.2 → 1.0.4

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

@@ -1,188 +1,165 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.insertFragmentList = exports.getTextAndListItemNodes = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
-var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toArray"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
-var _slate = require("slate");
-var _slugid = _interopRequireDefault(require("slugid"));
-var _core = require("../../../core");
-var _constant = require("../constant");
-var _elementTypes = require("../../../constants/element-types");
-var isListRoot = function isListRoot(node) {
-  return _slate.Element.isElement(node) && _constant.LIST_TYPES.includes(node.type);
+import { Element, Path, Transforms, Node, Editor, insertFragment } from 'slate';
+import slugid from 'slugid';
+import { findNode, generateDefaultText, getCommonNode, getNode, getNodes } from '../../../core';
+import { LIST_TYPES } from '../constant';
+import { LIST_ITEM, PARAGRAPH } from '../../../constants/element-types';
+const isListRoot = node => {
+  return Element.isElement(node) && LIST_TYPES.includes(node.type);
 };
-var getFirstAncestorOfType = function getFirstAncestorOfType(root, entry, _ref) {
-  var type = _ref.type;
-  var ancestor = _slate.Path.parent(entry[1]);
-  while ((0, _core.getNode)(root, ancestor).type !== type) {
-    ancestor = _slate.Path.parent(ancestor);
+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 [(0, _core.getNode)(root, ancestor), ancestor];
+  return [getNode(root, ancestor), ancestor];
 };
-var findListItemsWithContent = function findListItemsWithContent(first) {
-  var prev = null;
-  var node = first;
-  while (isListRoot(node) || node.type === _elementTypes.LIST_ITEM && node.children[0].type !== _elementTypes.PARAGRAPH) {
+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 = (0, _slicedToArray2.default)(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 = _slate.Node.texts(listRoot);
-  var textEntries = Array.from(_texts);
-  var commonAncestorEntry = textEntries.reduce(function (commonAncestor, textEntry) {
-    return _slate.Path.isAncestor(commonAncestor[1], textEntry[1]) ? commonAncestor : (0, _core.getCommonNode)(listRoot, textEntry[1], commonAncestor[1]);
+  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: _elementTypes.LIST_ITEM
+    type: LIST_ITEM
   }));
 
   // is ul/ol: return children
   // is not ul/ol
-  var _ref2 = isListRoot(commonAncestorEntry[0]) ? commonAncestorEntry[0].children : [commonAncestorEntry[0]],
-    _ref3 = (0, _toArray2.default)(_ref2),
-    first = _ref3[0],
-    rest = _ref3.slice(1);
-  return [].concat((0, _toConsumableArray2.default)(findListItemsWithContent(first)), (0, _toConsumableArray2.default)(rest));
+  const [first, ...rest] = isListRoot(commonAncestorEntry[0]) ? commonAncestorEntry[0].children : [commonAncestorEntry[0]];
+  return [...findListItemsWithContent(first), ...rest];
 };
-var wrapNodeIntoListItem = function wrapNodeIntoListItem(node) {
-  return node.type === _elementTypes.LIST_ITEM ? node : {
-    id: _slugid.default.nice(),
-    type: _elementTypes.LIST_ITEM,
+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 && (0, _toConsumableArray2.default)((0, _core.getNodes)({
+const isSingleLic = fragment => {
+  const isFragmentOnlyListRoot = fragment.length === 1 && isListRoot(fragment[0]);
+  return isFragmentOnlyListRoot && [...getNodes({
     children: fragment
-  })).filter(function (entry) {
-    return _slate.Element.isElement(entry[0]);
-  }).filter(function (_ref4) {
-    var _ref5 = (0, _slicedToArray2.default)(_ref4, 1),
-      node = _ref5[0];
-    return node.type === _elementTypes.PARAGRAPH;
+  })].filter(entry => Element.isElement(entry[0])).filter(_ref2 => {
+    let [node] = _ref2;
+    return node.type === PARAGRAPH;
   }).length === 1;
 };
-var getTextAndListItemNodes = exports.getTextAndListItemNodes = function getTextAndListItemNodes(editor, fragment, liEntry, licEntry) {
-  var _liEntry = (0, _slicedToArray2.default)(liEntry, 2),
-    liPath = _liEntry[1];
-  var _licEntry = (0, _slicedToArray2.default)(licEntry, 2),
-    licNode = _licEntry[0],
-    licPath = _licEntry[1];
-  var isEmptyNode = !_slate.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 = (0, _toArray2.default)(_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 = (0, _core.getNode)(editor, liPath);
-      var _li$children = (0, _toArray2.default)(li.children),
-        currentSubLists = _li$children.slice(1); // old
+      const li = getNode(editor, liPath);
+      const [, ...currentSubLists] = li.children; // old
 
-      var _first$children = (0, _toArray2.default)(first.children),
-        newLic = _first$children[0],
-        newSubLists = _first$children.slice(1); // copied
+      const [newLic, ...newSubLists] = first.children; // copied
       // insert copied contents
-      _slate.Transforms.insertNodes(editor, newLic, {
-        at: _slate.Path.next(licPath),
+      Transforms.insertNodes(editor, newLic, {
+        at: Path.next(licPath),
         select: true
       });
-      _slate.Transforms.removeNodes(editor, {
+      Transforms.removeNodes(editor, {
         at: licPath
       });
       if (newSubLists.length) {
         if (currentSubLists.length) {
-          var path = [].concat((0, _toConsumableArray2.default)(liPath), [1, 0]);
-          _slate.Transforms.insertNodes(editor, newSubLists[0].children, {
+          const path = [...liPath, 1, 0];
+          Transforms.insertNodes(editor, newSubLists[0].children, {
             at: path,
             select: true
           });
         } else {
-          _slate.Transforms.insertNodes(editor, newSubLists, {
-            at: _slate.Path.next(licPath),
+          Transforms.insertNodes(editor, newSubLists, {
+            at: Path.next(licPath),
             select: true
           });
         }
       }
-      textNode = (0, _core.generateDefaultText)();
+      textNode = generateDefaultText();
       listItemNodes = rest;
     } else {
-      textNode = (0, _core.generateDefaultText)();
-      listItemNodes = [first].concat((0, _toConsumableArray2.default)(rest));
+      textNode = generateDefaultText();
+      listItemNodes = [first, ...rest];
     }
   } else {
     textNode = first;
     listItemNodes = rest;
     return {
-      textNode: textNode,
-      listItemNodes: listItemNodes
+      textNode,
+      listItemNodes
     };
   }
   return {
-    textNode: textNode,
-    listItemNodes: listItemNodes
+    textNode,
+    listItemNodes
   };
 };
-var insertFragmentList = exports.insertFragmentList = function insertFragmentList(editor) {
-  var _insertFragment = editor.insertFragment;
-  return function (fragment) {
-    _slate.Editor.withoutNormalizing(editor, function () {
-      var liEntry = (0, _core.findNode)(editor, {
+export const insertFragmentList = editor => {
+  const {
+    insertFragment: _insertFragment
+  } = editor;
+  return fragment => {
+    Editor.withoutNormalizing(editor, () => {
+      let liEntry = findNode(editor, {
         match: {
-          type: _elementTypes.LIST_ITEM
+          type: LIST_ITEM
         },
         mode: 'lowest'
       });
       if (!liEntry) {
-        var nodes = isListRoot(fragment) ? [(0, _core.generateDefaultText)()].concat((0, _toConsumableArray2.default)(fragment)) : fragment;
+        const nodes = isListRoot(fragment) ? [generateDefaultText(), ...fragment] : fragment;
         return _insertFragment(nodes);
       }
-      (0, _slate.insertFragment)(editor, [(0, _core.generateDefaultText)()]); // need ' '
+      insertFragment(editor, [generateDefaultText()]); // need ' '
 
-      liEntry = (0, _core.findNode)(editor, {
+      liEntry = findNode(editor, {
         match: {
-          type: _elementTypes.LIST_ITEM
+          type: LIST_ITEM
         },
         mode: 'lowest'
       });
-      var licEntry = (0, _core.findNode)(editor, {
+      const licEntry = findNode(editor, {
         match: {
-          type: _elementTypes.PARAGRAPH
+          type: PARAGRAPH
         },
         mode: 'lowest'
       });
       if (!licEntry) {
-        var _nodes = isListRoot(fragment) ? [(0, _core.generateDefaultText)()].concat((0, _toConsumableArray2.default)(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;
-      (0, _slate.insertFragment)(editor, [textNode]);
-      var _liEntry2 = liEntry,
-        _liEntry3 = (0, _slicedToArray2.default)(_liEntry2, 2),
-        liPath = _liEntry3[1];
-      return _slate.Transforms.insertNodes(editor, listItemNodes, {
-        at: _slate.Path.next(liPath),
+      const {
+        textNode,
+        listItemNodes
+      } = getTextAndListItemNodes(editor, fragment, liEntry, licEntry);
+      insertFragment(editor, [textNode]);
+      const [, liPath] = liEntry;
+      return Transforms.insertNodes(editor, listItemNodes, {
+        at: Path.next(liPath),
         select: true
       });
     });

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

@@ -1,76 +1,65 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.normalizeList = void 0;
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
-var _slate = require("slate");
-var _transforms = require("../transforms");
-var _elementTypes = require("../../../constants/element-types");
-var _core = require("../../../core");
-var _constant = require("../constant");
-var normalizeList = exports.normalizeList = function normalizeList(editor) {
-  var normalizeNode = editor.normalizeNode;
-  return function (_ref) {
-    var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
-      node = _ref2[0],
-      path = _ref2[1];
-    if (!_slate.Element.isElement(node)) {
+import { Element, Transforms, Path } from 'slate';
+import { moveListItemsToList, normalizeListItem, normalizeNestedList } from '../transforms';
+import { LIST_ITEM } from '../../../constants/element-types';
+import { generateElement, getChildren, getNode, getPreviousPath, match } from '../../../core';
+import { LIST_TYPES } from '../constant';
+export const normalizeList = editor => {
+  const {
+    normalizeNode
+  } = editor;
+  return _ref => {
+    let [node, path] = _ref;
+    if (!Element.isElement(node)) {
       return normalizeNode([node, path]);
     }
 
     // root
-    if (_constant.LIST_TYPES.includes(node.type)) {
-      var children = (0, _core.getChildren)([node, path]);
-      var nonLiChild = children.find(function (_ref3) {
-        var _ref4 = (0, _slicedToArray2.default)(_ref3, 1),
-          child = _ref4[0];
-        return child.type !== _elementTypes.LIST_ITEM;
+    if (LIST_TYPES.includes(node.type)) {
+      const children = getChildren([node, path]);
+      const nonLiChild = children.find(_ref2 => {
+        let [child] = _ref2;
+        return child.type !== LIST_ITEM;
       });
       if (nonLiChild) {
-        var listItem = (0, _core.generateElement)(_elementTypes.LIST_ITEM, []);
-        _slate.Transforms.wrapNodes(editor, listItem, {
+        const listItem = generateElement(LIST_ITEM, []);
+        Transforms.wrapNodes(editor, listItem, {
           at: nonLiChild[1]
         });
         return;
       }
     }
-    if ((0, _core.match)(node, [], {
-      type: _constant.LIST_TYPES
+    if (match(node, [], {
+      type: LIST_TYPES
     })) {
-      if (!node.children.length || !node.children.find(function (item) {
-        return item.type === _elementTypes.LIST_ITEM;
-      })) {
-        _slate.Transforms.removeNodes(editor, {
+      if (!node.children.length || !node.children.find(item => item.type === LIST_ITEM)) {
+        Transforms.removeNodes(editor, {
           at: path
         });
         return;
       }
-      var nextPath = _slate.Path.next(path);
-      var nextNode = (0, _core.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) {
-        (0, _transforms.moveListItemsToList)(editor, {
+        moveListItemsToList(editor, {
           fromList: [nextNode, nextPath],
           toList: [node, path],
           deleteFromList: true
         });
       }
-      var prevPath = (0, _core.getPreviousPath)(path);
-      var prevNode = (0, _core.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;
       }
-      if ((0, _transforms.normalizeNestedList)(editor, {
+      if (normalizeNestedList(editor, {
         nestedListItem: [node, path]
       })) {
         return;
       }
     }
-    if (node.type === _elementTypes.LIST_ITEM) {
-      if ((0, _transforms.normalizeListItem)(editor, {
+    if (node.type === LIST_ITEM) {
+      if (normalizeListItem(editor, {
         listItem: [node, path]
       })) {
         return;

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

@@ -1,48 +1,49 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.handleTab = void 0;
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
-var _slate = require("slate");
-var _isHotkey = _interopRequireDefault(require("is-hotkey"));
-var _core = require("../../../core");
-var _elementTypes = require("../../../constants/element-types");
-var _transforms = require("../transforms");
-var handleTab = exports.handleTab = function handleTab(editor, event) {
-  var selection = editor.selection;
+import { Editor, Range, Transforms } from 'slate';
+import isHotkey from 'is-hotkey';
+import { findNode } from '../../../core';
+import { LIST_ITEM } from '../../../constants/element-types';
+import { moveListItems } from '../transforms';
+export const handleTab = (editor, event) => {
+  const {
+    selection
+  } = editor;
   if (!selection) return;
-  var selectedList = (0, _core.findNode)(editor, {
-    type: [_elementTypes.LIST_ITEM]
+  const selectedList = findNode(editor, {
+    type: [LIST_ITEM]
   });
   if (!selectedList) return;
-  var workRange = editor.selection;
-  if (!_slate.Range.isCollapsed(selection)) {
-    var anchor = selection.anchor,
-      focus = selection.focus;
-    if (_slate.Range.isBackward(selection)) {
-      var _anchor$focus = {
-        anchor: (0, _objectSpread2.default)({}, selection.focus),
-        focus: (0, _objectSpread2.default)({}, selection.anchor)
-      };
-      anchor = _anchor$focus.anchor;
-      focus = _anchor$focus.focus;
+  let workRange = editor.selection;
+  if (!Range.isCollapsed(selection)) {
+    let {
+      anchor,
+      focus
+    } = selection;
+    if (Range.isBackward(selection)) {
+      ({
+        anchor,
+        focus
+      } = {
+        anchor: {
+          ...selection.focus
+        },
+        focus: {
+          ...selection.anchor
+        }
+      });
     }
-    var unHungRange = _slate.Editor.unhangRange(editor, {
-      anchor: anchor,
-      focus: focus
+    const unHungRange = Editor.unhangRange(editor, {
+      anchor,
+      focus
     });
     if (unHungRange) {
       workRange = unHungRange;
-      _slate.Transforms.select(editor, unHungRange);
+      Transforms.select(editor, unHungRange);
     }
   }
-  var isIncrease = (0, _isHotkey.default)('shift+tab', event) ? false : true;
+  const isIncrease = isHotkey('shift+tab', event) ? false : true;
   if (workRange && selectedList) {
     event.preventDefault();
-    (0, _transforms.moveListItems)(editor, {
+    moveListItems(editor, {
       at: workRange,
       increase: isIncrease,
       enableResetOnShiftTab: true

package/dist/extension/plugins/list/queries/index.js

@@ -1,51 +1,43 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isListNested = exports.hasListChild = exports.getListItemEntry = void 0;
-var _slate = require("slate");
-var _elementTypes = require("../../../constants/element-types");
-var _constant = require("../constant");
-var getListItemEntry = exports.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;
-  if (_slate.Range.isRange(at) && !_slate.Range.isCollapsed(at)) {
+import { Editor, Element, Range, Node } from 'slate';
+import { LIST_ITEM } from '../../../constants/element-types';
+import { LIST_TYPES } from '../constant';
+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 (_slate.Range.isRange(at)) {
+  } else if (Range.isRange(at)) {
     _at = at.anchor.path;
   } else {
     _at = at;
   }
   if (_at) {
-    var node = _slate.Node.get(editor, _at);
+    const node = Node.get(editor, _at);
     if (node) {
-      var listItem = _slate.Editor.above(editor, {
+      const listItem = Editor.above(editor, {
         at: _at,
-        match: function match(n) {
-          return _slate.Element.isElement(n) && n.type === _elementTypes.LIST_ITEM;
-        }
+        match: n => Element.isElement(n) && n.type === LIST_ITEM
       });
       if (listItem) {
-        var list = _slate.Editor.parent(editor, listItem[1]);
+        const list = Editor.parent(editor, listItem[1]);
         return {
-          list: list,
-          listItem: listItem
+          list,
+          listItem
         };
       }
     }
   }
   return null;
 };
-var hasListChild = exports.hasListChild = function hasListChild(node) {
-  return node.children.some(function (n) {
-    return _slate.Element.isElement(n) && _constant.LIST_TYPES.includes(n.type);
+export const hasListChild = node => {
+  return node.children.some(n => {
+    return Element.isElement(n) && LIST_TYPES.includes(n.type);
   });
 };
-var isListNested = exports.isListNested = function isListNested(editor, listPath) {
+export const isListNested = (editor, listPath) => {
   var _Editor$parent;
-  var 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) === _elementTypes.LIST_ITEM;
+  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/extension/plugins/list/render-elem/index.js

@@ -1,38 +1,38 @@
-"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 _elementTypes = require("../../../constants/element-types");
-require("./style.css");
-var renderList = exports.renderList = function renderList(props, editor) {
-  var attributes = props.attributes,
-    children = props.children,
-    node = props.element;
-  var Tag = node.type === _elementTypes.ORDERED_LIST ? 'ol' : 'ul';
-  return /*#__PURE__*/_react.default.createElement(Tag, Object.assign({
+import React from 'react';
+import { ORDERED_LIST } from '../../../constants/element-types';
+import './style.css';
+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: "sf-list-line"
   }, attributes), children);
 };
-var renderListItem = exports.renderListItem = function renderListItem(props, editor) {
-  var attributes = props.attributes,
-    children = props.children,
-    element = props.element;
-  return /*#__PURE__*/_react.default.createElement("li", Object.assign({
+const renderListItem = (props, editor) => {
+  const {
+    attributes,
+    children,
+    element
+  } = props;
+  return /*#__PURE__*/React.createElement("li", Object.assign({
     "data-id": element.id,
     "data-root": "true"
   }, attributes), children);
 };
-var renderListLic = exports.renderListLic = function renderListLic(props, editor) {
-  var attributes = props.attributes,
-    children = props.children,
-    element = props.element;
-  return /*#__PURE__*/_react.default.createElement("div", Object.assign({
+const renderListLic = (props, editor) => {
+  const {
+    attributes,
+    children,
+    element
+  } = props;
+  return /*#__PURE__*/React.createElement("div", Object.assign({
     "data-id": element.id
   }, attributes), children);
-};
+};
+export { renderList, renderListItem, renderListLic };