@atlaskit/editor-plugin-base 0.1.0

package/dist/cjs/pm-plugins/frozen-editor.js

@@ -0,0 +1,265 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.frozenEditorPluginKey = exports.default = exports.NORMAL_SEVERITY_THRESHOLD = exports.DEGRADED_SEVERITY_THRESHOLD = exports.DEFAULT_TRACK_SEVERITY_THRESHOLD_NORMAL = exports.DEFAULT_TRACK_SEVERITY_THRESHOLD_DEGRADED = exports.DEFAULT_FREEZE_THRESHOLD = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _ufo = require("@atlaskit/editor-common/ufo");
+var _utils = require("@atlaskit/editor-common/utils");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _frozenEditor = require("../utils/frozen-editor");
+var _inputLatencyTracking = _interopRequireDefault(require("../utils/input-latency-tracking"));
+var _contextIdentifier = require("./context-identifier");
+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; }
+var frozenEditorPluginKey = new _state.PluginKey('frozenEditor');
+exports.frozenEditorPluginKey = frozenEditorPluginKey;
+var DEFAULT_KEYSTROKE_SAMPLING_LIMIT = 100;
+var DEFAULT_SLOW_THRESHOLD = 300;
+var DEFAULT_FREEZE_THRESHOLD = 600;
+exports.DEFAULT_FREEZE_THRESHOLD = DEFAULT_FREEZE_THRESHOLD;
+var NORMAL_SEVERITY_THRESHOLD = 2000;
+exports.NORMAL_SEVERITY_THRESHOLD = NORMAL_SEVERITY_THRESHOLD;
+var DEGRADED_SEVERITY_THRESHOLD = 3000;
+exports.DEGRADED_SEVERITY_THRESHOLD = DEGRADED_SEVERITY_THRESHOLD;
+var DEFAULT_TRACK_SEVERITY_ENABLED = false;
+var DEFAULT_TRACK_SEVERITY_THRESHOLD_NORMAL = 100;
+exports.DEFAULT_TRACK_SEVERITY_THRESHOLD_NORMAL = DEFAULT_TRACK_SEVERITY_THRESHOLD_NORMAL;
+var DEFAULT_TRACK_SEVERITY_THRESHOLD_DEGRADED = 500;
+exports.DEFAULT_TRACK_SEVERITY_THRESHOLD_DEGRADED = DEFAULT_TRACK_SEVERITY_THRESHOLD_DEGRADED;
+var dispatchLongTaskEvent = function dispatchLongTaskEvent(dispatchAnalyticsEvent, view, time, getNodeCount, interactionType, severity) {
+  var _getContextIdentifier;
+  var state = view.state;
+  var nodesCount = getNodeCount(state);
+  return dispatchAnalyticsEvent({
+    action: _analytics.ACTION.BROWSER_FREEZE,
+    actionSubject: _analytics.ACTION_SUBJECT.EDITOR,
+    attributes: _objectSpread(_objectSpread({
+      objectId: (_getContextIdentifier = (0, _contextIdentifier.getContextIdentifier)(state)) === null || _getContextIdentifier === void 0 ? void 0 : _getContextIdentifier.objectId,
+      freezeTime: time,
+      nodeSize: state.doc.nodeSize
+    }, nodesCount), {}, {
+      interactionType: interactionType,
+      severity: severity
+    }),
+    eventType: _analytics.EVENT_TYPE.OPERATIONAL
+  });
+};
+var _default = function _default(dispatchAnalyticsEvent, inputTracking, browserFreezeTracking, ufo) {
+  var interactionType;
+  var inputLatencyTracker = null;
+  var inputLatencySingleKeyTracker = null;
+  var inputLatencyRenderedTracker = null;
+  if (browserFreezeTracking !== null && browserFreezeTracking !== void 0 && browserFreezeTracking.trackInteractionType) {
+    interactionType = (0, _frozenEditor.setInteractionType)(_analytics.BROWSER_FREEZE_INTERACTION_TYPE.LOADING);
+  }
+  var samplingRate = inputTracking && typeof inputTracking.samplingRate === 'number' ? inputTracking.samplingRate : DEFAULT_KEYSTROKE_SAMPLING_LIMIT;
+  var slowThreshold = inputTracking && typeof inputTracking.slowThreshold === 'number' ? inputTracking.slowThreshold : DEFAULT_SLOW_THRESHOLD;
+  var freezeThreshold = inputTracking && typeof inputTracking.freezeThreshold === 'number' ? inputTracking.freezeThreshold : DEFAULT_FREEZE_THRESHOLD;
+  var allowCountNodes = inputTracking && inputTracking.countNodes;
+  var prevNodeCountState = null;
+  var prevNodeCount = {};
+
+  // Cache the result as we were calling this multiple times
+  // and has potential to be expensive
+  var getNodeCount = function getNodeCount(state) {
+    if (state === prevNodeCountState) {
+      return prevNodeCount;
+    }
+    prevNodeCount = allowCountNodes ? (0, _utils.countNodes)(state) : {};
+    prevNodeCountState = state;
+    return prevNodeCount;
+  };
+  var shouldTrackSeverity = (inputTracking === null || inputTracking === void 0 ? void 0 : inputTracking.trackSeverity) || DEFAULT_TRACK_SEVERITY_ENABLED;
+  var severityThresholdNormal = (inputTracking === null || inputTracking === void 0 ? void 0 : inputTracking.severityNormalThreshold) || DEFAULT_TRACK_SEVERITY_THRESHOLD_NORMAL;
+  var severityThresholdDegraded = (inputTracking === null || inputTracking === void 0 ? void 0 : inputTracking.severityDegradedThreshold) || DEFAULT_TRACK_SEVERITY_THRESHOLD_DEGRADED;
+  var createDispatchSample = function createDispatchSample(action, view) {
+    return function (time, severity) {
+      var _getContextIdentifier2;
+      var state = view.state;
+      var nodesCount = getNodeCount(state);
+      var samplePayload = {
+        action: action,
+        actionSubject: _analytics.ACTION_SUBJECT.EDITOR,
+        attributes: _objectSpread(_objectSpread({
+          time: time,
+          nodeSize: state.doc.nodeSize
+        }, nodesCount), {}, {
+          objectId: (_getContextIdentifier2 = (0, _contextIdentifier.getContextIdentifier)(state)) === null || _getContextIdentifier2 === void 0 ? void 0 : _getContextIdentifier2.objectId,
+          severity: shouldTrackSeverity ? severity : undefined
+        }),
+        eventType: _analytics.EVENT_TYPE.OPERATIONAL
+      };
+      dispatchAnalyticsEvent(samplePayload);
+    };
+  };
+  var createDispatchAverage = function createDispatchAverage(action, view) {
+    return function (_ref, severity) {
+      var _getContextIdentifier3;
+      var mean = _ref.mean,
+        median = _ref.median,
+        sampleSize = _ref.sampleSize;
+      var state = view.state;
+      var nodeCount = getNodeCount(state);
+      var averagePayload = {
+        action: action,
+        actionSubject: _analytics.ACTION_SUBJECT.EDITOR,
+        attributes: _objectSpread(_objectSpread({
+          mean: mean,
+          median: median,
+          sampleSize: sampleSize
+        }, nodeCount), {}, {
+          nodeSize: state.doc.nodeSize,
+          severity: shouldTrackSeverity ? severity : undefined,
+          objectId: (_getContextIdentifier3 = (0, _contextIdentifier.getContextIdentifier)(state)) === null || _getContextIdentifier3 === void 0 ? void 0 : _getContextIdentifier3.objectId
+        }),
+        eventType: _analytics.EVENT_TYPE.OPERATIONAL
+      };
+      dispatchAnalyticsEvent(averagePayload);
+    };
+  };
+  return new _safePlugin.SafePlugin({
+    key: frozenEditorPluginKey,
+    props: (0, _utils.isPerformanceAPIAvailable)() ? {
+      handleTextInput: function handleTextInput(view) {
+        if (browserFreezeTracking !== null && browserFreezeTracking !== void 0 && browserFreezeTracking.trackInteractionType) {
+          interactionType = _analytics.BROWSER_FREEZE_INTERACTION_TYPE.TYPING;
+        }
+        if (inputLatencyTracker) {
+          var end = inputLatencyTracker.start();
+
+          // This is called after all handleTextInput events are executed which means first handleTextInput time incorporates following handleTextInput processing time
+          // Also this is called before browser rendering so it doesn't count it.
+          requestAnimationFrame(end);
+        }
+        if (inputLatencySingleKeyTracker) {
+          var _end = inputLatencySingleKeyTracker.start();
+
+          // This is executed before next handleTextInput when multiple keypress events are in one animation frame
+          // so it tracks individual keypress processing time
+          Promise.resolve().then(_end);
+        }
+        if (inputLatencyRenderedTracker) {
+          var _end2 = inputLatencyRenderedTracker.start();
+
+          // This is called at the next event loop so it counts browser rendering time.
+          setTimeout(_end2);
+        }
+        return false;
+      },
+      handleDOMEvents: browserFreezeTracking !== null && browserFreezeTracking !== void 0 && browserFreezeTracking.trackInteractionType ? {
+        click: function click() {
+          interactionType = (0, _frozenEditor.setInteractionType)(_analytics.BROWSER_FREEZE_INTERACTION_TYPE.CLICKING);
+          return false;
+        },
+        paste: function paste() {
+          interactionType = (0, _frozenEditor.setInteractionType)(_analytics.BROWSER_FREEZE_INTERACTION_TYPE.PASTING);
+          return false;
+        }
+      } : undefined
+    } : undefined,
+    view: function view(_view) {
+      if (!(0, _utils.isPerformanceObserverAvailable)()) {
+        return {};
+      }
+      var experienceStore = ufo ? _ufo.ExperienceStore.getInstance(_view) : undefined;
+      if (inputTracking !== null && inputTracking !== void 0 && inputTracking.enabled) {
+        inputLatencyTracker = new _inputLatencyTracking.default({
+          samplingRate: samplingRate,
+          slowThreshold: slowThreshold,
+          normalThreshold: severityThresholdNormal,
+          degradedThreshold: severityThresholdDegraded,
+          onSampleStart: function onSampleStart() {
+            experienceStore === null || experienceStore === void 0 ? void 0 : experienceStore.start(_ufo.EditorExperience.typing);
+          },
+          onSampleEnd: function onSampleEnd(time, _ref2) {
+            var _getContextIdentifier4;
+            var isSlow = _ref2.isSlow,
+              severity = _ref2.severity;
+            var state = _view.state;
+            var nodesCount = getNodeCount(state);
+            if (isSlow) {
+              experienceStore === null || experienceStore === void 0 ? void 0 : experienceStore.addMetadata(_ufo.EditorExperience.typing, {
+                slowInput: true
+              });
+            }
+            experienceStore === null || experienceStore === void 0 ? void 0 : experienceStore.success(_ufo.EditorExperience.typing, _objectSpread(_objectSpread({
+              nodeSize: state.doc.nodeSize
+            }, nodesCount), {}, {
+              objectId: (_getContextIdentifier4 = (0, _contextIdentifier.getContextIdentifier)(state)) === null || _getContextIdentifier4 === void 0 ? void 0 : _getContextIdentifier4.objectId,
+              time: time,
+              severity: shouldTrackSeverity ? severity : undefined
+            }));
+          },
+          dispatchSample: createDispatchSample(_analytics.ACTION.INPUT_PERF_SAMPLING, _view),
+          dispatchAverage: createDispatchAverage(_analytics.ACTION.INPUT_PERF_SAMPLING_AVG, _view),
+          onSlowInput: function onSlowInput(time) {
+            var _getContextIdentifier5;
+            var state = _view.state;
+            var nodesCount = getNodeCount(state);
+            dispatchAnalyticsEvent({
+              action: _analytics.ACTION.SLOW_INPUT,
+              actionSubject: _analytics.ACTION_SUBJECT.EDITOR,
+              attributes: _objectSpread(_objectSpread({
+                time: time,
+                nodeSize: state.doc.nodeSize
+              }, nodesCount), {}, {
+                objectId: (_getContextIdentifier5 = (0, _contextIdentifier.getContextIdentifier)(state)) === null || _getContextIdentifier5 === void 0 ? void 0 : _getContextIdentifier5.objectId
+              }),
+              eventType: _analytics.EVENT_TYPE.OPERATIONAL
+            });
+          }
+        });
+      }
+      if (inputTracking !== null && inputTracking !== void 0 && inputTracking.trackSingleKeypress) {
+        inputLatencySingleKeyTracker = new _inputLatencyTracking.default({
+          samplingRate: samplingRate,
+          slowThreshold: slowThreshold,
+          normalThreshold: severityThresholdNormal,
+          degradedThreshold: severityThresholdDegraded,
+          dispatchSample: createDispatchSample(_analytics.ACTION.INPUT_PERF_SAMPLING_SINGLE_KEYPRESS, _view),
+          dispatchAverage: createDispatchAverage(_analytics.ACTION.INPUT_PERF_SAMPLING_SINGLE_KEYPRESS_AVG, _view)
+        });
+      }
+      if (inputTracking !== null && inputTracking !== void 0 && inputTracking.trackRenderingTime) {
+        inputLatencyRenderedTracker = new _inputLatencyTracking.default({
+          samplingRate: samplingRate,
+          slowThreshold: slowThreshold,
+          normalThreshold: severityThresholdNormal,
+          degradedThreshold: severityThresholdDegraded,
+          dispatchSample: createDispatchSample(_analytics.ACTION.INPUT_PERF_SAMPLING_RENDERED, _view),
+          dispatchAverage: createDispatchAverage(_analytics.ACTION.INPUT_PERF_SAMPLING_RENDERED_AVG, _view)
+        });
+      }
+      var observer;
+      try {
+        var _observer = new PerformanceObserver(function (list) {
+          var perfEntries = list.getEntries();
+          for (var i = 0; i < perfEntries.length; i++) {
+            var duration = perfEntries[i].duration;
+            if (duration > freezeThreshold) {
+              dispatchLongTaskEvent(dispatchAnalyticsEvent, _view, duration, getNodeCount, browserFreezeTracking !== null && browserFreezeTracking !== void 0 && browserFreezeTracking.trackInteractionType ? interactionType : undefined, browserFreezeTracking !== null && browserFreezeTracking !== void 0 && browserFreezeTracking.trackSeverity ? (0, _utils.getAnalyticsEventSeverity)(duration, browserFreezeTracking.severityNormalThreshold || NORMAL_SEVERITY_THRESHOLD, browserFreezeTracking.severityDegradedThreshold || DEGRADED_SEVERITY_THRESHOLD) : undefined);
+            }
+          }
+        });
+
+        // register observer for long task notifications
+        _observer.observe({
+          entryTypes: ['longtask']
+        });
+      } catch (e) {}
+      return {
+        destroy: function destroy() {
+          var _inputLatencyTracker;
+          (_inputLatencyTracker = inputLatencyTracker) === null || _inputLatencyTracker === void 0 ? void 0 : _inputLatencyTracker.flush();
+          observer === null || observer === void 0 ? void 0 : observer.disconnect();
+        }
+      };
+    }
+  });
+};
+exports.default = _default;

