@heartlandone/vega 2.97.0 → 2.99.0

package/dist/cjs/{token-extension-608bbf7b.js → token-extension-4686cb3b.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-71c27ff3.js');
-const codeBlock = require('./code-block-28a7732e.js');
-const contentState = require('./content-state-e2ab0f06.js');
-const typeGuard = require('./type-guard-a57ef3ac.js');
+const internalTranslationController = require('./internal-translation-controller-51f7f865.js');
+const internalCalendarPeriodFactory = require('./internal-calendar-period-factory-6196bc80.js');
+const codeBlock = require('./code-block-ea1f5eb3.js');
+const contentState = require('./content-state-8d07d530.js');
+const typeGuard = require('./type-guard-b8d7bb3f.js');
+const linkExtension = require('./link-extension-11340e1c.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-51097409.js');
+const splitCellOperation = require('./split-cell-operation-11bfb305.js');
 const changeManager = require('./change-manager-a297e4d2.js');
-const vegaInternalEventId = require('./vega-internal-event-id-ecc5b87a.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-1e3eeaa3.js');
+const imageExtension = require('./image-extension-9659708b.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.
@@ -1544,6 +1544,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';
 
@@ -1855,6 +1896,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 +1922,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 +1950,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 +1968,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 +1996,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 +2078,7 @@ class InsertFunctionBlockStrategy extends codeBlock.ActionHandleStrategy {
         {
           id: `${id}-2`,
           annotations: {
-            customClass: ['statementelement'],
+            customClass: [FUNCTION_CONTENT_CLASS],
           },
           type: 'paragraph',
           nodes: [
@@ -2037,7 +2097,7 @@ class InsertFunctionBlockStrategy extends codeBlock.ActionHandleStrategy {
         {
           id: `${id}-4`,
           annotations: {
-            customClass: ['statementelement'],
+            customClass: [FUNCTION_CONTENT_CLASS],
           },
           type: 'paragraph',
           nodes: [
@@ -2188,7 +2248,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.
@@ -2296,7 +2356,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 +2366,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 +2450,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 +2463,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 +2481,7 @@ class DivToFunctionBlockStrategy extends contentState.ElementToDTOStrategy {
       id: misc.generateUUID(),
       type: 'function-block',
       annotations: {
-        customClass: ['statement'],
+        customClass: [FUNCTION_BLOCK_CLASS],
       },
       children: [],
     });
@@ -2412,7 +2509,7 @@ class DivToFunctionBlockStrategy extends contentState.ElementToDTOStrategy {
 class DivToFunctionContentStrategy extends DivToLogicControlBlockStrategy {
   constructor() {
     super(...arguments);
-    this.blockClassName = 'statementelement';
+    this.blockClassName = FUNCTION_CONTENT_CLASS;
   }
   /**
    * @inheritDoc
@@ -2420,16 +2517,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 +2555,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 +2575,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 +2750,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 +2768,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
    */
@@ -3312,7 +3441,7 @@ class TablePopoverBaseRenderer {
    */
   getTableExtensionContext() {
     return this.renderContext
-      ? linkExtension.RTEExtensionContextManager.getExtensionContext(this.renderContext.host)
+      ? linkExtension.extensionContextManager.getExtensionContext(this.renderContext.host)
       : null;
   }
 }
@@ -11042,6 +11171,62 @@ class VegaRTEFullscreenExtension extends linkExtension.VegaRTEExtension {
 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>`,
 };
@@ -11050,9 +11235,10 @@ const paste = {
  * Renders and manages the paste format chooser UI.
  */
 class RTEPasteChooserUI {
-  constructor(hostRoot, callbacks) {
+  constructor(hostRoot, callbacks, options = {}) {
     this.hostRoot = hostRoot;
     this.callbacks = callbacks;
+    this.options = options;
     this.chooserEl = null;
     this.dropdownEl = null;
     this.triggerButtonEl = null;
@@ -11153,11 +11339,17 @@ class RTEPasteChooserUI {
     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));
+    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 === 'rich') {
+      if (mode === RTEPasteMode.RICH || mode === RTEPasteMode.WORD) {
         this.callbacks.onModeSelect(mode);
       }
     });
@@ -11167,7 +11359,7 @@ class RTEPasteChooserUI {
    * Creates a single dropdown item element for a paste mode.
    *
    * @param {Document} doc Document used to create the element.
-   * @param {PasteMode} key Paste mode key for the item.
+   * @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.
@@ -11187,161 +11379,2689 @@ class RTEPasteChooserUI {
 })();
 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';
 
 /**
- * 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.
+ * 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.
  */
-const RTE_PASTE_MODE_DATA_TYPE = 'application/x-vega-rte-paste-mode';
+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;
+  }
+}
 
 /**
- * Vega Rich Text Editor paste extension.
- * Intercepts keyboard paste and allows users to choose paste mode.
+ * 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.
  */
-class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
-  constructor() {
-    super(...arguments);
-    this.editableEl = null;
-    this.contentHostEl = null;
-    this.chooserUI = null;
-    this.pendingPastePayload = null;
-    this.listenerDocument = null;
-    this.listenerWindow = null;
-    /**
-     * Handles a native paste event by capturing the clipboard payload and
-     * rendering the paste-mode chooser.
-     *
-     * @param {ClipboardEvent} event Native clipboard paste event.
-     */
-    this.handlePasteEvent = (event) => {
-      var _a, _b;
-      const clipboardData = event.clipboardData;
-      if (!clipboardData) {
-        return;
-      }
-      // HTML is sanitized via DOMParser and ElementToDtoStrategyProcessor pipeline
-      const html = clipboardData.getData('text/html') || '';
-      const text = clipboardData.getData('text/plain') || '';
-      if (!html && !text) {
-        // Empty clipboard paste should not mutate editor content.
-        event.preventDefault();
-        event.stopPropagation();
-        return;
-      }
-      event.preventDefault();
-      event.stopPropagation();
-      const range = this.cloneCurrentSelectionRange();
-      const selectedNodes = ((_b = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelectedNodes) === null || _b === void 0 ? void 0 : _b.call(_a)) || [];
-      this.pendingPastePayload = { html, text, range, selectedNodes: [...selectedNodes] };
-      this.renderPasteChooser(event);
-    };
-    /**
-     * Dismisses the chooser when a pointer interaction occurs outside of it.
-     *
-     * @param {Event} event Pointer event captured on the document.
-     */
-    this.handleOutsidePointerDown = (event) => {
-      if (!this.chooserUI) {
-        return;
-      }
-      const eventPath = typeof event.composedPath === 'function' ? event.composedPath() : [];
-      if (this.chooserUI.includesEventPath(eventPath)) {
-        return;
-      }
-      this.clearPasteChooser();
-    };
-    /**
-     * Dismisses the chooser when the Escape key is pressed.
-     *
-     * @param {KeyboardEvent} event Keyboard event captured on the document.
-     */
-    this.handleOutsideKeyDown = (event) => {
-      if (event.key === 'Escape') {
-        this.clearPasteChooser();
+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}`);
       }
-    };
-    /**
-     * Dismisses the chooser when any relevant scroll container scrolls.
-     */
-    this.handleOutsideScroll = () => {
-      this.clearPasteChooser();
-    };
+    });
   }
   /** @inheritDoc */
-  initialExtensionAfterLoad(context) {
-    super.initialExtensionAfterLoad(context);
-    this.hostEl = context.host;
-    this.attachPasteListener();
+  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 */
-  destroyExtension() {
-    this.detachPasteListener();
-    this.clearPasteChooser();
+  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',
+    ];
   }
   /**
-   * Attaches the paste listener to the editable element.
+   * 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`.
    */
-  attachPasteListener() {
-    const { editableEl, contentHostEl, } = this.getEditorElements();
-    this.editableEl = editableEl;
-    this.contentHostEl = contentHostEl;
-    if (this.editableEl) {
-      this.editableEl.addEventListener('paste', this.handlePasteEvent);
+  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'];
   }
   /**
-   * Detaches the paste listener from the editable element.
+   * 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.
    */
-  detachPasteListener() {
-    if (this.editableEl) {
-      this.editableEl.removeEventListener('paste', this.handlePasteEvent);
+  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);
+        }
+      });
     }
-    this.editableEl = null;
-    this.contentHostEl = null;
   }
   /**
-   * Resolves the content host and editable element from the host shadow tree.
+   * Converts the HTML `<ol type>` attribute into a preserved
+   * `list-style-type` declaration for every ordered list that carries one.
    *
-   * @returns {EditorElements} Editor elements.
+   * 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.
    */
-  getEditorElements() {
-    var _a, _b, _c, _d, _e;
-    const contentHostEl = (_c = (_b = (_a = this.hostEl) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('vega-rich-text-content')) !== null && _c !== void 0 ? _c : null;
-    const editableEl = (_e = (_d = contentHostEl === null || contentHostEl === void 0 ? void 0 : contentHostEl.shadowRoot) === null || _d === void 0 ? void 0 : _d.querySelector('.rich-text-content')) !== null && _e !== void 0 ? _e : null;
-    return { editableEl, contentHostEl };
+  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}`);
+    });
   }
   /**
-   * Resolves the editable content element from the host shadow tree.
+   * Walks a container, folding each contiguous run of Word list paragraphs
+   * into a nested list tree in place of the original paragraphs.
    *
-   * @returns {HTMLDivElement | null} Editable element or `null` when unavailable.
+   * @param {HTMLElement} container Element whose direct children may include list paragraphs.
    */
-  getEditableElement() {
-    const { editableEl } = this.getEditorElements();
-    return editableEl;
+  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);
+    }
   }
   /**
-   * Clones the current selection range so it can be restored after the user
-   * chooses a paste mode.
+   * Determines whether an element is a Word list paragraph.
    *
-   * @returns {Range | null} Cloned range or `null` when there is no selection.
+   * 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.
    */
-  cloneCurrentSelectionRange() {
-    var _a;
-    const selection = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelection();
-    if (selection && selection.rangeCount > 0) {
-      return selection.getRangeAt(0).cloneRange();
+  isWordListParagraph(element) {
+    if (element.tagName !== 'P') {
+      return false;
     }
-    return null;
+    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());
   }
   /**
-   * Renders the paste-mode chooser and wires up dismissal listeners.
+   * 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'));
+  }
+}
+PasteImageParser.PREVIEW_IMG_KEY = 'data-rte-id';
+
+const REPLACE_IMAGE_SRC = 'REPLACE_IMAGE_SRC';
+/**
+ * Action to replace the `src` attribute of an `<img>` element in the RTE content.
+ */
+class ImageReplaceSrcAction extends codeBlock.ModifyContentAction {
+  constructor(imageElement, url) {
+    super();
+    this.type = REPLACE_IMAGE_SRC;
+    this.img = imageElement;
+    this.url = url;
+  }
+}
+
+/**
+ * Strategy to handle the `ImageReplaceSrcAction` for replacing the `src` attribute of an `<img>` element in the RTE content.
+ */
+class ImageReplaceSrcStrategy extends codeBlock.ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  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];
+    }
+  }
+}
+
+/**
+ * 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 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 = [];
+  }
+  /**
+   * Registers freshly created previews so they can be notified and later
+   * resolved to their uploaded URLs.
+   *
+   * @param {PasteImagePreview[]} previews Previews produced for the current paste.
+   */
+  register(previews) {
+    this.pendingNotifyImageIds = [];
+    previews.forEach((preview) => {
+      this.pendingNotifyImageIds.push(preview.id);
+      this.ownedImageIds.add(preview.id);
+      PendingImageRegistry.pendingImages.set(preview.id, preview);
+    });
+  }
+  /**
+   * @returns {boolean} Whether previews are queued for notification.
+   */
+  hasPendingNotifications() {
+    return this.pendingNotifyImageIds.length > 0;
+  }
+  /**
+   * 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 {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.
+   */
+  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));
+    }
+  }
+  /**
+   * 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.
+   */
+  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);
+    });
+    this.pendingNotifyImageIds = [];
+  }
+  /**
+   * Applies the uploaded URL for a pending pasted image, replacing its local
+   * preview `src` and revoking the object URL.
+   *
+   * @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.
+   */
+  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);
+    }
+  }
+}
+/**
+ * Pasted images awaiting upload, keyed by their {@link VegaRTEPasteImage.id}.
+ *
+ * Shared statically across instances so previews survive a paste-extension
+ * re-instantiation: the consumer may resolve `replaceUrl` after the editor
+ * has re-mounted and created a new extension/registry instance.
+ */
+PendingImageRegistry.pendingImages = new Map();
+
+/**
+ * Vega Rich Text Editor paste extension.
+ * Intercepts keyboard paste and allows users to choose paste mode.
+ */
+class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
+  constructor(options = {}) {
+    super();
+    this.editableEl = null;
+    this.contentHostEl = null;
+    this.chooserUI = null;
+    this.pendingPastePayload = null;
+    this.listenerDocument = null;
+    this.listenerWindow = null;
+    this.options = {};
+    this.strategySelector = new PasteStrategySelector();
+    this.clipboardFileContent = null;
+    this.imageParser = new PasteImageParser();
+    /** Owns pending pasted-image previews awaiting upload and their URL replacement. */
+    this.pendingImageRegistry = new PendingImageRegistry();
+    /**
+     * Handles a native paste event by capturing the clipboard payload and
+     * rendering the paste-mode chooser.
+     *
+     * @param {ClipboardEvent} event Native clipboard paste event.
+     */
+    this.handlePasteEvent = (event) => {
+      var _a, _b;
+      const clipboardData = event.clipboardData;
+      if (!clipboardData) {
+        return;
+      }
+      // HTML is sanitized via DOMParser and ElementToDtoStrategyProcessor pipeline
+      const html = clipboardData.getData('text/html') || '';
+      const text = clipboardData.getData('text/plain') || '';
+      // RTF must be read synchronously here: the paste event's DataTransfer is only
+      // readable during event dispatch, so reading it later (after the chooser) returns ''.
+      const rtf = clipboardData.getData('text/rtf') || '';
+      if (!html && !text) {
+        // Empty clipboard paste should not mutate editor content.
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      const range = this.cloneCurrentSelectionRange();
+      const selectedNodes = ((_b = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelectedNodes) === null || _b === void 0 ? void 0 : _b.call(_a)) || [];
+      this.pendingPastePayload = { html, text, range, selectedNodes: [...selectedNodes] };
+      this.clipboardFileContent = {
+        files: clipboardData.files ? Array.from(clipboardData.files) : [],
+        rtf,
+      };
+      this.renderPasteChooser(event);
+    };
+    /**
+     * Dismisses the chooser when a pointer interaction occurs outside of it.
+     *
+     * @param {Event} event Pointer event captured on the document.
+     */
+    this.handleOutsidePointerDown = (event) => {
+      if (!this.chooserUI) {
+        return;
+      }
+      const eventPath = typeof event.composedPath === 'function' ? event.composedPath() : [];
+      if (this.chooserUI.includesEventPath(eventPath)) {
+        return;
+      }
+      this.clearPasteChooser();
+    };
+    /**
+     * Dismisses the chooser when the Escape key is pressed.
+     *
+     * @param {KeyboardEvent} event Keyboard event captured on the document.
+     */
+    this.handleOutsideKeyDown = (event) => {
+      if (event.key === 'Escape') {
+        this.clearPasteChooser();
+      }
+    };
+    /**
+     * Dismisses the chooser when any relevant scroll container scrolls.
+     */
+    this.handleOutsideScroll = () => {
+      this.clearPasteChooser();
+    };
+    this.options = options;
+  }
+  /** @inheritDoc */
+  initialExtensionAfterLoad(context) {
+    super.initialExtensionAfterLoad(context);
+    this.hostEl = context.host;
+    this.attachPasteListener();
+  }
+  /** @inheritDoc */
+  destroyExtension() {
+    this.detachPasteListener();
+    this.clearPasteChooser();
+    this.pendingImageRegistry.discardUnsentPreviews();
+  }
+  /**
+   * Attaches the paste listener to the editable element.
+   */
+  attachPasteListener() {
+    const { editableEl, contentHostEl, } = this.getEditorElements();
+    this.editableEl = editableEl;
+    this.contentHostEl = contentHostEl;
+    if (this.editableEl) {
+      this.editableEl.addEventListener('paste', this.handlePasteEvent);
+    }
+  }
+  /**
+   * Detaches the paste listener from the editable element.
+   */
+  detachPasteListener() {
+    if (this.editableEl) {
+      this.editableEl.removeEventListener('paste', this.handlePasteEvent);
+    }
+    this.editableEl = null;
+    this.contentHostEl = null;
+  }
+  /**
+   * Resolves the content host and editable element from the host shadow tree.
+   *
+   * @returns {EditorElements} Editor elements.
+   */
+  getEditorElements() {
+    var _a, _b, _c, _d, _e;
+    const contentHostEl = (_c = (_b = (_a = this.hostEl) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('vega-rich-text-content')) !== null && _c !== void 0 ? _c : null;
+    const editableEl = (_e = (_d = contentHostEl === null || contentHostEl === void 0 ? void 0 : contentHostEl.shadowRoot) === null || _d === void 0 ? void 0 : _d.querySelector('.rich-text-content')) !== null && _e !== void 0 ? _e : null;
+    return { editableEl, contentHostEl };
+  }
+  /**
+   * Resolves the editable content element from the host shadow tree.
+   *
+   * @returns {HTMLDivElement | null} Editable element or `null` when unavailable.
+   */
+  getEditableElement() {
+    const { editableEl } = this.getEditorElements();
+    return editableEl;
+  }
+  /**
+   * Clones the current selection range so it can be restored after the user
+   * chooses a paste mode.
+   *
+   * @returns {Range | null} Cloned range or `null` when there is no selection.
+   */
+  cloneCurrentSelectionRange() {
+    var _a;
+    const selection = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelection();
+    if (selection && selection.rangeCount > 0) {
+      return selection.getRangeAt(0).cloneRange();
+    }
+    return null;
+  }
+  /**
+   * Renders the paste-mode chooser and wires up dismissal listeners.
    *
    * @param {ClipboardEvent} pasteEvent Originating paste event used for positioning.
    */
   renderPasteChooser(pasteEvent) {
-    var _a, _b;
+    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 +14073,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 +14204,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 +14223,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 +14332,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 +14345,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 +14358,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 +14393,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.
@@ -12089,7 +14850,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 +14863,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) }),
     };
   }
   /**