@atlaskit/renderer 137.1.6 → 137.1.7

package/dist/es2019/ui/Expand.js

@@ -13,8 +13,7 @@ import { akEditorLineHeight, akEditorSwoopCubicBezier, akLayoutGutterOffset } fr
 import ChevronRightIcon from '@atlaskit/icon/core/chevron-right';
 import Tooltip from '@atlaskit/tooltip/Tooltip';
 import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
-import { fg } from '@atlaskit/platform-feature-flags/fg';
-import { getExpandSearchText } from './utils/expand-search-text';
+import { ExpandBodyProvider, useExpandBody } from './expand-body';
 import _uniqueId from 'lodash/uniqueId';
 import { injectIntl } from 'react-intl';
 import { MODE, PLATFORM } from '../analytics/events';
@@ -139,12 +138,18 @@ const contentContainerStylesNotExpanded = css({
 // hidden="until-found" attribute on the outer container to hide content.
 // We remove height:0/overflow:hidden/clip from the inner wrapper so the
 // browser can actually search through the content.
+//
+// `user-select: none` must NOT be set here, unlike the variant above. WebKit scrolls to a
+// find-in-page match by selecting it, so unselectable text is matched but never revealed: the
+// reader is told there is a hit, the `hidden` attribute stays put, and the expand never opens.
+// Chrome does not need a selection, so it hid the problem. Nothing is lost by leaving it out —
+// content-visibility:hidden already makes a skipped subtree unselectable. It is only needed in the
+// other variant, where the content is merely clipped and would otherwise be selectable.
 const contentContainerStylesNotExpandedBrowserFind = css({
   // eslint-disable-next-line @atlaskit/ui-styling-standard/no-nested-selectors
   '.expand-content-wrapper, .nestedExpand-content-wrapper': {
     width: '100%',
-    display: 'block',
-    userSelect: 'none'
+    display: 'block'
   }
 });
 const clearNextSiblingMarginTopStyle = css({
@@ -215,15 +220,15 @@ function Expand({
   rendererContentMode,
   node
 }) {
+  const ancestorBody = useExpandBody();
   const [expanded, setExpanded] = useState(false);
   const [focused, setFocused] = useState(false);
   /**
-   * PGXT-9021: latches on the first open so the body stays mounted once rendered, including after
-   * the expand is collapsed again. Remounting it would re-run every macro and Forge data fetch
-   * inside on each reopen, which is both slower and visibly reloads content the reader has already
-   * seen. The saving this gate exists for is at initial load, where the body has never been opened,
-   * so nothing is given up by keeping it after that. Never set on the server, so the server and the
-   * client's first render agree and hydration cannot desync.
+   * PGXT-9021: once opened, the body stays rendered even if the reader closes the expand again.
+   * Throwing it away would re-run every macro and Forge fetch inside it on the next open, which is
+   * slower and visibly reloads content the reader has already seen. We only wanted to save work on
+   * the first page load, and by now that has happened. Starts false on both the server and the
+   * client, so hydration cannot disagree.
    */
   const [hasBeenExpanded, setHasBeenExpanded] = useState(false);
   const isMobile = false;
@@ -241,15 +246,21 @@ function Expand({
     setExpanded(true);
     setHasBeenExpanded(true);
   }, []);
+  // The browser found the text inside this expand. Opening this one is not enough: if it sits
+  // inside other expands, those have to open too or the reader still cannot see it. Each expand
+  // asks the one above it, so a single match opens the whole chain and nothing else.
+  const openWithAncestors = useCallback(() => {
+    openBody();
+    ancestorBody === null || ancestorBody === void 0 ? void 0 : ancestorBody.openWithAncestors();
+  }, [ancestorBody, openBody]);
 
-  // Feature-detect hidden="until-found" support via the beforematch event.
-  // Chrome 102+ and Firefox 130+ support it; Safari does not yet.
-  // In unsupported browsers, setting hidden="until-found" is treated as boolean hidden
-  // (display:none), which would break the expand entirely.
-  // Initialised as false and set in useEffect to avoid SSR/client hydration mismatch —
-  // useMemo would return true on the client's first render in supported browsers,
-  // differing from the server snapshot which always produces false.
-  const [supportsHiddenUntilFound, setSupportsHiddenUntilFound] = useState(false);
+  // Feature-detect hidden="until-found" support via the beforematch event. Chrome 102+,
+  // Firefox 139+ and Safari 26.2+ all have it; in a browser without it, hidden="until-found" is
+  // treated as plain boolean hidden (display:none), which would break the expand entirely.
+  // Starts as `undefined`, meaning "we do not know yet", and is only answered in an effect. We
+  // cannot check during render: the server has no browser to check, so it would say no there and
+  // yes on the client, and hydration would disagree.
+  const [supportsHiddenUntilFound, setSupportsHiddenUntilFound] = useState(undefined);
   useEffect(() => {
     const doc = getDocument();
     setSupportsHiddenUntilFound(doc !== null && doc !== void 0 && doc.body ? 'onbeforematch' in doc.body : false);
@@ -263,9 +274,9 @@ function Expand({
   // because visibility:hidden blocks browser find. On expanded, we restore visibility to visible.
   //
   // Only applied when the browser supports hidden="until-found" (detected via onbeforematch).
-  // In unsupported browsers (Safari), we skip this entirely and fall back to the normal
-  // CSS hiding (visibility:hidden + height:0), which doesn't support find-in-page but
-  // still works correctly for expand/collapse.
+  // Without it we skip this entirely and fall back to the normal CSS hiding
+  // (visibility:hidden + height:0), which doesn't support find-in-page but still works
+  // correctly for expand/collapse.
   useEffect(() => {
     const contentContainer = contentContainerRef.current;
     const contentWrapper = contentWrapperRef.current;
@@ -274,6 +285,13 @@ function Expand({
     }
     if (supportsHiddenUntilFound && isExperimentEnabled('platform_editor_close_expand_find') && !expanded) {
       contentWrapper.setAttribute('hidden', 'until-found');
+      // Products ship a CSS reset with `[hidden] { display: none }` — Confluence does. That is an
+      // author rule, so it beats the UA stylesheet's
+      // `[hidden="until-found"] { content-visibility: hidden }` and takes the content out of the
+      // page altogether, where find cannot reach it. Setting display next to the attribute keeps
+      // the two together, rather than relying on a class selector elsewhere out-weighing a reset
+      // we do not own.
+      contentWrapper.style.display = 'block';
       // Override the CSS visibility:hidden from contentContainerStyles — hidden="until-found"
       // now handles hiding via content-visibility:hidden, which allows browser find to index
       // the content. We use 'visible' (not '') because '' only clears the inline style but
@@ -282,6 +300,7 @@ function Expand({
       contentWrapper.style.visibility = 'visible';
     } else {
       contentWrapper.removeAttribute('hidden');
+      contentWrapper.style.display = '';
       contentContainer === null || contentContainer === void 0 ? void 0 : contentContainer.style.removeProperty('visibility');
       contentWrapper.style.visibility = '';
     }
@@ -293,20 +312,26 @@ function Expand({
     const contentWrapper = contentWrapperRef.current;
     const unbindWrapperBeforeMatch = contentWrapper && supportsHiddenUntilFound ? bind(contentWrapper, {
       type: 'beforematch',
-      listener: openBody
+      listener: openWithAncestors
     }) : undefined;
     return () => {
       unbindWrapperBeforeMatch === null || unbindWrapperBeforeMatch === void 0 ? void 0 : unbindWrapperBeforeMatch();
     };
-  }, [expanded, openBody, supportsHiddenUntilFound]);
+  }, [expanded, openWithAncestors, supportsHiddenUntilFound]);
 
-  // Until the expand is first opened, stand in a plain-text mirror of the body so
-  // hidden="until-found" keeps the content findable by browser find without mounting the real
-  // subtree. The beforematch listener above expands before the browser scrolls to its match.
-  // Computed lazily: a nested expand is not mounted until its ancestor opens, so its mirror is
-  // never built on initial load.
-  const searchText = useMemo(() => node && fg('hot-121622_lazy_load_expand_content') ? getExpandSearchText(node) : undefined, [node]);
-  const expandContent = searchText && !expanded && !hasBeenExpanded ? jsx("span", null, searchText) : children;
+  // While this is false, the blocks of the body show their text instead of rendering. It is true
+  // when:
+  // - the expand is open, or has been opened before, so the reader wants to see the content;
+  // - no node was given, so this expand never opted into lazy loading;
+  // - the experiment is off;
+  // - the browser has no hidden="until-found", so the text would not be findable and standing it in
+  //   would gain nothing. While we still do not know, we assume the browser has it — assuming the
+  //   opposite would render the whole body on the first paint and lose the saving entirely.
+  const revealed = expanded || hasBeenExpanded || !node || supportsHiddenUntilFound === false || !isExperimentEnabled('platform_editor_defer_collapsed_expand_body');
+  const expandBody = useMemo(() => ({
+    revealed,
+    openWithAncestors
+  }), [revealed, openWithAncestors]);
   return jsx(Container, {
     "data-testid": `expand-container-${nodeType}-${id}`,
     "data-node-type": nodeType,
@@ -371,7 +396,9 @@ function Expand({
     ref: contentWrapperRef
   }, jsx(WidthProvider, null, jsx("div", {
     css: clearNextSiblingMarginTopStyle
-  }), expandContent))));
+  }), jsx(ExpandBodyProvider, {
+    value: expandBody
+  }, children)))));
 }
 
 // eslint-disable-next-line @typescript-eslint/ban-types

package/dist/es2019/ui/Renderer/index.js

@@ -60,7 +60,7 @@ export const DEGRADED_SEVERITY_THRESHOLD = 3000;
 const TABLE_INFO_TIMEOUT = 10000;
 const RENDER_EVENT_SAMPLE_RATE = 0.1;
 const packageName = "@atlaskit/renderer";
-const packageVersion = "137.1.5";
+const packageVersion = "137.1.6";
 const setAsQueryContainerStyles = css({
   containerName: 'ak-renderer-wrapper',
   containerType: 'inline-size'

package/dist/es2019/ui/expand-body.js

@@ -0,0 +1,107 @@
+import React, { createContext, isValidElement, useContext } from 'react';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
+import { BLOCK_SEPARATOR, getBlockSearchText, holdsRevealableContent, isExpandNode } from './utils/expand-search-text';
+const ExpandBodyContext = /*#__PURE__*/createContext(null);
+export const ExpandBodyProvider = ExpandBodyContext.Provider;
+export const useExpandBody = () => useContext(ExpandBodyContext);
+/**
+ * One or more neighbouring blocks of an expand's body. Shows their text until the expand is
+ * opened, then renders them. Falls back to rendering if there is no text, or if there is no
+ * expand above it.
+ *
+ * The text is rendered as-is, with no element around it. Nothing reads it but browser find,
+ * which only needs the characters to be in the DOM.
+ */
+export const ExpandBodyBlock = ({
+  children,
+  searchText
+}) => {
+  const body = useExpandBody();
+  if (searchText === undefined || body === null || body.revealed) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, children);
+  }
+  return searchText;
+};
+
+/**
+ * Called for every node the serializer renders. If the node is a block of an expand's body,
+ * wraps it so it can show its text instead of rendering while that expand is collapsed.
+ * Everything else is returned untouched.
+ *
+ * A block holding an expand of its own is also returned untouched, so a table with a nested
+ * expand in it, or an extension holding stashed ADF, renders even while collapsed. That
+ * expand needs an element of its own, because the element browser find reveals is the only
+ * way we learn the match was inside it rather than higher up. We give up the saving on those
+ * blocks so the reader searches once instead of once per level.
+ *
+ * `ancestors` is the node's ancestor chain, nearest last.
+ */
+export const withExpandBodyBlock = (node, ancestors, index, serialized) => {
+  const parent = ancestors[ancestors.length - 1];
+  if (!parent || !isExpandNode(parent)) {
+    return serialized;
+  }
+  if (!isExperimentEnabled('platform_editor_defer_collapsed_expand_body') || holdsRevealableContent(node)) {
+    return serialized;
+  }
+  const searchText = getBlockSearchText(node);
+  if (searchText === undefined) {
+    return serialized;
+  }
+  return /*#__PURE__*/React.createElement(ExpandBodyBlock, {
+    key: `expand-body-block-${index}`,
+    searchText: searchText
+  }, serialized);
+};
+
+/** Whatever the serializer produced for one child: an element, a string, an array of either. */
+
+const searchTextOf = child => /*#__PURE__*/isValidElement(child) && child.type === ExpandBodyBlock ? child.props.searchText : undefined;
+
+/**
+ * Joins neighbouring blocks that are showing text into one, so a run of them is a single string in
+ * the DOM rather than one per block. A body of twenty paragraphs becomes one text node instead of
+ * twenty.
+ *
+ * A block that is being rendered — a nested expand, say — ends the run, because the text either
+ * side of it has to stay either side of it.
+ */
+export const mergeExpandBodyText = children => {
+  // Called for every fragment in the document, and only an expand's body has anything to merge, so
+  // leave the array alone unless two neighbours are actually showing text.
+  const hasRun = children.some((child, index) => index > 0 && searchTextOf(child) !== undefined && searchTextOf(children[index - 1]) !== undefined);
+  if (!hasRun) {
+    return children;
+  }
+  const merged = [];
+  let run = [];
+  const endRun = () => {
+    if (run.length === 0) {
+      return;
+    }
+    if (run.length === 1) {
+      merged.push(run[0]);
+    } else {
+      var _key;
+      const text = run.map(searchTextOf).filter(Boolean).join(BLOCK_SEPARATOR);
+      // The blocks themselves, not the wrappers around them: nesting the wrappers would show
+      // each block's text again inside the joined run.
+      const blocks = run.map(child => child.props.children);
+      merged.push( /*#__PURE__*/React.createElement(ExpandBodyBlock, {
+        key: (_key = run[0].key) !== null && _key !== void 0 ? _key : undefined,
+        searchText: text
+      }, blocks));
+    }
+    run = [];
+  };
+  children.forEach(child => {
+    if (searchTextOf(child) === undefined) {
+      endRun();
+      merged.push(child);
+      return;
+    }
+    run.push(child);
+  });
+  endRun();
+  return merged;
+};

package/dist/es2019/ui/utils/expand-search-text.js

@@ -6,20 +6,25 @@ import { findChildrenByMark } from '@atlaskit/editor-prosemirror/utils';
  */
 
 /** Separates text from adjacent blocks so phrases cannot fuse across block boundaries. */
-const BLOCK_SEPARATOR = ' ';
+export const BLOCK_SEPARATOR = ' ';
 const asText = value => typeof value === 'string' ? value : '';
+const nestedContentOf = attrs => {
+  var _attrs$parameters;
+  return attrs === null || attrs === void 0 ? void 0 : (_attrs$parameters = attrs.parameters) === null || _attrs$parameters === void 0 ? void 0 : _attrs$parameters.nestedContent;
+};
+export const isExpandNode = node => node.type.name === 'expand' || node.type.name === 'nestedExpand';
 
 /**
- * Extracts text from raw ADF JSON.
+ * Reads the text out of raw ADF JSON.
  *
- * Needed because some extensions stash a whole ADF subtree in `attrs.parameters.nestedContent`
- * instead of in their node content — Confluence does this when it coerces nesting the schema
- * cannot represent (an expand more than two collapsible layers deep, say). Such a node is a
- * ProseMirror leaf, so the model walk cannot see the subtree even though it renders on the page
- * via a nested renderer. Recurses, because nestedContent routinely holds further nested content.
+ * Some extensions keep a whole ADF subtree in `attrs.parameters.nestedContent` rather than in their
+ * node content. Confluence does this when the authored nesting is deeper than the schema allows —
+ * an expand more than two collapsible layers deep, for example. To ProseMirror the extension is a
+ * leaf, so walking the node tree never sees that subtree, even though a nested renderer puts it on
+ * the page. Recurses, because stashed content often stashes more content of its own.
  */
 const adfEntityText = entity => {
-  var _entity$attrs, _entity$attrs$paramet, _entity$content;
+  var _entity$content;
   if (!entity) {
     return '';
   }
@@ -27,57 +32,88 @@ const adfEntityText = entity => {
   if (entity.type === 'text') {
     parts.push(asText(entity.text));
   }
-  const nestedContent = (_entity$attrs = entity.attrs) === null || _entity$attrs === void 0 ? void 0 : (_entity$attrs$paramet = _entity$attrs.parameters) === null || _entity$attrs$paramet === void 0 ? void 0 : _entity$attrs$paramet.nestedContent;
+  const nestedContent = nestedContentOf(entity.attrs);
   if (nestedContent) {
     // Prefer the real subtree over `attrs.text`, which is only a placeholder label for it.
     parts.push(adfEntityText(nestedContent));
   } else {
-    var _entity$attrs2;
-    parts.push(asText((_entity$attrs2 = entity.attrs) === null || _entity$attrs2 === void 0 ? void 0 : _entity$attrs2.text));
+    var _entity$attrs;
+    parts.push(asText((_entity$attrs = entity.attrs) === null || _entity$attrs === void 0 ? void 0 : _entity$attrs.text));
   }
   (_entity$content = entity.content) === null || _entity$content === void 0 ? void 0 : _entity$content.forEach(child => parts.push(adfEntityText(child)));
   return parts.filter(Boolean).join(BLOCK_SEPARATOR);
 };
 
 /**
- * `textBetween` drops every non-text leaf unless the node spec declares `leafText`, and no ADF
- * node does. Leaves carry their visible text in attrs, so recover it here.
+ * `textBetween` skips every leaf node unless its spec declares `leafText`, and no ADF node
+ * does — so mentions, emoji, dates and statuses would all be lost. They keep their visible
+ * text in attrs, so read it from there.
  */
 const leafText = leaf => {
-  var _leaf$attrs, _leaf$attrs$parameter, _leaf$attrs2;
-  const nestedContent = (_leaf$attrs = leaf.attrs) === null || _leaf$attrs === void 0 ? void 0 : (_leaf$attrs$parameter = _leaf$attrs.parameters) === null || _leaf$attrs$parameter === void 0 ? void 0 : _leaf$attrs$parameter.nestedContent;
+  var _leaf$attrs;
+  const nestedContent = nestedContentOf(leaf.attrs);
   if (nestedContent) {
     return adfEntityText(nestedContent);
   }
-  return asText((_leaf$attrs2 = leaf.attrs) === null || _leaf$attrs2 === void 0 ? void 0 : _leaf$attrs2.text);
+  return asText((_leaf$attrs = leaf.attrs) === null || _leaf$attrs === void 0 ? void 0 : _leaf$attrs.text);
+};
+const isRevealable = node => isExpandNode(node) || Boolean(nestedContentOf(node.attrs));
+const revealableCache = new WeakMap();
+
+/**
+ * Whether this block holds something that can be opened on its own: an expand, or an extension
+ * holding stashed ADF that a nested renderer will mount expands from.
+ *
+ * Those need a real element even while the expand around them is collapsed. The element is how we
+ * know find matched inside them rather than higher up: the beforematch event says nothing about
+ * where the match was, so the element the browser chose to reveal is the only clue.
+ */
+export const holdsRevealableContent = node => {
+  const cached = revealableCache.get(node);
+  if (cached !== undefined) {
+    return cached;
+  }
+  let found = isRevealable(node);
+  if (!found) {
+    node.descendants(descendant => {
+      if (found) {
+        return false;
+      }
+      found = isRevealable(descendant);
+      return !found;
+    });
+  }
+  revealableCache.set(node, found);
+  return found;
 };
 const hasInlineComment = node => findChildrenByMark(node, node.type.schema.marks.annotation, true).some(annotation => annotation.node.marks.some(mark => mark.attrs.annotationType === 'inlineComment'));
 
-/** `null` is a cached "no mirror for this node", as distinct from `undefined` for a cache miss. */
+/** `null` is a cached "no search text for this node", as distinct from `undefined` for a miss. */
 const searchTextCache = new WeakMap();
 
 /**
- * Plain-text mirror of an expand's body, rendered in its place while collapsed so browser
- * find-in-page can still reach the content.
+ * The text shown in place of one block of a collapsed expand's body, so browser find can still
+ * reach the content without the block being rendered.
  *
- * Cached on the node. ProseMirror nodes are immutable and `render-document` memoises
- * `nodeFromJSON`, so the same node instance is reused across renders — including across the
- * serializer rebuilds that invalidate the module-level `memoizeOne` caches.
+ * Cached on the node. ProseMirror nodes never change, and the serializer reuses the same instances
+ * across renders, so the text only has to be worked out once per block.
  *
- * @returns the mirror text, or `undefined` if this expand must keep its body rendered.
+ * @returns the text, or `undefined` if this block has to be rendered instead.
  */
-export const getExpandSearchText = node => {
+export const getBlockSearchText = node => {
   var _cached;
   let cached = searchTextCache.get(node);
   if (cached === undefined) {
     cached = hasInlineComment(node) ?
-    // Withhold the mirror, which makes Expand keep rendering `children`. Comment
-    // navigation walks the DOM to find the annotated node and scrolls it into view, so
-    // the annotation has to exist as a real element — a flat text mirror carries no
-    // annotation marks and cannot stand in for it. Without this, stepping through
-    // comments with the arrow keys silently fails to reach any comment inside a
-    // collapsed expand. Costs the lazy-load win for these expands, deliberately.
-    null : node.textBetween(0, node.content.size, BLOCK_SEPARATOR, leafText);
+    // No text, which makes the block render instead. Comment navigation looks through the DOM
+    // for the commented text and scrolls to it, so that text has to be a real element —
+    // plain text carries no comment marks and cannot stand in for it. Without this, the
+    // arrow keys silently skip every comment inside a collapsed expand. We give up the
+    // saving for this block on purpose.
+    null :
+    // A leaf block is not inside its own range, so `textBetween` would return nothing and its
+    // text would be lost — a macro sitting straight in an expand body, for instance.
+    node.isLeaf ? leafText(node) : node.textBetween(0, node.content.size, BLOCK_SEPARATOR, leafText);
     searchTextCache.set(node, cached);
   }
   return (_cached = cached) !== null && _cached !== void 0 ? _cached : undefined;

package/dist/esm/react/index.js

@@ -11,6 +11,7 @@ import React from 'react';
 import { MarkType } from '@atlaskit/editor-prosemirror/model';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
+import { mergeExpandBodyText, withExpandBodyBlock } from '../ui/expand-body';
 import { Doc, DocWithSelectAllTrap, isTextNode, isTextWrapper, mergeTextNodes, toReact } from './nodes';
 import TextWrapperComponent from './nodes/text-wrapper';
 import { isNestedHeaderLinksEnabled } from './utils/links';
@@ -92,12 +93,13 @@ var ReactSerializer = /*#__PURE__*/function () {
       var shouldSkipLinkMark = function shouldSkipLinkMark(mark) {
         return _this.allowMediaLinking !== true && isMedia && mark.type.name === 'link';
       };
-      return marks.reduceRight(function (content, mark) {
+      var serialized = marks.reduceRight(function (content, mark) {
         if (shouldSkipLinkMark(mark) || shouldSkipBorderMark(mark)) {
           return content;
         }
         return _this.renderMark(markToReact(mark), _this.withMediaMarkProps(node, mark, _this.getMarkProps(mark, [], node)), "".concat(mark.type.name, "-").concat(index), content);
       }, serializedContent);
+      return withExpandBodyBlock(node, currentPath, index, serialized);
     });
     // Ignored via go/ees005
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -276,7 +278,7 @@ var ReactSerializer = /*#__PURE__*/function () {
         case 'expand':
           return this.getExpandProps(node, path);
         case 'nestedExpand':
-          if (fg('hot-121622_lazy_load_expand_content')) {
+          if (isExperimentEnabled('platform_editor_defer_collapsed_expand_body')) {
             return this.getExpandProps(node, path);
           }
           return this.getProps(node, path);
@@ -308,7 +310,7 @@ var ReactSerializer = /*#__PURE__*/function () {
       if (key === 'root-0') {
         this.resetState();
       }
-      return this.renderNode(target, props, key, this.getChildNodes(fragment).map(function (node, index) {
+      return this.renderNode(target, props, key, mergeExpandBodyText(this.getChildNodes(fragment).map(function (node, index) {
         if (isTextWrapper(node)) {
           return _this2.serializeTextWrapper(node.content, {
             index: index,
@@ -319,7 +321,7 @@ var ReactSerializer = /*#__PURE__*/function () {
           index: index,
           parentInfo: parentInfo
         });
-      }));
+      })));
     }
   }, {
     key: "serializeTextWrapper",
@@ -729,11 +731,8 @@ var ReactSerializer = /*#__PURE__*/function () {
     value: function getExpandProps(node) {
       var _this7 = this;
       var _path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-      // Expand receives the node rather than a precomputed string so it can derive the collapsed
-      // text mirror only when it actually renders one — a nested expand is not mounted until its
-      // ancestor opens — and so that derivation can reach content the model walk cannot, such as
-      // the ADF stashed in a coerced extension's `parameters.nestedContent`. Expand owns the
-      // feature gate check.
+      // Expand is given the node so it can tell whether it opted into lazy body loading at all. The
+      // text each block shows is attached to the block itself, by `withExpandBodyBlock`.
       if (!isNestedHeaderLinksEnabled(this.allowHeadingAnchorLinks)) {
         return _objectSpread(_objectSpread({}, this.getProps(node)), {}, {
           node: node