@atlaskit/editor-core 188.5.0 → 188.5.2

package/dist/cjs/plugins/selection/reducer.js

@@ -1,26 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.reducer = reducer;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _actions = require("./actions");
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function reducer(pluginState, action) {
-  switch (action.type) {
-    case _actions.SelectionActionTypes.SET_DECORATIONS:
-      return _objectSpread(_objectSpread({}, pluginState), {}, {
-        decorationSet: action.decorationSet,
-        selection: action.selection
-      });
-    case _actions.SelectionActionTypes.SET_RELATIVE_SELECTION:
-      return _objectSpread(_objectSpread({}, pluginState), {}, {
-        selectionRelativeToNode: action.selectionRelativeToNode
-      });
-    default:
-      return pluginState;
-  }
-}

package/dist/cjs/plugins/selection/types.js

@@ -1,20 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "RelativeSelectionPos", {
-  enumerable: true,
-  get: function get() {
-    return _selection.RelativeSelectionPos;
-  }
-});
-exports.selectionPluginKey = exports.SelectionDirection = void 0;
-var _state = require("@atlaskit/editor-prosemirror/state");
-var _selection = require("@atlaskit/editor-common/selection");
-var selectionPluginKey = exports.selectionPluginKey = new _state.PluginKey('selection');
-var SelectionDirection = exports.SelectionDirection = /*#__PURE__*/function (SelectionDirection) {
-  SelectionDirection[SelectionDirection["Before"] = -1] = "Before";
-  SelectionDirection[SelectionDirection["After"] = 1] = "After";
-  return SelectionDirection;
-}({});

package/dist/cjs/plugins/selection/utils.js

