@atlaskit/editor-common 69.2.2 → 69.3.1

package/dist/cjs/ui-menu/ToolbarButton/index.js

@@ -0,0 +1,127 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.TOOLBAR_BUTTON = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _react2 = require("@emotion/react");
+
+var _analyticsListeners = require("@atlaskit/analytics-listeners");
+
+var _tooltip = _interopRequireDefault(require("@atlaskit/tooltip"));
+
+var _analytics = require("../../analytics");
+
+var _styles = _interopRequireDefault(require("./styles"));
+
+var _templateObject;
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var TOOLBAR_BUTTON = _analytics.TOOLBAR_ACTION_SUBJECT_ID;
+exports.TOOLBAR_BUTTON = TOOLBAR_BUTTON;
+var buttonWrapper = (0, _react2.css)(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2.default)(["\n  display: flex;\n  height: 100%;\n"])));
+
+var ToolbarButton = /*#__PURE__*/_react.default.forwardRef(function (props, ref) {
+  var buttonId = props.buttonId,
+      testId = props.testId,
+      _props$className = props.className,
+      className = _props$className === void 0 ? '' : _props$className,
+      href = props.href,
+      iconAfter = props.iconAfter,
+      iconBefore = props.iconBefore,
+      disabled = props.disabled,
+      selected = props.selected,
+      spacing = props.spacing,
+      target = props.target,
+      children = props.children,
+      hideTooltip = props.hideTooltip,
+      title = props.title,
+      _props$titlePosition = props.titlePosition,
+      titlePosition = _props$titlePosition === void 0 ? 'top' : _props$titlePosition,
+      item = props.item,
+      ariaLabel = props['aria-label'],
+      ariaHasPopup = props['aria-haspopup'],
+      ariaExpanded = props['aria-expanded'],
+      ariaPressed = props['aria-pressed'],
+      onClick = props.onClick,
+      onItemClick = props.onItemClick;
+  var handleClick = (0, _react.useCallback)(function (event, analyticsEvent) {
+    if (disabled) {
+      return;
+    }
+
+    if (buttonId) {
+      analyticsEvent.update(function (payload) {
+        return _objectSpread(_objectSpread({}, payload), {}, {
+          action: _analytics.ACTION.CLICKED,
+          actionSubject: _analytics.ACTION_SUBJECT.TOOLBAR_BUTTON,
+          actionSubjectId: buttonId,
+          eventType: _analytics.EVENT_TYPE.UI
+        });
+      }).fire(_analyticsListeners.FabricChannel.editor);
+    }
+
+    if (onClick) {
+      onClick(event);
+    }
+
+    if (item && onItemClick) {
+      onItemClick(item);
+    }
+  }, [disabled, onClick, onItemClick, item, buttonId]);
+  var id = buttonId ? "editor-toolbar__".concat(buttonId) : undefined;
+  var button = (0, _react2.jsx)(_styles.default, {
+    id: id,
+    ref: ref,
+    appearance: "subtle",
+    testId: testId,
+    className: className,
+    href: href,
+    iconAfter: iconAfter,
+    iconBefore: iconBefore,
+    isDisabled: disabled,
+    isSelected: selected,
+    onClick: handleClick,
+    spacing: spacing || 'default',
+    target: target,
+    shouldFitContainer: true,
+    "aria-expanded": ariaExpanded,
+    "aria-haspopup": ariaHasPopup,
+    "aria-label": ariaLabel,
+    "aria-pressed": ariaPressed
+  }, children);
+
+  if (!title) {
+    return button;
+  }
+
+  var tooltipContent = !hideTooltip ? title : null;
+  return (0, _react2.jsx)(_tooltip.default, {
+    content: tooltipContent,
+    hideTooltipOnClick: true,
+    position: titlePosition
+  }, (0, _react2.jsx)("div", {
+    css: buttonWrapper
+  }, button));
+});
+
+var _default = ToolbarButton;
+exports.default = _default;

package/dist/cjs/ui-menu/ToolbarButton/styles.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _standardButton = _interopRequireDefault(require("@atlaskit/button/standard-button"));
+
+var _default = /*#__PURE__*/_react.default.forwardRef(function (props, ref) {
+  return /*#__PURE__*/_react.default.createElement(_standardButton.default, (0, _extends2.default)({
+    ref: ref
+  }, props, {
+    style: {
+      alignItems: 'center'
+    }
+  }));
+});
+
+exports.default = _default;

