@heartlandone/vega 2.97.0 → 2.99.0

package/dist/types/components/vega-rich-text-editor/extensions/paste/word-paste-transformers/word-structure-list-transformer.d.ts

@@ -0,0 +1,271 @@
+import { WordStructureTransformer } from './word-structure-transformer';
+/**
+ * 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.
+ */
+export declare class WordListRoleTransformer implements WordStructureTransformer {
+  /** @inheritDoc */
+  apply(root: HTMLElement): void;
+  /** @inheritDoc */
+  getAllowedTags(): string[];
+  /** @inheritDoc */
+  getAllowedAttributes(): Map<string, string[]>;
+  /** @inheritDoc */
+  getAllowedStyles(): string[];
+  /**
+   * 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.
+   */
+  private nestSiblingLists;
+  /**
+   * Converts the HTML `<ol type>` attribute into a preserved
+   * `list-style-type` declaration for every ordered list that carries one.
+   *
+   * Word can paste genuine `<ol>` elements (rather than flat list paragraphs)
+   * that encode alpha / Roman numbering via the legacy `type` attribute
+   * (`type=a`, `type=i`, `type=I`, …). The `type` attribute is not on the
+   * allowlist and would be dropped, losing the numbering style, so it is mapped
+   * onto `list-style-type` inside `data-style`. Decimal (`type=1`) lists are
+   * left untouched because a bare `<ol>` already renders as `1. 2. 3.`. An
+   * existing `list-style-type` declaration wins and is never overwritten.
+   *
+   * @param {HTMLElement} root Parsed body element.
+   */
+  private applyOrderedListTypeAttributes;
+  /**
+   * Walks a container, folding each contiguous run of Word list paragraphs
+   * into a nested list tree in place of the original paragraphs.
+   *
+   * @param {HTMLElement} container Element whose direct children may include list paragraphs.
+   */
+  private processContainer;
+  /**
+   * Determines whether an element is a Word list paragraph.
+   *
+   * A paragraph is only treated as a list when it carries a genuine Word list
+   * marker: either the `mso-list:l<n>` paragraph style, or the `MsoListParagraph`
+   * class **together with** an inner `mso-list:Ignore` marker span. The
+   * `MsoListParagraph` class alone is not sufficient — Word also uses that
+   * paragraph style for plain indented content (e.g. headings), which must not
+   * be folded into a `<ul>` / `<ol>`.
+   *
+   * @param {HTMLElement} element Candidate element.
+   * @returns {boolean} `true` when the element is a `<p>` carrying a Word list marker.
+   */
+  private isWordListParagraph;
+  /**
+   * 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.
+   */
+  private transformRun;
+  /**
+   * 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.
+   */
+  private needsSiblingList;
+  /**
+   * 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.
+   */
+  private readListStyleType;
+  /**
+   * 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.
+   */
+  private openNestedList;
+  /**
+   * 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.
+   */
+  private openSiblingList;
+  /**
+   * 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.
+   */
+  private attachList;
+  /**
+   * 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.
+   */
+  private createListElement;
+  /**
+   * 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.
+   */
+  private buildListItem;
+  /**
+   * 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).
+   */
+  private preserveMarkerPlaceholderImages;
+  /**
+   * 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).
+   */
+  private removeMarker;
+  /**
+   * 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.
+   */
+  private findMarker;
+  /**
+   * Reports whether an element has no meaningful (non-whitespace) content left.
+   *
+   * @param {HTMLElement} element Element to inspect.
+   * @returns {boolean} `true` when only whitespace remains.
+   */
+  private isEmptyElement;
+  /**
+   * Resolves the Word nesting depth for a list paragraph (defaults to 1).
+   *
+   * @param {HTMLElement} paragraph Word list paragraph.
+   * @returns {number} One-based nesting depth.
+   */
+  private resolveLevel;
+  /**
+   * 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.
+   */
+  private resolveListId;
+  /**
+   * 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.
+   */
+  private isOrderedMarker;
+  /**
+   * 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.
+   */
+  private resolveListStyleType;
+  /**
+   * 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.
+   */
+  private continuesAlphaList;
+  /**
+   * 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.
+   */
+  private resolveMarkerFont;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/word-paste-transformers/word-structure-paragraph-transformer.d.ts

@@ -0,0 +1,25 @@
+import { WordStructureTransformer } from './word-structure-transformer';
+/**
+ * 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 declare class WordParagraphRoleTransformer implements WordStructureTransformer {
+  /** @inheritDoc */
+  apply(root: HTMLElement): void;
+  /** @inheritDoc */
+  getAllowedTags(): string[];
+  /** @inheritDoc */
+  getAllowedAttributes(): Map<string, string[]>;
+  /** @inheritDoc */
+  getAllowedStyles(): string[];
+  /**
+   * 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`.
+   */
+  private resolveRole;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/word-paste-transformers/word-structure-table-transformer.d.ts

@@ -0,0 +1,240 @@
+import { WordStructureTransformer } from './word-structure-transformer';
+/**
+ * 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 declare class WordTableTransformer implements WordStructureTransformer {
+  /** @inheritDoc */
+  apply(root: HTMLElement): void;
+  /** @inheritDoc */
+  getAllowedTags(): string[];
+  /** @inheritDoc */
+  getAllowedAttributes(): Map<string, string[]>;
+  /** @inheritDoc */
+  getAllowedStyles(): string[];
+  /**
+   * 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.
+   */
+  private normalizeTable;
+  /**
+   * 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.
+   */
+  private removeHiddenMisalignedCells;
+  /**
+   * 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`.
+   */
+  private isRowOfTable;
+  /**
+   * Detects Word's hidden misaligned-row placeholder cell.
+   *
+   * @param {HTMLTableCellElement} cell Cell to inspect.
+   * @returns {boolean} `true` when the cell is a hidden placeholder.
+   */
+  private isHiddenMisalignedCell;
+  /**
+   * Reports whether a cell explicitly spans rows/columns.
+   *
+   * @param {HTMLTableCellElement} cell Cell to inspect.
+   * @returns {boolean} `true` when colspan/rowspan is present.
+   */
+  private hasExplicitSpan;
+  /**
+   * 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.
+   */
+  private hasZeroWidthMarker;
+  /**
+   * 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.
+   */
+  private hasMeaningfulCellContent;
+  /**
+   * 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.
+   */
+  private readStyleDeclaration;
+  /**
+   * 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.
+   */
+  private mergeFooterIntoBody;
+  /**
+   * 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.
+   */
+  private promoteHeadCells;
+  /**
+   * 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`).
+   */
+  private renameCell;
+  /**
+   * 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.
+   */
+  private replaceElementTag;
+  /**
+   * 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.
+   */
+  private stripClass;
+  /**
+   * 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.
+   */
+  private removeStructuralWhitespace;
+  /**
+   * 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.
+   */
+  private removeCellLayoutWhitespace;
+  /**
+   * 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.
+   */
+  private normalizeSpanAttributes;
+  /**
+   * 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.
+   */
+  private migrateCellAttributes;
+  /**
+   * 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.
+   */
+  private migrateCellWidth;
+  /**
+   * 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.
+   */
+  private toCssWidth;
+  /**
+   * 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.
+   */
+  private appendStyleDeclaration;
+  /**
+   * 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.
+   */
+  private removeBorderAndPaddingStyles;
+  /**
+   * 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).
+   */
+  private removeMatchingStyleDeclarations;
+  /**
+   * 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.
+   */
+  private styleHasProperty;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/word-paste-transformers/word-structure-transformer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 declare const WORD_SANITIZE_ALL_TAGS_KEY: string;
+export interface WordStructureTransformer {
+  /**
+   * Applies the transformation in place on the parsed body element.
+   *
+   * @param {HTMLElement} root Parsed body element of the Word fragment.
+   */
+  apply(root: HTMLElement): void;
+  /**
+   * Declares the HTML tags this transformer needs preserved through the Word
+   * allowlist pass.
+   *
+   * @returns {string[]} Allowed tag names (upper case).
+   */
+  getAllowedTags(): string[];
+  /**
+   * Declares the attributes this transformer needs preserved, keyed by
+   * upper-case tag name. Use {@link WORD_SANITIZE_ALL_TAGS_KEY} for attributes
+   * allowed on every allowed tag.
+   *
+   * @returns {Map<string, string[]>} Tag → allowed attribute names.
+   */
+  getAllowedAttributes(): Map<string, string[]>;
+  /**
+   * Declares the CSS property prefixes this transformer needs preserved.
+   *
+   * @returns {string[]} Allowed CSS property prefixes (lower case).
+   */
+  getAllowedStyles(): string[];
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-block.d.ts

@@ -42,6 +42,14 @@ export declare class RTETableBlock extends RTEBlock<VegaRTEContent | RTEHtmlBloc
    * @inheritDoc
    */
   getLastNode(): RTENode;
+  /**
+   * 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(): boolean;
   /**
    * Get the first node of the table block.
    *

package/dist/types/components/vega-rich-text-editor/extensions/tokens/span-to-token-node-strategy.d.ts

@@ -1,5 +1,5 @@
 import { Nullable } from '../../../../types/general';
-import { VegaRTECustomNode } from '../../interface';
+import { VegaRTECustomNode, VegaRTETextAnnotations, VegaRTETransformOptions } from '../../interface';
 import { ElementToDTOStrategy } from '../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
 /**
  * Strategy to convert <span class="token" token-key="...">...</span> to a token node
@@ -12,7 +12,7 @@ export declare class SpanToTokenNodeStrategy extends ElementToDTOStrategy {
   /**
    * @inheritDoc
    */
-  handle(elementsArray: HTMLElement[]): Nullable<VegaRTECustomNode>;
+  handle(elementsArray: HTMLElement[], _options?: VegaRTETransformOptions, parentTextAnnotations?: VegaRTETextAnnotations): Nullable<VegaRTECustomNode>;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/extensions/tokens/token-node.d.ts

@@ -1,6 +1,6 @@
 import { RTETextBlock } from '../../dto/blocks/text-block';
 import { RTETextNode } from '../../dto/nodes/text-node';
-import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTETokenNode } from '../../interface';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTETokenNode, VegaRTETransformOptions } from '../../interface';
 /**
  * Token node for the Vega Rich Text Editor.
  */
