@seafile/sdoc-editor 2.0.81 → 2.0.83

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

@@ -0,0 +1,190 @@
+"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("@seafile/slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _queries = require("../queries");
+var isListRoot = function isListRoot(node) {
+  return _slate.Element.isElement(node) && (0, _queries.getListTypes)().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);
+  }
+  return [(0, _core.getNode)(root, ancestor), ancestor];
+};
+var findListItemsWithContent = function findListItemsWithContent(first) {
+  var prev = null;
+  var node = first;
+  while (isListRoot(node) || node.type === _constants.LIST_ITEM && node.children[0].type !== _constants.PARAGRAPH) {
+    prev = node;
+    var _node$children = (0, _slicedToArray2["default"])(node.children, 1);
+    node = _node$children[0];
+  }
+  return prev ? prev.children : [node];
+};
+var trimList = function 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]);
+  }, getFirstAncestorOfType(listRoot, textEntries[0], {
+    type: _constants.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));
+};
+var wrapNodeIntoListItem = function wrapNodeIntoListItem(node) {
+  return node.type === _constants.LIST_ITEM ? node : {
+    id: _slugid["default"].nice(),
+    type: _constants.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)({
+    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 === _constants.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);
+  // 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 = [];
+  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
+
+      var _first$children = (0, _toArray2["default"])(first.children),
+        newLic = _first$children[0],
+        newSubLists = _first$children.slice(1); // copied
+      // insert copied contents
+      _slate.Transforms.insertNodes(editor, newLic, {
+        at: _slate.Path.next(licPath),
+        select: true
+      });
+      _slate.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, {
+            at: path,
+            select: true
+          });
+        } else {
+          _slate.Transforms.insertNodes(editor, newSubLists, {
+            at: _slate.Path.next(licPath),
+            select: true
+          });
+        }
+      }
+      textNode = (0, _core.generateDefaultText)();
+      listItemNodes = rest;
+    } else {
+      textNode = (0, _core.generateDefaultText)();
+      listItemNodes = [first].concat((0, _toConsumableArray2["default"])(rest));
+    }
+  } else {
+    textNode = first;
+    listItemNodes = rest;
+    return {
+      textNode: textNode,
+      listItemNodes: listItemNodes
+    };
+  }
+  return {
+    textNode: textNode,
+    listItemNodes: 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, {
+        match: {
+          type: _constants.LIST_ITEM
+        },
+        mode: 'lowest'
+      });
+      if (!liEntry) {
+        var nodes = isListRoot(fragment) ? [(0, _core.generateDefaultText)()].concat((0, _toConsumableArray2["default"])(fragment)) : fragment;
+        return _insertFragment(nodes);
+      }
+      _slate.Transforms.insertFragment(editor, [(0, _core.generateDefaultText)()]); // need ' '
+
+      liEntry = (0, _core.findNode)(editor, {
+        match: {
+          type: _constants.LIST_ITEM
+        },
+        mode: 'lowest'
+      });
+      var licEntry = (0, _core.findNode)(editor, {
+        match: {
+          type: _constants.PARAGRAPH
+        },
+        mode: 'lowest'
+      });
+      if (!licEntry) {
+        var _nodes = isListRoot(fragment) ? [(0, _core.generateDefaultText)()].concat((0, _toConsumableArray2["default"])(fragment)) : fragment;
+        return _insertFragment(_nodes);
+      }
+      var _getTextAndListItemNo = getTextAndListItemNodes(editor, fragment, liEntry, licEntry),
+        textNode = _getTextAndListItemNo.textNode,
+        listItemNodes = _getTextAndListItemNo.listItemNodes;
+      _slate.Transforms.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),
+        select: true
+      });
+    });
+  };
+};

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