package/dist/cjs/ui-menu/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Dropdown", {
+  enumerable: true,
+  get: function get() {
+    return _Dropdown.default;
+  }
+});
+Object.defineProperty(exports, "DropdownMenu", {
+  enumerable: true,
+  get: function get() {
+    return _DropdownMenu.default;
+  }
+});
+Object.defineProperty(exports, "TOOLBAR_BUTTON", {
+  enumerable: true,
+  get: function get() {
+    return _ToolbarButton.TOOLBAR_BUTTON;
+  }
+});
+Object.defineProperty(exports, "ToolbarButton", {
+  enumerable: true,
+  get: function get() {
+    return _ToolbarButton.default;
+  }
+});
+
+var _DropdownMenu = _interopRequireDefault(require("../ui-menu/DropdownMenu"));
+
+var _ToolbarButton = _interopRequireWildcard(require("../ui-menu/ToolbarButton"));
+
+var _Dropdown = _interopRequireDefault(require("./Dropdown"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/dist/cjs/ui-react/ReactEditorViewContext.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var ReactEditorViewContext = /*#__PURE__*/_react.default.createContext({});
+
+var _default = ReactEditorViewContext;
+exports.default = _default;

package/dist/cjs/ui-react/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ReactEditorViewContext", {
+  enumerable: true,
+  get: function get() {
+    return _ReactEditorViewContext.default;
+  }
+});
+Object.defineProperty(exports, "withReactEditorViewOuterListeners", {
+  enumerable: true,
+  get: function get() {
+    return _withReactEditorViewOuterListeners.default;
+  }
+});
+
+var _ReactEditorViewContext = _interopRequireDefault(require("./ReactEditorViewContext"));
+
+var _withReactEditorViewOuterListeners = _interopRequireDefault(require("./with-react-editor-view-outer-listeners"));

package/dist/cjs/ui-react/with-react-editor-view-outer-listeners.js

@@ -0,0 +1,159 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = withReactEditorViewOuterListeners;
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactDom = _interopRequireDefault(require("react-dom"));
+
+var _ReactEditorViewContext = _interopRequireDefault(require("./ReactEditorViewContext"));
+
+var _excluded = ["handleClickOutside", "handleEnterKeydown", "handleEscapeKeydown"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var WithOutsideClick = /*#__PURE__*/function (_PureComponent) {
+  (0, _inherits2.default)(WithOutsideClick, _PureComponent);
+
+  var _super = _createSuper(WithOutsideClick);
+
+  function WithOutsideClick() {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, WithOutsideClick);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "handleClick", function (evt) {
+      if (!_this.props.isActiveComponent) {
+        return;
+      }
+
+      var domNode = _reactDom.default.findDOMNode((0, _assertThisInitialized2.default)(_this)); // eslint-disable-line react/no-find-dom-node
+
+
+      if (!domNode || evt.target instanceof Node && !domNode.contains(evt.target)) {
+        if (_this.props.handleClickOutside) {
+          _this.props.handleClickOutside(evt);
+        }
+      }
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "handleKeydown", function (evt) {
+      if (!_this.props.isActiveComponent) {
+        return;
+      }
+
+      if (evt.code === 'Escape' && _this.props.handleEscapeKeydown) {
+        var _this$props$editorVie;
+
+        evt.preventDefault();
+        evt.stopPropagation();
+
+        _this.props.handleEscapeKeydown(evt);
+
+        if (!((_this$props$editorVie = _this.props.editorView) !== null && _this$props$editorVie !== void 0 && _this$props$editorVie.hasFocus())) {
+          var _this$props$editorVie2;
+
+          (_this$props$editorVie2 = _this.props.editorView) === null || _this$props$editorVie2 === void 0 ? void 0 : _this$props$editorVie2.focus();
+        }
+
+        return false;
+      } else if (evt.code === 'Enter' && _this.props.handleEnterKeydown) {
+        _this.props.handleEnterKeydown(evt);
+      }
+    });
+    return _this;
+  }
+
+  (0, _createClass2.default)(WithOutsideClick, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.props.handleClickOutside) {
+        document.addEventListener('click', this.handleClick, false);
+      }
+
+      if (this.props.handleEscapeKeydown) {
+        var _this$props$editorRef;
+
+        (((_this$props$editorRef = this.props.editorRef) === null || _this$props$editorRef === void 0 ? void 0 : _this$props$editorRef.current) || document).addEventListener('keydown', this.handleKeydown, false);
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.props.handleClickOutside) {
+        document.removeEventListener('click', this.handleClick, false);
+      }
+
+      if (this.props.handleEscapeKeydown) {
+        var _this$props$editorRef2;
+
+        (((_this$props$editorRef2 = this.props.editorRef) === null || _this$props$editorRef2 === void 0 ? void 0 : _this$props$editorRef2.current) || document).removeEventListener('keydown', this.handleKeydown, false);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return this.props.children;
+    }
+  }]);
+  return WithOutsideClick;
+}(_react.PureComponent);
+
+function hasIsOpen(props) {
+  return 'isOpen' in props;
+}
+
+function withReactEditorViewOuterListeners(Component) {
+  return function (_ref) {
+    var handleClickOutside = _ref.handleClickOutside,
+        handleEnterKeydown = _ref.handleEnterKeydown,
+        handleEscapeKeydown = _ref.handleEscapeKeydown,
+        props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+    var isActiveComponent = hasIsOpen(props) ? props.isOpen : true;
+    return /*#__PURE__*/_react.default.createElement(_ReactEditorViewContext.default.Consumer, null, function (_ref2) {
+      var editorView = _ref2.editorView,
+          editorRef = _ref2.editorRef;
+      return /*#__PURE__*/_react.default.createElement(WithOutsideClick, {
+        editorView: editorView,
+        editorRef: editorRef,
+        isActiveComponent: isActiveComponent,
+        handleClickOutside: handleClickOutside,
+        handleEnterKeydown: handleEnterKeydown,
+        handleEscapeKeydown: handleEscapeKeydown
+      }, /*#__PURE__*/_react.default.createElement(Component, props));
+    });
+  };
+}

