@globalpayments/vega 2.98.0 → 2.100.0

package/dist/esm/{token-extension-f2d009e3.js → token-extension-35c66684.js}

@@ -1,32 +1,32 @@
 import { g as generateUUID } from './misc-9fdbcfbb.js';
-import { a as arrayToClassString, g as getDeviceType, D as DeviceType, f as findParent, r as rgbToHex } from './ui-d73f756a.js';
+import { a as arrayToClassString, g as getDeviceType, D as DeviceType, f as findParent, r as rgbToHex, b as getDeepActiveElementInShadow } from './ui-80e610f4.js';
 import { L as LogUtility, I as InjectVegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
 import { I as InjectVegaTelemetrySlimmer, c as createPublicAPIRuntimeMetricsSlimmer } from './create-public-api-runtime-metrics-slimmer-48f85199.js';
 import { I as InternalVegaZIndexManager } from './internal-vega-z-index-manager-7d2b54c3.js';
 import { c as createDynamicSlimmer } from './dynamic-slimmer-90b8af32.js';
 import { P as PageResizeObserverSlimmer } from './page-resize-observer-slimmer-e24d36c5.js';
 import { i as internalVegaEventManager } from './internal-vega-event-manager-2ecc9186.js';
-import { V as VegaInternalTranslation } from './internal-translation-controller-fac22598.js';
-import { I as InternalCalendarPeriodConverter } from './internal-calendar-period-factory-7b294fb6.js';
-import { R as RTEExtensionContextManager, a as VegaRTEExtensionRenderer, b as VegaRTEExtension } from './link-extension-e8ee103e.js';
-import { M as ModifyContentAction, A as ActionHandleStrategyRegistry, R as RTETextNode, a as RTEBlock, b as RTETextBlock, c as RTEAnnotationStyle, d as ActionHandleStrategy, I as InsertChildrenAfterAction, e as AppendChildrenAction, f as RTENode, s as stateEntityRenderingRegistry, g as InsertChildrenBeforeAction, h as InternalAnnotationTypeEnum, i as ModifyContentActionType, B as BlockAnnotation, j as AnnotationAction, k as RemoveChildrenAction, C as CommonAnnotationTypeEnum, l as CustomAttributeAnnotation, m as RTEDTOClassManager, n as RTEFilterStylesStrategy, o as RTEDecoratorNode, S as SplitBlockWithNodeAction, U as UpdateTextAction, p as RTECodeBlock, q as RTEListItemBlock, r as RTECodeBlockNode, N as NodeAnnotationTypeEnum, t as CustomStyleAnnotation, u as RTEFilterStylesStrategyRegistry } from './code-block-9c513169.js';
-import { U as UpdateCursorPositionAction, V as VegaRTEContent, B as BlockToRTEBlockStrategyAbstract, E as ElementToDTOStrategy, h as htmlElementToAnnotationGenerator, I as InsertNewParagraphAction, R as RTEImageBlock, a as InsertChildrenBeforeStrategy, P as PasteContentStrategy, A as AnnotationGeneratorStrategyAbstract } from './content-state-25c81c08.js';
-import { i as isNonNullable } from './type-guard-f2624334.js';
+import { V as VegaInternalTranslation } from './internal-translation-controller-fff376d2.js';
+import { I as InternalCalendarPeriodConverter } from './internal-calendar-period-factory-d1a60f81.js';
+import { M as ModifyContentAction, A as ActionHandleStrategyRegistry, R as RTETextNode, H as HTML_VOID_TAGS, a as RTEBlock, b as RTETextBlock, c as RTE_BLOCK_BOUNDARY_ATTRIBUTE, d as RTEAnnotationStyle, e as ActionHandleStrategy, I as InsertChildrenAfterAction, f as AppendChildrenAction, g as RTENode, s as stateEntityRenderingRegistry, h as InsertChildrenBeforeAction, i as InternalAnnotationTypeEnum, j as ModifyContentActionType, B as BlockAnnotation, k as AnnotationAction, l as RemoveChildrenAction, C as CommonAnnotationTypeEnum, m as CustomAttributeAnnotation, n as RTEDTOClassManager, o as RTEFilterStylesStrategy, p as RTEDecoratorNode, S as SplitBlockWithNodeAction, U as UpdateTextAction, q as RTECodeBlock, r as RTEListItemBlock, t as RTECodeBlockNode, N as NodeAnnotationTypeEnum, u as CustomStyleAnnotation, v as RTEFilterStylesStrategyRegistry, w as RTE_PASTE_MODE_DATA_TYPE, x as RTE_WORD_COUNT_KEY } from './code-block-741d6b8e.js';
+import { U as UpdateCursorPositionAction, V as VegaRTEContent, B as BlockToRTEBlockStrategyAbstract, E as ElementToDTOStrategy, h as htmlElementToAnnotationGenerator, H as HtmlBlockStrategy, I as InsertNewParagraphAction, R as RTEImageBlock, a as InsertChildrenBeforeStrategy, P as PasteContentStrategy, A as AnnotationGeneratorStrategyAbstract, S as StylePreservator, b as RTEImageNode, C as COMMIT_VALUE } from './content-state-2f6f4204.js';
+import { i as isNonNullable } from './type-guard-26d83e7e.js';
+import { e as extensionContextManager, a as VegaRTEExtensionRenderer, b as VegaRTEExtension } from './link-extension-e89acb5c.js';
 import { V as VegaInternalIconManager } from './internal-icon-manager-e7c57096.js';
 import { v as vegaNonceManager } from './vega-nonce-manager-497e5eb5.js';
-import { D as DomNodeSubjectObserverFactory, d as domNodeSubjectFactory } from './dom-node-subject-observer-factory-ddff8662.js';
+import { D as DomNodeSubjectObserverFactory, d as domNodeSubjectFactory } from './dom-node-subject-observer-factory-bb7e68a0.js';
 import { V as VegaDropdownClick, a as VegaClick, b as VegaPopoverHide, c as VegaPopoverShow, d as VegaChange } from './vega-event-id-f55f6977.js';
-import { R as RTETableExtensionAnnotationTypeEnum, a as RTE_TABLE_HEAD_DEFAULT_BACKGROUND_COLOR, S as SettingEventHandler, T as TableSettingType, b as RTETableAnnotation, c as RTETableCellAnnotation, d as RTETableHeadCellBlock, e as RowOperationEventHandler, C as ColumnOperationEventHandler, M as MergeCellsOperationEventHandler, f as SplitCellOperationEventHandler, g as RTETableColorManager, h as RTETableBlock, i as generateTableBody, j as RTETableCellBlock, k as RTETableHeadBlock, l as RTETableBodyBlock, m as getParentBlockByType, n as RTETableHeadCellAnnotation, o as TableColumnStrategy, p as getAllTableRows, q as buildTableGrid, s as setSpanAttributes, r as findCellBlockById, t as getDefaultCellBlockTemplate, I as InsertTableColumnDirection, u as buildCellStartColumnMap, v as getTableColumnCount, w as getFirstNode, x as getCellSpan, y as createNewCell, z as MergeCellsOperationType, A as RTETableRowBlock, B as getActualColumnPosition, D as InsertTableRowDirection, E as RTE_TABLE_DEFAULT_COLORS, F as INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, G as INSERT_TABLE_ROW_INTO_SAME_SECTION, H as DELETE_TABLE_ROW, J as TOGGLE_HEADER_ROW, K as INSERT_TABLE_COLUMN, L as DELETE_TABLE_COLUMN, N as TOGGLE_HEADER_TABLE_COLUMN, O as ToggleHeaderTableColumnStrategy, P as SPLIT_TABLE_CELL, Q as REPLACE_TABLE_CELL, U as SPLIT_CELL_HORIZONTALLY, W as SPLIT_CELL_VERTICALLY, X as SELECT_TABLE_COLUMN, Y as MERGE_CELLS } from './split-cell-operation-1c8e7585.js';
+import { R as RTETableExtensionAnnotationTypeEnum, a as RTE_TABLE_HEAD_DEFAULT_BACKGROUND_COLOR, S as SettingEventHandler, T as TableSettingType, b as RTETableAnnotation, c as RTETableCellAnnotation, d as RTETableHeadCellBlock, e as RowOperationEventHandler, C as ColumnOperationEventHandler, M as MergeCellsOperationEventHandler, f as SplitCellOperationEventHandler, g as RTETableColorManager, h as RTETableBlock, i as generateTableBody, j as RTETableCellBlock, k as RTETableHeadBlock, l as RTETableBodyBlock, m as getParentBlockByType, n as RTETableHeadCellAnnotation, o as TableColumnStrategy, p as getAllTableRows, q as buildTableGrid, s as setSpanAttributes, r as findCellBlockById, t as getDefaultCellBlockTemplate, I as InsertTableColumnDirection, u as buildCellStartColumnMap, v as getTableColumnCount, w as getFirstNode, x as getCellSpan, y as createNewCell, z as MergeCellsOperationType, A as RTETableRowBlock, B as getActualColumnPosition, D as InsertTableRowDirection, E as RTE_TABLE_DEFAULT_COLORS, F as INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, G as INSERT_TABLE_ROW_INTO_SAME_SECTION, H as DELETE_TABLE_ROW, J as TOGGLE_HEADER_ROW, K as INSERT_TABLE_COLUMN, L as DELETE_TABLE_COLUMN, N as TOGGLE_HEADER_TABLE_COLUMN, O as ToggleHeaderTableColumnStrategy, P as SPLIT_TABLE_CELL, Q as REPLACE_TABLE_CELL, U as SPLIT_CELL_HORIZONTALLY, W as SPLIT_CELL_VERTICALLY, X as SELECT_TABLE_COLUMN, Y as MERGE_CELLS } from './split-cell-operation-cc0cdf90.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
 import { V as VegaInternalRTEExtensionTableCellsSelectionAnchor, a as VegaInternalPopoverUpdateTarget, b as VegaInternalRTEExtensionTableCellSelectionChange } from './vega-internal-event-id-86fce049.js';
 import { r as remoteInvocationRegistry } from './remote-invocation-registry-d69245c2.js';
-import { V as VegaInternalThemeManager, a as VegaDarkModeStyleController } from './dark-mode-style-controller-ca5afd2d.js';
+import { V as VegaInternalThemeManager, a as VegaDarkModeStyleController } from './dark-mode-style-controller-352f15ff.js';
 import { t as tryGetDocument } from './try-get-document-bef0f526.js';
 import { p as parseToPixelString } from './pixel-f32c07ce.js';
 import { c as cleanObject } from './object-0c277f57.js';
 import { d as debounce } from './timer-9321173b.js';
 import { c as camelToDashCase } from './string-a953eafc.js';
-import { R as ReplaceSelectedTextAction } from './image-extension-fbd1ed6e.js';
+import { R as ReplaceSelectedTextAction } from './image-extension-59484e9a.js';
 import { c as copy } from './copy-54e45e2d.js';
 
 const VegaLoaderRuntimeMetricsPayloadDefinition = [
@@ -1103,7 +1103,7 @@ class VegaRTEToolbarButtonRenderer {
    * @returns {Nullable<RTEExtensionContext>} - The extension context associated with the host.
    */
   getExtensionContext(el) {
-    return RTEExtensionContextManager.getExtensionContext(el);
+    return extensionContextManager.getExtensionContext(el);
   }
   /**
    * Renders a dropdown component with the specified properties and children.
@@ -1115,7 +1115,7 @@ class VegaRTEToolbarButtonRenderer {
    * @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, 
+    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;
@@ -1199,29 +1199,31 @@ class VegaRTEToolbarButtonRenderer {
    * @returns {VegaRTERenderResult} - The render result for the button.
    */
   renderButton(h, editorContext, buttonProps) {
-    const { icon, label, showArrowIcon, tooltip } = 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,
-      hidden: this.isHidden(editorContext),
-      selected: this.isSelected(editorContext),
+      '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) => {
+      'ref': (el) => {
         this.buttonEl = el;
         DomNodeSubjectObserverFactory.addUniqueObserverToNode(el, VegaClick, () => this.handleButtonClick(editorContext));
       },
-      onMouseDown: this.preventDefault,
+      'onMouseDown': this.preventDefault,
       // eslint-disable-next-line jsdoc/require-jsdoc
-      onKeyDown: (e) => this.handleButtonKeyDown(e),
+      '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' },
-          icon: VegaInternalIconManager.getIconKey('chevron-down'),
+          'size': 'size-8',
+          'color': isDisabled ? 'text-disabled' : 'text-secondary',
+          'style': { marginLeft: '8px' },
+          'aria-hidden': 'true',
+          'icon': VegaInternalIconManager.getIconKey('chevron-down'),
         })
         : null,
     ].filter(isNonNullable));
