@atlaskit/editor-common 69.2.2 → 69.3.0

package/dist/es2019/node-width/index.js

@@ -0,0 +1,74 @@
+import { findParentNodeOfTypeClosestToPos } from 'prosemirror-utils';
+import { akEditorFullWidthLayoutWidth, akLayoutGutterOffset, gridMediumMaxWidth } from '@atlaskit/editor-shared-styles';
+import { BODIED_EXT_PADDING } from '../styles/shared/extension';
+import { LAYOUT_COLUMN_PADDING, LAYOUT_SECTION_MARGIN } from '../styles/shared/layout';
+import { absoluteBreakoutWidth } from '../utils/breakout';
+/**
+ * Calculates width of parent node of a nested node (inside layouts, extension)
+ * If current node selection is not nested will return undefined
+ */
+
+export const getParentNodeWidth = (pos, state, containerWidth, isFullWidthModeEnabled) => {
+  if (!pos) {
+    return;
+  }
+
+  const node = getNestedParentNode(pos, state);
+
+  if (!node) {
+    return;
+  }
+
+  let layout = node.attrs.layout || 'default';
+  const {
+    schema
+  } = state;
+  const breakoutMark = schema.marks.breakout && schema.marks.breakout.isInSet(node.marks);
+
+  if (breakoutMark && breakoutMark.attrs.mode) {
+    layout = breakoutMark.attrs.mode;
+  }
+
+  let parentWidth = calcBreakoutNodeWidth(layout, containerWidth, isFullWidthModeEnabled);
+
+  if (node.type === schema.nodes.layoutSection) {
+    parentWidth += akLayoutGutterOffset * 2; // extra width that gets added to layout
+
+    if (containerWidth.width > gridMediumMaxWidth) {
+      parentWidth -= (LAYOUT_SECTION_MARGIN + 2) * (node.childCount - 1); // margin between sections
+
+      const $pos = state.doc.resolve(pos);
+      const column = findParentNodeOfTypeClosestToPos($pos, [state.schema.nodes.layoutColumn]);
+
+      if (column && column.node && !isNaN(column.node.attrs.width)) {
+        // get exact width of parent layout column using node attrs
+        parentWidth = Math.round(parentWidth * column.node.attrs.width * 0.01);
+      }
+    }
+  } // account for the padding of the parent node
+
+
+  if (node.type === schema.nodes.layoutSection) {
+    parentWidth -= LAYOUT_COLUMN_PADDING * 2;
+  } else if (node.type === schema.nodes.bodiedExtension) {
+    parentWidth -= BODIED_EXT_PADDING * 2;
+  }
+
+  parentWidth -= 2; // border
+
+  return parentWidth;
+};
+
+const getNestedParentNode = (tablePos, state) => {
+  if (tablePos === undefined) {
+    return null;
+  }
+
+  const $pos = state.doc.resolve(tablePos);
+  const parent = findParentNodeOfTypeClosestToPos($pos, [state.schema.nodes.bodiedExtension, state.schema.nodes.layoutSection, state.schema.nodes.expand]);
+  return parent ? parent.node : null;
+};
+
+const calcBreakoutNodeWidth = (layout, containerWidth, isFullWidthModeEnabled) => {
+  return isFullWidthModeEnabled ? Math.min(containerWidth.lineLength, akEditorFullWidthLayoutWidth) : absoluteBreakoutWidth(layout, containerWidth.width);
+};

package/dist/es2019/react-node-view/index.js

