@heartlandone/vega 2.101.0 → 2.103.0

package/dist/cjs/{token-extension-4badb962.js → token-extension-72d0cb08.js}

@@ -3,32 +3,32 @@
 const misc = require('./misc-3d30df91.js');
 const ui = require('./ui-c91c37a7.js');
 const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
-const createPublicApiRuntimeMetricsSlimmer = require('./create-public-api-runtime-metrics-slimmer-91b0cbfb.js');
+const discriminated = require('./discriminated-3b8e72d5.js');
 const internalVegaZIndexManager = require('./internal-vega-z-index-manager-f03ddb37.js');
 const dynamicSlimmer = require('./dynamic-slimmer-f31fdfd7.js');
 const pageResizeObserverSlimmer = require('./page-resize-observer-slimmer-273d62ef.js');
-const internalVegaEventManager = require('./internal-vega-event-manager-976b9526.js');
-const internalTranslationController = require('./internal-translation-controller-27bfc8c7.js');
-const internalCalendarPeriodFactory = require('./internal-calendar-period-factory-b11918ee.js');
-const codeBlock = require('./code-block-c598832d.js');
-const contentState = require('./content-state-da23e822.js');
-const typeGuard = require('./type-guard-00b8efc0.js');
-const linkExtension = require('./link-extension-f493e432.js');
-const internalIconManager = require('./internal-icon-manager-40bcac72.js');
+const internalVegaEventManager = require('./internal-vega-event-manager-0c256d63.js');
+const internalTranslationController = require('./internal-translation-controller-0d67ca4d.js');
+const internalCalendarPeriodFactory = require('./internal-calendar-period-factory-c3198ea7.js');
+const codeBlock = require('./code-block-72de6c4d.js');
+const contentState = require('./content-state-ff40bdc6.js');
+const linkExtension = require('./link-extension-1b4ed437.js');
+const internalIconManager = require('./internal-icon-manager-b9702049.js');
+const typeGuard = require('./type-guard-cce6fe1f.js');
 const vegaNonceManager = require('./vega-nonce-manager-df69d3ed.js');
-const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-c82df135.js');
-const vegaEventId = require('./vega-event-id-987a170c.js');
-const splitCellOperation = require('./split-cell-operation-0d33123e.js');
+const imageExtension = require('./image-extension-6a92c524.js');
+const splitCellOperation = require('./split-cell-operation-afc82323.js');
 const changeManager = require('./change-manager-a297e4d2.js');
+const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-c82df135.js');
 const vegaInternalEventId = require('./vega-internal-event-id-98d499d7.js');
 const remoteInvocationRegistry = require('./remote-invocation-registry-fc22fdd0.js');
 const darkModeStyleController = require('./dark-mode-style-controller-ec04ece9.js');
+const vegaEventId = require('./vega-event-id-b5abf7c9.js');
 const tryGetDocument = require('./try-get-document-c0ebd39a.js');
 const pixel = require('./pixel-98f2a10c.js');
 const object = require('./object-b53e9416.js');
 const timer = require('./timer-5f33058b.js');
 const string = require('./string-39438062.js');
