@atlaskit/editor-plugin-selection 0.1.0

package/dist/es2019/pm-plugins/selection-main.js

@@ -0,0 +1,97 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { SelectionActionTypes } from '../actions';
+import { createPluginState, getPluginState } from '../plugin-factory';
+import { selectionPluginKey } from '../types';
+import { getAllSelectionAnalyticsPayload, getCellSelectionAnalyticsPayload, getDecorations, getNodeSelectionAnalyticsPayload, getRangeSelectionAnalyticsPayload, shouldRecalcDecorations } from '../utils';
+import { onCreateSelectionBetween } from './events/create-selection-between';
+import { onKeydown } from './events/keydown';
+export const getInitialState = state => ({
+  decorationSet: getDecorations(state.tr),
+  selection: state.selection
+});
+export const createPlugin = (dispatch, dispatchAnalyticsEvent, options = {}) => {
+  return new SafePlugin({
+    key: selectionPluginKey,
+    state: createPluginState(dispatch, getInitialState),
+    view: () => ({
+      update: (editorView, oldEditorState) => {
+        const {
+          state
+        } = editorView;
+        if (!shouldRecalcDecorations({
+          oldEditorState,
+          newEditorState: state
+        })) {
+          return;
+        }
+        const analyticsPayload = getNodeSelectionAnalyticsPayload(state.selection) || getAllSelectionAnalyticsPayload(state.selection) ||
+        // We handle all range/cell selections except click and drag here, which is
+        // handled in mouseup handler below
+        !editorView.mouseDown && (getRangeSelectionAnalyticsPayload(state.selection, state.doc) || getCellSelectionAnalyticsPayload(state));
+
+        // We have to use dispatchAnalyticsEvent over any of the analytics plugin helpers
+        // as there were several issues caused by the fact that adding analytics through
+        // the plugin adds a new step to the transaction
+        // This causes prosemirror to run through some different code paths, eg. attempting
+        // to map selection
+        if (analyticsPayload) {
+          dispatchAnalyticsEvent(analyticsPayload);
+        }
+      }
+    }),
+    appendTransaction(_transactions, oldEditorState, newEditorState) {
+      if (!shouldRecalcDecorations({
+        oldEditorState,
+        newEditorState
+      })) {
+        return;
+      }
+      const {
+        tr
+      } = newEditorState;
+      tr.setMeta(selectionPluginKey, {
+        type: SelectionActionTypes.SET_DECORATIONS,
+        selection: tr.selection,
+        decorationSet: getDecorations(tr)
+      });
+      return tr;
+    },
+    filterTransaction(tr, state) {
+      // Prevent single click selecting atom nodes on mobile (we want to select with long press gesture instead)
+      if (options.useLongPressSelection && tr.selectionSet && tr.selection instanceof NodeSelection && !tr.getMeta(selectionPluginKey)) {
+        return false;
+      }
+
+      // Prevent prosemirror's mutation observer overriding a node selection with a text selection
+      // for exact same range - this was cause of being unable to change dates in collab:
+      // https://product-fabric.atlassian.net/browse/ED-10645
+      if (state.selection instanceof NodeSelection && tr.selection instanceof TextSelection && state.selection.from === tr.selection.from && state.selection.to === tr.selection.to) {
+        return false;
+      }
+      return true;
+    },
+    props: {
+      createSelectionBetween: onCreateSelectionBetween,
+      decorations(state) {
+        return getPluginState(state).decorationSet;
+      },
+      handleDOMEvents: {
+        keydown: onKeydown,
+        // We only want to fire analytics for a click and drag range/cell selection when
+        // the user has finished, otherwise we will get an event almost every time they move
+        // their mouse which is too much
+        mouseup: (editorView, event) => {
+          const mouseEvent = event;
+          if (!mouseEvent.shiftKey) {
+            const analyticsPayload = getRangeSelectionAnalyticsPayload(editorView.state.selection, editorView.state.doc) || getCellSelectionAnalyticsPayload(editorView.state);
+            if (analyticsPayload) {
+              dispatchAnalyticsEvent(analyticsPayload);
+            }
+          }
+          return false;
+        }
+      }
+    }
+  });
+};

package/dist/es2019/reducer.js

