@globalpayments/vega 2.101.0 → 2.103.0

package/dist/esm/{token-extension-530d9bde.js → token-extension-645a9520.js}

@@ -1,32 +1,32 @@
 import { g as generateUUID } from './misc-9fdbcfbb.js';
 import { a as arrayToClassString, g as getDeviceType, D as DeviceType, f as findParent, r as rgbToHex, b as getDeepActiveElementInShadow } from './ui-80e610f4.js';
 import { L as LogUtility, I as InjectVegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
-import { I as InjectVegaTelemetrySlimmer, c as createPublicAPIRuntimeMetricsSlimmer } from './create-public-api-runtime-metrics-slimmer-48f85199.js';
+import { I as InjectVegaTelemetrySlimmer, D as Discriminated, c as createPublicAPIRuntimeMetricsSlimmer } from './discriminated-fe5bf3c8.js';
 import { I as InternalVegaZIndexManager } from './internal-vega-z-index-manager-7d2b54c3.js';
 import { c as createDynamicSlimmer } from './dynamic-slimmer-90b8af32.js';
 import { P as PageResizeObserverSlimmer } from './page-resize-observer-slimmer-e24d36c5.js';
-import { i as internalVegaEventManager } from './internal-vega-event-manager-0c381f3b.js';
-import { V as VegaInternalTranslation } from './internal-translation-controller-fff376d2.js';
-import { I as InternalCalendarPeriodConverter } from './internal-calendar-period-factory-d1a60f81.js';
-import { M as ModifyContentAction, A as ActionHandleStrategyRegistry, R as RTETextNode, H as HTML_VOID_TAGS, a as RTEBlock, b as RTETextBlock, c as RTE_BLOCK_BOUNDARY_ATTRIBUTE, d as RTEAnnotationStyle, e as ActionHandleStrategy, I as InsertChildrenAfterAction, f as AppendChildrenAction, g as RTENode, s as stateEntityRenderingRegistry, h as InsertChildrenBeforeAction, i as InternalAnnotationTypeEnum, j as ModifyContentActionType, B as BlockAnnotation, k as AnnotationAction, l as RemoveChildrenAction, C as CommonAnnotationTypeEnum, m as CustomAttributeAnnotation, n as RTEDTOClassManager, o as RTEFilterStylesStrategy, p as RTEDecoratorNode, S as SplitBlockWithNodeAction, U as UpdateTextAction, q as RTECodeBlock, r as RTEListItemBlock, t as RTECodeBlockNode, N as NodeAnnotationTypeEnum, u as CustomStyleAnnotation, v as RTEFilterStylesStrategyRegistry, w as RTE_PASTE_MODE_DATA_TYPE, x as RTE_WORD_COUNT_KEY } from './code-block-1cdf7a51.js';
-import { U as UpdateCursorPositionAction, V as VegaRTEContent, B as BlockToRTEBlockStrategyAbstract, E as ElementToDTOStrategy, h as htmlElementToAnnotationGenerator, H as HtmlBlockStrategy, I as InsertNewParagraphAction, R as RTEImageBlock, a as InsertChildrenBeforeStrategy, P as PasteContentStrategy, A as AnnotationGeneratorStrategyAbstract, S as StylePreservator, b as RTEImageNode, C as COMMIT_VALUE } from './content-state-6eb610b8.js';
-import { i as isNonNullable } from './type-guard-26d83e7e.js';
-import { e as extensionContextManager, a as VegaRTEExtensionRenderer, b as VegaRTEExtension } from './link-extension-bc234cf7.js';
-import { V as VegaInternalIconManager } from './internal-icon-manager-e7c57096.js';
+import { i as internalVegaEventManager } from './internal-vega-event-manager-6eebe8f8.js';
+import { V as VegaInternalTranslation } from './internal-translation-controller-3637e47e.js';
+import { I as InternalCalendarPeriodConverter } from './internal-calendar-period-factory-261df2f2.js';
+import { M as ModifyContentAction, A as ActionHandleStrategyRegistry, R as RTETextNode, H as HTML_VOID_TAGS, a as RTENode, s as stateEntityRenderingRegistry, b as RTEBlock, c as RTETextBlock, N as NodeAnnotationTypeEnum, d as RTE_BLOCK_BOUNDARY_ATTRIBUTE, e as RTEAnnotationStyle, f as ActionHandleStrategy, I as InsertChildrenAfterAction, g as AppendChildrenAction, h as InsertChildrenBeforeAction, i as InternalAnnotationTypeEnum, j as ModifyContentActionType, B as BlockAnnotation, k as AnnotationAction, l as RemoveChildrenAction, C as CommonAnnotationTypeEnum, m as CustomAttributeAnnotation, n as RTEDTOClassManager, o as RTEFilterStylesStrategy, p as RTEDecoratorNode, S as SplitBlockWithNodeAction, U as UpdateTextAction, q as RTECodeBlock, r as RTEListItemBlock, t as RTECodeBlockNode, u as CustomStyleAnnotation, v as RTEFilterStylesStrategyRegistry, w as plainPasteLinesToHtml, x as toPlainPasteLines, y as RTE_PRESERVED_WHITESPACE_DATA_TYPE, z as RTE_PASTE_MODE_DATA_TYPE, D as RTE_WORD_COUNT_KEY } from './code-block-9360c331.js';
+import { U as UpdateCursorPositionAction, V as VegaRTEContent, B as BlockToRTEBlockStrategyAbstract, E as ElementToDTOStrategy, h as htmlElementToAnnotationGenerator, H as HtmlBlockStrategy, I as InsertNewParagraphAction, R as RTEImageBlock, a as InsertChildrenBeforeStrategy, P as PasteContentStrategy, A as AnnotationGeneratorStrategyAbstract, S as StylePreservator, b as RTEImageNode, C as COMMIT_VALUE } from './content-state-67a12e74.js';
+import { a as VegaRTEExtensionRenderer, b as VegaRTEExtension, e as extensionContextManager } from './link-extension-57ba9520.js';
+import { V as VegaInternalIconManager } from './internal-icon-manager-d4d534d2.js';
+import { i as isNonNullable } from './type-guard-204094c6.js';
 import { v as vegaNonceManager } from './vega-nonce-manager-497e5eb5.js';
-import { D as DomNodeSubjectObserverFactory, d as domNodeSubjectFactory } from './dom-node-subject-observer-factory-bb7e68a0.js';
-import { V as VegaDropdownClick, a as VegaClick, b as VegaPopoverHide, c as VegaPopoverShow, d as VegaChange } from './vega-event-id-59cd9297.js';
-import { R as RTETableExtensionAnnotationTypeEnum, a as RTE_TABLE_HEAD_DEFAULT_BACKGROUND_COLOR, S as SettingEventHandler, T as TableSettingType, b as RTETableAnnotation, c as RTETableCellAnnotation, d as RTETableHeadCellBlock, e as RowOperationEventHandler, C as ColumnOperationEventHandler, M as MergeCellsOperationEventHandler, f as SplitCellOperationEventHandler, g as RTETableColorManager, h as RTETableBlock, i as generateTableBody, j as RTETableCellBlock, k as RTETableHeadBlock, l as RTETableBodyBlock, m as getParentBlockByType, n as RTETableHeadCellAnnotation, o as TableColumnStrategy, p as getAllTableRows, q as buildTableGrid, s as setSpanAttributes, r as findCellBlockById, t as getDefaultCellBlockTemplate, I as InsertTableColumnDirection, u as buildCellStartColumnMap, v as getTableColumnCount, w as getFirstNode, x as getCellSpan, y as createNewCell, z as MergeCellsOperationType, A as RTETableRowBlock, B as getActualColumnPosition, D as InsertTableRowDirection, E as RTE_TABLE_DEFAULT_COLORS, F as INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, G as INSERT_TABLE_ROW_INTO_SAME_SECTION, H as DELETE_TABLE_ROW, J as TOGGLE_HEADER_ROW, K as INSERT_TABLE_COLUMN, L as DELETE_TABLE_COLUMN, N as TOGGLE_HEADER_TABLE_COLUMN, O as ToggleHeaderTableColumnStrategy, P as SPLIT_TABLE_CELL, Q as REPLACE_TABLE_CELL, U as SPLIT_CELL_HORIZONTALLY, W as SPLIT_CELL_VERTICALLY, X as SELECT_TABLE_COLUMN, Y as MERGE_CELLS } from './split-cell-operation-1a889fa0.js';
+import { b as VegaRTEToolbarButtonRenderer, A as ActionHandlerInterceptor, R as ReplaceSelectedTextAction, h as htmlContainsTable, c as htmlToPlainText, I as InsertNodeToNearestRootAction } from './image-extension-aea75132.js';
+import { R as RTETableExtensionAnnotationTypeEnum, a as RTE_TABLE_HEAD_DEFAULT_BACKGROUND_COLOR, S as SettingEventHandler, T as TableSettingType, b as RTETableAnnotation, c as RTETableCellAnnotation, d as RTETableHeadCellBlock, e as RowOperationEventHandler, C as ColumnOperationEventHandler, M as MergeCellsOperationEventHandler, f as SplitCellOperationEventHandler, g as RTETableColorManager, h as RTETableBlock, i as generateTableBody, j as RTETableCellBlock, k as RTETableHeadBlock, l as RTETableBodyBlock, m as getParentBlockByType, n as RTETableHeadCellAnnotation, o as TableColumnStrategy, p as getAllTableRows, q as buildTableGrid, s as setSpanAttributes, r as findCellBlockById, t as getDefaultCellBlockTemplate, I as InsertTableColumnDirection, u as buildCellStartColumnMap, v as getTableColumnCount, w as getFirstNode, x as getCellSpan, y as createNewCell, z as MergeCellsOperationType, A as RTETableRowBlock, B as getActualColumnPosition, D as InsertTableRowDirection, E as RTE_TABLE_DEFAULT_COLORS, F as INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, G as INSERT_TABLE_ROW_INTO_SAME_SECTION, H as DELETE_TABLE_ROW, J as TOGGLE_HEADER_ROW, K as INSERT_TABLE_COLUMN, L as DELETE_TABLE_COLUMN, N as TOGGLE_HEADER_TABLE_COLUMN, O as ToggleHeaderTableColumnStrategy, P as SPLIT_TABLE_CELL, Q as REPLACE_TABLE_CELL, U as SPLIT_CELL_HORIZONTALLY, W as SPLIT_CELL_VERTICALLY, X as SELECT_TABLE_COLUMN, Y as MERGE_CELLS } from './split-cell-operation-85a036f9.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
+import { D as DomNodeSubjectObserverFactory, d as domNodeSubjectFactory } from './dom-node-subject-observer-factory-bb7e68a0.js';
 import { V as VegaInternalRTEExtensionTableCellsSelectionAnchor, a as VegaInternalPopoverUpdateTarget, b as VegaInternalRTEExtensionTableCellSelectionChange } from './vega-internal-event-id-02093067.js';
 import { r as remoteInvocationRegistry } from './remote-invocation-registry-d69245c2.js';
 import { V as VegaInternalThemeManager, a as VegaDarkModeStyleController } from './dark-mode-style-controller-4e04a2d3.js';
+import { V as VegaPopoverHide, a as VegaPopoverShow, b as VegaClick, c as VegaChange } from './vega-event-id-6b4db259.js';
 import { t as tryGetDocument } from './try-get-document-bef0f526.js';
 import { p as parseToPixelString } from './pixel-f32c07ce.js';
 import { c as cleanObject } from './object-0c277f57.js';
 import { d as debounce } from './timer-9321173b.js';
 import { c as camelToDashCase } from './string-a953eafc.js';
-import { R as ReplaceSelectedTextAction } from './image-extension-f6dbd70c.js';
 import { c as copy } from './copy-54e45e2d.js';
 
 const VegaLoaderRuntimeMetricsPayloadDefinition = [
@@ -81,9 +81,10 @@ var __decorate$6 = (undefined && undefined.__decorate) || function (decorators,
 /**
  * Vega loader controller to control the loading indicator
  */
-class VegaLoaderController {
+class VegaLoaderController extends Discriminated {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaLoaderController, ['load', 'close'], VegaLoaderRuntimeMetricsPayloadDefinition, 'VegaLoaderController');
+    super(...arguments);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaLoaderController, ['load', 'close'], VegaLoaderRuntimeMetricsPayloadDefinition, VegaLoaderController.typeName);
   }
   /**
    * Create a loading indicator and append it to the container
@@ -193,6 +194,7 @@ class VegaLoaderController {
     }
   }
 }
+VegaLoaderController.typeName = 'VegaLoaderController';
 VegaLoaderController.SPECIAL_ELEMENT_TO_WRAP_FULL_BODY = ['VEGA-MODAL'];
 __decorate$6([
   InjectVegaTelemetrySlimmer()
@@ -271,8 +273,9 @@ var __decorate$5 = (undefined && undefined.__decorate) || function (decorators,
 /**
  * The page notification controller
  */
-class VegaNotifyController {
+class VegaNotifyController extends Discriminated {
   constructor() {
+    super(...arguments);
     this.resizeObserverSlimmer = createDynamicSlimmer(VegaNotifyController, PageResizeObserverSlimmer, [], [{ mapFrom: 'connectResizeObserver', mapTo: 'connectResizeObserver' }], [
       {
         // eslint-disable-next-line jsdoc/require-jsdoc
@@ -289,7 +292,7 @@ class VegaNotifyController {
         target: () => this.container,
       },
     ]);
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaNotifyController, ['open', 'close', 'closeAll'], VegaNotifyRuntimeMetricsPayloadDefinition, 'VegaNotifyController');
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaNotifyController, ['open', 'close', 'closeAll'], VegaNotifyRuntimeMetricsPayloadDefinition, VegaNotifyController.typeName);
   }
   /**
    * It creates a new notification element, adds it to the container, and returns the notification's ID
@@ -373,6 +376,7 @@ class VegaNotifyController {
     return this.container;
   }
 }
+VegaNotifyController.typeName = 'VegaNotifyController';
 __decorate$5([
   InjectVegaSlimmer()
 ], VegaNotifyController.prototype, "resizeObserverSlimmer", void 0);
@@ -605,9 +609,10 @@ var __decorate$4 = (undefined && undefined.__decorate) || function (decorators,
  * The VegaEventManager class provides methods for setting and retrieving event semantics configuration,
  * as well as getting the corresponding native event name for a given event.
  */
-class VegaEventManager {
+class VegaEventManager extends Discriminated {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaEventManager, ['setSemantics', 'getSemantics', 'getEnabledEventIdsByComponent'], VegaEventManagerRuntimeMetricsPayloadDefinition, 'VegaEventManager');
+    super(...arguments);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaEventManager, ['setSemantics', 'getSemantics', 'getEnabledEventIdsByComponent'], VegaEventManagerRuntimeMetricsPayloadDefinition, VegaEventManager.typeName);
   }
   /**
    * The function sets the semantics configuration for event management.
@@ -645,6 +650,7 @@ class VegaEventManager {
     return internalVegaEventManager.getEnabledEventIdsByComponent(componentName);
   }
 }
+VegaEventManager.typeName = 'VegaEventManager';
 __decorate$4([
   InjectVegaTelemetrySlimmer()
 ], VegaEventManager.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
@@ -704,9 +710,10 @@ var __decorate$3 = (undefined && undefined.__decorate) || function (decorators,
  * The VegaZIndexManager class calls a method in the ZIndexManager class to
  * change z-index values based on the input.
  */
-class VegaZIndexManager {
+class VegaZIndexManager extends Discriminated {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaZIndexManager, ['overrideZIndexBasicValues'], ZIndexManagerRuntimeMetricsPayloadDefinition, 'VegaZIndexManager');
+    super(...arguments);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaZIndexManager, ['overrideZIndexBasicValues'], ZIndexManagerRuntimeMetricsPayloadDefinition, VegaZIndexManager.typeName);
   }
   /**
    * The function "overrideZIndexBasicValues" calls a method in the "ZIndexManager" class to change the
@@ -719,6 +726,7 @@ class VegaZIndexManager {
     InternalVegaZIndexManager.overrideZIndexBasicValues(input);
   }
 }
+VegaZIndexManager.typeName = 'VegaZIndexManager';
 __decorate$3([
   InjectVegaTelemetrySlimmer()
 ], VegaZIndexManager.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
@@ -756,9 +764,10 @@ var __decorate$2 = (undefined && undefined.__decorate) || function (decorators,
 /**
  * WaitForVegaHandler to check whether the vega component has been loaded.
  */
-class WaitForVegaHandler {
+class WaitForVegaHandler extends Discriminated {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(WaitForVegaHandler, ['handle'], WaitForVegaPayloadDefinition, 'WaitForVegaHandler');
+    super(...arguments);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(WaitForVegaHandler, ['handle'], WaitForVegaPayloadDefinition, WaitForVegaHandler.typeName);
   }
   /* istanbul ignore next */
   /**
@@ -776,6 +785,7 @@ class WaitForVegaHandler {
       .map((item) => { var _a; return (_a = item.componentOnReady) === null || _a === void 0 ? void 0 : _a.call(item); }));
   }
 }
+WaitForVegaHandler.typeName = 'WaitForVegaHandler';
 __decorate$2([
   InjectVegaTelemetrySlimmer()
 ], WaitForVegaHandler.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
@@ -864,9 +874,10 @@ var __decorate$1 = (undefined && undefined.__decorate) || function (decorators,
 /**
  * Vega Skeleton Loader Controller to show skeletons in the target elements
  */
-class VegaSkeletonLoaderController {
+class VegaSkeletonLoaderController extends Discriminated {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaSkeletonLoaderController, ['load', 'unLoad', 'unLoadAll'], VegaSkeletonRuntimeMetricsPayloadDefinition, 'VegaSkeletonLoaderController');
+    super(...arguments);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaSkeletonLoaderController, ['load', 'unLoad', 'unLoadAll'], VegaSkeletonRuntimeMetricsPayloadDefinition, VegaSkeletonLoaderController.typeName);
     this.loaderMap = new Map();
   }
   /**
@@ -953,6 +964,7 @@ class VegaSkeletonLoaderController {
     return skeletonContainer;
   }
 }
+VegaSkeletonLoaderController.typeName = 'VegaSkeletonLoaderController';
 VegaSkeletonLoaderController.LOADER_DATA_SET_KEY = 'vegaSkeletonLoaderKey';
 __decorate$1([
   InjectVegaTelemetrySlimmer()
@@ -1013,9 +1025,10 @@ var __decorate = (undefined && undefined.__decorate) || function (decorators, ta
  *
  * @vegaVersion 2.27.0
  */
-class TranslationController {
+class TranslationController extends Discriminated {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(TranslationController, ['init', 'changeLanguage'], VegaTranslationRuntimeMetricsPayloadDefinition, 'TranslationController');
+    super(...arguments);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(TranslationController, ['init', 'changeLanguage'], VegaTranslationRuntimeMetricsPayloadDefinition, TranslationController.typeName);
   }
   /**
    * Get current language
@@ -1045,6 +1058,7 @@ class TranslationController {
     VegaInternalTranslation.changeLanguage(language);
   }
 }
+TranslationController.typeName = 'TranslationController';
 __decorate([
   InjectVegaTelemetrySlimmer()
 ], TranslationController.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
@@ -1069,336 +1083,6 @@ class VegaCalendarPeriodFactory {
   }
 }
 
-/**
- * Base class for rendering extension toolbar button in the rich text editor.
- * The renderer provides common functionalities for rendering toolbar buttons, including:
- * - Rendering a button with an icon, label, and optional arrow icon.
- * - Rendering a dropdown with a list of items.
- * - Rendering dropdown items.
- * - Rendering template for dropdown list.
- * - Determining if the button should be disabled based on the editor context.
- * - Handling button and dropdown click events.
- * Override the methods to customize the rendering and behavior of the button.
- */
-class VegaRTEToolbarButtonRenderer {
-  constructor() {
-    this.dropdownEl = null;
-    this.itemsContainerEl = null;
-    this.buttonEl = null;
-  }
-  /**
-   * Checks if the button should be hidden.
-   *
-   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
-   * @returns {boolean} True if the button is hidden, false otherwise.
-   */
-  isHidden(editorContext) {
-    return editorContext.sourceEditMode;
-  }
-  /**
-   * Get the extension context for the given rich text editor host element.
-   *
-   * @typedef HTMLVegaRichTextEditorElement - The type definition for the rich text editor host element.
-   * @param {HTMLVegaRichTextEditorElement} el - The host rich text editor element.
-   * @returns {Nullable<RTEExtensionContext>} - The extension context associated with the host.
-   */
-  getExtensionContext(el) {
-    return extensionContextManager.getExtensionContext(el);
-  }
-  /**
-   * Renders a dropdown component with the specified properties and children.
-   *
-   * @param {VegaRTECreateElementFunction} h - Create element function.
-   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
-   * @param {RTEToolbarDropdownProps} dropdownProps - The properties for the dropdown.
-   * @param {VegaRTERenderResult[]} children - The children elements for the dropdown.
-   * @returns {VegaRTERenderResult} - The render result for the dropdown.
-   */
-  renderDropdown(h, editorContext, dropdownProps, children) {
-    return h('vega-dropdown', Object.assign({ trigger: 'click', searchable: false, maxWidth: '200', itemDisplayRule: 'ellipsis', isScreenPosition: true, role: 'presentation', 
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      ref: (el) => {
-        this.dropdownEl = el;
-        DomNodeSubjectObserverFactory.addUniqueObserverToNode(el, VegaDropdownClick, (input) => {
-          const payload = input;
-          this.handleDropdownClick(payload.detail, editorContext);
-        });
-      } }, dropdownProps), children);
-  }
-  /**
-   * Renders the dropdown list template.
-   *
-   * @param {VegaRTECreateElementFunction} h - Create element function.
-   * @param {(RTEDropdownListItem | RTEDropdownListGroup)[]} itemList - The list of dropdown items.
-   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
-   * @returns {VegaRTERenderResult} - The render result for the dropdown list.
-   */
-  renderDropdownListTemplate(h, itemList, editorContext) {
-    return h('div', {
-      slot: 'items',
-      onMouseDown: this.preventDefault,
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      onKeyDown: (e) => this.handleItemsKeyDown(e),
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      ref: (el) => {
-        this.itemsContainerEl = el;
-      },
-      class: 'rte-dropdown-list',
-    }, [
-      h('style', { nonce: vegaNonceManager.nonce }, '.rte-dropdown-list vega-dropdown-group vega-dropdown-group { padding-left: 4px }'),
-      ...itemList.map((item) => {
-        return 'children' in item
-          ? this.renderDropdownGroup(h, item, editorContext)
-          : this.renderDropdownItem(h, item, editorContext);
-      }),
-    ]);
-  }
-  /**
-   * Renders a dropdown item for the toolbar button.
-   *
-   * @param {VegaRTECreateElementFunction} h - Create element function.
-   * @param {RTEDropdownListItem} item - The dropdown item.
-   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
-   * @returns {VegaRTERenderResult} - The render result for the dropdown item.
-   */
-  renderDropdownItem(h, item, editorContext) {
-    return h('vega-dropdown-item', {
-      key: item.key,
-      itemKey: item.key,
-      label: editorContext.translation.t(item.label),
-      prefixIcon: item.icon,
-    });
-  }
-  /**
-   * Renders a dropdown group for the toolbar button.
-   *
-   * @param {VegaRTECreateElementFunction} h - Create element function.
-   * @param {RTEDropdownListGroup} item - The dropdown group.
-   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
-   * @returns {VegaRTERenderResult} - The render result for the dropdown group.
-   */
-  renderDropdownGroup(h, item, editorContext) {
-    return h('vega-dropdown-group', {
-      key: item.key,
-      label: editorContext.translation.t(item.label),
-      divide: false,
-    }, item.children.map((child) => {
-      return 'children' in child
-        ? this.renderDropdownGroup(h, child, editorContext)
-        : this.renderDropdownItem(h, child, editorContext);
-    }));
-  }
-  /**
-   * Renders a common toolbar button with optional icon, label, and arrow icon.
-   * When a tooltip is provided via `buttonProps.tooltip`, the button is wrapped
-   * in a `vega-tooltip` element, matching the behavior of default toolbar buttons.
-   *
-   * @param {VegaRTECreateElementFunction} h - Create element function.
-   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
-   * @param {RTEToolbarButtonProps} buttonProps - The properties for the button.
-   * @returns {VegaRTERenderResult} - The render result for the button.
-   */
-  renderButton(h, editorContext, buttonProps) {
-    const { icon, label, showArrowIcon, tooltip, ariaLabel } = buttonProps;
-    const isDisabled = this.isDisabled(editorContext);
-    const button = h('vega-rich-text-editor-toolbar-button', {
-      'disabled': isDisabled,
-      'icon': icon,
-      'data-aria-label': ariaLabel !== null && ariaLabel !== void 0 ? ariaLabel : label,
-      'hidden': this.isHidden(editorContext),
-      'selected': this.isSelected(editorContext),
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      'ref': (el) => {
-        this.buttonEl = el;
-        DomNodeSubjectObserverFactory.addUniqueObserverToNode(el, VegaClick, () => this.handleButtonClick(editorContext));
-      },
-      'onMouseDown': this.preventDefault,
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      'onKeyDown': (e) => this.handleButtonKeyDown(e),
-    }, [
-      this.renderButtonLabel(h, editorContext, label),
-      showArrowIcon
-        ? h('vega-icon', {
-          'size': 'size-8',
-          'color': isDisabled ? 'text-disabled' : 'text-secondary',
-          'style': { marginLeft: '8px' },
-          'aria-hidden': 'true',
-          'icon': VegaInternalIconManager.getIconKey('chevron-down'),
-        })
-        : null,
-    ].filter(isNonNullable));
-    if (tooltip === null || tooltip === void 0 ? void 0 : tooltip.text) {
-      return h('vega-tooltip', { text: editorContext.translation.t(tooltip.text), placement: ['bottom', 'top'] }, [button]);
-    }
-    return button;
-  }
-  /**
-   * Renders the button label.
-   *
-   * @param {VegaRTECreateElementFunction} h - Create element function.
-   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
-   * @param {Nullable<string>} label - The button label if exist.
-   * @returns {Nullable<VegaRTERenderResult>} - The render result for the button.
-   */
-  renderButtonLabel(h, editorContext, label) {
-    if (label) {
-      const isDisabled = this.isDisabled(editorContext);
-      return h('vega-font', {
-        'variant': 'font-field-label-sm',
-        'color': isDisabled ? 'text-disabled' : 'text-primary',
-        'aria-hidden': 'true',
-      }, editorContext.translation.t(label));
-    }
-    return null;
-  }
-  /**
-   * Determines if the button should be disabled based on the editor context.
-   *
-   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
-   * @returns {boolean} - True if the button should be disabled, false otherwise.
-   */
-  isDisabled(editorContext) {
-    return editorContext.host.disabled;
-  }
-  /**
-   * Checks if the button should be selected.
-   *
-   * @param {VegaRTEToolbarRenderContext} _editorContext The render context for the editor.
-   * @returns {boolean} True if the button is selected, false otherwise.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  isSelected(_editorContext) {
-    return false;
-  }
-  /**
-   * Prevents the default action of the click event. This is to avoid losing focus from the editor when the button is clicked.
-   *
-   * @param {MouseEvent} e The mouse event to prevent default action for.
-   */
-  preventDefault(e) {
-    e.preventDefault();
-  }
-  /**
-   * Moves focus to the toolbar button. Targets the inner focusable `<button>`
-   * inside the button's shadow root, falling back to the host element.
-   */
-  focusToolbarButton() {
-    var _a, _b, _c, _d;
-    const innerButton = (_c = (_b = (_a = this.buttonEl) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('button')) !== null && _c !== void 0 ? _c : null;
-    (_d = (innerButton !== null && innerButton !== void 0 ? innerButton : this.buttonEl)) === null || _d === void 0 ? void 0 : _d.focus();
-  }
-  /**
-   * Recursively searches for a dropdown list item by its key.
-   *
-   * @param {(RTEDropdownListItem | RTEDropdownListGroup)[]} itemList The list of dropdown items or groups to search through.
-   * @param {string} key The key of the item to find.
-   * @returns {Nullable<RTEDropdownListItem>} The dropdown list item if found, otherwise null.
-   */
-  getListItemByKey(itemList, key) {
-    for (const item of itemList) {
-      if ('children' in item) {
-        const foundItem = this.getListItemByKey(item.children, key);
-        if (foundItem) {
-          return foundItem;
-        }
-      }
-      else if (item.key === key) {
-        return item;
-      }
-    }
-    return null;
-  }
-  /**
-   * Handles keyboard events on the toolbar button to support dropdown keyboard accessibility.
-   * - Enter / Space: Toggles the dropdown open/closed.
-   * - ArrowDown / ArrowUp: Opens the dropdown and focuses the first/last item.
-   *
-   * @param {KeyboardEvent} e The keyboard event.
-   */
-  handleButtonKeyDown(e) {
-    if (!this.dropdownEl) {
-      return;
-    }
-    if (e.code === 'Enter' || e.code === 'Space') {
-      e.preventDefault();
-      e.stopPropagation();
-      this.dropdownEl.dispatchEvent(new MouseEvent('click', { bubbles: true }));
-    }
-    else if (e.code === 'ArrowDown' || e.code === 'ArrowUp') {
-      e.preventDefault();
-      e.stopPropagation();
-      void this.dropdownEl.show().then(() => {
-        this.focusDropdownItem(e.code === 'ArrowDown' ? 'first' : 'last');
-      });
-    }
-  }
-  /**
-   * Handles keyboard navigation within the dropdown items container.
-   * - ArrowDown/ArrowUp: Moves focus to the next/previous non-disabled item.
-   * - Escape: Closes the dropdown and returns focus to the toolbar button.
-   *
-   * @param {KeyboardEvent} e The keyboard event.
-   */
-  handleItemsKeyDown(e) {
-    var _a, _b;
-    if (e.code === 'Escape') {
-      e.preventDefault();
-      e.stopPropagation();
-      if (this.dropdownEl) {
-        void this.dropdownEl.hide();
-      }
-      this.focusToolbarButton();
-      return;
-    }
-    if (e.code !== 'ArrowDown' && e.code !== 'ArrowUp') {
-      return;
-    }
-    e.preventDefault();
-    e.stopPropagation();
-    const items = this.getDropdownItems();
-    if (items.length === 0) {
-      return;
-    }
-    const currentIndex = items.findIndex((item) => { var _a, _b; return ((_a = item.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('li')) === ((_b = item.shadowRoot) === null || _b === void 0 ? void 0 : _b.activeElement); });
-    const direction = e.code === 'ArrowDown' ? 1 : -1;
-    const startIndex = currentIndex === -1 ? (e.code === 'ArrowDown' ? 0 : items.length - 1) : currentIndex + direction;
-    for (let offset = 0; offset < items.length; offset++) {
-      const index = (startIndex + offset * direction + items.length) % items.length;
-      if (!items[index].disabled) {
-        (_b = (_a = items[index].shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('li')) === null || _b === void 0 ? void 0 : _b.focus();
-        return;
-      }
-    }
-  }
-  /**
-   * Focuses the first or last non-disabled dropdown item.
-   *
-   * @param {'first' | 'last'} position Whether to focus the first or last item.
-   */
-  focusDropdownItem(position) {
-    var _a, _b;
-    const items = this.getDropdownItems();
-    const orderedItems = position === 'first' ? items : [...items].reverse();
-    for (const item of orderedItems) {
-      if (!item.disabled) {
-        (_b = (_a = item.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('li')) === null || _b === void 0 ? void 0 : _b.focus();
-        return;
-      }
-    }
-  }
-  /**
-   * Gets all dropdown items from the items container.
-   *
-   * @returns {HTMLVegaDropdownItemElement[]} Array of dropdown item elements.
-   */
-  getDropdownItems() {
-    if (!this.itemsContainerEl) {
-      return [];
-    }
-    return Array.from(this.itemsContainerEl.querySelectorAll('vega-dropdown-item'));
-  }
-}
-
 /**
  * Action to insert a token node at a specified range in the Rich Text Editor.
  *
@@ -1506,7 +1190,6 @@ class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
 class RTETokenNode extends RTETextNode {
   constructor(id, token, text, parentBlock, annotations) {
     super(id, text, parentBlock, annotations);
-    this.dtoName = RTETokenNode.dtoName;
     this.type = 'token';
     this.token = token;
     this.text = text;
@@ -1597,7 +1280,7 @@ class RTETokenNode extends RTETextNode {
     return attrs.length > 0 ? ` ${attrs.join(' ')}` : '';
   }
 }
-RTETokenNode.dtoName = 'RTETokenNode';
+RTETokenNode.typeName = 'RTETokenNode';
 
 /**
  * Token node renderer for the rich text editor.
@@ -1659,6 +1342,7 @@ class RTETokenNodeRenderer extends VegaRTEExtensionRenderer {
     return result;
   }
 }
+RTETokenNodeRenderer.typeName = 'RTETokenNodeRenderer';
 
 /**
  * Toolbar button renderer for language selection in Vega Rich Text Editor.
@@ -1945,98 +1629,273 @@ const FUNCTION_ELEMENT_CLASSES = [
 ];
 
 /**
- * RTE Function Block
+ * Class representing a logic control node in the rich text editor.
  */
-class RTEFunctionBlock extends RTEBlock {
-  constructor(id) {
+class RTELogicControlNode extends RTENode {
+  constructor(id, text, parent) {
     super(id);
-    this.dtoName = RTEFunctionBlock.dtoName;
-    this.type = 'function-block';
-    this.children = [];
+    this.type = 'logic-control-node';
+    this.text = '';
+    this.text = text;
+    this.parent = parent;
   }
   /**
-   * Creates an RTEFunctionBlock from a VegaFunctionBlock.
+   * Clone the current node instance.
    *
-   * @param {VegaFunctionBlock} block - The custom block to convert.
-   * @param {VegaRTETransformOptions} [options] - Optional transformation options.
-   * @returns {RTEFunctionBlock} The resulting RTEFunctionBlock.
+   * @returns {RTELogicControlNode} - A new instance of RTELogicControlNode.
    */
-  static from(block, options) {
-    const functionBlock = new RTEFunctionBlock(block.id);
-    const defaultAnnotation = { customClass: [FUNCTION_BLOCK_CLASS] };
-    let { annotations } = block;
-    annotations = annotations
-      ? Object.assign(Object.assign({}, annotations), defaultAnnotation) : defaultAnnotation;
-    super.convertAnnotationsToMap(functionBlock.annotationMap, annotations);
-    functionBlock.children = this.generateBlockChildren(block.children, options, functionBlock);
-    return functionBlock;
+  clone() {
+    return new RTELogicControlNode(this.id, this.text, this.parent);
   }
   /**
-   * Converts the RTEFunctionBlock and its children to an HTML string.
+   * Convert the node to its HTML representation.
    *
-   * @returns {string} The HTML string representation of the function block.
+   * @returns {string} - The HTML string of the logic control node.
    */
   toHtml() {
-    const childrenHtml = this.children
-      .map((child) => {
-      if (child instanceof RTETextBlock) {
-        const attrStr = this.getFunctionContentStyle(child);
-        return `<div class="${FUNCTION_CONTENT_CLASS}"${attrStr}>${child.getChildrenHtml()}</div>`;
-      }
-      else {
-        return child.toHtml();
-      }
-    })
-      .join('');
-    return `<div class="${FUNCTION_BLOCK_CLASS}" ${RTE_BLOCK_BOUNDARY_ATTRIBUTE}>${childrenHtml}</div>`;
+    return this.text;
   }
   /**
-   * @inheritDoc
+   * Convert the node to a JSON representation.
+   *
+   * @returns {unknown} - The JSON object of the statement syntax node.
    */
-  clone(parent) {
-    const clonedBlock = new RTEFunctionBlock(generateUUID());
-    clonedBlock.parent = parent;
-    clonedBlock.children = this.children.map((child) => {
-      const clonedChild = child.clone(clonedBlock);
-      return clonedChild;
-    });
-    clonedBlock.annotationMap = super.cloneAnnotations();
-    return clonedBlock;
+  toJSON() {
+    return {
+      id: this.id,
+      type: this.type,
+      text: this.text,
+    };
   }
   /**
-   * @inheritDoc
+   * Get the end offset of the node's range.
+   *
+   * @returns {number} - The end offset of the node's range.
    */
-  getLastNode() {
-    return this.children[this.children.length - 1].getLastNode();
+  getRangeEndOffset() {
+    return 1;
   }
   /**
-   * The function block is an atomic caret boundary: descending would resolve the caret onto a
-   * `contenteditable="false"` logic-control node instead of staying anchored to the block.
+   * Get the container element for the node's range.
    *
-   * @inheritDoc
+   * @returns {Nullable<Node>} - The container node for the range.
    */
-  allowsCaretDescend() {
-    return false;
+  getRangeContainer() {
+    const element = stateEntityRenderingRegistry.getDOMByEntity(this);
+    if (element) {
+      return element.parentElement;
+    }
   }
   /**
-   * @inheritDoc
+   * Get the content editable state of the node.
+   *
+   * @returns {boolean} - The content editable state of the node.
    */
-  isNotEmpty() {
-    return this.children.length > 0;
+  isContentEditable() {
+    return false;
   }
   /**
    * @inheritDoc
    */
-  toJSON() {
-    return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: this.type, children: this.children.map((child) => child.toJSON()) });
+  getPlainText() {
+    return this.text;
   }
-  /**
-   * Get the style string for function content block, excluding default paragraph styles.
-   *
-   * @param {RTETextBlock} block - The text block to extract styles from
-   * @returns {string} - The style attribute string
-   */
-  getFunctionContentStyle(block) {
+}
+RTELogicControlNode.typeName = 'RTELogicControlNode';
+
+/**
+ * Class representing a logic control block in the rich text editor.
+ */
+class RTELogicControlBlock extends 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
+ */
+class RTEFunctionBlock extends RTEBlock {
+  constructor(id) {
+    super(id);
+    this.type = 'function-block';
+    this.children = [];
+  }
+  /**
+   * Creates an RTEFunctionBlock from a VegaFunctionBlock.
+   *
+   * @param {VegaFunctionBlock} block - The custom block to convert.
+   * @param {VegaRTETransformOptions} [options] - Optional transformation options.
+   * @returns {RTEFunctionBlock} The resulting RTEFunctionBlock.
+   */
+  static from(block, options) {
+    const functionBlock = new RTEFunctionBlock(block.id);
+    const defaultAnnotation = { customClass: [FUNCTION_BLOCK_CLASS] };
+    let { annotations } = block;
+    annotations = annotations
+      ? 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 RTETextBlock)) {
+        return;
+      }
+      contentBlock.children.forEach((node) => {
+        const inlineHtml = node.getAnnotationByType(NodeAnnotationTypeEnum.INLINE_HTML);
+        if ((inlineHtml === null || inlineHtml === void 0 ? void 0 : inlineHtml.htmlTag) !== 'div')
+          return;
+        if (inlineHtml.child) {
+          node.annotationMap.set(NodeAnnotationTypeEnum.INLINE_HTML, inlineHtml.child);
+        }
+        else {
+          node.annotationMap.delete(NodeAnnotationTypeEnum.INLINE_HTML);
+        }
+      });
+    });
+  }
+  /**
+   * Converts the RTEFunctionBlock and its children to an HTML string.
+   *
+   * @returns {string} The HTML string representation of the function block.
+   */
+  toHtml() {
+    const childrenHtml = this.children
+      .map((child) => {
+      if (child instanceof RTETextBlock) {
+        const attrStr = this.getFunctionContentStyle(child);
+        return `<div class="${FUNCTION_CONTENT_CLASS}"${attrStr}>${child.getChildrenHtml()}</div>`;
+      }
+      else {
+        return child.toHtml();
+      }
+    })
+      .join('');
+    return `<div class="${FUNCTION_BLOCK_CLASS}" ${RTE_BLOCK_BOUNDARY_ATTRIBUTE}>${childrenHtml}</div>`;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    const clonedBlock = new RTEFunctionBlock(generateUUID());
+    clonedBlock.parent = parent;
+    clonedBlock.children = this.children.map((child) => {
+      const clonedChild = child.clone(clonedBlock);
+      return clonedChild;
+    });
+    clonedBlock.annotationMap = super.cloneAnnotations();
+    return clonedBlock;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastNode() {
+    return this.children[this.children.length - 1].getLastNode();
+  }
+  /**
+   * The function block is an atomic caret boundary: descending would resolve the caret onto a
+   * `contenteditable="false"` logic-control node instead of staying anchored to the block.
+   *
+   * @inheritDoc
+   */
+  allowsCaretDescend() {
+    return false;
+  }
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty() {
+    return this.children.length > 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: this.type, children: this.children.map((child) => child.toJSON()) });
+  }
+  /**
+   * Get the style string for function content block, excluding default paragraph styles.
+   *
+   * @param {RTETextBlock} block - The text block to extract styles from
+   * @returns {string} - The style attribute string
+   */
+  getFunctionContentStyle(block) {
     const blockAnnotationStyle = new RTEAnnotationStyle(block);
     let styles = blockAnnotationStyle.toCssText({ standalone: true });
     const textStyleAnnotation = block.getAnnotationByType('TEXT_STYLE');
@@ -2047,7 +1906,7 @@ class RTEFunctionBlock extends RTEBlock {
     return styles ? ` style="${styles}"` : '';
   }
 }
-RTEFunctionBlock.dtoName = 'RTEFunctionBlock';
+RTEFunctionBlock.typeName = 'RTEFunctionBlock';
 
 /**
  * Strategy to handle the insertion of a function block into the rich text editor.
@@ -2144,202 +2003,52 @@ class InsertFunctionBlockStrategy extends ActionHandleStrategy {
 }
 
 /**
- * Class representing a logic control node in the rich text editor.
+ * Function toolbar button renderer class.
  */
-class RTELogicControlNode extends RTENode {
-  constructor(id, text, parent) {
-    super(id);
-    this.dtoName = RTELogicControlNode.dtoName;
-    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 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 = 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.
-   */
-  getRangeContainer() {
-    const element = 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.dtoName = 'RTELogicControlNode';
-
-/**
- * Class representing a logic control block in the rich text editor.
- */
-class RTELogicControlBlock extends RTEBlock {
-  constructor(id, statementText, parent) {
-    super(id);
-    this.dtoName = RTELogicControlBlock.dtoName;
-    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.dtoName = 'RTELogicControlBlock';
-
-/**
- * Function toolbar button renderer class.
- */
-class FunctionToolbarButtonRenderer extends 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 = 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.
+   * @param {RTEExtensionFunctionType} itemKey - key of the clicked item
+   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
    */
   handleDropdownClick(itemKey, editorContext) {
     if (editorContext) {
@@ -2385,6 +2094,7 @@ class RTELogicControlBlockRenderer extends VegaRTEExtensionRenderer {
     }, renderData.statementText));
   }
 }
+RTELogicControlBlockRenderer.typeName = 'RTELogicControlBlockRenderer';
 
 /**
  * Returns true when the element belongs to function extension blocks by semantic
@@ -2510,6 +2220,7 @@ class DivToFunctionBlockStrategy extends ElementToDTOStrategy {
    * @inheritDoc
    */
   appendChildBlocks(currentBlock, childBlocks) {
+    RTEFunctionBlock.unwrapForeachContent(childBlocks);
     currentBlock.children = childBlocks.map((block) => {
       block.parent = currentBlock;
       return block;
@@ -2601,12 +2312,7 @@ class RTEFunctionBlockRenderer extends VegaRTEExtensionRenderer {
     return classes.trim();
   }
 }
-
-/**
- * Abstract class for action handler interceptors, which can intercept actions before they are handled.
- */
-class ActionHandlerInterceptor {
-}
+RTEFunctionBlockRenderer.typeName = 'RTEFunctionBlockRenderer';
 
 /**
  * Prevent special type input in function block.
@@ -2778,8 +2484,8 @@ class VegaRTEFunctionExtension extends VegaRTEExtension {
   constructor() {
     super();
     this.unregisterBlockBoundaryPredicate = null;
-    this.registerBlockBasicStrategies(RTELogicControlBlock.name);
-    this.registerBlockBasicStrategies(RTEFunctionBlock.name);
+    this.registerBlockBasicStrategies(RTELogicControlBlock.typeName);
+    this.registerBlockBasicStrategies(RTEFunctionBlock.typeName);
     this.preventFunctionBlockDefaultInsertNewParagraph();
     this.registerNode('logic-control-block', RTELogicControlBlock);
     this.registerRenderer('logic-control-block', new RTELogicControlBlockRenderer());
@@ -2811,23 +2517,23 @@ class VegaRTEFunctionExtension extends VegaRTEExtension {
    * Remove the appen children strategies to prevent default insert new paragraph logic in function block
    */
   preventFunctionBlockDefaultInsertNewParagraph() {
-    this.unRegisterStrategy(ModifyContentActionType.INSERT_NEW_PARAGRAPH, RTELogicControlBlock.name);
-    this.unRegisterStrategy(ModifyContentActionType.APPEND_CHILDREN, RTEFunctionBlock.name);
-    this.unRegisterStrategy(ModifyContentActionType.INSERT_CHILDREN_AFTER, RTEFunctionBlock.name);
-    this.unRegisterStrategy(ModifyContentActionType.INSERT_CHILDREN_BEFORE, RTEFunctionBlock.name);
-    this.unRegisterStrategy(ModifyContentActionType.PASTE_CONTENT, RTELogicControlBlock.name);
-    VegaRTEExtension.registerActionHandleStrategy(RTEFunctionBlock.name, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new FunctionBlockInsertParagraphStrategy());
+    this.unRegisterStrategy(ModifyContentActionType.INSERT_NEW_PARAGRAPH, RTELogicControlBlock.typeName);
+    this.unRegisterStrategy(ModifyContentActionType.APPEND_CHILDREN, RTEFunctionBlock.typeName);
+    this.unRegisterStrategy(ModifyContentActionType.INSERT_CHILDREN_AFTER, RTEFunctionBlock.typeName);
+    this.unRegisterStrategy(ModifyContentActionType.INSERT_CHILDREN_BEFORE, RTEFunctionBlock.typeName);
+    this.unRegisterStrategy(ModifyContentActionType.PASTE_CONTENT, RTELogicControlBlock.typeName);
+    VegaRTEExtension.registerActionHandleStrategy(RTEFunctionBlock.typeName, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new FunctionBlockInsertParagraphStrategy());
   }
 }
 (() => {
   const insertFunctionBlockStrategy = new InsertFunctionBlockStrategy();
-  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.name, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTETextBlock.name, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTEImageBlock.name, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTELogicControlBlock.name, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTETextBlock.name, PASTE_PLAIN_TEXT, new PastePlainTextStrategy());
-  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.name, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new PreventNewParagraphInterceptor());
-  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.name, ModifyContentActionType.PASTE_CONTENT, new PreventPasteContentInterceptor());
+  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.typeName, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTETextBlock.typeName, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEImageBlock.typeName, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTELogicControlBlock.typeName, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTETextBlock.typeName, PASTE_PLAIN_TEXT, new PastePlainTextStrategy());
+  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.typeName, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new PreventNewParagraphInterceptor());
+  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.typeName, ModifyContentActionType.PASTE_CONTENT, new PreventPasteContentInterceptor());
 })();
 VegaRTEFunctionExtension.TOOLBAR_BUTTON_KEY = 'functions';
 
@@ -2928,7 +2634,6 @@ var __rest$3 = (undefined && undefined.__rest) || function (s, e) {
 class RTETableCaptionBlock extends RTEBlock {
   constructor(id, options) {
     super(id);
-    this.dtoName = RTETableCaptionBlock.dtoName;
     this.type = 'table-caption';
     const { autoMatchFormat } = options || { autoMatchFormat: true };
     if (autoMatchFormat) {
@@ -2987,11 +2692,12 @@ class RTETableCaptionBlock extends RTEBlock {
     return Object.assign(Object.assign({}, super.toJSON()), { type: this.type, children: this.children.map((child) => child.toJSON()) });
   }
 }
+RTETableCaptionBlock.typeName = 'RTETableCaptionBlock';
+// eslint-disable-next-line @globalpayments/vega-eslint/vega-class-member-order-rule
 (() => {
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_CHILDREN_BEFORE, RTETableCaptionBlock.name, new InsertChildrenBeforeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.PASTE_CONTENT, RTETableCaptionBlock.name, new PasteContentStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_CHILDREN_BEFORE, RTETableCaptionBlock.typeName, new InsertChildrenBeforeStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.PASTE_CONTENT, RTETableCaptionBlock.typeName, new PasteContentStrategy());
 })();
-RTETableCaptionBlock.dtoName = 'RTETableCaptionBlock';
 
 const TOGGLE_TABLE_CAPTION = 'TOGGLE_TABLE_CAPTION';
 /**
@@ -3164,6 +2870,7 @@ class UpdateTablePropertiesAction extends AnnotationAction {
     return new RTETableAnnotation(this.tableProperties);
   }
 }
+UpdateTablePropertiesAction.typeName = 'UpdateTablePropertiesAction';
 
 /**
  * Cancel Event handler for the table properties.
@@ -3249,6 +2956,7 @@ class RTETableCellAnnotationsAction extends AnnotationAction {
     });
   }
 }
+RTETableCellAnnotationsAction.typeName = 'RTETableCellAnnotationsAction';
 
 /**
  * Action to apply annotations to a table head cell.
@@ -3266,6 +2974,7 @@ class RTETableHeadCellAnnotationsAction extends RTETableCellAnnotationsAction {
     return this.originAnnotation;
   }
 }
+RTETableHeadCellAnnotationsAction.typeName = 'RTETableHeadCellAnnotationsAction';
 
 var __rest$1 = (undefined && undefined.__rest) || function (s, e) {
   var t = {};
@@ -4515,6 +4224,7 @@ class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
     this.tableToolbar = null;
   }
 }
+RTETableBlockRenderer.typeName = 'RTETableBlockRenderer';
 
 /**
  * Renders a logic control block in the rich text editor.
@@ -4530,6 +4240,7 @@ class RTETableHeadRenderer extends VegaRTEExtensionRenderer {
     });
   }
 }
+RTETableHeadRenderer.typeName = 'RTETableHeadRenderer';
 
 /**
  * Renders a logic control block in the rich text editor.
@@ -4545,6 +4256,7 @@ class RTETableRowBlockRenderer extends VegaRTEExtensionRenderer {
     });
   }
 }
+RTETableRowBlockRenderer.typeName = 'RTETableRowBlockRenderer';
 
 /**
  * Renders a table cell block in the rich text editor.
@@ -4616,6 +4328,7 @@ class RTETableCellRenderer extends VegaRTEExtensionRenderer {
     };
   }
 }
+RTETableCellRenderer.typeName = 'RTETableCellRenderer';
 
 /**
  * Renders a table body block in the rich text editor.
@@ -4631,6 +4344,7 @@ class RTETableBodyRenderer extends VegaRTEExtensionRenderer {
     });
   }
 }
+RTETableBodyRenderer.typeName = 'RTETableBodyRenderer';
 
 /**
  * Renders a head cell block in the rich text editor.
@@ -4643,6 +4357,7 @@ class RTETableHeadCellRenderer extends RTETableCellRenderer {
     return super.renderByCellType(h, renderData, rteContext, 'th');
   }
 }
+RTETableHeadCellRenderer.typeName = 'RTETableHeadCellRenderer';
 
 const INSERT_TABLE_BLOCK = 'INSERT_TABLE_BLOCK';
 /**
@@ -5035,6 +4750,7 @@ class RTETableCaptionRenderer extends VegaRTEExtensionRenderer {
         .join(' '), 'data-placeholder': TABLE_CAPTION_PLACEHOLDER_TEXT }));
   }
 }
+RTETableCaptionRenderer.typeName = 'RTETableCaptionRenderer';
 
 /**
  * Abstract base strategy for table row actions. Provides common utilities for row manipulations.
@@ -7227,7 +6943,7 @@ class TableAnnotationHandler extends TableAnnotationHandlerBase {
    * @inheritDoc
    */
   canHandle(targetDto) {
-    return targetDto.dtoName === 'RTETableBlock';
+    return targetDto.typeName === 'RTETableBlock';
   }
   /**
    * Handle annotation extraction from table element.
@@ -7295,7 +7011,7 @@ class TableCellAnnotationHandler extends TableAnnotationHandlerBase {
    * @inheritDoc
    */
   canHandle(targetDto) {
-    return targetDto.dtoName === 'RTETableCellBlock';
+    return targetDto.typeName === 'RTETableCellBlock';
   }
   /**
    * Handle annotation extraction from table cell element.
@@ -7404,7 +7120,7 @@ class TableHeadCellAnnotationHandler extends TableCellAnnotationHandler {
    * @inheritDoc
    */
   canHandle(targetDto) {
-    return targetDto.dtoName === 'RTETableHeadCellBlock';
+    return targetDto.typeName === 'RTETableHeadCellBlock';
   }
 }
 
@@ -7884,7 +7600,7 @@ class TableBlockFilterStylesStrategy extends RTEFilterStylesStrategy {
    * @inheritDoc
    */
   canFilter(blockOrNodeInstance) {
-    return this.isTableBlock(blockOrNodeInstance.dtoName);
+    return this.isTableBlock(blockOrNodeInstance.typeName);
   }
   /**
    * @inheritDoc
@@ -7922,7 +7638,7 @@ class TableCaptionFilterStylesStrategy extends RTEFilterStylesStrategy {
    * @inheritDoc
    */
   canFilter(blockOrNodeInstance) {
-    return this.isTableCaption(blockOrNodeInstance.dtoName);
+    return this.isTableCaption(blockOrNodeInstance.typeName);
   }
   /**
    * @inheritDoc
@@ -7964,7 +7680,7 @@ class TableCellFilterStylesStrategy extends RTEFilterStylesStrategy {
    * @inheritDoc
    */
   canFilter(blockOrNodeInstance) {
-    return this.isTableCell(blockOrNodeInstance.dtoName);
+    return this.isTableCell(blockOrNodeInstance.typeName);
   }
   /**
    * The table cell border color can be represented in different formats (e.g., hex, rgb), so we need to ensure that we can handle both cases.
@@ -8028,12 +7744,12 @@ class VegaRTETableExtension extends VegaRTEExtension {
     this.tableSelection = new RTETableSelection();
     RTETableColorManager.setTableColors(colors);
     this.registerToolbarButtonRenderer(VegaRTETableExtension.TOOLBAR_BUTTON_KEY, this.toolbarButtonRenderer);
-    this.registerBlockBasicStrategies(RTETableBlock.name);
-    this.registerBlockBasicStrategies(RTETableHeadBlock.name);
-    this.registerBlockBasicStrategies(RTETableHeadCellBlock.name);
-    this.registerBlockBasicStrategies(RTETableRowBlock.name);
-    this.registerBlockBasicStrategies(RTETableCellBlock.name);
-    this.registerBlockBasicStrategies(RTETableBodyBlock.name);
+    this.registerBlockBasicStrategies(RTETableBlock.typeName);
+    this.registerBlockBasicStrategies(RTETableHeadBlock.typeName);
+    this.registerBlockBasicStrategies(RTETableHeadCellBlock.typeName);
+    this.registerBlockBasicStrategies(RTETableRowBlock.typeName);
+    this.registerBlockBasicStrategies(RTETableCellBlock.typeName);
+    this.registerBlockBasicStrategies(RTETableBodyBlock.typeName);
     this.registerRenderer('table-block', this.tableBlockRenderer);
     this.registerRenderer('table-head', new RTETableHeadRenderer());
     this.registerRenderer('table-head-cell', this.tableHeadCellRenderer);
@@ -8080,41 +7796,41 @@ class VegaRTETableExtension extends VegaRTEExtension {
 (() => {
   const insertTableBlockStrategy = new InsertTableBlockStrategy();
   const deleteTableBlockStrategy = new DeleteTableBlockStrategy();
-  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.name, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.typeName, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
   // Registered on the table block itself (not its parent) so a table can always be
   // deleted regardless of which block type it is nested in (root content, table cell,
   // blockquote, or any future container).
-  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, DELETE_TABLE_BLOCK, deleteTableBlockStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTETextBlock.name, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTEImageBlock.name, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, new InsertTableRowIntoDifferentSectionStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, INSERT_TABLE_ROW_INTO_SAME_SECTION, new InsertTableRowIntoSameSectionStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, DELETE_TABLE_ROW, new DeleteTableRowStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, TOGGLE_HEADER_ROW, new ToggleHeaderRowStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, INSERT_TABLE_COLUMN, new InsertTableColumnStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, DELETE_TABLE_COLUMN, new DeleteTableColumnStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, TOGGLE_HEADER_TABLE_COLUMN, new ToggleHeaderTableColumnStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableRowBlock.name, SPLIT_TABLE_CELL, new SplitTableCellStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableRowBlock.name, CREATE_SEGMENT_TABLE_CELL, new CreateSegmentTableCellStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableRowBlock.name, REPLACE_TABLE_CELL, new ReplaceTableCellStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.name, SPLIT_CELL_HORIZONTALLY, new SplitCellHorizontallyStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.name, SPLIT_CELL_VERTICALLY, new SplitCellVerticallyStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.name, SPLIT_CELL_HORIZONTALLY, new SplitCellHorizontallyStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.name, SPLIT_CELL_VERTICALLY, new SplitCellVerticallyStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, SELECT_TABLE_COLUMN, new SelectTableColumnStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, MERGE_CELLS, new MergeCellsStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, UpdateTablePropertiesAction.name, new UpdateTablePropertiesStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.name, RTETableCellAnnotationsAction.name, new UpdateTableCellPropertiesStrategy());
-  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.name, RTETableHeadCellAnnotationsAction.name, new UpdateTableCellPropertiesStrategy());
-  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.name, ModifyContentActionType.DELETE_BLOCK_CONTENT, new PreventCellContentDeleteInterceptor());
-  VegaRTEExtension.registerActionHandlerInterceptor(RTETableRowBlock.name, ModifyContentActionType.INSERT_CHILDREN_BEFORE, new PreventRowInsertInterceptor());
-  VegaRTEExtension.registerActionHandlerInterceptor(RTETableCellBlock.name, ModifyContentActionType.DELETE_CHILDREN, new PreventCellChildrenRemoveInterceptor());
-  VegaRTEExtension.registerActionHandlerInterceptor(RTETableHeadCellBlock.name, ModifyContentActionType.DELETE_CHILDREN, new PreventCellChildrenRemoveInterceptor());
-  VegaRTEExtension.registerActionHandlerInterceptor(RTETableBlock.name, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new PreventTableInsertParagraphInterceptor());
-  VegaRTEExtension.registerFilterStylesStrategy(RTETableBlock.dtoName, new TableBlockFilterStylesStrategy());
-  VegaRTEExtension.registerFilterStylesStrategy(RTETableCaptionBlock.dtoName, new TableCaptionFilterStylesStrategy());
-  VegaRTEExtension.registerFilterStylesStrategy(RTETableCellBlock.dtoName, new TableCellFilterStylesStrategy());
-  VegaRTEExtension.registerFilterStylesStrategy(RTETableHeadCellBlock.dtoName, new TableCellFilterStylesStrategy('th'));
+  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.typeName, DELETE_TABLE_BLOCK, deleteTableBlockStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTETextBlock.typeName, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEImageBlock.typeName, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.typeName, INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, new InsertTableRowIntoDifferentSectionStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.typeName, INSERT_TABLE_ROW_INTO_SAME_SECTION, new InsertTableRowIntoSameSectionStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.typeName, DELETE_TABLE_ROW, new DeleteTableRowStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.typeName, TOGGLE_HEADER_ROW, new ToggleHeaderRowStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.typeName, INSERT_TABLE_COLUMN, new InsertTableColumnStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.typeName, DELETE_TABLE_COLUMN, new DeleteTableColumnStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.typeName, TOGGLE_HEADER_TABLE_COLUMN, new ToggleHeaderTableColumnStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableRowBlock.typeName, SPLIT_TABLE_CELL, new SplitTableCellStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableRowBlock.typeName, CREATE_SEGMENT_TABLE_CELL, new CreateSegmentTableCellStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableRowBlock.typeName, REPLACE_TABLE_CELL, new ReplaceTableCellStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.typeName, SPLIT_CELL_HORIZONTALLY, new SplitCellHorizontallyStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.typeName, SPLIT_CELL_VERTICALLY, new SplitCellVerticallyStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.typeName, SPLIT_CELL_HORIZONTALLY, new SplitCellHorizontallyStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.typeName, SPLIT_CELL_VERTICALLY, new SplitCellVerticallyStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.typeName, SELECT_TABLE_COLUMN, new SelectTableColumnStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.typeName, MERGE_CELLS, new MergeCellsStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.typeName, UpdateTablePropertiesAction.typeName, new UpdateTablePropertiesStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.typeName, RTETableCellAnnotationsAction.typeName, new UpdateTableCellPropertiesStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.typeName, RTETableHeadCellAnnotationsAction.typeName, new UpdateTableCellPropertiesStrategy());
+  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.typeName, ModifyContentActionType.DELETE_BLOCK_CONTENT, new PreventCellContentDeleteInterceptor());
+  VegaRTEExtension.registerActionHandlerInterceptor(RTETableRowBlock.typeName, ModifyContentActionType.INSERT_CHILDREN_BEFORE, new PreventRowInsertInterceptor());
+  VegaRTEExtension.registerActionHandlerInterceptor(RTETableCellBlock.typeName, ModifyContentActionType.DELETE_CHILDREN, new PreventCellChildrenRemoveInterceptor());
+  VegaRTEExtension.registerActionHandlerInterceptor(RTETableHeadCellBlock.typeName, ModifyContentActionType.DELETE_CHILDREN, new PreventCellChildrenRemoveInterceptor());
+  VegaRTEExtension.registerActionHandlerInterceptor(RTETableBlock.typeName, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new PreventTableInsertParagraphInterceptor());
+  VegaRTEExtension.registerFilterStylesStrategy(RTETableBlock.typeName, new TableBlockFilterStylesStrategy());
+  VegaRTEExtension.registerFilterStylesStrategy(RTETableCaptionBlock.typeName, new TableCaptionFilterStylesStrategy());
+  VegaRTEExtension.registerFilterStylesStrategy(RTETableCellBlock.typeName, new TableCellFilterStylesStrategy());
+  VegaRTEExtension.registerFilterStylesStrategy(RTETableHeadCellBlock.typeName, new TableCellFilterStylesStrategy('th'));
 })();
 VegaRTETableExtension.TOOLBAR_BUTTON_KEY = 'table';
 
@@ -8149,6 +7865,7 @@ class RTEHorizontalLineNode extends RTEDecoratorNode {
     return '<hr>';
   }
 }
+RTEHorizontalLineNode.typeName = 'RTEHorizontalLineNode';
 
 /**
  * Predicate class provides static methods to check specific conditions on HTML elements or dto instances.
@@ -8193,7 +7910,7 @@ class HorizontalLineFilterStylesStrategy extends RTEFilterStylesStrategy {
    * @inheritDoc
    */
   canFilter(blockOrNodeInstance) {
-    return Predicate.isHorizontalLineBlock(blockOrNodeInstance.dtoName);
+    return Predicate.isHorizontalLineBlock(blockOrNodeInstance.typeName);
   }
   /**
    * @inheritDoc
@@ -8277,7 +7994,6 @@ class HorizontalLineAnnotation extends BlockAnnotation {
 class RTEHorizontalLineBlock extends RTEBlock {
   constructor(id, options) {
     super(id);
-    this.dtoName = RTEHorizontalLineBlock.dtoName;
     this.type = 'horizontal-line';
     this.children = [];
     const { autoMatchFormat = true } = options !== null && options !== void 0 ? options : {};
@@ -8355,7 +8071,7 @@ class RTEHorizontalLineBlock extends RTEBlock {
     return clonedBlock;
   }
 }
-RTEHorizontalLineBlock.dtoName = 'RTEHorizontalLineBlock';
+RTEHorizontalLineBlock.typeName = 'RTEHorizontalLineBlock';
 
 const horizontalLineBlockStylesCss = ".v-rte-horizontal-line{padding:8px 0;overflow:hidden}.v-rte-horizontal-line .v-rte-horizontal-line-hr{display:inline-block;width:100%;height:4px;border-width:0px;background-color:rgb(222, 222, 222)}";
 
@@ -8393,6 +8109,7 @@ class RTEHorizontalLineBlockRenderer extends VegaRTEExtensionRenderer {
     return horizontalLineBlockStylesCss;
   }
 }
+RTEHorizontalLineBlockRenderer.typeName = 'RTEHorizontalLineBlockRenderer';
 
 const HorizontalLine = {
   icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 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="M0 224H32 608h32v64H608 32 0V224z"/></svg>`,
@@ -8609,7 +8326,7 @@ class VegaRTEHorizontalLineExtension extends VegaRTEExtension {
     this.blockRenderer = new RTEHorizontalLineBlockRenderer();
     this.toolbarButtonRenderer = new RTEHorizontalLineToolbarButtonRenderer();
     // Register basic block strategies (delete, append, paste, etc.)
-    this.registerBlockBasicStrategies(RTEHorizontalLineBlock.name);
+    this.registerBlockBasicStrategies(RTEHorizontalLineBlock.typeName);
     // Register the block DTO class
     this.registerNode('horizontal-line', RTEHorizontalLineBlock);
     // Register the renderer
@@ -8619,16 +8336,16 @@ class VegaRTEHorizontalLineExtension extends VegaRTEExtension {
     // Register HTML → DTO conversion strategy
     this.registerElementToBlockDTOClassStrategy(new HrToHorizontalLineBlockStrategy());
     // Register filter styles strategy for source edit round-trip
-    VegaRTEExtension.registerFilterStylesStrategy(RTEHorizontalLineBlock.dtoName, new HorizontalLineFilterStylesStrategy());
+    VegaRTEExtension.registerFilterStylesStrategy(RTEHorizontalLineBlock.typeName, new HorizontalLineFilterStylesStrategy());
   }
 }
 (() => {
   const insertStrategy = new InsertHorizontalLineBlockStrategy();
   // Register insert strategy for all block types that can be a target
-  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTETextBlock.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTEImageBlock.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTEHorizontalLineBlock.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.typeName, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTETextBlock.typeName, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEImageBlock.typeName, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEHorizontalLineBlock.typeName, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
 })();
 VegaRTEHorizontalLineExtension.TOOLBAR_BUTTON_KEY = 'horizontalLine';
 
@@ -8713,7 +8430,6 @@ class BlockquoteAnnotation extends BlockAnnotation {
 class RTEBlockquoteBlock extends RTEBlock {
   constructor(id, options) {
     super(id);
-    this.dtoName = RTEBlockquoteBlock.dtoName;
     this.type = 'blockquote';
     this.children = [];
     const { autoMatchFormat = true } = options !== null && options !== void 0 ? options : {};
@@ -8774,7 +8490,7 @@ class RTEBlockquoteBlock extends RTEBlock {
     return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: 'blockquote', children: this.children.map((child) => child.toJSON()) });
   }
 }
-RTEBlockquoteBlock.dtoName = 'RTEBlockquoteBlock';
+RTEBlockquoteBlock.typeName = 'RTEBlockquoteBlock';
 
 /**
  * Wrap the selected blocks into a new `<blockquote>` block while preserving
@@ -8992,6 +8708,7 @@ class RTEBlockquoteBlockRenderer extends VegaRTEExtensionRenderer {
     return BlockquoteAnnotation.getDefaultCssText();
   }
 }
+RTEBlockquoteBlockRenderer.typeName = 'RTEBlockquoteBlockRenderer';
 const RTEBlockquoteBlockRenderer$1 = new RTEBlockquoteBlockRenderer();
 
 // FontAwesome 7.2.0 — `quote-left` (solid).
@@ -9273,7 +8990,7 @@ class BlockquoteFilterStylesStrategy extends RTEFilterStylesStrategy {
    * @inheritDoc
    */
   canFilter(blockOrNodeInstance) {
-    return BlockquoteFilterStylesStrategy.isBlockquoteBlock(blockOrNodeInstance.dtoName);
+    return BlockquoteFilterStylesStrategy.isBlockquoteBlock(blockOrNodeInstance.typeName);
   }
   /**
    * @inheritDoc
@@ -9296,28 +9013,28 @@ class VegaRTEBlockquoteExtension extends VegaRTEExtension {
   constructor() {
     super();
     this.toolbarButtonRenderer = new RTEBlockquoteToolbarButtonRenderer();
-    this.registerBlockBasicStrategies(RTEBlockquoteBlock.name);
+    this.registerBlockBasicStrategies(RTEBlockquoteBlock.typeName);
     this.registerNode('blockquote', RTEBlockquoteBlock);
     this.registerRenderer('blockquote', RTEBlockquoteBlockRenderer$1);
     this.registerToolbarButtonRenderer(VegaRTEBlockquoteExtension.TOOLBAR_BUTTON_KEY, this.toolbarButtonRenderer);
     this.registerElementToBlockDTOClassStrategy(new BlockquoteToBlockquoteBlockStrategy());
     // Register filter styles strategy for source edit round-trip.
-    VegaRTEExtension.registerFilterStylesStrategy(RTEBlockquoteBlock.dtoName, new BlockquoteFilterStylesStrategy());
+    VegaRTEExtension.registerFilterStylesStrategy(RTEBlockquoteBlock.typeName, new BlockquoteFilterStylesStrategy());
   }
 }
 (() => {
   const wrapStrategy = new BlockTransformToBlockquoteStrategy();
   // Root container — wrap top-level blocks.
-  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.typeName, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
   // Table cells (body + header) — wrap is scoped to the closest cell.
   // Other container blocks (code, list item, function) are intentionally
   // not registered, so the toolbar stays disabled inside them.
-  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTEBlockquoteBlock.name, REMOVE_BLOCKQUOTE, new RemoveBlockquoteStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.typeName, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.typeName, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEBlockquoteBlock.typeName, REMOVE_BLOCKQUOTE, new RemoveBlockquoteStrategy());
   // Enables exiting the blockquote via the keyboard: pressing Enter on an empty
   // trailing paragraph breaks out to a new paragraph after the blockquote.
-  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.name, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new BlockquoteExitOnEnterInterceptor());
+  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.typeName, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new BlockquoteExitOnEnterInterceptor());
 })();
 VegaRTEBlockquoteExtension.TOOLBAR_BUTTON_KEY = 'blockquote';
 
@@ -11200,6 +10917,7 @@ class LineHeightAnnotationAction extends AnnotationAction {
     return new LineHeightAnnotation(this.lineHeight);
   }
 }
+LineHeightAnnotationAction.typeName = 'LineHeightAnnotationAction';
 
 /**
  * Update the block line height strategy.
@@ -11296,7 +11014,7 @@ class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     const selectedBlocks = this.getSelectedBlocks(editorContext);
     return selectedBlocks.some((block) => block instanceof RTECodeBlock ||
       block instanceof RTEImageBlock ||
-      !ActionHandleStrategyRegistry.canHandle(LineHeightAnnotationAction.name, block));
+      !ActionHandleStrategyRegistry.canHandle(LineHeightAnnotationAction.typeName, block));
   }
   /**
    * @inheritDoc
@@ -11361,8 +11079,8 @@ class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
 })();
 
 const LINE_HEIGHT_AWARE_BLOCK_NAMES = new Set([
-  RTETextBlock.name,
-  RTEListItemBlock.name,
+  RTETextBlock.typeName,
+  RTEListItemBlock.typeName,
 ]);
 /** Handle line height annotation. */
 class LineHeightAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
@@ -11377,7 +11095,7 @@ class LineHeightAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
    * @returns {boolean} Whether the target DTO supports line-height annotations.
    */
   canHandle(targetDto) {
-    return LINE_HEIGHT_AWARE_BLOCK_NAMES.has(targetDto.name);
+    return LINE_HEIGHT_AWARE_BLOCK_NAMES.has(targetDto.typeName);
   }
   /**
    * Extract inline `line-height` as a semantic `lineHeight` annotation.
@@ -11529,8 +11247,8 @@ class VegaRTELineHeightExtension extends VegaRTEExtension {
 }
 (() => {
   [RTETextBlock, RTEListItemBlock].forEach((BlockClass) => {
-    VegaRTEExtension.registerActionHandleStrategy(BlockClass.name, LineHeightAnnotationAction.name, new BlockUpdateLineHeightStrategy());
-    RTEFilterStylesStrategyRegistry.register(BlockClass.name, new LineHeightFilterStylesStrategy());
+    VegaRTEExtension.registerActionHandleStrategy(BlockClass.typeName, LineHeightAnnotationAction.typeName, new BlockUpdateLineHeightStrategy());
+    RTEFilterStylesStrategyRegistry.register(BlockClass.typeName, new LineHeightFilterStylesStrategy());
     attachLineHeightFromJson(BlockClass);
   });
 })();
@@ -11803,6 +11521,7 @@ VegaRTEFullscreenExtension.controllerStore = VegaRTEFullscreenExtension.createSt
 var RTEPasteMode;
 (function (RTEPasteMode) {
   RTEPasteMode["RICH"] = "rich";
+  RTEPasteMode["PLAIN"] = "plain";
   RTEPasteMode["WORD"] = "word";
 })(RTEPasteMode || (RTEPasteMode = {}));
 /**
@@ -11854,185 +11573,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', 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');
-    const dropdownItems = [
-      this.createDropdownItem(doc, RTEPasteMode.RICH, VegaInternalTranslation.t('Use rich text'), RTEPasteChooserUI.CHOOSER_RICH_ATTR),
-    ];
-    if (this.options.showWordOption) {
-      dropdownItems.push(this.createDropdownItem(doc, RTEPasteMode.WORD, 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;
-  }
-}
-(() => {
-  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
@@ -14028,6 +13625,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();
+    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 plainPasteLinesToHtml(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 ? { [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 = htmlContainsTable(input.html);
+    if (input.text && input.text.includes('\t') && containsTable) {
+      return { text: input.text, hasEncodedWhitespace: false };
+    }
+    const derived = htmlToPlainText(input.html, {
+      preserveBoundaryBlankLines: !containsTable,
+      keepPreservedWhitespaceMarkers: true,
+    });
+    return derived
+      ? { text: derived, hasEncodedWhitespace: true }
+      : { text: input.text || '', hasEncodedWhitespace: false };
+  }
+}
+
 /**
  * Centralized selector for paste processing strategies.
  *
@@ -14040,10 +13707,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.
@@ -14511,24 +14195,591 @@ class PendingImageRegistry {
         imageNode && imageNode.apply(new ImageReplaceSrcAction(imageElement, url));
       }
     }
-    const pending = PendingImageRegistry.pendingImages.get(imageId);
-    if (pending) {
-      if (pending.objectUrl.startsWith('blob:')) {
-        URL.revokeObjectURL(pending.objectUrl);
-      }
-      PendingImageRegistry.pendingImages.delete(imageId);
-      this.ownedImageIds.delete(imageId);
+    const pending = PendingImageRegistry.pendingImages.get(imageId);
+    if (pending) {
+      if (pending.objectUrl.startsWith('blob:')) {
+        URL.revokeObjectURL(pending.objectUrl);
+      }
+      PendingImageRegistry.pendingImages.delete(imageId);
+      this.ownedImageIds.delete(imageId);
+    }
+  }
+}
+/**
+ * Pasted images awaiting upload, keyed by their {@link VegaRTEPasteImage.id}.
+ *
+ * Shared statically across instances so previews survive a paste-extension
+ * re-instantiation: the consumer may resolve `replaceUrl` after the editor
+ * has re-mounted and created a new extension/registry instance.
+ */
+PendingImageRegistry.pendingImages = new Map();
+
+/** Computes paste chooser placement from the paste pointer or saved caret range. */
+class ChooserPositioner {
+  constructor(getHostElement, getSelectionRange) {
+    this.getHostElement = getHostElement;
+    this.getSelectionRange = getSelectionRange;
+  }
+  /**
+   * @param {ClipboardEvent} event Originating paste event.
+   * @returns {ChooserPosition} Position in viewport coordinates.
+   */
+  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);
+  }
+  /**
+   * @param {DOMRect} rect Rectangle to inspect.
+   * @returns {boolean} Whether the rectangle has no usable position or dimensions.
+   */
+  isUnavailableRect(rect) {
+    return rect.width === 0 && rect.height === 0 && rect.left === 0 && rect.top === 0;
+  }
+  /**
+   * @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;
+    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);
+  }
+  /**
+   * @param {Node | null} node DOM node to measure.
+   * @returns {DOMRect | null} Element-backed rectangle for the node.
+   */
+  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;
+  }
+}
+
+/** Extracts local image previews from strategy output. */
+class ImageExtractor {
+  constructor(parser = new PasteImageParser()) {
+    this.parser = parser;
+  }
+  /**
+   * @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.
+   */
+  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 extraction = this.imageExtractor.extract(output.html, output.imagesToExtract, input.rtf);
+    if (extraction.previews.length > 0) {
+      this.pendingImageRegistry.register(extraction.previews);
+    }
+    return Object.assign(Object.assign({}, output), { html: extraction.html });
+  }
+}
+
+/** Builds the DataTransfer contract consumed by InsertPasteHandler. */
+class PasteDataTransferBuilder {
+  /**
+   * @param {PasteOutput} output Processed paste output to serialize.
+   * @returns {DataTransfer} Data transfer payload consumed by the paste handler.
+   */
+  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, [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 {
+      /**
+       * @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',
+  RTE_PASTE_MODE_DATA_TYPE,
+];
+
+/** Dispatches processed paste data through the editor's existing beforeinput pipeline. */
+class PasteDispatcher {
+  /**
+   * @param {HTMLDivElement} editableEl Editable content element receiving the event.
+   * @param {DataTransfer} dataTransfer Processed clipboard payload.
+   */
+  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;
+  }
+  /**
+   * @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.
+   */
+  restoreControllerState(payload) {
+    const context = this.getContext();
+    if (!payload.range || !context) {
+      return;
+    }
+    const rangeOptions = {
+      startNode: payload.range.startContainer,
+      endNode: payload.range.endContainer,
+      startOffset: payload.range.startOffset,
+      endOffset: payload.range.endOffset,
+    };
+    context.setSelectedNodes(payload.selectedNodes || [], rangeOptions);
+  }
+  /**
+   * @param {Range | null} range Native selection range to restore.
+   */
+  restoreRange(range) {
+    var _a;
+    if (!range) {
+      return;
+    }
+    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);
+    };
+  }
+  /**
+   * @param {HTMLDivElement | null} editableEl Editable content element to observe.
+   */
+  attach(editableEl) {
+    var _a;
+    this.detach();
+    this.editableEl = editableEl;
+    (_a = this.editableEl) === null || _a === void 0 ? void 0 : _a.addEventListener('paste', this.handlePasteEvent);
+  }
+  /**
+   * Detaches the current native paste listener.
+   */
+  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;
+  }
+  /**
+   * 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';
+    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', 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');
+    const dropdownItems = [
+      this.createDropdownItem(doc, RTEPasteMode.RICH, VegaInternalTranslation.t('Use rich text'), RTEPasteChooserUI.CHOOSER_RICH_ATTR),
+      this.createDropdownItem(doc, RTEPasteMode.PLAIN, VegaInternalTranslation.t('Use plain text'), RTEPasteChooserUI.CHOOSER_PLAIN_ATTR),
+    ];
+    if (this.options.showWordOption) {
+      dropdownItems.push(this.createDropdownItem(doc, RTEPasteMode.WORD, 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.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;
+  }
+}
+(() => {
+  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;
+    }
+    (_c = this.chooserUI) === null || _c === void 0 ? void 0 : _c.destroy();
+    this.chooserUI = null;
+    if (clearPayload) {
+      this.onClearPayload();
     }
   }
 }
-/**
- * Pasted images awaiting upload, keyed by their {@link VegaRTEPasteImage.id}.
- *
- * Shared statically across instances so previews survive a paste-extension
- * re-instantiation: the consumer may resolve `replaceUrl` after the editor
- * has re-mounted and created a new extension/registry instance.
- */
-PendingImageRegistry.pendingImages = new Map();
 
 /**
  * Vega Rich Text Editor paste extension.
@@ -14539,16 +14790,7 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
     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.
@@ -14556,33 +14798,7 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
      * @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);
+      this.pasteEventInterceptor.handlePasteEvent(event);
     };
     /**
      * Dismisses the chooser when a pointer interaction occurs outside of it.
@@ -14590,14 +14806,7 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
      * @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();
+      this.pasteChooserController.handleOutsidePointerDown(event);
     };
     /**
      * Dismisses the chooser when the Escape key is pressed.
@@ -14605,17 +14814,30 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
      * @param {KeyboardEvent} event Keyboard event captured on the document.
      */
     this.handleOutsideKeyDown = (event) => {
-      if (event.key === 'Escape') {
-        this.clearPasteChooser();
-      }
+      this.pasteChooserController.handleOutsideKeyDown(event);
     };
     /**
      * Dismisses the chooser when any relevant scroll container scrolls.
      */
     this.handleOutsideScroll = () => {
-      this.clearPasteChooser();
+      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) {
@@ -14629,6 +14851,10 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
     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.
    */
@@ -14636,17 +14862,13 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
     const { editableEl, contentHostEl, } = this.getEditorElements();
     this.editableEl = editableEl;
     this.contentHostEl = contentHostEl;
-    if (this.editableEl) {
-      this.editableEl.addEventListener('paste', this.handlePasteEvent);
-    }
+    this.pasteEventInterceptor.attach(this.editableEl);
   }
   /**
    * Detaches the paste listener from the editable element.
    */
   detachPasteListener() {
-    if (this.editableEl) {
-      this.editableEl.removeEventListener('paste', this.handlePasteEvent);
-    }
+    this.pasteEventInterceptor.detach();
     this.editableEl = null;
     this.contentHostEl = null;
   }
@@ -14677,12 +14899,7 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
    * @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;
+    return this.selectionSnapshotService.capture().range;
   }
   /**
    * Renders the paste-mode chooser and wires up dismissal listeners.
@@ -14690,145 +14907,8 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
    * @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.
-   */
-  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;
+    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.
@@ -14850,36 +14930,13 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
       return;
     }
     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.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();
   }
-  /**
-   * 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.
-   */
-  parseLocalImages(html, clipboardFileContent) {
-    const { html: result, previews } = this.imageParser.parseLocalImages(html, clipboardFileContent);
-    if (previews.length > 0) {
-      this.pendingImageRegistry.register(previews);
-    }
-    return result;
-  }
   /**
    * Emits the `imageInsertedCallback` for any pending previews, allowing the
    * consumer to upload them and resolve their URLs.
@@ -14889,141 +14946,17 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
       this.pendingImageRegistry.notifyInserted(this.options.imageInsertedCallback, () => { var _a; return (_a = this.editableEl) !== null && _a !== void 0 ? _a : this.getEditableElement(); }, (imageElement) => this.getDTOEntityByDom(imageElement));
     }
   }
-  /**
-   * 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 {RTEPasteMode} [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;
-    }
+    this.pasteChooserController.clear(clearPayload);
   }
 }
 (() => {
-  VegaRTEExtension.registerActionHandleStrategy(RTEImageNode.name, REPLACE_IMAGE_SRC, new ImageReplaceSrcStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTEImageNode.typeName, REPLACE_IMAGE_SRC, new ImageReplaceSrcStrategy());
 })();
 
 /**
@@ -15336,7 +15269,7 @@ class VegaRTECopyExtension extends VegaRTEExtension {
   }
 }
 (() => {
-  ActionHandleStrategyRegistry.register('COPY_SELECTED_CONTENT_ACTION', VegaRTEContent.name, new CopySelectedContentStrategy());
+  ActionHandleStrategyRegistry.register('COPY_SELECTED_CONTENT_ACTION', VegaRTEContent.typeName, new CopySelectedContentStrategy());
 })();
 // The unique key for the copy toolbar button, used for registration and retrieval.
 VegaRTECopyExtension.TOOLBAR_BUTTON_KEY = 'copy';
@@ -15538,23 +15471,9 @@ class VegaRTEWordCountExtension extends VegaRTEExtension {
 }
 (() => {
   // Gate over-limit commits through the shared action-interceptor pipeline.
-  VegaRTEExtension.registerActionHandlerInterceptor(VegaRTEContent.name, COMMIT_VALUE, new PreventHardLimitExceedInterceptor());
+  VegaRTEExtension.registerActionHandlerInterceptor(VegaRTEContent.typeName, COMMIT_VALUE, new PreventHardLimitExceedInterceptor());
 })();
 
-/**
- * Insert a new children to the nearest position of the parent container
- *
- * @example parent.apply(new InsertNodeToNearestRoot(rteRange, nodeToBeInserted))
- */
-class InsertNodeToNearestRootAction extends ModifyContentAction {
-  constructor(rteRange, nodeToBeInserted) {
-    super();
-    this.type = ModifyContentActionType.INSERT_NODE_TO_NEAREST_ROOT;
-    this.rteRange = rteRange;
-    this.nodeToBeInserted = nodeToBeInserted;
-  }
-}
-
 /**
  * Strategy to handle the insertion of a token node into the nearest root block.
  */
@@ -15666,9 +15585,9 @@ class VegaRTETokenExtension extends VegaRTEExtension {
 }
 (() => {
   const insertTokenNodeStrategy = new InsertTokenNodeStrategy();
-  VegaRTEExtension.registerActionHandleStrategy(RTETextBlock.name, 'INSERT_TOKEN_NODE', insertTokenNodeStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTEListItemBlock.name, 'INSERT_TOKEN_NODE', insertTokenNodeStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTETextBlock.typeName, 'INSERT_TOKEN_NODE', insertTokenNodeStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEListItemBlock.typeName, 'INSERT_TOKEN_NODE', insertTokenNodeStrategy);
 })();
 VegaRTETokenExtension.TOOLBAR_BUTTON_KEY = 'token';
 
-export { VegaRTEWordCountExtension as A, VegaCalendarPeriodFactory as B, VegaRTEToolbarButtonRenderer as C, RTETokenNode as D, RTETokenNodeRenderer as E, RTELanguageToolbarButtonRenderer as F, RTEBlockquoteBlock as G, DeleteSelectedContentAction as H, InsertNodeToNearestRootAction as I, ActionHandlerInterceptor as J, RTETokenToolbarButtonRenderer as R, VegaLoader as V, VegaNotify as a, VegaEventManager$1 as b, VegaZIndexManager$1 as c, VegaSkeletonLoader as d, VegaTranslation as e, VegaRTETokenExtension as f, VegaRTELanguageExtension as g, VegaRTEDefaultLineHeightOptions as h, VegaRTEFunctionExtension as i, VegaRTETableExtension as j, VegaRTEHorizontalLineExtension as k, VegaRTEBlockquoteExtension as l, VegaRTESpecialCharactersExtension as m, VegaRTEFindReplaceExtension as n, VegaRTESpecialCharactersEssentials as o, VegaRTESpecialCharactersLatin as p, VegaRTESpecialCharactersMathematical as q, VegaRTESpecialCharactersArrows as r, VegaRTESpecialCharactersCurrency as s, VegaRTESpecialCharactersText as t, VegaRTELineHeightExtension as u, VegaRTEPasteExtension as v, waitForVega as w, VegaRTEFullscreenExtension as x, VegaRTECopyExtension as y, VegaRTECutExtension as z };
+export { VegaRTEWordCountExtension as A, VegaCalendarPeriodFactory as B, RTETokenNode as C, RTETokenNodeRenderer as D, RTELanguageToolbarButtonRenderer as E, RTEBlockquoteBlock as F, DeleteSelectedContentAction as G, RTETokenToolbarButtonRenderer as R, VegaLoader as V, VegaNotify as a, VegaEventManager$1 as b, VegaZIndexManager$1 as c, VegaSkeletonLoader as d, VegaTranslation as e, VegaRTETokenExtension as f, VegaRTELanguageExtension as g, VegaRTEDefaultLineHeightOptions as h, VegaRTEFunctionExtension as i, VegaRTETableExtension as j, VegaRTEHorizontalLineExtension as k, VegaRTEBlockquoteExtension as l, VegaRTESpecialCharactersExtension as m, VegaRTEFindReplaceExtension as n, VegaRTESpecialCharactersEssentials as o, VegaRTESpecialCharactersLatin as p, VegaRTESpecialCharactersMathematical as q, VegaRTESpecialCharactersArrows as r, VegaRTESpecialCharactersCurrency as s, VegaRTESpecialCharactersText as t, VegaRTELineHeightExtension as u, VegaRTEPasteExtension as v, waitForVega as w, VegaRTEFullscreenExtension as x, VegaRTECopyExtension as y, VegaRTECutExtension as z };