@@ -1,280 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "createSelectionClickHandler", {
-  enumerable: true,
-  get: function get() {
-    return _selection.createSelectionClickHandler;
-  }
-});
-exports.findSelectableContainerParent = exports.findSelectableContainerBefore = exports.findSelectableContainerAfter = exports.findLastChildNodeToSelect = exports.findFirstChildNodeToSelect = void 0;
-Object.defineProperty(exports, "getAllSelectionAnalyticsPayload", {
-  enumerable: true,
-  get: function get() {
-    return _selection.getAllSelectionAnalyticsPayload;
-  }
-});
-Object.defineProperty(exports, "getCellSelectionAnalyticsPayload", {
-  enumerable: true,
-  get: function get() {
-    return _selection.getCellSelectionAnalyticsPayload;
-  }
-});
-exports.getDecorations = void 0;
-Object.defineProperty(exports, "getNodeSelectionAnalyticsPayload", {
-  enumerable: true,
-  get: function get() {
-    return _selection.getNodeSelectionAnalyticsPayload;
-  }
-});
-exports.getNodesToDecorateFromSelection = void 0;
-Object.defineProperty(exports, "getRangeSelectionAnalyticsPayload", {
-  enumerable: true,
-  get: function get() {
-    return _selection.getRangeSelectionAnalyticsPayload;
-  }
-});
-exports.isSelectionAtStartOfParentNode = exports.isSelectionAtEndOfParentNode = exports.isSelectableContainerNode = exports.isSelectableChildNode = void 0;
-exports.shouldRecalcDecorations = shouldRecalcDecorations;
-var _state = require("@atlaskit/editor-prosemirror/state");
-var _view = require("@atlaskit/editor-prosemirror/view");
-var _utils = require("@atlaskit/editor-prosemirror/utils");
-var _editorSharedStyles = require("@atlaskit/editor-shared-styles");
-var _selection = require("@atlaskit/editor-common/selection");
-var _utils2 = require("@atlaskit/editor-common/utils");
-var _types = require("./types");
-var getDecorations = exports.getDecorations = function getDecorations(tr) {
-  if (tr.selection instanceof _state.NodeSelection) {
-    return _view.DecorationSet.create(tr.doc, [_view.Decoration.node(tr.selection.from, tr.selection.to, {
-      class: _editorSharedStyles.akEditorSelectedNodeClassName
-    })]);
-  }
-  if (tr.selection instanceof _state.TextSelection || tr.selection instanceof _state.AllSelection) {
-    var decorations = getNodesToDecorateFromSelection(tr.selection, tr.doc).map(function (_ref) {
-      var node = _ref.node,
-        pos = _ref.pos;
-      return _view.Decoration.node(pos, pos + node.nodeSize, {
-        class: _editorSharedStyles.akEditorSelectedNodeClassName
-      });
-    });
-    return _view.DecorationSet.create(tr.doc, decorations);
-  }
-  return _view.DecorationSet.empty;
-};
-var topLevelBlockNodesThatHaveSelectionStyles = ['table', 'panel', 'expand', 'layoutSection', 'decisionList', 'decisionItem', 'codeBlock'];
-
-/**
- * Use `getNodesToDecorateFromSelection` to collect and return
- * a list of nodes within the Selection that should have Selection
- * decorations applied. This allows selection styles to be added to
- * nested nodes. It will ignore text nodes as decorations are
- * applied natively and also ignore nodes that don't completely
- * sit within the given `Selection`.
- */
-var getNodesToDecorateFromSelection = exports.getNodesToDecorateFromSelection = function getNodesToDecorateFromSelection(selection, doc) {
-  var nodes = [];
-  if (selection.from !== selection.to) {
-    var from = selection.from,
-      to = selection.to;
-    doc.nodesBetween(from, to, function (node, pos) {
-      var withinSelection = from <= pos && pos + node.nodeSize <= to;
-      // The reason we need to check for these nodes is to stop
-      // traversing their children if they are within a selection -
-      // this is to prevent selection styles from being added to
-      // the children as well as the parent node.
-      // Example scenario is if an entire table has been selected
-      // we should not traverse its children so we can apply the
-      // selection styles to the table. But if an entire tableRow
-      // has been selected (but the parent table has not) we should
-      // traverse it as it could contain other nodes that need
-      // selection styles. I couldn’t see a clear way to differentiate
-      // without explicitly stating which nodes should be traversed
-      // and which shouldn’t.
-      var isTopLevelNodeThatHasSelectionStyles = topLevelBlockNodesThatHaveSelectionStyles.includes(node.type.name);
-      // If the node is a top-level block node and completely sits within
-      // the selection, we do not recurse it's children to prevent selection
-      // styles being added to its child nodes. The expected behaviour
-      // is that selection styles are only added to the parent.
-      if (node && withinSelection && isTopLevelNodeThatHasSelectionStyles) {
-        nodes.push({
-          node: node,
-          pos: pos
-        });
-        return false;
-        // Otherwise we recurse the children and return them so we can apply
-        // selection styles. Text is handled by the browser.
-      } else if (node && withinSelection && !node.isText) {
-        nodes.push({
-          node: node,
-          pos: pos
-        });
-      }
-      return true;
-    });
-  }
-  return nodes;
-};
-function shouldRecalcDecorations(_ref2) {
-  var oldEditorState = _ref2.oldEditorState,
-    newEditorState = _ref2.newEditorState;
-  var oldSelection = oldEditorState.selection;
-  var newSelection = newEditorState.selection;
-  var oldPluginState = _types.selectionPluginKey.getState(oldEditorState);
-  var newPluginState = _types.selectionPluginKey.getState(newEditorState);
-  if (!oldPluginState || !newPluginState) {
-    return false;
-  }
-
-  // If selection is unchanged, no need to recalculate
-  if (oldSelection.eq(newSelection)) {
-    // We need this special case for NodeSelection, as Prosemirror still thinks the
-    // selections are equal when the node has changed
-    if (oldSelection instanceof _state.NodeSelection && newSelection instanceof _state.NodeSelection) {
-      var oldDecorations = oldPluginState.decorationSet.find();
-      var newDecorations = newPluginState.decorationSet.find();
-      // There might not be old or new decorations if the node selection is for a text node
-      // This wouldn't have happened intentionally, but we need to handle this case regardless
-      if (oldDecorations.length > 0 && newDecorations.length > 0) {
-        return !oldDecorations[0].eq(newDecorations[0]);
-      }
-      return !(oldDecorations.length === 0 && newDecorations.length === 0);
-    }
-    return false;
-  }
-
-  // There's no point updating decorations if going from one standard TextSelection to another
-  if (oldSelection instanceof _state.TextSelection && newSelection instanceof _state.TextSelection && oldSelection.from === oldSelection.to && newSelection.from === newSelection.to) {
-    return false;
-  }
-  return true;
-}
-var isSelectableContainerNode = exports.isSelectableContainerNode = function isSelectableContainerNode(node) {
-  return !!(node && !node.isAtom && _state.NodeSelection.isSelectable(node));
-};
-var isSelectableChildNode = exports.isSelectableChildNode = function isSelectableChildNode(node) {
-  return !!(node && (node.isText || (0, _utils2.isEmptyParagraph)(node) || _state.NodeSelection.isSelectable(node)));
-};
-
-/**
- * Finds closest parent node that is a selectable block container node
- * If it finds a parent that is not selectable but supports gap cursor, will
- * return undefined
- */
-var findSelectableContainerParent = exports.findSelectableContainerParent = function findSelectableContainerParent(selection) {
-  var foundNodeThatSupportsGapCursor = false;
-  var selectableNode = (0, _utils.findParentNode)(function (node) {
-    var isSelectable = isSelectableContainerNode(node);
-    if (!isSelectable && !(0, _selection.isIgnored)(node)) {
-      foundNodeThatSupportsGapCursor = true;
-    }
-    return isSelectable;
-  })(selection);
-  if (!foundNodeThatSupportsGapCursor) {
-    return selectableNode;
-  }
-};
-
-/**
- * Finds node before that is a selectable block container node, starting
- * from $pos.depth + 1 and working in
- * If it finds a node that is not selectable but supports gap cursor, will
- * return undefined
- */
-var findSelectableContainerBefore = exports.findSelectableContainerBefore = function findSelectableContainerBefore($pos, doc) {
-  // prosemirror just returns the same pos from Selection.findFrom when
-  // parent.inlineContent is true, so we move position back one here
-  // to counteract that
-  if ($pos.parent.inlineContent && isSelectableContainerNode($pos.parent)) {
-    $pos = doc.resolve($pos.start() - 1);
-  }
-  var selectionBefore = _state.Selection.findFrom($pos, -1);
-  if (selectionBefore) {
-    var $selectionBefore = doc.resolve(selectionBefore.from);
-    for (var i = $pos.depth + 1; i <= $selectionBefore.depth; i++) {
-      var node = $selectionBefore.node(i);
-      if (isSelectableContainerNode(node)) {
-        return {
-          node: node,
-          pos: $selectionBefore.start(i) - 1
-        };
-      }
-      if (i > $pos.depth + 1 && !(0, _selection.isIgnored)(node)) {
-        return;
-      }
-    }
-
-    /**
-     * Stick to the default left selection behaviour,
-     * useful for mediaSingleWithCaption
-     */
-    if (selectionBefore instanceof _state.NodeSelection && _state.NodeSelection.isSelectable(selectionBefore.node)) {
-      return {
-        node: selectionBefore.node,
-        pos: selectionBefore.from
-      };
-    }
-  }
-};
-
-/**
- * Finds node after that is a selectable block container node, starting
- * from $pos.depth + 1 and working in
- * If it finds a node that is not selectable but supports gap cursor, will
- * return undefined
- */
-var findSelectableContainerAfter = exports.findSelectableContainerAfter = function findSelectableContainerAfter($pos, doc) {
-  var selectionAfter = _state.Selection.findFrom($pos, 1);
-  if (selectionAfter) {
-    var $selectionAfter = doc.resolve(selectionAfter.from);
-    for (var i = $pos.depth + 1; i <= $selectionAfter.depth; i++) {
-      var node = $selectionAfter.node(i);
-      if (isSelectableContainerNode(node)) {
-        return {
-          node: node,
-          pos: $selectionAfter.start(i) - 1
-        };
-      }
-      if (i > $pos.depth + 1 && !(0, _selection.isIgnored)(node)) {
-        return;
-      }
-    }
-  }
-};
-
-/**
- * Finds first child node that is a selectable block container node OR that
- * supports gap cursor
- */
-var findFirstChildNodeToSelect = exports.findFirstChildNodeToSelect = function findFirstChildNodeToSelect(parent) {
-  return (0, _utils.flatten)(parent).find(function (child) {
-    return isSelectableChildNode(child.node) || !(0, _selection.isIgnored)(child.node);
-  });
-};
-
-/**
- * Finds last child node that is a selectable block container node OR that
- * supports gap cursor
- */
-var findLastChildNodeToSelect = exports.findLastChildNodeToSelect = function findLastChildNodeToSelect(parent) {
-  var child;
-  parent.descendants(function (node, pos) {
-    if (isSelectableChildNode(node) || !(0, _selection.isIgnored)(node)) {
-      child = {
-        node: node,
-        pos: pos
-      };
-      return false;
-    }
-  });
-  if (child) {
-    return child;
-  }
-};
-var isSelectionAtStartOfParentNode = exports.isSelectionAtStartOfParentNode = function isSelectionAtStartOfParentNode($pos, selection) {
-  return (0, _selection.isSelectionAtStartOfNode)($pos, findSelectableContainerParent(selection));
-};
-var isSelectionAtEndOfParentNode = exports.isSelectionAtEndOfParentNode = function isSelectionAtEndOfParentNode($pos, selection) {
-  return (0, _selection.isSelectionAtEndOfNode)($pos, findSelectableContainerParent(selection));
-};

