@globalpayments/vega 2.98.0 → 2.100.0

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/table/renderers/table-caption-renderer.d.ts

@@ -1,4 +1,4 @@
-import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
 import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
 import { RTETableCaptionBlock } from '../dto/table-caption-block';
 export declare const TABLE_CAPTION_PLACEHOLDER_TEXT: string;
@@ -9,5 +9,5 @@ export declare class RTETableCaptionRenderer extends VegaRTEExtensionRenderer {
   /**
    * @inheritDoc
    */
-  doRender(h: VegaRTECreateElementFunction, renderData: RTETableCaptionBlock): VegaRTERenderResult;
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableCaptionBlock, rteContext: RTERenderContext): VegaRTERenderResult;
 }

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-dynamic-popover-renderer.d.ts

@@ -32,8 +32,10 @@ export declare class TableDynamicPopoverRenderer extends TablePopoverBaseRendere
    *
    * @param {string} type - The table setting type determining which
    *  content variant to display (for example, table properties or cell properties).
+   * @param {Nullable<HTMLElement>} returnCell - The cell to move focus into the dialog for and
+   *  return focus to if the dialog is dismissed with Escape (set for keyboard/screen-reader users).
    */
-  show(type: string): Promise<void>;
+  show(type: string, returnCell?: Nullable<HTMLElement>): Promise<void>;
   /**
    * hide the popover.
    */
@@ -51,6 +53,21 @@ export declare class TableDynamicPopoverRenderer extends TablePopoverBaseRendere
    * @returns {Nullable<HTMLElement>} The constructed popover element.
    */
   render(): Nullable<HTMLElement>;
+  /**
+   * Whether the given event originated inside the properties dialog subtree (either the table or the
+   * cell properties form).
+   *
+   * @param {Event} event - The event to test.
+   * @returns {boolean} `true` when an active form is rendered and the event's composed path includes it.
+   */
+  protected isEventWithinPopover(event: Event): boolean;
+  /**
+   * Resolves the `.rich-text-content` editor root from the current table ref so the content can be
+   * made inert while the properties dialog holds keyboard/VoiceOver focus.
+   *
+   * @returns {Nullable<HTMLElement>} The editor content element, or `null` when it cannot be resolved.
+   */
+  protected getInertContentTarget(): Nullable<HTMLElement>;
   /**
    * Updates the visibility of the pre-rendered content blocks based on type.
    *
@@ -67,6 +84,19 @@ export declare class TableDynamicPopoverRenderer extends TablePopoverBaseRendere
    * Stores the current focus node before properties update action.
    */
   private storeCurrentFocusNode;