@@ -0,0 +1,84 @@
+"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("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _model = require("../model");
+var _queries = require("../queries");
+var _transforms = require("../transforms");
+var validChildrenTypes = [_constants.GROUP, _constants.LIST_ITEM];
+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)) {
+      return normalizeNode([node, path]);
+    }
+    var listTypes = (0, _queries.getListTypes)();
+
+    // root
+    if (listTypes.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 !validChildrenTypes.includes(child.type);
+      });
+      if (nonLiChild) {
+        var listItem = (0, _model.generateEmptyListItem)();
+        _slate.Transforms.wrapNodes(editor, listItem, {
+          at: nonLiChild[1]
+        });
+        return;
+      }
+    }
+    if ((0, _core.match)(node, [], {
+      type: listTypes
+    })) {
+      if (!node.children.length || !node.children.find(function (child) {
+        return validChildrenTypes.includes(child.type);
+      })) {
+        _slate.Transforms.removeNodes(editor, {
+          at: path
+        });
+        return;
+      }
+      var nextPath = _slate.Path.next(path);
+      var nextNode = (0, _core.getNode)(editor, nextPath);
+      if ((nextNode === null || nextNode === void 0 ? void 0 : nextNode.type) === node.type) {
+        (0, _transforms.moveListItemsToList)(editor, {
+          fromList: [nextNode, nextPath],
+          toList: [node, path],
+          deleteFromList: true
+        });
+      }
+      var prevPath = (0, _core.getPreviousPath)(path);
+      var prevNode = (0, _core.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, {
+        nestedListItem: [node, path]
+      })) {
+        return;
+      }
+    }
+    if (node.type === _constants.LIST_ITEM) {
+      if ((0, _transforms.normalizeListItem)(editor, {
+        listItem: [node, path]
+      })) {
+        return;
+      }
+    }
+    normalizeNode([node, path]);
+  };
+};

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

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onTabHandle = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slate = require("@seafile/slate");
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _transforms = require("../transforms");
+var onTabHandle = exports.onTabHandle = function onTabHandle(editor, event) {
+  var selection = editor.selection;
+  if (!selection) return;
+  var listSelected = (0, _core.findNode)(editor, {
+    type: [_constants.LIST_ITEM]
+  });
+  if (!listSelected) return false;
+  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;
+    }
+    var unHungRange = _slate.Editor.unhangRange(editor, {
+      anchor: anchor,
+      focus: focus
+    });
+    if (unHungRange) {
+      workRange = unHungRange;
+      _slate.Transforms.select(editor, unHungRange);
+    }
+  }
+  var increase = (0, _isHotkey["default"])('shift+tab', event) ? false : true;
+  if (workRange && listSelected) {
+    event.preventDefault();
+    (0, _transforms.moveListItems)(editor, {
+      at: workRange,
+      increase: increase,
+      enableResetOnShiftTab: true
+    });
+    return true;
+  }
+};

package/dist/extension/plugins/list/plugin/shortcut.js

