@seafile/sdoc-editor 0.3.6 → 0.3.7

package/dist/basic-sdk/extension/core/queries/index.js

@@ -1,9 +1,6 @@
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-var _excluded = ["at"];
+const _excluded = ["at"];
 import { Editor, Text, Path, Span, Element, Node, Range } from '@seafile/slate';
 import { ReactEditor } from '@seafile/slate-react';
 import { match } from '../utils';
@@ -11,30 +8,30 @@ import ObjectUtils from '../../../utils/object-utils';
 import { CODE_LINE } from '../../constants';
 
 // options
-export var getQueryOptions = function getQueryOptions(editor, options) {
-  var _match = options.match,
-    block = options.block;
-  var newMatch = undefined;
+export const getQueryOptions = (editor, options) => {
+  const {
+    match: _match,
+    block
+  } = options;
+  let newMatch = undefined;
   if (_match || block) {
-    newMatch = function newMatch(n, path) {
-      return match(n, path, _match) && (!block || Editor.isBlock(editor, n));
-    };
+    newMatch = (n, path) => match(n, path, _match) && (!block || Editor.isBlock(editor, n));
   }
   return _objectSpread(_objectSpread({}, options), {}, {
     match: newMatch
   });
 };
-export var findPath = function findPath(editor, node, defaultPath) {
+export const findPath = (editor, node, defaultPath) => {
   try {
     return ReactEditor.findPath(editor, node);
-  } catch (_unused) {
+  } catch {
     return defaultPath;
   }
 };
 
 // get node
-export var getNode = function getNode(editor, path) {
-  var node = null;
+export const getNode = (editor, path) => {
+  let node = null;
   try {
     node = Node.get(editor, path);
   } catch (err) {
@@ -42,22 +39,22 @@ export var getNode = function getNode(editor, path) {
   }
   return node;
 };
-export var getNodeType = function getNodeType(node) {
+export const getNodeType = node => {
   return Element.isElement(node) ? node.type : '';
 };
-export var getNodeById = function getNodeById(nodes, nodeId) {
-  var node;
-  for (var i = 0; i < nodes.length; i++) {
-    var currentNode = nodes[i];
+export const getNodeById = (nodes, nodeId) => {
+  let node;
+  for (let i = 0; i < nodes.length; i++) {
+    const currentNode = nodes[i];
     if (currentNode.id === nodeId) {
       node = currentNode;
       break;
     }
-    var childrenNodes = currentNode.children;
+    const {
+      children: childrenNodes
+    } = currentNode;
     if (!Array.isArray(childrenNodes)) continue;
-    var childNode = childrenNodes.find(function (node) {
-      return node.id === nodeId;
-    });
+    let childNode = childrenNodes.find(node => node.id === nodeId);
     if (childNode) {
       node = childNode;
       break;
@@ -69,19 +66,19 @@ export var getNodeById = function getNodeById(nodes, nodeId) {
   }
   return node;
 };
-export var isTextNode = function isTextNode(node) {
+export const isTextNode = node => {
   if (!node) return false;
   if (!ObjectUtils.hasProperty(node, 'children') && ObjectUtils.hasProperty(node, 'text')) return true;
 };
-export var getParentNode = function getParentNode(nodes, nodeId) {
-  var parentNode;
-  for (var i = 0; i < nodes.length; i++) {
-    var node = nodes[i];
-    var childrenNodes = node.children;
+export const getParentNode = (nodes, nodeId) => {
+  let parentNode;
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const {
+      children: childrenNodes
+    } = node;
     if (!Array.isArray(childrenNodes)) continue;
-    if (childrenNodes.find(function (node) {
-      return node.id === nodeId;
-    })) {
+    if (childrenNodes.find(node => node.id === nodeId)) {
       parentNode = node;
     } else {
       parentNode = getParentNode(childrenNodes, nodeId);
@@ -91,52 +88,40 @@ export var getParentNode = function getParentNode(nodes, nodeId) {
   }
   return parentNode;
 };
-export var getNodes = function getNodes(node, options) {
+export const getNodes = (node, options) => {
   return Node.nodes(node, options);
 };
-export var getCommonNode = function getCommonNode(root, path, ancestor) {
+export const getCommonNode = (root, path, ancestor) => {
   return Node.common(root, path, ancestor);
 };
-export var getSelectedNodeByType = function getSelectedNodeByType(editor, type) {
-  var match = function match(n) {
-    return getNodeType(n) === type;
-  };
-  var _Editor$nodes = Editor.nodes(editor, {
-      match: match,
-      universal: true
-    }),
-    _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),
-    nodeEntry = _Editor$nodes2[0];
+export const getSelectedNodeByType = (editor, type) => {
+  const match = n => getNodeType(n) === type;
+  const [nodeEntry] = Editor.nodes(editor, {
+    match,
+    universal: true
+  });
   return nodeEntry ? nodeEntry[0] : null;
 };
-export var getSelectedNodeByTypes = function getSelectedNodeByTypes(editor, types) {
-  var match = function match(n) {
-    return types.includes(getNodeType(n));
-  };
-  var _Editor$nodes3 = Editor.nodes(editor, {
-      match: match,
-      universal: true
-    }),
-    _Editor$nodes4 = _slicedToArray(_Editor$nodes3, 1),
-    nodeEntry = _Editor$nodes4[0];
+export const getSelectedNodeByTypes = (editor, types) => {
+  const match = n => types.includes(getNodeType(n));
+  const [nodeEntry] = Editor.nodes(editor, {
+    match,
+    universal: true
+  });
   return nodeEntry ? nodeEntry[0] : null;
 };
-export var getSelectedNodeEntryByType = function getSelectedNodeEntryByType(editor, type) {
-  var match = function match(n) {
-    return getNodeType(n) === type;
-  };
-  var _Editor$nodes5 = Editor.nodes(editor, {
-      match: match,
-      universal: false
-    }),
-    _Editor$nodes6 = _slicedToArray(_Editor$nodes5, 1),
-    nodeEntry = _Editor$nodes6[0];
+export const getSelectedNodeEntryByType = (editor, type) => {
+  const match = n => getNodeType(n) === type;
+  const [nodeEntry] = Editor.nodes(editor, {
+    match,
+    universal: false
+  });
   return nodeEntry ? nodeEntry : null;
 };
-export var getNodeEntries = function getNodeEntries(editor, options) {
+export const getNodeEntries = (editor, options) => {
   return Editor.nodes(editor, getQueryOptions(editor, options));
 };
-export var getEditorString = function getEditorString(editor, at, options) {
+export const getEditorString = (editor, at, options) => {
   if (!at) return '';
   try {
     return Editor.string(editor, at, options);
@@ -146,98 +131,77 @@ export var getEditorString = function getEditorString(editor, at, options) {
 };
 
 // children & child
-export var getChildren = function getChildren(nodeEntry) {
-  var _nodeEntry = _slicedToArray(nodeEntry, 2),
-    node = _nodeEntry[0],
-    path = _nodeEntry[1];
+export const getChildren = nodeEntry => {
+  const [node, path] = nodeEntry;
   if (Element.isAncestor(node)) {
-    var children = node.children;
-    return children.map(function (child, index) {
-      var childPath = path.concat([index]);
+    const {
+      children
+    } = node;
+    return children.map((child, index) => {
+      const childPath = path.concat([index]);
       return [child, childPath];
     });
   }
   return [];
 };
-export var getLastChild = function getLastChild(nodeEntry) {
-  var _nodeEntry2 = _slicedToArray(nodeEntry, 2),
-    node = _nodeEntry2[0],
-    path = _nodeEntry2[1];
+export const getLastChild = nodeEntry => {
+  const [node, path] = nodeEntry;
   if (Text.isText(node)) return null;
   if (!node.children.length) return null;
-  var children = node.children;
+  const children = node.children;
   return [children[children.length - 1], path.concat([children.length - 1])];
 };
-export var getDeepInlineChildren = function getDeepInlineChildren(editor, _ref) {
-  var children = _ref.children;
-  var inlineChildren = [];
-  var _iterator = _createForOfIteratorHelper(children),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var child = _step.value;
-      if (Editor.isBlock(editor, child[0])) {
-        inlineChildren.push.apply(inlineChildren, _toConsumableArray(getDeepInlineChildren(editor, {
-          children: getChildren(child)
-        })));
-      } else {
-        inlineChildren.push(child);
-      }
+export const getDeepInlineChildren = (editor, _ref) => {
+  let {
+    children
+  } = _ref;
+  const inlineChildren = [];
+  for (let child of children) {
+    if (Editor.isBlock(editor, child[0])) {
+      inlineChildren.push(...getDeepInlineChildren(editor, {
+        children: getChildren(child)
+      }));
+    } else {
+      inlineChildren.push(child);
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
   return inlineChildren;
 };
-export var getLastChildPath = function getLastChildPath(nodeEntry) {
-  var lastChild = getLastChild(nodeEntry);
+export const getLastChildPath = nodeEntry => {
+  const lastChild = getLastChild(nodeEntry);
   if (!lastChild) return nodeEntry[1].concat([-1]);
   return lastChild[1];
 };
-export var getPreviousPath = function getPreviousPath(path) {
+export const getPreviousPath = path => {
   if (path.length === 0) return;
-  var last = path[path.length - 1];
+  const last = path[path.length - 1];
   if (last <= 0) return;
   return path.slice(0, -1).concat(last - 1);
 };
-export var isLastChild = function isLastChild(nodeEntry, childPath) {
-  var lastChildPath = getLastChildPath(nodeEntry);
+export const isLastChild = (nodeEntry, childPath) => {
+  const lastChildPath = getLastChildPath(nodeEntry);
   return Path.equals(lastChildPath, childPath);
 };
-export var getSelectedElems = function getSelectedElems(editor) {
-  var elems = [];
-  var nodeEntries = Editor.nodes(editor, {
+export const getSelectedElems = editor => {
+  const elems = [];
+  const nodeEntries = Editor.nodes(editor, {
     universal: true
   });
-  var _iterator2 = _createForOfIteratorHelper(nodeEntries),
-    _step2;
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var nodeEntry = _step2.value;
-      var _nodeEntry3 = _slicedToArray(nodeEntry, 1),
-        node = _nodeEntry3[0];
-      if (Element.isElement(node)) elems.push(node);
-    }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
+  for (let nodeEntry of nodeEntries) {
+    const [node] = nodeEntry;
+    if (Element.isElement(node)) elems.push(node);
   }
   return elems;
 };
 
 // siblings
-export var getNextSiblingNodes = function getNextSiblingNodes(ancestorEntry, path) {
-  var _ancestorEntry = _slicedToArray(ancestorEntry, 2),
-    ancestor = _ancestorEntry[0],
-    ancestorPath = _ancestorEntry[1];
-  var leafIndex = path[ancestorPath.length];
-  var siblings = [];
-  var ancestorChildren = ancestor.children;
+export const getNextSiblingNodes = (ancestorEntry, path) => {
+  const [ancestor, ancestorPath] = ancestorEntry;
+  const leafIndex = path[ancestorPath.length];
+  const siblings = [];
+  const ancestorChildren = ancestor.children;
   if (leafIndex + 1 < ancestor.children.length) {
-    for (var i = leafIndex + 1; i < ancestor.children.length; i++) {
+    for (let i = leafIndex + 1; i < ancestor.children.length; i++) {
       siblings.push(ancestorChildren[i]);
     }
   }
@@ -245,40 +209,28 @@ export var getNextSiblingNodes = function getNextSiblingNodes(ancestorEntry, pat
 };
 
 // parent
-export var getAboveNode = function getAboveNode(editor, options) {
+export const getAboveNode = (editor, options) => {
   return Editor.above(editor, getQueryOptions(editor, options));
 };
-export var getAboveBlockNode = function getAboveBlockNode(editor, options) {
+export const getAboveBlockNode = (editor, options) => {
   return getAboveNode(editor, _objectSpread(_objectSpread({}, options), {}, {
     block: true
   }));
 };
-export var getPrevNode = function getPrevNode(editor) {
-  var _getAboveNode = getAboveNode(editor, {
-      mode: 'lowest',
-      match: function match(n) {
-        return Element.isElement(n) && Editor.isBlock(editor, n);
-      }
-    }),
-    _getAboveNode2 = _slicedToArray(_getAboveNode, 2),
-    lowerNode = _getAboveNode2[0],
-    lowerPath = _getAboveNode2[1];
-  var _getAboveNode3 = getAboveNode(editor, {
-      mode: 'highest',
-      match: function match(n) {
-        return Element.isElement(n) && Editor.isBlock(editor, n);
-      }
-    }),
-    _getAboveNode4 = _slicedToArray(_getAboveNode3, 2),
-    heightNode = _getAboveNode4[0],
-    heightPath = _getAboveNode4[1];
-  var prevNode = null;
+export const getPrevNode = editor => {
+  const [lowerNode, lowerPath] = getAboveNode(editor, {
+    mode: 'lowest',
+    match: n => Element.isElement(n) && Editor.isBlock(editor, n)
+  });
+  const [heightNode, heightPath] = getAboveNode(editor, {
+    mode: 'highest',
+    match: n => Element.isElement(n) && Editor.isBlock(editor, n)
+  });
+  let prevNode = null;
   try {
     prevNode = Editor.previous(editor, {
       at: lowerPath,
-      match: function match(n) {
-        return Element.isElement(n) && Editor.isBlock(editor, n);
-      }
+      match: n => Element.isElement(n) && Editor.isBlock(editor, n)
     });
   } catch (error) {
     prevNode = null;
@@ -287,9 +239,7 @@ export var getPrevNode = function getPrevNode(editor) {
     try {
       prevNode = Editor.previous(editor, {
         at: heightPath,
-        match: function match(n) {
-          return Element.isElement(n) && Editor.isBlock(editor, n);
-        }
+        match: n => Element.isElement(n) && Editor.isBlock(editor, n)
       });
     } catch (error) {
       prevNode = null;
@@ -297,32 +247,20 @@ export var getPrevNode = function getPrevNode(editor) {
   }
   return prevNode;
 };
-export var getNextNode = function getNextNode(editor) {
-  var _getAboveNode5 = getAboveNode(editor, {
-      mode: 'lowest',
-      match: function match(n) {
-        return Element.isElement(n) && Editor.isBlock(editor, n);
-      }
-    }),
-    _getAboveNode6 = _slicedToArray(_getAboveNode5, 2),
-    lowerNode = _getAboveNode6[0],
-    lowerPath = _getAboveNode6[1];
-  var _getAboveNode7 = getAboveNode(editor, {
-      mode: 'highest',
-      match: function match(n) {
-        return Element.isElement(n) && Editor.isBlock(editor, n);
-      }
-    }),
-    _getAboveNode8 = _slicedToArray(_getAboveNode7, 2),
-    heightNode = _getAboveNode8[0],
-    heightPath = _getAboveNode8[1];
-  var nextNode = null;
+export const getNextNode = editor => {
+  const [lowerNode, lowerPath] = getAboveNode(editor, {
+    mode: 'lowest',
+    match: n => Element.isElement(n) && Editor.isBlock(editor, n)
+  });
+  const [heightNode, heightPath] = getAboveNode(editor, {
+    mode: 'highest',
+    match: n => Element.isElement(n) && Editor.isBlock(editor, n)
+  });
+  let nextNode = null;
   try {
     nextNode = Editor.next(editor, {
       at: lowerPath,
-      match: function match(n) {
-        return Element.isElement(n) && Editor.isBlock(editor, n);
-      }
+      match: n => Element.isElement(n) && Editor.isBlock(editor, n)
     });
   } catch (error) {
     nextNode = null;
@@ -331,9 +269,7 @@ export var getNextNode = function getNextNode(editor) {
     try {
       nextNode = Editor.next(editor, {
         at: heightPath,
-        match: function match(n) {
-          return Element.isElement(n) && Editor.isBlock(editor, n);
-        }
+        match: n => Element.isElement(n) && Editor.isBlock(editor, n)
       });
     } catch (error) {
       nextNode = null;
@@ -343,181 +279,145 @@ export var getNextNode = function getNextNode(editor) {
 };
 
 // find node
-export var findNode = function findNode(editor, options) {
-  var nodeEntries = Editor.nodes(editor, _objectSpread({
+export const findNode = (editor, options) => {
+  const nodeEntries = Editor.nodes(editor, _objectSpread({
     at: editor.selection || []
   }, getQueryOptions(editor, options)));
-  var _nodeEntries = Array.from(nodeEntries);
+  const _nodeEntries = Array.from(nodeEntries);
   if (_nodeEntries[0]) {
     return _nodeEntries[0];
   }
   return undefined;
 };
-export var 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;
+export const findDescendant = (editor, options) => {
+  const {
+    at = editor.selection,
+    reverse = false,
+    voids = false,
+    match: _match
+  } = options;
   if (!at) return;
-  var from;
-  var to;
+  let from;
+  let to;
   if (Span.isSpan(at)) {
-    var _at = _slicedToArray(at, 2);
-    from = _at[0];
-    to = _at[1];
+    [from, to] = at;
   } else if (Range.isRange(at)) {
-    var first = Editor.first(editor, at);
-    var last = Editor.last(editor, at);
+    const first = Editor.first(editor, at);
+    const last = Editor.last(editor, at);
     from = reverse ? last : first;
     to = reverse ? first : last;
   }
-  var root = [editor, []];
+  let root = [editor, []];
   if (Path.isPath(at)) {
     root = Editor.node(editor, at);
   }
-  var nodeEntries = Node.descendants(root[0], {
-    from: from,
-    to: to,
-    reverse: reverse,
-    pass: function pass(_ref2) {
-      var _ref3 = _slicedToArray(_ref2, 1),
-        n = _ref3[0];
+  const nodeEntries = Node.descendants(root[0], {
+    from,
+    to,
+    reverse,
+    pass: _ref2 => {
+      let [n] = _ref2;
       return voids ? false : Editor.isVoid(editor, n);
     }
   });
-  var _iterator3 = _createForOfIteratorHelper(nodeEntries),
-    _step3;
-  try {
-    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-      var _step3$value = _slicedToArray(_step3.value, 2),
-        node = _step3$value[0],
-        path = _step3$value[1];
-      if (match(node, path, _match)) {
-        return [node, at.concat(path)];
-      }
+  for (const [node, path] of nodeEntries) {
+    if (match(node, path, _match)) {
+      return [node, at.concat(path)];
     }
-  } catch (err) {
-    _iterator3.e(err);
-  } finally {
-    _iterator3.f();
   }
   return undefined;
 };
 
 // is
-export var isStartPoint = function isStartPoint(editor, point, at) {
+export const isStartPoint = (editor, point, at) => {
   return !!point && Editor.isStart(editor, point, at);
 };
-export var isEndPoint = function isEndPoint(editor, point, at) {
+export const isEndPoint = (editor, point, at) => {
   return !!point && Editor.isEnd(editor, point, at);
 };
-export var isBlockTextEmptyAfterSelection = function isBlockTextEmptyAfterSelection(editor) {
+export const isBlockTextEmptyAfterSelection = editor => {
   if (!editor.selection) return false;
-  var blockAbove = Editor.above(editor, {
+  const blockAbove = Editor.above(editor, {
     block: true
   });
   if (!blockAbove) return false;
-  var cursor = editor.selection.focus;
-  var selectionParentEntry = Editor.parent(editor, editor.selection);
+  const cursor = editor.selection.focus;
+  const selectionParentEntry = Editor.parent(editor, editor.selection);
   if (!selectionParentEntry) return false;
-  var _selectionParentEntry = _slicedToArray(selectionParentEntry, 2),
-    selectionParentPath = _selectionParentEntry[1];
+  const [, selectionParentPath] = selectionParentEntry;
   if (!isEndPoint(editor, cursor, selectionParentPath)) return false;
-  var siblingNodes = getNextSiblingNodes(blockAbove, cursor.path);
+  const siblingNodes = getNextSiblingNodes(blockAbove, cursor.path);
   if (siblingNodes.length) {
     // 子节点包含 文本节点
-    var _iterator4 = _createForOfIteratorHelper(siblingNodes),
-      _step4;
-    try {
-      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-        var siblingNode = _step4.value;
-        if (Text.isText(siblingNode) && siblingNode.text) {
-          return false;
-        }
+    for (const siblingNode of siblingNodes) {
+      if (Text.isText(siblingNode) && siblingNode.text) {
+        return false;
       }
-    } catch (err) {
-      _iterator4.e(err);
-    } finally {
-      _iterator4.f();
     }
   } else {
     return isEndPoint(editor, cursor, blockAbove[1]);
   }
   return true;
 };
-export var isRangeAcrossBlocks = function isRangeAcrossBlocks(editor) {
-  var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var at = _ref4.at,
-    options = _objectWithoutProperties(_ref4, _excluded);
+export const isRangeAcrossBlocks = function (editor) {
+  let _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let {
+      at
+    } = _ref3,
+    options = _objectWithoutProperties(_ref3, _excluded);
   if (!at) at = editor.selection;
   if (!at) return;
-  var _Range$edges = Range.edges(at),
-    _Range$edges2 = _slicedToArray(_Range$edges, 2),
-    start = _Range$edges2[0],
-    end = _Range$edges2[1];
-  var startBlock = getAboveBlockNode(editor, _objectSpread({
+  const [start, end] = Range.edges(at);
+  const startBlock = getAboveBlockNode(editor, _objectSpread({
     at: start
   }, options));
-  var endBlock = getAboveBlockNode(editor, _objectSpread({
+  const endBlock = getAboveBlockNode(editor, _objectSpread({
     at: end
   }, options));
   if (!startBlock && !endBlock) return;
   if (!startBlock || !endBlock) return true;
   return !Path.equals(startBlock[1], endBlock[1]);
 };
-export var isAncestorEmpty = function isAncestorEmpty(editor, node) {
-  return !Node.string(node) && !node.children.some(function (n) {
-    return Editor.isInline(editor, n);
-  });
+export const isAncestorEmpty = (editor, node) => {
+  return !Node.string(node) && !node.children.some(n => Editor.isInline(editor, n));
 };
-export var isBlockAboveEmpty = function isBlockAboveEmpty(editor) {
+export const isBlockAboveEmpty = editor => {
   var _getAboveBlockNode;
-  var block = (_getAboveBlockNode = getAboveBlockNode(editor)) === null || _getAboveBlockNode === void 0 ? void 0 : _getAboveBlockNode[0];
+  const block = (_getAboveBlockNode = getAboveBlockNode(editor)) === null || _getAboveBlockNode === void 0 ? void 0 : _getAboveBlockNode[0];
   if (!block) return false;
   return isAncestorEmpty(editor, block);
 };
-export var isSelectionAtBlockStart = function isSelectionAtBlockStart(editor, options) {
-  var selection = editor.selection;
+export const isSelectionAtBlockStart = (editor, options) => {
+  const {
+    selection
+  } = editor;
   if (!selection) return false;
-  var nodeEntry = getAboveBlockNode(editor, options);
-  var path = nodeEntry === null || nodeEntry === void 0 ? void 0 : nodeEntry[1];
+  const nodeEntry = getAboveBlockNode(editor, options);
+  let path = nodeEntry === null || nodeEntry === void 0 ? void 0 : nodeEntry[1];
   if ((nodeEntry === null || nodeEntry === void 0 ? void 0 : nodeEntry[0].type) === CODE_LINE) {
     path = [path[0]];
   }
   if (!path) return false;
   return isStartPoint(editor, selection.focus, path) || Range.isExpanded(editor.selection) && isStartPoint(editor, selection.anchor, path);
 };
-export var isSelectionAtBlockEnd = function isSelectionAtBlockEnd(editor, options) {
+export const isSelectionAtBlockEnd = (editor, options) => {
   var _getAboveBlockNode2, _editor$selection;
-  var path = (_getAboveBlockNode2 = getAboveBlockNode(editor, options)) === null || _getAboveBlockNode2 === void 0 ? void 0 : _getAboveBlockNode2[1];
+  const 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);
 };
-export var isLastNode = function isLastNode(editor, node) {
-  var editorChildren = editor.children || [];
-  var editorChildrenLength = editorChildren.length;
+export const isLastNode = (editor, node) => {
+  const editorChildren = editor.children || [];
+  const editorChildrenLength = editorChildren.length;
   return editorChildren[editorChildrenLength - 1] === node;
 };
-export var isHasImg = function isHasImg(editor) {
-  var hasImg = false;
-  var _iterator5 = _createForOfIteratorHelper(Editor.nodes(editor, {
-      at: editor.selection
-    })),
-    _step5;
-  try {
-    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-      var _step5$value = _slicedToArray(_step5.value, 1),
-        node = _step5$value[0];
-      if ((node === null || node === void 0 ? void 0 : node.type) === 'image') {
-        hasImg = true;
-      }
+export const isHasImg = editor => {
+  let hasImg = false;
+  for (const [node] of Editor.nodes(editor, {
+    at: editor.selection
+  })) {
+    if ((node === null || node === void 0 ? void 0 : node.type) === 'image') {
+      hasImg = true;
     }
-  } catch (err) {
-    _iterator5.e(err);
-  } finally {
-    _iterator5.f();
   }
   return hasImg;
 };