+  /**
+   * Moves focus to the first focusable control in the active properties form so keyboard and
+   * screen-reader users land inside the dialog when it opens. The first form field is the Border
+   * Style select; its focusable trigger is the `.vega-input-select-container` element.
+   *
+   * @param {string} type - The table setting type that determines which form is visible.
+   */
+  private focusFirstFormField;
+  /**
+   * When the properties dialog hides after an Escape press, returns focus (and the caret) to the
+   * table cell that had focus before the dialog was opened via the setting toolbar.
+   */
+  private handleDialogHide;
   /**
    * Create and position an invisible anchor element whose position and size are identical to the geometry of the current multi-cell selection.
    * This anchor element will then be used as the target of the popup, so that the popup appears near the entire selection area.

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-popover-base-renderer.d.ts

@@ -3,9 +3,25 @@ import { RTERenderContext, VegaRTEToolbarRenderContext } from '../../../interfac
 import { RTETableExtensionContext } from '../table-extension';
 /**
  * Base renderer for table-related popovers, providing common functionalities such as accessing the table extension context.
+ *
+ * Popovers that move keyboard/VoiceOver focus into themselves (the setting toolbar and the
+ * properties dialog) share the same focus-restoration machinery: they make the editor content
+ * `inert` while open, track Escape presses at the document level, and return focus (and the caret)
+ * to the originating cell when an Escape dismisses the popover. That behavior lives here so the two
+ * renderers do not each carry a copy; subclasses only supply the two pieces that differ — how to
+ * resolve the editor content root ({@link getInertContentTarget}) and how to tell whether an event
+ * originated inside their own popover subtree ({@link isEventWithinPopover}).
  */
 export declare class TablePopoverBaseRenderer {
   protected renderContext: Nullable<RTERenderContext | VegaRTEToolbarRenderContext>;
+  /** The editor content element made inert while the popover holds focus, cached so it can be restored. */
+  protected inertedContentEl: Nullable<HTMLElement>;
+  /** The table cell to return focus to when the popover is dismissed via Escape. */
+  protected returnFocusCell: Nullable<HTMLElement>;
+  /** Tracks whether Escape was pressed while the popover was open. */
+  protected escapePressed: boolean;
+  /** Document the Escape tracker keydown listener is bound to, for later removal. */
+  protected keydownListenerDocument: Nullable<Document>;
   constructor(renderContext: RTERenderContext | VegaRTEToolbarRenderContext);
   /**
    * Retrieves the table extension context associated with the current render context.
@@ -13,4 +29,79 @@ export declare class TablePopoverBaseRenderer {
    * @returns {Nullable<RTETableExtensionContext>} The table extension context if available, otherwise null.
    */
   protected getTableExtensionContext(): Nullable<RTETableExtensionContext>;
+  /**
+   * Begins tracking so a later Escape can return focus to `returnCell`. Records the cell and clears
+   * any stale Escape observed before the popover was opened.
+   *
+   * @param {Nullable<HTMLElement>} returnCell - The cell to return focus to if the popover is dismissed with Escape.
+   */
+  protected beginReturnFocusTracking(returnCell: Nullable<HTMLElement>): void;
+  /**
+   * Registers the document-level (capture phase) Escape tracker. The popover renders in a portal, so
+   * its Escape does not bubble back to the table; observing on the document lets us know when to
+   * return focus to the cell.
+   *
+   * @param {Document} doc - The document to bind the keydown listener to.
+   */
+  protected attachEscapeTracker(doc: Document): void;
+  /**
+   * Removes the document-level Escape tracker if one was registered.
+   */
+  protected detachEscapeTracker(): void;
+  /**
+   * Tracks Escape key presses that originate inside the popover so focus can be returned to the
+   * originating cell when that Escape dismisses the popover. vega-popover's own Escape handler hides
+   * the popover without restoring focus, so the restore is coordinated here.
+   *
+   * The listener is bound at the document level (the popover renders in a portal, so its Escape does
+   * not bubble back to the table), so scope it to the popover subtree via {@link isEventWithinPopover}:
+   * a stray Escape elsewhere must not arm the restore and hijack focus on a later non-Escape dismissal
+   * (e.g. click-outside).
+   *
+   * @param {KeyboardEvent} event - The keydown event.
+   */
+  protected handleDocumentKeydown: (event: KeyboardEvent) => void;
+  /**
+   * Whether the given event originated inside this popover's subtree. Subclasses override this to
+   * match their own portal-rendered content; the base returns `false` so renderers that do not move
+   * focus never arm the restore.
+   *
+   * @param {Event} _event - The event to test.
+   * @returns {boolean} `true` when the event originated inside the popover subtree.
+   */
+  protected isEventWithinPopover(_event: Event): boolean;
+  /**
+   * When the popover hides after an Escape press, returns focus (and the caret) to the table cell
+   * that had focus before the popover was opened.
+   *
+   * vegaPopoverHide fires synchronously from the popover's own Escape handler, before the
+   * document-capture keydown observes the key and before the popover settles focus on `<body>`.
+   * Defer past that so the flag is set and this focus restore wins.
+   */
+  protected restoreFocusOnEscapeHide(): void;
+  /**
+   * Focuses the given table cell and collapses the caret at its start.
+   *
+   * @param {HTMLElement} cell - The table cell to focus.
+   */
+  protected restoreFocusToCell(cell: HTMLElement): void;
+  /**
+   * Resolves the `.rich-text-content` editor root to toggle `inert` on while the popover holds focus.
+   * Subclasses override this because they reach the content from different anchors (the toolbar's
+   * target vs. the current table ref); the base returns `null` so renderers that do not use inert are
+   * unaffected.
+   *
+   * @returns {Nullable<HTMLElement>} The editor content element, or `null` when it cannot be resolved.
+   */
+  protected getInertContentTarget(): Nullable<HTMLElement>;
+  /**
+   * Toggles `inert` on the editor content region while the popover holds keyboard/VoiceOver focus.
+   * Safari VoiceOver keeps its reading cursor anchored to the cell caret and does not follow the
+   * programmatic focus moved into the popover; making the editor content inert removes that text
+   * context so the VoiceOver cursor lands inside the popover. The popover is a body-level portal, so it
+   * is not a descendant of the inert content and stays interactive.
+   *
+   * @param {boolean} inert - Whether the editor content should be inert.
+   */
+  protected setEditorContentInert(inert: boolean): void;
 }

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-renderer.d.ts

@@ -24,9 +24,55 @@ export declare class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
    * @param {VegaRTECreateElementFunction} h - The create element function.
    * @param {RTETableBlock} renderData - The table block to render.
    * @param {(ref: HTMLElement) => HTMLElement} setTableRef - Set table ref to tableRef
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
    * @returns {VegaRTERenderResult} - The rendered table element.
    */
   private renderTable;
