@seafile/sdoc-editor 2.0.82 → 2.0.83

package/dist/extension/core/queries/index.js

@@ -0,0 +1,680 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.someNode = exports.isTopLevelListItem = exports.isTextNode = exports.isStartPoint = exports.isSelectionAtBlockStart = exports.isSelectionAtBlockEnd = exports.isRangeInSameBlock = exports.isRangeAcrossBlocks = exports.isMultiLevelList = exports.isMiddlePoint = exports.isLastNode = exports.isLastChild = exports.isHasImg = exports.isFirstChild = exports.isEndPoint = exports.isEmptyArticle = exports.isCursorAtBlockStart = exports.isCurrentLineHasText = exports.isCurrentLineEmpty = exports.isContainsVoidElement = exports.isBlockTextEmptyAfterSelection = exports.isBlockAboveEmpty = exports.isAncestorEmpty = exports.getTopLevelBlockNode = exports.getStartPoint = exports.getSelectedNodeEntryByType = exports.getSelectedNodeByTypes = exports.getSelectedNodeByType = exports.getSelectedElems = exports.getQueryOptions = exports.getPreviousPath = exports.getPrevNode = exports.getPointBefore = exports.getParentNode = exports.getNodes = exports.getNodeType = exports.getNodeEntries = exports.getNodeById = exports.getNode = exports.getNextSiblingNodes = exports.getNextNode = exports.getLastChildPath = exports.getLastChild = exports.getEndPoint = exports.getEditorString = exports.getDeepInlineChildren = exports.getCurrentNode = exports.getCommonNode = exports.getChildren = exports.getAboveNode = exports.getAboveBlockNode = exports.findPath = exports.findNode = exports.findDescendant = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectWithoutProperties"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createForOfIteratorHelper"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _constants = require("../../constants");
+var _utils = require("../utils");
+var _excluded = ["at"],
+  _excluded2 = ["at"];
+// options
+var getQueryOptions = exports.getQueryOptions = function getQueryOptions(editor, options) {
+  var _match = options.match,
+    block = options.block;
+  var newMatch = undefined;
+  if (_match || block) {
+    newMatch = function newMatch(n, path) {
+      return (0, _utils.match)(n, path, _match) && (!block || _slate.Editor.isBlock(editor, n));
+    };
+  }
+  return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, options), {}, {
+    match: newMatch
+  });
+};
+var findPath = exports.findPath = function findPath(editor, node, defaultPath) {
+  try {
+    return _slateReact.ReactEditor.findPath(editor, node);
+  } catch (_unused) {
+    return defaultPath;
+  }
+};
+
+// get node
+var getNode = exports.getNode = function getNode(editor, path) {
+  var node = null;
+  try {
+    node = _slate.Node.get(editor, path);
+  } catch (err) {
+    node = null;
+  }
+  return node;
+};
+var getNodeType = exports.getNodeType = function getNodeType(node) {
+  return _slate.Element.isElement(node) ? node.type : '';
+};
+var _getNodeById = exports.getNodeById = function getNodeById(nodes, nodeId) {
+  var node;
+  for (var i = 0; i < nodes.length; i++) {
+    var currentNode = nodes[i];
+    if (currentNode.id === nodeId) {
+      node = currentNode;
+      break;
+    }
+    var childrenNodes = currentNode.children;
+    if (!Array.isArray(childrenNodes)) continue;
+    var childNode = childrenNodes.find(function (node) {
+      return node.id === nodeId;
+    });
+    if (childNode) {
+      node = childNode;
+      break;
+    }
+    childNode = _getNodeById(childrenNodes, nodeId);
+    if (!childNode) continue;
+    node = childNode;
+    break;
+  }
+  return node;
+};
+var _getParentNode = exports.getParentNode = function getParentNode(nodes, nodeId) {
+  var parentNode;
+  for (var i = 0; i < nodes.length; i++) {
+    var node = nodes[i];
+    var childrenNodes = node.children;
+    if (!Array.isArray(childrenNodes)) continue;
+    if (childrenNodes.find(function (node) {
+      return node.id === nodeId;
+    })) {
+      parentNode = node;
+    } else {
+      parentNode = _getParentNode(childrenNodes, nodeId);
+    }
+    if (!parentNode) continue;
+    break;
+  }
+  return parentNode;
+};
+var getNodes = exports.getNodes = function getNodes(node, options) {
+  return _slate.Node.nodes(node, options);
+};
+var getCommonNode = exports.getCommonNode = function getCommonNode(root, path, ancestor) {
+  return _slate.Node.common(root, path, ancestor);
+};
+var getSelectedNodeByType = exports.getSelectedNodeByType = function getSelectedNodeByType(editor, type) {
+  var match = function match(n) {
+    return getNodeType(n) === type;
+  };
+  if (!editor.selection) return;
+  var at = _slate.Range.isCollapsed(editor.selection) ? editor.selection : _slate.Editor.start(editor, editor.selection);
+  var _Editor$nodes = _slate.Editor.nodes(editor, {
+      match: match,
+      universal: true,
+      at: at
+    }),
+    _Editor$nodes2 = (0, _slicedToArray2["default"])(_Editor$nodes, 1),
+    nodeEntry = _Editor$nodes2[0];
+  return nodeEntry ? nodeEntry[0] : null;
+};
+var getSelectedNodeByTypes = exports.getSelectedNodeByTypes = function getSelectedNodeByTypes(editor, types) {
+  var match = function match(n) {
+    return types.includes(getNodeType(n));
+  };
+  var _Editor$nodes3 = _slate.Editor.nodes(editor, {
+      match: match,
+      universal: true
+    }),
+    _Editor$nodes4 = (0, _slicedToArray2["default"])(_Editor$nodes3, 1),
+    nodeEntry = _Editor$nodes4[0];
+  return nodeEntry ? nodeEntry[0] : null;
+};
+var getSelectedNodeEntryByType = exports.getSelectedNodeEntryByType = function getSelectedNodeEntryByType(editor, type) {
+  var match = function match(n) {
+    return getNodeType(n) === type;
+  };
+  var _Editor$nodes5 = _slate.Editor.nodes(editor, {
+      match: match,
+      universal: false
+    }),
+    _Editor$nodes6 = (0, _slicedToArray2["default"])(_Editor$nodes5, 1),
+    nodeEntry = _Editor$nodes6[0];
+  return nodeEntry ? nodeEntry : null;
+};
+var getNodeEntries = exports.getNodeEntries = function getNodeEntries(editor, options) {
+  return _slate.Editor.nodes(editor, getQueryOptions(editor, options));
+};
+var getEditorString = exports.getEditorString = function getEditorString(editor, at, options) {
+  if (!at) return '';
+  try {
+    return _slate.Editor.string(editor, at, options);
+  } catch (error) {
+    return '';
+  }
+};
+
+// children & child
+var getChildren = exports.getChildren = function getChildren(nodeEntry) {
+  var _nodeEntry = (0, _slicedToArray2["default"])(nodeEntry, 2),
+    node = _nodeEntry[0],
+    path = _nodeEntry[1];
+  if (_slate.Element.isAncestor(node)) {
+    var children = node.children;
+    return children.map(function (child, index) {
+      var childPath = path.concat([index]);
+      return [child, childPath];
+    });
+  }
+  return [];
+};
+var getLastChild = exports.getLastChild = function getLastChild(nodeEntry) {
+  var _nodeEntry2 = (0, _slicedToArray2["default"])(nodeEntry, 2),
+    node = _nodeEntry2[0],
+    path = _nodeEntry2[1];
+  if (_slate.Text.isText(node)) return null;
+  if (!node.children.length) return null;
+  var children = node.children;
+  return [children[children.length - 1], path.concat([children.length - 1])];
+};
+var _getDeepInlineChildren = exports.getDeepInlineChildren = function getDeepInlineChildren(editor, _ref) {
+  var children = _ref.children;
+  var inlineChildren = [];
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(children),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var child = _step.value;
+      if (_slate.Editor.isBlock(editor, child[0])) {
+        inlineChildren.push.apply(inlineChildren, (0, _toConsumableArray2["default"])(_getDeepInlineChildren(editor, {
+          children: getChildren(child)
+        })));
+      } else {
+        inlineChildren.push(child);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return inlineChildren;
+};
+var getLastChildPath = exports.getLastChildPath = function getLastChildPath(nodeEntry) {
+  var lastChild = getLastChild(nodeEntry);
+  if (!lastChild) return nodeEntry[1].concat([-1]);
+  return lastChild[1];
+};
+var getPreviousPath = exports.getPreviousPath = function getPreviousPath(path) {
+  if (path.length === 0) return;
+  var last = path[path.length - 1];
+  if (last <= 0) return;
+  return path.slice(0, -1).concat(last - 1);
+};
+var getSelectedElems = exports.getSelectedElems = function getSelectedElems(editor) {
+  var elems = [];
+  var nodeEntries = _slate.Editor.nodes(editor, {
+    universal: true
+  });
+  var _iterator2 = (0, _createForOfIteratorHelper2["default"])(nodeEntries),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var nodeEntry = _step2.value;
+      var _nodeEntry3 = (0, _slicedToArray2["default"])(nodeEntry, 1),
+        node = _nodeEntry3[0];
+      if (_slate.Element.isElement(node)) elems.push(node);
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return elems;
+};
+
+// siblings
+var getNextSiblingNodes = exports.getNextSiblingNodes = function getNextSiblingNodes(ancestorEntry, path) {
+  var _ancestorEntry = (0, _slicedToArray2["default"])(ancestorEntry, 2),
+    ancestor = _ancestorEntry[0],
+    ancestorPath = _ancestorEntry[1];
+  var leafIndex = path[ancestorPath.length];
+  var siblings = [];
+  var ancestorChildren = ancestor.children;
+  if (leafIndex + 1 < ancestor.children.length) {
+    for (var i = leafIndex + 1; i < ancestor.children.length; i++) {
+      siblings.push(ancestorChildren[i]);
+    }
+  }
+  return siblings;
+};
+
+// parent
+var getAboveNode = exports.getAboveNode = function getAboveNode(editor, options) {
+  return _slate.Editor.above(editor, getQueryOptions(editor, options));
+};
+var getAboveBlockNode = exports.getAboveBlockNode = function getAboveBlockNode(editor, options) {
+  return getAboveNode(editor, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, options), {}, {
+    block: true
+  }));
+};
+var getTopLevelBlockNode = exports.getTopLevelBlockNode = function getTopLevelBlockNode(editor) {
+  return getAboveBlockNode(editor, {
+    match: function match(n, p) {
+      return _slate.Element.isElement(n) && p.length === 1;
+    }
+  });
+};
+var getPrevNode = exports.getPrevNode = function getPrevNode(editor) {
+  var lowerNodeEntry = getAboveNode(editor, {
+    mode: 'lowest',
+    match: function match(n) {
+      return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+    }
+  });
+  var highNodeEntry = getAboveNode(editor, {
+    mode: 'highest',
+    match: function match(n) {
+      return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+    }
+  });
+  if (!lowerNodeEntry || !highNodeEntry) return null;
+  var _highNodeEntry = (0, _slicedToArray2["default"])(highNodeEntry, 2),
+    heightNode = _highNodeEntry[0],
+    heightPath = _highNodeEntry[1];
+  var _lowerNodeEntry = (0, _slicedToArray2["default"])(lowerNodeEntry, 2),
+    lowerNode = _lowerNodeEntry[0],
+    lowerPath = _lowerNodeEntry[1];
+  var prevNode = null;
+  try {
+    prevNode = _slate.Editor.previous(editor, {
+      at: lowerPath,
+      match: function match(n) {
+        return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+      }
+    });
+  } catch (error) {
+    prevNode = null;
+  }
+  if (lowerNode.id !== heightNode.id && !prevNode) {
+    try {
+      prevNode = _slate.Editor.previous(editor, {
+        at: heightPath,
+        match: function match(n) {
+          return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+        }
+      });
+    } catch (error) {
+      prevNode = null;
+    }
+  }
+  return prevNode;
+};
+var getCurrentNode = exports.getCurrentNode = function getCurrentNode(editor) {
+  if (!editor.selection) return null;
+  var _Editor$nodes7 = _slate.Editor.nodes(editor, {
+      at: editor.selection,
+      match: function match(n) {
+        return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+      },
+      mode: 'lowest'
+    }),
+    _Editor$nodes8 = (0, _slicedToArray2["default"])(_Editor$nodes7, 1),
+    nodeEntry = _Editor$nodes8[0];
+  return nodeEntry || null;
+};
+var getNextNode = exports.getNextNode = function getNextNode(editor) {
+  var _getAboveNode = getAboveNode(editor, {
+      mode: 'lowest',
+      match: function match(n) {
+        return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+      }
+    }),
+    _getAboveNode2 = (0, _slicedToArray2["default"])(_getAboveNode, 2),
+    lowerNode = _getAboveNode2[0],
+    lowerPath = _getAboveNode2[1];
+  var _getAboveNode3 = getAboveNode(editor, {
+      mode: 'highest',
+      match: function match(n) {
+        return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+      }
+    }),
+    _getAboveNode4 = (0, _slicedToArray2["default"])(_getAboveNode3, 2),
+    heightNode = _getAboveNode4[0],
+    heightPath = _getAboveNode4[1];
+  var nextNode = null;
+  try {
+    nextNode = _slate.Editor.next(editor, {
+      at: lowerPath,
+      match: function match(n) {
+        return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+      }
+    });
+  } catch (error) {
+    nextNode = null;
+  }
+  if (lowerNode.id !== heightNode.id && !nextNode) {
+    try {
+      nextNode = _slate.Editor.next(editor, {
+        at: heightPath,
+        match: function match(n) {
+          return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+        }
+      });
+    } catch (error) {
+      nextNode = null;
+    }
+  }
+  return nextNode;
+};
+
+// find node
+var findNode = exports.findNode = function findNode(editor, options) {
+  var nodeEntries = _slate.Editor.nodes(editor, (0, _objectSpread2["default"])({
+    at: editor.selection || []
+  }, getQueryOptions(editor, options)));
+  var _nodeEntries = Array.from(nodeEntries);
+  if (_nodeEntries[0]) {
+    return _nodeEntries[0];
+  }
+  return undefined;
+};
+var findDescendant = exports.findDescendant = function findDescendant(editor, options) {
+  var _options$at = options.at,
+    at = _options$at === void 0 ? editor.selection : _options$at,
+    _options$reverse = options.reverse,
+    reverse = _options$reverse === void 0 ? false : _options$reverse,
+    _options$voids = options.voids,
+    voids = _options$voids === void 0 ? false : _options$voids,
+    _match = options.match;
+  if (!at) return;
+  var from;
+  var to;
+  if (_slate.Span.isSpan(at)) {
+    var _at = (0, _slicedToArray2["default"])(at, 2);
+    from = _at[0];
+    to = _at[1];
+  } else if (_slate.Range.isRange(at)) {
+    var first = _slate.Editor.first(editor, at);
+    var last = _slate.Editor.last(editor, at);
+    from = reverse ? last : first;
+    to = reverse ? first : last;
+  }
+  var root = [editor, []];
+  if (_slate.Path.isPath(at)) {
+    root = _slate.Editor.node(editor, at);
+  }
+  var nodeEntries = _slate.Node.descendants(root[0], {
+    from: from,
+    to: to,
+    reverse: reverse,
+    pass: function pass(_ref2) {
+      var _ref3 = (0, _slicedToArray2["default"])(_ref2, 1),
+        n = _ref3[0];
+      return voids ? false : _slate.Editor.isVoid(editor, n);
+    }
+  });
+  var _iterator3 = (0, _createForOfIteratorHelper2["default"])(nodeEntries),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _step3$value = (0, _slicedToArray2["default"])(_step3.value, 2),
+        node = _step3$value[0],
+        path = _step3$value[1];
+      if ((0, _utils.match)(node, path, _match)) {
+        return [node, at.concat(path)];
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return undefined;
+};
+
+// is
+var isTextNode = exports.isTextNode = function isTextNode(node) {
+  if (!node) return false;
+  if (_slate.Text.isText(node)) return true;
+  return false;
+};
+var isLastChild = exports.isLastChild = function isLastChild(nodeEntry, childPath) {
+  var lastChildPath = getLastChildPath(nodeEntry);
+  return _slate.Path.equals(lastChildPath, childPath);
+};
+var isStartPoint = exports.isStartPoint = function isStartPoint(editor, point, at) {
+  return !!point && _slate.Editor.isStart(editor, point, at);
+};
+var isEndPoint = exports.isEndPoint = function isEndPoint(editor, point, at) {
+  return !!point && _slate.Editor.isEnd(editor, point, at);
+};
+var isMiddlePoint = exports.isMiddlePoint = function isMiddlePoint(editor, point, at) {
+  return !isStartPoint(editor, point, at) && !isEndPoint(editor, point, at);
+};
+var isBlockTextEmptyAfterSelection = exports.isBlockTextEmptyAfterSelection = function isBlockTextEmptyAfterSelection(editor) {
+  if (!editor.selection) return false;
+  var blockAbove = _slate.Editor.above(editor, {
+    block: true
+  });
+  if (!blockAbove) return false;
+  var cursor = editor.selection.focus;
+  var selectionParentEntry = _slate.Editor.parent(editor, editor.selection);
+  if (!selectionParentEntry) return false;
+  var _selectionParentEntry = (0, _slicedToArray2["default"])(selectionParentEntry, 2),
+    selectionParentPath = _selectionParentEntry[1];
+  if (!isEndPoint(editor, cursor, selectionParentPath)) return false;
+  var siblingNodes = getNextSiblingNodes(blockAbove, cursor.path);
+  if (siblingNodes.length) {
+    // 子节点包含 文本节点
+    var _iterator4 = (0, _createForOfIteratorHelper2["default"])(siblingNodes),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var siblingNode = _step4.value;
+        if (_slate.Text.isText(siblingNode) && siblingNode.text) {
+          return false;
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+  } else {
+    return isEndPoint(editor, cursor, blockAbove[1]);
+  }
+  return true;
+};
+var isRangeAcrossBlocks = exports.isRangeAcrossBlocks = function isRangeAcrossBlocks(editor) {
+  var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    at = _ref4.at,
+    options = (0, _objectWithoutProperties2["default"])(_ref4, _excluded);
+  try {
+    if (!at) at = editor.selection;
+    if (!at) return;
+    var _Range$edges = _slate.Range.edges(at),
+      _Range$edges2 = (0, _slicedToArray2["default"])(_Range$edges, 2),
+      start = _Range$edges2[0],
+      end = _Range$edges2[1];
+    var startBlock = getAboveBlockNode(editor, (0, _objectSpread2["default"])({
+      at: start
+    }, options));
+    var endBlock = getAboveBlockNode(editor, (0, _objectSpread2["default"])({
+      at: end
+    }, options));
+    if (!startBlock && !endBlock) return;
+    if (!startBlock || !endBlock) return true;
+    return !_slate.Path.equals(startBlock[1], endBlock[1]);
+  } catch (error) {
+    return true;
+  }
+};
+var isAncestorEmpty = exports.isAncestorEmpty = function isAncestorEmpty(editor, node) {
+  return !_slate.Node.string(node) && !node.children.some(function (n) {
+    return _slate.Editor.isInline(editor, n);
+  });
+};
+var isBlockAboveEmpty = exports.isBlockAboveEmpty = function isBlockAboveEmpty(editor) {
+  var _getAboveBlockNode;
+  var block = (_getAboveBlockNode = getAboveBlockNode(editor)) === null || _getAboveBlockNode === void 0 ? void 0 : _getAboveBlockNode[0];
+  if (!block) return false;
+  return isAncestorEmpty(editor, block);
+};
+var isCursorAtBlockStart = exports.isCursorAtBlockStart = function isCursorAtBlockStart(editor, options) {
+  var selection = editor.selection;
+  if (!selection) return false;
+  var nodeEntry = getAboveBlockNode(editor, options);
+  var _ref5 = nodeEntry || [],
+    _ref6 = (0, _slicedToArray2["default"])(_ref5, 2),
+    node = _ref6[0],
+    path = _ref6[1];
+  if (!path) return false;
+
+  // Special handling of placeholders, such as link, inline image
+  if (_slate.Node.string(node.children[0]).length === 0) {
+    var _selection$focus = selection.focus,
+      offset = _selection$focus.offset,
+      point = _selection$focus.path;
+    if (offset !== 0) return false;
+    return _slate.Path.equals(point, [path[0], 1, 0]);
+  }
+  return isStartPoint(editor, selection.focus, path);
+};
+var isSelectionAtBlockStart = exports.isSelectionAtBlockStart = function isSelectionAtBlockStart(editor, options) {
+  var selection = editor.selection;
+  if (!selection) return false;
+  var nodeEntry = getAboveBlockNode(editor, options);
+  var path = nodeEntry === null || nodeEntry === void 0 ? void 0 : nodeEntry[1];
+  if ((nodeEntry === null || nodeEntry === void 0 ? void 0 : nodeEntry[0].type) === _constants.CODE_LINE) {
+    path = [path[0]];
+  }
+  if (!path) return false;
+  return isStartPoint(editor, selection.focus, path) || _slate.Range.isExpanded(editor.selection) && isStartPoint(editor, selection.anchor, path);
+};
+var isSelectionAtBlockEnd = exports.isSelectionAtBlockEnd = function isSelectionAtBlockEnd(editor, options) {
+  var _getAboveBlockNode2, _editor$selection;
+  var path = (_getAboveBlockNode2 = getAboveBlockNode(editor, options)) === null || _getAboveBlockNode2 === void 0 ? void 0 : _getAboveBlockNode2[1];
+  return !!path && isEndPoint(editor, (_editor$selection = editor.selection) === null || _editor$selection === void 0 ? void 0 : _editor$selection.focus, path);
+};
+var isLastNode = exports.isLastNode = function isLastNode(editor, node) {
+  var editorChildren = editor.children || [];
+  var editorChildrenLength = editorChildren.length;
+  return editorChildren[editorChildrenLength - 1] === node;
+};
+var isHasImg = exports.isHasImg = function isHasImg(editor) {
+  var hasImg = false;
+  var _iterator5 = (0, _createForOfIteratorHelper2["default"])(_slate.Editor.nodes(editor, {
+      at: editor.selection
+    })),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var _step5$value = (0, _slicedToArray2["default"])(_step5.value, 1),
+        node = _step5$value[0];
+      if ((node === null || node === void 0 ? void 0 : node.type) === 'image') {
+        hasImg = true;
+      }
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  return hasImg;
+};
+var isCurrentLineEmpty = exports.isCurrentLineEmpty = function isCurrentLineEmpty(editor) {
+  var selection = editor.selection;
+  if (!selection || !_slateReact.ReactEditor.isFocused(editor)) return false;
+  var _Editor$node = _slate.Editor.node(editor, selection.focus.path.slice(0, -1)),
+    _Editor$node2 = (0, _slicedToArray2["default"])(_Editor$node, 1),
+    node = _Editor$node2[0];
+  if (_slate.Element.isElement(node)) {
+    return node.children.every(function (child) {
+      return _slate.Element.isElement(child) ? false : _slate.Node.string(child) === '';
+    });
+  }
+  return true;
+};
+var isCurrentLineHasText = exports.isCurrentLineHasText = function isCurrentLineHasText(node) {
+  return _slate.Node.string(node).trim() !== '';
+};
+var isMultiLevelList = exports.isMultiLevelList = function isMultiLevelList(listNode) {
+  var _ref7 = listNode || {},
+    children = _ref7.children;
+  var isMultiLevel = children !== null && children !== void 0 && children.find(function (item) {
+    return (item === null || item === void 0 ? void 0 : item.children.length) > 1;
+  }) ? true : false;
+  return isMultiLevel;
+};
+var isTopLevelListItem = exports.isTopLevelListItem = function isTopLevelListItem(editor) {
+  var selection = editor.selection;
+  if (!selection) return false;
+  var _ref8 = _slate.Editor.parent(editor, selection) || [],
+    _ref9 = (0, _slicedToArray2["default"])(_ref8, 2),
+    paragraphPath = _ref9[1];
+  if (paragraphPath.length !== 0) {
+    var _ref0 = _slate.Editor.parent(editor, paragraphPath) || [],
+      _ref1 = (0, _slicedToArray2["default"])(_ref0, 2),
+      listItemNode = _ref1[0],
+      listItemPath = _ref1[1];
+    return listItemNode && listItemPath && (listItemNode === null || listItemNode === void 0 ? void 0 : listItemNode.type) === _constants.LIST_ITEM && (listItemPath === null || listItemPath === void 0 ? void 0 : listItemPath.length) === 2;
+  }
+  return false;
+};
+var isRangeInSameBlock = exports.isRangeInSameBlock = function isRangeInSameBlock(editor) {
+  var _ref10 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    at = _ref10.at,
+    options = (0, _objectWithoutProperties2["default"])(_ref10, _excluded2);
+  if (!at) at = editor.selection;
+  if (!at) return;
+  var _Range$edges3 = _slate.Range.edges(at),
+    _Range$edges4 = (0, _slicedToArray2["default"])(_Range$edges3, 2),
+    start = _Range$edges4[0],
+    end = _Range$edges4[1];
+  var startBlock = getAboveNode(editor, (0, _objectSpread2["default"])({
+    at: start
+  }, options));
+  var endBlock = getAboveNode(editor, (0, _objectSpread2["default"])({
+    at: end
+  }, options));
+  if (!startBlock || !endBlock) return;
+  return _slate.Path.equals(startBlock[1], endBlock[1]);
+};
+var isFirstChild = exports.isFirstChild = function isFirstChild(path) {
+  return path.at(-1) === 0;
+};
+var isEmptyArticle = exports.isEmptyArticle = function isEmptyArticle(editor) {
+  if (editor.children.length === 0) {
+    return true;
+  }
+  return false;
+};
+var isContainsVoidElement = exports.isContainsVoidElement = function isContainsVoidElement(root) {
+  var nodes = _slate.Node.nodes(root);
+  var _iterator6 = (0, _createForOfIteratorHelper2["default"])(nodes),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var nodeEntry = _step6.value;
+      var _nodeEntry4 = (0, _slicedToArray2["default"])(nodeEntry, 1),
+        n = _nodeEntry4[0];
+      if ((n === null || n === void 0 ? void 0 : n.type) === _constants.IMAGE) {
+        return true;
+      }
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  return false;
+};
+var getStartPoint = exports.getStartPoint = function getStartPoint(editor, at) {
+  return _slate.Editor.start(editor, at);
+};
+var getEndPoint = exports.getEndPoint = function getEndPoint(editor, at) {
+  return _slate.Editor.end(editor, at);
+};
+var getPointBefore = exports.getPointBefore = function getPointBefore(editor, at) {
+  return _slate.Editor.before(editor, at);
+};
+var someNode = exports.someNode = function someNode(editor, options) {
+  return !!findNode(editor, options);
+};