package/dist/cjs/selection-api/api.js

@@ -1,27 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createEditorSelectionAPI = void 0;
-var _commands = require("../plugins/selection/commands");
-var _pluginFactory = require("../plugins/selection/plugin-factory");
-var createEditorSelectionAPI = exports.createEditorSelectionAPI = function createEditorSelectionAPI() {
-  return {
-    getSelectionPluginState: function getSelectionPluginState(state) {
-      return (0, _pluginFactory.getPluginState)(state);
-    },
-    setSelectionRelativeToNode: function setSelectionRelativeToNode(_ref) {
-      var selectionRelativeToNode = _ref.selectionRelativeToNode,
-        selection = _ref.selection;
-      return function (state) {
-        var tr = state.tr;
-        var fakeDispatch = function fakeDispatch(_tr) {
-          tr = _tr;
-        };
-        (0, _commands.setSelectionRelativeToNode)(selectionRelativeToNode, selection)(state, fakeDispatch);
-        return tr;
-      };
-    }
-  };
-};

package/dist/es2019/plugins/selection/actions.js

@@ -1,5 +0,0 @@
-export let SelectionActionTypes = /*#__PURE__*/function (SelectionActionTypes) {
-  SelectionActionTypes["SET_DECORATIONS"] = "SET_DECORATIONS";
-  SelectionActionTypes["SET_RELATIVE_SELECTION"] = "SET_RELATIVE_SELECTION";
-  return SelectionActionTypes;
-}({});