@@ -1242,8 +1244,9 @@ class VegaRTEToolbarButtonRenderer {
     if (label) {
       const isDisabled = this.isDisabled(editorContext);
       return h('vega-font', {
-        variant: 'font-field-label-sm',
-        color: isDisabled ? 'text-disabled' : 'text-primary',
+        'variant': 'font-field-label-sm',
+        'color': isDisabled ? 'text-disabled' : 'text-primary',
+        'aria-hidden': 'true',
       }, editorContext.translation.t(label));
     }
     return null;
@@ -1275,6 +1278,15 @@ class VegaRTEToolbarButtonRenderer {
   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.
    *
@@ -1328,14 +1340,14 @@ class VegaRTEToolbarButtonRenderer {
    * @param {KeyboardEvent} e The keyboard event.
    */
   handleItemsKeyDown(e) {
-    var _a, _b, _c;
+    var _a, _b;
     if (e.code === 'Escape') {
       e.preventDefault();
       e.stopPropagation();
       if (this.dropdownEl) {
         void this.dropdownEl.hide();
       }
-      (_a = this.buttonEl) === null || _a === void 0 ? void 0 : _a.focus();
+      this.focusToolbarButton();
       return;
     }
     if (e.code !== 'ArrowDown' && e.code !== 'ArrowUp') {
@@ -1353,7 +1365,7 @@ class VegaRTEToolbarButtonRenderer {
     for (let offset = 0; offset < items.length; offset++) {
       const index = (startIndex + offset * direction + items.length) % items.length;
       if (!items[index].disabled) {
-        (_c = (_b = items[index].shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('li')) === null || _c === void 0 ? void 0 : _c.focus();
+        (_b = (_a = items[index].shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('li')) === null || _b === void 0 ? void 0 : _b.focus();
         return;
       }
     }
@@ -1423,6 +1435,7 @@ class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return this.renderDropdown(createElement, editorContext, {}, [
       this.renderButton(createElement, editorContext, {
         label: 'Tokens',
+        ariaLabel: 'Tokens',
         showArrowIcon: true,
         tooltip: { text: 'Insert token' },
       }),
@@ -1542,6 +1555,47 @@ class RTETokenNode extends RTETextNode {
   toHtml() {
     return `<span class="token" contenteditable="false" template-token-key="${this.token}" token-key="${this.token}"${super.generateAttributeString()}>${this.text}</span>`;
   }
+  /**
+   * @inheritDoc
+   */
+  renderHtmlFromDepth(depth, options) {
+    const annotation = this.getInlineHtmlAnnotationAtDepth(depth);
+    if (!annotation)
+      return this.toHtml();
+    return this.renderTokenWithWrapperStr(annotation);
+  }
+  /**
+   * Render token markup wrapped by inline HTML annotations, preserving token attributes.
+   *
+   * @param {InlineHtmlAnnotation} inlineHtmlNode - Current wrapper annotation.
+   * @returns {string} Token HTML wrapped by inline HTML annotations.
+   */
+  renderTokenWithWrapperStr(inlineHtmlNode) {
+    const { htmlTag, child } = inlineHtmlNode;
+    const attrStr = this.inlineHtmlAnnotationAttrStr(inlineHtmlNode);
+    if (!child) {
+      if (HTML_VOID_TAGS.has(htmlTag)) {
+        return `<${htmlTag}${attrStr}>`;
+      }
+      return `<${htmlTag}${attrStr}>${this.toHtml()}</${htmlTag}>`;
+    }
+    return `<${htmlTag}${attrStr}>${this.renderTokenWithWrapperStr(child)}</${htmlTag}>`;
+  }
+  /**
+   * Build inline HTML wrapper attributes string.
+   *
+   * @param {InlineHtmlAnnotation} annotation - Inline HTML annotation.
+   * @returns {string} Serialized attribute string.
+   */
+  inlineHtmlAnnotationAttrStr(annotation) {
+    const { customAttribute, customClass, customStyle } = annotation;
+    const attrs = [
+      ...((customAttribute === null || customAttribute === void 0 ? void 0 : customAttribute.toString()) || []),
+      customClass === null || customClass === void 0 ? void 0 : customClass.toString(),
+      customStyle === null || customStyle === void 0 ? void 0 : customStyle.toString(),
+    ].filter(isNonNullable);
+    return attrs.length > 0 ? ` ${attrs.join(' ')}` : '';
+  }
 }
 RTETokenNode.dtoName = 'RTETokenNode';
 
@@ -1665,6 +1719,7 @@ class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return this.renderDropdown(createElement, editorContext, { source: translatedSource }, [
       this.renderButton(createElement, editorContext, {
         label: this.getLanguageLabelByKey(this.selectedLanguage),
+        ariaLabel: 'Language',
         showArrowIcon: true,
         tooltip: { text: 'Select language' },
       }),
@@ -1680,10 +1735,11 @@ class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     this.translation = editorContext.translation;
     const isDisabled = this.isDisabled(editorContext);
     return h('vega-font', {
-      variant: 'font-field-label-sm',
-      color: isDisabled ? 'text-disabled' : 'text-primary',
+      'variant': 'font-field-label-sm',
+      'color': isDisabled ? 'text-disabled' : 'text-primary',
+      'aria-hidden': 'true',
       // eslint-disable-next-line jsdoc/require-jsdoc
-      ref: (el) => {
+      'ref': (el) => {
         this.labelRef = el;
       },
     }, editorContext.translation.t(label));
@@ -1853,6 +1909,7 @@ class VegaRTELanguageExtension extends VegaRTEExtension {
           options = {
             autoMatchFormat: (_a = host.sourceEditConfig.autoMatchFormat) !== null && _a !== void 0 ? _a : true,
             filterInlineStyles: host.sourceEditConfig.filterInlineStyles,
+            blockBoundaryRegistry: this.extensionContext.blockBoundaryRegistry,
           };
         }
         result = VegaRTEContent.fromHtml(codeBlock.value.code, options);
@@ -1878,6 +1935,15 @@ class InsertFunctionBlockAction extends ModifyContentAction {
   }
 }
 
+const FUNCTION_BLOCK_CLASS = 'statement';
+const FUNCTION_CONTENT_CLASS = 'statementelement';
+const FUNCTION_SYNTAX_CLASS = 'statementsyntax';
+const FUNCTION_ELEMENT_CLASSES = [
+  FUNCTION_BLOCK_CLASS,
+  FUNCTION_CONTENT_CLASS,
+  FUNCTION_SYNTAX_CLASS,
+];
+
 /**
  * RTE Function Block
  */
@@ -1897,7 +1963,7 @@ class RTEFunctionBlock extends RTEBlock {
    */
   static from(block, options) {
     const functionBlock = new RTEFunctionBlock(block.id);
-    const defaultAnnotation = { customClass: ['statement'] };
+    const defaultAnnotation = { customClass: [FUNCTION_BLOCK_CLASS] };
     let { annotations } = block;
     annotations = annotations
       ? Object.assign(Object.assign({}, annotations), defaultAnnotation) : defaultAnnotation;
@@ -1915,14 +1981,14 @@ class RTEFunctionBlock extends RTEBlock {
       .map((child) => {
       if (child instanceof RTETextBlock) {
         const attrStr = this.getFunctionContentStyle(child);
-        return `<div class="statementelement"${attrStr}>${child.getChildrenHtml()}</div>`;
+        return `<div class="${FUNCTION_CONTENT_CLASS}"${attrStr}>${child.getChildrenHtml()}</div>`;
       }
       else {
         return child.toHtml();
       }
     })
       .join('');
-    return `<div class="statement">${childrenHtml}</div>`;
+    return `<div class="${FUNCTION_BLOCK_CLASS}" ${RTE_BLOCK_BOUNDARY_ATTRIBUTE}>${childrenHtml}</div>`;
   }
   /**
    * @inheritDoc
@@ -1943,6 +2009,15 @@ class RTEFunctionBlock extends RTEBlock {
   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
    */
@@ -2016,7 +2091,7 @@ class InsertFunctionBlockStrategy extends ActionHandleStrategy {
         {
           id: `${id}-2`,
           annotations: {
-            customClass: ['statementelement'],
+            customClass: [FUNCTION_CONTENT_CLASS],
           },
           type: 'paragraph',
           nodes: [
@@ -2035,7 +2110,7 @@ class InsertFunctionBlockStrategy extends ActionHandleStrategy {
         {
           id: `${id}-4`,
           annotations: {
-            customClass: ['statementelement'],
+            customClass: [FUNCTION_CONTENT_CLASS],
           },
           type: 'paragraph',
           nodes: [
@@ -2135,6 +2210,12 @@ class RTELogicControlNode extends RTENode {
   isContentEditable() {
     return false;
   }
+  /**
+   * @inheritDoc
+   */
+  getPlainText() {
+    return this.text;
+  }
 }
 RTELogicControlNode.dtoName = 'RTELogicControlNode';
 
@@ -2186,7 +2267,7 @@ class RTELogicControlBlock extends RTEBlock {
    * @returns {string} - The HTML string of the logic control block.
    */
   toHtml() {
-    return `<div class='statementsyntax' contenteditable='false'>${this.statementText}</div>`;
+    return `<div class='${FUNCTION_SYNTAX_CLASS}' contenteditable='false'>${this.statementText}</div>`;
   }
   /**
    * Clone the current block instance.
@@ -2223,6 +2304,7 @@ class FunctionToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return this.renderDropdown(h, editorContext, {}, [
       this.renderButton(h, editorContext, {
         label: 'Functions',
+        ariaLabel: 'Functions',
         showArrowIcon: true,
         tooltip: { text: 'Insert function' },
       }),
@@ -2294,7 +2376,7 @@ class RTELogicControlBlockRenderer extends VegaRTEExtensionRenderer {
   doRender(h, renderData) {
     return h('div', {
       key: renderData.id,
-      class: 'statementsyntax',
+      class: FUNCTION_SYNTAX_CLASS,
       ref: this.useRef(renderData),
     }, h('span', {
       key: `${renderData.id}-1`,
@@ -2304,13 +2386,48 @@ class RTELogicControlBlockRenderer extends VegaRTEExtensionRenderer {
   }
 }
 
+/**
+ * Returns true when the element belongs to function extension blocks by semantic
+ * boundary attribute or known function element classes.
+ *
+ * Use this helper for broad detection (e.g., extension-level boundary predicate
+ * registration) where both container and child function elements should be
+ * treated as part of the function block structure.
+ *
+ * @param {HTMLElement} element - Element to inspect.
+ * @returns {boolean} Whether the element belongs to a function block structure.
+ * @example
+ * this.registerBlockBoundaryPredicate(isFunctionBlockElement);
+ */
+const isFunctionBlockElement = (element) => {
+  return (element.hasAttribute(RTE_BLOCK_BOUNDARY_ATTRIBUTE) ||
+    FUNCTION_ELEMENT_CLASSES.some((functionClass) => element.classList.contains(functionClass)));
+};
+/**
+ * Returns true when the element is a function block boundary container.
+ *
+ * Use this helper when conversion logic must identify only the function block
+ * container element (the DIV that maps to RTEFunctionBlock), not function child
+ * elements such as syntax/content nodes.
+ *
+ * @param {HTMLElement} element - Element to inspect.
+ * @returns {boolean} Whether the element is a function block boundary container.
+ * @example
+ * if (isFunctionBoundaryContainer(element)) {
+ *     // map the DIV to RTEFunctionBlock
+ * }
+ */
+const isFunctionBoundaryContainer = (element) => {
+  return (element.hasAttribute(RTE_BLOCK_BOUNDARY_ATTRIBUTE) || element.classList.contains(FUNCTION_BLOCK_CLASS));
+};
+
 /**
  * Strategy to convert a div with class 'statementsyntax' into an RTELogicControlBlock DTO.
  */
 class DivToLogicControlBlockStrategy extends BlockToRTEBlockStrategyAbstract {
   constructor() {
     super(...arguments);
-    this.blockClassName = 'statementsyntax';
+    this.blockClassName = FUNCTION_SYNTAX_CLASS;
   }
   /**
    * @inheritDoc
@@ -2353,7 +2470,7 @@ class DivToLogicControlBlockStrategy extends BlockToRTEBlockStrategyAbstract {
    * @returns {boolean} True if the element is a child of a function block, false otherwise
    */
   isFunctionBlockChild(element) {
-    return !!(element.parentElement && element.parentElement.classList.contains('statement'));
+    return !!(element.parentElement && isFunctionBoundaryContainer(element.parentElement));
   }
 }
 
@@ -2366,11 +2483,13 @@ class DivToFunctionBlockStrategy extends ElementToDTOStrategy {
    */
   canHandle(elementsArray, currentIndex) {
     const element = elementsArray[currentIndex];
-    return element &&
-      element.tagName === 'DIV' &&
-      element.classList.contains('statement') &&
+    if (element.nodeType !== Node.ELEMENT_NODE)
+      return 0;
+    const isFunctionBoundary = isFunctionBoundaryContainer(element);
+    return element.tagName === 'DIV' &&
+      isFunctionBoundary &&
       element.childNodes.length &&
-      element.querySelector('.statementsyntax')
+      element.querySelector(`.${FUNCTION_SYNTAX_CLASS}`)
       ? 1
       : 0;
   }
@@ -2382,7 +2501,7 @@ class DivToFunctionBlockStrategy extends ElementToDTOStrategy {
       id: generateUUID(),
       type: 'function-block',
       annotations: {
-        customClass: ['statement'],
+        customClass: [FUNCTION_BLOCK_CLASS],
       },
       children: [],
     });
@@ -2410,7 +2529,7 @@ class DivToFunctionBlockStrategy extends ElementToDTOStrategy {
 class DivToFunctionContentStrategy extends DivToLogicControlBlockStrategy {
   constructor() {
     super(...arguments);
-    this.blockClassName = 'statementelement';
+    this.blockClassName = FUNCTION_CONTENT_CLASS;
   }
   /**
    * @inheritDoc
@@ -2418,16 +2537,31 @@ class DivToFunctionContentStrategy extends DivToLogicControlBlockStrategy {
   handle(elementsArray, options) {
     const element = elementsArray[0];
     const annotations = htmlElementToAnnotationGenerator.generate(RTETextBlock, element);
-    const nodes = Array.from(elementsArray[0].childNodes);
     return RTETextBlock.from({
       id: generateUUID(),
       type: 'paragraph',
       annotations: Object.assign({ customClass: [this.blockClassName] }, annotations),
-      nodes: this.generateChildNodes(nodes, undefined, options),
+      nodes: this.generateChildNodes(Array.from(elementsArray[0].childNodes), undefined, options),
     });
   }
 }
 
+/** Preserve a div that contains a function block during auto-formatting. */
+class FunctionBlockContainerStrategy extends HtmlBlockStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray, currentIndex) {
+    const element = elementsArray[currentIndex];
+    if (element.nodeType !== Node.ELEMENT_NODE)
+      return 0;
+    const containsFunctionBlock = !!element.querySelector(`[${RTE_BLOCK_BOUNDARY_ATTRIBUTE}], .${FUNCTION_BLOCK_CLASS}`);
+    return element.nodeName === 'DIV' && !isFunctionBlockElement(element) && containsFunctionBlock
+      ? 1
+      : 0;
+  }
+}
+
 const functionBlockStylesCss = "div.statement{padding:2px 4px;background:rgba(var(--v-bg-accent3-secondary, 255, 239, 200));border:1px solid rgba(var(--v-bg-accent3-primary, 255, 220, 131));border-radius:4px;display:flex;flex-direction:row;justify-content:flex-start;align-items:stretch;gap:4px}div.statement .statementsyntax{padding:3px 0;line-height:22px}.rich-text-content div.statement .statementsyntax,.rich-text-content div.statement .statementelement{display:inline-block}div.statement+div.statement{margin-top:2px}div.statement .statementsyntax span{color:rgb(38, 42, 255);font-weight:bold}div.statement .statementelement{padding:2px 4px;background:rgba(var(--v-bg-secondary, 245, 247, 247));border:1px solid rgba(var(--v-border-color-input-field, 171, 198, 216));border-radius:4px;margin:0;min-width:8px}";
 
 /**
@@ -2441,6 +2575,7 @@ class RTEFunctionBlockRenderer extends VegaRTEExtensionRenderer {
     return createElement('div', {
       key: renderData.id,
       class: this.getElementClassName(renderData),
+      [RTE_BLOCK_BOUNDARY_ATTRIBUTE]: '',
       ref: this.useRef(renderData),
     });
   }
@@ -2460,8 +2595,8 @@ class RTEFunctionBlockRenderer extends VegaRTEExtensionRenderer {
    */
   getElementClassName(block) {
     let classes = block.getClasses();
-    if (classes.indexOf('statement') < 0) {
-      classes = 'statement ' + classes;
+    if (classes.indexOf(FUNCTION_BLOCK_CLASS) < 0) {
+      classes = FUNCTION_BLOCK_CLASS + ' ' + classes;
     }
     return classes.trim();
   }
@@ -2635,12 +2770,14 @@ class PastePlainTextStrategy extends ActionHandleStrategy {
 const convertLogicControlBlockStrategy = new DivToLogicControlBlockStrategy();
 const convertFunctionContentStrategy = new DivToFunctionContentStrategy();
 const convertFunctionBlockStrategy = new DivToFunctionBlockStrategy();
+const convertFunctionBlockContainerStrategy = new FunctionBlockContainerStrategy();
 /**
  * Function extension class for Vega Rich Text Editor.
  */
 class VegaRTEFunctionExtension extends VegaRTEExtension {
   constructor() {
     super();
+    this.unregisterBlockBoundaryPredicate = null;
     this.registerBlockBasicStrategies(RTELogicControlBlock.name);
     this.registerBlockBasicStrategies(RTEFunctionBlock.name);
     this.preventFunctionBlockDefaultInsertNewParagraph();
@@ -2651,11 +2788,25 @@ class VegaRTEFunctionExtension extends VegaRTEExtension {
     this.registerElementToBlockDTOClassStrategy(convertLogicControlBlockStrategy);
     this.registerElementToBlockDTOClassStrategy(convertFunctionContentStrategy);
     this.registerElementToBlockDTOClassStrategy(convertFunctionBlockStrategy);
+    this.registerElementToBlockDTOClassStrategy(convertFunctionBlockContainerStrategy);
   }
   /** @inheritDoc */
   prepareBeforeLoad(host) {
     this.registerToolbarButtonRenderer(VegaRTEFunctionExtension.TOOLBAR_BUTTON_KEY, new FunctionToolbarButtonRenderer(), host);
   }
+  /** @inheritDoc */
+  initialExtensionAfterLoad(context) {
+    var _a;
+    super.initialExtensionAfterLoad(context);
+    (_a = this.unregisterBlockBoundaryPredicate) === null || _a === void 0 ? void 0 : _a.call(this);
+    this.unregisterBlockBoundaryPredicate = this.registerBlockBoundaryPredicate(isFunctionBlockElement);
+  }
+  /** @inheritDoc */
+  destroyExtension() {
+    var _a;
+    (_a = this.unregisterBlockBoundaryPredicate) === null || _a === void 0 ? void 0 : _a.call(this);
+    this.unregisterBlockBoundaryPredicate = null;
+  }
   /**
    * Remove the appen children strategies to prevent default insert new paragraph logic in function block
    */
@@ -2680,7 +2831,7 @@ class VegaRTEFunctionExtension extends VegaRTEExtension {
 })();
 VegaRTEFunctionExtension.TOOLBAR_BUTTON_KEY = 'functions';
 
-const tableBlockStylesCss = ".v-rte--extension-table-container{display:table}table.v-rte--extension-table{border-collapse:collapse}table.v-rte--extension-table th,table.v-rte--extension-table td{border:1px solid #ddd;padding:12px;text-align:left;vertical-align:middle;min-width:55px;box-sizing:border-box;position:relative}table.v-rte--extension-table th{background-color:#f2f2f2}.rte-table-setting-popover,.rte-table-dynamic-popover{display:block}table.v-rte--extension-table .v-rte-table-cell-focused::after,table.v-rte--extension-table .v-rte-table-cell-selected::after{content:'';position:absolute;top:0;left:0;right:0;bottom:0;pointer-events:none;background-color:rgba(158, 207, 250, 0.3)}table.v-rte--extension-table:has(.v-rte-table-cell-selected){caret-color:transparent}table.v-rte--extension-table:has(.v-rte-table-cell-selected) ::selection{background-color:transparent}table.v-rte--extension-table:has(.v-rte-table-cell-selected) ::-moz-selection{background-color:transparent}.v-rte--extension-table-caption{padding:8px;border:1px solid #ddd;border-bottom:none;background-color:rgba(var(--v-bg-table-header, 240, 243, 247, 1));position:relative;display:table-caption;caption-side:top;min-height:22px;text-align:center;word-break:break-word;overflow-wrap:break-word}.v-rte--extension-table-caption.showPlaceholder::before{position:absolute;left:0;right:0;content:attr(data-placeholder);font-family:'Inter', sans-serif;font-size:16px;font-weight:400;line-height:24px;letter-spacing:0;color:rgba(var(--v-text-input-placeholder, 176, 180, 181, 1));text-align:center;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}";
+const tableBlockStylesCss = ".v-rte--extension-table-container{display:table}table.v-rte--extension-table{border-collapse:collapse}table.v-rte--extension-table th,table.v-rte--extension-table td{border:1px solid #ddd;padding:12px;text-align:left;vertical-align:middle;min-width:55px;box-sizing:border-box;position:relative}table.v-rte--extension-table th:focus,table.v-rte--extension-table td:focus{outline:none}table.v-rte--extension-table th{background-color:#f2f2f2}.rte-table-setting-popover,.rte-table-dynamic-popover{display:block}table.v-rte--extension-table .v-rte-table-cell-focused::after,table.v-rte--extension-table .v-rte-table-cell-selected::after{content:'';position:absolute;top:0;left:0;right:0;bottom:0;pointer-events:none;background-color:rgba(158, 207, 250, 0.3)}table.v-rte--extension-table:has(.v-rte-table-cell-selected){caret-color:transparent}table.v-rte--extension-table:has(.v-rte-table-cell-selected) ::selection{background-color:transparent}table.v-rte--extension-table:has(.v-rte-table-cell-selected) ::-moz-selection{background-color:transparent}.v-rte--extension-table-caption{padding:8px;border:1px solid #ddd;border-bottom:none;background-color:rgba(var(--v-bg-table-header, 240, 243, 247, 1));position:relative;display:table-caption;caption-side:top;min-height:22px;text-align:center;word-break:break-word;overflow-wrap:break-word}.v-rte--extension-table-caption.showPlaceholder::before{position:absolute;left:0;right:0;content:attr(data-placeholder);font-family:'Inter', sans-serif;font-size:16px;font-weight:400;line-height:24px;letter-spacing:0;color:rgba(var(--v-text-input-placeholder, 176, 180, 181, 1));text-align:center;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}";
 
 const DELETE_TABLE_BLOCK = 'DELETE_TABLE_BLOCK';
 /**
@@ -3298,9 +3449,42 @@ class CellPropertiesCancelEventHandler extends CellPropertiesEventHandler {
 
 /**
  * Base renderer for table-related popovers, providing common functionalities such as accessing the table extension context.
+ *
+ * Popovers that move keyboard/VoiceOver focus into themselves (the setting toolbar and the
+ * properties dialog) share the same focus-restoration machinery: they make the editor content
+ * `inert` while open, track Escape presses at the document level, and return focus (and the caret)
+ * to the originating cell when an Escape dismisses the popover. That behavior lives here so the two
+ * renderers do not each carry a copy; subclasses only supply the two pieces that differ — how to
+ * resolve the editor content root ({@link getInertContentTarget}) and how to tell whether an event
+ * originated inside their own popover subtree ({@link isEventWithinPopover}).
  */
 class TablePopoverBaseRenderer {
   constructor(renderContext) {
+    /** The editor content element made inert while the popover holds focus, cached so it can be restored. */
+    this.inertedContentEl = null;
+    /** The table cell to return focus to when the popover is dismissed via Escape. */
+    this.returnFocusCell = null;
+    /** Tracks whether Escape was pressed while the popover was open. */
+    this.escapePressed = false;
+    /** Document the Escape tracker keydown listener is bound to, for later removal. */
+    this.keydownListenerDocument = null;
+    /**
+     * Tracks Escape key presses that originate inside the popover so focus can be returned to the
+     * originating cell when that Escape dismisses the popover. vega-popover's own Escape handler hides
+     * the popover without restoring focus, so the restore is coordinated here.
+     *
+     * The listener is bound at the document level (the popover renders in a portal, so its Escape does
+     * not bubble back to the table), so scope it to the popover subtree via {@link isEventWithinPopover}:
+     * a stray Escape elsewhere must not arm the restore and hijack focus on a later non-Escape dismissal
+     * (e.g. click-outside).
+     *
+     * @param {KeyboardEvent} event - The keydown event.
+     */
+    this.handleDocumentKeydown = (event) => {
+      if (event.code === 'Escape' && this.isEventWithinPopover(event)) {
+        this.escapePressed = true;
+      }
+    };
     this.renderContext = renderContext;
   }
   /**
@@ -3310,9 +3494,124 @@ class TablePopoverBaseRenderer {
    */
   getTableExtensionContext() {
     return this.renderContext
-      ? RTEExtensionContextManager.getExtensionContext(this.renderContext.host)
+      ? extensionContextManager.getExtensionContext(this.renderContext.host)
       : null;
   }
+  /**
+   * Begins tracking so a later Escape can return focus to `returnCell`. Records the cell and clears
+   * any stale Escape observed before the popover was opened.
+   *
+   * @param {Nullable<HTMLElement>} returnCell - The cell to return focus to if the popover is dismissed with Escape.
+   */
+  beginReturnFocusTracking(returnCell) {
+    this.returnFocusCell = returnCell !== null && returnCell !== void 0 ? returnCell : null;
+    this.escapePressed = false;
+  }
+  /**
+   * Registers the document-level (capture phase) Escape tracker. The popover renders in a portal, so
+   * its Escape does not bubble back to the table; observing on the document lets us know when to
+   * return focus to the cell.
+   *
+   * @param {Document} doc - The document to bind the keydown listener to.
+   */
+  attachEscapeTracker(doc) {
+    doc.addEventListener('keydown', this.handleDocumentKeydown, { capture: true });
+    this.keydownListenerDocument = doc;
+  }
+  /**
+   * Removes the document-level Escape tracker if one was registered.
+   */
+  detachEscapeTracker() {
+    if (this.keydownListenerDocument) {
+      this.keydownListenerDocument.removeEventListener('keydown', this.handleDocumentKeydown, {
+        capture: true,
+      });
+      this.keydownListenerDocument = null;
+    }
+  }
+  /**
+   * Whether the given event originated inside this popover's subtree. Subclasses override this to
+   * match their own portal-rendered content; the base returns `false` so renderers that do not move
+   * focus never arm the restore.
+   *
+   * @param {Event} _event - The event to test.
+   * @returns {boolean} `true` when the event originated inside the popover subtree.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  isEventWithinPopover(_event) {
+    return false;
+  }
+  /**
+   * When the popover hides after an Escape press, returns focus (and the caret) to the table cell
+   * that had focus before the popover was opened.
+   *
+   * vegaPopoverHide fires synchronously from the popover's own Escape handler, before the
+   * document-capture keydown observes the key and before the popover settles focus on `<body>`.
+   * Defer past that so the flag is set and this focus restore wins.
+   */
+  restoreFocusOnEscapeHide() {
+    // eslint-disable-next-line no-restricted-globals
+    setTimeout(() => {
+      const shouldRestore = this.escapePressed;
+      const cell = this.returnFocusCell;
+      this.escapePressed = false;
+      this.returnFocusCell = null;
+      if (shouldRestore && cell && cell.isConnected) {
+        this.restoreFocusToCell(cell);
+      }
+    }, 0);
+  }
+  /**
+   * Focuses the given table cell and collapses the caret at its start.
+   *
+   * @param {HTMLElement} cell - The table cell to focus.
+   */
+  restoreFocusToCell(cell) {
+    var _a, _b, _c;
+    cell.focus();
+    const extensionContext = this.getTableExtensionContext();
+    const selection = (_c = (_a = extensionContext === null || extensionContext === void 0 ? void 0 : extensionContext.getSelection()) !== null && _a !== void 0 ? _a : (_b = cell.ownerDocument) === null || _b === void 0 ? void 0 : _b.getSelection()) !== null && _c !== void 0 ? _c : null;
+    if (selection) {
+      const range = new Range();
+      range.setStart(cell, 0);
+      range.setEnd(cell, 0);
+      selection.removeAllRanges();
+      selection.addRange(range);
+    }
+  }
+  /**
+   * Resolves the `.rich-text-content` editor root to toggle `inert` on while the popover holds focus.
+   * Subclasses override this because they reach the content from different anchors (the toolbar's
+   * target vs. the current table ref); the base returns `null` so renderers that do not use inert are
+   * unaffected.
+   *
+   * @returns {Nullable<HTMLElement>} The editor content element, or `null` when it cannot be resolved.
+   */
+  getInertContentTarget() {
+    return null;
+  }
+  /**
+   * Toggles `inert` on the editor content region while the popover holds keyboard/VoiceOver focus.
+   * Safari VoiceOver keeps its reading cursor anchored to the cell caret and does not follow the
+   * programmatic focus moved into the popover; making the editor content inert removes that text
+   * context so the VoiceOver cursor lands inside the popover. The popover is a body-level portal, so it
+   * is not a descendant of the inert content and stays interactive.
+   *
+   * @param {boolean} inert - Whether the editor content should be inert.
+   */
+  setEditorContentInert(inert) {
+    if (inert) {
+      const content = this.getInertContentTarget();
+      if (content) {
+        content.setAttribute('inert', '');
+        this.inertedContentEl = content;
+      }
+    }
+    else if (this.inertedContentEl) {
+      this.inertedContentEl.removeAttribute('inert');
+      this.inertedContentEl = null;
+    }
+  }
 }
 
 /**
@@ -3382,6 +3681,8 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
    * and clears the internal reference.
    */
   destroy() {
+    this.setEditorContentInert(false);
+    this.detachEscapeTracker();
     if (this.selectionAnchorRef && this.selectionAnchorRef.parentNode) {
       DomNodeSubjectObserverFactory.removeUniqueObserverFromNode(this.selectionAnchorRef, VegaInternalRTEExtensionTableCellsSelectionAnchor);
       this.selectionAnchorRef.parentNode.removeChild(this.selectionAnchorRef);
@@ -3394,8 +3695,13 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
    *
    * @param {string} type - The table setting type determining which
    *  content variant to display (for example, table properties or cell properties).
+   * @param {Nullable<HTMLElement>} returnCell - The cell to move focus into the dialog for and
+   *  return focus to if the dialog is dismissed with Escape (set for keyboard/screen-reader users).
    */
-  async show(type) {
+  async show(type, returnCell) {
+    // Remember the cell to return focus to if the dialog is dismissed with Escape, and clear any
+    // stale Escape recorded before the dialog was opened.
+    this.beginReturnFocusTracking(returnCell);
     let target = this.getTableRef();
     const extensionContext = this.getTableExtensionContext();
     let cells = [];
@@ -3415,6 +3721,11 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
     this.storeCurrentFocusNode();
     remoteInvocationRegistry.call(domNodeSubjectFactory.getSubject(this.popoverRef, VegaInternalPopoverUpdateTarget), target);
     await this.popoverRef.show();
+    // When opened for keyboard/screen-reader users (a return cell is known), move focus into the
+    // dialog so it lands on the first focusable field (the Border Style control).
+    if (returnCell) {
+      this.focusFirstFormField(type);
+    }
   }
   /**
    * hide the popover.
@@ -3449,7 +3760,11 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
         if (this.popoverCloseType === 'change' && extensionContext) {
           extensionContext.flushValue(extensionContext.host.value);
         }
+        this.handleDialogHide();
       });
+      // Escape inside the dialog (rendered in a portal) does not bubble back to the table, so
+      // observe it on the document (capture phase) to know when to return focus to the cell.
+      this.attachEscapeTracker(safeDocument);
       const slotDiv = safeDocument.createElement('div');
       slotDiv.setAttribute('slot', 'popover');
       slotDiv.className = 'rte-table-dynamic-popover-content';
@@ -3476,6 +3791,28 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
       return popover;
     }
   }
+  /**
+   * Whether the given event originated inside the properties dialog subtree (either the table or the
+   * cell properties form).
+   *
+   * @param {Event} event - The event to test.
+   * @returns {boolean} `true` when an active form is rendered and the event's composed path includes it.
+   */
+  isEventWithinPopover(event) {
+    const path = event.composedPath();
+    return ((!!this.tablePropertiesFormRef && path.includes(this.tablePropertiesFormRef)) ||
+      (!!this.cellPropertiesFormRef && path.includes(this.cellPropertiesFormRef)));
+  }
+  /**
+   * Resolves the `.rich-text-content` editor root from the current table ref so the content can be
+   * made inert while the properties dialog holds keyboard/VoiceOver focus.
+   *
+   * @returns {Nullable<HTMLElement>} The editor content element, or `null` when it cannot be resolved.
+   */
+  getInertContentTarget() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.getTableRef) === null || _a === void 0 ? void 0 : _a.call(this)) === null || _b === void 0 ? void 0 : _b.closest('.rich-text-content')) !== null && _c !== void 0 ? _c : null;
+  }
   /**
    * Updates the visibility of the pre-rendered content blocks based on type.
    *
@@ -3513,6 +3850,48 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
     const extensionContext = this.getTableExtensionContext();
     extensionContext && (this.currentFocusNode = extensionContext.getSelectedNodes()[0]);
   }
+  /**
+   * Moves focus to the first focusable control in the active properties form so keyboard and
+   * screen-reader users land inside the dialog when it opens. The first form field is the Border
+   * Style select; its focusable trigger is the `.vega-input-select-container` element.
+   *
+   * @param {string} type - The table setting type that determines which form is visible.
+   */
+  focusFirstFormField(type) {
+    const formRef = type === TableSettingType.TABLE ? this.tablePropertiesFormRef : this.cellPropertiesFormRef;
+    if (!formRef) {
+      return;
+    }
+    // Make the editor content inert up front so the table/cell cannot steal focus while the dialog
+    // lays out. The cell form applies the selected cell's styles on open, whose async reset fires a
+    // selectionchange that would otherwise re-focus the cell before we reach Border Style. Inert also
+    // gives VoiceOver no cell-caret text context, so its cursor follows the focus. Lifted on hide.
+    this.setEditorContentInert(true);
+    // The CELL form applies the selected cell's styles on open (it sets both `styleMap` and
+    // `defaultValue`), a heavier re-render than TABLE, so on the first open its Border Style control is
+    // present but 0×0 for a frame. WebKit's VoiceOver cursor does not follow `.focus()` onto a
+    // zero-area element, so defer through a double animation frame: the first schedules past the
+    // popover's async reveal, the second runs after the browser has committed the layout pass that
+    // sizes the control.
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        var _a, _b, _c, _d, _e;
+        const firstField = (_b = (_a = formRef.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('[data-vega-form]')) !== null && _b !== void 0 ? _b : null;
+        const container = (_d = (_c = firstField === null || firstField === void 0 ? void 0 : firstField.shadowRoot) === null || _c === void 0 ? void 0 : _c.querySelector('.vega-input-select-container')) !== null && _d !== void 0 ? _d : null;
+        (_e = (container !== null && container !== void 0 ? container : firstField)) === null || _e === void 0 ? void 0 : _e.focus();
+      });
+    });
+  }
+  /**
+   * When the properties dialog hides after an Escape press, returns focus (and the caret) to the
+   * table cell that had focus before the dialog was opened via the setting toolbar.
+   */
+  handleDialogHide() {
+    // Lift the inert guard on the editor content synchronously, before any focus restore runs, so the
+    // cell can receive focus and the editor is interactive again.
+    this.setEditorContentInert(false);
+    this.restoreFocusOnEscapeHide();
+  }
   /**
    * Create and position an invisible anchor element whose position and size are identical to the geometry of the current multi-cell selection.
    * This anchor element will then be used as the target of the popup, so that the popup appears near the entire selection area.
@@ -3607,6 +3986,62 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
         this.tableSettingRef.selectedCells = this.getTableSelectedCells();
       }
     };
+    /**
+     * Hides the table setting toolbar and its dynamic popover. Used when focus leaves the table (e.g.
+     * Escape moves focus from a cell back onto the table) so the contextual toolbar does not linger.
+     */
+    this.hide = () => {
+      var _a;
+      void this.tableDynamicPopover.hide();
+      void ((_a = this.popoverRef) === null || _a === void 0 ? void 0 : _a.hide());
+    };
+    /**
+     * Opens the table setting toolbar for keyboard/screen-reader users and moves focus to its first
+     * enabled button. Used by the Alt+F10 shortcut so the toolbar can be reached from inside a cell
+     * even when it is currently closed: it re-targets and shows the popover (the same path as a table
+     * click) before deferring focus to the first enabled button.
+     *
+     * @param {RTETableBlock} tableBlock - The table's block data.
+     * @param {() => HTMLElement} getTableRef - Getter for the table's DOM element.
+     * @param {Nullable<HTMLElement>} returnCell - The cell to return focus to if the toolbar is dismissed with Escape.
+     */
+    this.openSettingToolbarForKeyboard = (tableBlock, getTableRef, returnCell) => {
+      // Re-target and show the popover through the same path as a table click so the toolbar is
+      // actually visible before focus lands on it — otherwise focus would be pushed onto a hidden
+      // or stale toolbar that isn't shown.
+      this.reTarget(tableBlock, getTableRef);
+      void this.tableDynamicPopover.hide();
+      remoteInvocationRegistry.call(domNodeSubjectFactory.getSubject(this.popoverRef, VegaInternalPopoverUpdateTarget), getTableRef());
+      void this.popoverRef.show(true);
+      this.focusFirstSettingButton(returnCell);
+    };
+    /**
+     * Moves focus to the first enabled button in the table setting toolbar. Used by the Alt+F10
+     * shortcut so keyboard and screen-reader users can reach the toolbar from inside the table.
+     *
+     * @param {Nullable<HTMLElement>} returnCell - The cell to return focus to if the toolbar is dismissed with Escape.
+     */
+    this.focusFirstSettingButton = (returnCell) => {
+      var _a, _b;
+      // Remember the cell to return focus to if the toolbar is dismissed with Escape, and clear any
+      // stale Escape recorded before the toolbar was focused.
+      this.beginReturnFocusTracking(returnCell);
+      // Safari VoiceOver ignores the toolbar's aria-modal and keeps driving a caret through the still
+      // editable content, so on Ctrl+Opt+Right it walks the DOM caret out of the table into the editor
+      // instead of staying on the toolbar. Clear the caret AND make the editor content inert so there is
+      // no text context for VoiceOver to advance; the inert flag is lifted again when the toolbar hides.
+      (_b = (_a = this.getTableExtensionContext()) === null || _a === void 0 ? void 0 : _a.getSelection()) === null || _b === void 0 ? void 0 : _b.removeAllRanges();
+      this.setEditorContentInert(true);
+      // The popover reveals its content asynchronously, so defer to the next tick to make sure
+      // the setting buttons are present and focusable.
+      // eslint-disable-next-line no-restricted-globals
+      setTimeout(() => {
+        var _a, _b, _c;
+        const buttons = Array.from((_c = (_b = (_a = this.tableSettingRef) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelectorAll('.rte-table-setting-item')) !== null && _c !== void 0 ? _c : []);
+        const firstEnabled = buttons.find((button) => !button.hasAttribute('disabled'));
+        firstEnabled === null || firstEnabled === void 0 ? void 0 : firstEnabled.focus();
+      }, 0);
+    };
     /**
      * Handles setting menu click events.
      *
@@ -3619,11 +4054,16 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
         extensionContext && handler.execute(event.detail, extensionContext, this.tableBlock);
         if (event.detail[0] === TableSettingType.CAPTION) {
           this.updateTableSettingCaption();
+          this.moveFocusToCaption();
         }
       }
       if (event.detail[0] === TableSettingType.TABLE || event.detail[0] === TableSettingType.CELL) {
+        // Capture the return cell before hiding the setting popover, whose own hide handler clears
+        // it, so the properties dialog can move focus into itself and restore it to the cell on
+        // Escape for keyboard/screen-reader users.
+        const returnCell = this.returnFocusCell;
         void this.popoverRef.hide();
-        void this.tableDynamicPopover.show(event.detail[0]);
+        void this.tableDynamicPopover.show(event.detail[0], returnCell);
       }
     };
     /**
@@ -3631,6 +4071,17 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
      */
     this.handleTableSettingPopoverShow = () => {
       this.syncSelectedCells();
+      this.labelSettingDialog();
+    };
+    /**
+     * When the setting popover hides after an Escape press, returns focus (and the caret) to the
+     * table cell that had focus before the toolbar was reached via Alt+F10.
+     */
+    this.handleTableSettingPopoverHide = () => {
+      // Lift the inert guard on the editor content synchronously, before any focus restore runs, so the
+      // cell (or the properties dialog) can receive focus and the editor is interactive again.
+      this.setEditorContentInert(false);
+      this.restoreFocusOnEscapeHide();
     };
     this.tableDynamicPopover = new TableDynamicPopoverRenderer(RTETableColorManager.getTableColors(), renderContext);
   }
@@ -3639,6 +4090,8 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
    */
   destroy() {
     this.tableDynamicPopover.destroy();
+    this.setEditorContentInert(false);
+    this.detachEscapeTracker();
     if (this.popoverContainer) {
       this.popoverContainer.remove();
     }
@@ -3659,6 +4112,10 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
       popover.isScreenPosition = true;
       popover.className = 'rte-table-setting-popover';
       DomNodeSubjectObserverFactory.addUniqueObserverToNode(popover, VegaPopoverShow, this.handleTableSettingPopoverShow);
+      DomNodeSubjectObserverFactory.addUniqueObserverToNode(popover, VegaPopoverHide, this.handleTableSettingPopoverHide);
+      // Escape inside the popover (rendered in a portal) does not bubble back to the table, so
+      // observe it on the document (capture phase) to know when to return focus to the cell.
+      this.attachEscapeTracker(safeDocument);
       const slotDiv = safeDocument.createElement('div');
       slotDiv.setAttribute('slot', 'popover');
       const tableSetting = safeDocument.createElement('vega-rich-text-table-setting');
@@ -3671,6 +4128,25 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
       this.tableSettingRef = tableSetting;
     }
   }
+  /**
+   * Whether the given event originated inside the setting toolbar subtree.
+   *
+   * @param {Event} event - The event to test.
+   * @returns {boolean} `true` when the toolbar is rendered and the event's composed path includes it.
+   */
+  isEventWithinPopover(event) {
+    return !!this.tableSettingRef && event.composedPath().includes(this.tableSettingRef);
+  }
+  /**
+   * Resolves the `.rich-text-content` editor root from the setting toolbar's target so the content
+   * can be made inert while the toolbar holds keyboard/VoiceOver focus.
+   *
+   * @returns {Nullable<HTMLElement>} The editor content element, or `null` when it cannot be resolved.
+   */
+  getInertContentTarget() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.tableSettingRef) === null || _a === void 0 ? void 0 : _a.target) === null || _b === void 0 ? void 0 : _b.closest('.rich-text-content')) !== null && _c !== void 0 ? _c : null;
+  }
   /**
    * Updates the table setting component caption state to match the current table data.
    */
@@ -3680,6 +4156,35 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
       this.tableSettingRef.hasCaption = hasCaption;
     }
   }
+  /**
+   * When the caption is toggled on, moves keyboard/VoiceOver focus and the caret into the caption so
+   * the user lands in it to start typing. The setting toolbar is opened as inert-guarded for
+   * keyboard/screen-reader users, so lift that guard first; the caption is re-rendered by the toggle,
+   * so defer the focus to the next tick when the `<caption>` element exists.
+   */
+  moveFocusToCaption() {
+    if (!this.tableBlock.hasCaption()) {
+      return;
+    }
+    this.setEditorContentInert(false);
+    // eslint-disable-next-line no-restricted-globals
+    setTimeout(() => {
+      var _a, _b, _c, _d, _e, _f, _g;
+      const caption = (_c = (_b = (_a = this.tableSettingRef) === null || _a === void 0 ? void 0 : _a.target) === null || _b === void 0 ? void 0 : _b.querySelector('caption')) !== null && _c !== void 0 ? _c : null;
+      if (!caption) {
+        return;
+      }
+      caption.focus();
+      const selection = (_g = (_e = (_d = this.getTableExtensionContext()) === null || _d === void 0 ? void 0 : _d.getSelection()) !== null && _e !== void 0 ? _e : (_f = caption.ownerDocument) === null || _f === void 0 ? void 0 : _f.getSelection()) !== null && _g !== void 0 ? _g : null;
+      if (selection) {
+        const range = new Range();
+        range.selectNodeContents(caption);
+        range.collapse(false);
+        selection.removeAllRanges();
+        selection.addRange(range);
+      }
+    }, 0);
+  }
   /**
    * Re-targets the shared popovers to the given table.
    *
@@ -3694,6 +4199,22 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
       this.tableDynamicPopover.reTarget(tableBlock, getTableRef);
     }
   }
+  /**
+   * `vega-popover-content-box` renders `role="dialog"` + `aria-modal="true"`, which on WebKit
+   * VoiceOver confines the reading cursor to the popover. Keep those semantics so Ctrl+Opt+Arrow
+   * cannot walk the VoiceOver cursor out of the toolbar past the last button (VoiceOver swallows
+   * those keys, so this cannot be trapped in JS), and give the dialog an accessible name so it
+   * announces "Table tools" on entry.
+   */
+  labelSettingDialog() {
+    var _a, _b;
+    const dialog = (_b = (_a = this.tableSettingRef) === null || _a === void 0 ? void 0 : _a.closest('vega-popover-content-box')) !== null && _b !== void 0 ? _b : null;
+    if (dialog) {
+      dialog.setAttribute('role', 'dialog');
+      dialog.setAttribute('aria-modal', 'true');
+      dialog.setAttribute('aria-label', 'Table tools');
+    }
+  }
   /**
    * Collects and returns the currently selected table cells.
    *
@@ -3719,7 +4240,7 @@ class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
    */
   doRender(h, renderData, rteContext) {
     let tableRef;
-    const table = this.renderTable(h, renderData, (ref) => (tableRef = ref));
+    const table = this.renderTable(h, renderData, (ref) => (tableRef = ref), rteContext);
     this.renderTableToolbar(rteContext);
     const tableAnnotation = renderData.getAnnotationByType(RTETableExtensionAnnotationTypeEnum.TABLE);
     const children = rteContext.editable
@@ -3743,9 +4264,16 @@ class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
             }
           },
         }, [
-          // Add an extra div as slot container, to make sure the cursor can move to before/end of the table.
+          // The table is a fully non-editable "widget" wrapped by a
+          // `<div contenteditable="false">`: there is NO editable element wrapping the
+          // table, so Chrome/VoiceOver exposes it as a real table ("table, N columns, M
+          // rows") instead of flattening it into the surrounding text entry area. The
+          // <table> stays a plain, semantically clean table and each cell re-enables editing
+          // via contentEditable=true. The cursor moves to before/after the table via the
+          // adjacent paragraphs in the editor content, treating the table as an atomic widget.
           h('div', {
-            contentEditable: true,
+            class: 'v-rte--extension-table-widget',
+            contentEditable: false,
             ref: this.useRef(renderData),
           }, [table]),
         ]),
@@ -3759,6 +4287,11 @@ class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
     }
     const result = h('div', {
       class: 'v-rte--extension-table-container',
+      // The container is `display: table` (for shrink-to-fit centering), which WebKit maps to an
+      // AXTable. Without this, Safari VoiceOver lands its cursor on the container (or groups up to
+      // the widget host) instead of the real `<table>`. `role="presentation"` strips the container's
+      // implicit table semantics so VO descends to `table.v-rte--extension-table` like Chrome does.
+      role: 'presentation',
       style: Object.assign({}, containerStyle),
     }, children);
     /**
@@ -3787,17 +4320,151 @@ class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
    * @param {VegaRTECreateElementFunction} h - The create element function.
    * @param {RTETableBlock} renderData - The table block to render.
    * @param {(ref: HTMLElement) => HTMLElement} setTableRef - Set table ref to tableRef
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
    * @returns {VegaRTERenderResult} - The rendered table element.
    */
-  renderTable(h, renderData, setTableRef) {
+  renderTable(h, renderData, setTableRef, rteContext) {
     var _a;
-    return h('table', Object.assign(Object.assign({ key: renderData.id }, (_a = renderData.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.render()), { style: renderData.getStyles(), class: renderData.getClasses(), 
+    const editable = !!rteContext.editable;
+    return h('table', Object.assign(Object.assign(Object.assign(Object.assign({ key: renderData.id }, (_a = renderData.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.render()), { style: renderData.getStyles(), class: renderData.getClasses() }), (editable
+      ? {
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        onClick: (event) => this.handleTableActivate(event, rteContext),
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        onKeyDown: (event) => this.handleTableKeyDown(event, rteContext, renderData),
+      }
+      : undefined)), { 
       // eslint-disable-next-line jsdoc/require-jsdoc
       ref: (ref) => {
         this.useRef(renderData)(ref);
         setTableRef(ref);
       } }));
   }
+  /**
+   * Handles activation of the table itself (e.g. VoiceOver Ctrl+Option+Space, which dispatches a
+   * click on the focused table) by moving focus into the first cell so the user can start editing.
+   *
+   * @param {MouseEvent} event - The click event dispatched on the table.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  handleTableActivate(event, rteContext) {
+    const tableRef = event.currentTarget;
+    // Only treat this as "activate the table" when the click truly targets the table element
+    // itself — i.e. VoiceOver Ctrl+Option+Space (which dispatches a click on the focused table)
+    // or a click on the table's own padding/border. Clicks that bubble up from editable
+    // descendants (cells, or the supported <caption>) keep their native contentEditable caret
+    // placement, so we must not force focus into the first cell and break that interaction.
+    if (event.target !== event.currentTarget) {
+      return;
+    }
+    this.focusFirstCell(tableRef, rteContext);
+  }
+  /**
+   * Handles table-scoped keyboard shortcuts while focus is inside the table:
+   * - Alt+F10 opens the table setting toolbar (re-targeting and showing it when needed) and moves
+   *   focus to it (the common "focus the contextual toolbar" shortcut), so keyboard/screen-reader
+   *   users can reach the toolbar buttons even when it is currently closed.
+   * - Escape moves focus back onto the table, so the caret leaves the cell (its focus highlight
+   *   is cleared), the contextual setting toolbar is dismissed, and screen readers announce the
+   *   table again.
+   *
+   * @param {KeyboardEvent} event - The keydown event.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   * @param {RTETableBlock} renderData - The table block being rendered.
+   */
+  handleTableKeyDown(event, rteContext, renderData) {
+    var _a, _b;
+    if (event.altKey && event.key === 'F10') {
+      event.preventDefault();
+      event.stopPropagation();
+      const tableRef = event.currentTarget;
+      const f10Target = event.target;
+      const f10Cell = f10Target
+        ? f10Target.closest('td, th')
+        : null;
+      (_a = this.tableToolbar) === null || _a === void 0 ? void 0 : _a.openSettingToolbarForKeyboard(renderData, () => tableRef, f10Cell);
+      return;
+    }
+    if (event.key !== 'Escape') {
+      return;
+    }
+    const tableRef = event.currentTarget;
+    const target = event.target;
+    const cell = target
+      ? target.closest('td, th')
+      : null;
+    if (!cell || !tableRef.contains(cell)) {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    this.focusTable(tableRef, rteContext);
+    // Focus moved from the cell back onto the table, so dismiss the contextual setting toolbar
+    // that may have been opened (e.g. by activating the table) — otherwise it lingers with no
+    // focused cell to act on.
+    (_b = this.tableToolbar) === null || _b === void 0 ? void 0 : _b.hide();
+  }
+  /**
+   * Moves focus (and the caret) into the first cell of the table.
+   *
+   * @param {HTMLElement} tableRef - The table element.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  focusFirstCell(tableRef, rteContext) {
+    const firstCell = tableRef.querySelector('td, th');
+    if (!firstCell) {
+      return;
+    }
+    firstCell.focus();
+    const selection = this.getSelection(rteContext, tableRef);
+    if (selection) {
+      // Collapse the caret at the start of the cell content so the user can start typing.
+      const range = new Range();
+      range.setStart(firstCell, 0);
+      range.setEnd(firstCell, 0);
+      selection.removeAllRanges();
+      selection.addRange(range);
+    }
+  }
+  /**
+   * Moves focus onto the table element and clears any cell caret and selection highlight.
+   *
+   * @param {HTMLElement} tableRef - The table element.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  focusTable(tableRef, rteContext) {
+    var _a;
+    const selection = this.getSelection(rteContext, tableRef);
+    selection === null || selection === void 0 ? void 0 : selection.removeAllRanges();
+    const extensionContext = this.getExtensionContext(rteContext.host);
+    (_a = extensionContext === null || extensionContext === void 0 ? void 0 : extensionContext.tableSelection) === null || _a === void 0 ? void 0 : _a.setSelectedCells([]);
+    // The table is contentEditable=false, so it is not focusable by default. Add tabindex ONLY
+    // while moving focus onto it, and remove it again on blur, so that during normal navigation
+    // VoiceOver still announces it as "table, N columns, M rows" rather than a focusable widget.
+    tableRef.setAttribute('tabindex', '-1');
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    const removeTabindex = () => {
+      tableRef.removeAttribute('tabindex');
+      tableRef.removeEventListener('blur', removeTabindex);
+    };
+    tableRef.addEventListener('blur', removeTabindex);
+    tableRef.focus();
+  }
+  /**
+   * Resolves the editor selection, preferring the shadow-aware selection from the extension
+   * context and falling back to the table's owning document.
+   *
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   * @param {HTMLElement} tableRef - The table element.
+   * @returns {Nullable<Selection>} - The resolved selection, or null when unavailable.
+   */
+  getSelection(rteContext, tableRef) {
+    const extensionContext = this.getExtensionContext(rteContext.host);
+    if (extensionContext) {
+      return extensionContext.getSelection();
+    }
+    return tableRef.ownerDocument ? tableRef.ownerDocument.getSelection() : null;
+  }
   /**
    * Handles the removal of the table block.
    *
@@ -3900,9 +4567,9 @@ class RTETableCellRenderer extends VegaRTEExtensionRenderer {
    */
   renderByCellType(h, renderData, rteContext, elementType) {
     var _a;
-    return h(elementType, Object.assign(Object.assign(Object.assign({ key: `${renderData.id}-${elementType}`, 
+    return h(elementType, Object.assign(Object.assign(Object.assign(Object.assign({ key: `${renderData.id}-${elementType}`, 
       // eslint-disable-next-line jsdoc/require-jsdoc
-      ref: this.useRef(renderData) }, (_a = renderData.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.render()), { style: renderData.getStyles(rteContext), class: renderData.getClasses() }), (rteContext.editable ? this.onSelectionListeners(renderData, rteContext) : undefined)));
+      ref: this.useRef(renderData) }, (rteContext.editable ? { contentEditable: true, tabindex: -1 } : undefined)), (_a = renderData.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.render()), { style: renderData.getStyles(rteContext), class: renderData.getClasses() }), (rteContext.editable ? this.onSelectionListeners(renderData, rteContext) : undefined)));
   }
   /**
    * Returns the mouse event listeners for selection handling.
@@ -4181,6 +4848,7 @@ class RTETableToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return createTablePopoverRenderer.render(h, super.renderButton(h, editorContext, {
       showArrowIcon: true,
       icon: 'rte-table',
+      ariaLabel: 'Table',
       tooltip: { text: 'Insert table' },
     }));
   }
@@ -4361,16 +5029,10 @@ class RTETableCaptionRenderer extends VegaRTEExtensionRenderer {
   /**
    * @inheritDoc
    */
-  doRender(h, renderData) {
-    return h('caption', {
-      'key': renderData.id,
-      'ref': this.useRef(renderData),
-      'style': renderData.getStyles(),
-      'class': [renderData.getClasses(), renderData.isNotEmpty() ? null : 'showPlaceholder']
+  doRender(h, renderData, rteContext) {
+    return h('caption', Object.assign(Object.assign({ 'key': renderData.id, 'ref': this.useRef(renderData) }, (rteContext.editable ? { contentEditable: true } : undefined)), { 'style': renderData.getStyles(), 'class': [renderData.getClasses(), renderData.isNotEmpty() ? null : 'showPlaceholder']
         .filter(isNonNullable)
-        .join(' '),
-      'data-placeholder': TABLE_CAPTION_PLACEHOLDER_TEXT,
-    });
+        .join(' '), 'data-placeholder': TABLE_CAPTION_PLACEHOLDER_TEXT }));
   }
 }
 
@@ -5166,11 +5828,36 @@ class RTETableSelection {
       const commonAncestorContainer = range.commonAncestorContainer;
       const rangeInTable = !!findParent(commonAncestorContainer, `table`);
       if (rangeInTable) {
-        const selectedCells = this.filterSelectedCell(range, commonAncestorContainer);
+        let selectedCells = this.filterSelectedCell(range, commonAncestorContainer);
+        if (selectedCells.length === 0) {
+          // A collapsed caret placed at an element boundary (e.g. keyboard/VoiceOver entry via
+          // Ctrl+Option+Space) does not intersect a text node, so filterSelectedCell finds nothing
+          // on browsers that keep the caret on the element (Firefox) instead of normalizing it into
+          // the text node (Chrome). Resolve the containing cell directly so the setting toolbar is
+          // still enabled.
+          selectedCells = this.resolveCaretCell(commonAncestorContainer);
+        }
         this.setSelectedCells(selectedCells);
       }
     }
   }
+  /**
+   * Resolve the single table cell that contains the given selection node. Used as a fallback when a
+   * collapsed caret does not intersect any text node (see handleSelectionChange).
+   *
+   * @param {Node} node - The selection's common ancestor container.
+   * @returns {RTETableCellBlock[]} The containing cell block, or an empty list when none is found.
+   */
+  resolveCaretCell(node) {
+    var _a;
+    const startElement = node.nodeType === Node.TEXT_NODE ? node.parentElement : node;
+    const cellRef = (_a = startElement === null || startElement === void 0 ? void 0 : startElement.closest('td, th')) !== null && _a !== void 0 ? _a : null;
+    if (!cellRef) {
+      return [];
+    }
+    const cellBlock = stateEntityRenderingRegistry.getEntityByDOM(cellRef);
+    return cellBlock ? [cellBlock] : [];
+  }
   /**
    * Mark the beginning of a drag operation.
    */
@@ -7739,6 +8426,7 @@ class RTEHorizontalLineToolbarButtonRenderer extends VegaRTEToolbarButtonRendere
   render(createElement, editorContext) {
     return this.renderButton(createElement, editorContext, {
       icon: 'horizontal-line',
+      ariaLabel: VegaInternalTranslation.t('Horizontal line'),
       tooltip: { text: VegaInternalTranslation.t('Horizontal line') },
     });
   }
@@ -8334,6 +9022,7 @@ class RTEBlockquoteToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
   render(createElement, editorContext) {
     return this.renderButton(createElement, editorContext, {
       icon: 'quote-left',
+      ariaLabel: editorContext.translation.t('Block quote'),
       tooltip: { text: 'Block quote' },
     });
   }
@@ -8966,6 +9655,7 @@ class RTESpecialCharactersToolbarButtonRenderer extends VegaRTEToolbarButtonRend
       placement: 'bottom',
       showArrow: false,
       isScreenPosition: true,
+      role: 'presentation',
       // eslint-disable-next-line jsdoc/require-jsdoc
       ref: (ref) => {
         if (ref) {
@@ -8993,6 +9683,7 @@ class RTESpecialCharactersToolbarButtonRenderer extends VegaRTEToolbarButtonRend
       ]),
       h('div', { slot: 'popover-content' }, this.renderButton(h, editorContext, {
         icon: 'rte-special-characters',
+        ariaLabel: editorContext.translation.t('Special Characters'),
         tooltip: { text: 'Special Characters' },
       })),
     ]);
@@ -10206,14 +10897,22 @@ class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
       placement: 'bottom',
       showArrow: false,
       isScreenPosition: true,
+      role: 'presentation',
       // eslint-disable-next-line jsdoc/require-jsdoc
       ref: (ref) => {
         if (ref) {
           this.popoverRef = ref;
           DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaPopoverHide, () => {
+            const shouldRestoreFocus = this.shouldRestoreFocusToButton();
             this.isPopoverOpen = false;
             this.findController.clear();
             this.updatePanel({ current: 0, total: 0 });
+            if (shouldRestoreFocus) {
+              // Defer so it runs after the popover's own focus-restore
+              // (AriaDialogFocusableTrapSlimmer), returning focus to the toolbar
+              // button for keyboard and VoiceOver users when the panel is dismissed.
+              setTimeout(() => this.focusToolbarButton());
+            }
           });
           DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaPopoverShow, () => {
             this.isPopoverOpen = true;
@@ -10244,6 +10943,7 @@ class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
       ]),
       h('div', { slot: 'popover-content' }, this.renderButton(h, editorContext, {
         icon: 'rte-find-replace',
+        ariaLabel: editorContext.translation.t('Find and replace'),
         tooltip: { text: VegaInternalTranslation.t('Find and replace') },
       })),
     ]);
@@ -10346,13 +11046,54 @@ class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
       void this.popoverRef.hide();
     }
   }
-}
-(() => {
-  VegaInternalIconManager.register({ 'rte-find-replace': findReplaceIcon });
-})();
-
-/**
- * Find & Replace extension for Vega Rich Text Editor.
+  /**
+   * Decides whether closing the panel should return focus to the toolbar button.
+   *
+   * Focus is restored when the panel is dismissed while focus is still inside it
+   * (Escape key or the Close button) — including the VoiceOver case where the
+   * dialog's `inert` blur has already moved focus to `<body>`. It is not restored
+   * when focus has intentionally moved to another element (Tab out of the panel
+   * or interacting with something else), so we don't yank focus back.
+   *
+   * @returns {boolean} True when focus should return to the toolbar button.
+   */
+  shouldRestoreFocusToButton() {
+    // eslint-disable-next-line no-restricted-globals
+    const activeEl = getDeepActiveElementInShadow(document, true);
+    // eslint-disable-next-line no-restricted-globals
+    return !activeEl || activeEl === document.body || this.isElementWithinPanel(activeEl);
+  }
+  /**
+   * Checks whether an element is inside the panel, crossing shadow boundaries.
+   *
+   * @param {Nullable<HTMLElement>} el - The element to test.
+   * @returns {boolean} True when the element is contained by the panel.
+   */
+  isElementWithinPanel(el) {
+    if (!el || !this.panelRef) {
+      return false;
+    }
+    let node = el;
+    while (node) {
+      if (node === this.panelRef) {
+        return true;
+      }
+      const parent = node.parentNode;
+      // Cross shadow boundaries: a shadow root (nodeType 11) exposes its `host`.
+      node =
+        parent && parent.nodeType === Node.DOCUMENT_FRAGMENT_NODE
+          ? parent.host
+          : parent;
+    }
+    return false;
+  }
+}
+(() => {
+  VegaInternalIconManager.register({ 'rte-find-replace': findReplaceIcon });
+})();
+
+/**
+ * Find & Replace extension for Vega Rich Text Editor.
  *
  * Registers a toolbar button (magnifying-glass icon) that toggles the find-replace panel.
  * Each editor host gets its own isolated FindReplaceState and toolbar renderer instance,
@@ -10507,12 +11248,28 @@ class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     }, [
       this.renderButton(createElement, editorContext, {
         icon: 'line-height',
+        ariaLabel: editorContext.translation.t('Line Height'),
         showArrowIcon: true,
         tooltip: { text: VegaInternalTranslation.t('Line Height') },
       }),
       this.renderDropdownListTemplate(createElement, dropdownItems, editorContext),
     ]);
   }
+  /**
+   * Renders each line-height option with its label as light-DOM children rather than the
+   * `label` prop. This gives the focusable menuitem a light-DOM text anchor so Safari
+   * VoiceOver's reading cursor follows focus into the item (Ctrl+Opt+Right walks item→item
+   * instead of escaping to the next toolbar button).
+   *
+   * The label is wrapped in a `<span>` (not a bare text node) so a click targeting the label
+   * lands on a slotted element that composes into the item's shadow `<li>`; a bare text node
+   * resolves to the `vega-dropdown-item` host, whose click never reaches the shadow handler.
+   *
+   * @inheritDoc
+   */
+  renderDropdownItem(h, item, editorContext) {
+    return h('vega-dropdown-item', { key: item.key, itemKey: item.key, prefixIcon: item.icon }, h('span', undefined, editorContext.translation.t(item.label)));
+  }
   /**
    * @inheritDoc
    */
@@ -10814,6 +11571,9 @@ class RTEFullscreenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     const selected = this.isSelected();
     return this.renderButton(createElement, editorContext, {
       icon: selected ? 'rte-fullscreen-exit' : 'rte-fullscreen-enter',
+      ariaLabel: selected
+        ? editorContext.translation.t('Exit fullscreen mode')
+        : editorContext.translation.t('Enter fullscreen mode'),
       tooltip: {
         text: selected
           ? VegaInternalTranslation.t('Exit fullscreen mode')
@@ -10988,225 +11748,2807 @@ class FullscreenController {
       FullscreenController.documentScrollLockStates.set(ownerDocument, Object.assign(Object.assign({}, currentState), { lockCount: currentState.lockCount - 1 }));
       return;
     }
-    ownerDocument.body.style.overflow = currentState.bodyOverflow;
-    ownerDocument.documentElement.style.overflow = currentState.documentOverflow;
-    FullscreenController.documentScrollLockStates.delete(ownerDocument);
+    ownerDocument.body.style.overflow = currentState.bodyOverflow;
+    ownerDocument.documentElement.style.overflow = currentState.documentOverflow;
+    FullscreenController.documentScrollLockStates.delete(ownerDocument);
+  }
+}
+FullscreenController.STYLE_TAG_ID = 'v-rte-fullscreen-styles';
+FullscreenController.HOST_FULLSCREEN_STYLE = 'position:fixed;inset:0;background-color:rgba(var(--v-bg-primary, 252, 252, 252, 1));';
+/**
+ * Only three things need overriding inside the shadow root:
+ * 1. The outer vega-flex wrapper must fill the host height (`:host >`
+ *    avoids hitting the toolbar's nested vega-flex).
+ * 2. The editor container must grow to fill remaining space and drop
+ *    the fixed pixel height that Stencil injects from the `rows` prop.
+ * 3. The source-view container (shown in source-edit mode) also grows
+ *    and owns vertical scrolling so long source code is reachable.
+ * 4. overflow:auto on the container lets content scroll without clipping
+ *    internal pop-ups (link editor, color picker, etc.) at the host level.
+ */
+FullscreenController.INNER_FULLSCREEN_CSS = ':host > vega-flex { height: 100%; padding: 5px; box-sizing: border-box; }' +
+  ' .rich-text-editor-container { flex: 1 !important; height: auto !important; min-height: 0 !important; resize: none !important; overflow: auto !important; }' +
+  ' .source-view-container:not(.vega-hidden) { display: flex !important; flex: 1 !important; min-height: 0 !important; overflow: auto !important; flex-direction: column; }';
+FullscreenController.documentScrollLockStates = new WeakMap();
+
+/**
+ * Rich Text Editor extension that adds a toolbar button for viewport fullscreen mode.
+ *
+ * OOP Pattern: Extends VegaRTEExtension with fullscreen feature.
+ * Uses a per-host controller store to isolate state across hosts.
+ */
+class VegaRTEFullscreenExtension extends VegaRTEExtension {
+  /** @inheritDoc */
+  prepareBeforeLoad(host) {
+    const controller = new FullscreenController(host);
+    VegaRTEFullscreenExtension.controllerStore.set(host, controller);
+    this.registerToolbarButtonRenderer(VegaRTEFullscreenExtension.TOOLBAR_BUTTON_KEY, new RTEFullscreenToolbarButtonRenderer(controller), host);
+  }
+  /**
+   * Restore document scroll if the editor is removed while fullscreen is active.
+   * Without this, body overflow:hidden would persist after the host is gone.
+   */
+  destroyExtension() {
+    var _a, _b;
+    if ((_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.host) {
+      const host = this.extensionContext.host;
+      (_b = VegaRTEFullscreenExtension.controllerStore.get(host)) === null || _b === void 0 ? void 0 : _b.exitFullscreen();
+      VegaRTEFullscreenExtension.controllerStore.delete(host);
+    }
+  }
+}
+VegaRTEFullscreenExtension.TOOLBAR_BUTTON_KEY = 'fullscreen';
+VegaRTEFullscreenExtension.controllerStore = VegaRTEFullscreenExtension.createStateStore();
+
+var RTEPasteMode;
+(function (RTEPasteMode) {
+  RTEPasteMode["RICH"] = "rich";
+  RTEPasteMode["WORD"] = "word";
+})(RTEPasteMode || (RTEPasteMode = {}));
+/**
+ * Priority scale shared by all paste processing strategies.
+ */
+var PasteProcessingStrategyPriority;
+(function (PasteProcessingStrategyPriority) {
+  /** Fallback strategy used only when no specialized strategy matches. */
+  PasteProcessingStrategyPriority[PasteProcessingStrategyPriority["DEFAULT_FALLBACK"] = -1] = "DEFAULT_FALLBACK";
+  /** Baseline priority for generic strategies. */
+  PasteProcessingStrategyPriority[PasteProcessingStrategyPriority["BASE"] = 0] = "BASE";
+  /** Word strategy priority so it outranks generic strategies. */
+  PasteProcessingStrategyPriority[PasteProcessingStrategyPriority["WORD"] = 10] = "WORD";
+})(PasteProcessingStrategyPriority || (PasteProcessingStrategyPriority = {}));
+/**
+ * Abstract base class for paste processing strategies.
+ *
+ * Each strategy implements detection logic (`canHandle`) and transformation
+ * logic (`process`) for a specific clipboard source (Word, Google Docs, etc.).
+ * The strategy selector chooses the highest-priority strategy that can handle
+ * the given HTML.
+ */
+class AbstractPasteProcessingStrategy {
+  /**
+   * Downstream paste mode marker associated with this strategy.
+   *
+   * Defaults to regular rich-text paste unless a specialized strategy overrides it.
+   *
+   * @returns {RTEPasteMode} Paste mode marker for downstream handlers.
+   */
+  get type() {
+    return RTEPasteMode.RICH;
+  }
+  /**
+   * Optional: Strategy priority when multiple strategies match.
+   * Higher numbers = higher priority. Default: 0.
+   *
+   * @returns {number} Strategy priority.
+   */
+  get priority() {
+    return PasteProcessingStrategyPriority.BASE;
+  }
+  /**
+   * Whether pasted images from this source should be extracted into local
+   * previews by the paste extension after {@link process} runs.
+   *
+   * @returns {boolean} `false` unless a strategy opts into image processing.
+   */
+  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;
+  }
+  /**
+   * Opens the paste-mode chooser at the given position.
+   *
+   * @param {PasteChooserPosition} position Viewport position for the chooser.
+   */
+  open(position) {
+    this.destroy();
+    const doc = this.hostRoot.ownerDocument;
+    const chooser = doc.createElement('div');
+    chooser.setAttribute(RTEPasteChooserUI.CHOOSER_ATTR, 'true');
+    chooser.style.position = 'fixed';
+    chooser.style.zIndex = '1000';
+    chooser.style.left = `${position.left}px`;
+    chooser.style.top = `${position.top}px`;
+    const dropdownEl = this.createPasteChooserDropdown(doc, position.placement);
+    dropdownEl.placement = position.placement;
+    chooser.append(dropdownEl);
+    this.hostRoot.appendChild(chooser);
+    this.chooserEl = chooser;
+    this.dropdownEl = dropdownEl;
+    dropdownEl.addEventListener('vegaShow', () => {
+      if (this.triggerButtonEl) {
+        this.triggerButtonEl.selected = true;
+      }
+    });
+    dropdownEl.addEventListener('vegaHide', () => {
+      if (this.triggerButtonEl) {
+        this.triggerButtonEl.selected = false;
+      }
+    });
+  }
+  /**
+   * Removes the chooser from the DOM.
+   */
+  destroy() {
+    var _a;
+    if (this.dropdownEl && typeof this.dropdownEl.hide === 'function') {
+      void this.dropdownEl.hide();
+    }
+    if ((_a = this.chooserEl) === null || _a === void 0 ? void 0 : _a.parentNode) {
+      this.chooserEl.parentNode.removeChild(this.chooserEl);
+    }
+    if (this.triggerButtonEl) {
+      this.triggerButtonEl.selected = false;
+    }
+    this.dropdownEl = null;
+    this.chooserEl = null;
+    this.triggerButtonEl = null;
+  }
+  /**
+   * Determines whether the given event path targets the chooser.
+   *
+   * @param {EventTarget[]} eventPath Composed path of an event.
+   * @returns {boolean} `true` when the path includes the chooser.
+   */
+  includesEventPath(eventPath) {
+    if (!this.chooserEl) {
+      return false;
+    }
+    const isDropdownContentClick = eventPath.some((target) => {
+      return 'tagName' in target && target.tagName === 'VEGA-DROPDOWN-CONTENT-BOX';
+    });
+    return eventPath.includes(this.chooserEl) || isDropdownContentClick;
+  }
+  /**
+   * Builds the dropdown element with the rich text paste option.
+   *
+   * @param {Document} doc Document used to create elements.
+   * @param {['bottom', 'top'] | ['top', 'bottom']} placement Preferred placement order.
+   * @returns {HTMLElement} Configured dropdown element.
+   */
+  createPasteChooserDropdown(doc, placement) {
+    const dropdownEl = doc.createElement('vega-dropdown');
+    dropdownEl.trigger = 'click';
+    dropdownEl.selectType = 'single';
+    dropdownEl.selectedSourceKey = 'rich';
+    dropdownEl.maxWidth = 220;
+    dropdownEl.alignment = 'start';
+    dropdownEl.itemDisplayRule = 'ellipsis';
+    dropdownEl.isScreenPosition = true;
+    const triggerButton = doc.createElement('vega-rich-text-editor-toolbar-button');
+    const arrowIcon = placement[0] === 'top' ? 'chevron-up' : 'chevron-down';
+    triggerButton.setAttribute(RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR, 'true');
+    triggerButton.setAttribute('aria-label', VegaInternalTranslation.t('Paste options'));
+    triggerButton.setAttribute('arrow-icon', arrowIcon);
+    triggerButton.icon = 'rte-paste';
+    triggerButton.showArrowIcon = true;
+    triggerButton.selected = false;
+    this.triggerButtonEl = triggerButton;
+    const tooltipEl = doc.createElement('vega-tooltip');
+    tooltipEl.text = VegaInternalTranslation.t('Paste options');
+    tooltipEl.placement = ['bottom', 'top'];
+    tooltipEl.append(triggerButton);
+    dropdownEl.append(tooltipEl);
+    const itemsContainer = doc.createElement('div');
+    itemsContainer.setAttribute('slot', 'items');
+    const dropdownItems = [
+      this.createDropdownItem(doc, RTEPasteMode.RICH, VegaInternalTranslation.t('Use rich text'), RTEPasteChooserUI.CHOOSER_RICH_ATTR),
+    ];
+    if (this.options.showWordOption) {
+      dropdownItems.push(this.createDropdownItem(doc, RTEPasteMode.WORD, VegaInternalTranslation.t('Use Word'), RTEPasteChooserUI.CHOOSER_WORD_ATTR));
+    }
+    itemsContainer.append(...dropdownItems);
+    dropdownEl.append(itemsContainer);
+    dropdownEl.addEventListener('vegaDropdownClick', (event) => {
+      const mode = event.detail;
+      if (mode === RTEPasteMode.RICH || mode === RTEPasteMode.WORD) {
+        this.callbacks.onModeSelect(mode);
+      }
+    });
+    return dropdownEl;
+  }
+  /**
+   * Creates a single dropdown item element for a paste mode.
+   *
+   * @param {Document} doc Document used to create the element.
+   * @param {RTEPasteMode} key Paste mode key for the item.
+   * @param {string} label Display label for the item.
+   * @param {string} dataAttrName Data attribute marker for the item.
+   * @returns {HTMLVegaDropdownItemElement} Configured dropdown item element.
+   */
+  createDropdownItem(doc, key, label, dataAttrName) {
+    const itemEl = doc.createElement('vega-dropdown-item');
+    itemEl.itemKey = key;
+    itemEl.label = label;
+    itemEl.setAttribute(dataAttrName, 'true');
+    return itemEl;
+  }
+}
+(() => {
+  VegaInternalIconManager.register({
+    'rte-paste': paste,
+  });
+})();
+RTEPasteChooserUI.CHOOSER_ATTR = 'data-rte-paste-chooser';
+RTEPasteChooserUI.CHOOSER_RICH_ATTR = 'data-rte-paste-type-rich';
+RTEPasteChooserUI.CHOOSER_WORD_ATTR = 'data-rte-paste-type-word';
+RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR = 'data-rte-paste-trigger';
+
+/**
+ * Default paste processing strategy that acts as a fallback when no other
+ * strategy matches. This strategy always accepts the content and passes it
+ * through unchanged — the normal RTE paste pipeline (DOMParser +
+ * ElementToDtoStrategyProcessor) handles the rest.
+ */
+class DefaultPasteProcessingStrategy extends AbstractPasteProcessingStrategy {
+  /**
+   * Always matches as the terminal fallback strategy.
+   *
+   * @param {string} html Raw clipboard HTML.
+   * @returns {boolean} Always `true`.
+   */
+  canHandle(html) {
+    // Default strategy is the fallback — always returns true.
+    return html !== undefined;
+  }
+  /**
+   * Returns the original HTML unchanged.
+   *
+   * @param {string} html Raw clipboard HTML.
+   * @returns {string} Unchanged HTML.
+   */
+  process(html) {
+    // Current default behavior: pass through unchanged
+    // (DOMParser + ElementToDtoStrategyProcessor handles the rest)
+    return html;
+  }
+  /**
+   * Fallback priority so other strategies can win when matched.
+   *
+   * @returns {number} Strategy priority.
+   */
+  get priority() {
+    return PasteProcessingStrategyPriority.DEFAULT_FALLBACK;
+  }
+}
+
+/**
+ * Contract for Word DOM structure transformers. Each transformer is responsible
+ * for one structural concern (list markers, paragraph roles, tables, images…).
+ * Register new transformers in {@link WordPasteProcessingStrategy.STRUCTURE_TRANSFORMERS}
+ * to extend Word paste support without touching the core pipeline.
+ */
+const WORD_SANITIZE_ALL_TAGS_KEY = '*';
+
+/** CSS class prefix used by the RTE to encode text-style roles on elements. */
+const RTE_TEXT_STYLE_CLASS_PREFIX = 'v-rte--text-style-';
+/**
+ * Maps Word title / subtitle / heading paragraph style class names onto RTE
+ * CSS text-style classes. Any pre-existing `data-type` attributes are stripped
+ * first so only trusted values remain. Using a class instead of a custom
+ * attribute prevents the value from leaking into the DTO's custom-attribute
+ * annotation and subsequently into the serialized HTML output.
+ */
+class WordParagraphRoleTransformer {
+  /** @inheritDoc */
+  apply(root) {
+    // Strip any pre-existing data-type attributes so untrusted source values
+    // can never influence the role resolution.
+    Array.from(root.querySelectorAll('[data-type]')).forEach((element) => {
+      element.removeAttribute('data-type');
+    });
+    Array.from(root.querySelectorAll('p')).forEach((paragraph) => {
+      const rawClass = paragraph.getAttribute('class');
+      const role = this.resolveRole(rawClass);
+      // Drop the Word paragraph class once its role has been extracted so
+      // that Word artifacts (e.g. `MsoTitle`, `MsoNormal`) never leak into
+      // the sanitized output.
+      if (rawClass !== null) {
+        paragraph.removeAttribute('class');
+      }
+      if (role) {
+        // Encode the role as an RTE text-style CSS class so the downstream
+        // DTO processor can resolve it via getElementTypeByClassName().
+        paragraph.classList.add(`${RTE_TEXT_STYLE_CLASS_PREFIX}${role}`);
+      }
+    });
+  }
+  /** @inheritDoc */
+  getAllowedTags() {
+    return [
+      'P',
+      'BR',
+      'SPAN',
+      'STRONG',
+      'B',
+      'EM',
+      'I',
+      'U',
+      'S',
+      'STRIKE',
+      'DEL',
+      'H1',
+      'H2',
+      'H3',
+      'H4',
+      'H5',
+      'H6',
+      'A',
+      // Inline `<code>` is treated as an inline text annotation (like
+      // STRONG/EM/U) and therefore lives with the paragraph/inline
+      // allowlist. Block-level `<pre>` code blocks are owned by
+      // {@link WordCodeBlockTransformer}.
+      'CODE',
+    ];
+  }
+  /** @inheritDoc */
+  getAllowedAttributes() {
+    // `class` must be preserved so this transformer can parse Word paragraph
+    // roles (e.g., MsoTitle, MsoSubtitle, MsoHeadingN) in Phase 1. These classes
+    // are ultimately stripped when pasting in autoMatchFormat mode.
+    return new Map([
+      [WORD_SANITIZE_ALL_TAGS_KEY, ['class', 'style']],
+      ['A', ['href', 'target', 'title']],
+    ]);
+  }
+  /** @inheritDoc */
+  getAllowedStyles() {
+    return [
+      'color',
+      'background',
+      'text-align',
+      'text-indent',
+      'text-decoration',
+      'margin',
+      'padding',
+      'font',
+      'line-height',
+      'letter-spacing',
+      'vertical-align',
+    ];
+  }
+  /**
+   * Resolves the RTE text style for a Word paragraph class name.
+   *
+   * @param {string | null} className Raw `class` attribute value.
+   * @returns {WordParagraphRole | null} Matched role or `null`.
+   */
+  resolveRole(className) {
+    if (!className) {
+      return null;
+    }
+    const normalized = className.toLowerCase();
+    const headingMatch = /msoheading([1-6])/.exec(normalized);
+    if (headingMatch) {
+      return `heading-${headingMatch[1]}`;
+    }
+    if (/msosubtitle/.test(normalized)) {
+      return 'subtitle';
+    }
+    if (/msotitle/.test(normalized)) {
+      return 'title';
+    }
+    return null;
+  }
+}
+
+/** Font families Word uses to render bullet symbols rather than real characters. */
+const BULLET_FONT_PATTERN = /symbol|wingdings|webdings/i;
+/**
+ * Matches the paragraph-level Word list marker (`mso-list:l0 level1 lfo1`). The
+ * presence of `l<number>` distinguishes a genuine list paragraph from the inner
+ * `mso-list:Ignore` marker span.
+ */
+const PARAGRAPH_LIST_PATTERN = /mso-list\s*:\s*l\d+/i;
+/** Extracts the Word nesting depth (`level<number>`) from a list paragraph. */
+const LIST_LEVEL_PATTERN = /mso-list\s*:\s*l\d+\s+level(\d+)/i;
+/** Extracts the abstract Word list template id (`l<number>`). */
+const LIST_TEMPLATE_ID_PATTERN = /mso-list\s*:\s*l(\d+)/i;
+/** Extracts the Word list-format override id (`lfo<number>`), unique per list instance. */
+const LIST_OVERRIDE_ID_PATTERN = /\blfo(\d+)/i;
+/** Matches the inner span that holds the Word-rendered bullet / number glyph. */
+const LIST_IGNORE_PATTERN = /mso-list\s*:\s*ignore/i;
+/** Extracts a `font-family` declaration value from a preserved style string. */
+const FONT_FAMILY_PATTERN = /font-family\s*:\s*([^;]+)/i;
+/** Fallback Word list paragraph class when no `mso-list` style is present. */
+const LIST_PARAGRAPH_CLASS_PATTERN = /MsoListParagraph/i;
+/**
+ * CSS `list-style-type` values keyed by the shape of the Word marker token.
+ * Decimal markers are intentionally absent: a plain `<ol>` already renders as
+ * `1. 2. 3.`, so numeric lists keep the current behavior with no inline style.
+ *
+ * Roman patterns explicitly accept a lone `i` / `I` (representing 1), which is
+ * the typical first item of a Roman-numeral list. Multi-character sequences
+ * must contain only Roman letters.
+ */
+const LOWER_ROMAN_PATTERN = /^(i|[ivxlcdm]{2,})$/;
+const UPPER_ROMAN_PATTERN = /^(I|[IVXLCDM]{2,})$/;
+const LOWER_ALPHA_PATTERN = /^[a-z]+$/;
+const UPPER_ALPHA_PATTERN = /^[A-Z]+$/;
+const DECIMAL_PATTERN = /^[0-9]+$/;
+/** Extracts the `list-style-type` value from a preserved style string. */
+const LIST_STYLE_TYPE_PATTERN = /list-style-type\s*:\s*([^;]+)/i;
+/**
+ * Maps the HTML `<ol type>` attribute values Word emits on real ordered lists
+ * to the equivalent CSS `list-style-type`. Decimal (`type=1`) is intentionally
+ * absent: a plain `<ol>` already renders as `1. 2. 3.`, so it needs no inline
+ * style (matching the marker-derived handling above).
+ */
+const OL_TYPE_TO_LIST_STYLE_TYPE = {
+  a: 'lower-alpha',
+  A: 'upper-alpha',
+  i: 'lower-roman',
+  I: 'upper-roman',
+};
+/**
+ * Rebuilds Word list paragraphs into real `<ul>` / `<ol>` / `<li>` structures.
+ *
+ * Word does not emit list elements: it emits a flat sequence of `<p>` blocks
+ * that each carry an `mso-list:l<id> level<depth> lfo<override>` marker plus an
+ * inner `mso-list:Ignore` span that renders the visible bullet or number. This
+ * transformer walks every container that hosts list paragraphs (so nested
+ * `<div>` / table cells are covered), strips the marker span, decides bullet
+ * vs. numbered from the marker text / font, and folds the flat items back into
+ * a nested list tree the RTE slimmer can parse.
+ *
+ * Runs before {@link WordParagraphRoleTransformer} so the converted `<li>`
+ * elements are no longer seen as paragraphs during role resolution.
+ */
+class WordListRoleTransformer {
+  /** @inheritDoc */
+  apply(root) {
+    // Word can also emit real `<ol>` / `<ul>` structures where a nested list
+    // is a **sibling** of the preceding `<li>` rather than a child of it (an
+    // invalid nesting the HTML parser preserves as-is). Fix that first so the
+    // rest of the pipeline sees the standard `<li><ol>…</ol></li>` shape.
+    this.nestSiblingLists(root);
+    // Word may nest list paragraphs inside containers (e.g. `<div>`, table
+    // cells). Group by their direct parent so contiguous siblings in each
+    // container are folded together, regardless of where they sit in the tree.
+    const containers = new Set();
+    Array.from(root.querySelectorAll('p')).forEach((paragraph) => {
+      if (this.isWordListParagraph(paragraph) && paragraph.parentElement) {
+        containers.add(paragraph.parentElement);
+      }
+    });
+    // Include the root itself when it hosts list paragraphs directly.
+    if (Array.from(root.children).some((child) => this.isWordListParagraph(child))) {
+      containers.add(root);
+    }
+    containers.forEach((container) => this.processContainer(container));
+    // Word also emits real `<ol type=...>` elements whose numbering style lives
+    // on the (non-allowlisted) `type` attribute. Fold that into a preserved
+    // `list-style-type` so the marker style survives the allowlist pass.
+    this.applyOrderedListTypeAttributes(root);
+  }
+  /** @inheritDoc */
+  getAllowedTags() {
+    return ['UL', 'OL', 'LI'];
+  }
+  /** @inheritDoc */
+  getAllowedAttributes() {
+    return new Map();
+  }
+  /** @inheritDoc */
+  getAllowedStyles() {
+    return ['list-style'];
+  }
+  /**
+   * Moves any `<ol>` / `<ul>` that appears as a direct child of another
+   * `<ol>` / `<ul>` into the preceding `<li>` sibling, so downstream strategies
+   * see a well-formed nested list. Word emits this invalid shape when it uses
+   * real list elements (rather than flat `mso-list` paragraphs) — the browser
+   * parser keeps the nested list as a sibling of the `<li>` it should belong
+   * to, and the RTE's OL/UL block strategy would drop it because its
+   * `appendChildBlocks` only keeps `<li>` children.
+   *
+   * Runs bottom-up so a nested list that also has misplaced children is fixed
+   * before its own parent list picks it up.
+   *
+   * @param {HTMLElement} root Parsed body element.
+   */
+  nestSiblingLists(root) {
+    const lists = Array.from(root.querySelectorAll('ol, ul'));
+    for (let index = lists.length - 1; index >= 0; index--) {
+      Array.from(lists[index].children).forEach((child) => {
+        if (child.tagName !== 'OL' && child.tagName !== 'UL') {
+          return;
+        }
+        const previousItem = child.previousElementSibling;
+        if (previousItem && previousItem.tagName === 'LI') {
+          previousItem.appendChild(child);
+        }
+      });
+    }
+  }
+  /**
+   * Converts the HTML `<ol type>` attribute into a preserved
+   * `list-style-type` declaration for every ordered list that carries one.
+   *
+   * Word can paste genuine `<ol>` elements (rather than flat list paragraphs)
+   * that encode alpha / Roman numbering via the legacy `type` attribute
+   * (`type=a`, `type=i`, `type=I`, …). The `type` attribute is not on the
+   * allowlist and would be dropped, losing the numbering style, so it is mapped
+   * onto `list-style-type` inside `data-style`. Decimal (`type=1`) lists are
+   * left untouched because a bare `<ol>` already renders as `1. 2. 3.`. An
+   * existing `list-style-type` declaration wins and is never overwritten.
+   *
+   * @param {HTMLElement} root Parsed body element.
+   */
+  applyOrderedListTypeAttributes(root) {
+    Array.from(root.querySelectorAll('ol[type]')).forEach((orderedList) => {
+      const type = orderedList.getAttribute('type') || '';
+      const listStyleType = OL_TYPE_TO_LIST_STYLE_TYPE[type];
+      if (!listStyleType) {
+        return;
+      }
+      const style = orderedList.getAttribute('data-style') || '';
+      if (LIST_STYLE_TYPE_PATTERN.test(style)) {
+        return;
+      }
+      const prefix = style.trim() === '' ? '' : `${style.replace(/;\s*$/, '')}; `;
+      orderedList.setAttribute('data-style', `${prefix}list-style-type: ${listStyleType}`);
+    });
+  }
+  /**
+   * Walks a container, folding each contiguous run of Word list paragraphs
+   * into a nested list tree in place of the original paragraphs.
+   *
+   * @param {HTMLElement} container Element whose direct children may include list paragraphs.
+   */
+  processContainer(container) {
+    const children = Array.from(container.children);
+    let index = 0;
+    while (index < children.length) {
+      if (!this.isWordListParagraph(children[index])) {
+        index++;
+        continue;
+      }
+      const run = [];
+      while (index < children.length && this.isWordListParagraph(children[index])) {
+        run.push(children[index]);
+        index++;
+      }
+      this.transformRun(run, container);
+    }
+  }
+  /**
+   * Determines whether an element is a Word list paragraph.
+   *
+   * A paragraph is only treated as a list when it carries a genuine Word list
+   * marker: either the `mso-list:l<n>` paragraph style, or the `MsoListParagraph`
+   * class **together with** an inner `mso-list:Ignore` marker span. The
+   * `MsoListParagraph` class alone is not sufficient — Word also uses that
+   * paragraph style for plain indented content (e.g. headings), which must not
+   * be folded into a `<ul>` / `<ol>`.
+   *
+   * @param {HTMLElement} element Candidate element.
+   * @returns {boolean} `true` when the element is a `<p>` carrying a Word list marker.
+   */
+  isWordListParagraph(element) {
+    if (element.tagName !== 'P') {
+      return false;
+    }
+    const style = element.getAttribute('data-style') || '';
+    if (PARAGRAPH_LIST_PATTERN.test(style)) {
+      return true;
+    }
+    const className = element.getAttribute('class') || '';
+    return LIST_PARAGRAPH_CLASS_PATTERN.test(className) && this.findMarker(element) !== undefined;
+  }
+  /**
+   * Folds a flat run of Word list paragraphs into a nested list tree inserted
+   * before the run, then removes the original paragraphs.
+   *
+   * @param {HTMLElement[]} run Consecutive Word list paragraphs.
+   * @param {HTMLElement} container Element hosting the run.
+   */
+  transformRun(run, container) {
+    const anchor = run[0];
+    const stack = [];
+    run.forEach((paragraph) => {
+      // Compute the marker once per paragraph and thread it through the
+      // helpers that need it, so the DOM is not re-queried multiple times.
+      const marker = this.findMarker(paragraph);
+      const level = this.resolveLevel(paragraph);
+      const ordered = marker ? this.isOrderedMarker(marker, paragraph) : false;
+      const listId = this.resolveListId(paragraph);
+      // Close any lists deeper than the current item.
+      while (stack.length > 0 && stack[stack.length - 1].level > level) {
+        stack.pop();
+      }
+      // Resolve the marker style with the same-level list already open in
+      // context, so an ambiguous lone "i" / "I" continues an alpha list
+      // instead of being misread as Roman 1. The marker text is still on the
+      // paragraph here (buildListItem strips it below).
+      let top = stack[stack.length - 1];
+      const listStyleType = ordered && marker ? this.resolveListStyleType(marker, top, level, listId) : null;
+      const listItem = this.buildListItem(paragraph, marker);
+      if (!top || top.level < level) {
+        top = this.openNestedList(stack, container, anchor, ordered, level, listStyleType, listId);
+      }
+      else if (this.needsSiblingList(top, ordered, listStyleType, listId)) {
+        top = this.openSiblingList(stack, ordered, level, listStyleType, listId);
+      }
+      top.listEl.appendChild(listItem);
+    });
+    run.forEach((paragraph) => paragraph.remove());
+  }
+  /**
+   * Reports whether a same-level item must break out into a new sibling list.
+   * A different Word list instance always splits (so two separate lists pasted
+   * back-to-back keep independent numbering). Bullet-vs-numbered switches also
+   * split, and numbered lists additionally split when the CSS `list-style-type`
+   * changes (e.g. `1.` → `a)`).
+   *
+   * @param {OpenList} top Currently open list at the same nesting depth.
+   * @param {boolean} ordered Whether the incoming item is numbered.
+   * @param {string | null} listStyleType Incoming numbered list style, if any.
+   * @param {string | null} listId Incoming Word list instance id, if any.
+   * @returns {boolean} `true` when a new sibling list should be opened.
+   */
+  needsSiblingList(top, ordered, listStyleType, listId) {
+    // A known change of list instance means the two runs are distinct lists.
+    if (top.listId !== null && listId !== null && top.listId !== listId) {
+      return true;
+    }
+    if (top.ordered !== ordered) {
+      return true;
+    }
+    if (!ordered) {
+      return false;
+    }
+    return this.readListStyleType(top.listEl) !== listStyleType;
+  }
+  /**
+   * Reads a previously-written `list-style-type` from an open list element.
+   *
+   * @param {HTMLElement} listEl List element.
+   * @returns {string | null} The style value, or `null` when none is set.
+   */
+  readListStyleType(listEl) {
+    const match = LIST_STYLE_TYPE_PATTERN.exec(listEl.getAttribute('data-style') || '');
+    return match ? match[1].trim() : null;
+  }
+  /**
+   * Opens a new list nested one or more levels deeper than the current top.
+   * Word occasionally skips indent levels on paste (e.g. jumping from `level1`
+   * to `level3`); this walks the gap one level at a time, inserting placeholder
+   * lists so the deeper list is nested through empty `<li>` anchors instead of
+   * appearing as a sibling of the shallower list.
+   *
+   * @param {OpenList[]} stack Stack of currently open lists.
+   * @param {HTMLElement} container Host element for the top-level list.
+   * @param {HTMLElement} anchor Element the top-level list is inserted before.
+   * @param {boolean} ordered Whether the new list is numbered.
+   * @param {number} level Word nesting depth for the new list.
+   * @param {string | null} listStyleType CSS `list-style-type` for ordered lists.
+   * @param {string | null} listId Word list instance id for the new list.
+   * @returns {OpenList} The newly opened list.
+   */
+  openNestedList(stack, container, anchor, ordered, level, listStyleType, listId) {
+    let currentTop = stack[stack.length - 1];
+    let currentLevel = currentTop ? currentTop.level : 0;
+    while (currentLevel < level - 1) {
+      const bridge = this.createListElement(container, ordered, null);
+      this.attachList(bridge, currentTop, container, anchor);
+      // Empty `<li>` anchor so the next deeper list can be nested inside it.
+      bridge.appendChild(bridge.ownerDocument.createElement('li'));
+      stack.push({ level: currentLevel + 1, ordered, listId, listEl: bridge });
+      currentTop = stack[stack.length - 1];
+      currentLevel = currentTop.level;
+    }
+    const parent = stack[stack.length - 1];
+    const listEl = this.createListElement(container, ordered, listStyleType);
+    this.attachList(listEl, parent, container, anchor);
+    const opened = { level, ordered, listId, listEl };
+    stack.push(opened);
+    return opened;
+  }
+  /**
+   * Replaces the current top list with a sibling list at the same nesting
+   * depth. Used when the list flavor (bullet vs. numbered, or the ordered
+   * marker style) flips between two consecutive same-level items.
+   *
+   * @param {OpenList[]} stack Stack of currently open lists.
+   * @param {boolean} ordered Whether the sibling list is numbered.
+   * @param {number} level Word nesting depth for the sibling list.
+   * @param {string | null} listStyleType CSS `list-style-type` for ordered lists.
+   * @param {string | null} listId Word list instance id for the sibling list.
+   * @returns {OpenList} The newly opened sibling list.
+   */
+  openSiblingList(stack, ordered, level, listStyleType, listId) {
+    const current = stack[stack.length - 1];
+    const listEl = this.createListElement(current.listEl, ordered, listStyleType);
+    const parentNode = current.listEl.parentNode;
+    if (parentNode) {
+      parentNode.insertBefore(listEl, current.listEl.nextSibling);
+    }
+    stack.pop();
+    const opened = { level, ordered, listId, listEl };
+    stack.push(opened);
+    return opened;
+  }
+  /**
+   * Attaches a freshly created list element either inside the last item of the
+   * parent list (for nested lists) or before the run anchor (top-level lists).
+   *
+   * @param {HTMLElement} listEl List element to attach.
+   * @param {OpenList | undefined} parent Currently open parent list, if any.
+   * @param {HTMLElement} container Host element used for top-level insertion.
+   * @param {HTMLElement} anchor Element the top-level list is inserted before.
+   */
+  attachList(listEl, parent, container, anchor) {
+    if (parent) {
+      const parentItem = parent.listEl.lastElementChild;
+      (parentItem || parent.listEl).appendChild(listEl);
+    }
+    else {
+      container.insertBefore(listEl, anchor);
+    }
+  }
+  /**
+   * Creates an empty `<ol>` or `<ul>` element, tagging ordered lists with a
+   * `list-style-type` when their markers are not plain decimals.
+   *
+   * @param {HTMLElement} reference Element whose document creates the list.
+   * @param {boolean} ordered Whether to create a numbered list.
+   * @param {string | null} listStyleType CSS `list-style-type` for ordered lists.
+   * @returns {HTMLElement} The new list element.
+   */
+  createListElement(reference, ordered, listStyleType) {
+    const listEl = reference.ownerDocument.createElement(ordered ? 'ol' : 'ul');
+    if (ordered && listStyleType) {
+      // Styles are preserved as `data-style` across the DOMParser boundary and
+      // restored to `style` after the allowlist pass.
+      listEl.setAttribute('data-style', `list-style-type: ${listStyleType}`);
+    }
+    return listEl;
+  }
+  /**
+   * Converts a Word list paragraph into an `<li>` element: the marker span is
+   * removed and the remaining content is moved into the list item.
+   *
+   * @param {HTMLElement} paragraph Word list paragraph.
+   * @param {HTMLElement | undefined} marker Pre-resolved `mso-list:Ignore` span.
+   * @returns {HTMLLIElement} The populated list item.
+   */
+  buildListItem(paragraph, marker) {
+    const listItem = paragraph.ownerDocument.createElement('li');
+    if (marker) {
+      this.preserveMarkerPlaceholderImages(marker, paragraph);
+      this.removeMarker(marker, paragraph);
+    }
+    while (paragraph.firstChild) {
+      listItem.appendChild(paragraph.firstChild);
+    }
+    return listItem;
+  }
+  /**
+   * Moves any local (`file://`) images out of the marker span so they survive
+   * marker removal as list-item placeholders.
+   *
+   * Word renders a picture bullet as an `<img>` inside the `mso-list:Ignore`
+   * marker span. That bullet still occupies one image slot in the clipboard RTF,
+   * so silently dropping it here would leave its RTF blip unconsumed and shift
+   * every following image onto the wrong file. Keeping the bullet as a `file://`
+   * placeholder inside the `<li>` lets downstream preview pairing consume its RTF
+   * slot and then drop it (list images have no editor representation), keeping the
+   * remaining images aligned with their files. Non-local bullet images have no RTF
+   * counterpart and are left in the marker to be removed with it.
+   *
+   * @param {HTMLElement} marker Marker span holding the bullet glyph / image.
+   * @param {HTMLElement} paragraph Owning list paragraph (placeholder host).
+   */
+  preserveMarkerPlaceholderImages(marker, paragraph) {
+    const localImages = Array.from(marker.querySelectorAll('img')).filter((image) => (image.getAttribute('src') || '').startsWith('file://'));
+    // Capture the original first child once so images land ahead of the list
+    // content in their document order (repeated inserts before a stable anchor).
+    const anchor = paragraph.firstChild;
+    localImages.forEach((image) => {
+      paragraph.insertBefore(image, anchor);
+    });
+  }
+  /**
+   * Removes the `mso-list:Ignore` marker span and any wrapper elements it
+   * leaves empty behind.
+   *
+   * @param {HTMLElement} marker Marker span to remove.
+   * @param {HTMLElement} paragraph Owning list paragraph (stop boundary).
+   */
+  removeMarker(marker, paragraph) {
+    let current = marker;
+    while (current !== paragraph) {
+      const parent = current.parentElement;
+      current.remove();
+      if (!parent || parent === paragraph || !this.isEmptyElement(parent)) {
+        break;
+      }
+      current = parent;
+    }
+  }
+  /**
+   * Finds the `mso-list:Ignore` marker span within a list paragraph.
+   *
+   * @param {HTMLElement} paragraph Word list paragraph.
+   * @returns {HTMLElement | undefined} The marker span, if present.
+   */
+  findMarker(paragraph) {
+    return Array.from(paragraph.querySelectorAll('span')).find((span) => LIST_IGNORE_PATTERN.test(span.getAttribute('data-style') || ''));
+  }
+  /**
+   * Reports whether an element has no meaningful (non-whitespace) content left.
+   *
+   * @param {HTMLElement} element Element to inspect.
+   * @returns {boolean} `true` when only whitespace remains.
+   */
+  isEmptyElement(element) {
+    return (element.textContent || '').replace(/[\s\u00A0]/g, '') === '';
+  }
+  /**
+   * Resolves the Word nesting depth for a list paragraph (defaults to 1).
+   *
+   * @param {HTMLElement} paragraph Word list paragraph.
+   * @returns {number} One-based nesting depth.
+   */
+  resolveLevel(paragraph) {
+    const style = paragraph.getAttribute('data-style') || '';
+    const match = LIST_LEVEL_PATTERN.exec(style);
+    return match ? parseInt(match[1], 10) : 1;
+  }
+  /**
+   * Resolves the Word list instance id for a paragraph. Prefers the list-format
+   * override (`lfo<n>`), which is unique per pasted list, and falls back to the
+   * abstract list template id (`l<n>`). Returns `null` when neither is present
+   * (e.g. the `MsoListParagraph` class fallback).
+   *
+   * @param {HTMLElement} paragraph Word list paragraph.
+   * @returns {string | null} The list instance id, or `null` when unknown.
+   */
+  resolveListId(paragraph) {
+    const style = paragraph.getAttribute('data-style') || '';
+    const override = LIST_OVERRIDE_ID_PATTERN.exec(style);
+    if (override) {
+      return `lfo${override[1]}`;
+    }
+    const template = LIST_TEMPLATE_ID_PATTERN.exec(style);
+    return template ? `l${template[1]}` : null;
+  }
+  /**
+   * Decides whether a resolved marker span represents a numbered (`<ol>`) or
+   * bulleted (`<ul>`) item based on its text and font.
+   *
+   * @param {HTMLElement} marker Marker span.
+   * @param {HTMLElement} paragraph Owning list paragraph.
+   * @returns {boolean} `true` for numbered items, `false` for bulleted items.
+   */
+  isOrderedMarker(marker, paragraph) {
+    const markerText = marker.textContent.replace(/[\s\u00A0]/g, '');
+    if (BULLET_FONT_PATTERN.test(this.resolveMarkerFont(marker, paragraph))) {
+      return false;
+    }
+    // Numbered markers are alphanumeric sequences ("1.", "a)", "iv)");
+    // bullet markers are standalone symbols.
+    return /[0-9]/.test(markerText) || /^[a-z]+[.)]/i.test(markerText);
+  }
+  /**
+   * Resolves the CSS `list-style-type` for a numbered list marker.
+   * Plain decimal markers ("1.", "2.") return `null` so a bare `<ol>` is used;
+   * alphabetic and Roman markers map to the matching CSS value so their marker
+   * style is preserved.
+   *
+   * A lone `i` / `I` is ambiguous: it is both Roman numeral 1 and the 9th
+   * letter of the alphabet. When the same-level list already open for this
+   * instance is alpha, the marker is kept alpha so a long `a) ... h) i) j)`
+   * run does not split into a Roman sibling at item 9; otherwise the lone
+   * marker is treated as Roman 1 (the first item of a Roman list).
+   *
+   * @param {HTMLElement} marker Marker span.
+   * @param {OpenList | undefined} openList Same-depth list already open, if any.
+   * @param {number} level Word nesting depth of the incoming item.
+   * @param {string | null} listId Word list instance id of the incoming item.
+   * @returns {string | null} The CSS `list-style-type`, or `null` for decimals.
+   */
+  resolveListStyleType(marker, openList, level, listId) {
+    // Drop surrounding whitespace and the trailing "." / ")" separator to
+    // isolate the numbering token (e.g. "a)" -> "a", "iv." -> "iv").
+    const token = marker.textContent.replace(/[\s\u00A0]/g, '').replace(/[.)]+$/, '');
+    if (DECIMAL_PATTERN.test(token)) {
+      return null;
+    }
+    // Disambiguate a lone "i" / "I" from list context before the Roman check:
+    // if the current same-level list is already alpha, continue it.
+    if (token === 'i' || token === 'I') {
+      const alphaStyle = token === 'i' ? 'lower-alpha' : 'upper-alpha';
+      if (this.continuesAlphaList(openList, level, listId, alphaStyle)) {
+        return alphaStyle;
+      }
+    }
+    // Roman tokens are checked before alpha so "i" / "I" (Roman numeral 1) and
+    // multi-character sequences like "ii" / "IV" are not mistaken for letters.
+    if (LOWER_ROMAN_PATTERN.test(token)) {
+      return 'lower-roman';
+    }
+    if (UPPER_ROMAN_PATTERN.test(token)) {
+      return 'upper-roman';
+    }
+    if (LOWER_ALPHA_PATTERN.test(token)) {
+      return 'lower-alpha';
+    }
+    if (UPPER_ALPHA_PATTERN.test(token)) {
+      return 'upper-alpha';
+    }
+    return null;
+  }
+  /**
+   * Reports whether a lone `i` / `I` marker continues an already-open alpha
+   * list rather than starting a Roman one. True only when the same-depth list
+   * is a matching alpha `<ol>` for the same Word list instance, so an ambiguous
+   * marker at item 9 stays part of the surrounding `lower-alpha` / `upper-alpha`
+   * run instead of opening a Roman sibling.
+   *
+   * @param {OpenList | undefined} openList Same-depth list already open, if any.
+   * @param {number} level Word nesting depth of the incoming item.
+   * @param {string | null} listId Word list instance id of the incoming item.
+   * @param {string} alphaStyle The alpha style the marker would continue.
+   * @returns {boolean} `true` when the marker should be treated as alpha.
+   */
+  continuesAlphaList(openList, level, listId, alphaStyle) {
+    if (!openList || !openList.ordered || openList.level !== level) {
+      return false;
+    }
+    // Distinct Word list instances are separate lists; do not carry style over.
+    if (openList.listId !== null && listId !== null && openList.listId !== listId) {
+      return false;
+    }
+    return this.readListStyleType(openList.listEl) === alphaStyle;
+  }
+  /**
+   * Resolves the effective `font-family` for a marker by walking up to the
+   * paragraph, so Word's `Symbol` / `Wingdings` bullet fonts can be detected.
+   *
+   * @param {HTMLElement} marker Marker span.
+   * @param {HTMLElement} paragraph Owning list paragraph.
+   * @returns {string} The resolved font family, or an empty string.
+   */
+  resolveMarkerFont(marker, paragraph) {
+    let node = marker;
+    while (node && node !== paragraph.parentElement) {
+      const match = FONT_FAMILY_PATTERN.exec(node.getAttribute('data-style') || '');
+      if (match) {
+        return match[1];
+      }
+      node = node.parentElement;
+    }
+    return '';
+  }
+}
+
+/**
+ * Normalizes Word image markup into plain <img> tags, drops list-marker images,
+ * and optionally remaps image source paths.
+ */
+class WordImageTransformer {
+  /** @inheritDoc */
+  getAllowedTags() {
+    return ['IMG'];
+  }
+  /** @inheritDoc */
+  getAllowedAttributes() {
+    return new Map([['IMG', ['src', 'alt', 'title', 'width', 'height']]]);
+  }
+  /** @inheritDoc */
+  getAllowedStyles() {
+    return [];
+  }
+  /** @inheritDoc */
+  apply(root) {
+    this.normalizeWordImageDataElements(root);
+    this.normalizeStandardImages(root);
+    this.liftImagesOutOfTextStyleBlocks(root);
+    this.insertSpanBetweenAdjacentImages(root);
+  }
+  /**
+   * Lifts images out of text-style blocks (`h1`-`h6`, Word title / subtitle
+   * paragraphs) so they become standalone top-level images.
+   *
+   * The RTE data model represents these blocks as text blocks whose children
+   * are text nodes only, so an `<img>` nested inside one has no text-node
+   * representation and would be silently dropped during DTO conversion. Moving
+   * each image to a sibling position right after its block lets the downstream
+   * image-block strategies pick it up. Images are re-inserted in document order
+   * so they stay aligned with the RTF files paired later.
+   *
+   * Word title / subtitle paragraphs still carry their raw `MsoTitle` /
+   * `MsoSubtitle` class here because {@link WordParagraphRoleTransformer} runs
+   * after this transformer.
+   *
+   * @param {HTMLElement} root Parsed Word fragment root.
+   */
+  liftImagesOutOfTextStyleBlocks(root) {
+    const blockElements = Array.from(root.querySelectorAll('h1, h2, h3, h4, h5, h6, p')).filter((element) => this.isImageLiftTargetBlock(element));
+    blockElements.forEach((blockElement) => {
+      if (!blockElement.parentNode) {
+        return;
+      }
+      const imageElements = Array.from(blockElement.querySelectorAll('img'));
+      let referenceNode = blockElement;
+      imageElements.forEach((imageElement) => {
+        blockElement.parentNode.insertBefore(imageElement, referenceNode.nextSibling);
+        referenceNode = imageElement;
+      });
+    });
+  }
+  /**
+   * Reports whether a block hosts its images as text-only children, requiring
+   * nested images to be lifted out: any heading (`h1`-`h6`) or a Word title /
+   * subtitle paragraph.
+   *
+   * @param {HTMLElement} element Candidate block element.
+   * @returns {boolean} `true` when nested images must be lifted out of the block.
+   */
+  isImageLiftTargetBlock(element) {
+    const tagName = element.tagName.toLowerCase();
+    if (/^h[1-6]$/.test(tagName)) {
+      return true;
+    }
+    if (tagName === 'p') {
+      const className = (element.getAttribute('class') || '').toLowerCase();
+      return /msotitle/.test(className) || /msosubtitle/.test(className);
+    }
+    return false;
+  }
+  /**
+   * Converts Word VML `v:imagedata` elements to plain `<img>` elements.
+   *
+   * @param {HTMLElement} root Parsed Word fragment root.
+   */
+  normalizeWordImageDataElements(root) {
+    const imageDataElements = Array.from(root.querySelectorAll('v\\:imagedata, imagedata'));
+    imageDataElements.forEach((imageDataElement) => {
+      const src = imageDataElement.getAttribute('src') ||
+        imageDataElement.getAttribute('o:href') ||
+        imageDataElement.getAttribute('href') ||
+        '';
+      const alt = imageDataElement.getAttribute('alt') ||
+        imageDataElement.getAttribute('o:title') ||
+        imageDataElement.getAttribute('title') ||
+        '';
+      const wrapperElement = imageDataElement.closest('v\\:shape, shape') || imageDataElement;
+      if (!src) {
+        wrapperElement.remove();
+        return;
+      }
+      // Non-local list images have no RTF counterpart, so drop them now. Local
+      // (file://) list images are kept as placeholders and removed later during
+      // preview pairing so the image order stays aligned with the RTF files.
+      if (this.isListImage(wrapperElement) && !src.startsWith('file://')) {
+        wrapperElement.remove();
+        return;
+      }
+      const imageElement = root.ownerDocument.createElement('img');
+      imageElement.setAttribute('src', src);
+      if (alt) {
+        imageElement.setAttribute('alt', alt);
+      }
+      if (wrapperElement.parentNode) {
+        const shapeId = wrapperElement.getAttribute('id') || '';
+        if (shapeId) {
+          this.removeFallbackImagesForShapeId(root, shapeId);
+        }
+        wrapperElement.parentNode.insertBefore(imageElement, wrapperElement);
+        wrapperElement.parentNode.removeChild(wrapperElement);
+      }
+    });
+  }
+  /**
+   * Removes non-VML fallback images that reference a specific Word VML shape id.
+   *
+   * Word clipboard HTML often includes both `v:imagedata` and an `<img v:shapes="...">`
+   * fallback for the same visual image. Once VML is normalized, the fallback must
+   * be removed to avoid duplicated image handling.
+   *
+   * @param {HTMLElement} root Parsed Word fragment root.
+   * @param {string} shapeId VML shape id referenced by fallback images.
+   */
+  removeFallbackImagesForShapeId(root, shapeId) {
+    const imageElements = Array.from(root.querySelectorAll('img'));
+    imageElements.forEach((imageElement) => {
+      const referencedShapeId = imageElement.getAttribute('v:shapes') || imageElement.getAttribute('shapes') || '';
+      if (referencedShapeId === shapeId) {
+        imageElement.remove();
+      }
+    });
+  }
+  /**
+   * Removes list-marker images and sourceless `<img>` elements.
+   *
+   * @param {HTMLElement} root Parsed Word fragment root.
+   */
+  normalizeStandardImages(root) {
+    const imageElements = Array.from(root.querySelectorAll('img'));
+    imageElements.forEach((imageElement) => {
+      const src = imageElement.getAttribute('src') || '';
+      if (this.isListImage(imageElement)) {
+        // Non-local list images have no RTF counterpart, so drop them now. Local
+        // (file://) list images are kept as placeholders and removed later during
+        // preview pairing so the image order stays aligned with the RTF files.
+        if (!src.startsWith('file://')) {
+          imageElement.remove();
+        }
+        return;
+      }
+      if (!src) {
+        imageElement.remove();
+      }
+    });
+  }
+  /**
+   * Inserts an empty `<span> </span>` between adjacent images to avoid
+   * downstream image-block parsing treating a compact image run as a single image.
+   *
+   * @param {HTMLElement} root Parsed Word fragment root.
+   */
+  insertSpanBetweenAdjacentImages(root) {
+    const imageElements = Array.from(root.querySelectorAll('img'));
+    imageElements.forEach((imageElement) => {
+      if (!imageElement.parentNode) {
+        return;
+      }
+      const nextSibling = imageElement.nextSibling;
+      if (nextSibling &&
+        nextSibling.nodeType === Node.ELEMENT_NODE &&
+        nextSibling.tagName.toLowerCase() === 'img') {
+        const spacerElement = root.ownerDocument.createElement('span');
+        spacerElement.innerHTML = ' ';
+        imageElement.parentNode.insertBefore(spacerElement, nextSibling);
+      }
+    });
+  }
+  /**
+   * Currently the RTE does not support list images, so they must be removed from the paste content.
+   * Local (file://) list images are kept as placeholders here and removed later during preview pairing
+   * so the local images stay aligned with the RTF images; non-local list images are removed immediately.
+   * Returns true when the image is part of list content and should be ignored.
+   *
+   * Word list markup (`MsoListParagraph` / `mso-list`) is already normalized into
+   * real `li/ul/ol` by {@link WordListRoleTransformer}, which runs before this
+   * transformer, so a plain list-ancestor check is sufficient here.
+   *
+   * @param {Element} element Image element (or its wrapper).
+   * @returns {boolean} Whether this image belongs to list content.
+   */
+  isListImage(element) {
+    return Boolean(element.closest('li,ul,ol'));
+  }
+}
+
+/**
+ * Attribute that carries inline styles after `StylePreservator` renamed `style`
+ * to `data-style`. All style reads/writes in Phase 1 target this name so the
+ * declarations survive the CSP-sensitive `DOMParser` boundary (mirrors the
+ * handling in {@link WordListRoleTransformer}).
+ */
+const PRESERVED_STYLE_ATTR$1 = 'data-style';
+/** Table structural tags Word decorates with `Mso*` class artifacts. */
+const TABLE_SECTION_SELECTOR = 'thead, tbody, tfoot, caption, tr';
+/**
+ * Table containers whose direct text children are always layout whitespace.
+ * Word exports newlines and indentation between structural tags; those text
+ * nodes are not valid table content and must be dropped so they do not surface
+ * as stray spaces in the pasted table.
+ */
+const TABLE_CONTAINER_SELECTOR = 'thead, tbody, tfoot, tr';
+/** Cell tags that may carry Word presentational attributes and span markers. */
+const TABLE_CELL_SELECTOR = 'td, th';
+/**
+ * Block-level tags that mark a cell as containing block content. When a cell
+ * holds one of these, any whitespace-only text node sitting beside it is Word
+ * indentation (layout whitespace) rather than meaningful inline text.
+ */
+const CELL_BLOCK_CHILD_TAGS = new Set([
+  'P',
+  'DIV',
+  'UL',
+  'OL',
+  'LI',
+  'H1',
+  'H2',
+  'H3',
+  'H4',
+  'H5',
+  'H6',
+  'TABLE',
+  'BLOCKQUOTE',
+  'PRE',
+]);
+/** Span attributes whose value must be a positive integer greater than one. */
+const SPAN_ATTRIBUTES = ['colspan', 'rowspan'];
+/** Strict span values Word should emit after normalization. */
+const SPAN_VALUE_PATTERN = /^\d+$/;
+/**
+ * Matches the border box-model declarations (shorthand, per-side, and the
+ * width/style/color long-hands) that Word writes with point/centimeter units
+ * and system color keywords the RTE table model cannot parse. Word also emits
+ * per-side `border-*: none` resets to avoid double borders in its own layout,
+ * which would leave the pasted table with inconsistent cell borders. All of
+ * these are removed so the editor applies its uniform default border.
+ * `border-collapse` / `border-spacing` are intentionally excluded so table
+ * collapsing is preserved.
+ */
+const BORDER_BOX_STYLE_PATTERN = /^border(-(top|right|bottom|left))?(-(width|style|color))?$/;
+/**
+ * Matches padding declarations (shorthand and per-side) that Word writes with
+ * point/centimeter units the RTE cannot parse. Removed so the editor applies
+ * its default cell padding.
+ */
+const PADDING_STYLE_PATTERN = /^padding(-(top|right|bottom|left))?$/;
+/**
+ * Matches the standalone `width` declaration (not `min-width` / `max-width`).
+ * Word writes cell widths in points, so the point-based declaration is removed
+ * and replaced with the clean pixel value carried by the `width` attribute.
+ */
+const WIDTH_STYLE_PATTERN = /^width$/;
+/** Numeric zero (with optional decimal and optional unit suffix). */
+const ZERO_LENGTH_PATTERN = /^0+(\.0+)?([a-z%]+)?$/i;
+/**
+ * Maps Word cell presentational attributes onto the CSS declarations the RTE
+ * table cell annotation understands. These attributes are not on the paste
+ * allowlist, so migrating them into `data-style` is the only way to preserve
+ * the author's intent (shading, alignment) through sanitization. Only
+ * properties whose prefix is retained by the sanitizer are migrated, so
+ * fixed-width/height artifacts are intentionally dropped.
+ */
+const CELL_ATTRIBUTE_STYLE_MAP = [
+  // eslint-disable-next-line spellcheck/spell-checker
+  { attribute: 'valign', property: 'vertical-align' },
+  { attribute: 'align', property: 'text-align' },
+  // eslint-disable-next-line spellcheck/spell-checker
+  { attribute: 'bgcolor', property: 'background-color' },
+];
+/**
+ * Normalizes Microsoft Word table markup into clean, RTE-friendly tables.
+ *
+ * Word emits real `<table>/<tr>/<td>` elements, so the paste allowlist already
+ * keeps the structure. What it cannot fix is the Word-specific decoration that
+ * rides along:
+ * - `Mso*` class names (e.g. `MsoTableGrid`) survive because `class` is globally
+ *   allowed; they are Word artifacts and must not leak into the output.
+ * - Cell shading and alignment live in presentational attributes (`bgcolor`,
+ *   `align`, `valign`) that the allowlist strips, losing the formatting; they
+ *   are migrated into `data-style` so the RTE cell annotation can read them.
+ * - `colspan`/`rowspan` may carry redundant `1` values or non-numeric junk that
+ *   is normalized so span tables map cleanly onto the RTE table model.
+ * - Table and cell borders/padding are written with point/centimeter units,
+ *   system color keywords, and per-side `border-*: none` resets that the RTE
+ *   cannot parse and that render inconsistent borders; they are stripped so the
+ *   editor applies its uniform default border and padding.
+ * - Cell widths arrive both as a point-based `width` style (which the RTE cannot
+ *   parse) and a pixel `width` attribute; the point style is dropped and the
+ *   attribute is migrated into a clean pixel `width` declaration.
+ */
+class WordTableTransformer {
+  /** @inheritDoc */
+  apply(root) {
+    Array.from(root.querySelectorAll('table')).forEach((table) => this.normalizeTable(table));
+  }
+  /** @inheritDoc */
+  getAllowedTags() {
+    return ['TABLE', 'THEAD', 'TBODY', 'TR', 'TH', 'TD', 'CAPTION'];
+  }
+  /** @inheritDoc */
+  getAllowedAttributes() {
+    return new Map([
+      ['TD', ['colspan', 'rowspan']],
+      ['TH', ['colspan', 'rowspan']],
+    ]);
+  }
+  /** @inheritDoc */
+  getAllowedStyles() {
+    return ['border', 'width'];
+  }
+  /**
+   * Strips Word class artifacts from a table and its structural descendants,
+   * then normalizes every cell's span attributes and presentational styling.
+   *
+   * @param {HTMLTableElement} table Word table element to normalize in place.
+   */
+  normalizeTable(table) {
+    this.removeStructuralWhitespace(table);
+    this.stripClass(table);
+    this.removeBorderAndPaddingStyles(table);
+    Array.from(table.querySelectorAll(TABLE_SECTION_SELECTOR)).forEach((section) => this.stripClass(section));
+    this.removeHiddenMisalignedCells(table);
+    this.mergeFooterIntoBody(table);
+    this.promoteHeadCells(table);
+    Array.from(table.querySelectorAll(TABLE_CELL_SELECTOR)).forEach((cell) => {
+      this.removeCellLayoutWhitespace(cell);
+      this.stripClass(cell);
+      this.normalizeSpanAttributes(cell);
+      this.migrateCellAttributes(cell);
+      this.migrateCellWidth(cell);
+      this.removeBorderAndPaddingStyles(cell);
+    });
+  }
+  /**
+   * Removes Word's hidden `!supportMisalignedRows` placeholder cell. Word
+   * appends it as a zero-width trailing cell to keep legacy layout engines
+   * aligned, but it is not real content and should not survive paste as an
+   * extra visible column. Only the row's last cell is considered so an
+   * intentional interior zero-width cell is never dropped, and only rows that
+   * belong to this table (not a nested one) are touched.
+   *
+   * @param {HTMLTableElement} table Word table element.
+   */
+  removeHiddenMisalignedCells(table) {
+    Array.from(table.querySelectorAll('tr'))
+      .filter((row) => this.isRowOfTable(table, row))
+      .forEach((row) => {
+      const lastCell = row.lastElementChild;
+      if (lastCell &&
+        (lastCell.tagName === 'TD' || lastCell.tagName === 'TH') &&
+        this.isHiddenMisalignedCell(lastCell)) {
+        row.removeChild(lastCell);
+      }
+    });
+  }
+  /**
+   * Reports whether a row belongs directly to the given table rather than to a
+   * nested table, so the recursive `tr` query never reaches into a child table.
+   *
+   * @param {HTMLTableElement} table Table being normalized.
+   * @param {HTMLTableRowElement} row Row to test.
+   * @returns {boolean} `true` when the row's nearest ancestor table is `table`.
+   */
+  isRowOfTable(table, row) {
+    let ancestor = row.parentElement;
+    while (ancestor && ancestor.tagName !== 'BODY') {
+      if (ancestor.tagName === 'TABLE') {
+        return ancestor === table;
+      }
+      ancestor = ancestor.parentElement;
+    }
+    return false;
+  }
+  /**
+   * Detects Word's hidden misaligned-row placeholder cell.
+   *
+   * @param {HTMLTableCellElement} cell Cell to inspect.
+   * @returns {boolean} `true` when the cell is a hidden placeholder.
+   */
+  isHiddenMisalignedCell(cell) {
+    if (this.hasExplicitSpan(cell)) {
+      return false;
+    }
+    if (!this.hasZeroWidthMarker(cell)) {
+      return false;
+    }
+    return !this.hasMeaningfulCellContent(cell);
+  }
+  /**
+   * Reports whether a cell explicitly spans rows/columns.
+   *
+   * @param {HTMLTableCellElement} cell Cell to inspect.
+   * @returns {boolean} `true` when colspan/rowspan is present.
+   */
+  hasExplicitSpan(cell) {
+    return SPAN_ATTRIBUTES.some((attribute) => cell.hasAttribute(attribute));
+  }
+  /**
+   * Reports whether a cell is explicitly marked with zero width via attribute
+   * or preserved inline style.
+   *
+   * @param {HTMLTableCellElement} cell Cell to inspect.
+   * @returns {boolean} `true` when width is explicitly zero.
+   */
+  hasZeroWidthMarker(cell) {
+    const widthAttribute = cell.getAttribute('width');
+    if (widthAttribute !== null && ZERO_LENGTH_PATTERN.test(widthAttribute.trim())) {
+      return true;
+    }
+    const style = cell.getAttribute(PRESERVED_STYLE_ATTR$1);
+    if (style === null) {
+      return false;
+    }
+    const widthDeclarationValue = this.readStyleDeclaration(style, 'width');
+    return widthDeclarationValue !== null && ZERO_LENGTH_PATTERN.test(widthDeclarationValue);
+  }
+  /**
+   * Reports whether a cell has meaningful text content. `trim()` already treats
+   * the non-breaking space Word emits as blank, so a zero-width cell holding
+   * only markup (including an image) is intentionally treated as empty and
+   * removed.
+   *
+   * @param {HTMLTableCellElement} cell Cell to inspect.
+   * @returns {boolean} `true` when the cell has meaningful text.
+   */
+  hasMeaningfulCellContent(cell) {
+    return (cell.textContent || '').trim() !== '';
+  }
+  /**
+   * Reads one declaration value from a style string.
+   *
+   * @param {string} style Preserved style text.
+   * @param {string} property CSS property name to read.
+   * @returns {string | null} Declaration value when present.
+   */
+  readStyleDeclaration(style, property) {
+    const declarations = style
+      .split(';')
+      .map((declaration) => declaration.trim())
+      .filter((declaration) => declaration !== '');
+    for (const declaration of declarations) {
+      const separator = declaration.indexOf(':');
+      if (separator === -1) {
+        continue;
+      }
+      const name = declaration.slice(0, separator).trim().toLowerCase();
+      if (name !== property.toLowerCase()) {
+        continue;
+      }
+      const value = declaration.slice(separator + 1).trim();
+      return value === '' ? null : value;
+    }
+    return null;
+  }
+  /**
+   * Collapses every `<tfoot>` into the table body because the RTE table model
+   * has no footer section. Left in place, an unsupported `<tfoot>` is unwrapped
+   * by the paste sanitizer into a bare `<tr>` under `<table>`, so its rows lose
+   * their section placement. When the table already has a `<tbody>`, the
+   * footer's rows are appended to the last body so they stay in document order;
+   * otherwise the `<tfoot>` itself is renamed to `<tbody>` so its rows survive
+   * as body content.
+   *
+   * @param {HTMLTableElement} table Word table element.
+   */
+  mergeFooterIntoBody(table) {
+    const footers = Array.from(table.children).filter((child) => child.tagName === 'TFOOT');
+    footers.forEach((footer) => {
+      const bodies = Array.from(table.children).filter((child) => child.tagName === 'TBODY');
+      const targetBody = bodies[bodies.length - 1];
+      if (targetBody) {
+        while (footer.firstChild) {
+          targetBody.appendChild(footer.firstChild);
+        }
+        if (footer.parentNode) {
+          footer.parentNode.removeChild(footer);
+        }
+      }
+      else {
+        this.replaceElementTag(footer, 'tbody');
+      }
+    });
+  }
+  /**
+   * Promotes `<td>` cells that Word places directly inside a `<thead>` row to
+   * `<th>`. The RTE identifies header cells solely by the `TH` tag, so without
+   * this the head row would be parsed as ordinary body cells and lose its
+   * header annotations and rendering. Only direct `thead > tr > td` cells are
+   * converted so cells of a nested table are never touched.
+   *
+   * @param {HTMLTableElement} table Word table element.
+   */
+  promoteHeadCells(table) {
+    Array.from(table.querySelectorAll('thead')).forEach((head) => {
+      Array.from(head.children).forEach((row) => {
+        if (row.tagName !== 'TR') {
+          return;
+        }
+        Array.from(row.children).forEach((cell) => {
+          if (cell.tagName === 'TD') {
+            this.renameCell(cell, 'th');
+          }
+        });
+      });
+    });
+  }
+  /**
+   * Replaces a table cell element with an equivalent cell of a different tag,
+   * preserving its attributes and child nodes.
+   *
+   * @param {HTMLTableCellElement} cell Cell to replace.
+   * @param {string} tagName Target cell tag name (`th` / `td`).
+   */
+  renameCell(cell, tagName) {
+    this.replaceElementTag(cell, tagName);
+  }
+  /**
+   * Replaces an element with an equivalent element of a different tag,
+   * preserving its attributes and child nodes and its position in the tree.
+   *
+   * @param {Element} element Element to replace.
+   * @param {string} tagName Target tag name.
+   * @returns {HTMLElement} The replacement element.
+   */
+  replaceElementTag(element, tagName) {
+    const replacement = element.ownerDocument.createElement(tagName);
+    Array.from(element.attributes).forEach((attr) => {
+      replacement.setAttribute(attr.name, attr.value);
+    });
+    while (element.firstChild) {
+      replacement.appendChild(element.firstChild);
+    }
+    if (element.parentNode) {
+      element.parentNode.replaceChild(replacement, element);
+    }
+    return replacement;
+  }
+  /**
+   * Removes the `class` attribute so Word style class names cannot leak into
+   * the sanitized output (the global allowlist keeps `class` on every tag).
+   *
+   * @param {HTMLElement} element Table structural element.
+   */
+  stripClass(element) {
+    if (element.hasAttribute('class')) {
+      element.removeAttribute('class');
+    }
+  }
+  /**
+   * Drops whitespace-only text nodes that sit directly inside the table and its
+   * row containers. Word exports newlines/indentation between structural tags,
+   * which are invalid as table content and would otherwise render as stray
+   * spaces once the table is pasted.
+   *
+   * @param {HTMLTableElement} table Word table element.
+   */
+  removeStructuralWhitespace(table) {
+    const containers = [
+      table,
+      ...Array.from(table.querySelectorAll(TABLE_CONTAINER_SELECTOR)),
+    ];
+    containers.forEach((container) => {
+      Array.from(container.childNodes).forEach((node) => {
+        if (node.nodeType === Node.TEXT_NODE && (node.textContent || '').trim() === '') {
+          container.removeChild(node);
+        }
+      });
+    });
+  }
+  /**
+   * Drops whitespace-only text nodes that sit directly inside a cell whose
+   * content is block-level (e.g. Word wraps every cell's text in `<p>`). Word
+   * indents its markup, so these text nodes are pure layout whitespace; left in
+   * place each one is wrapped into its own paragraph by the RTE, producing the
+   * stray empty lines seen above and below the real cell content. Cells that
+   * only hold inline content are skipped so meaningful spaces between inline
+   * runs are never merged.
+   *
+   * @param {HTMLTableCellElement} cell Table cell element.
+   */
+  removeCellLayoutWhitespace(cell) {
+    const hasBlockChild = Array.from(cell.children).some((child) => CELL_BLOCK_CHILD_TAGS.has(child.tagName));
+    if (!hasBlockChild) {
+      return;
+    }
+    Array.from(cell.childNodes).forEach((node) => {
+      if (node.nodeType === Node.TEXT_NODE && (node.textContent || '').trim() === '') {
+        cell.removeChild(node);
+      }
+    });
+  }
+  /**
+   * Normalizes `colspan` / `rowspan` values: a redundant span of `1` or any
+   * non-numeric value is removed, and valid spans are rewritten as a clean
+   * integer so the RTE table model reads them consistently.
+   *
+   * @param {HTMLTableCellElement} cell Table cell element.
+   */
+  normalizeSpanAttributes(cell) {
+    SPAN_ATTRIBUTES.forEach((attribute) => {
+      const raw = cell.getAttribute(attribute);
+      if (raw === null) {
+        return;
+      }
+      const value = Number(raw);
+      if (!SPAN_VALUE_PATTERN.test(raw) || value <= 1) {
+        cell.removeAttribute(attribute);
+      }
+      else {
+        cell.setAttribute(attribute, String(value));
+      }
+    });
+  }
+  /**
+   * Migrates Word cell presentational attributes into `data-style` so the RTE
+   * cell annotation can read the shading and alignment, then removes the
+   * original attributes. An existing declaration for the same property always
+   * wins and is never overwritten.
+   *
+   * @param {HTMLTableCellElement} cell Table cell element.
+   */
+  migrateCellAttributes(cell) {
+    CELL_ATTRIBUTE_STYLE_MAP.forEach(({ attribute, property }) => {
+      const value = cell.getAttribute(attribute);
+      if (value && value.trim() !== '') {
+        this.appendStyleDeclaration(cell, property, value.trim().toLowerCase());
+      }
+      cell.removeAttribute(attribute);
+    });
+  }
+  /**
+   * Converts a cell's `width` attribute into a `width` style declaration. Word
+   * emits the width both as a point-based inline style (which the RTE cannot
+   * parse) and as a pixel `width` attribute; the point style is dropped and the
+   * attribute value becomes a clean pixel `width` declaration (a bare number is
+   * treated as pixels, any explicit unit such as `%` is kept as-is).
+   *
+   * @param {HTMLTableCellElement} cell Table cell element.
+   */
+  migrateCellWidth(cell) {
+    const attributeWidth = cell.getAttribute('width');
+    cell.removeAttribute('width');
+    // Drop Word's point-based width so it cannot survive as an unparseable value.
+    this.removeMatchingStyleDeclarations(cell, (property) => WIDTH_STYLE_PATTERN.test(property));
+    const cssWidth = this.toCssWidth(attributeWidth);
+    if (cssWidth !== null) {
+      this.appendStyleDeclaration(cell, 'width', cssWidth);
+    }
+  }
+  /**
+   * Normalizes a cell `width` attribute value into a CSS width value. A bare
+   * number is treated as pixels; any value carrying an explicit unit (e.g. `%`)
+   * is kept as-is. An empty or missing value yields `null`.
+   *
+   * @param {string | null} value Raw `width` attribute value.
+   * @returns {string | null} CSS width value, or `null` when there is nothing to migrate.
+   */
+  toCssWidth(value) {
+    if (value === null || value.trim() === '') {
+      return null;
+    }
+    const trimmed = value.trim();
+    return /^\d+(\.\d+)?$/.test(trimmed) ? `${trimmed}px` : trimmed;
+  }
+  /**
+   * Appends a `property: value` declaration to the preserved style attribute
+   * unless the property is already declared.
+   *
+   * @param {HTMLElement} element Element receiving the declaration.
+   * @param {string} property CSS property name.
+   * @param {string} value CSS value.
+   */
+  appendStyleDeclaration(element, property, value) {
+    const existing = element.getAttribute(PRESERVED_STYLE_ATTR$1) || '';
+    if (this.styleHasProperty(existing, property)) {
+      return;
+    }
+    const prefix = existing.trim() === '' ? '' : `${existing.replace(/;\s*$/, '')}; `;
+    element.setAttribute(PRESERVED_STYLE_ATTR$1, `${prefix}${property}: ${value}`);
+  }
+  /**
+   * Removes every border box-model and padding declaration from the preserved
+   * style so Word's point/centimeter units, system color keywords, and per-side
+   * `border-*: none` resets cannot reach the RTE. Once these are gone the table
+   * and cell annotations fall back to the editor's default border
+   * (`solid 1px #ddd`) and padding (`12px`), giving every pasted cell a uniform
+   * border. `border-collapse` / `border-spacing` are preserved so table
+   * collapsing is unaffected.
+   *
+   * @param {HTMLElement} element Table or cell element to normalize.
+   */
+  removeBorderAndPaddingStyles(element) {
+    this.removeMatchingStyleDeclarations(element, (property) => BORDER_BOX_STYLE_PATTERN.test(property) || PADDING_STYLE_PATTERN.test(property));
+  }
+  /**
+   * Removes every preserved-style declaration whose property name matches the
+   * given predicate, rewriting (or dropping) the `data-style` attribute.
+   *
+   * @param {HTMLElement} element Element whose preserved style is filtered.
+   * @param {(property: string) => boolean} shouldRemove Predicate that returns
+   * `true` for property names to drop (receives the lower-cased name).
+   */
+  removeMatchingStyleDeclarations(element, shouldRemove) {
+    const raw = element.getAttribute(PRESERVED_STYLE_ATTR$1);
+    if (raw === null || raw.trim() === '') {
+      return;
+    }
+    const kept = raw
+      .split(';')
+      .map((declaration) => declaration.trim())
+      .filter((declaration) => declaration !== '')
+      .filter((declaration) => {
+      const separator = declaration.indexOf(':');
+      if (separator === -1) {
+        return true;
+      }
+      const property = declaration.slice(0, separator).trim().toLowerCase();
+      return !shouldRemove(property);
+    });
+    if (kept.length > 0) {
+      element.setAttribute(PRESERVED_STYLE_ATTR$1, kept.join('; '));
+    }
+    else {
+      element.removeAttribute(PRESERVED_STYLE_ATTR$1);
+    }
+  }
+  /**
+   * Reports whether a preserved style string already declares a property.
+   *
+   * @param {string} style Preserved style attribute value.
+   * @param {string} property CSS property name.
+   * @returns {boolean} `true` when the property is already present.
+   */
+  styleHasProperty(style, property) {
+    return new RegExp(`(^|;)\\s*${property}\\s*:`, 'i').test(style);
+  }
+}
+
+/**
+ * Attribute that the RTE code-block parser uses to recognize code content.
+ */
+const CODE_LANGUAGE_ATTR = 'data-language';
+/**
+ * Default language applied when pasted code has no language metadata.
+ */
+const DEFAULT_CODE_LANGUAGE = 'plainText';
+/**
+ * Matches language hints encoded as CSS classes (for example `language-js`).
+ */
+const LANGUAGE_CLASS_PATTERN = /(?:^|\s)(?:language|lang)-([a-z0-9+_.-]+)(?:\s|$)/i;
+/**
+ * Removes Word-only class artifacts from code elements while preserving other
+ * classes. Kept as defense-in-depth: even though the shared sanitizer allowlist
+ * generally strips `Mso*` classes, this transformer normalizes the `<pre>`
+ * class list before language resolution so a stray `MsoPlainText` can never
+ * leak into `LANGUAGE_CLASS_PATTERN` matching.
+ */
+const WORD_CLASS_NAME_PATTERN = /^mso[a-z0-9_-]*$/i;
+/**
+ * Normalizes pasted `<pre>` nodes so they can be parsed as RTE code blocks.
+ *
+ * The RTE recognizes a code block only when `data-language` is present on
+ * `<pre>`. Word-exported snippets commonly use plain `<pre>` with no
+ * language metadata, so this transformer adds a default language and copies any
+ * detectable language hint from nested code markup when available.
+ */
+class WordCodeBlockTransformer {
+  /**
+   * Determines whether a node is a code block whose whitespace must be preserved.
+   *
+   * @param {Node} node Node to inspect.
+   * @returns {boolean} `true` when the node is a `<pre>` element.
+   */
+  static isCodeBlock(node) {
+    return node.nodeType === Node.ELEMENT_NODE && node.tagName.toUpperCase() === 'PRE';
+  }
+  /** @inheritDoc */
+  apply(root) {
+    Array.from(root.querySelectorAll('pre')).forEach((preElement) => {
+      this.stripWordClassArtifacts(preElement);
+      if (!preElement.hasAttribute(CODE_LANGUAGE_ATTR)) {
+        preElement.setAttribute(CODE_LANGUAGE_ATTR, this.resolveLanguage(preElement));
+      }
+    });
+  }
+  /** @inheritDoc */
+  getAllowedTags() {
+    return ['PRE'];
+  }
+  /** @inheritDoc */
+  getAllowedAttributes() {
+    return new Map([['PRE', [CODE_LANGUAGE_ATTR]]]);
+  }
+  /** @inheritDoc */
+  getAllowedStyles() {
+    return [];
+  }
+  /**
+   * Resolves code language metadata from `<pre>` class hints, falling back to
+   * {@link DEFAULT_CODE_LANGUAGE}.
+   *
+   * `apply()` only invokes this method when the `<pre>` has no
+   * `data-language` attribute, so class-based inference is the only source
+   * this method needs to consult.
+   *
+   * @param {HTMLElement} preElement Source `<pre>` element.
+   * @returns {string} Resolved language id or `plainText` fallback.
+   */
+  resolveLanguage(preElement) {
+    const classLanguage = this.resolveLanguageFromClassName(preElement).trim();
+    return classLanguage !== '' ? classLanguage : DEFAULT_CODE_LANGUAGE;
+  }
+  /**
+   * Extracts a language id from class names like `language-js` or `lang-ts`.
+   *
+   * @param {HTMLElement} preElement Source `<pre>` element.
+   * @returns {string} Extracted language id or empty string.
+   */
+  resolveLanguageFromClassName(preElement) {
+    const className = preElement.getAttribute('class') || '';
+    const match = LANGUAGE_CLASS_PATTERN.exec(className);
+    return match ? match[1] : '';
+  }
+  /**
+   * Removes Word-only `Mso*` class names and keeps any non-Word classes.
+   *
+   * @param {HTMLElement} preElement Source `<pre>` element.
+   */
+  stripWordClassArtifacts(preElement) {
+    const className = preElement.getAttribute('class') || '';
+    if (!className) {
+      return;
+    }
+    const filteredClasses = className
+      .split(/\s+/)
+      .map((name) => name.trim())
+      .filter((name) => name !== '' && !WORD_CLASS_NAME_PATTERN.test(name));
+    if (filteredClasses.length === 0) {
+      preElement.removeAttribute('class');
+      return;
+    }
+    preElement.setAttribute('class', filteredClasses.join(' '));
+  }
+}
+
+/**
+ * Default Word transformers. Sanitizer allowlist is aggregated from these
+ * transformer contracts so adding a new transformer automatically extends the
+ * allowlist surface.
+ */
+const WORD_STRUCTURE_TRANSFORMERS = [
+  new WordTableTransformer(),
+  new WordListRoleTransformer(),
+  new WordImageTransformer(),
+  new WordCodeBlockTransformer(),
+  new WordParagraphRoleTransformer(),
+];
+/**
+ * Aggregates the sanitizer allowlist from each transformer's declared contract
+ * (tags, attributes, style prefixes), removing duplicates and normalizing case
+ * so the strategy allowlist can never drift from the transformers that depend on
+ * it.
+ *
+ * @param {WordStructureTransformer[]} transformers Registered structure transformers.
+ * @returns {WordSanitizeConfig} Combined sanitizer configuration.
+ */
+function buildWordSanitizeConfig(transformers) {
+  const tags = new Set();
+  const stylePrefixes = new Set();
+  const attributesMap = new Map();
+  transformers.forEach((transformer) => {
+    transformer.getAllowedTags().forEach((tag) => {
+      tags.add(tag.toUpperCase());
+    });
+    transformer.getAllowedStyles().forEach((prefix) => {
+      stylePrefixes.add(prefix.toLowerCase());
+    });
+    transformer.getAllowedAttributes().forEach((attrs, tagName) => {
+      const normalizedTagName = tagName === WORD_SANITIZE_ALL_TAGS_KEY ? tagName : tagName.toUpperCase();
+      if (!attributesMap.has(normalizedTagName)) {
+        attributesMap.set(normalizedTagName, new Set());
+      }
+      const attrSet = attributesMap.get(normalizedTagName);
+      attrs.forEach((attr) => {
+        attrSet.add(attr.toLowerCase());
+      });
+    });
+  });
+  const allowedAttributes = {};
+  attributesMap.forEach((attrs, tagName) => {
+    allowedAttributes[tagName] = Array.from(attrs);
+  });
+  return {
+    allowedTags: Array.from(tags),
+    allowedAttributes,
+    allowedStylePrefixes: Array.from(stylePrefixes),
+  };
+}
+/**
+ * Default sanitizer allowlist aggregated from
+ * {@link WORD_STRUCTURE_TRANSFORMERS}. Exported so tests and callers can still
+ * provide stable overrides.
+ */
+const WORD_SANITIZE_CONFIG = buildWordSanitizeConfig(WORD_STRUCTURE_TRANSFORMERS);
+/**
+ * Attribute name that carries inline styles after {@link StylePreservator} has
+ * renamed `style` to `data-style`. All sanitization runs against this name so
+ * the styles survive the CSP-sensitive `DOMParser` boundary.
+ */
+const PRESERVED_STYLE_ATTR = 'data-style';
+/**
+ * Block tag that can represent an intentional blank line pasted from Word
+ * (an "empty" paragraph whose only content is a non-breaking space). Headings
+ * are excluded — an empty heading is treated as noise, not an intentional
+ * blank line.
+ */
+const BLANK_LINE_ELIGIBLE_TAGS = 'p';
+/**
+ * Zero-width space used to keep an intentional blank line alive. Unlike a
+ * non-breaking space, it is not stripped by `String.prototype.trim()`, so the
+ * downstream empty-block removal keeps the paragraph while it still renders as
+ * blank.
+ */
+const ZERO_WIDTH_SPACE = '\u200B';
+/**
+ * Style values the RTE cannot resolve, so any declaration whose value contains
+ * one of them is dropped during sanitization. These ride on allowed properties
+ * (`color`, `border`, `background`, …), so the prefix allowlist alone cannot
+ * remove them. Add legacy Word keywords here to filter them everywhere.
+ */
+// eslint-disable-next-line spellcheck/spell-checker
+const INVALID_STYLE_VALUES = ['windowtext'];
+/**
+ * Pre processes raw Word/Office clipboard HTML into clean, RTE-friendly HTML.
+ *
+ * The pipeline mirrors the two-phase design of the source Word cleaner:
+ * 1. Structure fixing — maps Word paragraph styles onto RTE text styles and
+ *    drops Word list marker artifacts.
+ * 2. Dynamic allowlist sanitizing — recursively strips disallowed tags,
+ *    attributes and inline style declarations while keeping inner content.
+ */
+class WordPasteProcessingStrategy extends AbstractPasteProcessingStrategy {
+  /**
+   * Downstream paste mode marker for Word-specific processing.
+   *
+   * @returns {RTEPasteMode} `word` so downstream handlers preserve Word annotations.
+   */
+  get type() {
+    return RTEPasteMode.WORD;
+  }
+  /**
+   * Detects whether raw clipboard HTML originated from Microsoft Word / Office.
+   *
+   * Used to auto-route a normal "rich text" paste through the Word cleaning
+   * pipeline when the source is actually Word, so users get correct formatting
+   * without having to explicitly pick the Word paste option.
+   *
+   * @param {string} html Raw `text/html` clipboard payload.
+   * @returns {boolean} `true` when the HTML carries Word/Office signatures.
+   */
+  canHandle(html) {
+    if (!html) {
+      return false;
+    }
+    return WordPasteProcessingStrategy.WORD_SIGNATURE_PATTERNS.some((pattern) => pattern.test(html));
+  }
+  /**
+   * Returns the priority of this strategy relative to others; higher values run first.
+   *
+   * @returns {number} The priority value.
+   */
+  get priority() {
+    return PasteProcessingStrategyPriority.WORD;
+  }
+  /**
+   * Whether this strategy extracts pasted images and produces local previews.
+   *
+   * @returns {boolean} Always `true`; Word paste swaps `file://` images to previews.
+   */
+  get supportsImageProcessing() {
+    return true;
+  }
+  /**
+   * Cleans raw Word clipboard HTML so it can flow through the normal RTE paste
+   * pipeline.
+   *
+   * @param {string} html Raw `text/html` clipboard payload from Word.
+   * @param {WordSanitizeConfig} [config] Optional allowlist override.
+   * @returns {string} Sanitized HTML string.
+   */
+  process(html, config = WORD_SANITIZE_CONFIG) {
+    if (!html) {
+      return '';
+    }
+    const withoutComments = this.stripWordComments(html);
+    // Preserve inline styles across the DOMParser boundary to avoid
+    // style-src-attr CSP violations (styles become data-style attributes).
+    const preservedHtml = StylePreservator.preserve(withoutComments).getProcessedHtml();
+    const parsedDoc = new DOMParser().parseFromString(preservedHtml, 'text/html');
+    const container = parsedDoc.body;
+    this.fixWordStructure(container);
+    // Sanitize each top-level child instead of the <body> itself so the body
+    // container is never unwrapped away.
+    Array.from(container.childNodes).forEach((child) => {
+      this.sanitizeNode(child, config);
+    });
+    // Collapse the source line wraps Word inserts inside text so a single
+    // logical line does not paste as multiple lines.
+    this.collapseInsignificantWhitespace(container);
+    // Drop the whitespace Word inserts directly between block elements so it
+    // does not paste as empty lines.
+    this.removeInterBlockWhitespace(container);
+    // Keep intentional blank lines (Word empty paragraphs) from being dropped by
+    // the downstream empty-block removal.
+    this.preserveWordEmptyLines(container);
+    return this.restoreStyleAttributeName(container.innerHTML);
+  }
+  /**
+   * Removes Office XML comments and down-level conditional markup that would
+   * otherwise confuse `DOMParser`.
+   *
+   * @param {string} html Raw HTML string.
+   * @returns {string} HTML without Word comment blocks.
+   */
+  stripWordComments(html) {
+    return html.replace(/<!--[\s\S]*?-->/g, '').replace(/<!\[[\s\S]*?\]>/g, '');
+  }
+  /**
+   * First phase: repairs Word-specific structure so it aligns with RTE text
+   * styles before the allowlist pass runs.
+   *
+   * @param {HTMLElement} root Parsed body element.
+   */
+  fixWordStructure(root) {
+    WordPasteProcessingStrategy.STRUCTURE_TRANSFORMERS.forEach((transformer) => {
+      transformer.apply(root);
+    });
+  }
+  /**
+   * Removes the whitespace-only text nodes Word emits directly between block
+   * elements (the `\n\n` at the top level of the fragment). After the allowlist
+   * pass, disallowed containers are already unwrapped, so any remaining
+   * top-level text node that is pure whitespace is an inter-block artifact.
+   * Whitespace inside inline/text elements is left untouched.
+   *
+   * @param {HTMLElement} root Parsed body element.
+   */
+  removeInterBlockWhitespace(root) {
+    Array.from(root.childNodes).forEach((node) => {
+      if (node.nodeType === Node.TEXT_NODE && node.textContent.trim() === '') {
+        root.removeChild(node);
+      }
+    });
+  }
+  /**
+   * Collapses insignificant ASCII whitespace inside text nodes the way a
+   * browser would when rendering. Word wraps long runs of text across multiple
+   * source lines, so a single logical line such as "Number list 1" arrives as
+   * "Number\nlist 1"; without normalization the newline surfaces as a spurious
+   * line break in the editor. Non-breaking spaces (`\u00A0`) are left untouched
+   * so intentional Word spacing and blank lines survive.
+   *
+   * @param {Node} node Node whose text descendants are normalized in place.
+   */
+  collapseInsignificantWhitespace(node) {
+    // Code blocks preserve their original whitespace, so skip the whole subtree.
+    if (WordCodeBlockTransformer.isCodeBlock(node)) {
+      return;
+    }
+    if (node.nodeType === Node.TEXT_NODE) {
+      const original = node.textContent;
+      const collapsed = original.replace(/[ \t\r\n\f]+/g, ' ');
+      if (collapsed !== original) {
+        node.textContent = collapsed;
+      }
+      return;
+    }
+    Array.from(node.childNodes).forEach((child) => {
+      this.collapseInsignificantWhitespace(child);
+    });
+  }
+  /**
+   * Preserves intentional blank lines authored in Word (empty paragraphs whose
+   * only content is a non-breaking space). The downstream paste pipeline drops
+   * any block whose text content trims to empty, and `trim()` also removes a
+   * non-breaking space; replacing the content with a zero-width space keeps the
+   * blank line because it survives `trim()` while still rendering as empty.
+   *
+   * @param {HTMLElement} root Parsed body element.
+   */
+  preserveWordEmptyLines(root) {
+    Array.from(root.querySelectorAll(BLANK_LINE_ELIGIBLE_TAGS)).forEach((block) => {
+      // Word paragraphs that host an image also carry a trailing
+      // `<o:p>&nbsp;</o:p>` whose non-breaking space would misidentify the
+      // paragraph as an empty line and wipe the image out.
+      if (block.querySelector('img')) {
+        return;
+      }
+      const text = block.textContent;
+      const hasRealText = text.replace(/[\s\u200B]+/g, '') !== '';
+      // Only an "empty" block that carries a non-breaking space is treated as
+      // an intentional Word blank line.
+      if (!hasRealText && /\u00A0/.test(text)) {
+        block.textContent = ZERO_WIDTH_SPACE;
+      }
+    });
+  }
+  /**
+   * Second phase: recursively enforces the dynamic allowlist on a node tree.
+   *
+   * @param {Node} node Node to sanitize in place.
+   * @param {WordSanitizeConfig} config Active allowlist configuration.
+   */
+  sanitizeNode(node, config) {
+    if (node.nodeType === Node.TEXT_NODE) {
+      return;
+    }
+    if (node.nodeType !== Node.ELEMENT_NODE) {
+      this.removeSelf(node);
+      return;
+    }
+    const element = node;
+    const tagName = element.tagName.toUpperCase();
+    // Sanitize children first (reverse order keeps indices stable while nodes
+    // may be removed or unwrapped).
+    const children = Array.from(element.childNodes);
+    for (let i = children.length - 1; i >= 0; i--) {
+      this.sanitizeNode(children[i], config);
+    }
+    // Tag-level filter: unwrap disallowed elements but keep their content.
+    if (!config.allowedTags.includes(tagName)) {
+      while (element.firstChild) {
+        if (element.parentNode && typeof element.parentNode.insertBefore === 'function') {
+          element.parentNode.insertBefore(element.firstChild, element);
+        }
+      }
+      this.removeSelf(element);
+      return;
+    }
+    this.sanitizeAttributes(element, tagName, config);
+  }
+  /**
+   * Removes disallowed attributes and filters style declarations.
+   *
+   * @param {Element} element Element being sanitized.
+   * @param {string} tagName Upper-case tag name.
+   * @param {WordSanitizeConfig} config Active sanitize configuration.
+   */
+  sanitizeAttributes(element, tagName, config) {
+    const commonAttrs = config.allowedAttributes[WORD_SANITIZE_ALL_TAGS_KEY] || [];
+    const tagAttrs = config.allowedAttributes[tagName] || [];
+    const allowedAttrs = new Set([...commonAttrs, ...tagAttrs]);
+    Array.from(element.attributes).forEach((attr) => {
+      const attrName = attr.name.toLowerCase();
+      const isStyle = attrName === PRESERVED_STYLE_ATTR;
+      const normalizedName = isStyle ? 'style' : attrName;
+      if (!allowedAttrs.has(normalizedName)) {
+        element.removeAttribute(attr.name);
+        return;
+      }
+      if (isStyle) {
+        this.sanitizeStyleAttribute(element, attr.name, config);
+      }
+    });
+  }
+  /**
+   * Filters CSS declarations inside a preserved style attribute: keeps only
+   * properties matching a prefix in {@link WordSanitizeConfig.allowedStylePrefixes};
+   * all others (including `mso-*` Word artifacts) are stripped.
+   *
+   * @param {Element} element Element owning the style attribute.
+   * @param {string} attrName Preserved style attribute name.
+   * @param {WordSanitizeConfig} config Active sanitize configuration.
+   */
+  sanitizeStyleAttribute(element, attrName, config) {
+    const rawStyle = element.getAttribute(attrName) || '';
+    // Delegate CSS parsing to the browser engine via a temporary element so
+    // that edge cases (values containing semicolons, multi-value shorthand,
+    // etc.) are handled correctly without a hand-rolled parser.
+    const tempEl = element.ownerDocument.createElement('span');
+    tempEl.setAttribute('style', rawStyle);
+    const parsedStyle = tempEl.style;
+    const cleanDeclarations = [];
+    for (let i = 0; i < parsedStyle.length; i++) {
+      const key = parsedStyle[i];
+      // Keep only properties whose name starts with an allowed prefix.
+      const isAllowed = config.allowedStylePrefixes.some((prefix) => key === prefix || key.startsWith(`${prefix}-`));
+      const value = parsedStyle.getPropertyValue(key);
+      // Drop declarations carrying a value the RTE cannot resolve (e.g. Word's
+      // legacy `windowText` system color), even on otherwise allowed properties.
+      const lowerCaseValue = value.toLowerCase();
+      const hasInvalidValue = INVALID_STYLE_VALUES.some((invalid) => lowerCaseValue.includes(invalid));
+      if (isAllowed && !hasInvalidValue) {
+        cleanDeclarations.push(`${key}: ${value}`);
+      }
+    }
+    const cleanStyle = cleanDeclarations.join('; ');
+    if (cleanStyle) {
+      element.setAttribute(attrName, cleanStyle);
+    }
+    else {
+      element.removeAttribute(attrName);
+    }
+  }
+  /**
+   * Converts preserved `data-style` attributes back to `style` in the final
+   * HTML string so downstream paste handling receives standard markup.
+   *
+   * @param {string} html Serialized sanitized HTML.
+   * @returns {string} HTML with `style` attributes restored.
+   */
+  restoreStyleAttributeName(html) {
+    return html.replace(/\sdata-style=/g, ' style=');
+  }
+  /**
+   * Removes the element from its parent node if it has one.
+   *
+   * @param {Node | Element} elementToBeRemoved The element to be removed from the DOM.
+   */
+  removeSelf(elementToBeRemoved) {
+    if (elementToBeRemoved.parentNode &&
+      typeof elementToBeRemoved.parentNode.removeChild === 'function') {
+      elementToBeRemoved.parentNode.removeChild(elementToBeRemoved);
+    }
+  }
+}
+/**
+ * Ordered list of structure transformers applied in Phase 1 before allowlist
+ * sanitization. To add support for a new node type (table, image, list…),
+ * create a class that implements {@link WordStructureTransformer} and append
+ * it here — no other changes to the pipeline are needed.
+ */
+WordPasteProcessingStrategy.STRUCTURE_TRANSFORMERS = [
+  ...WORD_STRUCTURE_TRANSFORMERS,
+];
+/**
+ * Signatures that identify clipboard HTML produced by Microsoft Word / Office.
+ * Any single match is enough to treat the payload as Word content because
+ * these markers do not appear in ordinary web or plain rich-text clipboards.
+ */
+WordPasteProcessingStrategy.WORD_SIGNATURE_PATTERNS = [
+  // <meta name=Generator content="Microsoft Word ...">
+  /content=["']?Microsoft\s+Word/i,
+  // eslint-disable-next-line spellcheck/spell-checker
+  // Office namespace declarations (urn:schemas-microsoft-com:office:word).
+  /urn:schemas-microsoft-com:office/i,
+  // Word paragraph/character style classes (MsoNormal, MsoTitle, MsoListParagraph…).
+  /class=["']?Mso[A-Za-z]/i,
+  // Word-only inline style properties.
+  /mso-[a-z-]+\s*:/i,
+  // Office XML paragraph marker elements (<o:p></o:p>).
+  /<\/?o:p>/i,
+];
+
+/**
+ * Centralized selector for paste processing strategies.
+ *
+ * Maintains a registry of available strategies and selects the highest-priority
+ * strategy that can handle the given clipboard HTML. Provides an extension
+ * point for adding support for new clipboard sources (e.g., Google Docs, Notion)
+ * without modifying the paste extension core logic.
+ */
+class PasteStrategySelector {
+  constructor() {
+    this.defaultStrategy = new DefaultPasteProcessingStrategy();
+    this.strategies = [
+      new WordPasteProcessingStrategy(),
+      this.defaultStrategy, // Fallback
+    ];
+  }
+  /**
+   * Select the appropriate strategy for the given HTML content.
+   * Returns the highest-priority strategy that can handle the content.
+   *
+   * @param {string} html Raw clipboard HTML.
+   * @returns {AbstractPasteProcessingStrategy} The selected strategy (always returns a strategy; default is the fallback).
+   */
+  selectStrategy(html) {
+    return this.selectHighestPriorityStrategy(this.strategies.filter((strategy) => strategy.canHandle(html)));
+  }
+  /**
+   * Selects the highest-priority registered strategy for an explicitly chosen paste mode.
+   *
+   * Used when the user manually chooses a non-default mode from the paste chooser.
+   *
+   * @param {RTEPasteMode} type Explicit paste mode selected by the user.
+   * @returns {AbstractPasteProcessingStrategy} The matching strategy or the default fallback.
+   */
+  selectStrategyByType(type) {
+    return this.selectHighestPriorityStrategy(this.strategies.filter((strategy) => strategy.type === type));
+  }
+  /**
+   * Register a new paste processing strategy.
+   * Useful for future extensions (e.g., GoogleDocsPasteStrategy).
+   *
+   * @param {AbstractPasteProcessingStrategy} strategy The strategy to register.
+   */
+  registerStrategy(strategy) {
+    this.strategies.push(strategy);
+  }
+  /**
+   * Returns the highest-priority strategy from a candidate set or the default fallback.
+   *
+   * @param {AbstractPasteProcessingStrategy[]} strategies Candidate strategies.
+   * @returns {AbstractPasteProcessingStrategy} Selected strategy.
+   */
+  selectHighestPriorityStrategy(strategies) {
+    const selectedStrategy = strategies.sort((a, b) => b.priority - a.priority)[0];
+    return selectedStrategy || this.defaultStrategy;
+  }
+}
+
+/**
+ * Extracts pasted image files from clipboard payloads and swaps matching
+ * `<img>` elements to local object-URL previews.
+ *
+ * The parser is stateless: callers own the returned {@link PasteImagePreview}
+ * list and decide how to track pending uploads.
+ */
+class PasteImageParser {
+  /**
+   * Parses local `file://` images from the HTML, swaps matching `<img>`
+   * elements to object-URL previews, and returns the rewritten HTML alongside
+   * the resolved pending previews.
+   *
+   * When no local images are resolved, the original HTML is returned unchanged
+   * with an empty preview list.
+   *
+   * @param {string} html HTML content to parse.
+   * @param {ClipboardFileContent | null} clipboardFileContent Clipboard payload for image extraction.
+   * @returns {ParseLocalImagesResult} Rewritten HTML and resolved previews.
+   */
+  parseLocalImages(html, clipboardFileContent) {
+    if (!html.includes('<img')) {
+      return { html, previews: [] };
+    }
+    const safeHtml = html.replace(/\s+style=/g, ' data-style=');
+    const parser = new DOMParser();
+    const parsedDoc = parser.parseFromString(safeHtml, 'text/html');
+    const localImageElements = Array.from(parsedDoc.querySelectorAll('img')).filter((img) => img.src.startsWith('file://'));
+    if (localImageElements.length === 0) {
+      return { html, previews: [] };
+    }
+    const imageFiles = this.extractImageFiles(clipboardFileContent, localImageElements);
+    if (imageFiles.length === 0) {
+      return { html, previews: [] };
+    }
+    const previews = this.createImagePreviews(localImageElements, imageFiles);
+    const rewrittenHtml = parsedDoc.body.innerHTML.replace(/ data-style=/g, ' style=');
+    return { html: rewrittenHtml, previews };
+  }
+  /**
+   * Swaps each `<img>` src to a local object-URL preview using the provided
+   * image files (paired by order), returning one preview per resolved image.
+   *
+   * Images that live inside a list are dropped instead of being previewed: the
+   * RTE does not support list images. They are removed here (after holding their
+   * position while the RTF images are paired by order) so the remaining images
+   * stay aligned with their files even when a list image is not the last one.
+   *
+   * @param {HTMLImageElement[]} images Placeholder `<img>` elements in document order.
+   * @param {File[]} files Image files to pair with the elements, in the same order.
+   * @returns {PasteImagePreview[]} Previews for the images that were resolved to a file.
+   */
+  createImagePreviews(images, files) {
+    const previews = [];
+    images.forEach((imageElement, index) => {
+      // List images have no editor representation, so drop them here instead of
+      // creating a preview. Removing them at this stage (rather than earlier)
+      // keeps the remaining images aligned with their files.
+      if (this.isListImage(imageElement)) {
+        imageElement.remove();
+        return;
+      }
+      const file = files[index];
+      if (!file) {
+        return;
+      }
+      const objectUrl = URL.createObjectURL(file);
+      imageElement.setAttribute('src', objectUrl);
+      const imageId = generateUUID();
+      imageElement.setAttribute(PasteImageParser.PREVIEW_IMG_KEY, imageId);
+      previews.push({ id: imageId, file, objectUrl });
+    });
+    return previews;
+  }
+  /**
+   * Extracts image files from clipboard data, preferring Word RTF-decoded
+   * images and falling back to the clipboard file list when RTF yields none.
+   *
+   * @param {ClipboardFileContent | null} clipboardFileContent Clipboard payload from a paste event.
+   * @param {HTMLElement[]} images `<img>` elements the files will be paired with.
+   * @returns {File[]} Image files found on the clipboard.
+   */
+  extractImageFiles(clipboardFileContent, images) {
+    let result = [];
+    if (clipboardFileContent) {
+      if (clipboardFileContent.rtf) {
+        result = this.safeExtractWordImages(clipboardFileContent.rtf, images);
+      }
+      if (result.length === 0 && clipboardFileContent.files) {
+        result = clipboardFileContent.files.filter((file) => file.type.startsWith('image/'));
+      }
+    }
+    return result;
+  }
+  /**
+   * Safely extracts image files from Word RTF clipboard data.
+   *
+   * @param {string} rtf Clipboard payload from a paste event.
+   * @param {HTMLElement[]} images Array of `<img>` elements that may be updated with staged previews.
+   * @returns {File[]} Image files found in the clipboard data.
+   */
+  safeExtractWordImages(rtf, images) {
+    // Word defines a list's picture bullet once in the list table
+    // (`{\*\listpicture ...}`) with no rendered counterpart. Drop that
+    // definition so its blip is not counted as a content image; the per-item
+    // `{\listtext ...}` bullet blips are kept because each still pairs with a
+    // preserved bullet placeholder `<img>`.
+    const contentRtf = this.stripListPictureDefinitions(rtf);
+    const fileObjects = [];
+    const imageRegex = /\\pngblip|\\jpegblip/g;
+    const matches = [...contentRtf.matchAll(imageRegex)];
+    matches.forEach((match, index) => {
+      if (index >= images.length || match.index === undefined) {
+        return;
+      }
+      const mimeType = match[0].includes('png') ? 'image/png' : 'image/jpeg';
+      const startIndex = match.index + match[0].length;
+      const bytes = this.extractImageBytes(contentRtf, startIndex);
+      if (bytes.length === 0) {
+        return;
+      }
+      const extension = mimeType.split('/')[1];
+      const file = new File(
+      // eslint-disable-next-line spellcheck/spell-checker
+      [new Uint8Array(bytes)], `word_img_${Date.now()}_${index}.${extension}`, { type: mimeType });
+      fileObjects.push(file);
+    });
+    return fileObjects;
+  }
+  /**
+   * Removes Word list-table picture-bullet definitions from the RTF so they are
+   * not counted as content images.
+   *
+   * Word declares a list's picture bullet once as a `{\*\listpicture ...}`
+   * destination inside the list table. It renders nothing on its own, so its
+   * blip has no matching content `<img>`; leaving it in shifts the ordinal
+   * pairing and makes the first real image resolve to the bullet. The per-item
+   * `{\listtext ...}` bullets are intentionally left untouched because each is
+   * kept as a placeholder `<img>` that consumes its blip downstream.
+   *
+   * @param {string} rtf Full RTF clipboard payload.
+   * @returns {string} RTF with list-table picture-bullet definitions removed.
+   */
+  stripListPictureDefinitions(rtf) {
+    // eslint-disable-next-line spellcheck/spell-checker
+    return this.removeBalancedGroups(rtf, '{\\*\\listpicture');
+  }
+  /**
+   * Removes every balanced-brace RTF group that starts with the given marker.
+   *
+   * @param {string} rtf RTF payload to scan.
+   * @param {string} marker Opening delimiter of the group to remove (including its `{`).
+   * @returns {string} RTF with the matching groups removed.
+   */
+  removeBalancedGroups(rtf, marker) {
+    let index = rtf.indexOf(marker);
+    while (index !== -1) {
+      const end = this.findGroupEnd(rtf, index);
+      rtf = rtf.slice(0, index) + rtf.slice(end);
+      index = rtf.indexOf(marker, index);
+    }
+    return rtf;
+  }
+  /**
+   * Finds the index just past the brace that closes the group opened at `start`.
+   *
+   * A backslash escapes the next character (such as `\{` or `\}`) so escaped
+   * braces are not counted. When the group is unbalanced the RTF length is
+   * returned so the trailing remainder is dropped.
+   *
+   * @param {string} rtf RTF payload to scan.
+   * @param {number} start Index of the group's opening `{`.
+   * @returns {number} Index immediately after the matching closing `}`.
+   */
+  findGroupEnd(rtf, start) {
+    const length = rtf.length;
+    let depth = 0;
+    let position = start;
+    while (position < length) {
+      const char = rtf[position];
+      if (char === '\\') {
+        position += 2;
+        continue;
+      }
+      if (char === '{') {
+        depth++;
+      }
+      else if (char === '}') {
+        depth--;
+        if (depth === 0) {
+          return position + 1;
+        }
+      }
+      position++;
+    }
+    return length;
+  }
+  /**
+   * Extracts the raw image bytes that follow a Word RTF blip marker.
+   *
+   * Starting just after the blip control word, RTF control words (such as
+   * `\bliptag`) and nested groups (such as `{\*\blipuid ...}`) are skipped so
+   * their hex is not mistaken for image data. Hex digits are decoded into bytes
+   * until the enclosing `{\pict}` group is closed.
+   *
+   * @param {string} rtf Full RTF clipboard payload.
+   * @param {number} startIndex Index immediately after the blip marker.
+   * @returns {number[]} Decoded image byte values.
+   */
+  extractImageBytes(rtf, startIndex) {
+    const length = rtf.length;
+    const bytes = [];
+    let depth = 0;
+    let highNibble = -1;
+    let position = startIndex;
+    while (position < length) {
+      const char = rtf[position];
+      if (char === '{') {
+        depth++;
+        position++;
+        continue;
+      }
+      if (char === '}') {
+        if (depth === 0) {
+          break;
+        }
+        depth--;
+        position++;
+        continue;
+      }
+      if (depth > 0) {
+        position++;
+        continue;
+      }
+      if (char === '\\') {
+        position++;
+        while (position < length && /[a-zA-Z]/.test(rtf[position])) {
+          position++;
+        }
+        if (position < length && rtf[position] === '-') {
+          position++;
+        }
+        while (position < length && /[0-9]/.test(rtf[position])) {
+          position++;
+        }
+        continue;
+      }
+      const nibble = this.hexNibble(char);
+      if (nibble >= 0) {
+        if (highNibble < 0) {
+          highNibble = nibble;
+        }
+        else {
+          bytes.push((highNibble << 4) | nibble);
+          highNibble = -1;
+        }
+      }
+      position++;
+    }
+    return bytes;
+  }
+  /**
+   * Converts a single hex character to its numeric value.
+   *
+   * @param {string} char Candidate hex character.
+   * @returns {number} Value in `[0, 15]`, or `-1` when not a hex digit.
+   */
+  hexNibble(char) {
+    if (char >= '0' && char <= '9') {
+      return char.charCodeAt(0) - 48;
+    }
+    if (char >= 'a' && char <= 'f') {
+      return char.charCodeAt(0) - 87;
+    }
+    if (char >= 'A' && char <= 'F') {
+      return char.charCodeAt(0) - 55;
+    }
+    return -1;
+  }
+  /**
+   * Returns whether an `<img>` element is nested inside list content.
+   *
+   * The Word paste sanitizer strips non-allowlisted attributes but keeps the
+   * `ul`/`ol`/`li` structure, so list membership is detected by DOM ancestry
+   * here rather than by a marker attribute set upstream.
+   *
+   * @param {HTMLImageElement} imageElement Image element to test.
+   * @returns {boolean} Whether the image is part of list content.
+   */
+  isListImage(imageElement) {
+    return Boolean(imageElement.closest('li,ul,ol'));
   }
 }
-FullscreenController.STYLE_TAG_ID = 'v-rte-fullscreen-styles';
-FullscreenController.HOST_FULLSCREEN_STYLE = 'position:fixed;inset:0;background-color:rgba(var(--v-bg-primary, 252, 252, 252, 1));';
+PasteImageParser.PREVIEW_IMG_KEY = 'data-rte-id';
+
+const REPLACE_IMAGE_SRC = 'REPLACE_IMAGE_SRC';
 /**
- * Only three things need overriding inside the shadow root:
- * 1. The outer vega-flex wrapper must fill the host height (`:host >`
- *    avoids hitting the toolbar's nested vega-flex).
- * 2. The editor container must grow to fill remaining space and drop
- *    the fixed pixel height that Stencil injects from the `rows` prop.
- * 3. The source-view container (shown in source-edit mode) also grows
- *    and owns vertical scrolling so long source code is reachable.
- * 4. overflow:auto on the container lets content scroll without clipping
- *    internal pop-ups (link editor, color picker, etc.) at the host level.
+ * Action to replace the `src` attribute of an `<img>` element in the RTE content.
  */
-FullscreenController.INNER_FULLSCREEN_CSS = ':host > vega-flex { height: 100%; padding: 5px; box-sizing: border-box; }' +
-  ' .rich-text-editor-container { flex: 1 !important; height: auto !important; min-height: 0 !important; resize: none !important; overflow: auto !important; }' +
-  ' .source-view-container:not(.vega-hidden) { display: flex !important; flex: 1 !important; min-height: 0 !important; overflow: auto !important; flex-direction: column; }';
-FullscreenController.documentScrollLockStates = new WeakMap();
+class ImageReplaceSrcAction extends ModifyContentAction {
+  constructor(imageElement, url) {
+    super();
+    this.type = REPLACE_IMAGE_SRC;
+    this.img = imageElement;
+    this.url = url;
+  }
+}
 
 /**
- * Rich Text Editor extension that adds a toolbar button for viewport fullscreen mode.
- *
- * OOP Pattern: Extends VegaRTEExtension with fullscreen feature.
- * Uses a per-host controller store to isolate state across hosts.
+ * Strategy to handle the `ImageReplaceSrcAction` for replacing the `src` attribute of an `<img>` element in the RTE content.
  */
-class VegaRTEFullscreenExtension extends VegaRTEExtension {
-  /** @inheritDoc */
-  prepareBeforeLoad(host) {
-    const controller = new FullscreenController(host);
-    VegaRTEFullscreenExtension.controllerStore.set(host, controller);
-    this.registerToolbarButtonRenderer(VegaRTEFullscreenExtension.TOOLBAR_BUTTON_KEY, new RTEFullscreenToolbarButtonRenderer(controller), host);
-  }
+class ImageReplaceSrcStrategy extends ActionHandleStrategy {
   /**
-   * Restore document scroll if the editor is removed while fullscreen is active.
-   * Without this, body overflow:hidden would persist after the host is gone.
+   * @inheritDoc
    */
-  destroyExtension() {
-    var _a, _b;
-    if ((_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.host) {
-      const host = this.extensionContext.host;
-      (_b = VegaRTEFullscreenExtension.controllerStore.get(host)) === null || _b === void 0 ? void 0 : _b.exitFullscreen();
-      VegaRTEFullscreenExtension.controllerStore.delete(host);
+  handleAction(action, target) {
+    const { img, url } = action;
+    img.setAttribute('src', url);
+    img.removeAttribute(PasteImageParser.PREVIEW_IMG_KEY);
+    target.url = url;
+    if (target.annotationMap && target.annotationMap.has('CUSTOM_ATTRIBUTE')) {
+      const customAttributeAnnotation = target.annotationMap.get('CUSTOM_ATTRIBUTE');
+      customAttributeAnnotation.customAttribute.src = url;
+      delete customAttributeAnnotation.customAttribute[PasteImageParser.PREVIEW_IMG_KEY];
     }
   }
 }
-VegaRTEFullscreenExtension.TOOLBAR_BUTTON_KEY = 'fullscreen';
-VegaRTEFullscreenExtension.controllerStore = VegaRTEFullscreenExtension.createStateStore();
-
-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.
+ * Owns the lifecycle of pasted images awaiting upload: it tracks their local
+ * object-URL previews, notifies the consumer once they are inserted, applies the
+ * uploaded URL back onto the live preview, and revokes object URLs on teardown.
+ *
+ * Keeping this state here rather than on the paste extension keeps the extension
+ * focused on clipboard capture and the chooser UI.
  */
-class RTEPasteChooserUI {
-  constructor(hostRoot, callbacks) {
-    this.hostRoot = hostRoot;
-    this.callbacks = callbacks;
-    this.chooserEl = null;
-    this.dropdownEl = null;
-    this.triggerButtonEl = null;
+class PendingImageRegistry {
+  constructor() {
+    /** Ids of pending images still holding an object URL owned by this registry. */
+    this.ownedImageIds = new Set();
+    /** Ids queued for the next {@link notifyInserted} call. */
+    this.pendingNotifyImageIds = [];
   }
   /**
-   * Opens the paste-mode chooser at the given position.
+   * Registers freshly created previews so they can be notified and later
+   * resolved to their uploaded URLs.
    *
-   * @param {PasteChooserPosition} position Viewport position for the chooser.
+   * @param {PasteImagePreview[]} previews Previews produced for the current paste.
    */
-  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;
-      }
+  register(previews) {
+    this.pendingNotifyImageIds = [];
+    previews.forEach((preview) => {
+      this.pendingNotifyImageIds.push(preview.id);
+      this.ownedImageIds.add(preview.id);
+      PendingImageRegistry.pendingImages.set(preview.id, preview);
     });
   }
   /**
-   * Removes the chooser from the DOM.
+   * @returns {boolean} Whether previews are queued for notification.
    */
-  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;
+  hasPendingNotifications() {
+    return this.pendingNotifyImageIds.length > 0;
   }
   /**
-   * Determines whether the given event path targets the chooser.
+   * Notifies the consumer about newly inserted pasted images so they can upload
+   * them and fill in the real URLs via the supplied `replaceUrl` callback.
    *
-   * @param {EventTarget[]} eventPath Composed path of an event.
-   * @returns {boolean} `true` when the path includes the chooser.
+   * @param {ImageInsertedCallback | undefined} callback Consumer callback to invoke.
+   * @param {GetEditableElement} getEditableElement Resolves the live editable element.
+   * @param {ResolveImageNode} resolveImageNode Resolves the DTO node for a preview element.
    */
-  includesEventPath(eventPath) {
-    if (!this.chooserEl) {
-      return false;
+  notifyInserted(callback, getEditableElement, resolveImageNode) {
+    const images = this.pendingNotifyImageIds
+      .map((id) => PendingImageRegistry.pendingImages.get(id))
+      .filter((preview) => !!preview);
+    this.pendingNotifyImageIds = [];
+    if (images.length && typeof callback === 'function') {
+      // Mark as handed to the consumer so teardown keeps them for a later replaceUrl.
+      images.forEach((image) => (image.notified = true));
+      const pasteImages = images.map((image) => ({
+        id: image.id,
+        file: image.file,
+      }));
+      callback(pasteImages, (imageId, url) => this.replaceUrl(imageId, url, getEditableElement, resolveImageNode));
     }
-    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.
+   * Revokes and forgets only previews that were never handed to a consumer for
+   * upload. Previews already notified via {@link notifyInserted} are left intact
+   * so an async {@link replaceUrl} can still resolve them after the extension is
+   * recreated; that callback owns their teardown.
    */
-  createPasteChooserDropdown(doc, placement) {
-    const dropdownEl = doc.createElement('vega-dropdown');
-    dropdownEl.trigger = 'click';
-    dropdownEl.selectType = 'single';
-    dropdownEl.selectedSourceKey = 'rich';
-    dropdownEl.maxWidth = 220;
-    dropdownEl.alignment = 'start';
-    dropdownEl.itemDisplayRule = 'ellipsis';
-    dropdownEl.isScreenPosition = true;
-    const triggerButton = doc.createElement('vega-rich-text-editor-toolbar-button');
-    const arrowIcon = placement[0] === 'top' ? 'chevron-up' : 'chevron-down';
-    triggerButton.setAttribute(RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR, 'true');
-    triggerButton.setAttribute('aria-label', VegaInternalTranslation.t('Paste options'));
-    triggerButton.setAttribute('arrow-icon', arrowIcon);
-    triggerButton.icon = 'rte-paste';
-    triggerButton.showArrowIcon = true;
-    triggerButton.selected = false;
-    this.triggerButtonEl = triggerButton;
-    const tooltipEl = doc.createElement('vega-tooltip');
-    tooltipEl.text = VegaInternalTranslation.t('Paste options');
-    tooltipEl.placement = ['bottom', 'top'];
-    tooltipEl.append(triggerButton);
-    dropdownEl.append(tooltipEl);
-    const itemsContainer = doc.createElement('div');
-    itemsContainer.setAttribute('slot', 'items');
-    itemsContainer.append(this.createDropdownItem(doc, 'rich', VegaInternalTranslation.t('Use rich text'), RTEPasteChooserUI.CHOOSER_RICH_ATTR));
-    dropdownEl.append(itemsContainer);
-    dropdownEl.addEventListener('vegaDropdownClick', (event) => {
-      const mode = event.detail;
-      if (mode === 'rich') {
-        this.callbacks.onModeSelect(mode);
+  discardUnsentPreviews() {
+    this.ownedImageIds.forEach((imageId) => {
+      const pending = PendingImageRegistry.pendingImages.get(imageId);
+      if (pending && pending.notified) {
+        return;
+      }
+      if (pending && pending.objectUrl.startsWith('blob:')) {
+        URL.revokeObjectURL(pending.objectUrl);
       }
+      PendingImageRegistry.pendingImages.delete(imageId);
+      this.ownedImageIds.delete(imageId);
     });
-    return dropdownEl;
+    this.pendingNotifyImageIds = [];
   }
   /**
-   * Creates a single dropdown item element for a paste mode.
+   * Applies the uploaded URL for a pending pasted image, replacing its local
+   * preview `src` and revoking the object URL.
    *
-   * @param {Document} doc Document used to create the element.
-   * @param {PasteMode} key Paste mode key for the item.
-   * @param {string} label Display label for the item.
-   * @param {string} dataAttrName Data attribute marker for the item.
-   * @returns {HTMLVegaDropdownItemElement} Configured dropdown item element.
+   * @param {string} imageId Pending image id supplied to the consumer callback.
+   * @param {string} url Uploaded image URL to apply.
+   * @param {GetEditableElement} getEditableElement Resolves the live editable element.
+   * @param {ResolveImageNode} resolveImageNode Resolves the DTO node for a preview 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;
+  replaceUrl(imageId, url, getEditableElement, resolveImageNode) {
+    var _a;
+    const editableEl = getEditableElement();
+    if (editableEl) {
+      const imageElement = (_a = editableEl.querySelector(`img[data-rte-id="${imageId}"]`)) !== null && _a !== void 0 ? _a : null;
+      if (imageElement) {
+        const imageNode = resolveImageNode(imageElement);
+        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);
+    }
   }
 }
-(() => {
-  VegaInternalIconManager.register({
-    'rte-paste': paste,
-  });
-})();
-RTEPasteChooserUI.CHOOSER_ATTR = 'data-rte-paste-chooser';
-RTEPasteChooserUI.CHOOSER_RICH_ATTR = 'data-rte-paste-type-rich';
-RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR = 'data-rte-paste-trigger';
-
 /**
- * Custom DataTransfer MIME type used to tag a synthetic paste with the chosen
- * paste mode (e.g. 'rich' or 'plain'), so downstream paste handling can decide
- * whether to preserve the original inline styles.
+ * 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.
  */
-const RTE_PASTE_MODE_DATA_TYPE = 'application/x-vega-rte-paste-mode';
+PendingImageRegistry.pendingImages = new Map();
 
 /**
  * Vega Rich Text Editor paste extension.
  * Intercepts keyboard paste and allows users to choose paste mode.
  */
 class VegaRTEPasteExtension extends VegaRTEExtension {
-  constructor() {
-    super(...arguments);
+  constructor(options = {}) {
+    super();
     this.editableEl = null;
     this.contentHostEl = null;
     this.chooserUI = null;
     this.pendingPastePayload = null;
     this.listenerDocument = null;
     this.listenerWindow = null;
+    this.options = {};
+    this.strategySelector = new PasteStrategySelector();
+    this.clipboardFileContent = null;
+    this.imageParser = new PasteImageParser();
+    /** Owns pending pasted-image previews awaiting upload and their URL replacement. */
+    this.pendingImageRegistry = new PendingImageRegistry();
     /**
      * Handles a native paste event by capturing the clipboard payload and
      * rendering the paste-mode chooser.
@@ -11222,6 +14564,9 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
       // 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();
@@ -11233,6 +14578,10 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
       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);
     };
     /**
@@ -11266,6 +14615,7 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
     this.handleOutsideScroll = () => {
       this.clearPasteChooser();
     };
+    this.options = options;
   }
   /** @inheritDoc */
   initialExtensionAfterLoad(context) {
@@ -11277,6 +14627,7 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
   destroyExtension() {
     this.detachPasteListener();
     this.clearPasteChooser();
+    this.pendingImageRegistry.discardUnsentPreviews();
   }
   /**
    * Attaches the paste listener to the editable element.
@@ -11339,7 +14690,7 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
    * @param {ClipboardEvent} pasteEvent Originating paste event used for positioning.
    */
   renderPasteChooser(pasteEvent) {
-    var _a, _b;
+    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;
@@ -11351,6 +14702,8 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
       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;
@@ -11480,7 +14833,10 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
   /**
    * Applies the chosen paste mode by dispatching a synthetic paste input event.
    *
-   * @param {PasteMode} mode Selected paste mode.
+   * `rich` keeps auto-detection enabled; any other explicit mode forces the
+   * corresponding registered strategy.
+   *
+   * @param {RTEPasteMode} mode Selected paste mode.
    */
   applyPasteMode(mode) {
     var _a;
@@ -11496,9 +14852,42 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
     editableEl.focus();
     this.restoreSelectionRange(this.pendingPastePayload.range);
     this.restoreSelectionControllerState(this.pendingPastePayload);
-    const dataTransfer = this.createDataTransfer(this.pendingPastePayload.html, this.pendingPastePayload.text, mode);
+    const strategy = mode === RTEPasteMode.RICH
+      ? this.strategySelector.selectStrategy(this.pendingPastePayload.html)
+      : this.strategySelector.selectStrategyByType(mode);
+    let processedHtml = strategy.process(this.pendingPastePayload.html);
+    // If the strategy supports image processing and there is clipboard file content, parse local images.
+    if (strategy.supportsImageProcessing && this.clipboardFileContent) {
+      processedHtml = this.parseLocalImages(processedHtml, this.clipboardFileContent);
+    }
+    this.clipboardFileContent = null;
+    const dataTransfer = this.createDataTransfer(processedHtml, this.pendingPastePayload.text, strategy.type);
     this.dispatchBeforeInputPaste(editableEl, dataTransfer);
     this.clearPasteChooser();
+    this.emitLocalImageInsertedEvent();
+  }
+  /**
+   * 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.
+   */
+  emitLocalImageInsertedEvent() {
+    if (this.pendingImageRegistry.hasPendingNotifications()) {
+      this.pendingImageRegistry.notifyInserted(this.options.imageInsertedCallback, () => { var _a; return (_a = this.editableEl) !== null && _a !== void 0 ? _a : this.getEditableElement(); }, (imageElement) => this.getDTOEntityByDom(imageElement));
+    }
   }
   /**
    * Restores SelectionController state from the captured selection so synthetic
@@ -11572,7 +14961,7 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
    *
    * @param {string} html HTML clipboard content.
    * @param {string} text Plain text clipboard content.
-   * @param {PasteMode} [mode] Selected paste mode marker.
+   * @param {RTEPasteMode} [mode] Selected paste mode marker.
    * @returns {DataTransfer} Populated data transfer payload.
    */
   createDataTransfer(html, text, mode) {
@@ -11633,6 +15022,9 @@ class VegaRTEPasteExtension extends VegaRTEExtension {
     }
   }
 }
+(() => {
+  VegaRTEExtension.registerActionHandleStrategy(RTEImageNode.name, REPLACE_IMAGE_SRC, new ImageReplaceSrcStrategy());
+})();
 
 /**
  * Action to extract the currently selected content (HTML and plain text) from the editor.
@@ -11670,6 +15062,7 @@ class RTECopyToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
   render(h, editorContext) {
     return this.renderButton(h, editorContext, {
       icon: 'rte-copy',
+      ariaLabel: editorContext.translation.t('Copy'),
       tooltip: { text: 'Copy' },
     });
   }
@@ -11985,6 +15378,7 @@ class RTECutToolbarButtonRenderer extends RTECopyToolbarButtonRenderer {
   render(h, editorContext) {
     return this.renderButton(h, editorContext, {
       icon: 'rte-cut',
+      ariaLabel: editorContext.translation.t('Cut'),
       tooltip: { text: 'Cut' },
     });
   }
@@ -12023,6 +15417,130 @@ class VegaRTECutExtension extends VegaRTEExtension {
 // The unique key for the cut toolbar button, used for registration and retrieval.
 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 {
+  /**
+   * Intercept when the candidate exceeds the configured maximum. Hard-limit
+   * commits are vetoed only when they increase the count.
+   *
+   * @param {CommitValueAction} action - the commit action carrying the candidate and previous values
+   * @returns {boolean} - whether the commit should be vetoed
+   */
+  canIntercept(action) {
+    var _a;
+    const extension = (_a = action.host.extensions) === null || _a === void 0 ? void 0 : _a.find((item) => this.isWordCountExtension(item));
+    if (!extension) {
+      return false;
+    }
+    const { hardLimit, maxChars } = extension.getConfig();
+    const nextContent = action.candidate.getPlainText();
+    const nextCount = extension.calculateTextCount(nextContent);
+    if (!isNonNullable(maxChars) || nextCount <= maxChars) {
+      return false;
+    }
+    let result = false;
+    let prevContent = '';
+    if (hardLimit && action.previous) {
+      prevContent = action.previous.getPlainText();
+      result = nextCount > extension.calculateTextCount(prevContent);
+    }
+    this.notifyCharsLimitExceeded(nextContent, prevContent, extension, action);
+    return result;
+  }
+  /**
+   * Not invoke the origin action handle to veto the commit that would push the character count past the hard limit.
+   */
+  intercept() {
+  }
+  /**
+   * Notify the consumer when the candidate exceeds the configured character limit.
+   * The previous content is empty when hard limit is not enabled for the performance optimization.
+   *
+   * @param {string} nextContent - the candidate content string
+   * @param {string} prevContent - the previous content string
+   * @param {VegaRTEWordCountExtension} extension - the configured word count extension
+   * @param {CommitValueAction} action - the commit action carrying the candidate value
+   */
+  notifyCharsLimitExceeded(nextContent, prevContent, extension, action) {
+    const { maxChars, hardLimit, onCharsLimitExceeded } = extension.getConfig();
+    if (typeof onCharsLimitExceeded === 'function') {
+      if (!hardLimit || prevContent !== nextContent) {
+        onCharsLimitExceeded(action.host, maxChars);
+      }
+    }
+  }
+  /**
+   * Check if the given extension is a word count extension.
+   *
+   * @param {VegaRTEExtension} extension - the extension to check
+   * @returns {boolean} - whether the extension is a word count extension
+   */
+  isWordCountExtension(extension) {
+    return extension['type'] === RTE_WORD_COUNT_KEY;
+  }
+}
+
+/**
+ * Default configuration applied when a word count option is not provided.
+ */
+const DEFAULT_WORD_COUNT_CONFIG = {
+  showCharCount: true,
+  countInlineBreak: false,
+  hardLimit: false,
+};
+/**
+ * Rich Text Editor extension that provides character counting.
+ */
+class VegaRTEWordCountExtension extends VegaRTEExtension {
+  constructor(config = {}) {
+    super();
+    /**
+     * Runtime discriminator used by the core to identify this extension.
+     */
+    this.type = RTE_WORD_COUNT_KEY;
+    this.config = Object.assign(Object.assign({}, DEFAULT_WORD_COUNT_CONFIG), config);
+  }
+  /**
+   * Get the extension configuration.
+   *
+   * @returns {ResolvedRTEWordCountConfig} The word count configuration.
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Compute the character count data for the given editor content.
+   *
+   * @param {VegaRTEContent} value - The editor content.
+   * @returns {VegaRTEWordCountData} The computed character count data.
+   */
+  getData(value) {
+    const plainText = value.getPlainText();
+    const { maxChars, hardLimit } = this.config;
+    const count = this.calculateTextCount(plainText);
+    return { count, maxChars, hardLimit };
+  }
+  /**
+   * Get the character count for the given content string.
+   *
+   * @param {string} content - The content string.
+   * @returns {number} The character count.
+   */
+  calculateTextCount(content) {
+    const { countInlineBreak } = this.config;
+    const text = countInlineBreak ? content : content.replace(/\n/g, '');
+    // Use the spread operator so that surrogate pairs (e.g. emoji) count as a single character.
+    return [...text].length;
+  }
+}
+(() => {
+  // Gate over-limit commits through the shared action-interceptor pipeline.
+  VegaRTEExtension.registerActionHandlerInterceptor(VegaRTEContent.name, COMMIT_VALUE, new PreventHardLimitExceedInterceptor());
+})();
+
 /**
  * Insert a new children to the nearest position of the parent container
  *
@@ -12087,7 +15605,7 @@ class SpanToTokenNodeStrategy extends ElementToDTOStrategy {
   /**
    * @inheritDoc
    */
-  handle(elementsArray) {
+  handle(elementsArray, _options, parentTextAnnotations) {
     const element = elementsArray[0];
     const tokenKey = element.getAttribute('token-key');
     const text = element.textContent;
@@ -12100,7 +15618,9 @@ class SpanToTokenNodeStrategy extends ElementToDTOStrategy {
       type: 'token',
       token: tokenKey,
       text,
-      annotations: Object.assign(Object.assign({}, restAnnotations), { customAttribute: this.createCustomAttrs(customAttribute) }),
+      annotations: Object.assign(Object.assign(Object.assign({}, restAnnotations), ((parentTextAnnotations === null || parentTextAnnotations === void 0 ? void 0 : parentTextAnnotations.inlineHtml)
+        ? { inlineHtml: parentTextAnnotations.inlineHtml }
+        : {})), { customAttribute: this.createCustomAttrs(customAttribute) }),
     };
   }
   /**
@@ -12151,4 +15671,4 @@ class VegaRTETokenExtension extends VegaRTEExtension {
 })();
 VegaRTETokenExtension.TOOLBAR_BUTTON_KEY = 'token';
 
-export { VegaCalendarPeriodFactory as A, VegaRTEToolbarButtonRenderer as B, RTETokenNode as C, RTETokenNodeRenderer as D, RTELanguageToolbarButtonRenderer as E, RTEBlockquoteBlock as F, DeleteSelectedContentAction as G, ActionHandlerInterceptor as H, InsertNodeToNearestRootAction as I, RTETokenToolbarButtonRenderer as R, VegaLoader as V, VegaNotify as a, VegaEventManager$1 as b, VegaZIndexManager$1 as c, VegaSkeletonLoader as d, VegaTranslation as e, VegaRTETokenExtension as f, VegaRTELanguageExtension as g, VegaRTEDefaultLineHeightOptions as h, VegaRTEFunctionExtension as i, VegaRTETableExtension as j, VegaRTEHorizontalLineExtension as k, VegaRTEBlockquoteExtension as l, VegaRTESpecialCharactersExtension as m, VegaRTEFindReplaceExtension as n, VegaRTESpecialCharactersEssentials as o, VegaRTESpecialCharactersLatin as p, VegaRTESpecialCharactersMathematical as q, VegaRTESpecialCharactersArrows as r, VegaRTESpecialCharactersCurrency as s, VegaRTESpecialCharactersText as t, VegaRTELineHeightExtension as u, VegaRTEPasteExtension as v, waitForVega as w, VegaRTEFullscreenExtension as x, VegaRTECopyExtension as y, VegaRTECutExtension as z };
+export { VegaRTEWordCountExtension as A, VegaCalendarPeriodFactory as B, VegaRTEToolbarButtonRenderer as C, RTETokenNode as D, RTETokenNodeRenderer as E, RTELanguageToolbarButtonRenderer as F, RTEBlockquoteBlock as G, DeleteSelectedContentAction as H, InsertNodeToNearestRootAction as I, ActionHandlerInterceptor as J, RTETokenToolbarButtonRenderer as R, VegaLoader as V, VegaNotify as a, VegaEventManager$1 as b, VegaZIndexManager$1 as c, VegaSkeletonLoader as d, VegaTranslation as e, VegaRTETokenExtension as f, VegaRTELanguageExtension as g, VegaRTEDefaultLineHeightOptions as h, VegaRTEFunctionExtension as i, VegaRTETableExtension as j, VegaRTEHorizontalLineExtension as k, VegaRTEBlockquoteExtension as l, VegaRTESpecialCharactersExtension as m, VegaRTEFindReplaceExtension as n, VegaRTESpecialCharactersEssentials as o, VegaRTESpecialCharactersLatin as p, VegaRTESpecialCharactersMathematical as q, VegaRTESpecialCharactersArrows as r, VegaRTESpecialCharactersCurrency as s, VegaRTESpecialCharactersText as t, VegaRTELineHeightExtension as u, VegaRTEPasteExtension as v, waitForVega as w, VegaRTEFullscreenExtension as x, VegaRTECopyExtension as y, VegaRTECutExtension as z };