+  /**
+   * Handles activation of the table itself (e.g. VoiceOver Ctrl+Option+Space, which dispatches a
+   * click on the focused table) by moving focus into the first cell so the user can start editing.
+   *
+   * @param {MouseEvent} event - The click event dispatched on the table.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  private handleTableActivate;
+  /**
+   * Handles table-scoped keyboard shortcuts while focus is inside the table:
+   * - Alt+F10 opens the table setting toolbar (re-targeting and showing it when needed) and moves
+   *   focus to it (the common "focus the contextual toolbar" shortcut), so keyboard/screen-reader
+   *   users can reach the toolbar buttons even when it is currently closed.
+   * - Escape moves focus back onto the table, so the caret leaves the cell (its focus highlight
+   *   is cleared), the contextual setting toolbar is dismissed, and screen readers announce the
+   *   table again.
+   *
+   * @param {KeyboardEvent} event - The keydown event.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   * @param {RTETableBlock} renderData - The table block being rendered.
+   */
+  private handleTableKeyDown;
+  /**
+   * Moves focus (and the caret) into the first cell of the table.
+   *
+   * @param {HTMLElement} tableRef - The table element.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  private focusFirstCell;
+  /**
+   * Moves focus onto the table element and clears any cell caret and selection highlight.
+   *
+   * @param {HTMLElement} tableRef - The table element.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  private focusTable;
+  /**
+   * Resolves the editor selection, preferring the shadow-aware selection from the extension
+   * context and falling back to the table's owning document.
+   *
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   * @param {HTMLElement} tableRef - The table element.
+   * @returns {Nullable<Selection>} - The resolved selection, or null when unavailable.
+   */
+  private getSelection;
   /**
    * Handles the removal of the table block.
    *

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-setting-popover-renderer.d.ts

@@ -1,3 +1,4 @@
+import { Nullable } from '../../../../../types/general';
 import { RTETableBlock } from '../dto/table-block';
 import { TablePopoverBaseRenderer } from './table-popover-base-renderer';
 import { RTERenderContext } from '../../../interface';
@@ -28,14 +29,58 @@ export declare class TableSettingPopoverRenderer extends TablePopoverBaseRendere
    * Sync the selected cells from the table selection to the table setting component.
    */
   syncSelectedCells: () => void;
+  /**
+   * Hides the table setting toolbar and its dynamic popover. Used when focus leaves the table (e.g.
+   * Escape moves focus from a cell back onto the table) so the contextual toolbar does not linger.
+   */
+  hide: () => void;
+  /**
+   * Opens the table setting toolbar for keyboard/screen-reader users and moves focus to its first
+   * enabled button. Used by the Alt+F10 shortcut so the toolbar can be reached from inside a cell
+   * even when it is currently closed: it re-targets and shows the popover (the same path as a table
+   * click) before deferring focus to the first enabled button.
+   *
+   * @param {RTETableBlock} tableBlock - The table's block data.
+   * @param {() => HTMLElement} getTableRef - Getter for the table's DOM element.
+   * @param {Nullable<HTMLElement>} returnCell - The cell to return focus to if the toolbar is dismissed with Escape.
+   */
+  openSettingToolbarForKeyboard: (tableBlock: RTETableBlock, getTableRef: () => HTMLElement, returnCell?: Nullable<HTMLElement>) => void;
+  /**
+   * Moves focus to the first enabled button in the table setting toolbar. Used by the Alt+F10
+   * shortcut so keyboard and screen-reader users can reach the toolbar from inside the table.
+   *
+   * @param {Nullable<HTMLElement>} returnCell - The cell to return focus to if the toolbar is dismissed with Escape.
+   */
+  focusFirstSettingButton: (returnCell?: Nullable<HTMLElement>) => void;
   /**
    * Builds the popover DOM and appends it to the RTE host. Idempotent: subsequent calls are no-ops.
    */
   render(): void;
+  /**
+   * Whether the given event originated inside the setting toolbar subtree.
+   *
+   * @param {Event} event - The event to test.
+   * @returns {boolean} `true` when the toolbar is rendered and the event's composed path includes it.
+   */
+  protected isEventWithinPopover(event: Event): boolean;
+  /**
+   * Resolves the `.rich-text-content` editor root from the setting toolbar's target so the content
+   * can be made inert while the toolbar holds keyboard/VoiceOver focus.
+   *
+   * @returns {Nullable<HTMLElement>} The editor content element, or `null` when it cannot be resolved.
+   */
+  protected getInertContentTarget(): Nullable<HTMLElement>;
   /**
    * Updates the table setting component caption state to match the current table data.
    */
   private updateTableSettingCaption;
