@globalpayments/vega 2.91.0 → 2.92.0

package/dist/collection/components/vega-field-label/vega-field-label.css

@@ -7,6 +7,11 @@
   display: inline-block;
 }
 
+:host(.center-align) {
+  display: inline-flex;
+  align-items: center;
+}
+
 :host(.disabled) {
   pointer-events: none;
 }
@@ -52,10 +57,19 @@ label:first-of-type {
   }
 }
 
+:host(.center-align) label:first-of-type {
+  display: inline-flex;
+  align-items: center;
+}
+
 :host(.disabled) > label > span.vega-field-label {
   color: rgba(var(--v-text-secondary, 107, 116, 125, 1));
 }
 
+:host(.center-align) .vega-field-label {
+  min-width: 0;
+}
+
 .vega-field-label-required {
   color: rgba(var(--v-text-error, 189, 41, 71, 1));
   margin-left: 4px;
@@ -71,6 +85,12 @@ label:first-of-type {
   vertical-align: top;
 }
 
+:host(.center-align) .label-suffix-button {
+  display: inline-flex;
+  align-items: center;
+  vertical-align: baseline;
+}
+
 .optional {
   margin-left: 4px;
   font-family: "Inter", sans-serif;

package/dist/collection/components/vega-field-label/vega-field-label.js

@@ -99,9 +99,12 @@ export class VegaFieldLabel {
     }
   }
   render() {
+    var _a;
+    const shouldCenterAlign = !!((_a = this.suffixButtonConfig) === null || _a === void 0 ? void 0 : _a.centerAlign);
     return sanitizeVegaComponent(h(Host, { class: {
-        hidden: this.label === '',
-        disabled: this.disabled,
+        'hidden': this.label === '',
+        'disabled': this.disabled,
+        'center-align': shouldCenterAlign,
       }, onClick: this.handleClick },
       this.labelAnnouncementRenderer.render(),
       h("label", { "aria-hidden": "true", part: "container" },
@@ -157,7 +160,7 @@ export class VegaFieldLabel {
       "mutable": false,
       "complexType": {
         "original": "Nullable<LabelSuffixButtonConfig>",
-        "resolved": "{ icon: string; } & Partial<Pick<HTMLVegaTooltipElement, \"size\" | \"trigger\" | \"minWidth\" | \"maxWidth\" | \"text\" | \"placement\" | \"alignment\">>",
+        "resolved": "{ icon: string; buttonSize?: VegaButtonCircleSize; centerAlign?: boolean; } & Partial<Pick<HTMLVegaTooltipElement, \"size\" | \"trigger\" | \"minWidth\" | \"maxWidth\" | \"text\" | \"placement\" | \"alignment\">>",
         "references": {
           "Nullable": {
             "location": "import",

package/dist/collection/components/vega-input/vega-input.css

@@ -112,6 +112,7 @@ vega-field-label {
   letter-spacing: 0px;
   color: rgba(var(--v-text-primary, 32, 54, 69, 1));
   background-color: rgba(var(--v-bg-primary, 252, 252, 252, 1));
+  font-feature-settings: "calt" 0;
 }
 @media screen and (min-width: 768px) and (max-width: 1023px) {
   .vega-input-input input {

package/dist/collection/components/vega-input/vega-input.js

@@ -590,7 +590,7 @@ export class VegaInput {
       "mutable": false,
       "complexType": {
         "original": "Nullable<LabelSuffixButtonConfig>",
-        "resolved": "{ icon: string; } & Partial<Pick<HTMLVegaTooltipElement, \"size\" | \"trigger\" | \"minWidth\" | \"maxWidth\" | \"text\" | \"placement\" | \"alignment\">>",
+        "resolved": "{ icon: string; buttonSize?: VegaButtonCircleSize; centerAlign?: boolean; } & Partial<Pick<HTMLVegaTooltipElement, \"size\" | \"trigger\" | \"minWidth\" | \"maxWidth\" | \"text\" | \"placement\" | \"alignment\">>",
         "references": {
           "Nullable": {
             "location": "import",

package/dist/collection/components/vega-input-select/vega-input-select.js

@@ -307,7 +307,7 @@ export class VegaInputSelect {
       "mutable": false,
       "complexType": {
         "original": "Nullable<LabelSuffixButtonConfig>",
-        "resolved": "{ icon: string; } & Partial<Pick<HTMLVegaTooltipElement, \"size\" | \"trigger\" | \"minWidth\" | \"maxWidth\" | \"text\" | \"placement\" | \"alignment\">>",
+        "resolved": "{ icon: string; buttonSize?: VegaButtonCircleSize; centerAlign?: boolean; } & Partial<Pick<HTMLVegaTooltipElement, \"size\" | \"trigger\" | \"minWidth\" | \"maxWidth\" | \"text\" | \"placement\" | \"alignment\">>",
         "references": {
           "Nullable": {
             "location": "import",

package/dist/collection/components/vega-rich-text-editor/assets/cut.js

@@ -0,0 +1,3 @@
+export default {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Pro 7.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M48 112a64 64 0 1 1 128 0 64 64 0 1 1 -128 0zm176 0C224 50.1 173.9 0 112 0S0 50.1 0 112 50.1 224 112 224c24 0 46.3-7.6 64.5-20.4l57.3 52.4-57.3 52.4C158.3 295.6 136 288 112 288 50.1 288 0 338.1 0 400s50.1 112 112 112 112-50.1 112-112c0-20.5-5.5-39.6-15.1-56.2L504.2 73.7c9.8-8.9 10.5-24.1 1.5-33.9s-24.1-10.5-33.9-1.5l-202.4 185.2-60.5-55.3c9.6-16.5 15.1-35.7 15.1-56.2zM471.8 473.7c9.8 8.9 25 8.3 33.9-1.5s8.3-25-1.5-33.9L338.6 286.8 302.7 319 471.8 473.7zM48 400a64 64 0 1 1 128 0 64 64 0 1 1 -128 0z"/></svg>`,
+};

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-delete-text-or-decorator-node-strategy.js

@@ -138,13 +138,28 @@ export class BlockDeleteTextOrDecoratorNodeStrategy extends BlockDeleteNodeConte
     }
     else {
       const shouldRemoveNode = previousNode;
-      if (shouldRemoveNode && !shouldRemoveNode.isContentEditable()) {
+      if (shouldRemoveNode &&
+        !shouldRemoveNode.isContentEditable() &&
+        shouldRemoveNode.parent === target) {
         previousNode = this.getPreviousNode(shouldRemoveNode);
         shouldRemoveNode.parent.apply(new RemoveChildrenAction(shouldRemoveNode));
         if (!previousNode) {
           action.nextNode = startContainerNode;
         }
       }
+      else if (previousNode &&
+        previousNode.parent !== target &&
+        target.type === previousNode.parent.type) {
+        // The caret sits at the start of a block whose first node is a non-editable node
+        // (e.g. a token). Merge this block into the previous one, mirroring the text-node
+        // behavior so Backspace/Delete join the two blocks instead of doing nothing.
+        //
+        // This also covers the case where the previous block ENDS with a non-editable node
+        // (e.g. another token): the previous node is non-editable but lives in a different
+        // block, so it must not be removed here — the blocks merge instead, keeping that
+        // trailing token intact.
+        previousNode.parent.apply(new MergeTwoBlocksNodesAction(target));
+      }
     }
     if (previousNode) {
       action.previousNode = previousNode;

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-merge-nodes-strategy.js

@@ -1,5 +1,8 @@
 import { AppendChildrenAction } from '../../actions/append-child-nodes-action';
+import { LinkGroupAnnotationAction } from '../../actions/link-group-annotation-action';
 import { RemoveChildrenAction } from '../../actions/remove-child-action';
+import { NodeAnnotationTypeEnum } from '../../annotations/node-annotation.abstract';
+import { RTETextNode } from '../../nodes/text-node';
 import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
 /**
  * Append the second block child nodes to the first block child nodes and remove the second block strategy.
@@ -19,7 +22,29 @@ export class BlockMergeNodesStrategy extends ActionHandleStrategy {
         shouldMergeNodes = anotherBlock.children.filter((node) => node.text);
       }
       target.apply(new AppendChildrenAction(shouldMergeNodes));
+      if (target.type !== 'image') {
+        this.transferLinkGroups(shouldMergeNodes, target);
+      }
       anotherBlock.parent.apply(new RemoveChildrenAction(anotherBlock));
     }
   }
+  /**
+   * Re-registers the link group annotation on the target block for any merged nodes that carry a
+   * link. The link group annotation lives on the block being removed, so without this the merged
+   * link nodes would lose their hyperlink rendering.
+   *
+   * @param {RTENode[]} mergedNodes - The nodes that were appended to the target block.
+   * @param {RTETextBlock} target - The text block that received the merged nodes.
+   */
+  transferLinkGroups(mergedNodes, target) {
+    mergedNodes.forEach((node) => {
+      if (!(node instanceof RTETextNode)) {
+        return;
+      }
+      const linkAnnotation = node.getAnnotationByType(NodeAnnotationTypeEnum.LINK);
+      if (linkAnnotation) {
+        target.apply(new LinkGroupAnnotationAction(linkAnnotation.link.groupKey, [node], 'link'));
+      }
+    });
+  }
 }

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/delete-selected-content-strategy.js

@@ -0,0 +1,16 @@
+import changeManager from '../../../../../helpers/change-manager/change-manager';
+import domNodeSubjectFactory from '../../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
+import { VegaInternalRichTextEditDeleteSelectedNodes } from '../../../../../helpers/event-manager/event-id/vega-internal-event-id';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * DeleteSelectedContentStrategy is responsible for handling the deletion of selected content within the rich text editor.
+ */
+export class DeleteSelectedContentStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action) {
+    const { host, mergeFlag } = action;
+    changeManager.notify(domNodeSubjectFactory.getSubject(host, VegaInternalRichTextEditDeleteSelectedNodes), { host, detail: mergeFlag });
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/delete-selected-content-action.js

@@ -0,0 +1,17 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Delete the currently selected content from the editor.
+ *
+ * @example currentVegaRTEContent.apply(new DeleteSelectedContentAction(host, mergeFlag))
+ */
+export class DeleteSelectedContentAction extends ModifyContentAction {
+  constructor(host, mergeFlag, flushable = false) {
+    super();
+    this.type = ModifyContentActionType.DELETE_SELECTED_CONTENT;
+    // mergeFlag indicates whether the action should merge adjacent text nodes after deletion.
+    this.mergeFlag = false;
+    this.host = host;
+    this.mergeFlag = mergeFlag;
+    this.isFlushable = flushable;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/modify-content-action.abstract.js

@@ -30,6 +30,7 @@ export var ModifyContentActionType;
   ModifyContentActionType["INSERT_TEXT_TO_DECORATOR_NODE"] = "INSERT_TEXT_TO_DECORATOR_NODE";
   ModifyContentActionType["INSERT_NODE_TO_NEAREST_ROOT"] = "INSERT_NODE_TO_NEAREST_ROOT";
   ModifyContentActionType["PASTE_CONTENT"] = "PASTE_CONTENT";
+  ModifyContentActionType["DELETE_SELECTED_CONTENT"] = "DELETE_SELECTED_CONTENT";
 })(ModifyContentActionType || (ModifyContentActionType = {}));
 /**
  * Abstract class for update node content, delete node, insert node

package/dist/collection/components/vega-rich-text-editor/dto/content-state.js

@@ -23,6 +23,7 @@ import { StylePreservator } from '../../../helpers/csp/styles-preservator';
 import { LogUtility } from '../../../utils/log';
 import { HTMLContentCleaner } from '../slimmers/controllers/html-cleaner';
 import { RTEFilterStylesStrategyRegistry } from './filter-styles-strategies/filter-styles-strategy-registry';
+import { DeleteSelectedContentStrategy } from './action-handle-strategies/modify-content-strategies/delete-selected-content-strategy';
 /**
  * Class representing the content state of the rich text editor.
  */
@@ -259,6 +260,7 @@ export class VegaRTEContent {
   ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_CHILDREN_AFTER, VegaRTEContent.name, new InsertChildrenAfterStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_TO_CODE_BLOCK, VegaRTEContent.name, new BlockTransformToCodeBlockStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.UPDATE_CURSOR_POSITION, VegaRTEContent.name, new UpdateCursorPositionStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_SELECTED_CONTENT, VegaRTEContent.name, new DeleteSelectedContentStrategy());
 })();
 /** Minimize-safe type discriminator for VegaRTEContent. */
 VegaRTEContent.dtoName = 'VegaRTEContent';

package/dist/collection/components/vega-rich-text-editor/dto/range.js

@@ -144,8 +144,8 @@ export class RTERange {
         : this._endNode.getRangeContainer();
       if (startContainer && endContainer) {
         range = new Range();
-        range.setStart(startContainer, this._startOffset);
-        range.setEnd(endContainer, this._endOffset);
+        range.setStart(startContainer, this.clampOffsetToContainer(startContainer, this._startOffset));
+        range.setEnd(endContainer, this.clampOffsetToContainer(endContainer, this._endOffset));
         this._startContainer = startContainer;
         this._endContainer = endContainer;
         this._oldNativeRange = range;
@@ -156,6 +156,28 @@ export class RTERange {
       return this._oldNativeRange;
     }
   }
+  /**
+   * Clamps an offset to the valid bound of a DOM container so that
+   * `Range.setStart` / `Range.setEnd` never throw `IndexSizeError`.
+   *
+   * A stored selection offset can become stale or unit-mismatched when an undo
+   * restores a selection captured against different content — for example after
+   * find-and-replace shrinks a text node, or when the selection node's DOM
+   * container is its parent element (offset measured in child-node count rather
+   * than characters, as for non-editable token / logic-control nodes). Text
+   * containers are bounded by character length, element containers by child count.
+   *
+   * @param {Node} container - The DOM container the offset applies to.
+   * @param {number} offset - The desired offset.
+   * @returns {number} The offset clamped to `[0, container length]`.
+   */
+  clampOffsetToContainer(container, offset) {
+    var _a, _b;
+    const max = container.nodeType === Node.TEXT_NODE
+      ? (_b = (_a = container.textContent) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0
+      : container.childNodes.length;
+    return Math.max(0, Math.min(offset, max));
+  }
   /**
    * Retrieves an RTENode based on the given element by checking its type and parent elements.
    *

package/dist/collection/components/vega-rich-text-editor/extensions/copy/action-handler-strategies/copy-selected-content-strategy.js

@@ -0,0 +1,226 @@
+import { LogUtility } from '../../../../../utils/log';
+import { tryGetDocument } from '../../../../../utils/try-get-document';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+/**
+ * Strategy that extracts the HTML and plain text content of the current selection, stores the
+ * result on the {@link CopySelectedContentAction} and writes it to the clipboard.
+ */
+export class CopySelectedContentStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action) {
+    const parentBlocks = this.getParentBlocks(action.selectedNodes);
+    const { html, text } = this.getSelectedContent(action.selection, parentBlocks);
+    if (text || html) {
+      action.copyResult = this.copyToClipboard(html, text);
+    }
+  }
+  /**
+   * Extracts the HTML and text content from the current selection.
+   *
+   * `Range.cloneContents()` returns only the nodes inside the selection, dropping the ancestor chain
+   * between the selection's common ancestor and its block. When the selection stays inside a single
+   * block, those dropped ancestors carry the styling, so the cloned fragment is re-wrapped with
+   * shallow clones of every ancestor from the common ancestor up to the block, preserving arbitrary
+   * inline nesting (e.g. `block > strong > em > span > text`).
+   *
+   * When the selection covers the whole block (its common ancestor sits above the block) or spans
+   * multiple blocks, each block is already kept by `cloneContents()`, so no re-wrapping is done.
+   *
+   * @param {Nullable<Selection>} selection - The current selection object.
+   * @param {RTEBlock[]} parentBlocks - The parent blocks of the selected nodes.
+   * @returns {RTESelectedContent} - The HTML and text content of the selected content.
+   */
+  getSelectedContent(selection, parentBlocks) {
+    const result = { html: '', text: '' };
+    if (!selection || selection.rangeCount === 0 || selection.isCollapsed) {
+      return result;
+    }
+    const range = selection.getRangeAt(0);
+    const doc = tryGetDocument();
+    if (!doc) {
+      return result;
+    }
+    // `cloneContents()` returns a `DocumentFragment` of real DOM nodes (already well-formed). Its
+    // `textContent` is the plain text; the fragment itself is wrapped/serialized into HTML below.
+    const fragment = range.cloneContents();
+    // A `DocumentFragment` has no `innerHTML`, so a temporary element is used to serialize it to HTML.
+    const container = doc.createElement('div');
+    const commonAncestor = range.commonAncestorContainer;
+    if (parentBlocks.length === 1) {
+      const block = this.getDOMByEntity(parentBlocks[0]);
+      // Only re-wrap when the block is dropped from the clone, i.e. the selection stays inside the
+      // block. When the whole block is selected, `commonAncestor` sits above it and the clone
+      // already keeps the block, so wrapping again would nest a duplicate block.
+      if (block && block.contains(commonAncestor)) {
+        // Wrap the cloned fragment with the dropped ancestor chain (from `commonAncestor` up to the
+        // block), preserving each element's styles, then serialize the rebuilt block to HTML.
+        const cloneNode = this.wrapWithAncestorChain(fragment, commonAncestor, block);
+        container.appendChild(cloneNode);
+        result.html = container.innerHTML;
+        result.text = container.textContent;
+        return result;
+      }
+    }
+    else if (parentBlocks.length > 1 &&
+      parentBlocks.every((block) => block.type === 'list-item')) {
+      const firstList = parentBlocks[0].parent;
+      if (firstList && parentBlocks.every((block) => block.parent === firstList)) {
+        const listElement = this.getDOMByEntity(firstList);
+        if (listElement && listElement.contains(commonAncestor)) {
+          const cloneListElement = listElement.cloneNode(false);
+          cloneListElement.appendChild(fragment);
+          container.appendChild(cloneListElement);
+          result.html = container.innerHTML;
+          result.text = container.textContent;
+          return result;
+        }
+      }
+    }
+    // The selection covers whole/multiple blocks: the clone already keeps them, so serialize as-is.
+    container.appendChild(fragment);
+    result.html = container.innerHTML;
+    result.text = container.textContent;
+    return result;
+  }
+  /**
+   * Wraps the cloned selection fragment with the ancestor chain that `cloneContents()` dropped,
+   * rebuilding every element from the selection's common ancestor up to the block while preserving
+   * each element's styles. Returns the cloned block that holds the rebuilt chain and content.
+   *
+   * When the common ancestor is the block itself, the fragment is appended directly under the cloned
+   * block, since no inline ancestor chain was dropped.
+   *
+   * @param {Node} content - The cloned selection fragment to place at the innermost level.
+   * @param {Node} commonAncestor - The selection's common ancestor container.
+   * @param {HTMLElement} block - The block element to stop cloning at.
+   * @returns {HTMLElement} - The cloned block wrapping the rebuilt ancestor chain and content.
+   */
+  wrapWithAncestorChain(content, commonAncestor, block) {
+    const blockClone = block.cloneNode(false);
+    // `cloneContents()` keeps everything inside `commonAncestor`, so the dropped chain runs from
+    // `commonAncestor` (its element, when the ancestor is a text node) up to the block.
+    const targetElement = commonAncestor.nodeType === Node.TEXT_NODE
+      ? commonAncestor.parentElement
+      : commonAncestor;
+    // The target is the block itself: the content sits directly under the block, no chain to rebuild.
+    if (targetElement === block) {
+      blockClone.appendChild(content);
+      return blockClone;
+    }
+    // Clone the target as the innermost container and place the content inside it.
+    const innermost = targetElement.cloneNode(false);
+    innermost.appendChild(content);
+    // Walk up from the target to the block, cloning each ancestor and nesting the chain bottom-up.
+    let shouldAppendNode = innermost;
+    let current = targetElement.parentElement;
+    while (current && current !== block) {
+      const parentClone = current.cloneNode(false);
+      parentClone.appendChild(shouldAppendNode);
+      shouldAppendNode = parentClone;
+      current = current.parentElement;
+    }
+    // Append the assembled ancestor chain to the cloned block.
+    blockClone.appendChild(shouldAppendNode);
+    // When the block is a list item inside an ordered list, wrap the cloned list item with a
+    // shallow clone of the ordered list to preserve the numbering.
+    if (blockClone.tagName === 'LI' &&
+      current &&
+      current.parentElement &&
+      current.parentElement.tagName === 'OL') {
+      const cloneList = current.parentElement.cloneNode(false);
+      cloneList.appendChild(blockClone);
+      return cloneList;
+    }
+    return blockClone;
+  }
+  /**
+   * Retrieves the parent blocks of the given selected nodes.
+   *
+   * @param {RTENode[]} selectedNodes - The nodes for which to find parent blocks.
+   * @returns {RTEBlock[]} An array of parent blocks.
+   */
+  getParentBlocks(selectedNodes) {
+    const parentBlocks = [];
+    for (const node of selectedNodes) {
+      const block = node.parent;
+      if (block && !parentBlocks.includes(block)) {
+        parentBlocks.push(block);
+      }
+    }
+    return parentBlocks;
+  }
+  /**
+   * Copies both HTML and plain text content to the clipboard using the Clipboard API.
+   *
+   * Browser compatibility for `navigator.clipboard.write()` with `ClipboardItem`:
+   * - Chrome 76+, Edge 79+, Safari 13.1+, Firefox 127+
+   *
+   * Since Firefox 86+ must be supported, fall back to `execCommand('copy')` when the
+   * Clipboard API is unavailable or fails (e.g. Firefox 86-126).
+   *
+   * @param {string} htmlContent - The HTML content to copy.
+   * @param {string} textContent - The plain text content to copy.
+   * @returns {Promise<boolean>} - A promise that resolves to true if the copy operation succeeded.
+   */
+  async copyToClipboard(htmlContent, textContent) {
+    let result = false;
+    try {
+      const htmlBlob = new Blob([htmlContent], { type: 'text/html' });
+      const textBlob = new Blob([textContent], { type: 'text/plain' });
+      const clipboardItem = new ClipboardItem({
+        'text/html': htmlBlob,
+        'text/plain': textBlob,
+      });
+      await navigator.clipboard.write([clipboardItem]);
+      result = true;
+    }
+    catch (_a) {
+      // Fallback for browsers without ClipboardItem support (e.g. Firefox 86-126)
+      result = this.copyWithExecCommand(htmlContent, textContent);
+      if (!result) {
+        LogUtility.warn('Failed to copy the selected content to the clipboard. Use keyboard shortcuts instead.');
+      }
+    }
+    return result;
+  }
+  /**
+   * Fallback copy method using `execCommand('copy')` for browsers that don't support the
+   * Clipboard API (e.g. Firefox 86-126).
+   *
+   * Instead of creating a temporary element and changing the selection (which would clear the
+   * editor's Shadow DOM selection and steal focus), this intercepts the native `copy` event that
+   * `execCommand('copy')` triggers and overrides its clipboard data. The user's original selection
+   * and focus stay untouched.
+   *
+   * @param {string} htmlContent - The HTML content to copy.
+   * @param {string} textContent - The plain text content to copy.
+   * @returns {boolean} - True if the copy command succeeded.
+   */
+  copyWithExecCommand(htmlContent, textContent) {
+    const doc = tryGetDocument();
+    if (!doc) {
+      return false;
+    }
+    /**
+     * Overrides the clipboard data of the native copy event triggered by `execCommand('copy')`.
+     *
+     * @param {ClipboardEvent} event - The native copy event.
+     */
+    const onCopy = (event) => {
+      if (event.clipboardData) {
+        event.clipboardData.setData('text/html', htmlContent);
+        event.clipboardData.setData('text/plain', textContent);
+      }
+      event.preventDefault();
+    };
+    doc.addEventListener('copy', onCopy);
+    try {
+      return doc.execCommand('copy');
+    }
+    finally {
+      doc.removeEventListener('copy', onCopy);
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/copy/actions/copy-selected-content-action.js

@@ -0,0 +1,21 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+/**
+ * Action to extract the currently selected content (HTML and plain text) from the editor.
+ *
+ * The action is read-only: it does not mutate the content state. The handling strategy resolves
+ * the selected HTML and plain text and writes them directly to the clipboard.
+ *
+ * @example host.value.apply(new CopySelectedContentAction(selection, selectedNodes));
+ */
+export class CopySelectedContentAction extends ModifyContentAction {
+  constructor(selection, selectedNodes) {
+    super();
+    this.type = 'COPY_SELECTED_CONTENT_ACTION';
+    this.selection = null;
+    this.selectedNodes = [];
+    // The result of the copy operation, which may be a Promise if the clipboard write is asynchronous.
+    this.copyResult = null;
+    this.selection = selection;
+    this.selectedNodes = selectedNodes;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/copy/copy-extension.js

@@ -0,0 +1,20 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { RTECopyToolbarButtonRenderer } from './copy-toolbar-button-renderer';
+import { ActionHandleStrategyRegistry } from '../../dto/action-handle-strategies/action-handle-strategy-registry';
+import { VegaRTEContent } from '../../dto/content-state';
+import { CopySelectedContentStrategy } from './action-handler-strategies/copy-selected-content-strategy';
+/**
+ * Vega Rich Text Editor Copy Extension.
+ * Adds a toolbar button that copies the currently selected editor content to the clipboard.
+ */
+export class VegaRTECopyExtension extends VegaRTEExtension {
+  /** @inheritDoc */
+  prepareBeforeLoad(host) {
+    this.registerToolbarButtonRenderer(VegaRTECopyExtension.TOOLBAR_BUTTON_KEY, new RTECopyToolbarButtonRenderer(), host);
+  }
+}
+(() => {
+  ActionHandleStrategyRegistry.register('COPY_SELECTED_CONTENT_ACTION', VegaRTEContent.name, new CopySelectedContentStrategy());
+})();
+// The unique key for the copy toolbar button, used for registration and retrieval.
+VegaRTECopyExtension.TOOLBAR_BUTTON_KEY = 'copy';

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

@@ -0,0 +1,58 @@
+import { VegaInternalIconManager } from '../../../../helpers/icon/internal-icon-manager';
+import { VegaRTEToolbarButtonRenderer } from '../base-toolbar-button-renderer';
+import copyIcon from '../../../../global/icons/copy';
+import { methodPlaceholder } from 'vega-slimmer/core';
+import { CopySelectedContentAction } from './actions/copy-selected-content-action';
+/**
+ * Toolbar button renderer for the Copy extension.
+ * Renders a toolbar button that copies the currently selected editor text to the clipboard.
+ */
+export class RTECopyToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  /**
+   * Renders the copy toolbar button.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {VegaRTERenderResult} - The toolbar button render result.
+   */
+  render(h, editorContext) {
+    return this.renderButton(h, editorContext, {
+      icon: 'rte-copy',
+      tooltip: { text: 'Copy' },
+    });
+  }
+  /**
+   * Determines if the copy button should be disabled.
+   * Disabled when the editor is disabled or when no content is selected.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {boolean} - True if the button should be disabled.
+   */
+  isDisabled(editorContext) {
+    const context = this.getExtensionContext(editorContext.host);
+    return (!context || context.host.disabled || !context.getSelection() || context.getSelection().isCollapsed);
+  }
+  /**
+   * Handles the copy button click event.
+   * Dispatches a copy action through `host.value`; the action handler extracts the current selection
+   * and writes the resulting HTML and plain text content to the clipboard.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   */
+  handleButtonClick(editorContext) {
+    const context = this.getExtensionContext(editorContext.host);
+    if (context && context.host) {
+      context.host.value.apply(new CopySelectedContentAction(context.getSelection(), context.getSelectedNodes()));
+    }
+  }
+  /*istanbul ignore next*/
+  /**
+   * Handles dropdown click event. Not applicable for the copy button, so it's left empty.
+   */
+  handleDropdownClick() {
+    methodPlaceholder();
+  }
+}
+(() => {
+  VegaInternalIconManager.register({ 'rte-copy': copyIcon });
+})();

package/dist/collection/components/vega-rich-text-editor/extensions/cut/cut-extension.js

@@ -0,0 +1,15 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { RTECutToolbarButtonRenderer } from './cut-toolbar-button-renderer';
+/**
+ * Vega Rich Text Editor Cut Extension.
+ * Adds a toolbar button that copies the currently selected editor content to the clipboard
+ * and removes it from the editor.
+ */
+export class VegaRTECutExtension extends VegaRTEExtension {
+  /** @inheritDoc */
+  prepareBeforeLoad(host) {
+    this.registerToolbarButtonRenderer(VegaRTECutExtension.TOOLBAR_BUTTON_KEY, new RTECutToolbarButtonRenderer(), host);
+  }
+}
+// The unique key for the cut toolbar button, used for registration and retrieval.
+VegaRTECutExtension.TOOLBAR_BUTTON_KEY = 'cut';