@globalpayments/vega 2.92.0 → 2.94.0

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/dto/blockquote-annotation.js

@@ -0,0 +1,76 @@
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { camelToDashCase } from '../../../../../utils/string';
+export var RTEBlockquoteExtensionAnnotationTypeEnum;
+(function (RTEBlockquoteExtensionAnnotationTypeEnum) {
+  RTEBlockquoteExtensionAnnotationTypeEnum["BLOCKQUOTE"] = "BLOCKQUOTE";
+})(RTEBlockquoteExtensionAnnotationTypeEnum || (RTEBlockquoteExtensionAnnotationTypeEnum = {}));
+/**
+ * CSS class applied to `<blockquote>` elements rendered inside the editor.
+ */
+export const BLOCKQUOTE_CLASS_NAME = 'v-rte-blockquote';
+/**
+ * Default visual styles for the `<blockquote>` element in the RTE.
+ */
+export const BLOCKQUOTE_DEFAULT_STYLES = {
+  overflow: 'hidden',
+  marginInline: '0',
+  paddingInline: '24px',
+  borderInlineStart: 'solid 5px hsl(0, 0%, 80%)',
+};
+/**
+ * Blockquote annotation.
+ */
+export class BlockquoteAnnotation extends BlockAnnotation {
+  constructor() {
+    super(...arguments);
+    this.type = RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE;
+  }
+  /**
+   * Generate the map item for the annotation.
+   *
+   * @returns {[RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE, BlockquoteAnnotation]} Map item.
+   */
+  static from() {
+    return [RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE, new BlockquoteAnnotation()];
+  }
+  /**
+   * Get the default CSS rule for the blockquote element.
+   *
+   * @returns {string} The default CSS rule.
+   */
+  static getDefaultCssText() {
+    const declarations = Object.entries(BLOCKQUOTE_DEFAULT_STYLES)
+      .map(([key, value]) => `\t${camelToDashCase(key)}: ${value};`)
+      .join('\n');
+    return `.${BLOCKQUOTE_CLASS_NAME} {\n${declarations}\n}`;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    // Blockquote identity is captured by the block type; nothing to serialize.
+    return null;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone() {
+    return new BlockquoteAnnotation();
+  }
+  /**
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return BLOCKQUOTE_CLASS_NAME;
+  }
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return BLOCKQUOTE_DEFAULT_STYLES;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/dto/rte-blockquote-block.js

@@ -0,0 +1,70 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { BlockquoteAnnotation } from './blockquote-annotation';
+/**
+ * DTO representing a `<blockquote>` block.
+ */
+export class RTEBlockquoteBlock extends RTEBlock {
+  constructor(id, options) {
+    super(id);
+    this.dtoName = RTEBlockquoteBlock.dtoName;
+    this.type = 'blockquote';
+    this.children = [];
+    const { autoMatchFormat = true } = options !== null && options !== void 0 ? options : {};
+    if (autoMatchFormat) {
+      this.annotationMap = new Map([BlockquoteAnnotation.from()]);
+    }
+  }
+  /**
+   * Convert a JSON block payload into an `RTEBlockquoteBlock` instance.
+   *
+   * @param {VegaRTEBlockquoteBlock} block - JSON payload.
+   * @param {VegaRTETransformOptions} [options] - Transform options.
+   * @returns {RTEBlockquoteBlock} The created blockquote block.
+   */
+  static from(block, options) {
+    const blockquote = new RTEBlockquoteBlock(block.id, options);
+    if (block.annotations) {
+      RTEBlock.convertAnnotationsToMap(blockquote.annotationMap, block.annotations);
+    }
+    blockquote.children = RTEBlock.generateBlockChildren(block.children, options, blockquote);
+    return blockquote;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    const cloned = new RTEBlockquoteBlock(this.id);
+    const clonedAsChildParent = cloned;
+    cloned.children = this.children.map((child) => child.clone(clonedAsChildParent));
+    cloned.annotationMap = this.cloneAnnotations();
+    cloned.parent = parent;
+    return cloned;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastNode() {
+    return this.children[this.children.length - 1].getLastNode();
+  }
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty() {
+    return this.children.length > 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  toHtml(options) {
+    const attrStr = this.generateAttributeString(options);
+    const inner = this.children.map((child) => child.toHtml(options)).join('');
+    return `<blockquote${attrStr}>${inner}</blockquote>`;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: 'blockquote', children: this.children.map((child) => child.toJSON()) });
+  }
+}
+RTEBlockquoteBlock.dtoName = 'RTEBlockquoteBlock';

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/element-to-dto-strategies/blockquote-to-blockquote-block-strategy.js

@@ -0,0 +1,53 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { ElementToDTOStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+import htmlElementToAnnotationGenerator from '../../../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
+import { RTEBlockquoteBlock } from '../dto/rte-blockquote-block';
+/**
+ * Claim every `<blockquote>` element encountered during HTML → DTO conversion
+ * and produce an {@link RTEBlockquoteBlock}.
+ *
+ * Nested `<blockquote>` elements are flattened to a single level in
+ * {@link appendChildBlocks}: any direct child that arrives as another
+ * `<blockquote>` is replaced by its own children, lifting them one level up.
+ */
+export class BlockquoteToBlockquoteBlockStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray, currentIndex) {
+    return elementsArray[currentIndex].tagName === 'BLOCKQUOTE' ? 1 : 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray, options) {
+    const element = elementsArray[0];
+    const annotations = htmlElementToAnnotationGenerator.generate(RTEBlockquoteBlock, element, options);
+    return RTEBlockquoteBlock.from({
+      id: generateUUID(),
+      type: 'blockquote',
+      annotations,
+      children: [],
+    }, options);
+  }
+  /**
+   * Flatten nested `<blockquote>` elements: any direct child that is itself
+   * an {@link RTEBlockquoteBlock} is replaced by its own children, lifting
+   * them one level up.
+   *
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock, childBlocks) {
+    const flattened = childBlocks.flatMap((child) => child instanceof RTEBlockquoteBlock ? child.children : [child]);
+    currentBlock.children = flattened.map((block) => {
+      block.parent = currentBlock;
+      return block;
+    });
+  }
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren() {
+    return true;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/filter-styles-strategies/blockquote-block/blockquote-filter-styles-strategy.js

@@ -0,0 +1,41 @@
+import { RTEFilterStylesStrategy, } from '../../../../dto/filter-styles-strategies/filter-styles-strategy.abstract';
+import { BLOCKQUOTE_DEFAULT_STYLES } from '../../dto/blockquote-annotation';
+/**
+ * Filter styles strategy for blockquote blocks.
+ * Strips default blockquote visual styles during output and refills them during input,
+ * ensuring source edit round-trips do not lose information.
+ */
+export class BlockquoteFilterStylesStrategy extends RTEFilterStylesStrategy {
+  constructor() {
+    super(...arguments);
+    this.stylesToBeFiltered = BLOCKQUOTE_DEFAULT_STYLES;
+    this.elementTagName = 'blockquote';
+  }
+  /**
+   * Checks if the given block dto class name corresponds to a blockquote block.
+   *
+   * @param {string} className The class name to check.
+   * @returns {boolean} True if the class name corresponds to a blockquote block, false otherwise.
+   */
+  static isBlockquoteBlock(className) {
+    return className === 'RTEBlockquoteBlock';
+  }
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance) {
+    return BlockquoteFilterStylesStrategy.isBlockquoteBlock(blockOrNodeInstance.dtoName);
+  }
+  /**
+   * @inheritDoc
+   */
+  canRefill(_blockOrNodeClassName, element) {
+    return element.tagName.toLowerCase() === this.elementTagName;
+  }
+  /**
+   * @inheritDoc
+   */
+  toCssText() {
+    return this.buildCssTextForStyles(this.elementTagName, this.classNameToBeAdded);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/renderers/blockquote-block-renderer.js

@@ -0,0 +1,21 @@
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { BlockquoteAnnotation } from '../dto/blockquote-annotation';
+/**
+ * Renderer for blockquote blocks in the rich text editor.
+ */
+export class RTEBlockquoteBlockRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(createElement, block, rteContext) {
+    var _a;
+    return createElement('blockquote', Object.assign({ key: block.id, class: block.getClasses(rteContext), style: block.getStyles(rteContext), ref: this.useRef(block) }, (_a = block.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.render()));
+  }
+  /**
+   * @inheritDoc
+   */
+  injectRTEScopeStyles() {
+    return BlockquoteAnnotation.getDefaultCssText();
+  }
+}
+export default new RTEBlockquoteBlockRenderer();

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/renderers/blockquote-toolbar-button-renderer.js

@@ -0,0 +1,260 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { VegaInternalIconManager } from '../../../../../helpers/icon/internal-icon-manager';
+import { ActionHandleStrategyRegistry } from '../../../dto/action-handle-strategies/action-handle-strategy-registry';
+import { RTETextBlock } from '../../../dto/blocks/text-block';
+import { VegaRTEContent } from '../../../dto/content-state';
+import { VegaRTEToolbarButtonRenderer } from '../../base-toolbar-button-renderer';
+import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
+import { UpdateCursorPositionAction } from '../../../dto/actions/update-cursor-position-action';
+import { RemoveBlockquoteAction } from '../actions/remove-blockquote-action';
+import { TRANSFORM_TO_BLOCKQUOTE, TransformToBlockquoteAction, } from '../actions/transform-to-blockquote-action';
+import { RTEBlockquoteBlock } from '../dto/rte-blockquote-block';
+import QuoteLeftIcon from '../assets/quote-left';
+/**
+ * Toolbar button renderer for the blockquote extension.
+ *
+ * Behaviors implemented:
+ * - Active (`selected`) when the caret/selection is inside any blockquote
+ *   ancestor.
+ * - Click wraps the current block(s) into a new `<blockquote>`, or unwraps
+ *   the nearest blockquote ancestor when active. Inside a list, the entire
+ *   list is wrapped (escalating to the outermost list block). With no
+ *   selection, a new empty blockquote is appended at the end and focused.
+ * - Disabled when the wrap container does not support the wrap strategy
+ *   (e.g. inside a code block or function block); the button remains
+ *   enabled inside a blockquote so it can be toggled off, and with no
+ *   selection so it can append a new blockquote.
+ * - Hidden in source-edit mode (inherited from {@link VegaRTEToolbarButtonRenderer}).
+ */
+export class RTEBlockquoteToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  /**
+   * @inheritDoc
+   */
+  render(createElement, editorContext) {
+    return this.renderButton(createElement, editorContext, {
+      icon: 'quote-left',
+      tooltip: { text: 'Block quote' },
+    });
+  }
+  /**
+   * @inheritDoc
+   */
+  isSelected(editorContext) {
+    const startNode = this.getStartNode(editorContext);
+    return startNode ? this.findBlockquoteAncestor(startNode) !== null : false;
+  }
+  /**
+   * @inheritDoc
+   */
+  isDisabled(editorContext) {
+    if (editorContext.host.disabled) {
+      return true;
+    }
+    const startNode = this.getStartNode(editorContext);
+    // No selection — click appends a new blockquote at the end.
+    // Inside a blockquote — click toggles it off.
+    // Either way, the button stays enabled.
+    if (!startNode || this.findBlockquoteAncestor(startNode) !== null) {
+      return false;
+    }
+    const { container } = this.resolveWrapAnchor(startNode.parent);
+    return !ActionHandleStrategyRegistry.canHandle(TRANSFORM_TO_BLOCKQUOTE, container);
+  }
+  /**
+   * @inheritDoc
+   */
+  handleButtonClick(editorContext) {
+    const context = this.getExtensionContext(editorContext.host);
+    if (context) {
+      const { host, getSelectedNodes } = context;
+      const selectedNodes = getSelectedNodes();
+      const startNode = selectedNodes[0];
+      if (!startNode) {
+        // No active selection → append a new empty blockquote at the end (mirrors text-style toolbar).
+        this.appendEmptyBlockquote(host.value);
+        return;
+      }
+      // Direction is decided by the first selected block only.
+      if (this.findBlockquoteAncestor(startNode)) {
+        const blockquoteAncestors = this.collectBlockquoteAncestors(selectedNodes);
+        blockquoteAncestors.forEach((blockquote) => {
+          blockquote.apply(new RemoveBlockquoteAction());
+        });
+      }
+      else {
+        this.wrapSelectedBlocks(selectedNodes);
+      }
+      host.value.apply(new UpdateCursorPositionAction(startNode, editorContext.rteRange.startOffset));
+    }
+  }
+  /* istanbul ignore next */
+  /**
+   * @inheritDoc
+   */
+  handleDropdownClick() {
+    // No dropdown — single toggle button.
+  }
+  /**
+   * Append an empty paragraph wrapped in a new blockquote to the end of the
+   * content and place the caret inside it.
+   *
+   * @param {VegaRTEContent} content - Editor content to append to.
+   */
+  appendEmptyBlockquote(content) {
+    if (content.children.length > 0) {
+      const lastBlock = content.children[content.children.length - 1];
+      const newBlock = RTETextBlock.from({
+        id: generateUUID(),
+        type: 'paragraph',
+        nodes: [{ id: generateUUID(), type: 'text', text: '' }],
+      });
+      content.apply(new InsertChildrenAfterAction(lastBlock, newBlock));
+      content.apply(new TransformToBlockquoteAction([newBlock]));
+      content.apply(new UpdateCursorPositionAction(newBlock.getLastNode(), 0));
+    }
+  }
+  /**
+   * Wrap the selection's unique parent blocks into a new blockquote. Blocks
+   * inside a list or other nested container escalate to the top-level block.
+   * When the selection spans multiple top-level (root) blocks, any scoped
+   * container touched along the way (e.g. a table cell) is treated as an
+   * opaque block instead of an independent wrap target — the whole
+   * selection wraps as one, and any blockquote nested deeper than the
+   * top-level block (e.g. inside a table cell) is left untouched. Existing
+   * top-level blockquote blocks in the selection are merged (flattened)
+   * into the new one rather than nested.
+   *
+   * @param {RTENode[]} selectedNodes - Currently selected nodes.
+   */
+  wrapSelectedBlocks(selectedNodes) {
+    var _a, _b;
+    const uniqueBlocks = this.getUniqueBlocks(selectedNodes);
+    // If the selection spans more than one top-level block, force every
+    // anchor resolution to escalate all the way to the root, ignoring any
+    // scoped container (e.g. a table cell) it passes through.
+    const rootAncestors = new Set(uniqueBlocks.map((block) => { var _a; return (_a = this.resolveWrapAnchor(block, true).wrapBlock) !== null && _a !== void 0 ? _a : block; }));
+    const forceRootScope = rootAncestors.size > 1;
+    // Pass 1: unwrap any existing blockquote reachable from the selection so it merges instead of nesting.
+    const alreadyUnwrapped = new Set();
+    for (const block of uniqueBlocks) {
+      const { wrapBlock } = this.resolveWrapAnchor(block, forceRootScope);
+      if (wrapBlock instanceof RTEBlockquoteBlock && !alreadyUnwrapped.has(wrapBlock)) {
+        alreadyUnwrapped.add(wrapBlock);
+        wrapBlock.apply(new RemoveBlockquoteAction());
+      }
+    }
+    // Pass 2: group targets by their resolved container so each container is wrapped independently.
+    const containerMap = new Map();
+    for (const block of uniqueBlocks) {
+      const anchor = this.resolveWrapAnchor(block, forceRootScope);
+      const { container } = anchor;
+      if (container) {
+        const target = (_a = anchor.wrapBlock) !== null && _a !== void 0 ? _a : block;
+        const targets = (_b = containerMap.get(container)) !== null && _b !== void 0 ? _b : new Set();
+        targets.add(target);
+        containerMap.set(container, targets);
+      }
+    }
+    for (const [container, targets] of containerMap) {
+      container.apply(new TransformToBlockquoteAction([...targets]));
+    }
+  }
+  /**
+   * Resolve the starting node of the current toolbar selection, if any.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - Render context.
+   * @returns {Nullable<RTENode>} The first selected node, or null.
+   */
+  getStartNode(editorContext) {
+    const context = this.getExtensionContext(editorContext.host);
+    return context === null || context === void 0 ? void 0 : context.getSelectedNodes()[0];
+  }
+  /**
+   * Collect the unique closest blockquote ancestors of every selected node.
+   * Multiple selected nodes that share the same blockquote ancestor collapse
+   * into a single entry, so applying {@link RemoveBlockquoteAction} to each
+   * result unwraps every distinct blockquote in the selection exactly once.
+   *
+   * @param {RTENode[]} nodes - Selected nodes.
+   * @returns {Set<RTEBlockquoteBlock>} Unique blockquote ancestors, preserving insertion order.
+   */
+  collectBlockquoteAncestors(nodes) {
+    const ancestors = new Set();
+    nodes.forEach((node) => {
+      const ancestor = this.findBlockquoteAncestor(node);
+      if (ancestor) {
+        ancestors.add(ancestor);
+      }
+    });
+    return ancestors;
+  }
+  /**
+   * Walk up the block ancestors of the supplied node looking for an
+   * {@link RTEBlockquoteBlock}.
+   *
+   * @param {RTENode} node - Starting node.
+   * @returns {Nullable<RTEBlockquoteBlock>} The closest blockquote ancestor, or null.
+   */
+  findBlockquoteAncestor(node) {
+    let current = node.parent;
+    while (current && !(current instanceof VegaRTEContent)) {
+      if (current instanceof RTEBlockquoteBlock) {
+        return current;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+  /**
+   * Collect unique block ancestors (immediate parent blocks) from a list of
+   * selected nodes, preserving order of first appearance.
+   *
+   * @param {RTENode[]} nodes - Selected nodes.
+   * @returns {RTEBlock[]} Unique parent blocks.
+   */
+  getUniqueBlocks(nodes) {
+    const seen = new Set();
+    const result = [];
+    nodes.forEach((node) => {
+      const block = node.parent;
+      if (block && !seen.has(block)) {
+        seen.add(block);
+        result.push(block);
+      }
+    });
+    return result;
+  }
+  /**
+   * Walk up from `block` to find the nearest ancestor that is a direct child
+   * of a container registered to handle {@link TRANSFORM_TO_BLOCKQUOTE}
+   * (e.g. {@link VegaRTEContent}, {@link RTETableCellBlock}).
+   *
+   * Stops as soon as the parent can handle the wrap action, so that blocks
+   * inside a table cell are scoped to the cell (not escalated to the root)
+   * while blocks inside a list are still escalated to the top-level list.
+   * Pass `forceRootScope` to ignore scoped containers and always escalate
+   * to the root — used when the overall selection spans multiple top-level
+   * blocks, so a table (or any other scoped container) is wrapped as a
+   * single opaque block alongside its siblings instead of independently.
+   *
+   * @param {RTEBlock} block - Immediate parent block of the selected node.
+   * @param {boolean} [forceRootScope] - Ignore scoped containers and escalate to the root.
+   * @returns {WrapAnchor} `wrapBlock` is the top-level ancestor when the block
+   *   is nested (otherwise null); `container` is the nearest wrap-capable parent.
+   */
+  resolveWrapAnchor(block, forceRootScope = false) {
+    let current = block;
+    while (current.parent &&
+      !(current.parent instanceof VegaRTEContent) &&
+      (forceRootScope ||
+        !ActionHandleStrategyRegistry.canHandle(TRANSFORM_TO_BLOCKQUOTE, current.parent))) {
+      current = current.parent;
+    }
+    const wrapBlock = current !== block ? current : null;
+    const container = current.parent;
+    return { wrapBlock, container };
+  }
+}
+(() => {
+  VegaInternalIconManager.register({ 'quote-left': QuoteLeftIcon });
+})();

package/dist/collection/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/helper/find-replace-highlight-manager.js

@@ -19,8 +19,9 @@ const HIGHLIGHT_ACTIVE_BG = `rgba(var(--v-rte-find-highlight-active-bg, ${HIGHLI
  * jumping, and VegaChange events), this manager renders semi-transparent
  * highlight rectangles in an absolutely-positioned overlay container.
  *
- * The overlay lives inside `.rich-text-editor-container` (the RTE's scroll
- * container) so highlight divs scroll naturally with the text content.
+ * The overlay lives inside `vega-rich-text-content`'s internal
+ * `.rich-text-content` container (the actual text scroll coordinate space).
+ * This keeps highlight rectangles aligned when the editable area scrolls.
  * `pointer-events: none` ensures highlights don't interfere with user
  * interaction (selection, typing, clicking).
  *
@@ -83,8 +84,11 @@ export class FindReplaceHighlightManager {
   }
   // ─── Private helpers ──────────────────────────────────────────────────────────
   /**
-   * Gets the existing overlay container or creates one inside the RTE's
-   * scroll container (`.rich-text-editor-container`).
+   * Gets the existing overlay container or creates one in the same coordinate
+   * space as rendered text.
+   *
+   * Mount target: `vega-rich-text-content` shadow root's
+   * `.rich-text-content` element (actual text scroll layer).
    *
    * @typedef HTMLVegaRichTextEditorElement - The type of the host rich text editor element.
    * @param {HTMLVegaRichTextEditorElement} host - The RTE host element.
@@ -96,8 +100,8 @@ export class FindReplaceHighlightManager {
     }
     const safeDocument = tryGetDocument();
     if (safeDocument) {
-      const scrollContainer = host.shadowRoot.querySelector('.rich-text-editor-container');
-      if (scrollContainer) {
+      const textContainer = this.resolveOverlayMountTarget(host);
+      if (textContainer) {
         // The overlay is appended as the last child (paints above content).
         // Blend mode is controlled via CSS variable --v-rte-find-highlight-blend:
         //   - Light (default): multiply (yellow darkens white bg, text readable)
@@ -113,13 +117,23 @@ export class FindReplaceHighlightManager {
         overlay.style.pointerEvents = 'none';
         overlay.style.overflow = 'visible';
         overlay.style.setProperty('mix-blend-mode', 'var(--v-rte-find-highlight-blend, multiply)');
-        scrollContainer.appendChild(overlay);
+        textContainer.appendChild(overlay);
         this.overlayContainer = overlay;
         return overlay;
       }
     }
     return null;
   }
+  /**
+   * Resolves the overlay mount target that matches the text rendering coordinate space.
+   *
+   * @param {HTMLVegaRichTextEditorElement} host - The RTE host element.
+   * @returns {Nullable<HTMLDivElement>} The preferred mount target or null.
+   */
+  resolveOverlayMountTarget(host) {
+    var _a, _b, _c, _d;
+    return ((_d = (_c = (_b = (_a = host.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('vega-rich-text-content')) === null || _b === void 0 ? void 0 : _b.shadowRoot) === null || _c === void 0 ? void 0 : _c.querySelector('.rich-text-content')) !== null && _d !== void 0 ? _d : null);
+  }
   /**
    * Creates absolutely-positioned highlight rectangles for a single node
    * position within a match.

package/dist/collection/components/vega-rich-text-editor/extensions/find-replace/slimmer/renderers/find-replace-toolbar-button-renderer.js

@@ -139,6 +139,18 @@ export class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButtonRender
     DomNodeSubjectObserverFactory.addUniqueObserverToNode(editorContext.host, VegaChange, this.debouncedRefresh);
     if (this.isHidden(editorContext) && this.isPopoverOpen && this.popoverRef) {
       void this.popoverRef.hide();
+      return;
+    }
+    // Keep the popover open but force a refresh of placement/z-index.
+    // This prevents stale geometry when editor layout/stacking changes while
+    // the panel is already visible (for example fullscreen toggle or resize).
+    // `show(true)` here is intentionally a refresh call, not a reopen.
+    // Verified behavior: this refresh does not introduce flickering/animation artifacts.
+    // Find & Replace differs from other toolbar popovers because it uses trigger='none'
+    // and stays open until explicitly closed. Other toolbar popovers use
+    // trigger='click' and auto-close when users click the fullscreen button.
+    if (this.isPopoverOpen && this.popoverRef) {
+      void this.popoverRef.show(true);
     }
   }
   /**

package/dist/collection/components/vega-rich-text-editor/extensions/fullscreen/assets/fullscreen-enter.js

@@ -0,0 +1,3 @@
+export default {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Pro 6.3.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><path fill="currentColor" d="M295 183c-9.4 9.4-9.4 24.6 0 33.9s24.6 9.4 33.9 0l135-135V168c0 13.3 10.7 24 24 24s24-10.7 24-24V24c0-13.3-10.7-24-24-24H344c-13.3 0-24 10.7-24 24s10.7 24 24 24h86.1L295 183zM217 329c9.4-9.4 9.4-24.6 0-33.9s-24.6-9.4-33.9 0L48 430.1V344c0-13.3-10.7-24-24-24s-24 10.7-24 24V488c0 13.3 10.7 24 24 24H168c13.3 0 24-10.7 24-24s-10.7-24-24-24H81.9L217 329z"/></svg>`,
+};

package/dist/collection/components/vega-rich-text-editor/extensions/fullscreen/assets/fullscreen-exit.js

@@ -0,0 +1,3 @@
+export default {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Pro 6.3.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><path fill="currentColor" d="M473 57c9.4-9.4 9.4-24.6 0-33.9s-24.6-9.4-33.9 0l-135 135V72c0-13.3-10.7-24-24-24s-24 10.7-24 24V216c0 13.3 10.7 24 24 24H424c13.3 0 24-10.7 24-24s-10.7-24-24-24H337.9L473 57zM7 455c-9.4 9.4-9.4 24.6 0 33.9s24.6 9.4 33.9 0l135-135V440c0 13.3 10.7 24 24 24s24-10.7 24-24V296c0-13.3-10.7-24-24-24H56c-13.3 0-24 10.7-24 24s10.7 24 24 24h86.1L7 455z"/></svg>`,
+};