package/dist/cjs/pm-plugins/inline-cursor-target.js

@@ -0,0 +1,184 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isInlineNodeView = exports.inlineCursorTargetStateKey = exports.default = void 0;
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _utils = require("@atlaskit/editor-common/utils");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _view = require("@atlaskit/editor-prosemirror/view");
+var inlineCursorTargetStateKey = new _state.PluginKey('inlineCursorTargetPlugin');
+exports.inlineCursorTargetStateKey = inlineCursorTargetStateKey;
+var isInlineNodeView = function isInlineNodeView(node) {
+  return node && node.type.isInline && !node.type.isText;
+};
+exports.isInlineNodeView = isInlineNodeView;
+var _default = function _default() {
+  return new _safePlugin.SafePlugin({
+    key: inlineCursorTargetStateKey,
+    state: {
+      init: function init() {
+        return {
+          cursorTarget: undefined
+        };
+      },
+      apply: function apply(tr) {
+        var selection = tr.selection,
+          doc = tr.doc;
+        var $from = selection.$from,
+          $to = selection.$to;
+        // In Safari, if the cursor target is to the right of the cursor it will block selections
+        // made with shift + arrowRight and vice versa for shift + arrowLeft. This is due to a
+        // contenteditable bug in safari, where editable elements block the selection but we need
+        // the cursor target to be editable for the following:
+        // - Ability to navigate with down/up arrows when between inline nodes
+        // - Ability to navigate with down/up arrows when between the start of a paragraph & an inline node
+        // - Ability to click and drag to select an inline node if it is the first node
+        // To prevent blocking the selection, we check handleDOMEvents and add meta to
+        // the transaction to prevent the plugin from making cursor target decorations.
+        var safariShiftSelection = tr.getMeta(inlineCursorTargetStateKey);
+        if (selection && (0, _utils.isTextSelection)(selection) && !safariShiftSelection) {
+          var hasInlineNodeViewAfter = isInlineNodeView($from.nodeAfter);
+          var hasInlineNodeViewBefore = isInlineNodeView($from.nodeBefore);
+          var isAtStartAndInlineNodeViewAfter = $from.parentOffset === 0 && isInlineNodeView($from.nodeAfter);
+          var isAtEndAndInlineNodeViewBefore = doc.resolve($from.pos).node().lastChild === $from.nodeBefore && isInlineNodeView($from.nodeBefore);
+          var createWidget = function createWidget(side) {
+            var node = document.createElement('span');
+            node.contentEditable = 'true';
+            node.setAttribute('aria-hidden', 'true');
+            node.appendChild(document.createTextNode(_utils.ZERO_WIDTH_SPACE));
+            node.className = 'cursor-target';
+            var $from = selection.$from;
+            var rightPosition = $from.pos;
+            var leftPosition = $from.posAtIndex(Math.max($from.index() - 1, 0));
+            var widgetPos = side === 'left' ? leftPosition : rightPosition;
+            return _view.Decoration.widget(widgetPos, node, {
+              raw: true,
+              key: 'inlineCursor'
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            });
+          };
+
+          // Create editable decoration widgets around the current inline node to allow proper cursor navigation.
+          if ((hasInlineNodeViewAfter || isAtEndAndInlineNodeViewBefore) && (hasInlineNodeViewBefore || isAtStartAndInlineNodeViewAfter)) {
+            return {
+              cursorTarget: {
+                decorations: [createWidget('left'), createWidget('right')],
+                positions: {
+                  from: $from.pos,
+                  to: $to.pos
+                }
+              }
+            };
+          }
+        }
+        return {
+          cursorTarget: undefined
+        };
+      }
+    },
+    props: {
+      decorations: function decorations(state) {
+        var doc = state.doc;
+        var _ref = inlineCursorTargetStateKey.getState(state),
+          cursorTarget = _ref.cursorTarget;
+        if (cursorTargetHasValidDecorations(cursorTarget)) {
+          return _view.DecorationSet.create(doc, cursorTarget.decorations);
+        }
+        return null;
+      },
+      handleDOMEvents: {
+        // Workaround to prevent the decorations created by the plugin from
+        // blocking shift + arrow left/right selections in safari. When
+        // a shift + arrow left/right event is detected, send meta data to the
+        // plugin to prevent it from creating decorations.
+        // TODO We may be able to remove this when playing the following ticket:
+        // https://product-fabric.atlassian.net/browse/ED-14938
+        keydown: function keydown(view, event) {
+          if (_utils.browser.safari && event instanceof KeyboardEvent && event.shiftKey && (event.key === 'ArrowLeft' || event.key === 'ArrowRight')) {
+            view.dispatch(view.state.tr.setMeta(inlineCursorTargetStateKey, {
+              cursorTarget: undefined
+            }));
+          }
+          return false;
+        },
+        // Check the DOM to see if there are inline cursor targets
+        // after a composition event ends. If so, manually insert the
+        // event data in order to prevent contents ending up inside
+        // of the cursor target decorations.
+        compositionend: function compositionend(view, incorrectlyTypedEvent) {
+          // This is typed by the prosemirror definitions as Event,
+          // this type is incorrect, and it is actually an InputEvent
+          var event = incorrectlyTypedEvent;
+          var state = view.state;
+          var _ref2 = inlineCursorTargetStateKey.getState(state),
+            cursorTarget = _ref2.cursorTarget;
+          if (cursorTarget !== undefined) {
+            handleTextInputInsideCursorTargetDecoration({
+              event: event,
+              cursorTarget: cursorTarget,
+              view: view
+            });
+            return true;
+          }
+          return false;
+        },
+        // Check the DOM to see if there are inline cursor targets
+        // before any input event. If so, manually insert the
+        // event data in order to prevent contents ending up inside
+        // of the cursor target decorations.
+        beforeinput: function beforeinput(view, incorrectlyTypedEvent) {
+          // This is typed by the prosemirror definitions as Event,
+          // this type is incorrect, and it is actually an InputEvent
+          var event = incorrectlyTypedEvent;
+          var state = view.state;
+          var _ref3 = inlineCursorTargetStateKey.getState(state),
+            cursorTarget = _ref3.cursorTarget;
+          if (!event.isComposing && cursorTarget !== undefined) {
+            handleTextInputInsideCursorTargetDecoration({
+              event: event,
+              cursorTarget: cursorTarget,
+              view: view
+            });
+            return true;
+          }
+          return false;
+        }
+      }
+    }
+  });
+};
+exports.default = _default;
+function cursorTargetHasValidDecorations(cursorTarget) {
+  if (!cursorTarget ||
+  // Decorations can end up as null when the decorations prop is
+  // called after the decorations have been removed from the dom.
+  // https://github.com/ProseMirror/prosemirror-view/blob/8f0d313a6389b86a335274fba36534ba1cb21f12/src/decoration.js#L30
+  cursorTarget.decorations.includes(null)) {
+    return false;
+  }
+  return true;
+}
+function handleTextInputInsideCursorTargetDecoration(_ref4) {
+  var event = _ref4.event,
+    view = _ref4.view,
+    cursorTarget = _ref4.cursorTarget;
+  event.stopPropagation();
+  event.preventDefault();
+  var content = event.data || '';
+  var tr = view.state.tr;
+
+  // ensure any custom handleTextInput handlers are called for the input event
+  // ie. type ahead, emoji shortcuts.
+  var potentiallyHandleByHandleTextInput = view.someProp('handleTextInput', function (f) {
+    return f(view, cursorTarget.positions.from, cursorTarget.positions.to, content);
+  });
+  if (potentiallyHandleByHandleTextInput) {
+    // if a handleTextInput handler has handled the event, we don't want to
+    // manually update the document.
+    return;
+  }
+  tr.insertText(content);
+  view.dispatch(tr);
+}

