@heartlandone/vega 2.102.0 → 2.103.0

package/dist/cjs/{token-extension-86723cad.js → token-extension-72d0cb08.js}

@@ -8,16 +8,16 @@ const internalVegaZIndexManager = require('./internal-vega-z-index-manager-f03dd
 const dynamicSlimmer = require('./dynamic-slimmer-f31fdfd7.js');
 const pageResizeObserverSlimmer = require('./page-resize-observer-slimmer-273d62ef.js');
 const internalVegaEventManager = require('./internal-vega-event-manager-0c256d63.js');
-const internalTranslationController = require('./internal-translation-controller-eae8a8de.js');
-const internalCalendarPeriodFactory = require('./internal-calendar-period-factory-3c5236be.js');
-const codeBlock = require('./code-block-06e6591f.js');
-const contentState = require('./content-state-8c862e5e.js');
-const linkExtension = require('./link-extension-2a6133b7.js');
+const internalTranslationController = require('./internal-translation-controller-0d67ca4d.js');
+const internalCalendarPeriodFactory = require('./internal-calendar-period-factory-c3198ea7.js');
+const codeBlock = require('./code-block-72de6c4d.js');
+const contentState = require('./content-state-ff40bdc6.js');
+const linkExtension = require('./link-extension-1b4ed437.js');
 const internalIconManager = require('./internal-icon-manager-b9702049.js');
-const typeGuard = require('./type-guard-29e01bd4.js');
+const typeGuard = require('./type-guard-cce6fe1f.js');
 const vegaNonceManager = require('./vega-nonce-manager-df69d3ed.js');
-const imageExtension = require('./image-extension-1cf84f27.js');
-const splitCellOperation = require('./split-cell-operation-28f6f8d9.js');
+const imageExtension = require('./image-extension-6a92c524.js');
+const splitCellOperation = require('./split-cell-operation-afc82323.js');
 const changeManager = require('./change-manager-a297e4d2.js');
 const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-c82df135.js');
 const vegaInternalEventId = require('./vega-internal-event-id-98d499d7.js');
@@ -1630,6 +1630,154 @@ const FUNCTION_ELEMENT_CLASSES = [
   FUNCTION_SYNTAX_CLASS,
 ];
 
+/**
+ * Class representing a logic control node in the rich text editor.
+ */
+class RTELogicControlNode extends codeBlock.RTENode {
+  constructor(id, text, parent) {
+    super(id);
+    this.type = 'logic-control-node';
+    this.text = '';
+    this.text = text;
+    this.parent = parent;
+  }
+  /**
+   * Clone the current node instance.
+   *
+   * @returns {RTELogicControlNode} - A new instance of RTELogicControlNode.
+   */
+  clone() {
+    return new RTELogicControlNode(this.id, this.text, this.parent);
+  }
+  /**
+   * Convert the node to its HTML representation.
+   *
+   * @returns {string} - The HTML string of the logic control node.
+   */
+  toHtml() {
+    return this.text;
+  }
+  /**
+   * Convert the node to a JSON representation.
+   *
+   * @returns {unknown} - The JSON object of the statement syntax node.
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      type: this.type,
+      text: this.text,
+    };
+  }
+  /**
+   * Get the end offset of the node's range.
+   *
+   * @returns {number} - The end offset of the node's range.
+   */
+  getRangeEndOffset() {
+    return 1;
+  }
+  /**
+   * Get the container element for the node's range.
+   *
+   * @returns {Nullable<Node>} - The container node for the range.
+   */
+  getRangeContainer() {
+    const element = codeBlock.stateEntityRenderingRegistry.getDOMByEntity(this);
+    if (element) {
+      return element.parentElement;
+    }
+  }
+  /**
+   * Get the content editable state of the node.
+   *
+   * @returns {boolean} - The content editable state of the node.
+   */
+  isContentEditable() {
+    return false;
+  }
+  /**
+   * @inheritDoc
+   */
+  getPlainText() {
+    return this.text;
+  }
+}
+RTELogicControlNode.typeName = 'RTELogicControlNode';
+
+/**
+ * Class representing a logic control block in the rich text editor.
+ */
+class RTELogicControlBlock extends codeBlock.RTEBlock {
+  constructor(id, statementText, parent) {
+    super(id);
+    this.type = 'logic-control-block';
+    this.children = [];
+    this.statementText = '';
+    this.statementText = statementText;
+    this.children = [new RTELogicControlNode(`${id}-node-1`, statementText, this)];
+    if (parent) {
+      this.parent = parent;
+    }
+  }
+  /**
+   * Create a logic control block from a JSON representation.
+   *
+   * @param {VegaRTELogicControlBlock} json - The JSON object representing the logic control block.
+   * @returns {RTELogicControlBlock} - The created logic control block.
+   */
+  static from(json) {
+    const block = new RTELogicControlBlock(json.id, json.statementText);
+    return block;
+  }
+  /**
+   * Check the block is not empty.
+   *
+   * @returns {boolean} - Always true for logic control block.
+   */
+  isNotEmpty() {
+    return true;
+  }
+  /**
+   * Get the last node of the block.
+   *
+   * @returns {RTELogicControlNode} - The last node in the block.
+   */
+  getLastNode() {
+    return this.children[this.children.length - 1];
+  }
+  /**
+   * Convert the block to its HTML representation.
+   *
+   * @returns {string} - The HTML string of the logic control block.
+   */
+  toHtml() {
+    return `<div class='${FUNCTION_SYNTAX_CLASS}' contenteditable='false'>${this.statementText}</div>`;
+  }
+  /**
+   * Clone the current block instance.
+   *
+   * @param { RTEFunctionBlock } parent - The parent function block for the cloned instance.
+   * @returns {RTELogicControlBlock} - A new instance of RTEStatementSyntaxBlock.
+   */
+  clone(parent) {
+    return new RTELogicControlBlock(this.id, this.statementText, parent);
+  }
+  /**
+   * Get the JSON representation of the block.
+   *
+   * @returns {VegaRTELogicControlBlock} - The JSON object of the logic control block.
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      type: this.type,
+      statementText: this.statementText,
+    };
+  }
+}
+RTELogicControlBlock.typeName = 'RTELogicControlBlock';
+
 /**
  * RTE Function Block
  */
@@ -1654,8 +1802,36 @@ class RTEFunctionBlock extends codeBlock.RTEBlock {
       ? Object.assign(Object.assign({}, annotations), defaultAnnotation) : defaultAnnotation;
     super.convertAnnotationsToMap(functionBlock.annotationMap, annotations);
     functionBlock.children = this.generateBlockChildren(block.children, options, functionBlock);
+    this.unwrapForeachContent(functionBlock.children);
     return functionBlock;
   }
+  /**
+   * Removes a redundant div wrapper from FOREACH content so it is rendered inline
+   * with the FOREACH control. SHOW content retains its wrapper to preserve line breaks.
+   *
+   * @param {RTEFunctionBlockChild[]} children - The function block children to normalize.
+   */
+  static unwrapForeachContent(children) {
+    children.forEach((logicControlBlock, index) => {
+      const contentBlock = children[index + 1];
+      if (!(logicControlBlock instanceof RTELogicControlBlock) ||
+        logicControlBlock.statementText !== 'FOREACH' ||
+        !(contentBlock instanceof codeBlock.RTETextBlock)) {
+        return;
+      }
+      contentBlock.children.forEach((node) => {
+        const inlineHtml = node.getAnnotationByType(codeBlock.NodeAnnotationTypeEnum.INLINE_HTML);
+        if ((inlineHtml === null || inlineHtml === void 0 ? void 0 : inlineHtml.htmlTag) !== 'div')
+          return;
+        if (inlineHtml.child) {
+          node.annotationMap.set(codeBlock.NodeAnnotationTypeEnum.INLINE_HTML, inlineHtml.child);
+        }
+        else {
+          node.annotationMap.delete(codeBlock.NodeAnnotationTypeEnum.INLINE_HTML);
+        }
+      });
+    });
+  }
   /**
    * Converts the RTEFunctionBlock and its children to an HTML string.
    *
@@ -1829,218 +2005,70 @@ class InsertFunctionBlockStrategy extends codeBlock.ActionHandleStrategy {
 }
 
 /**
- * Class representing a logic control node in the rich text editor.
+ * Function toolbar button renderer class.
  */
-class RTELogicControlNode extends codeBlock.RTENode {
-  constructor(id, text, parent) {
-    super(id);
-    this.type = 'logic-control-node';
-    this.text = '';
-    this.text = text;
-    this.parent = parent;
-  }
-  /**
-   * Clone the current node instance.
-   *
-   * @returns {RTELogicControlNode} - A new instance of RTELogicControlNode.
-   */
-  clone() {
-    return new RTELogicControlNode(this.id, this.text, this.parent);
-  }
+class FunctionToolbarButtonRenderer extends imageExtension.VegaRTEToolbarButtonRenderer {
   /**
-   * Convert the node to its HTML representation.
-   *
-   * @returns {string} - The HTML string of the logic control node.
+   * @inheritDoc
    */
-  toHtml() {
-    return this.text;
+  render(h, editorContext) {
+    return this.renderDropdown(h, editorContext, {}, [
+      this.renderButton(h, editorContext, {
+        label: 'Functions',
+        ariaLabel: 'Functions',
+        showArrowIcon: true,
+        tooltip: { text: 'Insert function' },
+      }),
+      this.renderDropdownListTemplate(h, FunctionToolbarButtonRenderer.FUNCTION_LIST, editorContext),
+    ]);
   }
   /**
-   * Convert the node to a JSON representation.
+   * Overrides the isDisabled method to determine if the button should be disabled.
    *
-   * @returns {unknown} - The JSON object of the statement syntax node.
+   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
+   * @returns {boolean} - true if the button should be disabled, false otherwise.
    */
-  toJSON() {
-    return {
-      id: this.id,
-      type: this.type,
-      text: this.text,
-    };
+  isDisabled(editorContext) {
+    const context = this.getExtensionContext(editorContext.host);
+    if (context) {
+      const { host, getSelectedNodes } = context;
+      const focusNode = getSelectedNodes()[0];
+      let enableInsert = true;
+      if (focusNode) {
+        enableInsert = codeBlock.ActionHandleStrategyRegistry.canHandle(INSERT_FUNCTION_BLOCK, focusNode.parent);
+      }
+      return host.disabled || !enableInsert;
+    }
+    return false;
   }
-  /**
-   * Get the end offset of the node's range.
-   *
-   * @returns {number} - The end offset of the node's range.
-   */
-  getRangeEndOffset() {
-    return 1;
+  /* istanbul ignore next */
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  handleButtonClick() {
+    throw new Error('Method not implemented.');
   }
   /**
-   * Get the container element for the node's range.
+   * Handles dropdown click event
    *
-   * @returns {Nullable<Node>} - The container node for the range.
+   * @param {RTEExtensionFunctionType} itemKey - key of the clicked item
+   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
    */
-  getRangeContainer() {
-    const element = codeBlock.stateEntityRenderingRegistry.getDOMByEntity(this);
-    if (element) {
-      return element.parentElement;
-    }
-  }
-  /**
-   * Get the content editable state of the node.
-   *
-   * @returns {boolean} - The content editable state of the node.
-   */
-  isContentEditable() {
-    return false;
-  }
-  /**
-   * @inheritDoc
-   */
-  getPlainText() {
-    return this.text;
-  }
-}
-RTELogicControlNode.typeName = 'RTELogicControlNode';
-
-/**
- * Class representing a logic control block in the rich text editor.
- */
-class RTELogicControlBlock extends codeBlock.RTEBlock {
-  constructor(id, statementText, parent) {
-    super(id);
-    this.type = 'logic-control-block';
-    this.children = [];
-    this.statementText = '';
-    this.statementText = statementText;
-    this.children = [new RTELogicControlNode(`${id}-node-1`, statementText, this)];
-    if (parent) {
-      this.parent = parent;
-    }
-  }
-  /**
-   * Create a logic control block from a JSON representation.
-   *
-   * @param {VegaRTELogicControlBlock} json - The JSON object representing the logic control block.
-   * @returns {RTELogicControlBlock} - The created logic control block.
-   */
-  static from(json) {
-    const block = new RTELogicControlBlock(json.id, json.statementText);
-    return block;
-  }
-  /**
-   * Check the block is not empty.
-   *
-   * @returns {boolean} - Always true for logic control block.
-   */
-  isNotEmpty() {
-    return true;
-  }
-  /**
-   * Get the last node of the block.
-   *
-   * @returns {RTELogicControlNode} - The last node in the block.
-   */
-  getLastNode() {
-    return this.children[this.children.length - 1];
-  }
-  /**
-   * Convert the block to its HTML representation.
-   *
-   * @returns {string} - The HTML string of the logic control block.
-   */
-  toHtml() {
-    return `<div class='${FUNCTION_SYNTAX_CLASS}' contenteditable='false'>${this.statementText}</div>`;
-  }
-  /**
-   * Clone the current block instance.
-   *
-   * @param { RTEFunctionBlock } parent - The parent function block for the cloned instance.
-   * @returns {RTELogicControlBlock} - A new instance of RTEStatementSyntaxBlock.
-   */
-  clone(parent) {
-    return new RTELogicControlBlock(this.id, this.statementText, parent);
-  }
-  /**
-   * Get the JSON representation of the block.
-   *
-   * @returns {VegaRTELogicControlBlock} - The JSON object of the logic control block.
-   */
-  toJSON() {
-    return {
-      id: this.id,
-      type: this.type,
-      statementText: this.statementText,
-    };
-  }
-}
-RTELogicControlBlock.typeName = 'RTELogicControlBlock';
-
-/**
- * Function toolbar button renderer class.
- */
-class FunctionToolbarButtonRenderer extends imageExtension.VegaRTEToolbarButtonRenderer {
-  /**
-   * @inheritDoc
-   */
-  render(h, editorContext) {
-    return this.renderDropdown(h, editorContext, {}, [
-      this.renderButton(h, editorContext, {
-        label: 'Functions',
-        ariaLabel: 'Functions',
-        showArrowIcon: true,
-        tooltip: { text: 'Insert function' },
-      }),
-      this.renderDropdownListTemplate(h, FunctionToolbarButtonRenderer.FUNCTION_LIST, editorContext),
-    ]);
-  }
-  /**
-   * Overrides the isDisabled method to determine if the button should be disabled.
-   *
-   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
-   * @returns {boolean} - true if the button should be disabled, false otherwise.
-   */
-  isDisabled(editorContext) {
-    const context = this.getExtensionContext(editorContext.host);
-    if (context) {
-      const { host, getSelectedNodes } = context;
-      const focusNode = getSelectedNodes()[0];
-      let enableInsert = true;
-      if (focusNode) {
-        enableInsert = codeBlock.ActionHandleStrategyRegistry.canHandle(INSERT_FUNCTION_BLOCK, focusNode.parent);
-      }
-      return host.disabled || !enableInsert;
-    }
-    return false;
-  }
-  /* istanbul ignore next */
-  // eslint-disable-next-line jsdoc/require-jsdoc
-  handleButtonClick() {
-    throw new Error('Method not implemented.');
-  }
-  /**
-   * Handles dropdown click event
-   *
-   * @param {RTEExtensionFunctionType} itemKey - key of the clicked item
-   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
-   */
-  handleDropdownClick(itemKey, editorContext) {
-    if (editorContext) {
-      const context = this.getExtensionContext(editorContext.host);
-      if (context) {
-        const { host, getSelectedNodes } = context;
-        const focusNode = getSelectedNodes()[0];
-        const action = new InsertFunctionBlockAction(itemKey);
-        if (!focusNode) {
-          host.value.apply(action);
-        }
-        else if (focusNode.parent) {
-          focusNode.parent.apply(action);
-        }
-        if (action.nextFocusNode) {
-          host.value.apply(new contentState.UpdateCursorPositionAction(action.nextFocusNode, 1));
-        }
-      }
+  handleDropdownClick(itemKey, editorContext) {
+    if (editorContext) {
+      const context = this.getExtensionContext(editorContext.host);
+      if (context) {
+        const { host, getSelectedNodes } = context;
+        const focusNode = getSelectedNodes()[0];
+        const action = new InsertFunctionBlockAction(itemKey);
+        if (!focusNode) {
+          host.value.apply(action);
+        }
+        else if (focusNode.parent) {
+          focusNode.parent.apply(action);
+        }
+        if (action.nextFocusNode) {
+          host.value.apply(new contentState.UpdateCursorPositionAction(action.nextFocusNode, 1));
+        }
+      }
     }
   }
 }
@@ -2194,6 +2222,7 @@ class DivToFunctionBlockStrategy extends contentState.ElementToDTOStrategy {
    * @inheritDoc
    */
   appendChildBlocks(currentBlock, childBlocks) {
+    RTEFunctionBlock.unwrapForeachContent(childBlocks);
     currentBlock.children = childBlocks.map((block) => {
       block.parent = currentBlock;
       return block;
@@ -11494,6 +11523,7 @@ VegaRTEFullscreenExtension.controllerStore = VegaRTEFullscreenExtension.createSt
 var RTEPasteMode;
 (function (RTEPasteMode) {
   RTEPasteMode["RICH"] = "rich";
+  RTEPasteMode["PLAIN"] = "plain";
   RTEPasteMode["WORD"] = "word";
 })(RTEPasteMode || (RTEPasteMode = {}));
 /**
@@ -11545,185 +11575,63 @@ class AbstractPasteProcessingStrategy {
   get supportsImageProcessing() {
     return false;
   }
-}
-
-const paste = {
-  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>`,
-};
-
-/**
- * Renders and manages the paste format chooser UI.
- */
-class RTEPasteChooserUI {
-  constructor(hostRoot, callbacks, options = {}) {
-    this.hostRoot = hostRoot;
-    this.callbacks = callbacks;
-    this.options = options;
-    this.chooserEl = null;
-    this.dropdownEl = null;
-    this.triggerButtonEl = null;
+  /** @returns {boolean} Whether this strategy consumes `text/plain` instead of `text/html` (default: false). */
+  get consumesPlainText() {
+    return false;
   }
   /**
-   * Opens the paste-mode chooser at the given position.
+   * Owns the complete content policy for this paste mode. Subclasses that
+   * only need a different source string should override {@link getSourceContent}
+   * instead of re-implementing this method.
    *
-   * @param {PasteChooserPosition} position Viewport position for the chooser.
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {PasteOutput} Complete downstream paste contract.
    */
-  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;
-      }
-    });
+  transform(input) {
+    const content = this.getSourceContent(input);
+    return {
+      html: this.process(content),
+      text: this.consumesPlainText ? content : input.text,
+      mode: this.type,
+      markers: {},
+      extractImages: this.supportsImageProcessing,
+      imagesToExtract: this.supportsImageProcessing ? input.files : [],
+    };
   }
   /**
-   * Removes the chooser from the DOM.
+   * Resolves the source string passed to {@link process}. Defaults to
+   * `input.text` when {@link consumesPlainText} is true, otherwise `input.html`.
+   *
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {string} Content to feed into `process`.
    */
-  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;
+  getSourceContent(input) {
+    return this.consumesPlainText ? input.text : input.html;
   }
+}
+
+/**
+ * Default paste processing strategy that acts as a fallback when no other
+ * strategy matches. This strategy always accepts the content and passes it
+ * through unchanged — the normal RTE paste pipeline (DOMParser +
+ * ElementToDtoStrategyProcessor) handles the rest.
+ */
+class DefaultPasteProcessingStrategy extends AbstractPasteProcessingStrategy {
   /**
-   * Determines whether the given event path targets the chooser.
+   * Always matches as the terminal fallback strategy.
    *
-   * @param {EventTarget[]} eventPath Composed path of an event.
-   * @returns {boolean} `true` when the path includes the chooser.
+   * @param {string} html Raw clipboard HTML.
+   * @returns {boolean} Always `true`.
    */
-  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;
+  canHandle(html) {
+    // Default strategy is the fallback — always returns true.
+    return html !== undefined;
   }
   /**
-   * Builds the dropdown element with the rich text paste option.
+   * Returns the original HTML unchanged.
    *
-   * @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';
-    dropdownEl.isScreenPosition = true;
-    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', internalTranslationController.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 = internalTranslationController.VegaInternalTranslation.t('Paste options');
-    tooltipEl.placement = ['bottom', 'top'];
-    tooltipEl.append(triggerButton);
-    dropdownEl.append(tooltipEl);
-    const itemsContainer = doc.createElement('div');
-    itemsContainer.setAttribute('slot', 'items');
-    const dropdownItems = [
-      this.createDropdownItem(doc, RTEPasteMode.RICH, internalTranslationController.VegaInternalTranslation.t('Use rich text'), RTEPasteChooserUI.CHOOSER_RICH_ATTR),
-    ];
-    if (this.options.showWordOption) {
-      dropdownItems.push(this.createDropdownItem(doc, RTEPasteMode.WORD, internalTranslationController.VegaInternalTranslation.t('Use Word'), RTEPasteChooserUI.CHOOSER_WORD_ATTR));
-    }
-    itemsContainer.append(...dropdownItems);
-    dropdownEl.append(itemsContainer);
-    dropdownEl.addEventListener('vegaDropdownClick', (event) => {
-      const mode = event.detail;
-      if (mode === RTEPasteMode.RICH || mode === RTEPasteMode.WORD) {
-        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 {RTEPasteMode} 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;
-  }
-}
-(() => {
-  internalIconManager.VegaInternalIconManager.register({
-    'rte-paste': paste,
-  });
-})();
-RTEPasteChooserUI.CHOOSER_ATTR = 'data-rte-paste-chooser';
-RTEPasteChooserUI.CHOOSER_RICH_ATTR = 'data-rte-paste-type-rich';
-RTEPasteChooserUI.CHOOSER_WORD_ATTR = 'data-rte-paste-type-word';
-RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR = 'data-rte-paste-trigger';
-
-/**
- * Default paste processing strategy that acts as a fallback when no other
- * strategy matches. This strategy always accepts the content and passes it
- * through unchanged — the normal RTE paste pipeline (DOMParser +
- * ElementToDtoStrategyProcessor) handles the rest.
- */
-class DefaultPasteProcessingStrategy extends AbstractPasteProcessingStrategy {
-  /**
-   * Always matches as the terminal fallback strategy.
-   *
-   * @param {string} html Raw clipboard HTML.
-   * @returns {boolean} Always `true`.
-   */
-  canHandle(html) {
-    // Default strategy is the fallback — always returns true.
-    return html !== undefined;
-  }
-  /**
-   * Returns the original HTML unchanged.
-   *
-   * @param {string} html Raw clipboard HTML.
-   * @returns {string} Unchanged HTML.
+   * @param {string} html Raw clipboard HTML.
+   * @returns {string} Unchanged HTML.
    */
   process(html) {
     // Current default behavior: pass through unchanged
@@ -13719,6 +13627,76 @@ WordPasteProcessingStrategy.WORD_SIGNATURE_PATTERNS = [
   /<\/?o:p>/i,
 ];
 
+/** Converts plain-text clipboard to paragraph-per-line HTML. */
+class PlainPasteProcessingStrategy extends AbstractPasteProcessingStrategy {
+  /** @returns {RTEPasteMode} Plain-text paste mode. */
+  get type() {
+    return RTEPasteMode.PLAIN;
+  }
+  /** @returns {boolean} Always `true`; consumes `text/plain` instead of `text/html`. */
+  get consumesPlainText() {
+    return true;
+  }
+  /** @returns {boolean} Always `false`; never auto-selected. */
+  canHandle() {
+    return false;
+  }
+  /**
+   * Converts plain text to paragraph HTML; every `\n` starts a new paragraph.
+   *
+   * @param {string} text - Clipboard `text/plain` payload.
+   * @param {boolean} decodeEncodedWhitespace - Decode markers emitted by HTML conversion.
+   * @returns {string} Paragraph HTML.
+   */
+  process(text, decodeEncodedWhitespace = false) {
+    if (!text) {
+      return '';
+    }
+    const safeDocument = tryGetDocument.tryGetDocument();
+    if (!safeDocument) {
+      return '';
+    }
+    // Line splitting and boundary whitespace handling live in `toPlainPasteLines` so the
+    // emitted HTML and the RTE nodes built by `InsertPasteHandler` share one conversion.
+    return codeBlock.plainPasteLinesToHtml(codeBlock.toPlainPasteLines(text, decodeEncodedWhitespace));
+  }
+  /**
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {PasteOutput} Plain HTML, canonical text, and whitespace marker contract.
+   */
+  transform(input) {
+    const source = this.getPlainTextSource(input);
+    return {
+      html: this.process(source.text, source.hasEncodedWhitespace),
+      text: source.text,
+      mode: this.type,
+      markers: source.hasEncodedWhitespace ? { [codeBlock.RTE_PRESERVED_WHITESPACE_DATA_TYPE]: 'true' } : {},
+      extractImages: false,
+      imagesToExtract: [],
+    };
+  }
+  /**
+   * @param {PasteInput} input Clipboard content used to derive canonical plain text.
+   * @returns {PlainTextSource} Canonical text and whether it contains whitespace sentinels.
+   */
+  getPlainTextSource(input) {
+    if (!input.html) {
+      return { text: input.text || '', hasEncodedWhitespace: false };
+    }
+    const containsTable = imageExtension.htmlContainsTable(input.html);
+    if (input.text && input.text.includes('\t') && containsTable) {
+      return { text: input.text, hasEncodedWhitespace: false };
+    }
+    const derived = imageExtension.htmlToPlainText(input.html, {
+      preserveBoundaryBlankLines: !containsTable,
+      keepPreservedWhitespaceMarkers: true,
+    });
+    return derived
+      ? { text: derived, hasEncodedWhitespace: true }
+      : { text: input.text || '', hasEncodedWhitespace: false };
+  }
+}
+
 /**
  * Centralized selector for paste processing strategies.
  *
@@ -13731,10 +13709,27 @@ class PasteStrategySelector {
   constructor() {
     this.defaultStrategy = new DefaultPasteProcessingStrategy();
     this.strategies = [
+      new PlainPasteProcessingStrategy(),
       new WordPasteProcessingStrategy(),
       this.defaultStrategy, // Fallback
     ];
   }
+  /**
+   * Selects the strategy that will process this paste.
+   *
+   * When `explicitMode` is provided and not `rich`, the strategy registered for that mode
+   * is used. Otherwise the highest-priority strategy whose `canHandle` matches the HTML
+   * wins, falling back to the default pass-through strategy.
+   *
+   * @param {PasteInput} input Captured clipboard payload used for auto-detection.
+   * @param {RTEPasteMode} [explicitMode] Paste mode the user picked from the chooser.
+   * @returns {AbstractPasteProcessingStrategy} Strategy to run for this paste.
+   */
+  select(input, explicitMode) {
+    return explicitMode && explicitMode !== RTEPasteMode.RICH
+      ? this.selectStrategyByType(explicitMode)
+      : this.selectStrategy(input.html);
+  }
   /**
    * Select the appropriate strategy for the given HTML content.
    * Returns the highest-priority strategy that can handle the content.
@@ -14221,271 +14216,79 @@ class PendingImageRegistry {
  */
 PendingImageRegistry.pendingImages = new Map();
 
-/**
- * Vega Rich Text Editor paste extension.
- * Intercepts keyboard paste and allows users to choose paste mode.
- */
-class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
-  constructor(options = {}) {
-    super();
-    this.editableEl = null;
-    this.contentHostEl = null;
-    this.chooserUI = null;
-    this.pendingPastePayload = null;
-    this.listenerDocument = null;
-    this.listenerWindow = null;
-    this.options = {};
-    this.strategySelector = new PasteStrategySelector();
-    this.clipboardFileContent = null;
-    this.imageParser = new PasteImageParser();
-    /** Owns pending pasted-image previews awaiting upload and their URL replacement. */
-    this.pendingImageRegistry = new PendingImageRegistry();
-    /**
-     * 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') || '';
-      // RTF must be read synchronously here: the paste event's DataTransfer is only
-      // readable during event dispatch, so reading it later (after the chooser) returns ''.
-      const rtf = clipboardData.getData('text/rtf') || '';
-      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.clipboardFileContent = {
-        files: clipboardData.files ? Array.from(clipboardData.files) : [],
-        rtf,
-      };
-      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();
-    };
-    this.options = options;
-  }
-  /** @inheritDoc */
-  initialExtensionAfterLoad(context) {
-    super.initialExtensionAfterLoad(context);
-    this.hostEl = context.host;
-    this.attachPasteListener();
-  }
-  /** @inheritDoc */
-  destroyExtension() {
-    this.detachPasteListener();
-    this.clearPasteChooser();
-    this.pendingImageRegistry.discardUnsentPreviews();
+/** Computes paste chooser placement from the paste pointer or saved caret range. */
+class ChooserPositioner {
+  constructor(getHostElement, getSelectionRange) {
+    this.getHostElement = getHostElement;
+    this.getSelectionRange = getSelectionRange;
   }
   /**
-   * Attaches the paste listener to the editable element.
+   * @param {ClipboardEvent} event Originating paste event.
+   * @returns {ChooserPosition} Position in viewport coordinates.
    */
-  attachPasteListener() {
-    const { editableEl, contentHostEl, } = this.getEditorElements();
-    this.editableEl = editableEl;
-    this.contentHostEl = contentHostEl;
-    if (this.editableEl) {
-      this.editableEl.addEventListener('paste', this.handlePasteEvent);
+  compute(event) {
+    var _a, _b, _c;
+    const hostEl = this.getHostElement();
+    if (!hostEl) {
+      return { left: 0, top: 0, placement: ['bottom', 'top'] };
+    }
+    const hostRect = hostEl.getBoundingClientRect();
+    const viewportHeight = (_b = (_a = 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;
+    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 };
+  }
+  /** @returns {DOMRect | null} Best available caret rectangle. */
+  getCaretRect() {
+    const range = this.getSelectionRange();
+    if (!range) {
+      return null;
+    }
+    const rect = range.getBoundingClientRect();
+    if (!this.isUnavailableRect(rect)) {
+      return rect;
+    }
+    const domRectList = range.getClientRects();
+    if (domRectList.length > 0) {
+      return domRectList[0];
     }
+    return this.getRangeContainerRect(range);
   }
   /**
-   * Detaches the paste listener from the editable element.
+   * @param {DOMRect} rect Rectangle to inspect.
+   * @returns {boolean} Whether the rectangle has no usable position or dimensions.
    */
-  detachPasteListener() {
-    if (this.editableEl) {
-      this.editableEl.removeEventListener('paste', this.handlePasteEvent);
-    }
-    this.editableEl = null;
-    this.contentHostEl = null;
+  isUnavailableRect(rect) {
+    return rect.width === 0 && rect.height === 0 && rect.left === 0 && rect.top === 0;
   }
   /**
-   * 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, _c;
-    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);
-      },
-    }, {
-      showWordOption: ((_c = this.options) === null || _c === void 0 ? void 0 : _c.enableWordPaste) === true,
-    });
-    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.
+   * @param {Range} range Selection range whose container should be measured.
+   * @returns {DOMRect | null} Best available rectangle for the range container.
    */
   getRangeContainerRect(range) {
     var _a, _b, _c, _d, _e, _f;
@@ -14502,10 +14305,8 @@ class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
     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.
+   * @param {Node | null} node DOM node to measure.
+   * @returns {DOMRect | null} Element-backed rectangle for the node.
    */
   getNodeRect(node) {
     var _a, _b;
@@ -14521,73 +14322,145 @@ class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
     }
     return null;
   }
+}
+
+/** Extracts local image previews from strategy output. */
+class ImageExtractor {
+  constructor(parser = new PasteImageParser()) {
+    this.parser = parser;
+  }
   /**
-   * Applies the chosen paste mode by dispatching a synthetic paste input event.
-   *
-   * `rich` keeps auto-detection enabled; any other explicit mode forces the
-   * corresponding registered strategy.
-   *
-   * @param {RTEPasteMode} mode Selected paste mode.
+   * @param {string} html HTML content containing local image references.
+   * @param {File[]} files Clipboard image files.
+   * @param {string} rtf Rich text clipboard content used to resolve images.
+   * @returns {ParseLocalImagesResult} HTML and extracted local image previews.
    */
-  applyPasteMode(mode) {
-    var _a;
-    if (!this.pendingPastePayload) {
-      this.clearPasteChooser();
-      return;
+  extract(html, files, rtf) {
+    const clipboardFileContent = { files, rtf };
+    return this.parser.parseLocalImages(html, clipboardFileContent);
+  }
+}
+
+/** Selects and executes one paste strategy, then performs declared post-processing. */
+class PasteProcessingPipeline {
+  constructor(selector, imageExtractor, pendingImageRegistry) {
+    this.selector = selector;
+    this.imageExtractor = imageExtractor;
+    this.pendingImageRegistry = pendingImageRegistry;
+  }
+  /**
+   * @param {PendingPastePayload} payload Captured clipboard and selection data.
+   * @param {RTEPasteMode} explicitMode Paste mode selected by the user.
+   * @returns {PasteOutput} Processed paste output and image extraction metadata.
+   */
+  process(payload, explicitMode) {
+    const input = {
+      html: payload.html,
+      text: payload.text,
+      files: payload.files,
+      rtf: payload.rtf,
+    };
+    const output = this.selector.select(input, explicitMode).transform(input);
+    if (!output.extractImages) {
+      return output;
     }
-    const editableEl = (_a = this.editableEl) !== null && _a !== void 0 ? _a : this.getEditableElement();
-    if (!editableEl) {
-      this.clearPasteChooser();
-      return;
+    const extraction = this.imageExtractor.extract(output.html, output.imagesToExtract, input.rtf);
+    if (extraction.previews.length > 0) {
+      this.pendingImageRegistry.register(extraction.previews);
     }
-    editableEl.focus();
-    this.restoreSelectionRange(this.pendingPastePayload.range);
-    this.restoreSelectionControllerState(this.pendingPastePayload);
-    const strategy = mode === RTEPasteMode.RICH
-      ? this.strategySelector.selectStrategy(this.pendingPastePayload.html)
-      : this.strategySelector.selectStrategyByType(mode);
-    let processedHtml = strategy.process(this.pendingPastePayload.html);
-    // If the strategy supports image processing and there is clipboard file content, parse local images.
-    if (strategy.supportsImageProcessing && this.clipboardFileContent) {
-      processedHtml = this.parseLocalImages(processedHtml, this.clipboardFileContent);
-    }
-    this.clipboardFileContent = null;
-    const dataTransfer = this.createDataTransfer(processedHtml, this.pendingPastePayload.text, strategy.type);
-    this.dispatchBeforeInputPaste(editableEl, dataTransfer);
-    this.clearPasteChooser();
-    this.emitLocalImageInsertedEvent();
+    return Object.assign(Object.assign({}, output), { html: extraction.html });
   }
+}
+
+/** Builds the DataTransfer contract consumed by InsertPasteHandler. */
+class PasteDataTransferBuilder {
   /**
-   * Parses local images from the HTML and emits events for further processing.
-   *
-   * @param {string} html HTML content to parse.
-   * @param {ClipboardFileContent} clipboardFileContent Clipboard file content for image extraction.
-   * @returns {string} Processed HTML with local image references replaced.
+   * @param {PasteOutput} output Processed paste output to serialize.
+   * @returns {DataTransfer} Data transfer payload consumed by the paste handler.
    */
-  parseLocalImages(html, clipboardFileContent) {
-    const { html: result, previews } = this.imageParser.parseLocalImages(html, clipboardFileContent);
-    if (previews.length > 0) {
-      this.pendingImageRegistry.register(previews);
+  build(output) {
+    // Reserved keys always win over `markers` so a strategy cannot clobber the base contract.
+    const safeMarkers = Object.assign({}, output.markers);
+    PasteDataTransferBuilder.RESERVED_KEYS.forEach((key) => delete safeMarkers[key]);
+    const values = Object.assign(Object.assign({}, safeMarkers), { 'text/html': output.html, 'text/plain': output.text, [codeBlock.RTE_PASTE_MODE_DATA_TYPE]: output.mode });
+    if (typeof DataTransfer !== 'undefined') {
+      const dataTransfer = new DataTransfer();
+      Object.keys(values).forEach((type) => {
+        const value = values[type];
+        if (value) {
+          dataTransfer.setData(type, value);
+        }
+      });
+      return dataTransfer;
     }
-    return result;
+    return {
+      /**
+       * @param {string} type Clipboard data type to read.
+       * @returns {string} Clipboard value for the requested type.
+       */
+      getData: (type) => { var _a; return (_a = values[type]) !== null && _a !== void 0 ? _a : ''; },
+    };
   }
+}
+PasteDataTransferBuilder.RESERVED_KEYS = [
+  'text/html',
+  'text/plain',
+  codeBlock.RTE_PASTE_MODE_DATA_TYPE,
+];
+
+/** Dispatches processed paste data through the editor's existing beforeinput pipeline. */
+class PasteDispatcher {
   /**
-   * Emits the `imageInsertedCallback` for any pending previews, allowing the
-   * consumer to upload them and resolve their URLs.
+   * @param {HTMLDivElement} editableEl Editable content element receiving the event.
+   * @param {DataTransfer} dataTransfer Processed clipboard payload.
    */
-  emitLocalImageInsertedEvent() {
-    if (this.pendingImageRegistry.hasPendingNotifications()) {
-      this.pendingImageRegistry.notifyInserted(this.options.imageInsertedCallback, () => { var _a; return (_a = this.editableEl) !== null && _a !== void 0 ? _a : this.getEditableElement(); }, (imageElement) => this.getDTOEntityByDom(imageElement));
+  dispatch(editableEl, dataTransfer) {
+    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);
+  }
+}
+
+/** Captures and restores native and editor selection state around chooser interaction. */
+class SelectionSnapshotService {
+  constructor(getContext) {
+    this.getContext = getContext;
   }
   /**
-   * 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.
+   * @returns {SelectionSnapshot} Captured native and editor selection state.
+   */
+  capture() {
+    var _a;
+    const context = this.getContext();
+    const selection = context === null || context === void 0 ? void 0 : context.getSelection();
+    const range = selection && selection.rangeCount > 0 ? selection.getRangeAt(0).cloneRange() : null;
+    const selectedNodes = ((_a = context === null || context === void 0 ? void 0 : context.getSelectedNodes) === null || _a === void 0 ? void 0 : _a.call(context)) || [];
+    return { range, selectedNodes: [...selectedNodes] };
+  }
+  /**
+   * @param {PendingPastePayload} payload Paste payload containing captured selection state.
+   */
+  restore(payload) {
+    this.restoreRange(payload.range);
+    this.restoreControllerState(payload);
+  }
+  /**
+   * @param {PendingPastePayload} payload Paste payload containing editor selection state.
    */
-  restoreSelectionControllerState(payload) {
-    if (!payload.range || !this.extensionContext) {
+  restoreControllerState(payload) {
+    const context = this.getContext();
+    if (!payload.range || !context) {
       return;
     }
     const rangeOptions = {
@@ -14596,121 +14469,492 @@ class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
       startOffset: payload.range.startOffset,
       endOffset: payload.range.endOffset,
     };
-    this.extensionContext.setSelectedNodes(payload.selectedNodes || [], rangeOptions);
+    context.setSelectedNodes(payload.selectedNodes || [], rangeOptions);
   }
   /**
-   * Restores a previously cloned selection range.
-   *
-   * @param {Range | null} range Range to restore.
+   * @param {Range | null} range Native selection range to restore.
    */
-  restoreSelectionRange(range) {
+  restoreRange(range) {
     var _a;
     if (!range) {
       return;
     }
-    const selection = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelection();
+    const selection = (_a = this.getContext()) === null || _a === void 0 ? void 0 : _a.getSelection();
     if (selection) {
       selection.removeAllRanges();
       selection.addRange(range);
     }
   }
+}
+
+/** Owns the native paste listener and synchronous clipboard payload capture. */
+class PasteEventInterceptor {
+  constructor(selectionSnapshotService, onPasteCaptured) {
+    this.selectionSnapshotService = selectionSnapshotService;
+    this.onPasteCaptured = onPasteCaptured;
+    this.editableEl = null;
+    /**
+     * @param {ClipboardEvent} event Native paste event to capture.
+     */
+    this.handlePasteEvent = (event) => {
+      const clipboardData = event.clipboardData;
+      if (!clipboardData) {
+        return;
+      }
+      const html = clipboardData.getData('text/html') || '';
+      const text = clipboardData.getData('text/plain') || '';
+      const rtf = clipboardData.getData('text/rtf') || '';
+      if (!html && !text) {
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      const snapshot = this.selectionSnapshotService.capture();
+      const files = clipboardData.files ? Array.from(clipboardData.files) : [];
+      this.onPasteCaptured({ html, text, range: snapshot.range, selectedNodes: snapshot.selectedNodes, files, rtf }, event);
+    };
+  }
   /**
-   * Dispatches a synthetic `beforeinput` paste event into the editor pipeline.
-   *
-   * @param {HTMLDivElement} editableEl Editable content element.
-   * @param {DataTransfer} dataTransfer Clipboard payload for the paste.
+   * @param {HTMLDivElement | null} editableEl Editable content element to observe.
    */
-  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);
+  attach(editableEl) {
+    var _a;
+    this.detach();
+    this.editableEl = editableEl;
+    (_a = this.editableEl) === null || _a === void 0 ? void 0 : _a.addEventListener('paste', this.handlePasteEvent);
   }
   /**
-   * 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 {RTEPasteMode} [mode] Selected paste mode marker.
-   * @returns {DataTransfer} Populated data transfer payload.
+   * Detaches the current native paste listener.
    */
-  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(codeBlock.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 === codeBlock.RTE_PASTE_MODE_DATA_TYPE) {
-          return mode !== null && mode !== void 0 ? mode : '';
-        }
-        return '';
-      },
-    };
+  detach() {
+    var _a;
+    (_a = this.editableEl) === null || _a === void 0 ? void 0 : _a.removeEventListener('paste', this.handlePasteEvent);
+    this.editableEl = null;
+  }
+}
+
+const paste = {
+  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>`,
+};
+
+/**
+ * Renders and manages the paste format chooser UI.
+ */
+class RTEPasteChooserUI {
+  constructor(hostRoot, callbacks, options = {}) {
+    this.hostRoot = hostRoot;
+    this.callbacks = callbacks;
+    this.options = options;
+    this.chooserEl = null;
+    this.dropdownEl = null;
+    this.triggerButtonEl = null;
   }
   /**
-   * Tears down the chooser UI and removes dismissal listeners.
+   * Opens the paste-mode chooser at the given position.
    *
-   * @param {boolean} [clearPayload] Whether to also clear the pending payload.
+   * @param {PasteChooserPosition} position Viewport position for the chooser.
    */
-  clearPasteChooser(clearPayload = true) {
-    if (this.contentHostEl) {
-      this.contentHostEl.removeEventListener('scroll', this.handleOutsideScroll);
+  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';
+    dropdownEl.isScreenPosition = true;
+    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', internalTranslationController.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 = internalTranslationController.VegaInternalTranslation.t('Paste options');
+    tooltipEl.placement = ['bottom', 'top'];
+    tooltipEl.append(triggerButton);
+    dropdownEl.append(tooltipEl);
+    const itemsContainer = doc.createElement('div');
+    itemsContainer.setAttribute('slot', 'items');
+    const dropdownItems = [
+      this.createDropdownItem(doc, RTEPasteMode.RICH, internalTranslationController.VegaInternalTranslation.t('Use rich text'), RTEPasteChooserUI.CHOOSER_RICH_ATTR),
+      this.createDropdownItem(doc, RTEPasteMode.PLAIN, internalTranslationController.VegaInternalTranslation.t('Use plain text'), RTEPasteChooserUI.CHOOSER_PLAIN_ATTR),
+    ];
+    if (this.options.showWordOption) {
+      dropdownItems.push(this.createDropdownItem(doc, RTEPasteMode.WORD, internalTranslationController.VegaInternalTranslation.t('Use Word'), RTEPasteChooserUI.CHOOSER_WORD_ATTR));
     }
-    if (this.listenerWindow) {
-      this.listenerWindow.removeEventListener('scroll', this.handleOutsideScroll, true);
-      this.listenerWindow = null;
+    itemsContainer.append(...dropdownItems);
+    dropdownEl.append(itemsContainer);
+    dropdownEl.addEventListener('vegaDropdownClick', (event) => {
+      const mode = event.detail;
+      if (mode === RTEPasteMode.RICH || mode === RTEPasteMode.PLAIN || mode === RTEPasteMode.WORD) {
+        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 {RTEPasteMode} 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;
+  }
+}
+(() => {
+  internalIconManager.VegaInternalIconManager.register({
+    'rte-paste': paste,
+  });
+})();
+RTEPasteChooserUI.CHOOSER_ATTR = 'data-rte-paste-chooser';
+RTEPasteChooserUI.CHOOSER_RICH_ATTR = 'data-rte-paste-type-rich';
+RTEPasteChooserUI.CHOOSER_PLAIN_ATTR = 'data-rte-paste-type-plain';
+RTEPasteChooserUI.CHOOSER_WORD_ATTR = 'data-rte-paste-type-word';
+RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR = 'data-rte-paste-trigger';
+
+/** Owns chooser rendering and all listener bookkeeping used to dismiss it. */
+class PasteChooserController {
+  constructor(positioner, onModeSelect, onClearPayload) {
+    this.positioner = positioner;
+    this.onModeSelect = onModeSelect;
+    this.onClearPayload = onClearPayload;
+    this.chooserUI = null;
+    this.listenerDocument = null;
+    this.listenerWindow = null;
+    this.contentHostEl = null;
+    /**
+     * @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)) {
+        this.clear();
+      }
+    };
+    /**
+     * @param {KeyboardEvent} event Keyboard event captured on the document.
+     */
+    this.handleOutsideKeyDown = (event) => {
+      if (event.key === 'Escape') {
+        this.clear();
+      }
+    };
+    /**
+     * Clears the chooser when a relevant scroll container scrolls.
+     *
+     * @returns {void}
+     */
+    this.handleOutsideScroll = () => this.clear();
+  }
+  /**
+   * @returns {RTEPasteChooserUI | null} Current chooser UI, or `null` when closed.
+   */
+  get ui() {
+    return this.chooserUI;
+  }
+  /**
+   * @param {HTMLElement | null} hostEl Rich text editor host element.
+   * @param {HTMLElement | null} contentHostEl Scrollable content host element.
+   * @param {ClipboardEvent} pasteEvent Originating paste event used for positioning.
+   * @param {boolean} showWordOption Whether to display the Word paste option.
+   */
+  open(hostEl, contentHostEl, pasteEvent, showWordOption) {
+    var _a, _b, _c;
+    const hostRoot = (_a = hostEl === null || hostEl === void 0 ? void 0 : hostEl.shadowRoot) !== null && _a !== void 0 ? _a : null;
+    if (!hostRoot || !hostEl) {
+      return;
     }
+    this.clear(false);
+    const position = this.positioner.compute(pasteEvent);
+    this.chooserUI = new RTEPasteChooserUI(hostRoot, { onModeSelect: this.onModeSelect }, { showWordOption });
+    this.chooserUI.open(position);
+    this.contentHostEl = contentHostEl;
+    this.listenerDocument = 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);
+    (_b = this.listenerWindow) === null || _b === void 0 ? void 0 : _b.addEventListener('scroll', this.handleOutsideScroll, true);
+    (_c = this.contentHostEl) === null || _c === void 0 ? void 0 : _c.addEventListener('scroll', this.handleOutsideScroll);
+  }
+  /**
+   * @param {boolean} [clearPayload] Whether to also clear the pending paste payload.
+   */
+  clear(clearPayload = true) {
+    var _a, _b, _c;
+    (_a = this.contentHostEl) === null || _a === void 0 ? void 0 : _a.removeEventListener('scroll', this.handleOutsideScroll);
+    this.contentHostEl = null;
+    (_b = this.listenerWindow) === null || _b === void 0 ? void 0 : _b.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();
-    }
+    (_c = this.chooserUI) === null || _c === void 0 ? void 0 : _c.destroy();
     this.chooserUI = null;
     if (clearPayload) {
+      this.onClearPayload();
+    }
+  }
+}
+
+/**
+ * Vega Rich Text Editor paste extension.
+ * Intercepts keyboard paste and allows users to choose paste mode.
+ */
+class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
+  constructor(options = {}) {
+    super();
+    this.editableEl = null;
+    this.contentHostEl = null;
+    this.pendingPastePayload = 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) => {
+      this.pasteEventInterceptor.handlePasteEvent(event);
+    };
+    /**
+     * Dismisses the chooser when a pointer interaction occurs outside of it.
+     *
+     * @param {Event} event Pointer event captured on the document.
+     */
+    this.handleOutsidePointerDown = (event) => {
+      this.pasteChooserController.handleOutsidePointerDown(event);
+    };
+    /**
+     * Dismisses the chooser when the Escape key is pressed.
+     *
+     * @param {KeyboardEvent} event Keyboard event captured on the document.
+     */
+    this.handleOutsideKeyDown = (event) => {
+      this.pasteChooserController.handleOutsideKeyDown(event);
+    };
+    /**
+     * Dismisses the chooser when any relevant scroll container scrolls.
+     */
+    this.handleOutsideScroll = () => {
+      this.pasteChooserController.handleOutsideScroll();
+    };
+    this.options = options;
+    this.strategySelector = new PasteStrategySelector();
+    this.imageParser = new PasteImageParser();
+    this.pendingImageRegistry = new PendingImageRegistry();
+    this.chooserPositioner = new ChooserPositioner(() => this.hostEl, () => { var _a, _b; return (_b = (_a = this.pendingPastePayload) === null || _a === void 0 ? void 0 : _a.range) !== null && _b !== void 0 ? _b : this.cloneCurrentSelectionRange(); });
+    this.processingPipeline = new PasteProcessingPipeline(this.strategySelector, new ImageExtractor(this.imageParser), this.pendingImageRegistry);
+    this.dataTransferBuilder = new PasteDataTransferBuilder();
+    this.pasteDispatcher = new PasteDispatcher();
+    this.selectionSnapshotService = new SelectionSnapshotService(() => this.extensionContext);
+    this.pasteEventInterceptor = new PasteEventInterceptor(this.selectionSnapshotService, (payload, event) => {
+      this.pendingPastePayload = payload;
+      this.renderPasteChooser(event);
+    });
+    this.pasteChooserController = new PasteChooserController(this.chooserPositioner, (mode) => this.applyPasteMode(mode), () => {
       this.pendingPastePayload = null;
+    });
+  }
+  /** @inheritDoc */
+  initialExtensionAfterLoad(context) {
+    super.initialExtensionAfterLoad(context);
+    this.hostEl = context.host;
+    this.attachPasteListener();
+  }
+  /** @inheritDoc */
+  destroyExtension() {
+    this.detachPasteListener();
+    this.clearPasteChooser();
+    this.pendingImageRegistry.discardUnsentPreviews();
+  }
+  /** @returns {RTEPasteChooserUI | null} Currently open chooser UI, or `null` when closed. */
+  get chooserUI() {
+    return this.pasteChooserController.ui;
+  }
+  /**
+   * Attaches the paste listener to the editable element.
+   */
+  attachPasteListener() {
+    const { editableEl, contentHostEl, } = this.getEditorElements();
+    this.editableEl = editableEl;
+    this.contentHostEl = contentHostEl;
+    this.pasteEventInterceptor.attach(this.editableEl);
+  }
+  /**
+   * Detaches the paste listener from the editable element.
+   */
+  detachPasteListener() {
+    this.pasteEventInterceptor.detach();
+    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() {
+    return this.selectionSnapshotService.capture().range;
+  }
+  /**
+   * Renders the paste-mode chooser and wires up dismissal listeners.
+   *
+   * @param {ClipboardEvent} pasteEvent Originating paste event used for positioning.
+   */
+  renderPasteChooser(pasteEvent) {
+    var _a;
+    this.pasteChooserController.open(this.hostEl, this.contentHostEl, pasteEvent, ((_a = this.options) === null || _a === void 0 ? void 0 : _a.enableWordPaste) === true);
+  }
+  /**
+   * Applies the chosen paste mode by dispatching a synthetic paste input event.
+   *
+   * `rich` keeps auto-detection enabled; any other explicit mode forces the
+   * corresponding registered strategy.
+   *
+   * @param {RTEPasteMode} 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.selectionSnapshotService.restore(this.pendingPastePayload);
+    const output = this.processingPipeline.process(this.pendingPastePayload, mode);
+    const dataTransfer = this.dataTransferBuilder.build(output);
+    this.pasteDispatcher.dispatch(editableEl, dataTransfer);
+    this.clearPasteChooser();
+    this.emitLocalImageInsertedEvent();
+  }
+  /**
+   * Emits the `imageInsertedCallback` for any pending previews, allowing the
+   * consumer to upload them and resolve their URLs.
+   */
+  emitLocalImageInsertedEvent() {
+    if (this.pendingImageRegistry.hasPendingNotifications()) {
+      this.pendingImageRegistry.notifyInserted(this.options.imageInsertedCallback, () => { var _a; return (_a = this.editableEl) !== null && _a !== void 0 ? _a : this.getEditableElement(); }, (imageElement) => this.getDTOEntityByDom(imageElement));
+    }
+  }
+  /**
+   * Tears down the chooser UI and removes dismissal listeners.
+   *
+   * @param {boolean} [clearPayload] Whether to also clear the pending payload.
+   */
+  clearPasteChooser(clearPayload = true) {
+    this.pasteChooserController.clear(clearPayload);
   }
 }
 (() => {