-const imageExtension = require('./image-extension-673ebe7f.js');
 const copy = require('./copy-d021c780.js');
 
 const VegaLoaderRuntimeMetricsPayloadDefinition = [
@@ -83,9 +83,10 @@ var __decorate$6 = (undefined && undefined.__decorate) || function (decorators,
 /**
  * Vega loader controller to control the loading indicator
  */
-class VegaLoaderController {
+class VegaLoaderController extends discriminated.Discriminated {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicApiRuntimeMetricsSlimmer.createPublicAPIRuntimeMetricsSlimmer(VegaLoaderController, ['load', 'close'], VegaLoaderRuntimeMetricsPayloadDefinition, 'VegaLoaderController');
+    super(...arguments);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = discriminated.createPublicAPIRuntimeMetricsSlimmer(VegaLoaderController, ['load', 'close'], VegaLoaderRuntimeMetricsPayloadDefinition, VegaLoaderController.typeName);
   }
   /**
    * Create a loading indicator and append it to the container
@@ -195,9 +196,10 @@ class VegaLoaderController {
     }
   }
 }
+VegaLoaderController.typeName = 'VegaLoaderController';
 VegaLoaderController.SPECIAL_ELEMENT_TO_WRAP_FULL_BODY = ['VEGA-MODAL'];
 __decorate$6([
-  createPublicApiRuntimeMetricsSlimmer.InjectVegaTelemetrySlimmer()
+  discriminated.InjectVegaTelemetrySlimmer()
 ], VegaLoaderController.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
 const VegaLoader = new VegaLoaderController();
 
@@ -273,8 +275,9 @@ var __decorate$5 = (undefined && undefined.__decorate) || function (decorators,
 /**
  * The page notification controller
  */
-class VegaNotifyController {
+class VegaNotifyController extends discriminated.Discriminated {
   constructor() {
+    super(...arguments);
     this.resizeObserverSlimmer = dynamicSlimmer.createDynamicSlimmer(VegaNotifyController, pageResizeObserverSlimmer.PageResizeObserverSlimmer, [], [{ mapFrom: 'connectResizeObserver', mapTo: 'connectResizeObserver' }], [
       {
         // eslint-disable-next-line jsdoc/require-jsdoc
@@ -291,7 +294,7 @@ class VegaNotifyController {
         target: () => this.container,
       },
     ]);
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicApiRuntimeMetricsSlimmer.createPublicAPIRuntimeMetricsSlimmer(VegaNotifyController, ['open', 'close', 'closeAll'], VegaNotifyRuntimeMetricsPayloadDefinition, 'VegaNotifyController');
+    this.vegaPublicAPIRuntimeMetricsSlimmer = discriminated.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
@@ -375,11 +378,12 @@ class VegaNotifyController {
     return this.container;
   }
 }
+VegaNotifyController.typeName = 'VegaNotifyController';
 __decorate$5([
   globalSlimmerRegistry.InjectVegaSlimmer()
 ], VegaNotifyController.prototype, "resizeObserverSlimmer", void 0);
 __decorate$5([
-  createPublicApiRuntimeMetricsSlimmer.InjectVegaTelemetrySlimmer()
+  discriminated.InjectVegaTelemetrySlimmer()
 ], VegaNotifyController.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
 const VegaNotify = new VegaNotifyController();
 
@@ -607,9 +611,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.Discriminated {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicApiRuntimeMetricsSlimmer.createPublicAPIRuntimeMetricsSlimmer(VegaEventManager, ['setSemantics', 'getSemantics', 'getEnabledEventIdsByComponent'], VegaEventManagerRuntimeMetricsPayloadDefinition, 'VegaEventManager');
+    super(...arguments);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = discriminated.createPublicAPIRuntimeMetricsSlimmer(VegaEventManager, ['setSemantics', 'getSemantics', 'getEnabledEventIdsByComponent'], VegaEventManagerRuntimeMetricsPayloadDefinition, VegaEventManager.typeName);
   }
   /**
    * The function sets the semantics configuration for event management.
@@ -647,8 +652,9 @@ class VegaEventManager {
     return internalVegaEventManager.internalVegaEventManager.getEnabledEventIdsByComponent(componentName);
   }
 }
+VegaEventManager.typeName = 'VegaEventManager';
 __decorate$4([
-  createPublicApiRuntimeMetricsSlimmer.InjectVegaTelemetrySlimmer()
+  discriminated.InjectVegaTelemetrySlimmer()
 ], VegaEventManager.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
 const VegaEventManager$1 = new VegaEventManager();
 
@@ -706,9 +712,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.Discriminated {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicApiRuntimeMetricsSlimmer.createPublicAPIRuntimeMetricsSlimmer(VegaZIndexManager, ['overrideZIndexBasicValues'], ZIndexManagerRuntimeMetricsPayloadDefinition, 'VegaZIndexManager');
+    super(...arguments);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = discriminated.createPublicAPIRuntimeMetricsSlimmer(VegaZIndexManager, ['overrideZIndexBasicValues'], ZIndexManagerRuntimeMetricsPayloadDefinition, VegaZIndexManager.typeName);
   }
   /**
    * The function "overrideZIndexBasicValues" calls a method in the "ZIndexManager" class to change the
@@ -721,8 +728,9 @@ class VegaZIndexManager {
     internalVegaZIndexManager.InternalVegaZIndexManager.overrideZIndexBasicValues(input);
   }
 }
+VegaZIndexManager.typeName = 'VegaZIndexManager';
 __decorate$3([
-  createPublicApiRuntimeMetricsSlimmer.InjectVegaTelemetrySlimmer()
+  discriminated.InjectVegaTelemetrySlimmer()
 ], VegaZIndexManager.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
 const VegaZIndexManager$1 = new VegaZIndexManager();
 
@@ -758,9 +766,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.Discriminated {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicApiRuntimeMetricsSlimmer.createPublicAPIRuntimeMetricsSlimmer(WaitForVegaHandler, ['handle'], WaitForVegaPayloadDefinition, 'WaitForVegaHandler');
+    super(...arguments);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = discriminated.createPublicAPIRuntimeMetricsSlimmer(WaitForVegaHandler, ['handle'], WaitForVegaPayloadDefinition, WaitForVegaHandler.typeName);
   }
   /* istanbul ignore next */
   /**
@@ -778,8 +787,9 @@ class WaitForVegaHandler {
       .map((item) => { var _a; return (_a = item.componentOnReady) === null || _a === void 0 ? void 0 : _a.call(item); }));
   }
 }
+WaitForVegaHandler.typeName = 'WaitForVegaHandler';
 __decorate$2([
-  createPublicApiRuntimeMetricsSlimmer.InjectVegaTelemetrySlimmer()
+  discriminated.InjectVegaTelemetrySlimmer()
 ], WaitForVegaHandler.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
 const WaitForVega = new WaitForVegaHandler();
 /* istanbul ignore next */
@@ -866,9 +876,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.Discriminated {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicApiRuntimeMetricsSlimmer.createPublicAPIRuntimeMetricsSlimmer(VegaSkeletonLoaderController, ['load', 'unLoad', 'unLoadAll'], VegaSkeletonRuntimeMetricsPayloadDefinition, 'VegaSkeletonLoaderController');
+    super(...arguments);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = discriminated.createPublicAPIRuntimeMetricsSlimmer(VegaSkeletonLoaderController, ['load', 'unLoad', 'unLoadAll'], VegaSkeletonRuntimeMetricsPayloadDefinition, VegaSkeletonLoaderController.typeName);
     this.loaderMap = new Map();
   }
   /**
@@ -955,9 +966,10 @@ class VegaSkeletonLoaderController {
     return skeletonContainer;
   }
 }
+VegaSkeletonLoaderController.typeName = 'VegaSkeletonLoaderController';
 VegaSkeletonLoaderController.LOADER_DATA_SET_KEY = 'vegaSkeletonLoaderKey';
 __decorate$1([
-  createPublicApiRuntimeMetricsSlimmer.InjectVegaTelemetrySlimmer()
+  discriminated.InjectVegaTelemetrySlimmer()
 ], VegaSkeletonLoaderController.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
 const VegaSkeletonLoader = new VegaSkeletonLoaderController();
 
@@ -1015,9 +1027,10 @@ var __decorate = (undefined && undefined.__decorate) || function (decorators, ta
  *
  * @vegaVersion 2.27.0
  */
-class TranslationController {
+class TranslationController extends discriminated.Discriminated {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicApiRuntimeMetricsSlimmer.createPublicAPIRuntimeMetricsSlimmer(TranslationController, ['init', 'changeLanguage'], VegaTranslationRuntimeMetricsPayloadDefinition, 'TranslationController');
+    super(...arguments);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = discriminated.createPublicAPIRuntimeMetricsSlimmer(TranslationController, ['init', 'changeLanguage'], VegaTranslationRuntimeMetricsPayloadDefinition, TranslationController.typeName);
   }
   /**
    * Get current language
@@ -1047,8 +1060,9 @@ class TranslationController {
     internalTranslationController.VegaInternalTranslation.changeLanguage(language);
   }
 }
+TranslationController.typeName = 'TranslationController';
 __decorate([
-  createPublicApiRuntimeMetricsSlimmer.InjectVegaTelemetrySlimmer()
+  discriminated.InjectVegaTelemetrySlimmer()
 ], TranslationController.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
 const VegaTranslation = new TranslationController();
 
@@ -1071,336 +1085,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 linkExtension.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.DomNodeSubjectObserverFactory.addUniqueObserverToNode(el, vegaEventId.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.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.DomNodeSubjectObserverFactory.addUniqueObserverToNode(el, vegaEventId.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': internalIconManager.VegaInternalIconManager.getIconKey('chevron-down'),
-        })
-        : null,
-    ].filter(typeGuard.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.
  *
@@ -1420,7 +1104,7 @@ class InsertTokenNodeAction extends codeBlock.ModifyContentAction {
 /**
  * Renderer for the token toolbar button in the Vega Rich Text Editor.
  */
-class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+class RTETokenToolbarButtonRenderer extends imageExtension.VegaRTEToolbarButtonRenderer {
   constructor(tokenList) {
     super();
     this.tokenList = [];
@@ -1508,7 +1192,6 @@ class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
 class RTETokenNode extends codeBlock.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;
@@ -1599,7 +1282,7 @@ class RTETokenNode extends codeBlock.RTETextNode {
     return attrs.length > 0 ? ` ${attrs.join(' ')}` : '';
   }
 }
-RTETokenNode.dtoName = 'RTETokenNode';
+RTETokenNode.typeName = 'RTETokenNode';
 
 /**
  * Token node renderer for the rich text editor.
@@ -1661,13 +1344,14 @@ class RTETokenNodeRenderer extends linkExtension.VegaRTEExtensionRenderer {
     return result;
   }
 }
+RTETokenNodeRenderer.typeName = 'RTETokenNodeRenderer';
 
 /**
  * Toolbar button renderer for language selection in Vega Rich Text Editor.
  * Each editor host gets its own instance, registered via
  * {@link VegaRTEExtension#prepareBeforeLoad}, so renderer state is held in plain fields.
  */
-class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+class RTELanguageToolbarButtonRenderer extends imageExtension.VegaRTEToolbarButtonRenderer {
   constructor(languageList, languageChangeCallback, selectedLanguage = '') {
     super();
     this.languageList = [];
@@ -1947,98 +1631,273 @@ const FUNCTION_ELEMENT_CLASSES = [
 ];
 
 /**
- * RTE Function Block
+ * Class representing a logic control node in the rich text editor.
  */
-class RTEFunctionBlock extends codeBlock.RTEBlock {
-  constructor(id) {
+class RTELogicControlNode extends codeBlock.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 codeBlock.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}" ${codeBlock.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(misc.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 = codeBlock.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 codeBlock.RTEBlock {
+  constructor(id, statementText, parent) {
+    super(id);
+    this.type = 'logic-control-block';
+    this.children = [];
+    this.statementText = '';
+    this.statementText = statementText;
+    this.children = [new RTELogicControlNode(`${id}-node-1`, statementText, this)];
+    if (parent) {
+      this.parent = parent;
+    }
+  }
+  /**
+   * Create a logic control block from a JSON representation.
+   *
+   * @param {VegaRTELogicControlBlock} json - The JSON object representing the logic control block.
+   * @returns {RTELogicControlBlock} - The created logic control block.
+   */
+  static from(json) {
+    const block = new RTELogicControlBlock(json.id, json.statementText);
+    return block;
+  }
+  /**
+   * Check the block is not empty.
+   *
+   * @returns {boolean} - Always true for logic control block.
+   */
+  isNotEmpty() {
+    return true;
+  }
+  /**
+   * Get the last node of the block.
+   *
+   * @returns {RTELogicControlNode} - The last node in the block.
+   */
+  getLastNode() {
+    return this.children[this.children.length - 1];
+  }
+  /**
+   * Convert the block to its HTML representation.
+   *
+   * @returns {string} - The HTML string of the logic control block.
+   */
+  toHtml() {
+    return `<div class='${FUNCTION_SYNTAX_CLASS}' contenteditable='false'>${this.statementText}</div>`;
+  }
+  /**
+   * Clone the current block instance.
+   *
+   * @param { RTEFunctionBlock } parent - The parent function block for the cloned instance.
+   * @returns {RTELogicControlBlock} - A new instance of RTEStatementSyntaxBlock.
+   */
+  clone(parent) {
+    return new RTELogicControlBlock(this.id, this.statementText, parent);
+  }
+  /**
+   * Get the JSON representation of the block.
+   *
+   * @returns {VegaRTELogicControlBlock} - The JSON object of the logic control block.
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      type: this.type,
+      statementText: this.statementText,
+    };
+  }
+}
+RTELogicControlBlock.typeName = 'RTELogicControlBlock';
+
+/**
+ * RTE Function Block
+ */
+class RTEFunctionBlock extends codeBlock.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 codeBlock.RTETextBlock)) {
+        return;
+      }
+      contentBlock.children.forEach((node) => {
+        const inlineHtml = node.getAnnotationByType(codeBlock.NodeAnnotationTypeEnum.INLINE_HTML);
+        if ((inlineHtml === null || inlineHtml === void 0 ? void 0 : inlineHtml.htmlTag) !== 'div')
+          return;
+        if (inlineHtml.child) {
+          node.annotationMap.set(codeBlock.NodeAnnotationTypeEnum.INLINE_HTML, inlineHtml.child);
+        }
+        else {
+          node.annotationMap.delete(codeBlock.NodeAnnotationTypeEnum.INLINE_HTML);
+        }
+      });
+    });
+  }
+  /**
+   * Converts the RTEFunctionBlock and its children to an HTML string.
+   *
+   * @returns {string} The HTML string representation of the function block.
+   */
+  toHtml() {
+    const childrenHtml = this.children
+      .map((child) => {
+      if (child instanceof codeBlock.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}" ${codeBlock.RTE_BLOCK_BOUNDARY_ATTRIBUTE}>${childrenHtml}</div>`;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    const clonedBlock = new RTEFunctionBlock(misc.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 codeBlock.RTEAnnotationStyle(block);
     let styles = blockAnnotationStyle.toCssText({ standalone: true });
     const textStyleAnnotation = block.getAnnotationByType('TEXT_STYLE');
@@ -2049,7 +1908,7 @@ class RTEFunctionBlock extends codeBlock.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.
@@ -2146,202 +2005,52 @@ class InsertFunctionBlockStrategy extends codeBlock.ActionHandleStrategy {
 }
 
 /**
- * Class representing a logic control node in the rich text editor.
+ * Function toolbar button renderer class.
  */
-class RTELogicControlNode extends codeBlock.RTENode {
-  constructor(id, text, parent) {
-    super(id);
-    this.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 imageExtension.VegaRTEToolbarButtonRenderer {
   /**
-   * Convert the node to its HTML representation.
-   *
-   * @returns {string} - The HTML string of the logic control node.
+   * @inheritDoc
    */
-  toHtml() {
-    return this.text;
+  render(h, editorContext) {
+    return this.renderDropdown(h, editorContext, {}, [
+      this.renderButton(h, editorContext, {
+        label: 'Functions',
+        ariaLabel: 'Functions',
+        showArrowIcon: true,
+        tooltip: { text: 'Insert function' },
+      }),
+      this.renderDropdownListTemplate(h, FunctionToolbarButtonRenderer.FUNCTION_LIST, editorContext),
+    ]);
   }
   /**
-   * Convert the node to a JSON representation.
+   * Overrides the isDisabled method to determine if the button should be disabled.
    *
-   * @returns {unknown} - The JSON object of the statement syntax node.
+   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
+   * @returns {boolean} - true if the button should be disabled, false otherwise.
    */
-  toJSON() {
-    return {
-      id: this.id,
-      type: this.type,
-      text: this.text,
-    };
+  isDisabled(editorContext) {
+    const context = this.getExtensionContext(editorContext.host);
+    if (context) {
+      const { host, getSelectedNodes } = context;
+      const focusNode = getSelectedNodes()[0];
+      let enableInsert = true;
+      if (focusNode) {
+        enableInsert = codeBlock.ActionHandleStrategyRegistry.canHandle(INSERT_FUNCTION_BLOCK, focusNode.parent);
+      }
+      return host.disabled || !enableInsert;
+    }
+    return false;
   }
-  /**
-   * Get the end offset of the node's range.
-   *
-   * @returns {number} - The end offset of the node's range.
-   */
-  getRangeEndOffset() {
-    return 1;
+  /* istanbul ignore next */
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  handleButtonClick() {
+    throw new Error('Method not implemented.');
   }
   /**
-   * Get the container element for the node's range.
+   * Handles dropdown click event
    *
-   * @returns {Nullable<Node>} - The container node for the range.
-   */
-  getRangeContainer() {
-    const element = codeBlock.stateEntityRenderingRegistry.getDOMByEntity(this);
-    if (element) {
-      return element.parentElement;
-    }
-  }
-  /**
-   * Get the content editable state of the node.
-   *
-   * @returns {boolean} - The content editable state of the node.
-   */
-  isContentEditable() {
-    return false;
-  }
-  /**
-   * @inheritDoc
-   */
-  getPlainText() {
-    return this.text;
-  }
-}
-RTELogicControlNode.dtoName = 'RTELogicControlNode';
-
-/**
- * Class representing a logic control block in the rich text editor.
- */
-class RTELogicControlBlock extends codeBlock.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 = codeBlock.ActionHandleStrategyRegistry.canHandle(INSERT_FUNCTION_BLOCK, focusNode.parent);
-      }
-      return host.disabled || !enableInsert;
-    }
-    return false;
-  }
-  /* istanbul ignore next */
-  // eslint-disable-next-line jsdoc/require-jsdoc
-  handleButtonClick() {
-    throw new Error('Method not implemented.');
-  }
-  /**
-   * Handles dropdown click event
-   *
-   * @param {RTEExtensionFunctionType} itemKey - key of the clicked item
-   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
+   * @param {RTEExtensionFunctionType} itemKey - key of the clicked item
+   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
    */
   handleDropdownClick(itemKey, editorContext) {
     if (editorContext) {
@@ -2387,6 +2096,7 @@ class RTELogicControlBlockRenderer extends linkExtension.VegaRTEExtensionRendere
     }, renderData.statementText));
   }
 }
+RTELogicControlBlockRenderer.typeName = 'RTELogicControlBlockRenderer';
 
 /**
  * Returns true when the element belongs to function extension blocks by semantic
@@ -2512,6 +2222,7 @@ class DivToFunctionBlockStrategy extends contentState.ElementToDTOStrategy {
    * @inheritDoc
    */
   appendChildBlocks(currentBlock, childBlocks) {
+    RTEFunctionBlock.unwrapForeachContent(childBlocks);
     currentBlock.children = childBlocks.map((block) => {
       block.parent = currentBlock;
       return block;
@@ -2603,17 +2314,12 @@ class RTEFunctionBlockRenderer extends linkExtension.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.
  */
-class PreventNewParagraphInterceptor extends ActionHandlerInterceptor {
+class PreventNewParagraphInterceptor extends imageExtension.ActionHandlerInterceptor {
   /**
    * Checks the target block parent whether is function block.
    *
@@ -2780,8 +2486,8 @@ class VegaRTEFunctionExtension extends linkExtension.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());
@@ -2813,23 +2519,23 @@ class VegaRTEFunctionExtension extends linkExtension.VegaRTEExtension {
    * Remove the appen children strategies to prevent default insert new paragraph logic in function block
    */
   preventFunctionBlockDefaultInsertNewParagraph() {
-    this.unRegisterStrategy(codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, RTELogicControlBlock.name);
-    this.unRegisterStrategy(codeBlock.ModifyContentActionType.APPEND_CHILDREN, RTEFunctionBlock.name);
-    this.unRegisterStrategy(codeBlock.ModifyContentActionType.INSERT_CHILDREN_AFTER, RTEFunctionBlock.name);
-    this.unRegisterStrategy(codeBlock.ModifyContentActionType.INSERT_CHILDREN_BEFORE, RTEFunctionBlock.name);
-    this.unRegisterStrategy(codeBlock.ModifyContentActionType.PASTE_CONTENT, RTELogicControlBlock.name);
-    linkExtension.VegaRTEExtension.registerActionHandleStrategy(RTEFunctionBlock.name, codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, new FunctionBlockInsertParagraphStrategy());
+    this.unRegisterStrategy(codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, RTELogicControlBlock.typeName);
+    this.unRegisterStrategy(codeBlock.ModifyContentActionType.APPEND_CHILDREN, RTEFunctionBlock.typeName);
+    this.unRegisterStrategy(codeBlock.ModifyContentActionType.INSERT_CHILDREN_AFTER, RTEFunctionBlock.typeName);
+    this.unRegisterStrategy(codeBlock.ModifyContentActionType.INSERT_CHILDREN_BEFORE, RTEFunctionBlock.typeName);
+    this.unRegisterStrategy(codeBlock.ModifyContentActionType.PASTE_CONTENT, RTELogicControlBlock.typeName);
+    linkExtension.VegaRTEExtension.registerActionHandleStrategy(RTEFunctionBlock.typeName, codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, new FunctionBlockInsertParagraphStrategy());
   }
 }
 (() => {
   const insertFunctionBlockStrategy = new InsertFunctionBlockStrategy();
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.VegaRTEContent.name, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.name, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.RTEImageBlock.name, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(RTELogicControlBlock.name, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.name, PASTE_PLAIN_TEXT, new PastePlainTextStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(codeBlock.RTETextBlock.name, codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, new PreventNewParagraphInterceptor());
-  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(codeBlock.RTETextBlock.name, codeBlock.ModifyContentActionType.PASTE_CONTENT, new PreventPasteContentInterceptor());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.VegaRTEContent.typeName, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.typeName, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.RTEImageBlock.typeName, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(RTELogicControlBlock.typeName, INSERT_FUNCTION_BLOCK, insertFunctionBlockStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.typeName, PASTE_PLAIN_TEXT, new PastePlainTextStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(codeBlock.RTETextBlock.typeName, codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, new PreventNewParagraphInterceptor());
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(codeBlock.RTETextBlock.typeName, codeBlock.ModifyContentActionType.PASTE_CONTENT, new PreventPasteContentInterceptor());
 })();
 VegaRTEFunctionExtension.TOOLBAR_BUTTON_KEY = 'functions';
 
@@ -2930,7 +2636,6 @@ var __rest$3 = (undefined && undefined.__rest) || function (s, e) {
 class RTETableCaptionBlock extends codeBlock.RTEBlock {
   constructor(id, options) {
     super(id);
-    this.dtoName = RTETableCaptionBlock.dtoName;
     this.type = 'table-caption';
     const { autoMatchFormat } = options || { autoMatchFormat: true };
     if (autoMatchFormat) {
@@ -2989,11 +2694,12 @@ class RTETableCaptionBlock extends codeBlock.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
 (() => {
-  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_CHILDREN_BEFORE, RTETableCaptionBlock.name, new contentState.InsertChildrenBeforeStrategy());
-  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.PASTE_CONTENT, RTETableCaptionBlock.name, new contentState.PasteContentStrategy());
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_CHILDREN_BEFORE, RTETableCaptionBlock.typeName, new contentState.InsertChildrenBeforeStrategy());
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.PASTE_CONTENT, RTETableCaptionBlock.typeName, new contentState.PasteContentStrategy());
 })();
-RTETableCaptionBlock.dtoName = 'RTETableCaptionBlock';
 
 const TOGGLE_TABLE_CAPTION = 'TOGGLE_TABLE_CAPTION';
 /**
@@ -3166,6 +2872,7 @@ class UpdateTablePropertiesAction extends codeBlock.AnnotationAction {
     return new splitCellOperation.RTETableAnnotation(this.tableProperties);
   }
 }
+UpdateTablePropertiesAction.typeName = 'UpdateTablePropertiesAction';
 
 /**
  * Cancel Event handler for the table properties.
@@ -3251,6 +2958,7 @@ class RTETableCellAnnotationsAction extends codeBlock.AnnotationAction {
     });
   }
 }
+RTETableCellAnnotationsAction.typeName = 'RTETableCellAnnotationsAction';
 
 /**
  * Action to apply annotations to a table head cell.
@@ -3268,6 +2976,7 @@ class RTETableHeadCellAnnotationsAction extends RTETableCellAnnotationsAction {
     return this.originAnnotation;
   }
 }
+RTETableHeadCellAnnotationsAction.typeName = 'RTETableHeadCellAnnotationsAction';
 
 var __rest$1 = (undefined && undefined.__rest) || function (s, e) {
   var t = {};
@@ -4517,6 +4226,7 @@ class RTETableBlockRenderer extends linkExtension.VegaRTEExtensionRenderer {
     this.tableToolbar = null;
   }
 }
+RTETableBlockRenderer.typeName = 'RTETableBlockRenderer';
 
 /**
  * Renders a logic control block in the rich text editor.
@@ -4532,6 +4242,7 @@ class RTETableHeadRenderer extends linkExtension.VegaRTEExtensionRenderer {
     });
   }
 }
+RTETableHeadRenderer.typeName = 'RTETableHeadRenderer';
 
 /**
  * Renders a logic control block in the rich text editor.
@@ -4547,6 +4258,7 @@ class RTETableRowBlockRenderer extends linkExtension.VegaRTEExtensionRenderer {
     });
   }
 }
+RTETableRowBlockRenderer.typeName = 'RTETableRowBlockRenderer';
 
 /**
  * Renders a table cell block in the rich text editor.
@@ -4618,6 +4330,7 @@ class RTETableCellRenderer extends linkExtension.VegaRTEExtensionRenderer {
     };
   }
 }
+RTETableCellRenderer.typeName = 'RTETableCellRenderer';
 
 /**
  * Renders a table body block in the rich text editor.
@@ -4633,6 +4346,7 @@ class RTETableBodyRenderer extends linkExtension.VegaRTEExtensionRenderer {
     });
   }
 }
+RTETableBodyRenderer.typeName = 'RTETableBodyRenderer';
 
 /**
  * Renders a head cell block in the rich text editor.
@@ -4645,6 +4359,7 @@ class RTETableHeadCellRenderer extends RTETableCellRenderer {
     return super.renderByCellType(h, renderData, rteContext, 'th');
   }
 }
+RTETableHeadCellRenderer.typeName = 'RTETableHeadCellRenderer';
 
 const INSERT_TABLE_BLOCK = 'INSERT_TABLE_BLOCK';
 /**
@@ -4841,7 +4556,7 @@ class RTETableToolbarPopoverRenderer extends TablePopoverBaseRenderer {
 /**
  * Function toolbar button renderer class.
  */
-class RTETableToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+class RTETableToolbarButtonRenderer extends imageExtension.VegaRTEToolbarButtonRenderer {
   /**
    * @inheritDoc
    */
@@ -4943,7 +4658,7 @@ class InsertTableBlockStrategy extends codeBlock.ActionHandleStrategy {
 /**
  * Interceptor to prevent deletion of a table cell if it is the cell with empty content.
  */
-class PreventCellContentDeleteInterceptor extends ActionHandlerInterceptor {
+class PreventCellContentDeleteInterceptor extends imageExtension.ActionHandlerInterceptor {
   /**
    * Prevent deletion if the target block is the only child of a table cell and is empty.
    *
@@ -4988,7 +4703,7 @@ class DeleteTableBlockStrategy extends codeBlock.ActionHandleStrategy {
 /**
  * Interceptor to prevent removal of all children from a cell, ensuring at least one child remains.
  */
-class PreventCellChildrenRemoveInterceptor extends ActionHandlerInterceptor {
+class PreventCellChildrenRemoveInterceptor extends imageExtension.ActionHandlerInterceptor {
   /**
    * Prevent removal if the target cell would be left empty after the action.
    *
@@ -5037,6 +4752,7 @@ class RTETableCaptionRenderer extends linkExtension.VegaRTEExtensionRenderer {
         .join(' '), 'data-placeholder': TABLE_CAPTION_PLACEHOLDER_TEXT }));
   }
 }
+RTETableCaptionRenderer.typeName = 'RTETableCaptionRenderer';
 
 /**
  * Abstract base strategy for table row actions. Provides common utilities for row manipulations.
@@ -6677,7 +6393,7 @@ class SelectTableColumnStrategy extends splitCellOperation.TableColumnStrategy {
 /**
  * Interceptor to prevent insertion of non-cell blocks into a table row.
  */
-class PreventRowInsertInterceptor extends ActionHandlerInterceptor {
+class PreventRowInsertInterceptor extends imageExtension.ActionHandlerInterceptor {
   /**
    * Prevent insertion if any of the children to be inserted is not a table cell block.
    *
@@ -7229,7 +6945,7 @@ class TableAnnotationHandler extends TableAnnotationHandlerBase {
    * @inheritDoc
    */
   canHandle(targetDto) {
-    return targetDto.dtoName === 'RTETableBlock';
+    return targetDto.typeName === 'RTETableBlock';
   }
   /**
    * Handle annotation extraction from table element.
@@ -7297,7 +7013,7 @@ class TableCellAnnotationHandler extends TableAnnotationHandlerBase {
    * @inheritDoc
    */
   canHandle(targetDto) {
-    return targetDto.dtoName === 'RTETableCellBlock';
+    return targetDto.typeName === 'RTETableCellBlock';
   }
   /**
    * Handle annotation extraction from table cell element.
@@ -7406,7 +7122,7 @@ class TableHeadCellAnnotationHandler extends TableCellAnnotationHandler {
    * @inheritDoc
    */
   canHandle(targetDto) {
-    return targetDto.dtoName === 'RTETableHeadCellBlock';
+    return targetDto.typeName === 'RTETableHeadCellBlock';
   }
 }
 
@@ -7825,7 +7541,7 @@ class InsertTableRowIntoSameSectionStrategy extends TableRowCommonUtilitiesStrat
 /**
  * Interceptor to insert a paragraph before or after a table block.
  */
-class PreventTableInsertParagraphInterceptor extends ActionHandlerInterceptor {
+class PreventTableInsertParagraphInterceptor extends imageExtension.ActionHandlerInterceptor {
   /**
    * Intercept insert paragraph action when table block has a parent.
    *
@@ -7886,7 +7602,7 @@ class TableBlockFilterStylesStrategy extends codeBlock.RTEFilterStylesStrategy {
    * @inheritDoc
    */
   canFilter(blockOrNodeInstance) {
-    return this.isTableBlock(blockOrNodeInstance.dtoName);
+    return this.isTableBlock(blockOrNodeInstance.typeName);
   }
   /**
    * @inheritDoc
@@ -7924,7 +7640,7 @@ class TableCaptionFilterStylesStrategy extends codeBlock.RTEFilterStylesStrategy
    * @inheritDoc
    */
   canFilter(blockOrNodeInstance) {
-    return this.isTableCaption(blockOrNodeInstance.dtoName);
+    return this.isTableCaption(blockOrNodeInstance.typeName);
   }
   /**
    * @inheritDoc
@@ -7966,7 +7682,7 @@ class TableCellFilterStylesStrategy extends codeBlock.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.
@@ -8030,12 +7746,12 @@ class VegaRTETableExtension extends linkExtension.VegaRTEExtension {
     this.tableSelection = new RTETableSelection();
     splitCellOperation.RTETableColorManager.setTableColors(colors);
     this.registerToolbarButtonRenderer(VegaRTETableExtension.TOOLBAR_BUTTON_KEY, this.toolbarButtonRenderer);
-    this.registerBlockBasicStrategies(splitCellOperation.RTETableBlock.name);
-    this.registerBlockBasicStrategies(splitCellOperation.RTETableHeadBlock.name);
-    this.registerBlockBasicStrategies(splitCellOperation.RTETableHeadCellBlock.name);
-    this.registerBlockBasicStrategies(splitCellOperation.RTETableRowBlock.name);
-    this.registerBlockBasicStrategies(splitCellOperation.RTETableCellBlock.name);
-    this.registerBlockBasicStrategies(splitCellOperation.RTETableBodyBlock.name);
+    this.registerBlockBasicStrategies(splitCellOperation.RTETableBlock.typeName);
+    this.registerBlockBasicStrategies(splitCellOperation.RTETableHeadBlock.typeName);
+    this.registerBlockBasicStrategies(splitCellOperation.RTETableHeadCellBlock.typeName);
+    this.registerBlockBasicStrategies(splitCellOperation.RTETableRowBlock.typeName);
+    this.registerBlockBasicStrategies(splitCellOperation.RTETableCellBlock.typeName);
+    this.registerBlockBasicStrategies(splitCellOperation.RTETableBodyBlock.typeName);
     this.registerRenderer('table-block', this.tableBlockRenderer);
     this.registerRenderer('table-head', new RTETableHeadRenderer());
     this.registerRenderer('table-head-cell', this.tableHeadCellRenderer);
@@ -8082,41 +7798,41 @@ class VegaRTETableExtension extends linkExtension.VegaRTEExtension {
 (() => {
   const insertTableBlockStrategy = new InsertTableBlockStrategy();
   const deleteTableBlockStrategy = new DeleteTableBlockStrategy();
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.VegaRTEContent.name, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.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).
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, DELETE_TABLE_BLOCK, deleteTableBlockStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.name, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.RTEImageBlock.name, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, splitCellOperation.INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, new InsertTableRowIntoDifferentSectionStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, splitCellOperation.INSERT_TABLE_ROW_INTO_SAME_SECTION, new InsertTableRowIntoSameSectionStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, splitCellOperation.DELETE_TABLE_ROW, new DeleteTableRowStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, splitCellOperation.TOGGLE_HEADER_ROW, new ToggleHeaderRowStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, splitCellOperation.INSERT_TABLE_COLUMN, new InsertTableColumnStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, splitCellOperation.DELETE_TABLE_COLUMN, new DeleteTableColumnStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, splitCellOperation.TOGGLE_HEADER_TABLE_COLUMN, new splitCellOperation.ToggleHeaderTableColumnStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableRowBlock.name, splitCellOperation.SPLIT_TABLE_CELL, new SplitTableCellStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableRowBlock.name, CREATE_SEGMENT_TABLE_CELL, new CreateSegmentTableCellStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableRowBlock.name, splitCellOperation.REPLACE_TABLE_CELL, new ReplaceTableCellStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableCellBlock.name, splitCellOperation.SPLIT_CELL_HORIZONTALLY, new SplitCellHorizontallyStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableCellBlock.name, splitCellOperation.SPLIT_CELL_VERTICALLY, new SplitCellVerticallyStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableHeadCellBlock.name, splitCellOperation.SPLIT_CELL_HORIZONTALLY, new SplitCellHorizontallyStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableHeadCellBlock.name, splitCellOperation.SPLIT_CELL_VERTICALLY, new SplitCellVerticallyStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, splitCellOperation.SELECT_TABLE_COLUMN, new SelectTableColumnStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, splitCellOperation.MERGE_CELLS, new MergeCellsStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, UpdateTablePropertiesAction.name, new UpdateTablePropertiesStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableCellBlock.name, RTETableCellAnnotationsAction.name, new UpdateTableCellPropertiesStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableHeadCellBlock.name, RTETableHeadCellAnnotationsAction.name, new UpdateTableCellPropertiesStrategy());
-  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(codeBlock.RTETextBlock.name, codeBlock.ModifyContentActionType.DELETE_BLOCK_CONTENT, new PreventCellContentDeleteInterceptor());
-  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(splitCellOperation.RTETableRowBlock.name, codeBlock.ModifyContentActionType.INSERT_CHILDREN_BEFORE, new PreventRowInsertInterceptor());
-  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(splitCellOperation.RTETableCellBlock.name, codeBlock.ModifyContentActionType.DELETE_CHILDREN, new PreventCellChildrenRemoveInterceptor());
-  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(splitCellOperation.RTETableHeadCellBlock.name, codeBlock.ModifyContentActionType.DELETE_CHILDREN, new PreventCellChildrenRemoveInterceptor());
-  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(splitCellOperation.RTETableBlock.name, codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, new PreventTableInsertParagraphInterceptor());
-  linkExtension.VegaRTEExtension.registerFilterStylesStrategy(splitCellOperation.RTETableBlock.dtoName, new TableBlockFilterStylesStrategy());
-  linkExtension.VegaRTEExtension.registerFilterStylesStrategy(RTETableCaptionBlock.dtoName, new TableCaptionFilterStylesStrategy());
-  linkExtension.VegaRTEExtension.registerFilterStylesStrategy(splitCellOperation.RTETableCellBlock.dtoName, new TableCellFilterStylesStrategy());
-  linkExtension.VegaRTEExtension.registerFilterStylesStrategy(splitCellOperation.RTETableHeadCellBlock.dtoName, new TableCellFilterStylesStrategy('th'));
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.typeName, DELETE_TABLE_BLOCK, deleteTableBlockStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.typeName, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.RTEImageBlock.typeName, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.typeName, splitCellOperation.INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, new InsertTableRowIntoDifferentSectionStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.typeName, splitCellOperation.INSERT_TABLE_ROW_INTO_SAME_SECTION, new InsertTableRowIntoSameSectionStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.typeName, splitCellOperation.DELETE_TABLE_ROW, new DeleteTableRowStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.typeName, splitCellOperation.TOGGLE_HEADER_ROW, new ToggleHeaderRowStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.typeName, splitCellOperation.INSERT_TABLE_COLUMN, new InsertTableColumnStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.typeName, splitCellOperation.DELETE_TABLE_COLUMN, new DeleteTableColumnStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.typeName, splitCellOperation.TOGGLE_HEADER_TABLE_COLUMN, new splitCellOperation.ToggleHeaderTableColumnStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableRowBlock.typeName, splitCellOperation.SPLIT_TABLE_CELL, new SplitTableCellStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableRowBlock.typeName, CREATE_SEGMENT_TABLE_CELL, new CreateSegmentTableCellStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableRowBlock.typeName, splitCellOperation.REPLACE_TABLE_CELL, new ReplaceTableCellStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableCellBlock.typeName, splitCellOperation.SPLIT_CELL_HORIZONTALLY, new SplitCellHorizontallyStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableCellBlock.typeName, splitCellOperation.SPLIT_CELL_VERTICALLY, new SplitCellVerticallyStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableHeadCellBlock.typeName, splitCellOperation.SPLIT_CELL_HORIZONTALLY, new SplitCellHorizontallyStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableHeadCellBlock.typeName, splitCellOperation.SPLIT_CELL_VERTICALLY, new SplitCellVerticallyStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.typeName, splitCellOperation.SELECT_TABLE_COLUMN, new SelectTableColumnStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.typeName, splitCellOperation.MERGE_CELLS, new MergeCellsStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.typeName, UpdateTablePropertiesAction.typeName, new UpdateTablePropertiesStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableCellBlock.typeName, RTETableCellAnnotationsAction.typeName, new UpdateTableCellPropertiesStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableHeadCellBlock.typeName, RTETableHeadCellAnnotationsAction.typeName, new UpdateTableCellPropertiesStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(codeBlock.RTETextBlock.typeName, codeBlock.ModifyContentActionType.DELETE_BLOCK_CONTENT, new PreventCellContentDeleteInterceptor());
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(splitCellOperation.RTETableRowBlock.typeName, codeBlock.ModifyContentActionType.INSERT_CHILDREN_BEFORE, new PreventRowInsertInterceptor());
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(splitCellOperation.RTETableCellBlock.typeName, codeBlock.ModifyContentActionType.DELETE_CHILDREN, new PreventCellChildrenRemoveInterceptor());
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(splitCellOperation.RTETableHeadCellBlock.typeName, codeBlock.ModifyContentActionType.DELETE_CHILDREN, new PreventCellChildrenRemoveInterceptor());
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(splitCellOperation.RTETableBlock.typeName, codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, new PreventTableInsertParagraphInterceptor());
+  linkExtension.VegaRTEExtension.registerFilterStylesStrategy(splitCellOperation.RTETableBlock.typeName, new TableBlockFilterStylesStrategy());
+  linkExtension.VegaRTEExtension.registerFilterStylesStrategy(RTETableCaptionBlock.typeName, new TableCaptionFilterStylesStrategy());
+  linkExtension.VegaRTEExtension.registerFilterStylesStrategy(splitCellOperation.RTETableCellBlock.typeName, new TableCellFilterStylesStrategy());
+  linkExtension.VegaRTEExtension.registerFilterStylesStrategy(splitCellOperation.RTETableHeadCellBlock.typeName, new TableCellFilterStylesStrategy('th'));
 })();
 VegaRTETableExtension.TOOLBAR_BUTTON_KEY = 'table';
 
@@ -8151,6 +7867,7 @@ class RTEHorizontalLineNode extends codeBlock.RTEDecoratorNode {
     return '<hr>';
   }
 }
+RTEHorizontalLineNode.typeName = 'RTEHorizontalLineNode';
 
 /**
  * Predicate class provides static methods to check specific conditions on HTML elements or dto instances.
@@ -8195,7 +7912,7 @@ class HorizontalLineFilterStylesStrategy extends codeBlock.RTEFilterStylesStrate
    * @inheritDoc
    */
   canFilter(blockOrNodeInstance) {
-    return Predicate.isHorizontalLineBlock(blockOrNodeInstance.dtoName);
+    return Predicate.isHorizontalLineBlock(blockOrNodeInstance.typeName);
   }
   /**
    * @inheritDoc
@@ -8279,7 +7996,6 @@ class HorizontalLineAnnotation extends codeBlock.BlockAnnotation {
 class RTEHorizontalLineBlock extends codeBlock.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 : {};
@@ -8357,7 +8073,7 @@ class RTEHorizontalLineBlock extends codeBlock.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)}";
 
@@ -8395,6 +8111,7 @@ class RTEHorizontalLineBlockRenderer extends linkExtension.VegaRTEExtensionRende
     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>`,
@@ -8417,7 +8134,7 @@ class InsertHorizontalLineBlockAction extends codeBlock.ModifyContentAction {
 /**
  * Toolbar button renderer for horizontal line insertion.
  */
-class RTEHorizontalLineToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+class RTEHorizontalLineToolbarButtonRenderer extends imageExtension.VegaRTEToolbarButtonRenderer {
   /**
    * Renders the horizontal line toolbar button.
    *
@@ -8611,7 +8328,7 @@ class VegaRTEHorizontalLineExtension extends linkExtension.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
@@ -8621,16 +8338,16 @@ class VegaRTEHorizontalLineExtension extends linkExtension.VegaRTEExtension {
     // Register HTML → DTO conversion strategy
     this.registerElementToBlockDTOClassStrategy(new HrToHorizontalLineBlockStrategy());
     // Register filter styles strategy for source edit round-trip
-    linkExtension.VegaRTEExtension.registerFilterStylesStrategy(RTEHorizontalLineBlock.dtoName, new HorizontalLineFilterStylesStrategy());
+    linkExtension.VegaRTEExtension.registerFilterStylesStrategy(RTEHorizontalLineBlock.typeName, new HorizontalLineFilterStylesStrategy());
   }
 }
 (() => {
   const insertStrategy = new InsertHorizontalLineBlockStrategy();
   // Register insert strategy for all block types that can be a target
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.VegaRTEContent.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.RTEImageBlock.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(RTEHorizontalLineBlock.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.VegaRTEContent.typeName, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.typeName, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.RTEImageBlock.typeName, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(RTEHorizontalLineBlock.typeName, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
 })();
 VegaRTEHorizontalLineExtension.TOOLBAR_BUTTON_KEY = 'horizontalLine';
 
@@ -8715,7 +8432,6 @@ class BlockquoteAnnotation extends codeBlock.BlockAnnotation {
 class RTEBlockquoteBlock extends codeBlock.RTEBlock {
   constructor(id, options) {
     super(id);
-    this.dtoName = RTEBlockquoteBlock.dtoName;
     this.type = 'blockquote';
     this.children = [];
     const { autoMatchFormat = true } = options !== null && options !== void 0 ? options : {};
@@ -8776,7 +8492,7 @@ class RTEBlockquoteBlock extends codeBlock.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
@@ -8840,7 +8556,7 @@ class RemoveBlockquoteStrategy extends codeBlock.ActionHandleStrategy {
  * the quote) moves that empty paragraph out to a new paragraph after the blockquote,
  * instead of stacking another empty line inside the quote.
  */
-class BlockquoteExitOnEnterInterceptor extends ActionHandlerInterceptor {
+class BlockquoteExitOnEnterInterceptor extends imageExtension.ActionHandlerInterceptor {
   /**
    * Intercept only when the caret sits in an empty paragraph that is the last child of a blockquote.
    *
@@ -8994,6 +8710,7 @@ class RTEBlockquoteBlockRenderer extends linkExtension.VegaRTEExtensionRenderer
     return BlockquoteAnnotation.getDefaultCssText();
   }
 }
+RTEBlockquoteBlockRenderer.typeName = 'RTEBlockquoteBlockRenderer';
 const RTEBlockquoteBlockRenderer$1 = new RTEBlockquoteBlockRenderer();
 
 // FontAwesome 7.2.0 — `quote-left` (solid).
@@ -9017,7 +8734,7 @@ const QuoteLeftIcon = {
  *   selection so it can append a new blockquote.
  * - Hidden in source-edit mode (inherited from {@link VegaRTEToolbarButtonRenderer}).
  */
-class RTEBlockquoteToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+class RTEBlockquoteToolbarButtonRenderer extends imageExtension.VegaRTEToolbarButtonRenderer {
   /**
    * @inheritDoc
    */
@@ -9275,7 +8992,7 @@ class BlockquoteFilterStylesStrategy extends codeBlock.RTEFilterStylesStrategy {
    * @inheritDoc
    */
   canFilter(blockOrNodeInstance) {
-    return BlockquoteFilterStylesStrategy.isBlockquoteBlock(blockOrNodeInstance.dtoName);
+    return BlockquoteFilterStylesStrategy.isBlockquoteBlock(blockOrNodeInstance.typeName);
   }
   /**
    * @inheritDoc
@@ -9298,28 +9015,28 @@ class VegaRTEBlockquoteExtension extends linkExtension.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.
-    linkExtension.VegaRTEExtension.registerFilterStylesStrategy(RTEBlockquoteBlock.dtoName, new BlockquoteFilterStylesStrategy());
+    linkExtension.VegaRTEExtension.registerFilterStylesStrategy(RTEBlockquoteBlock.typeName, new BlockquoteFilterStylesStrategy());
   }
 }
 (() => {
   const wrapStrategy = new BlockTransformToBlockquoteStrategy();
   // Root container — wrap top-level blocks.
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.VegaRTEContent.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.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.
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableCellBlock.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableHeadCellBlock.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(RTEBlockquoteBlock.name, REMOVE_BLOCKQUOTE, new RemoveBlockquoteStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableCellBlock.typeName, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableHeadCellBlock.typeName, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  linkExtension.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.
-  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(codeBlock.RTETextBlock.name, codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, new BlockquoteExitOnEnterInterceptor());
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(codeBlock.RTETextBlock.typeName, codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, new BlockquoteExitOnEnterInterceptor());
 })();
 VegaRTEBlockquoteExtension.TOOLBAR_BUTTON_KEY = 'blockquote';
 
@@ -9637,7 +9354,7 @@ const specialCharactersIcon = {
  * Renders a toolbar button with an Ω icon that opens a popover panel
  * with categorized character grids.
  */
-class RTESpecialCharactersToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+class RTESpecialCharactersToolbarButtonRenderer extends imageExtension.VegaRTEToolbarButtonRenderer {
   constructor(categories) {
     super();
     this.panelRef = null;
@@ -10858,7 +10575,7 @@ class ReplaceController extends FindReplaceControllerAbstract {
  * Both controllers share a single {@link FindReplaceControllerContext} so they
  * operate on the same search state and highlight overlays.
  */
-class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+class FindReplaceToolbarButtonRenderer extends imageExtension.VegaRTEToolbarButtonRenderer {
   constructor() {
     super(...arguments);
     this.sharedContext = createFindReplaceControllerContext();
@@ -11202,6 +10919,7 @@ class LineHeightAnnotationAction extends codeBlock.AnnotationAction {
     return new LineHeightAnnotation(this.lineHeight);
   }
 }
+LineHeightAnnotationAction.typeName = 'LineHeightAnnotationAction';
 
 /**
  * Update the block line height strategy.
@@ -11228,7 +10946,7 @@ const lineHeight = {
 /**
  * Renderer for the line-height toolbar button in the Vega Rich Text Editor.
  */
-class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+class RTELineHeightToolbarButtonRenderer extends imageExtension.VegaRTEToolbarButtonRenderer {
   constructor(options) {
     super();
     this.options = options;
@@ -11298,7 +11016,7 @@ class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     const selectedBlocks = this.getSelectedBlocks(editorContext);
     return selectedBlocks.some((block) => block instanceof codeBlock.RTECodeBlock ||
       block instanceof contentState.RTEImageBlock ||
-      !codeBlock.ActionHandleStrategyRegistry.canHandle(LineHeightAnnotationAction.name, block));
+      !codeBlock.ActionHandleStrategyRegistry.canHandle(LineHeightAnnotationAction.typeName, block));
   }
   /**
    * @inheritDoc
@@ -11363,8 +11081,8 @@ class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
 })();
 
 const LINE_HEIGHT_AWARE_BLOCK_NAMES = new Set([
-  codeBlock.RTETextBlock.name,
-  codeBlock.RTEListItemBlock.name,
+  codeBlock.RTETextBlock.typeName,
+  codeBlock.RTEListItemBlock.typeName,
 ]);
 /** Handle line height annotation. */
 class LineHeightAnnotationHandler extends contentState.AnnotationGeneratorStrategyAbstract {
@@ -11379,7 +11097,7 @@ class LineHeightAnnotationHandler extends contentState.AnnotationGeneratorStrate
    * @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.
@@ -11531,8 +11249,8 @@ class VegaRTELineHeightExtension extends linkExtension.VegaRTEExtension {
 }
 (() => {
   [codeBlock.RTETextBlock, codeBlock.RTEListItemBlock].forEach((BlockClass) => {
-    linkExtension.VegaRTEExtension.registerActionHandleStrategy(BlockClass.name, LineHeightAnnotationAction.name, new BlockUpdateLineHeightStrategy());
-    codeBlock.RTEFilterStylesStrategyRegistry.register(BlockClass.name, new LineHeightFilterStylesStrategy());
+    linkExtension.VegaRTEExtension.registerActionHandleStrategy(BlockClass.typeName, LineHeightAnnotationAction.typeName, new BlockUpdateLineHeightStrategy());
+    codeBlock.RTEFilterStylesStrategyRegistry.register(BlockClass.typeName, new LineHeightFilterStylesStrategy());
     attachLineHeightFromJson(BlockClass);
   });
 })();
@@ -11549,7 +11267,7 @@ const fullscreenExit = {
 /**
  * Toolbar button renderer for fullscreen toggle.
  */
-class RTEFullscreenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+class RTEFullscreenToolbarButtonRenderer extends imageExtension.VegaRTEToolbarButtonRenderer {
   constructor(controller) {
     super();
     this.controller = controller;
@@ -11805,6 +11523,7 @@ VegaRTEFullscreenExtension.controllerStore = VegaRTEFullscreenExtension.createSt
 var RTEPasteMode;
 (function (RTEPasteMode) {
   RTEPasteMode["RICH"] = "rich";
+  RTEPasteMode["PLAIN"] = "plain";
   RTEPasteMode["WORD"] = "word";
 })(RTEPasteMode || (RTEPasteMode = {}));
 /**
@@ -11856,185 +11575,63 @@ class AbstractPasteProcessingStrategy {
   get supportsImageProcessing() {
     return false;
   }
-}
-
-const paste = {
-  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Pro 6.3.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><path fill="currentColor" d="M80 96v16c0 17.7 14.3 32 32 32h60.8c16.6-28.7 47.6-48 83.2-48h62c-7.1-27.6-32.2-48-62-48H215.4C211.6 20.9 188.2 0 160 0s-51.6 20.9-55.4 48H64C28.7 48 0 76.7 0 112V384c0 35.3 28.7 64 64 64h96V400H64c-8.8 0-16-7.2-16-16V112c0-8.8 7.2-16 16-16H80zm64-40a16 16 0 1 1 32 0 16 16 0 1 1 -32 0zM256 464c-8.8 0-16-7.2-16-16V192c0-8.8 7.2-16 16-16H384v48c0 17.7 14.3 32 32 32h48V448c0 8.8-7.2 16-16 16H256zm192 48c35.3 0 64-28.7 64-64V227.9c0-12.7-5.1-24.9-14.1-33.9l-51.9-51.9c-9-9-21.2-14.1-33.9-14.1H256c-35.3 0-64 28.7-64 64V448c0 35.3 28.7 64 64 64H448z"/></svg>`,
-};
-
-/**
- * Renders and manages the paste format chooser UI.
- */
-class RTEPasteChooserUI {
-  constructor(hostRoot, callbacks, options = {}) {
-    this.hostRoot = hostRoot;
-    this.callbacks = callbacks;
-    this.options = options;
-    this.chooserEl = null;
-    this.dropdownEl = null;
-    this.triggerButtonEl = null;
+  /** @returns {boolean} Whether this strategy consumes `text/plain` instead of `text/html` (default: false). */
+  get consumesPlainText() {
+    return false;
   }
   /**
-   * Opens the paste-mode chooser at the given position.
+   * Owns the complete content policy for this paste mode. Subclasses that
+   * only need a different source string should override {@link getSourceContent}
+   * instead of re-implementing this method.
    *
-   * @param {PasteChooserPosition} position Viewport position for the chooser.
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {PasteOutput} Complete downstream paste contract.
    */
-  open(position) {
-    this.destroy();
-    const doc = this.hostRoot.ownerDocument;
-    const chooser = doc.createElement('div');
-    chooser.setAttribute(RTEPasteChooserUI.CHOOSER_ATTR, 'true');
-    chooser.style.position = 'fixed';
-    chooser.style.zIndex = '1000';
-    chooser.style.left = `${position.left}px`;
-    chooser.style.top = `${position.top}px`;
-    const dropdownEl = this.createPasteChooserDropdown(doc, position.placement);
-    dropdownEl.placement = position.placement;
-    chooser.append(dropdownEl);
-    this.hostRoot.appendChild(chooser);
-    this.chooserEl = chooser;
-    this.dropdownEl = dropdownEl;
-    dropdownEl.addEventListener('vegaShow', () => {
-      if (this.triggerButtonEl) {
-        this.triggerButtonEl.selected = true;
-      }
-    });
-    dropdownEl.addEventListener('vegaHide', () => {
-      if (this.triggerButtonEl) {
-        this.triggerButtonEl.selected = false;
-      }
-    });
+  transform(input) {
+    const content = this.getSourceContent(input);
+    return {
+      html: this.process(content),
+      text: this.consumesPlainText ? content : input.text,
+      mode: this.type,
+      markers: {},
+      extractImages: this.supportsImageProcessing,
+      imagesToExtract: this.supportsImageProcessing ? input.files : [],
+    };
   }
   /**
-   * Removes the chooser from the DOM.
+   * Resolves the source string passed to {@link process}. Defaults to
+   * `input.text` when {@link consumesPlainText} is true, otherwise `input.html`.
+   *
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {string} Content to feed into `process`.
    */
-  destroy() {
-    var _a;
-    if (this.dropdownEl && typeof this.dropdownEl.hide === 'function') {
-      void this.dropdownEl.hide();
-    }
-    if ((_a = this.chooserEl) === null || _a === void 0 ? void 0 : _a.parentNode) {
-      this.chooserEl.parentNode.removeChild(this.chooserEl);
-    }
-    if (this.triggerButtonEl) {
-      this.triggerButtonEl.selected = false;
-    }
-    this.dropdownEl = null;
-    this.chooserEl = null;
-    this.triggerButtonEl = null;
+  getSourceContent(input) {
+    return this.consumesPlainText ? input.text : input.html;
   }
+}
+
+/**
+ * Default paste processing strategy that acts as a fallback when no other
+ * strategy matches. This strategy always accepts the content and passes it
+ * through unchanged — the normal RTE paste pipeline (DOMParser +
+ * ElementToDtoStrategyProcessor) handles the rest.
+ */
+class DefaultPasteProcessingStrategy extends AbstractPasteProcessingStrategy {
   /**
-   * Determines whether the given event path targets the chooser.
+   * Always matches as the terminal fallback strategy.
    *
-   * @param {EventTarget[]} eventPath Composed path of an event.
-   * @returns {boolean} `true` when the path includes the chooser.
+   * @param {string} html Raw clipboard HTML.
+   * @returns {boolean} Always `true`.
    */
-  includesEventPath(eventPath) {
-    if (!this.chooserEl) {
-      return false;
-    }
-    const isDropdownContentClick = eventPath.some((target) => {
-      return 'tagName' in target && target.tagName === 'VEGA-DROPDOWN-CONTENT-BOX';
-    });
-    return eventPath.includes(this.chooserEl) || isDropdownContentClick;
+  canHandle(html) {
+    // Default strategy is the fallback — always returns true.
+    return html !== undefined;
   }
   /**
-   * Builds the dropdown element with the rich text paste option.
+   * Returns the original HTML unchanged.
    *
-   * @param {Document} doc Document used to create elements.
-   * @param {['bottom', 'top'] | ['top', 'bottom']} placement Preferred placement order.
-   * @returns {HTMLElement} Configured dropdown element.
-   */
-  createPasteChooserDropdown(doc, placement) {
-    const dropdownEl = doc.createElement('vega-dropdown');
-    dropdownEl.trigger = 'click';
-    dropdownEl.selectType = 'single';
-    dropdownEl.selectedSourceKey = 'rich';
-    dropdownEl.maxWidth = 220;
-    dropdownEl.alignment = 'start';
-    dropdownEl.itemDisplayRule = 'ellipsis';
-    dropdownEl.isScreenPosition = true;
-    const triggerButton = doc.createElement('vega-rich-text-editor-toolbar-button');
-    const arrowIcon = placement[0] === 'top' ? 'chevron-up' : 'chevron-down';
-    triggerButton.setAttribute(RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR, 'true');
-    triggerButton.setAttribute('aria-label', internalTranslationController.VegaInternalTranslation.t('Paste options'));
-    triggerButton.setAttribute('arrow-icon', arrowIcon);
-    triggerButton.icon = 'rte-paste';
-    triggerButton.showArrowIcon = true;
-    triggerButton.selected = false;
-    this.triggerButtonEl = triggerButton;
-    const tooltipEl = doc.createElement('vega-tooltip');
-    tooltipEl.text = internalTranslationController.VegaInternalTranslation.t('Paste options');
-    tooltipEl.placement = ['bottom', 'top'];
-    tooltipEl.append(triggerButton);
-    dropdownEl.append(tooltipEl);
-    const itemsContainer = doc.createElement('div');
-    itemsContainer.setAttribute('slot', 'items');
-    const dropdownItems = [
-      this.createDropdownItem(doc, RTEPasteMode.RICH, internalTranslationController.VegaInternalTranslation.t('Use rich text'), RTEPasteChooserUI.CHOOSER_RICH_ATTR),
-    ];
-    if (this.options.showWordOption) {
-      dropdownItems.push(this.createDropdownItem(doc, RTEPasteMode.WORD, internalTranslationController.VegaInternalTranslation.t('Use Word'), RTEPasteChooserUI.CHOOSER_WORD_ATTR));
-    }
-    itemsContainer.append(...dropdownItems);
-    dropdownEl.append(itemsContainer);
-    dropdownEl.addEventListener('vegaDropdownClick', (event) => {
-      const mode = event.detail;
-      if (mode === RTEPasteMode.RICH || mode === RTEPasteMode.WORD) {
-        this.callbacks.onModeSelect(mode);
-      }
-    });
-    return dropdownEl;
-  }
-  /**
-   * Creates a single dropdown item element for a paste mode.
-   *
-   * @param {Document} doc Document used to create the element.
-   * @param {RTEPasteMode} key Paste mode key for the item.
-   * @param {string} label Display label for the item.
-   * @param {string} dataAttrName Data attribute marker for the item.
-   * @returns {HTMLVegaDropdownItemElement} Configured dropdown item element.
-   */
-  createDropdownItem(doc, key, label, dataAttrName) {
-    const itemEl = doc.createElement('vega-dropdown-item');
-    itemEl.itemKey = key;
-    itemEl.label = label;
-    itemEl.setAttribute(dataAttrName, 'true');
-    return itemEl;
-  }
-}
-(() => {
-  internalIconManager.VegaInternalIconManager.register({
-    'rte-paste': paste,
-  });
-})();
-RTEPasteChooserUI.CHOOSER_ATTR = 'data-rte-paste-chooser';
-RTEPasteChooserUI.CHOOSER_RICH_ATTR = 'data-rte-paste-type-rich';
-RTEPasteChooserUI.CHOOSER_WORD_ATTR = 'data-rte-paste-type-word';
-RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR = 'data-rte-paste-trigger';
-
-/**
- * Default paste processing strategy that acts as a fallback when no other
- * strategy matches. This strategy always accepts the content and passes it
- * through unchanged — the normal RTE paste pipeline (DOMParser +
- * ElementToDtoStrategyProcessor) handles the rest.
- */
-class DefaultPasteProcessingStrategy extends AbstractPasteProcessingStrategy {
-  /**
-   * Always matches as the terminal fallback strategy.
-   *
-   * @param {string} html Raw clipboard HTML.
-   * @returns {boolean} Always `true`.
-   */
-  canHandle(html) {
-    // Default strategy is the fallback — always returns true.
-    return html !== undefined;
-  }
-  /**
-   * Returns the original HTML unchanged.
-   *
-   * @param {string} html Raw clipboard HTML.
-   * @returns {string} Unchanged HTML.
+   * @param {string} html Raw clipboard HTML.
+   * @returns {string} Unchanged HTML.
    */
   process(html) {
     // Current default behavior: pass through unchanged
@@ -14030,6 +13627,76 @@ WordPasteProcessingStrategy.WORD_SIGNATURE_PATTERNS = [
   /<\/?o:p>/i,
 ];
 
+/** Converts plain-text clipboard to paragraph-per-line HTML. */
+class PlainPasteProcessingStrategy extends AbstractPasteProcessingStrategy {
+  /** @returns {RTEPasteMode} Plain-text paste mode. */
+  get type() {
+    return RTEPasteMode.PLAIN;
+  }
+  /** @returns {boolean} Always `true`; consumes `text/plain` instead of `text/html`. */
+  get consumesPlainText() {
+    return true;
+  }
+  /** @returns {boolean} Always `false`; never auto-selected. */
+  canHandle() {
+    return false;
+  }
+  /**
+   * Converts plain text to paragraph HTML; every `\n` starts a new paragraph.
+   *
+   * @param {string} text - Clipboard `text/plain` payload.
+   * @param {boolean} decodeEncodedWhitespace - Decode markers emitted by HTML conversion.
+   * @returns {string} Paragraph HTML.
+   */
+  process(text, decodeEncodedWhitespace = false) {
+    if (!text) {
+      return '';
+    }
+    const safeDocument = tryGetDocument.tryGetDocument();
+    if (!safeDocument) {
+      return '';
+    }
+    // Line splitting and boundary whitespace handling live in `toPlainPasteLines` so the
+    // emitted HTML and the RTE nodes built by `InsertPasteHandler` share one conversion.
+    return codeBlock.plainPasteLinesToHtml(codeBlock.toPlainPasteLines(text, decodeEncodedWhitespace));
+  }
+  /**
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {PasteOutput} Plain HTML, canonical text, and whitespace marker contract.
+   */
+  transform(input) {
+    const source = this.getPlainTextSource(input);
+    return {
+      html: this.process(source.text, source.hasEncodedWhitespace),
+      text: source.text,
+      mode: this.type,
+      markers: source.hasEncodedWhitespace ? { [codeBlock.RTE_PRESERVED_WHITESPACE_DATA_TYPE]: 'true' } : {},
+      extractImages: false,
+      imagesToExtract: [],
+    };
+  }
+  /**
+   * @param {PasteInput} input Clipboard content used to derive canonical plain text.
+   * @returns {PlainTextSource} Canonical text and whether it contains whitespace sentinels.
+   */
+  getPlainTextSource(input) {
+    if (!input.html) {
+      return { text: input.text || '', hasEncodedWhitespace: false };
+    }
+    const containsTable = imageExtension.htmlContainsTable(input.html);
+    if (input.text && input.text.includes('\t') && containsTable) {
+      return { text: input.text, hasEncodedWhitespace: false };
+    }
+    const derived = imageExtension.htmlToPlainText(input.html, {
+      preserveBoundaryBlankLines: !containsTable,
+      keepPreservedWhitespaceMarkers: true,
+    });
+    return derived
+      ? { text: derived, hasEncodedWhitespace: true }
+      : { text: input.text || '', hasEncodedWhitespace: false };
+  }
+}
+
 /**
  * Centralized selector for paste processing strategies.
  *
@@ -14042,10 +13709,27 @@ class PasteStrategySelector {
   constructor() {
     this.defaultStrategy = new DefaultPasteProcessingStrategy();
     this.strategies = [
+      new PlainPasteProcessingStrategy(),
       new WordPasteProcessingStrategy(),
       this.defaultStrategy, // Fallback
     ];
   }
+  /**
+   * Selects the strategy that will process this paste.
+   *
+   * When `explicitMode` is provided and not `rich`, the strategy registered for that mode
+   * is used. Otherwise the highest-priority strategy whose `canHandle` matches the HTML
+   * wins, falling back to the default pass-through strategy.
+   *
+   * @param {PasteInput} input Captured clipboard payload used for auto-detection.
+   * @param {RTEPasteMode} [explicitMode] Paste mode the user picked from the chooser.
+   * @returns {AbstractPasteProcessingStrategy} Strategy to run for this paste.
+   */
+  select(input, explicitMode) {
+    return explicitMode && explicitMode !== RTEPasteMode.RICH
+      ? this.selectStrategyByType(explicitMode)
+      : this.selectStrategy(input.html);
+  }
   /**
    * Select the appropriate strategy for the given HTML content.
    * Returns the highest-priority strategy that can handle the content.
@@ -14513,24 +14197,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, [codeBlock.RTE_PASTE_MODE_DATA_TYPE]: output.mode });
+    if (typeof DataTransfer !== 'undefined') {
+      const dataTransfer = new DataTransfer();
+      Object.keys(values).forEach((type) => {
+        const value = values[type];
+        if (value) {
+          dataTransfer.setData(type, value);
+        }
+      });
+      return dataTransfer;
+    }
+    return {
+      /**
+       * @param {string} type Clipboard data type to read.
+       * @returns {string} Clipboard value for the requested type.
+       */
+      getData: (type) => { var _a; return (_a = values[type]) !== null && _a !== void 0 ? _a : ''; },
+    };
+  }
+}
+PasteDataTransferBuilder.RESERVED_KEYS = [
+  'text/html',
+  'text/plain',
+  codeBlock.RTE_PASTE_MODE_DATA_TYPE,
+];
+
+/** Dispatches processed paste data through the editor's existing beforeinput pipeline. */
+class PasteDispatcher {
+  /**
+   * @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', internalTranslationController.VegaInternalTranslation.t('Paste options'));
+    triggerButton.setAttribute('arrow-icon', arrowIcon);
+    triggerButton.icon = 'rte-paste';
+    triggerButton.showArrowIcon = true;
+    triggerButton.selected = false;
+    this.triggerButtonEl = triggerButton;
+    const tooltipEl = doc.createElement('vega-tooltip');
+    tooltipEl.text = internalTranslationController.VegaInternalTranslation.t('Paste options');
+    tooltipEl.placement = ['bottom', 'top'];
+    tooltipEl.append(triggerButton);
+    dropdownEl.append(tooltipEl);
+    const itemsContainer = doc.createElement('div');
+    itemsContainer.setAttribute('slot', 'items');
+    const dropdownItems = [
+      this.createDropdownItem(doc, RTEPasteMode.RICH, internalTranslationController.VegaInternalTranslation.t('Use rich text'), RTEPasteChooserUI.CHOOSER_RICH_ATTR),
+      this.createDropdownItem(doc, RTEPasteMode.PLAIN, internalTranslationController.VegaInternalTranslation.t('Use plain text'), RTEPasteChooserUI.CHOOSER_PLAIN_ATTR),
+    ];
+    if (this.options.showWordOption) {
+      dropdownItems.push(this.createDropdownItem(doc, RTEPasteMode.WORD, internalTranslationController.VegaInternalTranslation.t('Use Word'), RTEPasteChooserUI.CHOOSER_WORD_ATTR));
+    }
+    itemsContainer.append(...dropdownItems);
+    dropdownEl.append(itemsContainer);
+    dropdownEl.addEventListener('vegaDropdownClick', (event) => {
+      const mode = event.detail;
+      if (mode === RTEPasteMode.RICH || mode === RTEPasteMode.PLAIN || mode === RTEPasteMode.WORD) {
+        this.callbacks.onModeSelect(mode);
+      }
+    });
+    return dropdownEl;
+  }
+  /**
+   * Creates a single dropdown item element for a paste mode.
+   *
+   * @param {Document} doc Document used to create the element.
+   * @param {RTEPasteMode} key Paste mode key for the item.
+   * @param {string} label Display label for the item.
+   * @param {string} dataAttrName Data attribute marker for the item.
+   * @returns {HTMLVegaDropdownItemElement} Configured dropdown item element.
+   */
+  createDropdownItem(doc, key, label, dataAttrName) {
+    const itemEl = doc.createElement('vega-dropdown-item');
+    itemEl.itemKey = key;
+    itemEl.label = label;
+    itemEl.setAttribute(dataAttrName, 'true');
+    return itemEl;
+  }
+}
+(() => {
+  internalIconManager.VegaInternalIconManager.register({
+    'rte-paste': paste,
+  });
+})();
+RTEPasteChooserUI.CHOOSER_ATTR = 'data-rte-paste-chooser';
+RTEPasteChooserUI.CHOOSER_RICH_ATTR = 'data-rte-paste-type-rich';
+RTEPasteChooserUI.CHOOSER_PLAIN_ATTR = 'data-rte-paste-type-plain';
+RTEPasteChooserUI.CHOOSER_WORD_ATTR = 'data-rte-paste-type-word';
+RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR = 'data-rte-paste-trigger';
+
+/** Owns chooser rendering and all listener bookkeeping used to dismiss it. */
+class PasteChooserController {
+  constructor(positioner, onModeSelect, onClearPayload) {
+    this.positioner = positioner;
+    this.onModeSelect = onModeSelect;
+    this.onClearPayload = onClearPayload;
+    this.chooserUI = null;
+    this.listenerDocument = null;
+    this.listenerWindow = null;
+    this.contentHostEl = null;
+    /**
+     * @param {Event} event Pointer event captured on the document.
+     */
+    this.handleOutsidePointerDown = (event) => {
+      if (!this.chooserUI) {
+        return;
+      }
+      const eventPath = typeof event.composedPath === 'function' ? event.composedPath() : [];
+      if (!this.chooserUI.includesEventPath(eventPath)) {
+        this.clear();
+      }
+    };
+    /**
+     * @param {KeyboardEvent} event Keyboard event captured on the document.
+     */
+    this.handleOutsideKeyDown = (event) => {
+      if (event.key === 'Escape') {
+        this.clear();
+      }
+    };
+    /**
+     * Clears the chooser when a relevant scroll container scrolls.
+     *
+     * @returns {void}
+     */
+    this.handleOutsideScroll = () => this.clear();
+  }
+  /**
+   * @returns {RTEPasteChooserUI | null} Current chooser UI, or `null` when closed.
+   */
+  get ui() {
+    return this.chooserUI;
+  }
+  /**
+   * @param {HTMLElement | null} hostEl Rich text editor host element.
+   * @param {HTMLElement | null} contentHostEl Scrollable content host element.
+   * @param {ClipboardEvent} pasteEvent Originating paste event used for positioning.
+   * @param {boolean} showWordOption Whether to display the Word paste option.
+   */
+  open(hostEl, contentHostEl, pasteEvent, showWordOption) {
+    var _a, _b, _c;
+    const hostRoot = (_a = hostEl === null || hostEl === void 0 ? void 0 : hostEl.shadowRoot) !== null && _a !== void 0 ? _a : null;
+    if (!hostRoot || !hostEl) {
+      return;
+    }
+    this.clear(false);
+    const position = this.positioner.compute(pasteEvent);
+    this.chooserUI = new RTEPasteChooserUI(hostRoot, { onModeSelect: this.onModeSelect }, { showWordOption });
+    this.chooserUI.open(position);
+    this.contentHostEl = contentHostEl;
+    this.listenerDocument = hostEl.ownerDocument;
+    this.listenerWindow = this.listenerDocument.defaultView;
+    this.listenerDocument.addEventListener('mousedown', this.handleOutsidePointerDown, true);
+    this.listenerDocument.addEventListener('keydown', this.handleOutsideKeyDown, true);
+    this.listenerDocument.addEventListener('scroll', this.handleOutsideScroll, true);
+    (_b = this.listenerWindow) === null || _b === void 0 ? void 0 : _b.addEventListener('scroll', this.handleOutsideScroll, true);
+    (_c = this.contentHostEl) === null || _c === void 0 ? void 0 : _c.addEventListener('scroll', this.handleOutsideScroll);
+  }
+  /**
+   * @param {boolean} [clearPayload] Whether to also clear the pending paste payload.
+   */
+  clear(clearPayload = true) {
+    var _a, _b, _c;
+    (_a = this.contentHostEl) === null || _a === void 0 ? void 0 : _a.removeEventListener('scroll', this.handleOutsideScroll);
+    this.contentHostEl = null;
+    (_b = this.listenerWindow) === null || _b === void 0 ? void 0 : _b.removeEventListener('scroll', this.handleOutsideScroll, true);
+    this.listenerWindow = null;
+    if (this.listenerDocument) {
+      this.listenerDocument.removeEventListener('mousedown', this.handleOutsidePointerDown, true);
+      this.listenerDocument.removeEventListener('keydown', this.handleOutsideKeyDown, true);
+      this.listenerDocument.removeEventListener('scroll', this.handleOutsideScroll, true);
+      this.listenerDocument = null;
+    }
+    (_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.
@@ -14541,16 +14792,7 @@ class VegaRTEPasteExtension extends linkExtension.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.
@@ -14558,33 +14800,7 @@ class VegaRTEPasteExtension extends linkExtension.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.
@@ -14592,14 +14808,7 @@ class VegaRTEPasteExtension extends linkExtension.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.
@@ -14607,17 +14816,30 @@ class VegaRTEPasteExtension extends linkExtension.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) {
@@ -14631,6 +14853,10 @@ class VegaRTEPasteExtension extends linkExtension.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.
    */
@@ -14638,17 +14864,13 @@ class VegaRTEPasteExtension extends linkExtension.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;
   }
@@ -14679,12 +14901,7 @@ class VegaRTEPasteExtension extends linkExtension.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.
@@ -14692,145 +14909,8 @@ class VegaRTEPasteExtension extends linkExtension.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.
@@ -14852,36 +14932,13 @@ class VegaRTEPasteExtension extends linkExtension.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.
@@ -14891,141 +14948,17 @@ class VegaRTEPasteExtension extends linkExtension.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(codeBlock.RTE_PASTE_MODE_DATA_TYPE, mode);
-      }
-      return dataTransfer;
-    }
-    return {
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      getData: (type) => {
-        if (type === 'text/html') {
-          return html;
-        }
-        if (type === 'text/plain') {
-          return text;
-        }
-        if (type === codeBlock.RTE_PASTE_MODE_DATA_TYPE) {
-          return mode !== null && mode !== void 0 ? mode : '';
-        }
-        return '';
-      },
-    };
-  }
   /**
    * 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);
   }
 }
 (() => {
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.RTEImageNode.name, REPLACE_IMAGE_SRC, new ImageReplaceSrcStrategy());
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.RTEImageNode.typeName, REPLACE_IMAGE_SRC, new ImageReplaceSrcStrategy());
 })();
 
 /**
@@ -15053,7 +14986,7 @@ class CopySelectedContentAction extends codeBlock.ModifyContentAction {
  * Toolbar button renderer for the Copy extension.
  * Renders a toolbar button that copies the currently selected editor text to the clipboard.
  */
-class RTECopyToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+class RTECopyToolbarButtonRenderer extends imageExtension.VegaRTEToolbarButtonRenderer {
   /**
    * Renders the copy toolbar button.
    *
@@ -15338,7 +15271,7 @@ class VegaRTECopyExtension extends linkExtension.VegaRTEExtension {
   }
 }
 (() => {
-  codeBlock.ActionHandleStrategyRegistry.register('COPY_SELECTED_CONTENT_ACTION', contentState.VegaRTEContent.name, new CopySelectedContentStrategy());
+  codeBlock.ActionHandleStrategyRegistry.register('COPY_SELECTED_CONTENT_ACTION', contentState.VegaRTEContent.typeName, new CopySelectedContentStrategy());
 })();
 // The unique key for the copy toolbar button, used for registration and retrieval.
 VegaRTECopyExtension.TOOLBAR_BUTTON_KEY = 'copy';
@@ -15423,7 +15356,7 @@ VegaRTECutExtension.TOOLBAR_BUTTON_KEY = 'cut';
  * Vetoes a commit that would push the character count past the hard limit, while
  * still allowing deletions and formatting that keep or reduce the count.
  */
-class PreventHardLimitExceedInterceptor extends ActionHandlerInterceptor {
+class PreventHardLimitExceedInterceptor extends imageExtension.ActionHandlerInterceptor {
   /**
    * Intercept when the candidate exceeds the configured maximum. Hard-limit
    * commits are vetoed only when they increase the count.
@@ -15540,23 +15473,9 @@ class VegaRTEWordCountExtension extends linkExtension.VegaRTEExtension {
 }
 (() => {
   // Gate over-limit commits through the shared action-interceptor pipeline.
-  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(contentState.VegaRTEContent.name, contentState.COMMIT_VALUE, new PreventHardLimitExceedInterceptor());
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(contentState.VegaRTEContent.typeName, contentState.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 codeBlock.ModifyContentAction {
-  constructor(rteRange, nodeToBeInserted) {
-    super();
-    this.type = codeBlock.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.
  */
@@ -15571,7 +15490,7 @@ class InsertTokenNodeStrategy extends codeBlock.ActionHandleStrategy {
       const { key, label, customAttrs = { wrapped: 'true' } } = token;
       const tokenNode = new RTETokenNode(misc.generateUUID(), key, label, block);
       tokenNode.annotationMap.set('CUSTOM_ATTRIBUTE', new codeBlock.CustomAttributeAnnotation(customAttrs));
-      block.apply(new InsertNodeToNearestRootAction(rteRange, tokenNode));
+      block.apply(new imageExtension.InsertNodeToNearestRootAction(rteRange, tokenNode));
       action.actionHandleResult = true;
     }
   }
@@ -15668,14 +15587,12 @@ class VegaRTETokenExtension extends linkExtension.VegaRTEExtension {
 }
 (() => {
   const insertTokenNodeStrategy = new InsertTokenNodeStrategy();
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.name, 'INSERT_TOKEN_NODE', insertTokenNodeStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTEListItemBlock.name, 'INSERT_TOKEN_NODE', insertTokenNodeStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.typeName, 'INSERT_TOKEN_NODE', insertTokenNodeStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTEListItemBlock.typeName, 'INSERT_TOKEN_NODE', insertTokenNodeStrategy);
 })();
 VegaRTETokenExtension.TOOLBAR_BUTTON_KEY = 'token';
 
-exports.ActionHandlerInterceptor = ActionHandlerInterceptor;
 exports.DeleteSelectedContentAction = DeleteSelectedContentAction;
-exports.InsertNodeToNearestRootAction = InsertNodeToNearestRootAction;
 exports.RTEBlockquoteBlock = RTEBlockquoteBlock;
 exports.RTELanguageToolbarButtonRenderer = RTELanguageToolbarButtonRenderer;
 exports.RTETokenNode = RTETokenNode;
@@ -15705,7 +15622,6 @@ exports.VegaRTESpecialCharactersMathematical = VegaRTESpecialCharactersMathemati
 exports.VegaRTESpecialCharactersText = VegaRTESpecialCharactersText;
 exports.VegaRTETableExtension = VegaRTETableExtension;
 exports.VegaRTETokenExtension = VegaRTETokenExtension;
-exports.VegaRTEToolbarButtonRenderer = VegaRTEToolbarButtonRenderer;
 exports.VegaRTEWordCountExtension = VegaRTEWordCountExtension;
 exports.VegaSkeletonLoader = VegaSkeletonLoader;
 exports.VegaTranslation = VegaTranslation;