@@ -0,0 +1,199 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React from 'react';
+import { ACTION_SUBJECT, ACTION_SUBJECT_ID } from '../analytics';
+import { createDispatch } from '../event-dispatcher';
+import { ErrorBoundary } from '../ui/ErrorBoundary';
+import { analyticsEventKey } from '../utils/analytics'; //import {
+//  getPerformanceOptions,
+//  startMeasureReactNodeViewRendered,
+//  stopMeasureReactNodeViewRendered,
+//} from './get-performance-options';
+
+export default class ReactNodeView {
+  constructor(_node, view, getPos, portalProviderAPI, eventDispatcher, reactComponentProps, reactComponent, hasAnalyticsContext = false, viewShouldUpdate, hasIntlContext = false) {
+    _defineProperty(this, "handleRef", node => this._handleRef(node));
+
+    _defineProperty(this, "dispatchAnalyticsEvent", payload => {
+      if (this.eventDispatcher) {
+        const dispatch = createDispatch(this.eventDispatcher);
+        dispatch(analyticsEventKey, {
+          payload
+        });
+      }
+    });
+
+    this.node = _node;
+    this.view = view;
+    this.getPos = getPos;
+    this.portalProviderAPI = portalProviderAPI;
+    this.reactComponentProps = reactComponentProps || {};
+    this.reactComponent = reactComponent;
+    this.hasAnalyticsContext = hasAnalyticsContext;
+    this._viewShouldUpdate = viewShouldUpdate;
+    this.eventDispatcher = eventDispatcher;
+    this.hasIntlContext = hasIntlContext;
+  }
+  /**
+   * This method exists to move initialization logic out of the constructor,
+   * so object can be initialized properly before calling render first time.
+   *
+   * Example:
+   * Instance properties get added to an object only after super call in
+   * constructor, which leads to some methods being undefined during the
+   * first render.
+   */
+
+
+  init() {
+    this.domRef = this.createDomRef();
+    this.setDomAttrs(this.node, this.domRef);
+    const {
+      dom: contentDOMWrapper,
+      contentDOM
+    } = this.getContentDOM() || {
+      dom: undefined,
+      contentDOM: undefined
+    };
+
+    if (this.domRef && contentDOMWrapper) {
+      this.domRef.appendChild(contentDOMWrapper);
+      this.contentDOM = contentDOM ? contentDOM : contentDOMWrapper;
+      this.contentDOMWrapper = contentDOMWrapper || contentDOM;
+    } // @see ED-3790
+    // something gets messed up during mutation processing inside of a
+    // nodeView if DOM structure has nested plain "div"s, it doesn't see the
+    // difference between them and it kills the nodeView
+
+
+    this.domRef.classList.add(`${this.node.type.name}View-content-wrap`); // TODO: ED-15580
+    //const {
+    //  samplingRate,
+    //  slowThreshold,
+    //  trackingEnabled,
+    //} = getPerformanceOptions(this.view);
+    //trackingEnabled &&
+    //  startMeasureReactNodeViewRendered({ nodeTypeName: this.node.type.name });
+
+    this.renderReactComponent(() => this.render(this.reactComponentProps, this.handleRef)); //trackingEnabled &&
+    //  stopMeasureReactNodeViewRendered({
+    //    nodeTypeName: this.node.type.name,
+    //    dispatchAnalyticsEvent: this.dispatchAnalyticsEvent,
+    //    editorState: this.view.state,
+    //    samplingRate,
+    //    slowThreshold,
+    //  });
+
+    return this;
+  }
+
+  renderReactComponent(component) {
+    if (!this.domRef || !component) {
+      return;
+    }
+
+    const componentWithErrorBoundary = () => {
+      var _this$node$type$name, _this$node, _this$node$type;
+
+      return /*#__PURE__*/React.createElement(ErrorBoundary, {
+        component: ACTION_SUBJECT.REACT_NODE_VIEW,
+        componentId: (_this$node$type$name = this === null || this === void 0 ? void 0 : (_this$node = this.node) === null || _this$node === void 0 ? void 0 : (_this$node$type = _this$node.type) === null || _this$node$type === void 0 ? void 0 : _this$node$type.name) !== null && _this$node$type$name !== void 0 ? _this$node$type$name : ACTION_SUBJECT_ID.UNKNOWN_NODE,
+        dispatchAnalyticsEvent: this.dispatchAnalyticsEvent
+      }, component());
+    };
+
+    this.portalProviderAPI.render(componentWithErrorBoundary, this.domRef, this.hasAnalyticsContext, this.hasIntlContext);
+  }
+
+  createDomRef() {
+    if (!this.node.isInline) {
+      return document.createElement('div');
+    }
+
+    const htmlElement = document.createElement('span');
+    return htmlElement;
+  }
+
+  getContentDOM() {
+    return undefined;
+  }
+
+  _handleRef(node) {
+    const contentDOM = this.contentDOMWrapper || this.contentDOM; // move the contentDOM node inside the inner reference after rendering
+
+    if (node && contentDOM && !node.contains(contentDOM)) {
+      node.appendChild(contentDOM);
+    }
+  }
+
+  render(props, forwardRef) {
+    return this.reactComponent ? /*#__PURE__*/React.createElement(this.reactComponent, _extends({
+      view: this.view,
+      getPos: this.getPos,
+      node: this.node,
+      forwardRef: forwardRef
+    }, props)) : null;
+  }
+
+  update(node, _decorations, _innerDecorations, validUpdate = () => true) {
+    // @see https://github.com/ProseMirror/prosemirror/issues/648
+    const isValidUpdate = this.node.type === node.type && validUpdate(this.node, node);
+
+    if (!isValidUpdate) {
+      return false;
+    }
+
+    if (this.domRef && !this.node.sameMarkup(node)) {
+      this.setDomAttrs(node, this.domRef);
+    } // View should not process a re-render if this is false.
+    // We dont want to destroy the view, so we return true.
+
+
+    if (!this.viewShouldUpdate(node)) {
+      this.node = node;
+      return true;
+    }
+
+    this.node = node;
+    this.renderReactComponent(() => this.render(this.reactComponentProps, this.handleRef));
+    return true;
+  }
+
+  viewShouldUpdate(nextNode) {
+    if (this._viewShouldUpdate) {
+      return this._viewShouldUpdate(nextNode);
+    }
+
+    return true;
+  }
+  /**
+   * Copies the attributes from a ProseMirror Node to a DOM node.
+   * @param node The Prosemirror Node from which to source the attributes
+   */
+
+
+  setDomAttrs(node, element) {
+    Object.keys(node.attrs || {}).forEach(attr => {
+      element.setAttribute(attr, node.attrs[attr]);
+    });
+  }
+
+  get dom() {
+    return this.domRef;
+  }
+
+  destroy() {
+    if (!this.domRef) {
+      return;
+    }
+
+    this.portalProviderAPI.remove(this.domRef);
+    this.domRef = undefined;
+    this.contentDOM = undefined;
+  }
+
+  static fromComponent(component, portalProviderAPI, eventDispatcher, props, viewShouldUpdate, hasIntlContext = false) {
+    return (node, view, getPos) => new ReactNodeView(node, view, getPos, portalProviderAPI, eventDispatcher, props, component, false, viewShouldUpdate, hasIntlContext).init();
+  }
+
+}