@@ -0,0 +1,97 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleShortcut = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _helpers = require("../helpers");
+var _model = require("../model");
+var _transforms = require("../transforms");
+/**
+ * @param {Editor} editor
+ * @param {String} text
+ * @returns {Boolean} isPreventInsert
+ */
+var handleShortcut = exports.handleShortcut = function handleShortcut(editor, text) {
+  if (text !== ' ') return false;
+  var selection = editor.selection;
+  if (!_slate.Range.isCollapsed(selection)) return false;
+  var _Editor$above = _slate.Editor.above(editor),
+    _Editor$above2 = (0, _slicedToArray2["default"])(_Editor$above, 2),
+    aboveNode = _Editor$above2[0],
+    aboveNodePath = _Editor$above2[1];
+  var aboveNodeRef = _slate.Editor.pathRef(editor, aboveNodePath);
+  if (aboveNode.type !== _constants.PARAGRAPH) return false;
+  // Match ordered list shortcut
+  var regShortcut = /^\s*[1-9]+\.\s*$/;
+  var _getBeforeText = (0, _helpers.getBeforeText)(editor),
+    beforeText = _getBeforeText.beforeText,
+    range = _getBeforeText.range;
+  var matchResult = beforeText.match(regShortcut);
+  var 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 = (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
+    _slate.Transforms["delete"](editor, {
+      at: range
+    });
+    (0, _transforms.toggleList)(editor, _constants.ORDERED_LIST);
+    return true;
+  }
+  var _Editor$node = _slate.Editor.node(editor, previousNodePath),
+    _Editor$node2 = (0, _slicedToArray2["default"])(_Editor$node, 2),
+    previousNode = _Editor$node2[0],
+    previousPath = _Editor$node2[1];
+  // If the previous node is not an ordered list and is not start with `1.`,it is not a shortcut
+  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 !== _constants.ORDERED_LIST && matchedText === '1.') {
+    // Delete shortcut key text
+    _slate.Transforms["delete"](editor, {
+      at: range
+    });
+    (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
+  var shortcutOrderNum = parseInt(matchResult[0].slice(0, -1));
+
+  // Check If order number is continuous
+  if (previousNode.children.length + 1 !== shortcutOrderNum) return false;
+
+  // Delete shortcut key text
+  _slate.Transforms["delete"](editor, {
+    at: range
+  });
+  // Update aboveNode after delete shortcut text
+  var _Editor$above3 = _slate.Editor.above(editor);
+  var _Editor$above4 = (0, _slicedToArray2["default"])(_Editor$above3, 1);
+  aboveNode = _Editor$above4[0];
+  var _getLastChild = (0, _core.getLastChild)([previousNode, previousPath]),
+    _getLastChild2 = (0, _slicedToArray2["default"])(_getLastChild, 2),
+    lastListItemPath = _getLastChild2[1];
+  var targetInsertPath = _slate.Path.next(lastListItemPath);
+  // Wrap the paragraph in a list item
+  var insertedListItem = (0, _model.generateEmptyListItem)();
+  insertedListItem.children.push(aboveNode);
+  _slate.Transforms.insertNodes(editor, insertedListItem, {
+    at: targetInsertPath
+  });
+  _slate.Transforms.removeNodes(editor, {
+    at: aboveNodeRef.unref()
+  });
+  // Set the selection to the end of the inserted list item
+  _slate.Transforms.select(editor, _slate.Editor.end(editor, targetInsertPath));
+  return true;
+};

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

@@ -0,0 +1,53 @@
+"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");
+var getListTypes = exports.getListTypes = function getListTypes() {
+  return [_constants.ORDERED_LIST, _constants.UNORDERED_LIST];
+};
+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)) {
+    _at = at.focus.path;
+  } else if (_slate.Range.isRange(at)) {
+    _at = at.anchor.path;
+  } else {
+    _at = at;
+  }
+  if (_at) {
+    var node = _slate.Node.get(editor, _at);
+    if (node) {
+      var listItem = _slate.Editor.above(editor, {
+        at: _at,
+        match: function match(n) {
+          return _slate.Element.isElement(n) && n.type === _constants.LIST_ITEM;
+        }
+      });
+      if (listItem) {
+        var list = _slate.Editor.parent(editor, listItem[1]);
+        return {
+          list: list,
+          listItem: listItem
+        };
+      }
+    }
+  }
+  return null;
+};
+var hasListChild = exports.hasListChild = function hasListChild(node) {
+  return node.children.some(function (n) {
+    return _slate.Element.isElement(n) && getListTypes().includes(n.type);
+  });
+};
+var isListNested = exports.isListNested = function 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) === _constants.LIST_ITEM;
+};

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

@@ -0,0 +1,55 @@
+"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");
+var renderList = exports.renderList = function renderList(props, editor) {
+  var attributes = props.attributes,
+    children = props.children,
+    node = props.element;
+  var 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);
+};
+var renderListItem = exports.renderListItem = function renderListItem(props, editor) {
+  var attributes = props.attributes,
+    children = props.children,
+    element = props.element;
+  var align = element.children[0].align;
+  var className = '';
+  switch (align) {
+    case 'center':
+      className = 'align-self-center';
+      break;
+    case 'right':
+      className = 'align-self-end';
+      break;
+    default:
+      className = '';
+  }
+  var isBold = element.children[0].children.every(function (item) {
+    return item.bold === true;
+  });
+  return /*#__PURE__*/_react["default"].createElement("li", Object.assign({
+    "data-id": element.id
+  }, attributes, {
+    className: (0, _classnames["default"])(className, {
+      'sdoc-li-bold': isBold
+    })
+  }), 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({
+    "data-id": element.id
+  }, attributes), children);
+};

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

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