package/dist/cjs/utils/dom.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.closest = closest;
+exports.closestElement = closestElement;
+exports.containsClassName = void 0;
+exports.mapElem = mapElem;
+exports.maphElem = maphElem;
+exports.parsePx = parsePx;
+exports.removeNestedEmptyEls = removeNestedEmptyEls;
+exports.unwrap = unwrap;
+exports.walkUpTreeUntil = walkUpTreeUntil;
+
+/**
+ * Walks a DOM tree up to the provided `stopElement`, or if falsy before.
+ * @param element
+ * @param stopElement
+ */
+function walkUpTreeUntil(element, shouldStop) {
+  var rootElement = element;
+
+  while (rootElement && rootElement.parentElement && !shouldStop(rootElement)) {
+    rootElement = rootElement.parentElement;
+  }
+
+  return rootElement;
+}
+/**
+ * Takes all children out from wrapped el and puts them directly inside
+ * the parent el, at the wrapped el's position
+ */
+
+
+function unwrap(parent, wrapped) {
+  var docsFragment = document.createDocumentFragment();
+  Array.from(wrapped.children).forEach(function (child) {
+    docsFragment.appendChild(child);
+  });
+  parent.replaceChild(docsFragment, wrapped);
+}
+/**
+ * Walks up DOM removing elements if they are empty until it finds
+ * one that is not
+ */
+
+
+function removeNestedEmptyEls(el) {
+  while (el.parentElement && el.childElementCount === 0 && el.textContent === '') {
+    var parentEl = el.parentElement;
+    parentEl.removeChild(el);
+    el = parentEl;
+  }
+}
+/**
+ * IE11 doesn't support classList to SVGElements
+ **/
+
+
+var containsClassName = function containsClassName(node, className) {
+  if (!node) {
+    return false;
+  }
+
+  if (node.classList && node.classList.contains) {
+    return node.classList.contains(className);
+  }
+
+  if (!node.className) {
+    return false;
+  }
+
+  var classNames = typeof node.className.baseVal === 'string' ? node.className.baseVal : node.className;
+  return classNames.split(' ').indexOf(className) !== -1;
+};
+
+exports.containsClassName = containsClassName;
+
+function closest(node, s) {
+  if (!node) {
+    return null;
+  }
+
+  var el = node;
+
+  if (!document.documentElement || !document.documentElement.contains(el)) {
+    return null;
+  }
+
+  if (el.closest) {
+    return el.closest(s);
+  }
+
+  do {
+    var matchfn = el.matches ? el.matches : el.msMatchesSelector;
+
+    if (matchfn && matchfn.call(el, s)) {
+      return el;
+    }
+
+    el = el.parentElement || el.parentNode;
+  } while (el !== null && el.nodeType === 1);
+
+  return null;
+}
+/*
+ * @deprecated - Use HTMLElement.protoype.closest instead
+ */
+
+
+function closestElement(node, s) {
+  return closest(node, s);
+}
+
+function parsePx(pxStr) {
+  if (!pxStr.endsWith('px')) {
+    return undefined;
+  }
+
+  var maybeNumber = parseInt(pxStr, 10);
+  return !Number.isNaN(maybeNumber) ? maybeNumber : undefined;
+}
+
+// does typescript have function templates yet?
+function mapElem(elem, callback) {
+  var array = [];
+
+  for (var i = 0; i < elem.childElementCount; i++) {
+    array.push(callback(elem.children[i], i, elem));
+  }
+
+  return array;
+}
+
+function maphElem(elem, callback) {
+  return mapElem(elem, callback);
+}