package/dist/es2019/react-node-view/types.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/selection/gap-cursor/selection.js

@@ -0,0 +1,136 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { Slice } from 'prosemirror-model';
+import { Selection } from 'prosemirror-state';
+import { isValidTargetNode } from './utils/is-valid-target-node';
+export let Side;
+
+(function (Side) {
+  Side["LEFT"] = "left";
+  Side["RIGHT"] = "right";
+})(Side || (Side = {}));
+
+export const JSON_ID = 'gapcursor';
+export class GapCursorSelection extends Selection {
+  /**
+   * Construct a GapCursorSelection
+   * @param {ResolvedPos} $pos resolved position
+   * @param {Side} side side where the gap cursor is drawn
+   */
+  constructor($pos, side = Side.LEFT) {
+    super($pos, $pos);
+
+    _defineProperty(this, "visible", false);
+
+    this.side = side;
+  }
+
+  static valid($pos) {
+    const {
+      parent,
+      nodeBefore,
+      nodeAfter
+    } = $pos;
+    const targetNode = isValidTargetNode(nodeBefore) ? nodeBefore : isValidTargetNode(nodeAfter) ? nodeAfter : null;
+
+    if (!targetNode || parent.isTextblock) {
+      return false;
+    }
+
+    const deflt = parent.contentMatchAt($pos.index()).defaultType;
+    return deflt && deflt.isTextblock;
+  }
+
+  static findFrom($pos, dir, mustMove = false) {
+    const side = dir === 1 ? Side.RIGHT : Side.LEFT;
+
+    if (!mustMove && GapCursorSelection.valid($pos)) {
+      return new GapCursorSelection($pos, side);
+    }
+
+    let pos = $pos.pos; // TODO: Fix any, potential issue. ED-5048
+
+    let next = null; // Scan up from this position
+
+    for (let d = $pos.depth;; d--) {
+      const parent = $pos.node(d);
+
+      if (side === Side.RIGHT ? $pos.indexAfter(d) < parent.childCount : $pos.index(d) > 0) {
+        next = parent.maybeChild(side === Side.RIGHT ? $pos.indexAfter(d) : $pos.index(d) - 1);
+        break;
+      } else if (d === 0) {
+        return null;
+      }
+
+      pos += dir;
+      const $cur = $pos.doc.resolve(pos);
+
+      if (GapCursorSelection.valid($cur)) {
+        return new GapCursorSelection($cur, side);
+      }
+    } // And then down into the next node
+
+
+    for (;;) {
+      next = side === Side.RIGHT ? next.firstChild : next.lastChild;
+
+      if (next === null) {
+        break;
+      }
+
+      pos += dir;
+      const $cur = $pos.doc.resolve(pos);
+
+      if (GapCursorSelection.valid($cur)) {
+        return new GapCursorSelection($cur, side);
+      }
+    }
+
+    return null;
+  }
+
+  static fromJSON(doc, json) {
+    return new GapCursorSelection(doc.resolve(json.pos), json.side);
+  }
+
+  map(doc, mapping) {
+    const $pos = doc.resolve(mapping.map(this.head));
+    return GapCursorSelection.valid($pos) ? new GapCursorSelection($pos, this.side) : Selection.near($pos);
+  }
+
+  eq(other) {
+    return other instanceof GapCursorSelection && other.head === this.head;
+  }
+
+  content() {
+    return Slice.empty;
+  }
+
+  getBookmark() {
+    return new GapBookmark(this.anchor);
+  }
+
+  toJSON() {
+    return {
+      pos: this.head,
+      type: JSON_ID,
+      side: this.side
+    };
+  }
+
+}
+Selection.jsonID(JSON_ID, GapCursorSelection);
+export class GapBookmark {
+  constructor(pos) {
+    this.pos = pos;
+  }
+
+  map(mapping) {
+    return new GapBookmark(mapping.map(this.pos));
+  }
+
+  resolve(doc) {
+    const $pos = doc.resolve(this.pos);
+    return GapCursorSelection.valid($pos) ? new GapCursorSelection($pos) : Selection.near($pos);
+  }
+
+}