+  /**
+   * When the caption is toggled on, moves keyboard/VoiceOver focus and the caret into the caption so
+   * the user lands in it to start typing. The setting toolbar is opened as inert-guarded for
+   * keyboard/screen-reader users, so lift that guard first; the caption is re-rendered by the toggle,
+   * so defer the focus to the next tick when the `<caption>` element exists.
+   */
+  private moveFocusToCaption;
   /**
    * Re-targets the shared popovers to the given table.
    *
@@ -53,6 +98,19 @@ export declare class TableSettingPopoverRenderer extends TablePopoverBaseRendere
    * Handles the popover show event to sync the selected table cells to the table setting component.
    */
   private handleTableSettingPopoverShow;
+  /**
+   * When the setting popover hides after an Escape press, returns focus (and the caret) to the
+   * table cell that had focus before the toolbar was reached via Alt+F10.
+   */
+  private handleTableSettingPopoverHide;
+  /**
+   * `vega-popover-content-box` renders `role="dialog"` + `aria-modal="true"`, which on WebKit
+   * VoiceOver confines the reading cursor to the popover. Keep those semantics so Ctrl+Opt+Arrow
+   * cannot walk the VoiceOver cursor out of the toolbar past the last button (VoiceOver swallows
+   * those keys, so this cannot be trapped in JS), and give the dialog an accessible name so it
+   * announces "Table tools" on entry.
+   */
+  private labelSettingDialog;
   /**
    * Collects and returns the currently selected table cells.
    *

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

@@ -111,6 +111,14 @@ export declare class RTETableSelection {
    * Handle selection change events from the document for the cell click selection.
    */
   private handleSelectionChange;
+  /**
+   * Resolve the single table cell that contains the given selection node. Used as a fallback when a
+   * collapsed caret does not intersect any text node (see handleSelectionChange).
+   *
+   * @param {Node} node - The selection's common ancestor container.
+   * @returns {RTETableCellBlock[]} The containing cell block, or an empty list when none is found.
+   */
+  private resolveCaretCell;
   /**
    * Recursively filter and collect selected table cell blocks within the given node.
    *

package/dist/types/components/vega-rich-text-editor/extensions/table/vega-rich-text-table-properties/slimmers/renderers/vega-rich-text-table-properties-basic-form-field-renderer.abstract.d.ts

@@ -7,6 +7,7 @@ export declare abstract class VegaRichTextTablePropertiesBaseFormFieldRenderer e
   static TABLE_BORDER_STYLES: SelectSourceItem[];
   protected controller: VegaRichTextTableProperties['controller'];
   protected defaultValue: VegaRichTextTableProperties['defaultValue'];
+  protected translationSlimmer: VegaRichTextTableProperties['translationSlimmer'];
   protected renderer: VegaRichTextTableProperties['renderer'];
   protected styleMap: VegaRichTextTableProperties['styleMap'];
   protected vegaChange: VegaRichTextTableProperties['vegaChange'];
@@ -34,7 +35,7 @@ export declare abstract class VegaRichTextTablePropertiesBaseFormFieldRenderer e
    * @returns { HTMLElement } The dimension fields element.
    */
   protected renderDimensionFields(withPadding?: boolean): HTMLElement;
-  protected renderAlignmentField(alignmentList: string[], iconPrefix: string, formFieldName: string): HTMLElement;
+  protected renderAlignmentField(alignmentList: string[], iconPrefix: string, formFieldName: string, ariaLabelMap: Record<string, string>): HTMLElement;
   /**
    * Render save and cancel action buttons.
    *

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

@@ -9,6 +9,7 @@ import { TableColorController } from './slimmers/controllers/vega-rich-text-tabl
 import { VegaRichTextTablePropertiesFormFieldRenderer } from './slimmers/renderers/vega-rich-text-table-properties-form-field-renderer';
 import { VegaRichTextCellPropertiesFormFieldRenderer } from './slimmers/renderers/vega-rich-text-cell-properties-form-field-renderer';
 import { DarkModeStateControllerSlimmer } from '../../../../../helpers/slimmers/dark-mode-state-controller-slimmer';
+import { AriaAttributesValueMapper } from '../../../../../helpers/slimmers/mutation-observer/aria-attributes-value-mapper';
 /**
  * @vegaVersion 2.79.0
  */
@@ -21,6 +22,7 @@ export declare class VegaRichTextTableProperties {
   protected readonly cellFormRenderer: VegaRichTextCellPropertiesFormFieldRenderer;
   protected readonly controller: TableColorController;
   protected darkModeStateSlimmer: DarkModeStateControllerSlimmer;
+  protected ariaAttributesValueMapper: AriaAttributesValueMapper;
   protected changeEventPreventSlimmer: ChildNodesEventPreventSlimmer;
   host: HTMLVegaRichTextTablePropertiesElement;
   isInDarkMode: boolean;