package/dist/cjs/pm-plugins/newline-preserve-marks.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.newlinePreserveMarksKey = exports.default = void 0;
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _utils = require("@atlaskit/editor-common/utils");
+var _keymap = require("@atlaskit/editor-prosemirror/keymap");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var newlinePreserveMarksKey = new _state.PluginKey('newlinePreserveMarksPlugin');
+exports.newlinePreserveMarksKey = newlinePreserveMarksKey;
+var isSelectionAligned = function isSelectionAligned(state) {
+  return !!state.selection.$to.parent.marks.find(function (m) {
+    return m.type === state.schema.marks.alignment;
+  });
+};
+var splitBlockPreservingMarks = function splitBlockPreservingMarks(state, dispatch) {
+  if (dispatch) {
+    dispatch(state.tr.split(state.tr.mapping.map(state.selection.$from.pos), 1));
+  }
+  return true;
+};
+var _default = function _default() {
+  return new _safePlugin.SafePlugin({
+    key: newlinePreserveMarksKey,
+    props: {
+      handleKeyDown: (0, _keymap.keydownHandler)({
+        Enter: (0, _utils.filterCommand)([_utils.isSelectionEndOfParagraph, isSelectionAligned], splitBlockPreservingMarks)
+      })
+    }
+  });
+};
+exports.default = _default;