package/dist/es2019/selection/gap-cursor/utils/index.js

@@ -0,0 +1,2 @@
+export { isIgnored } from './is-ignored';
+export { isValidTargetNode } from './is-valid-target-node';

package/dist/es2019/selection/gap-cursor/utils/is-ignored.js

@@ -0,0 +1,5 @@
+// we don't show gap cursor for those nodes
+const IGNORED_NODES = ['paragraph', 'bulletList', 'orderedList', 'listItem', 'taskItem', 'decisionItem', 'heading', 'blockquote', 'layoutColumn', 'caption', 'media'];
+export const isIgnored = node => {
+  return !!node && IGNORED_NODES.indexOf(node.type.name) !== -1;
+};

package/dist/es2019/selection/gap-cursor/utils/is-valid-target-node.js

@@ -0,0 +1,4 @@
+import { isIgnored } from './is-ignored';
+export const isValidTargetNode = node => {
+  return !!node && !isIgnored(node);
+};

package/dist/es2019/selection/index.js

@@ -0,0 +1,4 @@
+export { RelativeSelectionPos } from './types';
+export { GapCursorSelection, Side, JSON_ID, GapBookmark } from './gap-cursor/selection';
+export { isIgnored, isValidTargetNode } from './gap-cursor/utils';
+export { isSelectionAtStartOfNode, isSelectionAtEndOfNode } from './utils';

package/dist/es2019/selection/types.js

@@ -0,0 +1,8 @@
+export let RelativeSelectionPos;
+
+(function (RelativeSelectionPos) {
+  RelativeSelectionPos["Before"] = "Before";
+  RelativeSelectionPos["Start"] = "Start";
+  RelativeSelectionPos["Inside"] = "Inside";
+  RelativeSelectionPos["End"] = "End";
+})(RelativeSelectionPos || (RelativeSelectionPos = {}));

package/dist/es2019/selection/utils.js

@@ -0,0 +1,38 @@
+export const isSelectionAtStartOfNode = ($pos, parentNode) => {
+  if (!parentNode) {
+    return false;
+  }
+
+  for (let i = $pos.depth + 1; i > 0; i--) {
+    const node = $pos.node(i);
+
+    if (node && node.eq(parentNode.node)) {
+      break;
+    }
+
+    if (i > 1 && $pos.before(i) !== $pos.before(i - 1) + 1) {
+      return false;
+    }
+  }
+
+  return true;
+};
+export const isSelectionAtEndOfNode = ($pos, parentNode) => {
+  if (!parentNode) {
+    return false;
+  }
+
+  for (let i = $pos.depth + 1; i > 0; i--) {
+    const node = $pos.node(i);
+
+    if (node && node.eq(parentNode.node)) {
+      break;
+    }
+
+    if (i > 1 && $pos.after(i) !== $pos.after(i - 1) - 1) {
+      return false;
+    }
+  }
+
+  return true;
+};

package/dist/es2019/styles/index.js