package/dist/cjs/utils/editor-core-utils.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isValidPosition = exports.isTextSelection = exports.isLastItemMediaGroup = exports.isElementInTableCell = exports.extractSliceFromStep = void 0;
+exports.nonNullable = nonNullable;
+exports.setNodeSelection = void 0;
+exports.stepAddsOneOf = stepAddsOneOf;
+exports.stepHasSlice = void 0;
+
+var _prosemirrorState = require("prosemirror-state");
+
+var _prosemirrorTransform = require("prosemirror-transform");
+
+var _dom = require("./dom");
+
+var stepHasSlice = function stepHasSlice(step) {
+  return step && step.hasOwnProperty('slice');
+};
+/**
+ * Checks whether a given step is adding nodes of given nodeTypes
+ *
+ * @param step Step to check
+ * @param nodeTypes NodeTypes being added
+ */
+
+
+exports.stepHasSlice = stepHasSlice;
+
+function stepAddsOneOf(step, nodeTypes) {
+  var adds = false;
+
+  if (!stepHasSlice(step)) {
+    return adds;
+  }
+
+  step.slice.content.descendants(function (node) {
+    if (nodeTypes.has(node.type)) {
+      adds = true;
+    }
+
+    return !adds;
+  });
+  return adds;
+}
+
+var extractSliceFromStep = function extractSliceFromStep(step) {
+  if (!(step instanceof _prosemirrorTransform.ReplaceStep) && !(step instanceof _prosemirrorTransform.ReplaceAroundStep)) {
+    return null;
+  } // @ts-ignore This is by design. Slice is a private property, but accesible, from ReplaceStep.
+  // However, we need to read it to found if the step was adding a newline
+
+
+  var slice = step.slice;
+  return slice;
+};
+
+exports.extractSliceFromStep = extractSliceFromStep;
+
+var isTextSelection = function isTextSelection(selection) {
+  return selection instanceof _prosemirrorState.TextSelection;
+};
+
+exports.isTextSelection = isTextSelection;
+
+var isElementInTableCell = function isElementInTableCell(element) {
+  return (0, _dom.closest)(element, 'td') || (0, _dom.closest)(element, 'th');
+};
+
+exports.isElementInTableCell = isElementInTableCell;
+
+var isLastItemMediaGroup = function isLastItemMediaGroup(node) {
+  var content = node.content;
+  return !!content.lastChild && content.lastChild.type.name === 'mediaGroup';
+}; // TODO: pulled from `packages/editor/editor-core/src/utils/selection.ts`
+
+
+exports.isLastItemMediaGroup = isLastItemMediaGroup;
+
+var setNodeSelection = function setNodeSelection(view, pos) {
+  var state = view.state,
+      dispatch = view.dispatch;
+
+  if (!isFinite(pos)) {
+    return;
+  }
+
+  var tr = state.tr.setSelection(_prosemirrorState.NodeSelection.create(state.doc, pos));
+  dispatch(tr);
+};
+
+exports.setNodeSelection = setNodeSelection;
+
+function nonNullable(value) {
+  return value !== null && value !== undefined;
+} // checks if the given position is within the ProseMirror document
+
+
+var isValidPosition = function isValidPosition(pos, state) {
+  if (pos >= 0 && pos <= state.doc.resolve(0).end()) {
+    return true;
+  }
+
+  return false;
+};
+
+exports.isValidPosition = isValidPosition;