@@ -0,0 +1,18 @@
+import { SelectionActionTypes } from './actions';
+export function reducer(pluginState, action) {
+  switch (action.type) {
+    case SelectionActionTypes.SET_DECORATIONS:
+      return {
+        ...pluginState,
+        decorationSet: action.decorationSet,
+        selection: action.selection
+      };
+    case SelectionActionTypes.SET_RELATIVE_SELECTION:
+      return {
+        ...pluginState,
+        selectionRelativeToNode: action.selectionRelativeToNode
+      };
+    default:
+      return pluginState;
+  }
+}

package/dist/es2019/types.js

@@ -0,0 +1,9 @@
+import { RelativeSelectionPos } from '@atlaskit/editor-common/selection';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export const selectionPluginKey = new PluginKey('selection');
+export { RelativeSelectionPos };
+export let SelectionDirection = /*#__PURE__*/function (SelectionDirection) {
+  SelectionDirection[SelectionDirection["Before"] = -1] = "Before";
+  SelectionDirection[SelectionDirection["After"] = 1] = "After";
+  return SelectionDirection;
+}({});

package/dist/es2019/utils.js

@@ -0,0 +1,233 @@
+import { createSelectionClickHandler, getAllSelectionAnalyticsPayload, getCellSelectionAnalyticsPayload, getNodeSelectionAnalyticsPayload, getRangeSelectionAnalyticsPayload, isIgnored as isIgnoredByGapCursor, isSelectionAtEndOfNode, isSelectionAtStartOfNode } from '@atlaskit/editor-common/selection';
+import { isEmptyParagraph } from '@atlaskit/editor-common/utils';
+import { AllSelection, NodeSelection, Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { findParentNode, flatten } from '@atlaskit/editor-prosemirror/utils';
+import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { akEditorSelectedNodeClassName } from '@atlaskit/editor-shared-styles';
+import { selectionPluginKey } from './types';
+export const getDecorations = tr => {
+  if (tr.selection instanceof NodeSelection) {
+    return DecorationSet.create(tr.doc, [Decoration.node(tr.selection.from, tr.selection.to, {
+      class: akEditorSelectedNodeClassName
+    })]);
+  }
+  if (tr.selection instanceof TextSelection || tr.selection instanceof AllSelection) {
+    const decorations = getNodesToDecorateFromSelection(tr.selection, tr.doc).map(({
+      node,
+      pos
+    }) => {
+      return Decoration.node(pos, pos + node.nodeSize, {
+        class: akEditorSelectedNodeClassName
+      });
+    });
+    return DecorationSet.create(tr.doc, decorations);
+  }
+  return DecorationSet.empty;
+};
+const 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`.
+ */
+export const getNodesToDecorateFromSelection = (selection, doc) => {
+  const nodes = [];
+  if (selection.from !== selection.to) {
+    const {
+      from,
+      to
+    } = selection;
+    doc.nodesBetween(from, to, (node, pos) => {
+      const 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.
+      const 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,
+          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,
+          pos
+        });
+      }
+      return true;
+    });
+  }
+  return nodes;
+};
+export function shouldRecalcDecorations({
+  oldEditorState,
+  newEditorState
+}) {
+  const oldSelection = oldEditorState.selection;
+  const newSelection = newEditorState.selection;
+  const oldPluginState = selectionPluginKey.getState(oldEditorState);
+  const newPluginState = 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 NodeSelection && newSelection instanceof NodeSelection) {
+      const oldDecorations = oldPluginState.decorationSet.find();
+      const 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 TextSelection && newSelection instanceof TextSelection && oldSelection.from === oldSelection.to && newSelection.from === newSelection.to) {
+    return false;
+  }
+  return true;
+}
+export const isSelectableContainerNode = node => !!(node && !node.isAtom && NodeSelection.isSelectable(node));
+export const isSelectableChildNode = node => !!(node && (node.isText || isEmptyParagraph(node) || 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
+ */
+export const findSelectableContainerParent = selection => {
+  let foundNodeThatSupportsGapCursor = false;
+  const selectableNode = findParentNode(node => {
+    const isSelectable = isSelectableContainerNode(node);
+    if (!isSelectable && !isIgnoredByGapCursor(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
+ */
+export const 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);
+  }
+  const selectionBefore = Selection.findFrom($pos, -1);
+  if (selectionBefore) {
+    const $selectionBefore = doc.resolve(selectionBefore.from);
+    for (let i = $pos.depth + 1; i <= $selectionBefore.depth; i++) {
+      const node = $selectionBefore.node(i);
+      if (isSelectableContainerNode(node)) {
+        return {
+          node,
+          pos: $selectionBefore.start(i) - 1
+        };
+      }
+      if (i > $pos.depth + 1 && !isIgnoredByGapCursor(node)) {
+        return;
+      }
+    }
+
+    /**
+     * Stick to the default left selection behaviour,
+     * useful for mediaSingleWithCaption
+     */
+    if (selectionBefore instanceof NodeSelection && 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
+ */
+export const findSelectableContainerAfter = ($pos, doc) => {
+  const selectionAfter = Selection.findFrom($pos, 1);
+  if (selectionAfter) {
+    const $selectionAfter = doc.resolve(selectionAfter.from);
+    for (let i = $pos.depth + 1; i <= $selectionAfter.depth; i++) {
+      const node = $selectionAfter.node(i);
+      if (isSelectableContainerNode(node)) {
+        return {
+          node,
+          pos: $selectionAfter.start(i) - 1
+        };
+      }
+      if (i > $pos.depth + 1 && !isIgnoredByGapCursor(node)) {
+        return;
+      }
+    }
+  }
+};
+
+/**
+ * Finds first child node that is a selectable block container node OR that
+ * supports gap cursor
+ */
+export const findFirstChildNodeToSelect = parent => flatten(parent).find(child => isSelectableChildNode(child.node) || !isIgnoredByGapCursor(child.node));
+
+/**
+ * Finds last child node that is a selectable block container node OR that
+ * supports gap cursor
+ */
+export const findLastChildNodeToSelect = parent => {
+  let child;
+  parent.descendants((node, pos) => {
+    if (isSelectableChildNode(node) || !isIgnoredByGapCursor(node)) {
+      child = {
+        node,
+        pos
+      };
+      return false;
+    }
+  });
+  if (child) {
+    return child;
+  }
+};
+export const isSelectionAtStartOfParentNode = ($pos, selection) => isSelectionAtStartOfNode($pos, findSelectableContainerParent(selection));
+export const isSelectionAtEndOfParentNode = ($pos, selection) => isSelectionAtEndOfNode($pos, findSelectableContainerParent(selection));
+export { getNodeSelectionAnalyticsPayload, getAllSelectionAnalyticsPayload, getRangeSelectionAnalyticsPayload, getCellSelectionAnalyticsPayload, createSelectionClickHandler };

package/dist/esm/actions.js

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

package/dist/esm/commands.js

@@ -0,0 +1,251 @@
+import { isIgnored as isIgnoredByGapCursor } from '@atlaskit/editor-common/selection';
+import { isEmptyParagraph, isNodeEmpty } from '@atlaskit/editor-common/utils';
+import { NodeSelection, Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { SelectionActionTypes } from './actions';
+import { GapCursorSelection, Side } from './gap-cursor-selection';
+import { createCommand, getPluginState } from './plugin-factory';
+import { RelativeSelectionPos, SelectionDirection, selectionPluginKey } from './types';
+import { findFirstChildNodeToSelect, findLastChildNodeToSelect, findSelectableContainerAfter, findSelectableContainerBefore, findSelectableContainerParent, isSelectableContainerNode, isSelectionAtEndOfParentNode, isSelectionAtStartOfParentNode } from './utils';
+export var selectNearNode = function selectNearNode(selectionRelativeToNode, selection) {
+  return function (_ref) {
+    var tr = _ref.tr;
+    tr.setMeta(selectionPluginKey, {
+      type: SelectionActionTypes.SET_RELATIVE_SELECTION,
+      selectionRelativeToNode: selectionRelativeToNode
+    });
+    if (selection) {
+      return tr.setSelection(selection);
+    }
+    return tr;
+  };
+};
+export var setSelectionRelativeToNode = function setSelectionRelativeToNode(selectionRelativeToNode, selection) {
+  return createCommand({
+    type: SelectionActionTypes.SET_RELATIVE_SELECTION,
+    selectionRelativeToNode: selectionRelativeToNode
+  }, function (tr) {
+    return selectNearNode(selectionRelativeToNode, selection)({
+      tr: tr
+    }) || tr;
+  });
+};
+export var arrowRight = function arrowRight(state, dispatch) {
+  var selection = state.selection;
+  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 var arrowLeft = function arrowLeft(state, dispatch) {
+  var selection = state.selection;
+  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;
+};
+var arrowRightFromGapCursor = function arrowRightFromGapCursor(selection) {
+  return function (state, dispatch) {
+    var $from = selection.$from,
+      $to = selection.$to,
+      side = selection.side;
+    if (side === Side.LEFT) {
+      var 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)) {
+      var _selectableNode = findSelectableContainerParent(selection);
+      if (_selectableNode) {
+        return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, _selectableNode.pos))(state, dispatch);
+      }
+    }
+    return false;
+  };
+};
+var arrowLeftFromGapCursor = function arrowLeftFromGapCursor(selection) {
+  return function (state, dispatch) {
+    var $from = selection.$from,
+      side = selection.side;
+    var _getPluginState = getPluginState(state),
+      selectionRelativeToNode = _getPluginState.selectionRelativeToNode;
+    if (side === Side.RIGHT) {
+      var 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) {
+        var $parent = state.doc.resolve(selection.$from.before(selection.$from.depth));
+        if ($parent) {
+          var _selectableNode2 = findSelectableContainerBefore($parent, state.doc);
+          if (_selectableNode2 && isIgnoredByGapCursor(_selectableNode2.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, _selectableNode2.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 {
+        var _selectableNode3 = findSelectableContainerParent(selection);
+        if (_selectableNode3) {
+          return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, _selectableNode3.pos))(state, dispatch);
+        }
+      }
+    }
+    return false;
+  };
+};
+var arrowRightFromNode = function arrowRightFromNode(selection) {
+  return function (state, dispatch) {
+    var node = selection.node,
+      from = selection.from,
+      $to = selection.$to;
+    var _getPluginState2 = getPluginState(state),
+      selectionRelativeToNode = _getPluginState2.selectionRelativeToNode;
+    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)) {
+      var 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;
+  };
+};
+var arrowLeftFromNode = function arrowLeftFromNode(selection) {
+  return function (state, dispatch) {
+    var node = selection.node,
+      from = selection.from,
+      to = selection.to,
+      $from = selection.$from;
+    var _getPluginState3 = getPluginState(state),
+      selectionRelativeToNode = _getPluginState3.selectionRelativeToNode;
+    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
+      var selectableNode = findSelectableContainerBefore($from, state.doc);
+      if (selectableNode && isIgnoredByGapCursor(selectableNode.node)) {
+        return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+      }
+    }
+    return false;
+  };
+};
+var arrowRightFromText = function arrowRightFromText(selection) {
+  return function (state, dispatch) {
+    if (isSelectionAtEndOfParentNode(selection.$to, selection)) {
+      var selectableNode = findSelectableContainerParent(selection);
+      if (selectableNode) {
+        return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+      }
+    }
+    return false;
+  };
+};
+var arrowLeftFromText = function arrowLeftFromText(selection) {
+  return function (state, dispatch) {
+    var _getPluginState4 = getPluginState(state),
+      selectionRelativeToNode = _getPluginState4.selectionRelativeToNode;
+    if (selectionRelativeToNode === RelativeSelectionPos.Before) {
+      var 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)) {
+      var _selectableNode4 = findSelectableContainerParent(selection);
+      if (_selectableNode4) {
+        return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, _selectableNode4.pos))(state, dispatch);
+      }
+    }
+    return false;
+  };
+};
+var findAndSetTextSelection = function findAndSetTextSelection(selectionRelativeToNode, $pos, dir) {
+  return function (state, dispatch) {
+    var sel = Selection.findFrom($pos, dir, true);
+    if (sel) {
+      return setSelectionRelativeToNode(selectionRelativeToNode, sel)(state, dispatch);
+    }
+    return false;
+  };
+};
+var setSelectionInsideAtNodeStart = function setSelectionInsideAtNodeStart(selectionRelativeToNode, node, pos) {
+  return function (state, dispatch) {
+    if (isNodeEmpty(node)) {
+      return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(pos), SelectionDirection.After)(state, dispatch);
+    }
+    var selectableNode = findFirstChildNodeToSelect(node);
+    if (selectableNode) {
+      var childNode = selectableNode.node,
+        childPos = selectableNode.pos;
+      var 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 var setSelectionInsideAtNodeEnd = function setSelectionInsideAtNodeEnd(selectionRelativeToNode, node, from, to) {
+  return function (state, dispatch) {
+    if (isNodeEmpty(node)) {
+      return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(to), SelectionDirection.Before)(state, dispatch);
+    }
+    var selectableNode = findLastChildNodeToSelect(node);
+    if (selectableNode) {
+      var childNode = selectableNode.node,
+        childPos = selectableNode.pos;
+      var 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;
+  };
+};