@globalpayments/vega 2.98.0 → 2.99.0

package/dist/collection/components/vega-rich-text-editor/extensions/paste/word-paste-transformers/word-structure-paragraph-transformer.js

@@ -0,0 +1,112 @@
+import { WORD_SANITIZE_ALL_TAGS_KEY } from './word-structure-transformer';
+/** 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.
+ */
+export class WordParagraphRoleTransformer {
+  /** @inheritDoc */
+  apply(root) {
+    // Strip any pre-existing data-type attributes so untrusted source values
+    // can never influence the role resolution.
+    Array.from(root.querySelectorAll('[data-type]')).forEach((element) => {
+      element.removeAttribute('data-type');
+    });
+    Array.from(root.querySelectorAll('p')).forEach((paragraph) => {
+      const rawClass = paragraph.getAttribute('class');
+      const role = this.resolveRole(rawClass);
+      // Drop the Word paragraph class once its role has been extracted so
+      // that Word artifacts (e.g. `MsoTitle`, `MsoNormal`) never leak into
+      // the sanitized output.
+      if (rawClass !== null) {
+        paragraph.removeAttribute('class');
+      }
+      if (role) {
+        // Encode the role as an RTE text-style CSS class so the downstream
+        // DTO processor can resolve it via getElementTypeByClassName().
+        paragraph.classList.add(`${RTE_TEXT_STYLE_CLASS_PREFIX}${role}`);
+      }
+    });
+  }
+  /** @inheritDoc */
+  getAllowedTags() {
+    return [
+      'P',
+      'BR',
+      'SPAN',
+      'STRONG',
+      'B',
+      'EM',
+      'I',
+      'U',
+      'S',
+      'STRIKE',
+      'DEL',
+      'H1',
+      'H2',
+      'H3',
+      'H4',
+      'H5',
+      'H6',
+      'A',
+      // Inline `<code>` is treated as an inline text annotation (like
+      // STRONG/EM/U) and therefore lives with the paragraph/inline
+      // allowlist. Block-level `<pre>` code blocks are owned by
+      // {@link WordCodeBlockTransformer}.
+      'CODE',
+    ];
+  }
+  /** @inheritDoc */
+  getAllowedAttributes() {
+    // `class` must be preserved so this transformer can parse Word paragraph
+    // roles (e.g., MsoTitle, MsoSubtitle, MsoHeadingN) in Phase 1. These classes
+    // are ultimately stripped when pasting in autoMatchFormat mode.
+    return new Map([
+      [WORD_SANITIZE_ALL_TAGS_KEY, ['class', 'style']],
+      ['A', ['href', 'target', 'title']],
+    ]);
+  }
+  /** @inheritDoc */
+  getAllowedStyles() {
+    return [
+      'color',
+      'background',
+      'text-align',
+      'text-indent',
+      'text-decoration',
+      'margin',
+      'padding',
+      'font',
+      'line-height',
+      'letter-spacing',
+      'vertical-align',
+    ];
+  }
+  /**
+   * Resolves the RTE text style for a Word paragraph class name.
+   *
+   * @param {string | null} className Raw `class` attribute value.
+   * @returns {WordParagraphRole | null} Matched role or `null`.
+   */
+  resolveRole(className) {
+    if (!className) {
+      return null;
+    }
+    const normalized = className.toLowerCase();
+    const headingMatch = /msoheading([1-6])/.exec(normalized);
+    if (headingMatch) {
+      return `heading-${headingMatch[1]}`;
+    }
+    if (/msosubtitle/.test(normalized)) {
+      return 'subtitle';
+    }
+    if (/msotitle/.test(normalized)) {
+      return 'title';
+    }
+    return null;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/paste/word-paste-transformers/word-structure-table-transformer.js

@@ -0,0 +1,551 @@
+/**
+ * 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 = '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.
+ */
+export 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);
+    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) || '';
+    if (this.styleHasProperty(existing, property)) {
+      return;
+    }
+    const prefix = existing.trim() === '' ? '' : `${existing.replace(/;\s*$/, '')}; `;
+    element.setAttribute(PRESERVED_STYLE_ATTR, `${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);
+    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, kept.join('; '));
+    }
+    else {
+      element.removeAttribute(PRESERVED_STYLE_ATTR);
+    }
+  }
+  /**
+   * 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);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/paste/word-paste-transformers/word-structure-transformer.js

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+export const WORD_SANITIZE_ALL_TAGS_KEY = '*';

package/dist/collection/components/vega-rich-text-editor/extensions/table/dto/table-block.js

@@ -44,6 +44,16 @@ export class RTETableBlock extends RTEBlock {
   getLastNode() {
     return this.children[this.children.length - 1].getLastNode();
   }
+  /**
+   * The table is an atomic caret boundary: resolving a caret on its boundary must keep
+   * it anchored to the table block (so paragraph-insertion before/after works) rather
+   * than descending into a cell.
+   *
+   * @inheritDoc
+   */
+  allowsCaretDescend() {
+    return false;
+  }
   /**
    * Get the first node of the table block.
    *