@@ -18,4 +18,6 @@ export { dateSharedStyle, DateSharedCssClassName } from './shared/date';
 export { tasksAndDecisionsStyles, TaskDecisionSharedCssClassName } from './shared/task-decision';
 export { StatusSharedCssClassName } from './shared/status';
 export { smartCardSharedStyles, SmartCardSharedCssClassName } from './shared/smart-card';
-export { CodeBlockSharedCssClassName, codeBlockSharedStyles } from './shared/code-block';
+export { CodeBlockSharedCssClassName, codeBlockSharedStyles } from './shared/code-block';
+export { LAYOUT_SECTION_MARGIN, LAYOUT_COLUMN_PADDING } from './shared/layout';
+export { EXTENSION_PADDING, BODIED_EXT_PADDING } from './shared/extension';

package/dist/es2019/styles/shared/extension.js

@@ -0,0 +1,3 @@
+import { gridSize } from '@atlaskit/theme/constants';
+export const EXTENSION_PADDING = gridSize();
+export const BODIED_EXT_PADDING = EXTENSION_PADDING * 2;

package/dist/es2019/styles/shared/layout.js

@@ -0,0 +1,3 @@
+import { gridSize } from '@atlaskit/theme/constants';
+export const LAYOUT_SECTION_MARGIN = gridSize();
+export const LAYOUT_COLUMN_PADDING = gridSize() * 1.5;

package/dist/es2019/styles/shared/table.js

