@globalpayments/vega 2.98.0 → 2.100.0

package/dist/cjs/{token-extension-78b5a026.js → token-extension-8d7bd451.js}

@@ -8,27 +8,27 @@ const internalVegaZIndexManager = require('./internal-vega-z-index-manager-f03dd
 const dynamicSlimmer = require('./dynamic-slimmer-f31fdfd7.js');
 const pageResizeObserverSlimmer = require('./page-resize-observer-slimmer-273d62ef.js');
 const internalVegaEventManager = require('./internal-vega-event-manager-7003c84a.js');
-const internalTranslationController = require('./internal-translation-controller-1dac2df8.js');
-const internalCalendarPeriodFactory = require('./internal-calendar-period-factory-dfcdd3f6.js');
-const linkExtension = require('./link-extension-220ff6a9.js');
-const codeBlock = require('./code-block-d78c2b2c.js');
-const contentState = require('./content-state-78a620a9.js');
-const typeGuard = require('./type-guard-a57ef3ac.js');
+const internalTranslationController = require('./internal-translation-controller-27bfc8c7.js');
+const internalCalendarPeriodFactory = require('./internal-calendar-period-factory-b11918ee.js');
+const codeBlock = require('./code-block-3b42c364.js');
+const contentState = require('./content-state-87a06c1a.js');
+const typeGuard = require('./type-guard-00b8efc0.js');
+const linkExtension = require('./link-extension-71eeaa9f.js');
 const internalIconManager = require('./internal-icon-manager-40bcac72.js');
 const vegaNonceManager = require('./vega-nonce-manager-df69d3ed.js');
 const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-c82df135.js');
 const vegaEventId = require('./vega-event-id-58afed7a.js');
-const splitCellOperation = require('./split-cell-operation-873d5db7.js');
+const splitCellOperation = require('./split-cell-operation-ef783850.js');
 const changeManager = require('./change-manager-a297e4d2.js');
 const vegaInternalEventId = require('./vega-internal-event-id-f4d33037.js');
 const remoteInvocationRegistry = require('./remote-invocation-registry-fc22fdd0.js');
-const darkModeStyleController = require('./dark-mode-style-controller-32d4054a.js');
+const darkModeStyleController = require('./dark-mode-style-controller-f3da3342.js');
 const tryGetDocument = require('./try-get-document-c0ebd39a.js');
 const pixel = require('./pixel-98f2a10c.js');
 const object = require('./object-b53e9416.js');
 const timer = require('./timer-5f33058b.js');
 const string = require('./string-39438062.js');
-const imageExtension = require('./image-extension-260fa69c.js');
+const imageExtension = require('./image-extension-ccda26d3.js');
 const copy = require('./copy-d021c780.js');
 
 const VegaLoaderRuntimeMetricsPayloadDefinition = [
@@ -1105,7 +1105,7 @@ class VegaRTEToolbarButtonRenderer {
    * @returns {Nullable<RTEExtensionContext>} - The extension context associated with the host.
    */
   getExtensionContext(el) {
-    return linkExtension.RTEExtensionContextManager.getExtensionContext(el);
+    return linkExtension.extensionContextManager.getExtensionContext(el);
   }
   /**
    * Renders a dropdown component with the specified properties and children.
@@ -1117,7 +1117,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;
@@ -1201,29 +1201,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.DomNodeSubjectObserverFactory.addUniqueObserverToNode(el, vegaEventId.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: internalIconManager.VegaInternalIconManager.getIconKey('chevron-down'),
+          'size': 'size-8',
+          'color': isDisabled ? 'text-disabled' : 'text-secondary',
+          'style': { marginLeft: '8px' },
+          'aria-hidden': 'true',
+          'icon': internalIconManager.VegaInternalIconManager.getIconKey('chevron-down'),
         })
         : null,
     ].filter(typeGuard.isNonNullable));
@@ -1244,8 +1246,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;
@@ -1277,6 +1280,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.
    *
@@ -1330,14 +1342,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') {
@@ -1355,7 +1367,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;
       }
     }
@@ -1425,6 +1437,7 @@ class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return this.renderDropdown(createElement, editorContext, {}, [
       this.renderButton(createElement, editorContext, {
         label: 'Tokens',
+        ariaLabel: 'Tokens',
         showArrowIcon: true,
         tooltip: { text: 'Insert token' },
       }),
@@ -1544,6 +1557,47 @@ class RTETokenNode extends codeBlock.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 (codeBlock.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(typeGuard.isNonNullable);
+    return attrs.length > 0 ? ` ${attrs.join(' ')}` : '';
+  }
 }
 RTETokenNode.dtoName = 'RTETokenNode';
 
@@ -1667,6 +1721,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' },
       }),
@@ -1682,10 +1737,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));
@@ -1855,6 +1911,7 @@ class VegaRTELanguageExtension extends linkExtension.VegaRTEExtension {
           options = {
             autoMatchFormat: (_a = host.sourceEditConfig.autoMatchFormat) !== null && _a !== void 0 ? _a : true,
             filterInlineStyles: host.sourceEditConfig.filterInlineStyles,
+            blockBoundaryRegistry: this.extensionContext.blockBoundaryRegistry,
           };
         }
         result = contentState.VegaRTEContent.fromHtml(codeBlock.value.code, options);
@@ -1880,6 +1937,15 @@ class InsertFunctionBlockAction extends codeBlock.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
  */
@@ -1899,7 +1965,7 @@ class RTEFunctionBlock extends codeBlock.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;
@@ -1917,14 +1983,14 @@ class RTEFunctionBlock extends codeBlock.RTEBlock {
       .map((child) => {
       if (child instanceof codeBlock.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}" ${codeBlock.RTE_BLOCK_BOUNDARY_ATTRIBUTE}>${childrenHtml}</div>`;
   }
   /**
    * @inheritDoc
@@ -1945,6 +2011,15 @@ class RTEFunctionBlock extends codeBlock.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
    */
@@ -2018,7 +2093,7 @@ class InsertFunctionBlockStrategy extends codeBlock.ActionHandleStrategy {
         {
           id: `${id}-2`,
           annotations: {
-            customClass: ['statementelement'],
+            customClass: [FUNCTION_CONTENT_CLASS],
           },
           type: 'paragraph',
           nodes: [
@@ -2037,7 +2112,7 @@ class InsertFunctionBlockStrategy extends codeBlock.ActionHandleStrategy {
         {
           id: `${id}-4`,
           annotations: {
-            customClass: ['statementelement'],
+            customClass: [FUNCTION_CONTENT_CLASS],
           },
           type: 'paragraph',
           nodes: [
@@ -2137,6 +2212,12 @@ class RTELogicControlNode extends codeBlock.RTENode {
   isContentEditable() {
     return false;
   }
+  /**
+   * @inheritDoc
+   */
+  getPlainText() {
+    return this.text;
+  }
 }
 RTELogicControlNode.dtoName = 'RTELogicControlNode';
 
@@ -2188,7 +2269,7 @@ class RTELogicControlBlock extends codeBlock.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.
@@ -2225,6 +2306,7 @@ class FunctionToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return this.renderDropdown(h, editorContext, {}, [
       this.renderButton(h, editorContext, {
         label: 'Functions',
+        ariaLabel: 'Functions',
         showArrowIcon: true,
         tooltip: { text: 'Insert function' },
       }),
@@ -2296,7 +2378,7 @@ class RTELogicControlBlockRenderer extends linkExtension.VegaRTEExtensionRendere
   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`,
@@ -2306,13 +2388,48 @@ class RTELogicControlBlockRenderer extends linkExtension.VegaRTEExtensionRendere
   }
 }
 
+/**
+ * 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(codeBlock.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(codeBlock.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 contentState.BlockToRTEBlockStrategyAbstract {
   constructor() {
     super(...arguments);
-    this.blockClassName = 'statementsyntax';
+    this.blockClassName = FUNCTION_SYNTAX_CLASS;
   }
   /**
    * @inheritDoc
@@ -2355,7 +2472,7 @@ class DivToLogicControlBlockStrategy extends contentState.BlockToRTEBlockStrateg
    * @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));
   }
 }
 
@@ -2368,11 +2485,13 @@ class DivToFunctionBlockStrategy extends contentState.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;
   }
@@ -2384,7 +2503,7 @@ class DivToFunctionBlockStrategy extends contentState.ElementToDTOStrategy {
       id: misc.generateUUID(),
       type: 'function-block',
       annotations: {
-        customClass: ['statement'],
+        customClass: [FUNCTION_BLOCK_CLASS],
       },
       children: [],
     });
@@ -2412,7 +2531,7 @@ class DivToFunctionBlockStrategy extends contentState.ElementToDTOStrategy {
 class DivToFunctionContentStrategy extends DivToLogicControlBlockStrategy {
   constructor() {
     super(...arguments);
-    this.blockClassName = 'statementelement';
+    this.blockClassName = FUNCTION_CONTENT_CLASS;
   }
   /**
    * @inheritDoc
@@ -2420,16 +2539,31 @@ class DivToFunctionContentStrategy extends DivToLogicControlBlockStrategy {
   handle(elementsArray, options) {
     const element = elementsArray[0];
     const annotations = contentState.htmlElementToAnnotationGenerator.generate(codeBlock.RTETextBlock, element);
-    const nodes = Array.from(elementsArray[0].childNodes);
     return codeBlock.RTETextBlock.from({
       id: misc.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 contentState.HtmlBlockStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray, currentIndex) {
+    const element = elementsArray[currentIndex];
+    if (element.nodeType !== Node.ELEMENT_NODE)
+      return 0;
+    const containsFunctionBlock = !!element.querySelector(`[${codeBlock.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}";
 
 /**
@@ -2443,6 +2577,7 @@ class RTEFunctionBlockRenderer extends linkExtension.VegaRTEExtensionRenderer {
     return createElement('div', {
       key: renderData.id,
       class: this.getElementClassName(renderData),
+      [codeBlock.RTE_BLOCK_BOUNDARY_ATTRIBUTE]: '',
       ref: this.useRef(renderData),
     });
   }
@@ -2462,8 +2597,8 @@ class RTEFunctionBlockRenderer extends linkExtension.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();
   }
@@ -2637,12 +2772,14 @@ class PastePlainTextStrategy extends codeBlock.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 linkExtension.VegaRTEExtension {
   constructor() {
     super();
+    this.unregisterBlockBoundaryPredicate = null;
     this.registerBlockBasicStrategies(RTELogicControlBlock.name);
     this.registerBlockBasicStrategies(RTEFunctionBlock.name);
     this.preventFunctionBlockDefaultInsertNewParagraph();
@@ -2653,11 +2790,25 @@ class VegaRTEFunctionExtension extends linkExtension.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
    */
@@ -2682,7 +2833,7 @@ class VegaRTEFunctionExtension extends linkExtension.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';
 /**
@@ -3300,9 +3451,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;
   }
   /**
@@ -3312,9 +3496,124 @@ class TablePopoverBaseRenderer {
    */
   getTableExtensionContext() {
     return this.renderContext
-      ? linkExtension.RTEExtensionContextManager.getExtensionContext(this.renderContext.host)
+      ? linkExtension.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;
+    }
+  }
 }
 
 /**
@@ -3384,6 +3683,8 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
    * and clears the internal reference.
    */
   destroy() {
+    this.setEditorContentInert(false);
+    this.detachEscapeTracker();
     if (this.selectionAnchorRef && this.selectionAnchorRef.parentNode) {
       domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.removeUniqueObserverFromNode(this.selectionAnchorRef, vegaInternalEventId.VegaInternalRTEExtensionTableCellsSelectionAnchor);
       this.selectionAnchorRef.parentNode.removeChild(this.selectionAnchorRef);
@@ -3396,8 +3697,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 = [];
@@ -3417,6 +3723,11 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
     this.storeCurrentFocusNode();
     remoteInvocationRegistry.remoteInvocationRegistry.call(domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubject(this.popoverRef, vegaInternalEventId.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.
@@ -3451,7 +3762,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';
@@ -3478,6 +3793,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.
    *
@@ -3515,6 +3852,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 === splitCellOperation.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.
@@ -3609,6 +3988,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.remoteInvocationRegistry.call(domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubject(this.popoverRef, vegaInternalEventId.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.
      *
@@ -3621,11 +4056,16 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
         extensionContext && handler.execute(event.detail, extensionContext, this.tableBlock);
         if (event.detail[0] === splitCellOperation.TableSettingType.CAPTION) {
           this.updateTableSettingCaption();
+          this.moveFocusToCaption();
         }
       }
       if (event.detail[0] === splitCellOperation.TableSettingType.TABLE || event.detail[0] === splitCellOperation.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);
       }
     };
     /**
@@ -3633,6 +4073,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(splitCellOperation.RTETableColorManager.getTableColors(), renderContext);
   }
@@ -3641,6 +4092,8 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
    */
   destroy() {
     this.tableDynamicPopover.destroy();
+    this.setEditorContentInert(false);
+    this.detachEscapeTracker();
     if (this.popoverContainer) {
       this.popoverContainer.remove();
     }
@@ -3661,6 +4114,10 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
       popover.isScreenPosition = true;
       popover.className = 'rte-table-setting-popover';
       domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(popover, vegaEventId.VegaPopoverShow, this.handleTableSettingPopoverShow);
+      domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(popover, vegaEventId.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');
@@ -3673,6 +4130,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.
    */
@@ -3682,6 +4158,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.
    *
@@ -3696,6 +4201,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.
    *
@@ -3721,7 +4242,7 @@ class RTETableBlockRenderer extends linkExtension.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(splitCellOperation.RTETableExtensionAnnotationTypeEnum.TABLE);
     const children = rteContext.editable
@@ -3745,9 +4266,16 @@ class RTETableBlockRenderer extends linkExtension.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]),
         ]),
@@ -3761,6 +4289,11 @@ class RTETableBlockRenderer extends linkExtension.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);
     /**
@@ -3789,17 +4322,151 @@ class RTETableBlockRenderer extends linkExtension.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.
    *
@@ -3902,9 +4569,9 @@ class RTETableCellRenderer extends linkExtension.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.
@@ -4183,6 +4850,7 @@ class RTETableToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return createTablePopoverRenderer.render(h, super.renderButton(h, editorContext, {
       showArrowIcon: true,
       icon: 'rte-table',
+      ariaLabel: 'Table',
       tooltip: { text: 'Insert table' },
     }));
   }
@@ -4363,16 +5031,10 @@ class RTETableCaptionRenderer extends linkExtension.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(typeGuard.isNonNullable)
-        .join(' '),
-      'data-placeholder': TABLE_CAPTION_PLACEHOLDER_TEXT,
-    });
+        .join(' '), 'data-placeholder': TABLE_CAPTION_PLACEHOLDER_TEXT }));
   }
 }
 
@@ -5168,11 +5830,36 @@ class RTETableSelection {
       const commonAncestorContainer = range.commonAncestorContainer;
       const rangeInTable = !!ui.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 = codeBlock.stateEntityRenderingRegistry.getEntityByDOM(cellRef);
+    return cellBlock ? [cellBlock] : [];
+  }
   /**
    * Mark the beginning of a drag operation.
    */
@@ -7741,6 +8428,7 @@ class RTEHorizontalLineToolbarButtonRenderer extends VegaRTEToolbarButtonRendere
   render(createElement, editorContext) {
     return this.renderButton(createElement, editorContext, {
       icon: 'horizontal-line',
+      ariaLabel: internalTranslationController.VegaInternalTranslation.t('Horizontal line'),
       tooltip: { text: internalTranslationController.VegaInternalTranslation.t('Horizontal line') },
     });
   }
@@ -8336,6 +9024,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' },
     });
   }
@@ -8968,6 +9657,7 @@ class RTESpecialCharactersToolbarButtonRenderer extends VegaRTEToolbarButtonRend
       placement: 'bottom',
       showArrow: false,
       isScreenPosition: true,
+      role: 'presentation',
       // eslint-disable-next-line jsdoc/require-jsdoc
       ref: (ref) => {
         if (ref) {
@@ -8995,6 +9685,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' },
       })),
     ]);
@@ -10208,14 +10899,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.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, vegaEventId.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.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, vegaEventId.VegaPopoverShow, () => {
             this.isPopoverOpen = true;
@@ -10246,6 +10945,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: internalTranslationController.VegaInternalTranslation.t('Find and replace') },
       })),
     ]);
@@ -10348,13 +11048,54 @@ class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
       void this.popoverRef.hide();
     }
   }