package/dist/es2019/plugins/selection/commands.js

@@ -1,250 +0,0 @@
-import { NodeSelection, TextSelection, Selection } from '@atlaskit/editor-prosemirror/state';
-import { GapCursorSelection, Side } from './gap-cursor-selection';
-import { isIgnored as isIgnoredByGapCursor } from '@atlaskit/editor-common/selection';
-import { isNodeEmpty, isEmptyParagraph } from '@atlaskit/editor-common/utils';
-import { SelectionActionTypes } from './actions';
-import { createCommand, getPluginState } from './plugin-factory';
-import { isSelectableContainerNode, isSelectionAtEndOfParentNode, findSelectableContainerParent, isSelectionAtStartOfParentNode, findSelectableContainerBefore, findSelectableContainerAfter, findFirstChildNodeToSelect, findLastChildNodeToSelect } from './utils';
-import { RelativeSelectionPos, SelectionDirection, selectionPluginKey } from './types';
-export const selectNearNode = (selectionRelativeToNode, selection) => ({
-  tr
-}) => {
-  tr.setMeta(selectionPluginKey, {
-    type: SelectionActionTypes.SET_RELATIVE_SELECTION,
-    selectionRelativeToNode
-  });
-  if (selection) {
-    return tr.setSelection(selection);
-  }
-  return tr;
-};
-export const setSelectionRelativeToNode = (selectionRelativeToNode, selection) => createCommand({
-  type: SelectionActionTypes.SET_RELATIVE_SELECTION,
-  selectionRelativeToNode
-}, tr => {
-  return selectNearNode(selectionRelativeToNode, selection)({
-    tr
-  }) || tr;
-});
-export const arrowRight = (state, dispatch) => {
-  const {
-    selection
-  } = state;
-  if (selection instanceof GapCursorSelection) {
-    return arrowRightFromGapCursor(selection)(state, dispatch);
-  } else if (selection instanceof NodeSelection) {
-    return arrowRightFromNode(selection)(state, dispatch);
-  } else if (selection instanceof TextSelection) {
-    return arrowRightFromText(selection)(state, dispatch);
-  }
-  return false;
-};
-export const arrowLeft = (state, dispatch) => {
-  const {
-    selection
-  } = state;
-  if (selection instanceof GapCursorSelection) {
-    return arrowLeftFromGapCursor(selection)(state, dispatch);
-  } else if (selection instanceof NodeSelection) {
-    return arrowLeftFromNode(selection)(state, dispatch);
-  } else if (selection instanceof TextSelection) {
-    return arrowLeftFromText(selection)(state, dispatch);
-  }
-  return false;
-};
-const arrowRightFromGapCursor = selection => (state, dispatch) => {
-  const {
-    $from,
-    $to,
-    side
-  } = selection;
-  if (side === Side.LEFT) {
-    const selectableNode = findSelectableContainerAfter($to, state.doc);
-    if (selectableNode) {
-      return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-    }
-  } else if (side === Side.RIGHT && isSelectionAtEndOfParentNode($from, selection)) {
-    const selectableNode = findSelectableContainerParent(selection);
-    if (selectableNode) {
-      return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-    }
-  }
-  return false;
-};
-const arrowLeftFromGapCursor = selection => (state, dispatch) => {
-  const {
-    $from,
-    side
-  } = selection;
-  const {
-    selectionRelativeToNode
-  } = getPluginState(state);
-  if (side === Side.RIGHT) {
-    const selectableNode = findSelectableContainerBefore($from, state.doc);
-    if (selectableNode) {
-      return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-    }
-  } else if (side === Side.LEFT && isSelectionAtStartOfParentNode($from, selection)) {
-    if (selectionRelativeToNode === RelativeSelectionPos.Before) {
-      const $parent = state.doc.resolve(selection.$from.before(selection.$from.depth));
-      if ($parent) {
-        const selectableNode = findSelectableContainerBefore($parent, state.doc);
-        if (selectableNode && isIgnoredByGapCursor(selectableNode.node)) {
-          // selection is inside node without gap cursor preceeded by another node without gap cursor - set node selection for previous node
-          return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-        }
-      }
-      // we don't return this as we want to reset the relative pos, but not block other plugins
-      // from responding to arrow left key
-      setSelectionRelativeToNode()(state, dispatch);
-    } else {
-      const selectableNode = findSelectableContainerParent(selection);
-      if (selectableNode) {
-        return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-      }
-    }
-  }
-  return false;
-};
-const arrowRightFromNode = selection => (state, dispatch) => {
-  const {
-    node,
-    from,
-    $to
-  } = selection;
-  const {
-    selectionRelativeToNode
-  } = getPluginState(state);
-  if (node.isAtom) {
-    if (isSelectionAtEndOfParentNode($to, selection)) {
-      // selection is for inline node that is the last child of its parent node - set text selection after it
-      return findAndSetTextSelection(RelativeSelectionPos.End, state.doc.resolve(from + 1), SelectionDirection.After)(state, dispatch);
-    }
-    return false;
-  } else if (selectionRelativeToNode === RelativeSelectionPos.Start) {
-    // selection is for container node - set selection inside it at the start
-    return setSelectionInsideAtNodeStart(RelativeSelectionPos.Inside, node, from)(state, dispatch);
-  } else if (isIgnoredByGapCursor(node) && (!selectionRelativeToNode || selectionRelativeToNode === RelativeSelectionPos.End)) {
-    const selectableNode = findSelectableContainerAfter($to, state.doc);
-    if (selectableNode && isIgnoredByGapCursor(selectableNode.node)) {
-      // selection is for node without gap cursor followed by another node without gap cursor - set node selection for next node
-      return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-    }
-  }
-  return false;
-};
-const arrowLeftFromNode = selection => (state, dispatch) => {
-  const {
-    node,
-    from,
-    to,
-    $from
-  } = selection;
-  const {
-    selectionRelativeToNode
-  } = getPluginState(state);
-  if (node.isAtom) {
-    if (isSelectionAtStartOfParentNode($from, selection)) {
-      // selection is for inline node that is the first child of its parent node - set text selection before it
-      return findAndSetTextSelection(RelativeSelectionPos.Start, state.doc.resolve(from), SelectionDirection.Before)(state, dispatch);
-    }
-    return false;
-  } else if (selectionRelativeToNode === RelativeSelectionPos.End) {
-    // selection is for container node - set selection inside it at the end
-    return setSelectionInsideAtNodeEnd(RelativeSelectionPos.Inside, node, from, to)(state, dispatch);
-  } else if (!selectionRelativeToNode || selectionRelativeToNode === RelativeSelectionPos.Inside) {
-    // selection is for container node - set selection inside it at the start
-    // (this is a special case when the user selects by clicking node)
-    return setSelectionInsideAtNodeStart(RelativeSelectionPos.Before, node, from)(state, dispatch);
-  } else if (isIgnoredByGapCursor(node) && selectionRelativeToNode === RelativeSelectionPos.Start) {
-    // selection is for node without gap cursor preceeded by another node without gap cursor - set node selection for previous node
-    const selectableNode = findSelectableContainerBefore($from, state.doc);
-    if (selectableNode && isIgnoredByGapCursor(selectableNode.node)) {
-      return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-    }
-  }
-  return false;
-};
-const arrowRightFromText = selection => (state, dispatch) => {
-  if (isSelectionAtEndOfParentNode(selection.$to, selection)) {
-    const selectableNode = findSelectableContainerParent(selection);
-    if (selectableNode) {
-      return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-    }
-  }
-  return false;
-};
-const arrowLeftFromText = selection => (state, dispatch) => {
-  const {
-    selectionRelativeToNode
-  } = getPluginState(state);
-  if (selectionRelativeToNode === RelativeSelectionPos.Before) {
-    const selectableNode = findSelectableContainerBefore(selection.$from, state.doc);
-    if (selectableNode && isIgnoredByGapCursor(selectableNode.node)) {
-      // selection is inside node without gap cursor preceeded by another node without gap cursor - set node selection for previous node
-      return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-    }
-    // we don't return this as we want to reset the relative pos, but not block other plugins
-    // from responding to arrow left key
-    setSelectionRelativeToNode(undefined)(state, dispatch);
-  } else if (isSelectionAtStartOfParentNode(selection.$from, selection)) {
-    const selectableNode = findSelectableContainerParent(selection);
-    if (selectableNode) {
-      return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-    }
-  }
-  return false;
-};
-const findAndSetTextSelection = (selectionRelativeToNode, $pos, dir) => (state, dispatch) => {
-  const sel = Selection.findFrom($pos, dir, true);
-  if (sel) {
-    return setSelectionRelativeToNode(selectionRelativeToNode, sel)(state, dispatch);
-  }
-  return false;
-};
-const setSelectionInsideAtNodeStart = (selectionRelativeToNode, node, pos) => (state, dispatch) => {
-  if (isNodeEmpty(node)) {
-    return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(pos), SelectionDirection.After)(state, dispatch);
-  }
-  const selectableNode = findFirstChildNodeToSelect(node);
-  if (selectableNode) {
-    const {
-      node: childNode,
-      pos: childPos
-    } = selectableNode;
-    const selectionPos = pos + childPos + 1;
-    if (childNode.isText || childNode.isAtom) {
-      return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos), SelectionDirection.Before)(state, dispatch);
-    } else if (isEmptyParagraph(childNode)) {
-      return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos + 1), SelectionDirection.Before)(state, dispatch);
-    } else if (!isIgnoredByGapCursor(node)) {
-      return setSelectionRelativeToNode(selectionRelativeToNode, new GapCursorSelection(state.doc.resolve(selectionPos), Side.LEFT))(state, dispatch);
-    } else if (isSelectableContainerNode(node)) {
-      return setSelectionRelativeToNode(selectionRelativeToNode, NodeSelection.create(state.doc, selectionPos))(state, dispatch);
-    }
-  }
-  return false;
-};
-export const setSelectionInsideAtNodeEnd = (selectionRelativeToNode, node, from, to) => (state, dispatch) => {
-  if (isNodeEmpty(node)) {
-    return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(to), SelectionDirection.Before)(state, dispatch);
-  }
-  const selectableNode = findLastChildNodeToSelect(node);
-  if (selectableNode) {
-    const {
-      node: childNode,
-      pos: childPos
-    } = selectableNode;
-    const selectionPos = from + childPos + childNode.nodeSize;
-    if (childNode.isText || childNode.isAtom) {
-      return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos + 1), SelectionDirection.After)(state, dispatch);
-    } else if (isEmptyParagraph(childNode)) {
-      return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos), SelectionDirection.After)(state, dispatch);
-    } else if (!isIgnoredByGapCursor(node)) {
-      return setSelectionRelativeToNode(selectionRelativeToNode, new GapCursorSelection(state.doc.resolve(selectionPos + 1), Side.RIGHT))(state, dispatch);
-    } else if (isSelectableContainerNode(node)) {
-      return setSelectionRelativeToNode(selectionRelativeToNode, NodeSelection.create(state.doc, selectionPos))(state, dispatch);
-    }
-  }
-  return false;
-};