@@ -28,7 +28,9 @@ export const TableSharedCssClassName = {
   TABLE_STICKY_SENTINEL_BOTTOM: `${tablePrefixSelector}-sticky-sentinel-bottom`,
   TABLE_CELL_NODEVIEW_CONTENT_DOM: tableCellContentDomSelector,
   TABLE_CELL_WRAPPER: tableCellSelector,
-  TABLE_HEADER_CELL_WRAPPER: tableHeaderSelector
+  TABLE_HEADER_CELL_WRAPPER: tableHeaderSelector,
+  TABLE_ROW_CONTROLS_WRAPPER: `${tablePrefixSelector}-row-controls-wrapper`,
+  TABLE_COLUMN_CONTROLS_DECORATIONS: `${tablePrefixSelector}-column-controls-decoration`
 };
 
 const tableSharedStyle = props => css`

package/dist/es2019/transforms/expand.js

@@ -0,0 +1,36 @@
+import { Fragment, Slice } from 'prosemirror-model';
+import { findParentNodeOfType, findSelectedNodeOfType } from 'prosemirror-utils';
+import { mapChildren } from '../utils/slice';
+export const findExpand = (state, selection) => {
+  const {
+    expand,
+    nestedExpand
+  } = state.schema.nodes;
+  return findSelectedNodeOfType([expand, nestedExpand])(selection || state.selection) || findParentNodeOfType([expand, nestedExpand])(selection || state.selection);
+}; // If the top level is a single expand, and the expand is not
+// a part of copied content, then return unwrap contents.
+// This is needed for handling content copied from expand.
+// https://product-fabric.atlassian.net/browse/ED-9146
+
+export const transformSliceToRemoveOpenExpand = (slice, schema) => {
+  if (slice.openStart > 1 && slice.openEnd > 1 && slice.content.childCount === 1 && slice.content.firstChild && slice.content.firstChild.type === schema.nodes.expand) {
+    return new Slice(slice.content.firstChild.content, slice.openStart - 1, slice.openEnd - 1);
+  }
+
+  return slice;
+};
+export const transformSliceNestedExpandToExpand = (slice, schema) => {
+  const {
+    expand,
+    nestedExpand
+  } = schema.nodes;
+  const children = [];
+  mapChildren(slice.content, node => {
+    if (node.type === nestedExpand) {
+      children.push(expand.createChecked(node.attrs, node.content, node.marks));
+    } else {
+      children.push(node);
+    }
+  });
+  return new Slice(Fragment.fromArray(children), slice.openStart, slice.openEnd);
+};

package/dist/es2019/transforms/extension.js

@@ -0,0 +1,26 @@
+import { Slice } from 'prosemirror-model';
+import { mapFragment } from '../utils/slice';
+/**
+ * Lift content out of "open" top-level bodiedExtensions.
+ * Will not work if bodiedExtensions are nested, or when bodiedExtensions are not in the top level
+ */
+
+export const transformSliceToRemoveOpenBodiedExtension = (slice, schema) => {
+  const {
+    bodiedExtension
+  } = schema.nodes;
+  const fragment = mapFragment(slice.content, (node, parent, index) => {
+    if (node.type === bodiedExtension && !parent) {
+      const currentNodeIsAtStartAndIsOpen = slice.openStart && index === 0;
+      const currentNodeIsAtEndAndIsOpen = slice.openEnd && index + 1 === slice.content.childCount;
+
+      if (currentNodeIsAtStartAndIsOpen || currentNodeIsAtEndAndIsOpen) {
+        return node.content;
+      }
+    }
+
+    return node;
+  }); // If the first/last child has changed - then we know we've removed a bodied extension & to decrement the open depth
+
+  return new Slice(fragment, fragment.firstChild && fragment.firstChild.type !== slice.content.firstChild.type ? slice.openStart - 1 : slice.openStart, fragment.lastChild && fragment.lastChild.type !== slice.content.lastChild.type ? slice.openEnd - 1 : slice.openEnd);
+};

package/dist/es2019/transforms/index.js

@@ -0,0 +1,3 @@
+export { unwrapContentFromLayout, removeLayoutFromFirstChild, removeLayoutFromLastChild, transformSliceToRemoveOpenLayoutNodes } from './layout';
+export { findExpand, transformSliceToRemoveOpenExpand, transformSliceNestedExpandToExpand } from './expand';
+export { transformSliceToRemoveOpenBodiedExtension } from './extension';

package/dist/es2019/transforms/layout.js

@@ -0,0 +1,54 @@
+import { Fragment, Slice } from 'prosemirror-model';
+import { flatmap, mapFragment } from '../utils/slice';
+
+const isLayoutNode = node => node.type === node.type.schema.nodes.layoutSection || node.type === node.type.schema.nodes.layoutColumn;
+
+export function unwrapContentFromLayout(maybeLayoutSection) {
+  const fragment = mapFragment(Fragment.from(maybeLayoutSection), node => {
+    return isLayoutNode(node) ? node.content : node;
+  });
+  const nodes = [];
+  fragment.forEach(i => nodes.push(i));
+  return nodes;
+}
+export function removeLayoutFromFirstChild(node, i) {
+  return i === 0 ? unwrapContentFromLayout(node) : node;
+}
+export function removeLayoutFromLastChild(node, i, fragment) {
+  return i === fragment.childCount - 1 ? unwrapContentFromLayout(node) : node;
+}
+/**
+ * When we have a slice that cuts across a layoutSection/layoutColumn
+ * we can end up with unexpected behaviour on paste/drop where a user
+ * is able to add columns to a layoutSection. By 'lifting' any content
+ * inside an 'open' layoutSection/layoutColumn to the top level, we
+ * can ensure prevent this.
+ *
+ * We only care about slices with non-zero openStart / openEnd's here
+ * as we're totally fine for people to copy/paste a full layoutSection
+ */
+
+export function transformSliceToRemoveOpenLayoutNodes(slice, schema) {
+  // Case 1: A slice entirely within a single layoutSection
+  if (slice.openStart && slice.openEnd && slice.content.childCount === 1) {
+    const maybeLayoutSection = slice.content.firstChild;
+
+    if (maybeLayoutSection.type === schema.nodes.layoutSection) {
+      return new Slice(flatmap(slice.content, removeLayoutFromFirstChild), // '-2' here because we've removed the layoutSection/layoutColumn; reducing the open depth.
+      slice.openStart - 2, slice.openEnd - 2);
+    }
+  } // Case 2: A slice starting inside a layoutSection and finishing outside
+
+
+  if (slice.openStart && slice.content.firstChild.type === schema.nodes.layoutSection) {
+    slice = new Slice(flatmap(slice.content, removeLayoutFromFirstChild), slice.openStart - 2, slice.openEnd);
+  } // Case 3: A slice starting outside a layoutSection and finishing inside
+
+
+  if (slice.openEnd && slice.content.lastChild.type === schema.nodes.layoutSection) {
+    slice = new Slice(flatmap(slice.content, removeLayoutFromLastChild), slice.openStart, slice.openEnd - 2);
+  } // Case 2 & 3 also handles a slice starting in one layoutSection & finishing in a different layoutSection
+
+
+  return slice;
+}

package/dist/es2019/types/command.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/types/context-panel.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/types/editor-actions.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/types/editor-appearance.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/types/editor-container-width.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/types/editor-plugin.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/types/editor-react-context.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/types/empty-state-handler.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/types/feature-flags.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/types/floating-toolbar.js

@@ -0,0 +1 @@
+export {};