-}
-(() => {
-  internalIconManager.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 = ui.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;
+  }
+}
+(() => {
+  internalIconManager.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,
@@ -10509,12 +11250,28 @@ class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     }, [
       this.renderButton(createElement, editorContext, {
         icon: 'line-height',
+        ariaLabel: editorContext.translation.t('Line Height'),
         showArrowIcon: true,
         tooltip: { text: internalTranslationController.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
    */
@@ -10816,6 +11573,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
           ? internalTranslationController.VegaInternalTranslation.t('Exit fullscreen mode')
@@ -10990,225 +11750,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 linkExtension.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', internalTranslationController.VegaInternalTranslation.t('Paste options'));
+    triggerButton.setAttribute('arrow-icon', arrowIcon);
+    triggerButton.icon = 'rte-paste';
+    triggerButton.showArrowIcon = true;
+    triggerButton.selected = false;
+    this.triggerButtonEl = triggerButton;
+    const tooltipEl = doc.createElement('vega-tooltip');
+    tooltipEl.text = internalTranslationController.VegaInternalTranslation.t('Paste options');
+    tooltipEl.placement = ['bottom', 'top'];
+    tooltipEl.append(triggerButton);
+    dropdownEl.append(tooltipEl);
+    const itemsContainer = doc.createElement('div');
+    itemsContainer.setAttribute('slot', 'items');
+    const dropdownItems = [
+      this.createDropdownItem(doc, RTEPasteMode.RICH, internalTranslationController.VegaInternalTranslation.t('Use rich text'), RTEPasteChooserUI.CHOOSER_RICH_ATTR),
+    ];
+    if (this.options.showWordOption) {
+      dropdownItems.push(this.createDropdownItem(doc, RTEPasteMode.WORD, internalTranslationController.VegaInternalTranslation.t('Use Word'), RTEPasteChooserUI.CHOOSER_WORD_ATTR));
+    }
+    itemsContainer.append(...dropdownItems);
+    dropdownEl.append(itemsContainer);
+    dropdownEl.addEventListener('vegaDropdownClick', (event) => {
+      const mode = event.detail;
+      if (mode === RTEPasteMode.RICH || mode === RTEPasteMode.WORD) {
+        this.callbacks.onModeSelect(mode);
+      }
+    });
+    return dropdownEl;
+  }
+  /**
+   * Creates a single dropdown item element for a paste mode.
+   *
+   * @param {Document} doc Document used to create the element.
+   * @param {RTEPasteMode} key Paste mode key for the item.
+   * @param {string} label Display label for the item.
+   * @param {string} dataAttrName Data attribute marker for the item.
+   * @returns {HTMLVegaDropdownItemElement} Configured dropdown item element.
+   */
+  createDropdownItem(doc, key, label, dataAttrName) {
+    const itemEl = doc.createElement('vega-dropdown-item');
+    itemEl.itemKey = key;
+    itemEl.label = label;
+    itemEl.setAttribute(dataAttrName, 'true');
+    return itemEl;
+  }
+}
+(() => {
+  internalIconManager.VegaInternalIconManager.register({
+    'rte-paste': paste,
+  });
+})();
+RTEPasteChooserUI.CHOOSER_ATTR = 'data-rte-paste-chooser';
+RTEPasteChooserUI.CHOOSER_RICH_ATTR = 'data-rte-paste-type-rich';
+RTEPasteChooserUI.CHOOSER_WORD_ATTR = 'data-rte-paste-type-word';
+RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR = 'data-rte-paste-trigger';
+
+/**
+ * Default paste processing strategy that acts as a fallback when no other
+ * strategy matches. This strategy always accepts the content and passes it
+ * through unchanged — the normal RTE paste pipeline (DOMParser +
+ * ElementToDtoStrategyProcessor) handles the rest.
+ */
+class DefaultPasteProcessingStrategy extends AbstractPasteProcessingStrategy {
+  /**
+   * Always matches as the terminal fallback strategy.
+   *
+   * @param {string} html Raw clipboard HTML.
+   * @returns {boolean} Always `true`.
+   */
+  canHandle(html) {
+    // Default strategy is the fallback — always returns true.
+    return html !== undefined;
+  }
+  /**
+   * Returns the original HTML unchanged.
+   *
+   * @param {string} html Raw clipboard HTML.
+   * @returns {string} Unchanged HTML.
+   */
+  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 = contentState.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 = misc.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 codeBlock.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 linkExtension.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 codeBlock.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', internalTranslationController.VegaInternalTranslation.t('Paste options'));
-    triggerButton.setAttribute('arrow-icon', arrowIcon);
-    triggerButton.icon = 'rte-paste';
-    triggerButton.showArrowIcon = true;
-    triggerButton.selected = false;
-    this.triggerButtonEl = triggerButton;
-    const tooltipEl = doc.createElement('vega-tooltip');
-    tooltipEl.text = internalTranslationController.VegaInternalTranslation.t('Paste options');
-    tooltipEl.placement = ['bottom', 'top'];
-    tooltipEl.append(triggerButton);
-    dropdownEl.append(tooltipEl);
-    const itemsContainer = doc.createElement('div');
-    itemsContainer.setAttribute('slot', 'items');
-    itemsContainer.append(this.createDropdownItem(doc, 'rich', internalTranslationController.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);
+    }
   }
 }
-(() => {
-  internalIconManager.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 linkExtension.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.
@@ -11224,6 +14566,9 @@ class VegaRTEPasteExtension extends linkExtension.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();
@@ -11235,6 +14580,10 @@ class VegaRTEPasteExtension extends linkExtension.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);
     };
     /**
@@ -11268,6 +14617,7 @@ class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
     this.handleOutsideScroll = () => {
       this.clearPasteChooser();
     };
+    this.options = options;
   }
   /** @inheritDoc */
   initialExtensionAfterLoad(context) {
@@ -11279,6 +14629,7 @@ class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
   destroyExtension() {
     this.detachPasteListener();
     this.clearPasteChooser();
+    this.pendingImageRegistry.discardUnsentPreviews();
   }
   /**
    * Attaches the paste listener to the editable element.
@@ -11341,7 +14692,7 @@ class VegaRTEPasteExtension extends linkExtension.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;
@@ -11353,6 +14704,8 @@ class VegaRTEPasteExtension extends linkExtension.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;
@@ -11482,7 +14835,10 @@ class VegaRTEPasteExtension extends linkExtension.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;
@@ -11498,9 +14854,42 @@ class VegaRTEPasteExtension extends linkExtension.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
@@ -11574,7 +14963,7 @@ class VegaRTEPasteExtension extends linkExtension.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) {
@@ -11587,7 +14976,7 @@ class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
         dataTransfer.setData('text/plain', text);
       }
       if (mode) {
-        dataTransfer.setData(RTE_PASTE_MODE_DATA_TYPE, mode);
+        dataTransfer.setData(codeBlock.RTE_PASTE_MODE_DATA_TYPE, mode);
       }
       return dataTransfer;
     }
@@ -11600,7 +14989,7 @@ class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
         if (type === 'text/plain') {
           return text;
         }
-        if (type === RTE_PASTE_MODE_DATA_TYPE) {
+        if (type === codeBlock.RTE_PASTE_MODE_DATA_TYPE) {
           return mode !== null && mode !== void 0 ? mode : '';
         }
         return '';
@@ -11635,6 +15024,9 @@ class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
     }
   }
 }
+(() => {
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.RTEImageNode.name, REPLACE_IMAGE_SRC, new ImageReplaceSrcStrategy());
+})();
 
 /**
  * Action to extract the currently selected content (HTML and plain text) from the editor.
@@ -11672,6 +15064,7 @@ class RTECopyToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
   render(h, editorContext) {
     return this.renderButton(h, editorContext, {
       icon: 'rte-copy',
+      ariaLabel: editorContext.translation.t('Copy'),
       tooltip: { text: 'Copy' },
     });
   }
@@ -11987,6 +15380,7 @@ class RTECutToolbarButtonRenderer extends RTECopyToolbarButtonRenderer {
   render(h, editorContext) {
     return this.renderButton(h, editorContext, {
       icon: 'rte-cut',
+      ariaLabel: editorContext.translation.t('Cut'),
       tooltip: { text: 'Cut' },
     });
   }
@@ -12025,6 +15419,130 @@ class VegaRTECutExtension extends linkExtension.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 (!typeGuard.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'] === codeBlock.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 linkExtension.VegaRTEExtension {
+  constructor(config = {}) {
+    super();
+    /**
+     * Runtime discriminator used by the core to identify this extension.
+     */
+    this.type = codeBlock.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.
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(contentState.VegaRTEContent.name, contentState.COMMIT_VALUE, new PreventHardLimitExceedInterceptor());
+})();
+
 /**
  * Insert a new children to the nearest position of the parent container
  *
@@ -12089,7 +15607,7 @@ class SpanToTokenNodeStrategy extends contentState.ElementToDTOStrategy {
   /**
    * @inheritDoc
    */
-  handle(elementsArray) {
+  handle(elementsArray, _options, parentTextAnnotations) {
     const element = elementsArray[0];
     const tokenKey = element.getAttribute('token-key');
     const text = element.textContent;
@@ -12102,7 +15620,9 @@ class SpanToTokenNodeStrategy extends contentState.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) }),
     };
   }
   /**
@@ -12186,6 +15706,7 @@ exports.VegaRTESpecialCharactersText = VegaRTESpecialCharactersText;
 exports.VegaRTETableExtension = VegaRTETableExtension;
 exports.VegaRTETokenExtension = VegaRTETokenExtension;
 exports.VegaRTEToolbarButtonRenderer = VegaRTEToolbarButtonRenderer;
+exports.VegaRTEWordCountExtension = VegaRTEWordCountExtension;
 exports.VegaSkeletonLoader = VegaSkeletonLoader;
 exports.VegaTranslation = VegaTranslation;
 exports.VegaZIndexManager = VegaZIndexManager$1;