@globalpayments/vega 2.91.0 → 2.93.0

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

@@ -24,7 +24,7 @@ export class VegaRTEHorizontalLineExtension extends VegaRTEExtension {
     // Register the renderer
     this.registerRenderer('horizontal-line', this.blockRenderer);
     // Register the toolbar button
-    this.registerToolbarButtonRenderer('horizontalLine', this.toolbarButtonRenderer);
+    this.registerToolbarButtonRenderer(VegaRTEHorizontalLineExtension.TOOLBAR_BUTTON_KEY, this.toolbarButtonRenderer);
     // Register HTML → DTO conversion strategy
     this.registerElementToBlockDTOClassStrategy(new HrToHorizontalLineBlockStrategy());
     // Register filter styles strategy for source edit round-trip
@@ -39,3 +39,4 @@ export class VegaRTEHorizontalLineExtension extends VegaRTEExtension {
   VegaRTEExtension.registerActionHandleStrategy(RTEImageBlock.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
   VegaRTEExtension.registerActionHandleStrategy(RTEHorizontalLineBlock.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
 })();
+VegaRTEHorizontalLineExtension.TOOLBAR_BUTTON_KEY = 'horizontalLine';

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

@@ -0,0 +1,34 @@
+import { VegaRTEExtension } from '../extension.abstract';
+/**
+ * Rich Text Editor extension that configures built-in image behavior.
+ */
+export class VegaRTEImageExtension extends VegaRTEExtension {
+  constructor(config = {}) {
+    super();
+    this.config = config;
+  }
+  /**
+   * Store config per host so both toolbar-image and inline-image editors
+   * can consistently read the extension settings.
+   *
+   * @param {HTMLElement} host - The host rich text editor element.
+   */
+  prepareBeforeLoad(host) {
+    VegaRTEImageExtension.configStore.set(host, this.config);
+  }
+  /**
+   * Remove config for the current host when the extension is destroyed.
+   */
+  destroyExtension() {
+    var _a;
+    if ((_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.host) {
+      VegaRTEImageExtension.configStore.delete(this.extensionContext.host);
+    }
+  }
+}
+/**
+ * Per-host config store. Declare as static readonly to isolate config per editor host.
+ *
+ * @type {RTEExtensionStateStore<VegaRTEImageExtensionConfig>}
+ */
+VegaRTEImageExtension.configStore = VegaRTEImageExtension.createStateStore();

package/dist/collection/components/vega-rich-text-editor/extensions/image/type.js

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

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

@@ -46,7 +46,7 @@ export class VegaRTELanguageExtension extends VegaRTEExtension {
    */
   prepareBeforeLoad(host) {
     this.languageToolbarButtonRenderer = new RTELanguageToolbarButtonRenderer(this.languageList, this.languageChangeCallBack, this.languageState.selectedLanguage);
-    this.registerToolbarButtonRenderer('languages', this.languageToolbarButtonRenderer, host);
+    this.registerToolbarButtonRenderer(VegaRTELanguageExtension.TOOLBAR_BUTTON_KEY, this.languageToolbarButtonRenderer, host);
   }
   /**
    * Initializes the language extension.
@@ -138,3 +138,4 @@ export class VegaRTELanguageExtension extends VegaRTEExtension {
     return result;
   }
 }
+VegaRTELanguageExtension.TOOLBAR_BUTTON_KEY = 'languages';

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

@@ -32,7 +32,7 @@ export class VegaRTELineHeightExtension extends VegaRTEExtension {
    */
   prepareBeforeLoad(host) {
     this.toolbarButtonRenderer = new RTELineHeightToolbarButtonRenderer(this.options);
-    this.registerToolbarButtonRenderer('lineHeight', this.toolbarButtonRenderer, host);
+    this.registerToolbarButtonRenderer(VegaRTELineHeightExtension.TOOLBAR_BUTTON_KEY, this.toolbarButtonRenderer, host);
   }
 }
 (() => {
@@ -42,3 +42,4 @@ export class VegaRTELineHeightExtension extends VegaRTEExtension {
     attachLineHeightFromJson(BlockClass);
   });
 })();
+VegaRTELineHeightExtension.TOOLBAR_BUTTON_KEY = 'lineHeight';

package/dist/collection/components/vega-rich-text-editor/extensions/paste/assets/paste.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="M80 96v16c0 17.7 14.3 32 32 32h60.8c16.6-28.7 47.6-48 83.2-48h62c-7.1-27.6-32.2-48-62-48H215.4C211.6 20.9 188.2 0 160 0s-51.6 20.9-55.4 48H64C28.7 48 0 76.7 0 112V384c0 35.3 28.7 64 64 64h96V400H64c-8.8 0-16-7.2-16-16V112c0-8.8 7.2-16 16-16H80zm64-40a16 16 0 1 1 32 0 16 16 0 1 1 -32 0zM256 464c-8.8 0-16-7.2-16-16V192c0-8.8 7.2-16 16-16H384v48c0 17.7 14.3 32 32 32h48V448c0 8.8-7.2 16-16 16H256zm192 48c35.3 0 64-28.7 64-64V227.9c0-12.7-5.1-24.9-14.1-33.9l-51.9-51.9c-9-9-21.2-14.1-33.9-14.1H256c-35.3 0-64 28.7-64 64V448c0 35.3 28.7 64 64 64H448z"/></svg>`,
+};

package/dist/collection/components/vega-rich-text-editor/extensions/paste/paste-chooser-ui.js

@@ -0,0 +1,144 @@
+import { VegaInternalIconManager } from '../../../../helpers/icon/internal-icon-manager';
+import { VegaInternalTranslation } from '../../../../helpers/translation/internal-translation-controller';
+import paste from './assets/paste';
+/**
+ * Renders and manages the paste format chooser UI.
+ */
+export class RTEPasteChooserUI {
+  constructor(hostRoot, callbacks) {
+    this.hostRoot = hostRoot;
+    this.callbacks = callbacks;
+    this.chooserEl = null;
+    this.dropdownEl = null;
+    this.triggerButtonEl = null;
+  }
+  /**
+   * Opens the paste-mode chooser at the given position.
+   *
+   * @param {PasteChooserPosition} position Viewport position for the chooser.
+   */
+  open(position) {
+    this.destroy();
+    const doc = this.hostRoot.ownerDocument;
+    const chooser = doc.createElement('div');
+    chooser.setAttribute(RTEPasteChooserUI.CHOOSER_ATTR, 'true');
+    chooser.style.position = 'fixed';
+    chooser.style.zIndex = '1000';
+    chooser.style.left = `${position.left}px`;
+    chooser.style.top = `${position.top}px`;
+    const dropdownEl = this.createPasteChooserDropdown(doc, position.placement);
+    dropdownEl.placement = position.placement;
+    chooser.append(dropdownEl);
+    this.hostRoot.appendChild(chooser);
+    this.chooserEl = chooser;
+    this.dropdownEl = dropdownEl;
+    dropdownEl.addEventListener('vegaShow', () => {
+      if (this.triggerButtonEl) {
+        this.triggerButtonEl.selected = true;
+      }
+    });
+    dropdownEl.addEventListener('vegaHide', () => {
+      if (this.triggerButtonEl) {
+        this.triggerButtonEl.selected = false;
+      }
+    });
+  }
+  /**
+   * Removes the chooser from the DOM.
+   */
+  destroy() {
+    var _a;
+    if (this.dropdownEl && typeof this.dropdownEl.hide === 'function') {
+      void this.dropdownEl.hide();
+    }
+    if ((_a = this.chooserEl) === null || _a === void 0 ? void 0 : _a.parentNode) {
+      this.chooserEl.parentNode.removeChild(this.chooserEl);
+    }
+    if (this.triggerButtonEl) {
+      this.triggerButtonEl.selected = false;
+    }
+    this.dropdownEl = null;
+    this.chooserEl = null;
+    this.triggerButtonEl = null;
+  }
+  /**
+   * Determines whether the given event path targets the chooser.
+   *
+   * @param {EventTarget[]} eventPath Composed path of an event.
+   * @returns {boolean} `true` when the path includes the chooser.
+   */
+  includesEventPath(eventPath) {
+    if (!this.chooserEl) {
+      return false;
+    }
+    const isDropdownContentClick = eventPath.some((target) => {
+      return 'tagName' in target && target.tagName === 'VEGA-DROPDOWN-CONTENT-BOX';
+    });
+    return eventPath.includes(this.chooserEl) || isDropdownContentClick;
+  }
+  /**
+   * Builds the dropdown element with the rich text paste option.
+   *
+   * @param {Document} doc Document used to create elements.
+   * @param {['bottom', 'top'] | ['top', 'bottom']} placement Preferred placement order.
+   * @returns {HTMLElement} Configured dropdown element.
+   */
+  createPasteChooserDropdown(doc, placement) {
+    const dropdownEl = doc.createElement('vega-dropdown');
+    dropdownEl.trigger = 'click';
+    dropdownEl.selectType = 'single';
+    dropdownEl.selectedSourceKey = 'rich';
+    dropdownEl.maxWidth = 220;
+    dropdownEl.alignment = 'start';
+    dropdownEl.itemDisplayRule = 'ellipsis';
+    const triggerButton = doc.createElement('vega-rich-text-editor-toolbar-button');
+    const arrowIcon = placement[0] === 'top' ? 'chevron-up' : 'chevron-down';
+    triggerButton.setAttribute(RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR, 'true');
+    triggerButton.setAttribute('aria-label', VegaInternalTranslation.t('Paste options'));
+    triggerButton.setAttribute('arrow-icon', arrowIcon);
+    triggerButton.icon = 'rte-paste';
+    triggerButton.showArrowIcon = true;
+    triggerButton.selected = false;
+    this.triggerButtonEl = triggerButton;
+    const tooltipEl = doc.createElement('vega-tooltip');
+    tooltipEl.text = VegaInternalTranslation.t('Paste options');
+    tooltipEl.placement = ['bottom', 'top'];
+    tooltipEl.append(triggerButton);
+    dropdownEl.append(tooltipEl);
+    const itemsContainer = doc.createElement('div');
+    itemsContainer.setAttribute('slot', 'items');
+    itemsContainer.append(this.createDropdownItem(doc, 'rich', VegaInternalTranslation.t('Use rich text'), RTEPasteChooserUI.CHOOSER_RICH_ATTR));
+    dropdownEl.append(itemsContainer);
+    dropdownEl.addEventListener('vegaDropdownClick', (event) => {
+      const mode = event.detail;
+      if (mode === 'rich') {
+        this.callbacks.onModeSelect(mode);
+      }
+    });
+    return dropdownEl;
+  }
+  /**
+   * Creates a single dropdown item element for a paste mode.
+   *
+   * @param {Document} doc Document used to create the element.
+   * @param {PasteMode} key Paste mode key for the item.
+   * @param {string} label Display label for the item.
+   * @param {string} dataAttrName Data attribute marker for the item.
+   * @returns {HTMLVegaDropdownItemElement} Configured dropdown item element.
+   */
+  createDropdownItem(doc, key, label, dataAttrName) {
+    const itemEl = doc.createElement('vega-dropdown-item');
+    itemEl.itemKey = key;
+    itemEl.label = label;
+    itemEl.setAttribute(dataAttrName, 'true');
+    return itemEl;
+  }
+}
+(() => {
+  VegaInternalIconManager.register({
+    'rte-paste': paste,
+  });
+})();
+RTEPasteChooserUI.CHOOSER_ATTR = 'data-rte-paste-chooser';
+RTEPasteChooserUI.CHOOSER_RICH_ATTR = 'data-rte-paste-type-rich';
+RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR = 'data-rte-paste-trigger';

package/dist/collection/components/vega-rich-text-editor/extensions/paste/paste-constants.js

@@ -0,0 +1,6 @@
+/**
+ * Custom DataTransfer MIME type used to tag a synthetic paste with the chosen
+ * paste mode (e.g. 'rich' or 'plain'), so downstream paste handling can decide
+ * whether to preserve the original inline styles.
+ */
+export const RTE_PASTE_MODE_DATA_TYPE = 'application/x-vega-rte-paste-mode';

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

@@ -0,0 +1,442 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { RTEPasteChooserUI } from './paste-chooser-ui';
+import { RTE_PASTE_MODE_DATA_TYPE } from './paste-constants';
+/**
+ * Vega Rich Text Editor paste extension.
+ * Intercepts keyboard paste and allows users to choose paste mode.
+ */
+export class VegaRTEPasteExtension extends VegaRTEExtension {
+  constructor() {
+    super(...arguments);
+    this.editableEl = null;
+    this.contentHostEl = null;
+    this.chooserUI = null;
+    this.pendingPastePayload = null;
+    this.listenerDocument = null;
+    this.listenerWindow = null;
+    /**
+     * Handles a native paste event by capturing the clipboard payload and
+     * rendering the paste-mode chooser.
+     *
+     * @param {ClipboardEvent} event Native clipboard paste event.
+     */
+    this.handlePasteEvent = (event) => {
+      var _a, _b;
+      const clipboardData = event.clipboardData;
+      if (!clipboardData) {
+        return;
+      }
+      // HTML is sanitized via DOMParser and ElementToDtoStrategyProcessor pipeline
+      const html = clipboardData.getData('text/html') || '';
+      const text = clipboardData.getData('text/plain') || '';
+      if (!html && !text) {
+        // Empty clipboard paste should not mutate editor content.
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      const range = this.cloneCurrentSelectionRange();
+      const selectedNodes = ((_b = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelectedNodes) === null || _b === void 0 ? void 0 : _b.call(_a)) || [];
+      this.pendingPastePayload = { html, text, range, selectedNodes: [...selectedNodes] };
+      this.renderPasteChooser(event);
+    };
+    /**
+     * Dismisses the chooser when a pointer interaction occurs outside of it.
+     *
+     * @param {Event} event Pointer event captured on the document.
+     */
+    this.handleOutsidePointerDown = (event) => {
+      if (!this.chooserUI) {
+        return;
+      }
+      const eventPath = typeof event.composedPath === 'function' ? event.composedPath() : [];
+      if (this.chooserUI.includesEventPath(eventPath)) {
+        return;
+      }
+      this.clearPasteChooser();
+    };
+    /**
+     * Dismisses the chooser when the Escape key is pressed.
+     *
+     * @param {KeyboardEvent} event Keyboard event captured on the document.
+     */
+    this.handleOutsideKeyDown = (event) => {
+      if (event.key === 'Escape') {
+        this.clearPasteChooser();
+      }
+    };
+    /**
+     * Dismisses the chooser when any relevant scroll container scrolls.
+     */
+    this.handleOutsideScroll = () => {
+      this.clearPasteChooser();
+    };
+  }
+  /** @inheritDoc */
+  initialExtensionAfterLoad(context) {
+    super.initialExtensionAfterLoad(context);
+    this.hostEl = context.host;
+    this.attachPasteListener();
+  }
+  /** @inheritDoc */
+  destroyExtension() {
+    this.detachPasteListener();
+    this.clearPasteChooser();
+  }
+  /**
+   * Attaches the paste listener to the editable element.
+   */
+  attachPasteListener() {
+    const { editableEl, contentHostEl, } = this.getEditorElements();
+    this.editableEl = editableEl;
+    this.contentHostEl = contentHostEl;
+    if (this.editableEl) {
+      this.editableEl.addEventListener('paste', this.handlePasteEvent);
+    }
+  }
+  /**
+   * Detaches the paste listener from the editable element.
+   */
+  detachPasteListener() {
+    if (this.editableEl) {
+      this.editableEl.removeEventListener('paste', this.handlePasteEvent);
+    }
+    this.editableEl = null;
+    this.contentHostEl = null;
+  }
+  /**
+   * Resolves the content host and editable element from the host shadow tree.
+   *
+   * @returns {EditorElements} Editor elements.
+   */
+  getEditorElements() {
+    var _a, _b, _c, _d, _e;
+    const contentHostEl = (_c = (_b = (_a = this.hostEl) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('vega-rich-text-content')) !== null && _c !== void 0 ? _c : null;
+    const editableEl = (_e = (_d = contentHostEl === null || contentHostEl === void 0 ? void 0 : contentHostEl.shadowRoot) === null || _d === void 0 ? void 0 : _d.querySelector('.rich-text-content')) !== null && _e !== void 0 ? _e : null;
+    return { editableEl, contentHostEl };
+  }
+  /**
+   * Resolves the editable content element from the host shadow tree.
+   *
+   * @returns {HTMLDivElement | null} Editable element or `null` when unavailable.
+   */
+  getEditableElement() {
+    const { editableEl } = this.getEditorElements();
+    return editableEl;
+  }
+  /**
+   * Clones the current selection range so it can be restored after the user
+   * chooses a paste mode.
+   *
+   * @returns {Range | null} Cloned range or `null` when there is no selection.
+   */
+  cloneCurrentSelectionRange() {
+    var _a;
+    const selection = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelection();
+    if (selection && selection.rangeCount > 0) {
+      return selection.getRangeAt(0).cloneRange();
+    }
+    return null;
+  }
+  /**
+   * Renders the paste-mode chooser and wires up dismissal listeners.
+   *
+   * @param {ClipboardEvent} pasteEvent Originating paste event used for positioning.
+   */
+  renderPasteChooser(pasteEvent) {
+    var _a, _b;
+    const hostRoot = (_b = (_a = this.hostEl) === null || _a === void 0 ? void 0 : _a.shadowRoot) !== null && _b !== void 0 ? _b : null;
+    if (!hostRoot) {
+      return;
+    }
+    this.clearPasteChooser(false);
+    const position = this.computeChooserPosition(pasteEvent);
+    this.chooserUI = new RTEPasteChooserUI(hostRoot, {
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      onModeSelect: (mode) => {
+        this.applyPasteMode(mode);
+      },
+    });
+    this.chooserUI.open(position);
+    this.listenerDocument = this.hostEl.ownerDocument;
+    this.listenerWindow = this.listenerDocument.defaultView;
+    this.listenerDocument.addEventListener('mousedown', this.handleOutsidePointerDown, true);
+    this.listenerDocument.addEventListener('keydown', this.handleOutsideKeyDown, true);
+    this.listenerDocument.addEventListener('scroll', this.handleOutsideScroll, true);
+    if (this.listenerWindow) {
+      this.listenerWindow.addEventListener('scroll', this.handleOutsideScroll, true);
+    }
+    if (this.contentHostEl) {
+      this.contentHostEl.addEventListener('scroll', this.handleOutsideScroll);
+    }
+  }
+  /**
+   * Computes the on-screen position for the chooser based on pointer or caret.
+   *
+   * @param {ClipboardEvent} event Originating paste event.
+   * @returns {ChooserPosition} Position in viewport coordinates.
+   */
+  computeChooserPosition(event) {
+    var _a, _b, _c;
+    const hostRect = this.hostEl.getBoundingClientRect();
+    const viewportHeight = (_b = (_a = this.hostEl.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.innerHeight) !== null && _b !== void 0 ? _b : window.innerHeight;
+    const pointerEvent = event;
+    const hasPointer = typeof pointerEvent.clientX === 'number' &&
+      pointerEvent.clientX > 0 &&
+      typeof pointerEvent.clientY === 'number' &&
+      pointerEvent.clientY > 0;
+    // For keyboard-initiated paste (Command/Control+V) clientX/Y are 0, so anchor
+    // the chooser to the current caret instead of a fixed host-relative spot.
+    const caretRect = hasPointer ? null : this.getCaretRect();
+    const CHOOSER_GAP_PX = 8;
+    const CHOOSER_MIN_MARGIN_PX = 12;
+    const CHOOSER_WIDTH_PX = 220;
+    const CHOOSER_FALLBACK_OFFSET_PX = 40;
+    const CHOOSER_MIN_VISIBLE_BELOW_SPACE_PX = 88;
+    const baseLeft = hasPointer
+      ? pointerEvent.clientX
+      : (_c = caretRect === null || caretRect === void 0 ? void 0 : caretRect.left) !== null && _c !== void 0 ? _c : hostRect.left + CHOOSER_MIN_MARGIN_PX;
+    const baseTop = hasPointer
+      ? pointerEvent.clientY
+      : caretRect
+        ? caretRect.bottom
+        : hostRect.top + CHOOSER_FALLBACK_OFFSET_PX;
+    const maxLeft = Math.max(hostRect.left + CHOOSER_MIN_MARGIN_PX, hostRect.right - CHOOSER_WIDTH_PX);
+    const left = Math.min(Math.max(baseLeft, hostRect.left + CHOOSER_MIN_MARGIN_PX), maxLeft);
+    const top = Math.max(baseTop + CHOOSER_GAP_PX, hostRect.top + CHOOSER_MIN_MARGIN_PX);
+    const availableBelow = viewportHeight - top - CHOOSER_MIN_MARGIN_PX;
+    const availableAbove = top - CHOOSER_MIN_MARGIN_PX;
+    const placement = availableBelow >= CHOOSER_MIN_VISIBLE_BELOW_SPACE_PX || availableBelow >= availableAbove
+      ? ['bottom', 'top']
+      : ['top', 'bottom'];
+    return { left, top, placement };
+  }
+  /**
+   * Resolves the bounding rect of the pending caret position.
+   *
+   * @returns {DOMRect | null} Caret rect or `null` when it cannot be determined.
+   */
+  getCaretRect() {
+    var _a, _b;
+    const range = (_b = (_a = this.pendingPastePayload) === null || _a === void 0 ? void 0 : _a.range) !== null && _b !== void 0 ? _b : this.cloneCurrentSelectionRange();
+    if (!range) {
+      return null;
+    }
+    const rect = range.getBoundingClientRect();
+    if (this.isUnavailableRect(rect)) {
+      // eslint-disable-next-line spellcheck/spell-checker
+      const domRectList = range.getClientRects();
+      if (domRectList.length > 0) {
+        return domRectList[0];
+      }
+      return this.getRangeContainerRect(range);
+    }
+    return rect;
+  }
+  /**
+   * Returns whether the browser could not resolve a meaningful caret rectangle.
+   *
+   * @param {DOMRect} rect Candidate caret rect.
+   * @returns {boolean} Whether the rect is unusable.
+   */
+  isUnavailableRect(rect) {
+    return rect.width === 0 && rect.height === 0 && rect.left === 0 && rect.top === 0;
+  }
+  /**
+   * Falls back to the range container or neighbor child node bounds.
+   *
+   * @param {Range} range Caret/selection range.
+   * @returns {DOMRect | null} Best-effort caret anchor rectangle.
+   */
+  getRangeContainerRect(range) {
+    var _a, _b, _c, _d, _e, _f;
+    const containerNode = (_a = range.startContainer) !== null && _a !== void 0 ? _a : null;
+    if (!containerNode) {
+      return null;
+    }
+    if (containerNode.nodeType === Node.ELEMENT_NODE) {
+      const containerElement = containerNode;
+      const previousNode = (_b = containerElement.childNodes[range.startOffset - 1]) !== null && _b !== void 0 ? _b : null;
+      const currentNode = (_c = containerElement.childNodes[range.startOffset]) !== null && _c !== void 0 ? _c : null;
+      return ((_e = (_d = this.getNodeRect(previousNode)) !== null && _d !== void 0 ? _d : this.getNodeRect(currentNode)) !== null && _e !== void 0 ? _e : this.getNodeRect(containerElement));
+    }
+    return (_f = this.getNodeRect(containerNode)) !== null && _f !== void 0 ? _f : this.getNodeRect(containerNode.parentNode);
+  }
+  /**
+   * Returns an element-backed rectangle from a DOM node.
+   *
+   * @param {Node | null} node Candidate node.
+   * @returns {DOMRect | null} Node rectangle when resolvable.
+   */
+  getNodeRect(node) {
+    var _a, _b;
+    if (!node) {
+      return null;
+    }
+    if (node.nodeType === Node.TEXT_NODE) {
+      return (_b = (_a = node.parentElement) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect()) !== null && _b !== void 0 ? _b : null;
+    }
+    if (node.nodeType === Node.ELEMENT_NODE) {
+      const rect = node.getBoundingClientRect();
+      return this.isUnavailableRect(rect) ? null : rect;
+    }
+    return null;
+  }
+  /**
+   * Applies the chosen paste mode by dispatching a synthetic paste input event.
+   *
+   * @param {PasteMode} mode Selected paste mode.
+   */
+  applyPasteMode(mode) {
+    var _a;
+    if (!this.pendingPastePayload) {
+      this.clearPasteChooser();
+      return;
+    }
+    const editableEl = (_a = this.editableEl) !== null && _a !== void 0 ? _a : this.getEditableElement();
+    if (!editableEl) {
+      this.clearPasteChooser();
+      return;
+    }
+    editableEl.focus();
+    this.restoreSelectionRange(this.pendingPastePayload.range);
+    this.restoreSelectionControllerState(this.pendingPastePayload);
+    const dataTransfer = this.createDataTransfer(this.pendingPastePayload.html, this.pendingPastePayload.text, mode);
+    this.dispatchBeforeInputPaste(editableEl, dataTransfer);
+    this.clearPasteChooser();
+  }
+  /**
+   * Restores SelectionController state from the captured selection so synthetic
+   * beforeinput paste can replace the selected content instead of appending.
+   *
+   * @param {PendingPastePayload} payload Pending paste payload.
+   */
+  restoreSelectionControllerState(payload) {
+    if (!payload.range || !this.extensionContext) {
+      return;
+    }
+    const rangeOptions = {
+      startNode: payload.range.startContainer,
+      endNode: payload.range.endContainer,
+      startOffset: payload.range.startOffset,
+      endOffset: payload.range.endOffset,
+    };
+    this.extensionContext.setSelectedNodes(payload.selectedNodes || [], rangeOptions);
+  }
+  /**
+   * Restores a previously cloned selection range.
+   *
+   * @param {Range | null} range Range to restore.
+   */
+  restoreSelectionRange(range) {
+    var _a;
+    if (!range) {
+      return;
+    }
+    const selection = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelection();
+    if (selection) {
+      selection.removeAllRanges();
+      selection.addRange(range);
+    }
+  }
+  /**
+   * Dispatches a synthetic `beforeinput` paste event into the editor pipeline.
+   *
+   * @param {HTMLDivElement} editableEl Editable content element.
+   * @param {DataTransfer} dataTransfer Clipboard payload for the paste.
+   */
+  dispatchBeforeInputPaste(editableEl, dataTransfer) {
+    // This synthetic beforeinput event intentionally reuses the existing
+    // UserInputController -> insertFromPaste -> InsertPasteHandler pipeline.
+    const beforeInputEvent = new CustomEvent('beforeinput', {
+      bubbles: true,
+      cancelable: true,
+    });
+    try {
+      Object.defineProperties(beforeInputEvent, {
+        inputType: {
+          value: 'insertFromPaste',
+          configurable: true,
+        },
+        dataTransfer: {
+          value: dataTransfer,
+          configurable: true,
+        },
+      });
+    }
+    catch (_a) {
+      Object.assign(beforeInputEvent, {
+        inputType: 'insertFromPaste',
+        dataTransfer,
+      });
+    }
+    editableEl.dispatchEvent(beforeInputEvent);
+  }
+  /**
+   * Builds a `DataTransfer` payload carrying the paste content and mode marker.
+   *
+   * @param {string} html HTML clipboard content.
+   * @param {string} text Plain text clipboard content.
+   * @param {PasteMode} [mode] Selected paste mode marker.
+   * @returns {DataTransfer} Populated data transfer payload.
+   */
+  createDataTransfer(html, text, mode) {
+    if (typeof DataTransfer !== 'undefined') {
+      const dataTransfer = new DataTransfer();
+      if (html) {
+        dataTransfer.setData('text/html', html);
+      }
+      if (text) {
+        dataTransfer.setData('text/plain', text);
+      }
+      if (mode) {
+        dataTransfer.setData(RTE_PASTE_MODE_DATA_TYPE, mode);
+      }
+      return dataTransfer;
+    }
+    return {
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      getData: (type) => {
+        if (type === 'text/html') {
+          return html;
+        }
+        if (type === 'text/plain') {
+          return text;
+        }
+        if (type === RTE_PASTE_MODE_DATA_TYPE) {
+          return mode !== null && mode !== void 0 ? mode : '';
+        }
+        return '';
+      },
+    };
+  }
+  /**
+   * Tears down the chooser UI and removes dismissal listeners.
+   *
+   * @param {boolean} [clearPayload] Whether to also clear the pending payload.
+   */
+  clearPasteChooser(clearPayload = true) {
+    if (this.contentHostEl) {
+      this.contentHostEl.removeEventListener('scroll', this.handleOutsideScroll);
+    }
+    if (this.listenerWindow) {
+      this.listenerWindow.removeEventListener('scroll', this.handleOutsideScroll, true);
+      this.listenerWindow = null;
+    }
+    if (this.listenerDocument) {
+      this.listenerDocument.removeEventListener('mousedown', this.handleOutsidePointerDown, true);
+      this.listenerDocument.removeEventListener('keydown', this.handleOutsideKeyDown, true);
+      this.listenerDocument.removeEventListener('scroll', this.handleOutsideScroll, true);
+      this.listenerDocument = null;
+    }
+    if (this.chooserUI) {
+      this.chooserUI.destroy();
+    }
+    this.chooserUI = null;
+    if (clearPayload) {
+      this.pendingPastePayload = null;
+    }
+  }
+}