@globalpayments/vega 2.99.0 → 2.101.0

package/dist/cjs/{token-extension-4686cb3b.js → token-extension-4badb962.js}

@@ -7,28 +7,28 @@ const createPublicApiRuntimeMetricsSlimmer = require('./create-public-api-runtim
 const internalVegaZIndexManager = require('./internal-vega-z-index-manager-f03ddb37.js');
 const dynamicSlimmer = require('./dynamic-slimmer-f31fdfd7.js');
 const pageResizeObserverSlimmer = require('./page-resize-observer-slimmer-273d62ef.js');
-const internalVegaEventManager = require('./internal-vega-event-manager-7003c84a.js');
-const internalTranslationController = require('./internal-translation-controller-51f7f865.js');
-const internalCalendarPeriodFactory = require('./internal-calendar-period-factory-6196bc80.js');
-const codeBlock = require('./code-block-ea1f5eb3.js');
-const contentState = require('./content-state-8d07d530.js');
-const typeGuard = require('./type-guard-b8d7bb3f.js');
-const linkExtension = require('./link-extension-11340e1c.js');
+const internalVegaEventManager = require('./internal-vega-event-manager-976b9526.js');
+const internalTranslationController = require('./internal-translation-controller-27bfc8c7.js');
+const internalCalendarPeriodFactory = require('./internal-calendar-period-factory-b11918ee.js');
+const codeBlock = require('./code-block-c598832d.js');
+const contentState = require('./content-state-da23e822.js');
+const typeGuard = require('./type-guard-00b8efc0.js');
+const linkExtension = require('./link-extension-f493e432.js');
 const internalIconManager = require('./internal-icon-manager-40bcac72.js');
 const vegaNonceManager = require('./vega-nonce-manager-df69d3ed.js');
 const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-c82df135.js');
-const vegaEventId = require('./vega-event-id-58afed7a.js');
-const splitCellOperation = require('./split-cell-operation-11bfb305.js');
+const vegaEventId = require('./vega-event-id-987a170c.js');
+const splitCellOperation = require('./split-cell-operation-0d33123e.js');
 const changeManager = require('./change-manager-a297e4d2.js');
-const vegaInternalEventId = require('./vega-internal-event-id-f4d33037.js');
+const vegaInternalEventId = require('./vega-internal-event-id-98d499d7.js');
 const remoteInvocationRegistry = require('./remote-invocation-registry-fc22fdd0.js');
-const darkModeStyleController = require('./dark-mode-style-controller-f3da3342.js');
+const darkModeStyleController = require('./dark-mode-style-controller-ec04ece9.js');
 const tryGetDocument = require('./try-get-document-c0ebd39a.js');
 const pixel = require('./pixel-98f2a10c.js');
 const object = require('./object-b53e9416.js');
 const timer = require('./timer-5f33058b.js');
 const string = require('./string-39438062.js');
-const imageExtension = require('./image-extension-9659708b.js');
+const imageExtension = require('./image-extension-673ebe7f.js');
 const copy = require('./copy-d021c780.js');
 
 const VegaLoaderRuntimeMetricsPayloadDefinition = [
@@ -1117,7 +1117,7 @@ class VegaRTEToolbarButtonRenderer {
    * @returns {VegaRTERenderResult} - The render result for the dropdown.
    */
   renderDropdown(h, editorContext, dropdownProps, children) {
-    return h('vega-dropdown', Object.assign({ trigger: 'click', searchable: false, maxWidth: '200', itemDisplayRule: 'ellipsis', isScreenPosition: true, 
+    return h('vega-dropdown', Object.assign({ trigger: 'click', searchable: false, maxWidth: '200', itemDisplayRule: 'ellipsis', isScreenPosition: true, role: 'presentation', 
       // eslint-disable-next-line jsdoc/require-jsdoc
       ref: (el) => {
         this.dropdownEl = el;
@@ -1201,29 +1201,31 @@ class VegaRTEToolbarButtonRenderer {
    * @returns {VegaRTERenderResult} - The render result for the button.
    */
   renderButton(h, editorContext, buttonProps) {
-    const { icon, label, showArrowIcon, tooltip } = buttonProps;
+    const { icon, label, showArrowIcon, tooltip, ariaLabel } = buttonProps;
     const isDisabled = this.isDisabled(editorContext);
     const button = h('vega-rich-text-editor-toolbar-button', {
-      disabled: isDisabled,
-      icon: icon,
-      hidden: this.isHidden(editorContext),
-      selected: this.isSelected(editorContext),
+      'disabled': isDisabled,
+      'icon': icon,
+      'data-aria-label': ariaLabel !== null && ariaLabel !== void 0 ? ariaLabel : label,
+      'hidden': this.isHidden(editorContext),
+      'selected': this.isSelected(editorContext),
       // eslint-disable-next-line jsdoc/require-jsdoc
-      ref: (el) => {
+      'ref': (el) => {
         this.buttonEl = el;
         domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(el, vegaEventId.VegaClick, () => this.handleButtonClick(editorContext));
       },
-      onMouseDown: this.preventDefault,
+      'onMouseDown': this.preventDefault,
       // eslint-disable-next-line jsdoc/require-jsdoc
-      onKeyDown: (e) => this.handleButtonKeyDown(e),
+      'onKeyDown': (e) => this.handleButtonKeyDown(e),
     }, [
       this.renderButtonLabel(h, editorContext, label),
       showArrowIcon
         ? h('vega-icon', {
-          size: 'size-8',
-          color: isDisabled ? 'text-disabled' : 'text-secondary',
-          style: { marginLeft: '8px' },
-          icon: internalIconManager.VegaInternalIconManager.getIconKey('chevron-down'),
+          'size': 'size-8',
+          'color': isDisabled ? 'text-disabled' : 'text-secondary',
+          'style': { marginLeft: '8px' },
+          'aria-hidden': 'true',
+          'icon': internalIconManager.VegaInternalIconManager.getIconKey('chevron-down'),
         })
         : null,
     ].filter(typeGuard.isNonNullable));
@@ -1244,8 +1246,9 @@ class VegaRTEToolbarButtonRenderer {
     if (label) {
       const isDisabled = this.isDisabled(editorContext);
       return h('vega-font', {
-        variant: 'font-field-label-sm',
-        color: isDisabled ? 'text-disabled' : 'text-primary',
+        'variant': 'font-field-label-sm',
+        'color': isDisabled ? 'text-disabled' : 'text-primary',
+        'aria-hidden': 'true',
       }, editorContext.translation.t(label));
     }
     return null;
@@ -1277,6 +1280,15 @@ class VegaRTEToolbarButtonRenderer {
   preventDefault(e) {
     e.preventDefault();
   }
+  /**
+   * Moves focus to the toolbar button. Targets the inner focusable `<button>`
+   * inside the button's shadow root, falling back to the host element.
+   */
+  focusToolbarButton() {
+    var _a, _b, _c, _d;
+    const innerButton = (_c = (_b = (_a = this.buttonEl) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('button')) !== null && _c !== void 0 ? _c : null;
+    (_d = (innerButton !== null && innerButton !== void 0 ? innerButton : this.buttonEl)) === null || _d === void 0 ? void 0 : _d.focus();
+  }
   /**
    * Recursively searches for a dropdown list item by its key.
    *
@@ -1330,14 +1342,14 @@ class VegaRTEToolbarButtonRenderer {
    * @param {KeyboardEvent} e The keyboard event.
    */
   handleItemsKeyDown(e) {
-    var _a, _b, _c;
+    var _a, _b;
     if (e.code === 'Escape') {
       e.preventDefault();
       e.stopPropagation();
       if (this.dropdownEl) {
         void this.dropdownEl.hide();
       }
-      (_a = this.buttonEl) === null || _a === void 0 ? void 0 : _a.focus();
+      this.focusToolbarButton();
       return;
     }
     if (e.code !== 'ArrowDown' && e.code !== 'ArrowUp') {
@@ -1355,7 +1367,7 @@ class VegaRTEToolbarButtonRenderer {
     for (let offset = 0; offset < items.length; offset++) {
       const index = (startIndex + offset * direction + items.length) % items.length;
       if (!items[index].disabled) {
-        (_c = (_b = items[index].shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('li')) === null || _c === void 0 ? void 0 : _c.focus();
+        (_b = (_a = items[index].shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('li')) === null || _b === void 0 ? void 0 : _b.focus();
         return;
       }
     }
@@ -1425,6 +1437,7 @@ class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return this.renderDropdown(createElement, editorContext, {}, [
       this.renderButton(createElement, editorContext, {
         label: 'Tokens',
+        ariaLabel: 'Tokens',
         showArrowIcon: true,
         tooltip: { text: 'Insert token' },
       }),
@@ -1708,6 +1721,7 @@ class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return this.renderDropdown(createElement, editorContext, { source: translatedSource }, [
       this.renderButton(createElement, editorContext, {
         label: this.getLanguageLabelByKey(this.selectedLanguage),
+        ariaLabel: 'Language',
         showArrowIcon: true,
         tooltip: { text: 'Select language' },
       }),
@@ -1723,10 +1737,11 @@ class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     this.translation = editorContext.translation;
     const isDisabled = this.isDisabled(editorContext);
     return h('vega-font', {
-      variant: 'font-field-label-sm',
-      color: isDisabled ? 'text-disabled' : 'text-primary',
+      'variant': 'font-field-label-sm',
+      'color': isDisabled ? 'text-disabled' : 'text-primary',
+      'aria-hidden': 'true',
       // eslint-disable-next-line jsdoc/require-jsdoc
-      ref: (el) => {
+      'ref': (el) => {
         this.labelRef = el;
       },
     }, editorContext.translation.t(label));
@@ -2197,6 +2212,12 @@ class RTELogicControlNode extends codeBlock.RTENode {
   isContentEditable() {
     return false;
   }
+  /**
+   * @inheritDoc
+   */
+  getPlainText() {
+    return this.text;
+  }
 }
 RTELogicControlNode.dtoName = 'RTELogicControlNode';
 
@@ -2285,6 +2306,7 @@ class FunctionToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return this.renderDropdown(h, editorContext, {}, [
       this.renderButton(h, editorContext, {
         label: 'Functions',
+        ariaLabel: 'Functions',
         showArrowIcon: true,
         tooltip: { text: 'Insert function' },
       }),
@@ -2811,7 +2833,7 @@ class VegaRTEFunctionExtension extends linkExtension.VegaRTEExtension {
 })();
 VegaRTEFunctionExtension.TOOLBAR_BUTTON_KEY = 'functions';
 
-const tableBlockStylesCss = ".v-rte--extension-table-container{display:table}table.v-rte--extension-table{border-collapse:collapse}table.v-rte--extension-table th,table.v-rte--extension-table td{border:1px solid #ddd;padding:12px;text-align:left;vertical-align:middle;min-width:55px;box-sizing:border-box;position:relative}table.v-rte--extension-table th{background-color:#f2f2f2}.rte-table-setting-popover,.rte-table-dynamic-popover{display:block}table.v-rte--extension-table .v-rte-table-cell-focused::after,table.v-rte--extension-table .v-rte-table-cell-selected::after{content:'';position:absolute;top:0;left:0;right:0;bottom:0;pointer-events:none;background-color:rgba(158, 207, 250, 0.3)}table.v-rte--extension-table:has(.v-rte-table-cell-selected){caret-color:transparent}table.v-rte--extension-table:has(.v-rte-table-cell-selected) ::selection{background-color:transparent}table.v-rte--extension-table:has(.v-rte-table-cell-selected) ::-moz-selection{background-color:transparent}.v-rte--extension-table-caption{padding:8px;border:1px solid #ddd;border-bottom:none;background-color:rgba(var(--v-bg-table-header, 240, 243, 247, 1));position:relative;display:table-caption;caption-side:top;min-height:22px;text-align:center;word-break:break-word;overflow-wrap:break-word}.v-rte--extension-table-caption.showPlaceholder::before{position:absolute;left:0;right:0;content:attr(data-placeholder);font-family:'Inter', sans-serif;font-size:16px;font-weight:400;line-height:24px;letter-spacing:0;color:rgba(var(--v-text-input-placeholder, 176, 180, 181, 1));text-align:center;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}";
+const tableBlockStylesCss = ".v-rte--extension-table-container{display:table}table.v-rte--extension-table{border-collapse:collapse}table.v-rte--extension-table th,table.v-rte--extension-table td{border:1px solid #ddd;padding:12px;text-align:left;vertical-align:middle;min-width:55px;box-sizing:border-box;position:relative}table.v-rte--extension-table th:focus,table.v-rte--extension-table td:focus{outline:none}table.v-rte--extension-table th{background-color:#f2f2f2}.rte-table-setting-popover,.rte-table-dynamic-popover{display:block}table.v-rte--extension-table .v-rte-table-cell-focused::after,table.v-rte--extension-table .v-rte-table-cell-selected::after{content:'';position:absolute;top:0;left:0;right:0;bottom:0;pointer-events:none;background-color:rgba(158, 207, 250, 0.3)}table.v-rte--extension-table:has(.v-rte-table-cell-selected){caret-color:transparent}table.v-rte--extension-table:has(.v-rte-table-cell-selected) ::selection{background-color:transparent}table.v-rte--extension-table:has(.v-rte-table-cell-selected) ::-moz-selection{background-color:transparent}.v-rte--extension-table-caption{padding:8px;border:1px solid #ddd;border-bottom:none;background-color:rgba(var(--v-bg-table-header, 240, 243, 247, 1));position:relative;display:table-caption;caption-side:top;min-height:22px;text-align:center;word-break:break-word;overflow-wrap:break-word}.v-rte--extension-table-caption.showPlaceholder::before{position:absolute;left:0;right:0;content:attr(data-placeholder);font-family:'Inter', sans-serif;font-size:16px;font-weight:400;line-height:24px;letter-spacing:0;color:rgba(var(--v-text-input-placeholder, 176, 180, 181, 1));text-align:center;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}";
 
 const DELETE_TABLE_BLOCK = 'DELETE_TABLE_BLOCK';
 /**
@@ -3429,9 +3451,42 @@ class CellPropertiesCancelEventHandler extends CellPropertiesEventHandler {
 
 /**
  * Base renderer for table-related popovers, providing common functionalities such as accessing the table extension context.
+ *
+ * Popovers that move keyboard/VoiceOver focus into themselves (the setting toolbar and the
+ * properties dialog) share the same focus-restoration machinery: they make the editor content
+ * `inert` while open, track Escape presses at the document level, and return focus (and the caret)
+ * to the originating cell when an Escape dismisses the popover. That behavior lives here so the two
+ * renderers do not each carry a copy; subclasses only supply the two pieces that differ — how to
+ * resolve the editor content root ({@link getInertContentTarget}) and how to tell whether an event
+ * originated inside their own popover subtree ({@link isEventWithinPopover}).
  */
 class TablePopoverBaseRenderer {
   constructor(renderContext) {
+    /** The editor content element made inert while the popover holds focus, cached so it can be restored. */
+    this.inertedContentEl = null;
+    /** The table cell to return focus to when the popover is dismissed via Escape. */
+    this.returnFocusCell = null;
+    /** Tracks whether Escape was pressed while the popover was open. */
+    this.escapePressed = false;
+    /** Document the Escape tracker keydown listener is bound to, for later removal. */
+    this.keydownListenerDocument = null;
+    /**
+     * Tracks Escape key presses that originate inside the popover so focus can be returned to the
+     * originating cell when that Escape dismisses the popover. vega-popover's own Escape handler hides
+     * the popover without restoring focus, so the restore is coordinated here.
+     *
+     * The listener is bound at the document level (the popover renders in a portal, so its Escape does
+     * not bubble back to the table), so scope it to the popover subtree via {@link isEventWithinPopover}:
+     * a stray Escape elsewhere must not arm the restore and hijack focus on a later non-Escape dismissal
+     * (e.g. click-outside).
+     *
+     * @param {KeyboardEvent} event - The keydown event.
+     */
+    this.handleDocumentKeydown = (event) => {
+      if (event.code === 'Escape' && this.isEventWithinPopover(event)) {
+        this.escapePressed = true;
+      }
+    };
     this.renderContext = renderContext;
   }
   /**
@@ -3444,6 +3499,121 @@ class TablePopoverBaseRenderer {
       ? linkExtension.extensionContextManager.getExtensionContext(this.renderContext.host)
       : null;
   }
+  /**
+   * Begins tracking so a later Escape can return focus to `returnCell`. Records the cell and clears
+   * any stale Escape observed before the popover was opened.
+   *
+   * @param {Nullable<HTMLElement>} returnCell - The cell to return focus to if the popover is dismissed with Escape.
+   */
+  beginReturnFocusTracking(returnCell) {
+    this.returnFocusCell = returnCell !== null && returnCell !== void 0 ? returnCell : null;
+    this.escapePressed = false;
+  }
+  /**
+   * Registers the document-level (capture phase) Escape tracker. The popover renders in a portal, so
+   * its Escape does not bubble back to the table; observing on the document lets us know when to
+   * return focus to the cell.
+   *
+   * @param {Document} doc - The document to bind the keydown listener to.
+   */
+  attachEscapeTracker(doc) {
+    doc.addEventListener('keydown', this.handleDocumentKeydown, { capture: true });
+    this.keydownListenerDocument = doc;
+  }
+  /**
+   * Removes the document-level Escape tracker if one was registered.
+   */
+  detachEscapeTracker() {
+    if (this.keydownListenerDocument) {
+      this.keydownListenerDocument.removeEventListener('keydown', this.handleDocumentKeydown, {
+        capture: true,
+      });
+      this.keydownListenerDocument = null;
+    }
+  }
+  /**
+   * Whether the given event originated inside this popover's subtree. Subclasses override this to
+   * match their own portal-rendered content; the base returns `false` so renderers that do not move
+   * focus never arm the restore.
+   *
+   * @param {Event} _event - The event to test.
+   * @returns {boolean} `true` when the event originated inside the popover subtree.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  isEventWithinPopover(_event) {
+    return false;
+  }
+  /**
+   * When the popover hides after an Escape press, returns focus (and the caret) to the table cell
+   * that had focus before the popover was opened.
+   *
+   * vegaPopoverHide fires synchronously from the popover's own Escape handler, before the
+   * document-capture keydown observes the key and before the popover settles focus on `<body>`.
+   * Defer past that so the flag is set and this focus restore wins.
+   */
+  restoreFocusOnEscapeHide() {
+    // eslint-disable-next-line no-restricted-globals
+    setTimeout(() => {
+      const shouldRestore = this.escapePressed;
+      const cell = this.returnFocusCell;
+      this.escapePressed = false;
+      this.returnFocusCell = null;
+      if (shouldRestore && cell && cell.isConnected) {
+        this.restoreFocusToCell(cell);
+      }
+    }, 0);
+  }
+  /**
+   * Focuses the given table cell and collapses the caret at its start.
+   *
+   * @param {HTMLElement} cell - The table cell to focus.
+   */
+  restoreFocusToCell(cell) {
+    var _a, _b, _c;
+    cell.focus();
+    const extensionContext = this.getTableExtensionContext();
+    const selection = (_c = (_a = extensionContext === null || extensionContext === void 0 ? void 0 : extensionContext.getSelection()) !== null && _a !== void 0 ? _a : (_b = cell.ownerDocument) === null || _b === void 0 ? void 0 : _b.getSelection()) !== null && _c !== void 0 ? _c : null;
+    if (selection) {
+      const range = new Range();
+      range.setStart(cell, 0);
+      range.setEnd(cell, 0);
+      selection.removeAllRanges();
+      selection.addRange(range);
+    }
+  }
+  /**
+   * Resolves the `.rich-text-content` editor root to toggle `inert` on while the popover holds focus.
+   * Subclasses override this because they reach the content from different anchors (the toolbar's
+   * target vs. the current table ref); the base returns `null` so renderers that do not use inert are
+   * unaffected.
+   *
+   * @returns {Nullable<HTMLElement>} The editor content element, or `null` when it cannot be resolved.
+   */
+  getInertContentTarget() {
+    return null;
+  }
+  /**
+   * Toggles `inert` on the editor content region while the popover holds keyboard/VoiceOver focus.
+   * Safari VoiceOver keeps its reading cursor anchored to the cell caret and does not follow the
+   * programmatic focus moved into the popover; making the editor content inert removes that text
+   * context so the VoiceOver cursor lands inside the popover. The popover is a body-level portal, so it
+   * is not a descendant of the inert content and stays interactive.
+   *
+   * @param {boolean} inert - Whether the editor content should be inert.
+   */
+  setEditorContentInert(inert) {
+    if (inert) {
+      const content = this.getInertContentTarget();
+      if (content) {
+        content.setAttribute('inert', '');
+        this.inertedContentEl = content;
+      }
+    }
+    else if (this.inertedContentEl) {
+      this.inertedContentEl.removeAttribute('inert');
+      this.inertedContentEl = null;
+    }
+  }
 }
 
 /**
@@ -3513,6 +3683,8 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
    * and clears the internal reference.
    */
   destroy() {
+    this.setEditorContentInert(false);
+    this.detachEscapeTracker();
     if (this.selectionAnchorRef && this.selectionAnchorRef.parentNode) {
       domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.removeUniqueObserverFromNode(this.selectionAnchorRef, vegaInternalEventId.VegaInternalRTEExtensionTableCellsSelectionAnchor);
       this.selectionAnchorRef.parentNode.removeChild(this.selectionAnchorRef);
@@ -3525,8 +3697,13 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
    *
    * @param {string} type - The table setting type determining which
    *  content variant to display (for example, table properties or cell properties).
+   * @param {Nullable<HTMLElement>} returnCell - The cell to move focus into the dialog for and
+   *  return focus to if the dialog is dismissed with Escape (set for keyboard/screen-reader users).
    */
-  async show(type) {
+  async show(type, returnCell) {
+    // Remember the cell to return focus to if the dialog is dismissed with Escape, and clear any
+    // stale Escape recorded before the dialog was opened.
+    this.beginReturnFocusTracking(returnCell);
     let target = this.getTableRef();
     const extensionContext = this.getTableExtensionContext();
     let cells = [];
@@ -3546,6 +3723,11 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
     this.storeCurrentFocusNode();
     remoteInvocationRegistry.remoteInvocationRegistry.call(domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubject(this.popoverRef, vegaInternalEventId.VegaInternalPopoverUpdateTarget), target);
     await this.popoverRef.show();
+    // When opened for keyboard/screen-reader users (a return cell is known), move focus into the
+    // dialog so it lands on the first focusable field (the Border Style control).
+    if (returnCell) {
+      this.focusFirstFormField(type);
+    }
   }
   /**
    * hide the popover.
@@ -3580,7 +3762,11 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
         if (this.popoverCloseType === 'change' && extensionContext) {
           extensionContext.flushValue(extensionContext.host.value);
         }
+        this.handleDialogHide();
       });
+      // Escape inside the dialog (rendered in a portal) does not bubble back to the table, so
+      // observe it on the document (capture phase) to know when to return focus to the cell.
+      this.attachEscapeTracker(safeDocument);
       const slotDiv = safeDocument.createElement('div');
       slotDiv.setAttribute('slot', 'popover');
       slotDiv.className = 'rte-table-dynamic-popover-content';
@@ -3607,6 +3793,28 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
       return popover;
     }
   }
+  /**
+   * Whether the given event originated inside the properties dialog subtree (either the table or the
+   * cell properties form).
+   *
+   * @param {Event} event - The event to test.
+   * @returns {boolean} `true` when an active form is rendered and the event's composed path includes it.
+   */
+  isEventWithinPopover(event) {
+    const path = event.composedPath();
+    return ((!!this.tablePropertiesFormRef && path.includes(this.tablePropertiesFormRef)) ||
+      (!!this.cellPropertiesFormRef && path.includes(this.cellPropertiesFormRef)));
+  }
+  /**
+   * Resolves the `.rich-text-content` editor root from the current table ref so the content can be
+   * made inert while the properties dialog holds keyboard/VoiceOver focus.
+   *
+   * @returns {Nullable<HTMLElement>} The editor content element, or `null` when it cannot be resolved.
+   */
+  getInertContentTarget() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.getTableRef) === null || _a === void 0 ? void 0 : _a.call(this)) === null || _b === void 0 ? void 0 : _b.closest('.rich-text-content')) !== null && _c !== void 0 ? _c : null;
+  }
   /**
    * Updates the visibility of the pre-rendered content blocks based on type.
    *
@@ -3644,6 +3852,48 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
     const extensionContext = this.getTableExtensionContext();
     extensionContext && (this.currentFocusNode = extensionContext.getSelectedNodes()[0]);
   }
+  /**
+   * Moves focus to the first focusable control in the active properties form so keyboard and
+   * screen-reader users land inside the dialog when it opens. The first form field is the Border
+   * Style select; its focusable trigger is the `.vega-input-select-container` element.
+   *
+   * @param {string} type - The table setting type that determines which form is visible.
+   */
+  focusFirstFormField(type) {
+    const formRef = type === splitCellOperation.TableSettingType.TABLE ? this.tablePropertiesFormRef : this.cellPropertiesFormRef;
+    if (!formRef) {
+      return;
+    }
+    // Make the editor content inert up front so the table/cell cannot steal focus while the dialog
+    // lays out. The cell form applies the selected cell's styles on open, whose async reset fires a
+    // selectionchange that would otherwise re-focus the cell before we reach Border Style. Inert also
+    // gives VoiceOver no cell-caret text context, so its cursor follows the focus. Lifted on hide.
+    this.setEditorContentInert(true);
+    // The CELL form applies the selected cell's styles on open (it sets both `styleMap` and
+    // `defaultValue`), a heavier re-render than TABLE, so on the first open its Border Style control is
+    // present but 0×0 for a frame. WebKit's VoiceOver cursor does not follow `.focus()` onto a
+    // zero-area element, so defer through a double animation frame: the first schedules past the
+    // popover's async reveal, the second runs after the browser has committed the layout pass that
+    // sizes the control.
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        var _a, _b, _c, _d, _e;
+        const firstField = (_b = (_a = formRef.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('[data-vega-form]')) !== null && _b !== void 0 ? _b : null;
+        const container = (_d = (_c = firstField === null || firstField === void 0 ? void 0 : firstField.shadowRoot) === null || _c === void 0 ? void 0 : _c.querySelector('.vega-input-select-container')) !== null && _d !== void 0 ? _d : null;
+        (_e = (container !== null && container !== void 0 ? container : firstField)) === null || _e === void 0 ? void 0 : _e.focus();
+      });
+    });
+  }
+  /**
+   * When the properties dialog hides after an Escape press, returns focus (and the caret) to the
+   * table cell that had focus before the dialog was opened via the setting toolbar.
+   */
+  handleDialogHide() {
+    // Lift the inert guard on the editor content synchronously, before any focus restore runs, so the
+    // cell can receive focus and the editor is interactive again.
+    this.setEditorContentInert(false);
+    this.restoreFocusOnEscapeHide();
+  }
   /**
    * Create and position an invisible anchor element whose position and size are identical to the geometry of the current multi-cell selection.
    * This anchor element will then be used as the target of the popup, so that the popup appears near the entire selection area.
@@ -3738,6 +3988,62 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
         this.tableSettingRef.selectedCells = this.getTableSelectedCells();
       }
     };
+    /**
+     * Hides the table setting toolbar and its dynamic popover. Used when focus leaves the table (e.g.
+     * Escape moves focus from a cell back onto the table) so the contextual toolbar does not linger.
+     */
+    this.hide = () => {
+      var _a;
+      void this.tableDynamicPopover.hide();
+      void ((_a = this.popoverRef) === null || _a === void 0 ? void 0 : _a.hide());
+    };
+    /**
+     * Opens the table setting toolbar for keyboard/screen-reader users and moves focus to its first
+     * enabled button. Used by the Alt+F10 shortcut so the toolbar can be reached from inside a cell
+     * even when it is currently closed: it re-targets and shows the popover (the same path as a table
+     * click) before deferring focus to the first enabled button.
+     *
+     * @param {RTETableBlock} tableBlock - The table's block data.
+     * @param {() => HTMLElement} getTableRef - Getter for the table's DOM element.
+     * @param {Nullable<HTMLElement>} returnCell - The cell to return focus to if the toolbar is dismissed with Escape.
+     */
+    this.openSettingToolbarForKeyboard = (tableBlock, getTableRef, returnCell) => {
+      // Re-target and show the popover through the same path as a table click so the toolbar is
+      // actually visible before focus lands on it — otherwise focus would be pushed onto a hidden
+      // or stale toolbar that isn't shown.
+      this.reTarget(tableBlock, getTableRef);
+      void this.tableDynamicPopover.hide();
+      remoteInvocationRegistry.remoteInvocationRegistry.call(domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubject(this.popoverRef, vegaInternalEventId.VegaInternalPopoverUpdateTarget), getTableRef());
+      void this.popoverRef.show(true);
+      this.focusFirstSettingButton(returnCell);
+    };
+    /**
+     * Moves focus to the first enabled button in the table setting toolbar. Used by the Alt+F10
+     * shortcut so keyboard and screen-reader users can reach the toolbar from inside the table.
+     *
+     * @param {Nullable<HTMLElement>} returnCell - The cell to return focus to if the toolbar is dismissed with Escape.
+     */
+    this.focusFirstSettingButton = (returnCell) => {
+      var _a, _b;
+      // Remember the cell to return focus to if the toolbar is dismissed with Escape, and clear any
+      // stale Escape recorded before the toolbar was focused.
+      this.beginReturnFocusTracking(returnCell);
+      // Safari VoiceOver ignores the toolbar's aria-modal and keeps driving a caret through the still
+      // editable content, so on Ctrl+Opt+Right it walks the DOM caret out of the table into the editor
+      // instead of staying on the toolbar. Clear the caret AND make the editor content inert so there is
+      // no text context for VoiceOver to advance; the inert flag is lifted again when the toolbar hides.
+      (_b = (_a = this.getTableExtensionContext()) === null || _a === void 0 ? void 0 : _a.getSelection()) === null || _b === void 0 ? void 0 : _b.removeAllRanges();
+      this.setEditorContentInert(true);
+      // The popover reveals its content asynchronously, so defer to the next tick to make sure
+      // the setting buttons are present and focusable.
+      // eslint-disable-next-line no-restricted-globals
+      setTimeout(() => {
+        var _a, _b, _c;
+        const buttons = Array.from((_c = (_b = (_a = this.tableSettingRef) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelectorAll('.rte-table-setting-item')) !== null && _c !== void 0 ? _c : []);
+        const firstEnabled = buttons.find((button) => !button.hasAttribute('disabled'));
+        firstEnabled === null || firstEnabled === void 0 ? void 0 : firstEnabled.focus();
+      }, 0);
+    };
     /**
      * Handles setting menu click events.
      *
@@ -3750,11 +4056,16 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
         extensionContext && handler.execute(event.detail, extensionContext, this.tableBlock);
         if (event.detail[0] === splitCellOperation.TableSettingType.CAPTION) {
           this.updateTableSettingCaption();
+          this.moveFocusToCaption();
         }
       }
       if (event.detail[0] === splitCellOperation.TableSettingType.TABLE || event.detail[0] === splitCellOperation.TableSettingType.CELL) {
+        // Capture the return cell before hiding the setting popover, whose own hide handler clears
+        // it, so the properties dialog can move focus into itself and restore it to the cell on
+        // Escape for keyboard/screen-reader users.
+        const returnCell = this.returnFocusCell;
         void this.popoverRef.hide();
-        void this.tableDynamicPopover.show(event.detail[0]);
+        void this.tableDynamicPopover.show(event.detail[0], returnCell);
       }
     };
     /**
@@ -3762,6 +4073,17 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
      */
     this.handleTableSettingPopoverShow = () => {
       this.syncSelectedCells();
+      this.labelSettingDialog();
+    };
+    /**
+     * When the setting popover hides after an Escape press, returns focus (and the caret) to the
+     * table cell that had focus before the toolbar was reached via Alt+F10.
+     */
+    this.handleTableSettingPopoverHide = () => {
+      // Lift the inert guard on the editor content synchronously, before any focus restore runs, so the
+      // cell (or the properties dialog) can receive focus and the editor is interactive again.
+      this.setEditorContentInert(false);
+      this.restoreFocusOnEscapeHide();
     };
     this.tableDynamicPopover = new TableDynamicPopoverRenderer(splitCellOperation.RTETableColorManager.getTableColors(), renderContext);
   }
@@ -3770,6 +4092,8 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
    */
   destroy() {
     this.tableDynamicPopover.destroy();
+    this.setEditorContentInert(false);
+    this.detachEscapeTracker();
     if (this.popoverContainer) {
       this.popoverContainer.remove();
     }
@@ -3790,6 +4114,10 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
       popover.isScreenPosition = true;
       popover.className = 'rte-table-setting-popover';
       domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(popover, vegaEventId.VegaPopoverShow, this.handleTableSettingPopoverShow);
+      domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(popover, vegaEventId.VegaPopoverHide, this.handleTableSettingPopoverHide);
+      // Escape inside the popover (rendered in a portal) does not bubble back to the table, so
+      // observe it on the document (capture phase) to know when to return focus to the cell.
+      this.attachEscapeTracker(safeDocument);
       const slotDiv = safeDocument.createElement('div');
       slotDiv.setAttribute('slot', 'popover');
       const tableSetting = safeDocument.createElement('vega-rich-text-table-setting');
@@ -3802,6 +4130,25 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
       this.tableSettingRef = tableSetting;
     }
   }
+  /**
+   * Whether the given event originated inside the setting toolbar subtree.
+   *
+   * @param {Event} event - The event to test.
+   * @returns {boolean} `true` when the toolbar is rendered and the event's composed path includes it.
+   */
+  isEventWithinPopover(event) {
+    return !!this.tableSettingRef && event.composedPath().includes(this.tableSettingRef);
+  }
+  /**
+   * Resolves the `.rich-text-content` editor root from the setting toolbar's target so the content
+   * can be made inert while the toolbar holds keyboard/VoiceOver focus.
+   *
+   * @returns {Nullable<HTMLElement>} The editor content element, or `null` when it cannot be resolved.
+   */
+  getInertContentTarget() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.tableSettingRef) === null || _a === void 0 ? void 0 : _a.target) === null || _b === void 0 ? void 0 : _b.closest('.rich-text-content')) !== null && _c !== void 0 ? _c : null;
+  }
   /**
    * Updates the table setting component caption state to match the current table data.
    */
@@ -3811,6 +4158,35 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
       this.tableSettingRef.hasCaption = hasCaption;
     }
   }
+  /**
+   * When the caption is toggled on, moves keyboard/VoiceOver focus and the caret into the caption so
+   * the user lands in it to start typing. The setting toolbar is opened as inert-guarded for
+   * keyboard/screen-reader users, so lift that guard first; the caption is re-rendered by the toggle,
+   * so defer the focus to the next tick when the `<caption>` element exists.
+   */
+  moveFocusToCaption() {
+    if (!this.tableBlock.hasCaption()) {
+      return;
+    }
+    this.setEditorContentInert(false);
+    // eslint-disable-next-line no-restricted-globals
+    setTimeout(() => {
+      var _a, _b, _c, _d, _e, _f, _g;
+      const caption = (_c = (_b = (_a = this.tableSettingRef) === null || _a === void 0 ? void 0 : _a.target) === null || _b === void 0 ? void 0 : _b.querySelector('caption')) !== null && _c !== void 0 ? _c : null;
+      if (!caption) {
+        return;
+      }
+      caption.focus();
+      const selection = (_g = (_e = (_d = this.getTableExtensionContext()) === null || _d === void 0 ? void 0 : _d.getSelection()) !== null && _e !== void 0 ? _e : (_f = caption.ownerDocument) === null || _f === void 0 ? void 0 : _f.getSelection()) !== null && _g !== void 0 ? _g : null;
+      if (selection) {
+        const range = new Range();
+        range.selectNodeContents(caption);
+        range.collapse(false);
+        selection.removeAllRanges();
+        selection.addRange(range);
+      }
+    }, 0);
+  }
   /**
    * Re-targets the shared popovers to the given table.
    *
@@ -3825,6 +4201,22 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
       this.tableDynamicPopover.reTarget(tableBlock, getTableRef);
     }
   }
+  /**
+   * `vega-popover-content-box` renders `role="dialog"` + `aria-modal="true"`, which on WebKit
+   * VoiceOver confines the reading cursor to the popover. Keep those semantics so Ctrl+Opt+Arrow
+   * cannot walk the VoiceOver cursor out of the toolbar past the last button (VoiceOver swallows
+   * those keys, so this cannot be trapped in JS), and give the dialog an accessible name so it
+   * announces "Table tools" on entry.
+   */
+  labelSettingDialog() {
+    var _a, _b;
+    const dialog = (_b = (_a = this.tableSettingRef) === null || _a === void 0 ? void 0 : _a.closest('vega-popover-content-box')) !== null && _b !== void 0 ? _b : null;
+    if (dialog) {
+      dialog.setAttribute('role', 'dialog');
+      dialog.setAttribute('aria-modal', 'true');
+      dialog.setAttribute('aria-label', 'Table tools');
+    }
+  }
   /**
    * Collects and returns the currently selected table cells.
    *
@@ -3850,7 +4242,7 @@ class RTETableBlockRenderer extends linkExtension.VegaRTEExtensionRenderer {
    */
   doRender(h, renderData, rteContext) {
     let tableRef;
-    const table = this.renderTable(h, renderData, (ref) => (tableRef = ref));
+    const table = this.renderTable(h, renderData, (ref) => (tableRef = ref), rteContext);
     this.renderTableToolbar(rteContext);
     const tableAnnotation = renderData.getAnnotationByType(splitCellOperation.RTETableExtensionAnnotationTypeEnum.TABLE);
     const children = rteContext.editable
@@ -3874,9 +4266,16 @@ class RTETableBlockRenderer extends linkExtension.VegaRTEExtensionRenderer {
             }
           },
         }, [
-          // Add an extra div as slot container, to make sure the cursor can move to before/end of the table.
+          // The table is a fully non-editable "widget" wrapped by a
+          // `<div contenteditable="false">`: there is NO editable element wrapping the
+          // table, so Chrome/VoiceOver exposes it as a real table ("table, N columns, M
+          // rows") instead of flattening it into the surrounding text entry area. The
+          // <table> stays a plain, semantically clean table and each cell re-enables editing
+          // via contentEditable=true. The cursor moves to before/after the table via the
+          // adjacent paragraphs in the editor content, treating the table as an atomic widget.
           h('div', {
-            contentEditable: true,
+            class: 'v-rte--extension-table-widget',
+            contentEditable: false,
             ref: this.useRef(renderData),
           }, [table]),
         ]),
@@ -3890,6 +4289,11 @@ class RTETableBlockRenderer extends linkExtension.VegaRTEExtensionRenderer {
     }
     const result = h('div', {
       class: 'v-rte--extension-table-container',
+      // The container is `display: table` (for shrink-to-fit centering), which WebKit maps to an
+      // AXTable. Without this, Safari VoiceOver lands its cursor on the container (or groups up to
+      // the widget host) instead of the real `<table>`. `role="presentation"` strips the container's
+      // implicit table semantics so VO descends to `table.v-rte--extension-table` like Chrome does.
+      role: 'presentation',
       style: Object.assign({}, containerStyle),
     }, children);
     /**
@@ -3918,17 +4322,151 @@ class RTETableBlockRenderer extends linkExtension.VegaRTEExtensionRenderer {
    * @param {VegaRTECreateElementFunction} h - The create element function.
    * @param {RTETableBlock} renderData - The table block to render.
    * @param {(ref: HTMLElement) => HTMLElement} setTableRef - Set table ref to tableRef
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
    * @returns {VegaRTERenderResult} - The rendered table element.
    */
-  renderTable(h, renderData, setTableRef) {
+  renderTable(h, renderData, setTableRef, rteContext) {
     var _a;
-    return h('table', Object.assign(Object.assign({ key: renderData.id }, (_a = renderData.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.render()), { style: renderData.getStyles(), class: renderData.getClasses(), 
+    const editable = !!rteContext.editable;
+    return h('table', Object.assign(Object.assign(Object.assign(Object.assign({ key: renderData.id }, (_a = renderData.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.render()), { style: renderData.getStyles(), class: renderData.getClasses() }), (editable
+      ? {
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        onClick: (event) => this.handleTableActivate(event, rteContext),
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        onKeyDown: (event) => this.handleTableKeyDown(event, rteContext, renderData),
+      }
+      : undefined)), { 
       // eslint-disable-next-line jsdoc/require-jsdoc
       ref: (ref) => {
         this.useRef(renderData)(ref);
         setTableRef(ref);
       } }));
   }
+  /**
+   * Handles activation of the table itself (e.g. VoiceOver Ctrl+Option+Space, which dispatches a
+   * click on the focused table) by moving focus into the first cell so the user can start editing.
+   *
+   * @param {MouseEvent} event - The click event dispatched on the table.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  handleTableActivate(event, rteContext) {
+    const tableRef = event.currentTarget;
+    // Only treat this as "activate the table" when the click truly targets the table element
+    // itself — i.e. VoiceOver Ctrl+Option+Space (which dispatches a click on the focused table)
+    // or a click on the table's own padding/border. Clicks that bubble up from editable
+    // descendants (cells, or the supported <caption>) keep their native contentEditable caret
+    // placement, so we must not force focus into the first cell and break that interaction.
+    if (event.target !== event.currentTarget) {
+      return;
+    }
+    this.focusFirstCell(tableRef, rteContext);
+  }
+  /**
+   * Handles table-scoped keyboard shortcuts while focus is inside the table:
+   * - Alt+F10 opens the table setting toolbar (re-targeting and showing it when needed) and moves
+   *   focus to it (the common "focus the contextual toolbar" shortcut), so keyboard/screen-reader
+   *   users can reach the toolbar buttons even when it is currently closed.
+   * - Escape moves focus back onto the table, so the caret leaves the cell (its focus highlight
+   *   is cleared), the contextual setting toolbar is dismissed, and screen readers announce the
+   *   table again.
+   *
+   * @param {KeyboardEvent} event - The keydown event.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   * @param {RTETableBlock} renderData - The table block being rendered.
+   */
+  handleTableKeyDown(event, rteContext, renderData) {
+    var _a, _b;
+    if (event.altKey && event.key === 'F10') {
+      event.preventDefault();
+      event.stopPropagation();
+      const tableRef = event.currentTarget;
+      const f10Target = event.target;
+      const f10Cell = f10Target
+        ? f10Target.closest('td, th')
+        : null;
+      (_a = this.tableToolbar) === null || _a === void 0 ? void 0 : _a.openSettingToolbarForKeyboard(renderData, () => tableRef, f10Cell);
+      return;
+    }
+    if (event.key !== 'Escape') {
+      return;
+    }
+    const tableRef = event.currentTarget;
+    const target = event.target;
+    const cell = target
+      ? target.closest('td, th')
+      : null;
+    if (!cell || !tableRef.contains(cell)) {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    this.focusTable(tableRef, rteContext);
+    // Focus moved from the cell back onto the table, so dismiss the contextual setting toolbar
+    // that may have been opened (e.g. by activating the table) — otherwise it lingers with no
+    // focused cell to act on.
+    (_b = this.tableToolbar) === null || _b === void 0 ? void 0 : _b.hide();
+  }
+  /**
+   * Moves focus (and the caret) into the first cell of the table.
+   *
+   * @param {HTMLElement} tableRef - The table element.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  focusFirstCell(tableRef, rteContext) {
+    const firstCell = tableRef.querySelector('td, th');
+    if (!firstCell) {
+      return;
+    }
+    firstCell.focus();
+    const selection = this.getSelection(rteContext, tableRef);
+    if (selection) {
+      // Collapse the caret at the start of the cell content so the user can start typing.
+      const range = new Range();
+      range.setStart(firstCell, 0);
+      range.setEnd(firstCell, 0);
+      selection.removeAllRanges();
+      selection.addRange(range);
+    }
+  }
+  /**
+   * Moves focus onto the table element and clears any cell caret and selection highlight.
+   *
+   * @param {HTMLElement} tableRef - The table element.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  focusTable(tableRef, rteContext) {
+    var _a;
+    const selection = this.getSelection(rteContext, tableRef);
+    selection === null || selection === void 0 ? void 0 : selection.removeAllRanges();
+    const extensionContext = this.getExtensionContext(rteContext.host);
+    (_a = extensionContext === null || extensionContext === void 0 ? void 0 : extensionContext.tableSelection) === null || _a === void 0 ? void 0 : _a.setSelectedCells([]);
+    // The table is contentEditable=false, so it is not focusable by default. Add tabindex ONLY
+    // while moving focus onto it, and remove it again on blur, so that during normal navigation
+    // VoiceOver still announces it as "table, N columns, M rows" rather than a focusable widget.
+    tableRef.setAttribute('tabindex', '-1');
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    const removeTabindex = () => {
+      tableRef.removeAttribute('tabindex');
+      tableRef.removeEventListener('blur', removeTabindex);
+    };
+    tableRef.addEventListener('blur', removeTabindex);
+    tableRef.focus();
+  }
+  /**
+   * Resolves the editor selection, preferring the shadow-aware selection from the extension
+   * context and falling back to the table's owning document.
+   *
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   * @param {HTMLElement} tableRef - The table element.
+   * @returns {Nullable<Selection>} - The resolved selection, or null when unavailable.
+   */
+  getSelection(rteContext, tableRef) {
+    const extensionContext = this.getExtensionContext(rteContext.host);
+    if (extensionContext) {
+      return extensionContext.getSelection();
+    }
+    return tableRef.ownerDocument ? tableRef.ownerDocument.getSelection() : null;
+  }
   /**
    * Handles the removal of the table block.
    *
@@ -4031,9 +4569,9 @@ class RTETableCellRenderer extends linkExtension.VegaRTEExtensionRenderer {
    */
   renderByCellType(h, renderData, rteContext, elementType) {
     var _a;
-    return h(elementType, Object.assign(Object.assign(Object.assign({ key: `${renderData.id}-${elementType}`, 
+    return h(elementType, Object.assign(Object.assign(Object.assign(Object.assign({ key: `${renderData.id}-${elementType}`, 
       // eslint-disable-next-line jsdoc/require-jsdoc
-      ref: this.useRef(renderData) }, (_a = renderData.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.render()), { style: renderData.getStyles(rteContext), class: renderData.getClasses() }), (rteContext.editable ? this.onSelectionListeners(renderData, rteContext) : undefined)));
+      ref: this.useRef(renderData) }, (rteContext.editable ? { contentEditable: true, tabindex: -1 } : undefined)), (_a = renderData.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.render()), { style: renderData.getStyles(rteContext), class: renderData.getClasses() }), (rteContext.editable ? this.onSelectionListeners(renderData, rteContext) : undefined)));
   }
   /**
    * Returns the mouse event listeners for selection handling.
@@ -4312,6 +4850,7 @@ class RTETableToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return createTablePopoverRenderer.render(h, super.renderButton(h, editorContext, {
       showArrowIcon: true,
       icon: 'rte-table',
+      ariaLabel: 'Table',
       tooltip: { text: 'Insert table' },
     }));
   }
@@ -4492,16 +5031,10 @@ class RTETableCaptionRenderer extends linkExtension.VegaRTEExtensionRenderer {
   /**
    * @inheritDoc
    */
-  doRender(h, renderData) {
-    return h('caption', {
-      'key': renderData.id,
-      'ref': this.useRef(renderData),
-      'style': renderData.getStyles(),
-      'class': [renderData.getClasses(), renderData.isNotEmpty() ? null : 'showPlaceholder']
+  doRender(h, renderData, rteContext) {
+    return h('caption', Object.assign(Object.assign({ 'key': renderData.id, 'ref': this.useRef(renderData) }, (rteContext.editable ? { contentEditable: true } : undefined)), { 'style': renderData.getStyles(), 'class': [renderData.getClasses(), renderData.isNotEmpty() ? null : 'showPlaceholder']
         .filter(typeGuard.isNonNullable)
-        .join(' '),
-      'data-placeholder': TABLE_CAPTION_PLACEHOLDER_TEXT,
-    });
+        .join(' '), 'data-placeholder': TABLE_CAPTION_PLACEHOLDER_TEXT }));
   }
 }
 
@@ -5297,11 +5830,36 @@ class RTETableSelection {
       const commonAncestorContainer = range.commonAncestorContainer;
       const rangeInTable = !!ui.findParent(commonAncestorContainer, `table`);
       if (rangeInTable) {
-        const selectedCells = this.filterSelectedCell(range, commonAncestorContainer);
+        let selectedCells = this.filterSelectedCell(range, commonAncestorContainer);
+        if (selectedCells.length === 0) {
+          // A collapsed caret placed at an element boundary (e.g. keyboard/VoiceOver entry via
+          // Ctrl+Option+Space) does not intersect a text node, so filterSelectedCell finds nothing
+          // on browsers that keep the caret on the element (Firefox) instead of normalizing it into
+          // the text node (Chrome). Resolve the containing cell directly so the setting toolbar is
+          // still enabled.
+          selectedCells = this.resolveCaretCell(commonAncestorContainer);
+        }
         this.setSelectedCells(selectedCells);
       }
     }
   }
+  /**
+   * Resolve the single table cell that contains the given selection node. Used as a fallback when a
+   * collapsed caret does not intersect any text node (see handleSelectionChange).
+   *
+   * @param {Node} node - The selection's common ancestor container.
+   * @returns {RTETableCellBlock[]} The containing cell block, or an empty list when none is found.
+   */
+  resolveCaretCell(node) {
+    var _a;
+    const startElement = node.nodeType === Node.TEXT_NODE ? node.parentElement : node;
+    const cellRef = (_a = startElement === null || startElement === void 0 ? void 0 : startElement.closest('td, th')) !== null && _a !== void 0 ? _a : null;
+    if (!cellRef) {
+      return [];
+    }
+    const cellBlock = codeBlock.stateEntityRenderingRegistry.getEntityByDOM(cellRef);
+    return cellBlock ? [cellBlock] : [];
+  }
   /**
    * Mark the beginning of a drag operation.
    */
@@ -7870,6 +8428,7 @@ class RTEHorizontalLineToolbarButtonRenderer extends VegaRTEToolbarButtonRendere
   render(createElement, editorContext) {
     return this.renderButton(createElement, editorContext, {
       icon: 'horizontal-line',
+      ariaLabel: internalTranslationController.VegaInternalTranslation.t('Horizontal line'),
       tooltip: { text: internalTranslationController.VegaInternalTranslation.t('Horizontal line') },
     });
   }
@@ -8465,6 +9024,7 @@ class RTEBlockquoteToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
   render(createElement, editorContext) {
     return this.renderButton(createElement, editorContext, {
       icon: 'quote-left',
+      ariaLabel: editorContext.translation.t('Block quote'),
       tooltip: { text: 'Block quote' },
     });
   }
@@ -9097,6 +9657,7 @@ class RTESpecialCharactersToolbarButtonRenderer extends VegaRTEToolbarButtonRend
       placement: 'bottom',
       showArrow: false,
       isScreenPosition: true,
+      role: 'presentation',
       // eslint-disable-next-line jsdoc/require-jsdoc
       ref: (ref) => {
         if (ref) {
@@ -9124,6 +9685,7 @@ class RTESpecialCharactersToolbarButtonRenderer extends VegaRTEToolbarButtonRend
       ]),
       h('div', { slot: 'popover-content' }, this.renderButton(h, editorContext, {
         icon: 'rte-special-characters',
+        ariaLabel: editorContext.translation.t('Special Characters'),
         tooltip: { text: 'Special Characters' },
       })),
     ]);
@@ -10337,14 +10899,22 @@ class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
       placement: 'bottom',
       showArrow: false,
       isScreenPosition: true,
+      role: 'presentation',
       // eslint-disable-next-line jsdoc/require-jsdoc
       ref: (ref) => {
         if (ref) {
           this.popoverRef = ref;
           domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, vegaEventId.VegaPopoverHide, () => {
+            const shouldRestoreFocus = this.shouldRestoreFocusToButton();
             this.isPopoverOpen = false;
             this.findController.clear();
             this.updatePanel({ current: 0, total: 0 });
+            if (shouldRestoreFocus) {
+              // Defer so it runs after the popover's own focus-restore
+              // (AriaDialogFocusableTrapSlimmer), returning focus to the toolbar
+              // button for keyboard and VoiceOver users when the panel is dismissed.
+              setTimeout(() => this.focusToolbarButton());
+            }
           });
           domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, vegaEventId.VegaPopoverShow, () => {
             this.isPopoverOpen = true;
@@ -10375,6 +10945,7 @@ class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
       ]),
       h('div', { slot: 'popover-content' }, this.renderButton(h, editorContext, {
         icon: 'rte-find-replace',
+        ariaLabel: editorContext.translation.t('Find and replace'),
         tooltip: { text: internalTranslationController.VegaInternalTranslation.t('Find and replace') },
       })),
     ]);
@@ -10477,6 +11048,47 @@ class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
       void this.popoverRef.hide();
     }
   }
+  /**
+   * Decides whether closing the panel should return focus to the toolbar button.
+   *
+   * Focus is restored when the panel is dismissed while focus is still inside it
+   * (Escape key or the Close button) — including the VoiceOver case where the
+   * dialog's `inert` blur has already moved focus to `<body>`. It is not restored
+   * when focus has intentionally moved to another element (Tab out of the panel
+   * or interacting with something else), so we don't yank focus back.
+   *
+   * @returns {boolean} True when focus should return to the toolbar button.
+   */
+  shouldRestoreFocusToButton() {
+    // eslint-disable-next-line no-restricted-globals
+    const activeEl = ui.getDeepActiveElementInShadow(document, true);
+    // eslint-disable-next-line no-restricted-globals
+    return !activeEl || activeEl === document.body || this.isElementWithinPanel(activeEl);
+  }
+  /**
+   * Checks whether an element is inside the panel, crossing shadow boundaries.
+   *
+   * @param {Nullable<HTMLElement>} el - The element to test.
+   * @returns {boolean} True when the element is contained by the panel.
+   */
+  isElementWithinPanel(el) {
+    if (!el || !this.panelRef) {
+      return false;
+    }
+    let node = el;
+    while (node) {
+      if (node === this.panelRef) {
+        return true;
+      }
+      const parent = node.parentNode;
+      // Cross shadow boundaries: a shadow root (nodeType 11) exposes its `host`.
+      node =
+        parent && parent.nodeType === Node.DOCUMENT_FRAGMENT_NODE
+          ? parent.host
+          : parent;
+    }
+    return false;
+  }
 }
 (() => {
   internalIconManager.VegaInternalIconManager.register({ 'rte-find-replace': findReplaceIcon });
@@ -10638,12 +11250,28 @@ class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     }, [
       this.renderButton(createElement, editorContext, {
         icon: 'line-height',
+        ariaLabel: editorContext.translation.t('Line Height'),
         showArrowIcon: true,
         tooltip: { text: internalTranslationController.VegaInternalTranslation.t('Line Height') },
       }),
       this.renderDropdownListTemplate(createElement, dropdownItems, editorContext),
     ]);
   }
+  /**
+   * Renders each line-height option with its label as light-DOM children rather than the
+   * `label` prop. This gives the focusable menuitem a light-DOM text anchor so Safari
+   * VoiceOver's reading cursor follows focus into the item (Ctrl+Opt+Right walks item→item
+   * instead of escaping to the next toolbar button).
+   *
+   * The label is wrapped in a `<span>` (not a bare text node) so a click targeting the label
+   * lands on a slotted element that composes into the item's shadow `<li>`; a bare text node
+   * resolves to the `vega-dropdown-item` host, whose click never reaches the shadow handler.
+   *
+   * @inheritDoc
+   */
+  renderDropdownItem(h, item, editorContext) {
+    return h('vega-dropdown-item', { key: item.key, itemKey: item.key, prefixIcon: item.icon }, h('span', undefined, editorContext.translation.t(item.label)));
+  }
   /**
    * @inheritDoc
    */
@@ -10945,6 +11573,9 @@ class RTEFullscreenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     const selected = this.isSelected();
     return this.renderButton(createElement, editorContext, {
       icon: selected ? 'rte-fullscreen-exit' : 'rte-fullscreen-enter',
+      ariaLabel: selected
+        ? editorContext.translation.t('Exit fullscreen mode')
+        : editorContext.translation.t('Enter fullscreen mode'),
       tooltip: {
         text: selected
           ? internalTranslationController.VegaInternalTranslation.t('Exit fullscreen mode')
@@ -14433,6 +15064,7 @@ class RTECopyToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
   render(h, editorContext) {
     return this.renderButton(h, editorContext, {
       icon: 'rte-copy',
+      ariaLabel: editorContext.translation.t('Copy'),
       tooltip: { text: 'Copy' },
     });
   }
@@ -14748,6 +15380,7 @@ class RTECutToolbarButtonRenderer extends RTECopyToolbarButtonRenderer {
   render(h, editorContext) {
     return this.renderButton(h, editorContext, {
       icon: 'rte-cut',
+      ariaLabel: editorContext.translation.t('Cut'),
       tooltip: { text: 'Cut' },
     });
   }
@@ -14786,6 +15419,130 @@ class VegaRTECutExtension extends linkExtension.VegaRTEExtension {
 // The unique key for the cut toolbar button, used for registration and retrieval.
 VegaRTECutExtension.TOOLBAR_BUTTON_KEY = 'cut';
 
+/**
+ * Vetoes a commit that would push the character count past the hard limit, while
+ * still allowing deletions and formatting that keep or reduce the count.
+ */
+class PreventHardLimitExceedInterceptor extends ActionHandlerInterceptor {
+  /**
+   * Intercept when the candidate exceeds the configured maximum. Hard-limit
+   * commits are vetoed only when they increase the count.
+   *
+   * @param {CommitValueAction} action - the commit action carrying the candidate and previous values
+   * @returns {boolean} - whether the commit should be vetoed
+   */
+  canIntercept(action) {
+    var _a;
+    const extension = (_a = action.host.extensions) === null || _a === void 0 ? void 0 : _a.find((item) => this.isWordCountExtension(item));
+    if (!extension) {
+      return false;
+    }
+    const { hardLimit, maxChars } = extension.getConfig();
+    const nextContent = action.candidate.getPlainText();
+    const nextCount = extension.calculateTextCount(nextContent);
+    if (!typeGuard.isNonNullable(maxChars) || nextCount <= maxChars) {
+      return false;
+    }
+    let result = false;
+    let prevContent = '';
+    if (hardLimit && action.previous) {
+      prevContent = action.previous.getPlainText();
+      result = nextCount > extension.calculateTextCount(prevContent);
+    }
+    this.notifyCharsLimitExceeded(nextContent, prevContent, extension, action);
+    return result;
+  }
+  /**
+   * Not invoke the origin action handle to veto the commit that would push the character count past the hard limit.
+   */
+  intercept() {
+  }
+  /**
+   * Notify the consumer when the candidate exceeds the configured character limit.
+   * The previous content is empty when hard limit is not enabled for the performance optimization.
+   *
+   * @param {string} nextContent - the candidate content string
+   * @param {string} prevContent - the previous content string
+   * @param {VegaRTEWordCountExtension} extension - the configured word count extension
+   * @param {CommitValueAction} action - the commit action carrying the candidate value
+   */
+  notifyCharsLimitExceeded(nextContent, prevContent, extension, action) {
+    const { maxChars, hardLimit, onCharsLimitExceeded } = extension.getConfig();
+    if (typeof onCharsLimitExceeded === 'function') {
+      if (!hardLimit || prevContent !== nextContent) {
+        onCharsLimitExceeded(action.host, maxChars);
+      }
+    }
+  }
+  /**
+   * Check if the given extension is a word count extension.
+   *
+   * @param {VegaRTEExtension} extension - the extension to check
+   * @returns {boolean} - whether the extension is a word count extension
+   */
+  isWordCountExtension(extension) {
+    return extension['type'] === codeBlock.RTE_WORD_COUNT_KEY;
+  }
+}
+
+/**
+ * Default configuration applied when a word count option is not provided.
+ */
+const DEFAULT_WORD_COUNT_CONFIG = {
+  showCharCount: true,
+  countInlineBreak: false,
+  hardLimit: false,
+};
+/**
+ * Rich Text Editor extension that provides character counting.
+ */
+class VegaRTEWordCountExtension extends linkExtension.VegaRTEExtension {
+  constructor(config = {}) {
+    super();
+    /**
+     * Runtime discriminator used by the core to identify this extension.
+     */
+    this.type = codeBlock.RTE_WORD_COUNT_KEY;
+    this.config = Object.assign(Object.assign({}, DEFAULT_WORD_COUNT_CONFIG), config);
+  }
+  /**
+   * Get the extension configuration.
+   *
+   * @returns {ResolvedRTEWordCountConfig} The word count configuration.
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Compute the character count data for the given editor content.
+   *
+   * @param {VegaRTEContent} value - The editor content.
+   * @returns {VegaRTEWordCountData} The computed character count data.
+   */
+  getData(value) {
+    const plainText = value.getPlainText();
+    const { maxChars, hardLimit } = this.config;
+    const count = this.calculateTextCount(plainText);
+    return { count, maxChars, hardLimit };
+  }
+  /**
+   * Get the character count for the given content string.
+   *
+   * @param {string} content - The content string.
+   * @returns {number} The character count.
+   */
+  calculateTextCount(content) {
+    const { countInlineBreak } = this.config;
+    const text = countInlineBreak ? content : content.replace(/\n/g, '');
+    // Use the spread operator so that surrogate pairs (e.g. emoji) count as a single character.
+    return [...text].length;
+  }
+}
+(() => {
+  // Gate over-limit commits through the shared action-interceptor pipeline.
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(contentState.VegaRTEContent.name, contentState.COMMIT_VALUE, new PreventHardLimitExceedInterceptor());
+})();
+
 /**
  * Insert a new children to the nearest position of the parent container
  *
@@ -14949,6 +15706,7 @@ exports.VegaRTESpecialCharactersText = VegaRTESpecialCharactersText;
 exports.VegaRTETableExtension = VegaRTETableExtension;
 exports.VegaRTETokenExtension = VegaRTETokenExtension;
 exports.VegaRTEToolbarButtonRenderer = VegaRTEToolbarButtonRenderer;
+exports.VegaRTEWordCountExtension = VegaRTEWordCountExtension;
 exports.VegaSkeletonLoader = VegaSkeletonLoader;
 exports.VegaTranslation = VegaTranslation;
 exports.VegaZIndexManager = VegaZIndexManager$1;