@@ -39,4 +39,22 @@ export declare class RTETokenNode extends RTETextNode {
    * @returns {string} - The HTML representation of the token node.
    */
   toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  renderHtmlFromDepth(depth: number, options?: VegaRTETransformOptions): string;
+  /**
+   * 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.
+   */
+  private renderTokenWithWrapperStr;
+  /**
+   * Build inline HTML wrapper attributes string.
+   *
+   * @param {InlineHtmlAnnotation} annotation - Inline HTML annotation.
+   * @returns {string} Serialized attribute string.
+   */
+  private inlineHtmlAnnotationAttrStr;
 }

package/dist/types/components/vega-rich-text-editor/helpers/utils.d.ts

@@ -18,6 +18,13 @@ export declare function createStyleMapFromElement(element: HTMLElement): Annotat
  * @returns {string[]} Array of individual CSS property strings.
  */
 export declare function splitStyleProperties(styleAttr: string): string[];
+/**
+ * Simple escape HTML-sensitive characters so text can be rendered literally in HTML. Only escape &, <, and >.
+ *
+ * @param {string} text - Raw text content.
+ * @returns {string} Escaped text content.
+ */
+export declare function simpleEscapeHtml(text: string): string;
 /**
  * Escape HTML-sensitive characters so text can be rendered literally in HTML.
  *