@globalpayments/vega 2.99.0 → 2.101.0

package/dist/esm/{token-extension-74a0eeb1.js → token-extension-530d9bde.js}

@@ -1,32 +1,32 @@
 import { g as generateUUID } from './misc-9fdbcfbb.js';
-import { a as arrayToClassString, g as getDeviceType, D as DeviceType, f as findParent, r as rgbToHex } from './ui-d73f756a.js';
+import { a as arrayToClassString, g as getDeviceType, D as DeviceType, f as findParent, r as rgbToHex, b as getDeepActiveElementInShadow } from './ui-80e610f4.js';
 import { L as LogUtility, I as InjectVegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
 import { I as InjectVegaTelemetrySlimmer, c as createPublicAPIRuntimeMetricsSlimmer } from './create-public-api-runtime-metrics-slimmer-48f85199.js';
 import { I as InternalVegaZIndexManager } from './internal-vega-z-index-manager-7d2b54c3.js';
 import { c as createDynamicSlimmer } from './dynamic-slimmer-90b8af32.js';
 import { P as PageResizeObserverSlimmer } from './page-resize-observer-slimmer-e24d36c5.js';
-import { i as internalVegaEventManager } from './internal-vega-event-manager-2ecc9186.js';
-import { V as VegaInternalTranslation } from './internal-translation-controller-b33430c6.js';
-import { I as InternalCalendarPeriodConverter } from './internal-calendar-period-factory-d58f35c6.js';
-import { M as ModifyContentAction, A as ActionHandleStrategyRegistry, R as RTETextNode, H as HTML_VOID_TAGS, a as RTEBlock, b as RTETextBlock, c as RTE_BLOCK_BOUNDARY_ATTRIBUTE, d as RTEAnnotationStyle, e as ActionHandleStrategy, I as InsertChildrenAfterAction, f as AppendChildrenAction, g as RTENode, s as stateEntityRenderingRegistry, h as InsertChildrenBeforeAction, i as InternalAnnotationTypeEnum, j as ModifyContentActionType, B as BlockAnnotation, k as AnnotationAction, l as RemoveChildrenAction, C as CommonAnnotationTypeEnum, m as CustomAttributeAnnotation, n as RTEDTOClassManager, o as RTEFilterStylesStrategy, p as RTEDecoratorNode, S as SplitBlockWithNodeAction, U as UpdateTextAction, q as RTECodeBlock, r as RTEListItemBlock, t as RTECodeBlockNode, N as NodeAnnotationTypeEnum, u as CustomStyleAnnotation, v as RTEFilterStylesStrategyRegistry, w as RTE_PASTE_MODE_DATA_TYPE } from './code-block-e6443949.js';
-import { U as UpdateCursorPositionAction, V as VegaRTEContent, B as BlockToRTEBlockStrategyAbstract, E as ElementToDTOStrategy, h as htmlElementToAnnotationGenerator, H as HtmlBlockStrategy, I as InsertNewParagraphAction, R as RTEImageBlock, a as InsertChildrenBeforeStrategy, P as PasteContentStrategy, A as AnnotationGeneratorStrategyAbstract, S as StylePreservator, b as RTEImageNode } from './content-state-43cdacff.js';
-import { i as isNonNullable } from './type-guard-6fc96870.js';
-import { e as extensionContextManager, a as VegaRTEExtensionRenderer, b as VegaRTEExtension } from './link-extension-230bae8d.js';
+import { i as internalVegaEventManager } from './internal-vega-event-manager-0c381f3b.js';
+import { V as VegaInternalTranslation } from './internal-translation-controller-fff376d2.js';
+import { I as InternalCalendarPeriodConverter } from './internal-calendar-period-factory-d1a60f81.js';
+import { M as ModifyContentAction, A as ActionHandleStrategyRegistry, R as RTETextNode, H as HTML_VOID_TAGS, a as RTEBlock, b as RTETextBlock, c as RTE_BLOCK_BOUNDARY_ATTRIBUTE, d as RTEAnnotationStyle, e as ActionHandleStrategy, I as InsertChildrenAfterAction, f as AppendChildrenAction, g as RTENode, s as stateEntityRenderingRegistry, h as InsertChildrenBeforeAction, i as InternalAnnotationTypeEnum, j as ModifyContentActionType, B as BlockAnnotation, k as AnnotationAction, l as RemoveChildrenAction, C as CommonAnnotationTypeEnum, m as CustomAttributeAnnotation, n as RTEDTOClassManager, o as RTEFilterStylesStrategy, p as RTEDecoratorNode, S as SplitBlockWithNodeAction, U as UpdateTextAction, q as RTECodeBlock, r as RTEListItemBlock, t as RTECodeBlockNode, N as NodeAnnotationTypeEnum, u as CustomStyleAnnotation, v as RTEFilterStylesStrategyRegistry, w as RTE_PASTE_MODE_DATA_TYPE, x as RTE_WORD_COUNT_KEY } from './code-block-1cdf7a51.js';
+import { U as UpdateCursorPositionAction, V as VegaRTEContent, B as BlockToRTEBlockStrategyAbstract, E as ElementToDTOStrategy, h as htmlElementToAnnotationGenerator, H as HtmlBlockStrategy, I as InsertNewParagraphAction, R as RTEImageBlock, a as InsertChildrenBeforeStrategy, P as PasteContentStrategy, A as AnnotationGeneratorStrategyAbstract, S as StylePreservator, b as RTEImageNode, C as COMMIT_VALUE } from './content-state-6eb610b8.js';
+import { i as isNonNullable } from './type-guard-26d83e7e.js';
+import { e as extensionContextManager, a as VegaRTEExtensionRenderer, b as VegaRTEExtension } from './link-extension-bc234cf7.js';
 import { V as VegaInternalIconManager } from './internal-icon-manager-e7c57096.js';
 import { v as vegaNonceManager } from './vega-nonce-manager-497e5eb5.js';
-import { D as DomNodeSubjectObserverFactory, d as domNodeSubjectFactory } from './dom-node-subject-observer-factory-ddff8662.js';
-import { V as VegaDropdownClick, a as VegaClick, b as VegaPopoverHide, c as VegaPopoverShow, d as VegaChange } from './vega-event-id-f55f6977.js';
-import { R as RTETableExtensionAnnotationTypeEnum, a as RTE_TABLE_HEAD_DEFAULT_BACKGROUND_COLOR, S as SettingEventHandler, T as TableSettingType, b as RTETableAnnotation, c as RTETableCellAnnotation, d as RTETableHeadCellBlock, e as RowOperationEventHandler, C as ColumnOperationEventHandler, M as MergeCellsOperationEventHandler, f as SplitCellOperationEventHandler, g as RTETableColorManager, h as RTETableBlock, i as generateTableBody, j as RTETableCellBlock, k as RTETableHeadBlock, l as RTETableBodyBlock, m as getParentBlockByType, n as RTETableHeadCellAnnotation, o as TableColumnStrategy, p as getAllTableRows, q as buildTableGrid, s as setSpanAttributes, r as findCellBlockById, t as getDefaultCellBlockTemplate, I as InsertTableColumnDirection, u as buildCellStartColumnMap, v as getTableColumnCount, w as getFirstNode, x as getCellSpan, y as createNewCell, z as MergeCellsOperationType, A as RTETableRowBlock, B as getActualColumnPosition, D as InsertTableRowDirection, E as RTE_TABLE_DEFAULT_COLORS, F as INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, G as INSERT_TABLE_ROW_INTO_SAME_SECTION, H as DELETE_TABLE_ROW, J as TOGGLE_HEADER_ROW, K as INSERT_TABLE_COLUMN, L as DELETE_TABLE_COLUMN, N as TOGGLE_HEADER_TABLE_COLUMN, O as ToggleHeaderTableColumnStrategy, P as SPLIT_TABLE_CELL, Q as REPLACE_TABLE_CELL, U as SPLIT_CELL_HORIZONTALLY, W as SPLIT_CELL_VERTICALLY, X as SELECT_TABLE_COLUMN, Y as MERGE_CELLS } from './split-cell-operation-89b91a38.js';
+import { D as DomNodeSubjectObserverFactory, d as domNodeSubjectFactory } from './dom-node-subject-observer-factory-bb7e68a0.js';
+import { V as VegaDropdownClick, a as VegaClick, b as VegaPopoverHide, c as VegaPopoverShow, d as VegaChange } from './vega-event-id-59cd9297.js';
+import { R as RTETableExtensionAnnotationTypeEnum, a as RTE_TABLE_HEAD_DEFAULT_BACKGROUND_COLOR, S as SettingEventHandler, T as TableSettingType, b as RTETableAnnotation, c as RTETableCellAnnotation, d as RTETableHeadCellBlock, e as RowOperationEventHandler, C as ColumnOperationEventHandler, M as MergeCellsOperationEventHandler, f as SplitCellOperationEventHandler, g as RTETableColorManager, h as RTETableBlock, i as generateTableBody, j as RTETableCellBlock, k as RTETableHeadBlock, l as RTETableBodyBlock, m as getParentBlockByType, n as RTETableHeadCellAnnotation, o as TableColumnStrategy, p as getAllTableRows, q as buildTableGrid, s as setSpanAttributes, r as findCellBlockById, t as getDefaultCellBlockTemplate, I as InsertTableColumnDirection, u as buildCellStartColumnMap, v as getTableColumnCount, w as getFirstNode, x as getCellSpan, y as createNewCell, z as MergeCellsOperationType, A as RTETableRowBlock, B as getActualColumnPosition, D as InsertTableRowDirection, E as RTE_TABLE_DEFAULT_COLORS, F as INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, G as INSERT_TABLE_ROW_INTO_SAME_SECTION, H as DELETE_TABLE_ROW, J as TOGGLE_HEADER_ROW, K as INSERT_TABLE_COLUMN, L as DELETE_TABLE_COLUMN, N as TOGGLE_HEADER_TABLE_COLUMN, O as ToggleHeaderTableColumnStrategy, P as SPLIT_TABLE_CELL, Q as REPLACE_TABLE_CELL, U as SPLIT_CELL_HORIZONTALLY, W as SPLIT_CELL_VERTICALLY, X as SELECT_TABLE_COLUMN, Y as MERGE_CELLS } from './split-cell-operation-1a889fa0.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
-import { V as VegaInternalRTEExtensionTableCellsSelectionAnchor, a as VegaInternalPopoverUpdateTarget, b as VegaInternalRTEExtensionTableCellSelectionChange } from './vega-internal-event-id-86fce049.js';
+import { V as VegaInternalRTEExtensionTableCellsSelectionAnchor, a as VegaInternalPopoverUpdateTarget, b as VegaInternalRTEExtensionTableCellSelectionChange } from './vega-internal-event-id-02093067.js';
 import { r as remoteInvocationRegistry } from './remote-invocation-registry-d69245c2.js';
-import { V as VegaInternalThemeManager, a as VegaDarkModeStyleController } from './dark-mode-style-controller-352f15ff.js';
+import { V as VegaInternalThemeManager, a as VegaDarkModeStyleController } from './dark-mode-style-controller-4e04a2d3.js';
 import { t as tryGetDocument } from './try-get-document-bef0f526.js';
 import { p as parseToPixelString } from './pixel-f32c07ce.js';
 import { c as cleanObject } from './object-0c277f57.js';
 import { d as debounce } from './timer-9321173b.js';
 import { c as camelToDashCase } from './string-a953eafc.js';
-import { R as ReplaceSelectedTextAction } from './image-extension-9b8abd0d.js';
+import { R as ReplaceSelectedTextAction } from './image-extension-f6dbd70c.js';
 import { c as copy } from './copy-54e45e2d.js';
 
 const VegaLoaderRuntimeMetricsPayloadDefinition = [
@@ -1115,7 +1115,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;
@@ -1199,29 +1199,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.addUniqueObserverToNode(el, 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: VegaInternalIconManager.getIconKey('chevron-down'),
+          'size': 'size-8',
+          'color': isDisabled ? 'text-disabled' : 'text-secondary',
+          'style': { marginLeft: '8px' },
+          'aria-hidden': 'true',
+          'icon': VegaInternalIconManager.getIconKey('chevron-down'),
         })
         : null,
     ].filter(isNonNullable));
@@ -1242,8 +1244,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;
@@ -1275,6 +1278,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.
    *
@@ -1328,14 +1340,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') {
@@ -1353,7 +1365,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;
       }
     }
@@ -1423,6 +1435,7 @@ class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return this.renderDropdown(createElement, editorContext, {}, [
       this.renderButton(createElement, editorContext, {
         label: 'Tokens',
+        ariaLabel: 'Tokens',
         showArrowIcon: true,
         tooltip: { text: 'Insert token' },
       }),
@@ -1706,6 +1719,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' },
       }),
@@ -1721,10 +1735,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));
@@ -2195,6 +2210,12 @@ class RTELogicControlNode extends RTENode {
   isContentEditable() {
     return false;
   }
+  /**
+   * @inheritDoc
+   */
+  getPlainText() {
+    return this.text;
+  }
 }
 RTELogicControlNode.dtoName = 'RTELogicControlNode';
 
@@ -2283,6 +2304,7 @@ class FunctionToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return this.renderDropdown(h, editorContext, {}, [
       this.renderButton(h, editorContext, {
         label: 'Functions',
+        ariaLabel: 'Functions',
         showArrowIcon: true,
         tooltip: { text: 'Insert function' },
       }),
@@ -2809,7 +2831,7 @@ class VegaRTEFunctionExtension extends 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';
 /**
@@ -3427,9 +3449,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;
   }
   /**
@@ -3442,6 +3497,121 @@ class TablePopoverBaseRenderer {
       ? 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;
+    }
+  }
 }
 
 /**
@@ -3511,6 +3681,8 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
    * and clears the internal reference.
    */
   destroy() {
+    this.setEditorContentInert(false);
+    this.detachEscapeTracker();
     if (this.selectionAnchorRef && this.selectionAnchorRef.parentNode) {
       DomNodeSubjectObserverFactory.removeUniqueObserverFromNode(this.selectionAnchorRef, VegaInternalRTEExtensionTableCellsSelectionAnchor);
       this.selectionAnchorRef.parentNode.removeChild(this.selectionAnchorRef);
@@ -3523,8 +3695,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 = [];
@@ -3544,6 +3721,11 @@ class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
     this.storeCurrentFocusNode();
     remoteInvocationRegistry.call(domNodeSubjectFactory.getSubject(this.popoverRef, 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.
@@ -3578,7 +3760,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';
@@ -3605,6 +3791,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.
    *
@@ -3642,6 +3850,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 === 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.
@@ -3736,6 +3986,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.call(domNodeSubjectFactory.getSubject(this.popoverRef, 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.
      *
@@ -3748,11 +4054,16 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
         extensionContext && handler.execute(event.detail, extensionContext, this.tableBlock);
         if (event.detail[0] === TableSettingType.CAPTION) {
           this.updateTableSettingCaption();
+          this.moveFocusToCaption();
         }
       }
       if (event.detail[0] === TableSettingType.TABLE || event.detail[0] === 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);
       }
     };
     /**
@@ -3760,6 +4071,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(RTETableColorManager.getTableColors(), renderContext);
   }
@@ -3768,6 +4090,8 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
    */
   destroy() {
     this.tableDynamicPopover.destroy();
+    this.setEditorContentInert(false);
+    this.detachEscapeTracker();
     if (this.popoverContainer) {
       this.popoverContainer.remove();
     }
@@ -3788,6 +4112,10 @@ class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
       popover.isScreenPosition = true;
       popover.className = 'rte-table-setting-popover';
       DomNodeSubjectObserverFactory.addUniqueObserverToNode(popover, VegaPopoverShow, this.handleTableSettingPopoverShow);
+      DomNodeSubjectObserverFactory.addUniqueObserverToNode(popover, 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');
@@ -3800,6 +4128,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.
    */
@@ -3809,6 +4156,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.
    *
@@ -3823,6 +4199,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.
    *
@@ -3848,7 +4240,7 @@ class RTETableBlockRenderer extends 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(RTETableExtensionAnnotationTypeEnum.TABLE);
     const children = rteContext.editable
@@ -3872,9 +4264,16 @@ class RTETableBlockRenderer extends 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]),
         ]),
@@ -3888,6 +4287,11 @@ class RTETableBlockRenderer extends 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);
     /**
@@ -3916,17 +4320,151 @@ 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.
    */
-  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.
    *
@@ -4029,9 +4567,9 @@ class RTETableCellRenderer extends 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.
@@ -4310,6 +4848,7 @@ class RTETableToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     return createTablePopoverRenderer.render(h, super.renderButton(h, editorContext, {
       showArrowIcon: true,
       icon: 'rte-table',
+      ariaLabel: 'Table',
       tooltip: { text: 'Insert table' },
     }));
   }
@@ -4490,16 +5029,10 @@ class RTETableCaptionRenderer extends 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(isNonNullable)
-        .join(' '),
-      'data-placeholder': TABLE_CAPTION_PLACEHOLDER_TEXT,
-    });
+        .join(' '), 'data-placeholder': TABLE_CAPTION_PLACEHOLDER_TEXT }));
   }
 }
 
@@ -5295,11 +5828,36 @@ class RTETableSelection {
       const commonAncestorContainer = range.commonAncestorContainer;
       const rangeInTable = !!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 = stateEntityRenderingRegistry.getEntityByDOM(cellRef);
+    return cellBlock ? [cellBlock] : [];
+  }
   /**
    * Mark the beginning of a drag operation.
    */
@@ -7868,6 +8426,7 @@ class RTEHorizontalLineToolbarButtonRenderer extends VegaRTEToolbarButtonRendere
   render(createElement, editorContext) {
     return this.renderButton(createElement, editorContext, {
       icon: 'horizontal-line',
+      ariaLabel: VegaInternalTranslation.t('Horizontal line'),
       tooltip: { text: VegaInternalTranslation.t('Horizontal line') },
     });
   }
@@ -8463,6 +9022,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' },
     });
   }
@@ -9095,6 +9655,7 @@ class RTESpecialCharactersToolbarButtonRenderer extends VegaRTEToolbarButtonRend
       placement: 'bottom',
       showArrow: false,
       isScreenPosition: true,
+      role: 'presentation',
       // eslint-disable-next-line jsdoc/require-jsdoc
       ref: (ref) => {
         if (ref) {
@@ -9122,6 +9683,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' },
       })),
     ]);
@@ -10335,14 +10897,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.addUniqueObserverToNode(ref, 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.addUniqueObserverToNode(ref, VegaPopoverShow, () => {
             this.isPopoverOpen = true;
@@ -10373,6 +10943,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: VegaInternalTranslation.t('Find and replace') },
       })),
     ]);
@@ -10475,6 +11046,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 = 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;
+  }
 }
 (() => {
   VegaInternalIconManager.register({ 'rte-find-replace': findReplaceIcon });
@@ -10636,12 +11248,28 @@ class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     }, [
       this.renderButton(createElement, editorContext, {
         icon: 'line-height',
+        ariaLabel: editorContext.translation.t('Line Height'),
         showArrowIcon: true,
         tooltip: { text: 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
    */
@@ -10943,6 +11571,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
           ? VegaInternalTranslation.t('Exit fullscreen mode')
@@ -14431,6 +15062,7 @@ class RTECopyToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
   render(h, editorContext) {
     return this.renderButton(h, editorContext, {
       icon: 'rte-copy',
+      ariaLabel: editorContext.translation.t('Copy'),
       tooltip: { text: 'Copy' },
     });
   }
@@ -14746,6 +15378,7 @@ class RTECutToolbarButtonRenderer extends RTECopyToolbarButtonRenderer {
   render(h, editorContext) {
     return this.renderButton(h, editorContext, {
       icon: 'rte-cut',
+      ariaLabel: editorContext.translation.t('Cut'),
       tooltip: { text: 'Cut' },
     });
   }
@@ -14784,6 +15417,130 @@ class VegaRTECutExtension extends 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 (!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'] === 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 VegaRTEExtension {
+  constructor(config = {}) {
+    super();
+    /**
+     * Runtime discriminator used by the core to identify this extension.
+     */
+    this.type = 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.
+  VegaRTEExtension.registerActionHandlerInterceptor(VegaRTEContent.name, COMMIT_VALUE, new PreventHardLimitExceedInterceptor());
+})();
+
 /**
  * Insert a new children to the nearest position of the parent container
  *
@@ -14914,4 +15671,4 @@ class VegaRTETokenExtension extends VegaRTEExtension {
 })();
 VegaRTETokenExtension.TOOLBAR_BUTTON_KEY = 'token';
 
-export { VegaCalendarPeriodFactory as A, VegaRTEToolbarButtonRenderer as B, RTETokenNode as C, RTETokenNodeRenderer as D, RTELanguageToolbarButtonRenderer as E, RTEBlockquoteBlock as F, DeleteSelectedContentAction as G, ActionHandlerInterceptor as H, InsertNodeToNearestRootAction as I, RTETokenToolbarButtonRenderer as R, VegaLoader as V, VegaNotify as a, VegaEventManager$1 as b, VegaZIndexManager$1 as c, VegaSkeletonLoader as d, VegaTranslation as e, VegaRTETokenExtension as f, VegaRTELanguageExtension as g, VegaRTEDefaultLineHeightOptions as h, VegaRTEFunctionExtension as i, VegaRTETableExtension as j, VegaRTEHorizontalLineExtension as k, VegaRTEBlockquoteExtension as l, VegaRTESpecialCharactersExtension as m, VegaRTEFindReplaceExtension as n, VegaRTESpecialCharactersEssentials as o, VegaRTESpecialCharactersLatin as p, VegaRTESpecialCharactersMathematical as q, VegaRTESpecialCharactersArrows as r, VegaRTESpecialCharactersCurrency as s, VegaRTESpecialCharactersText as t, VegaRTELineHeightExtension as u, VegaRTEPasteExtension as v, waitForVega as w, VegaRTEFullscreenExtension as x, VegaRTECopyExtension as y, VegaRTECutExtension as z };
+export { VegaRTEWordCountExtension as A, VegaCalendarPeriodFactory as B, VegaRTEToolbarButtonRenderer as C, RTETokenNode as D, RTETokenNodeRenderer as E, RTELanguageToolbarButtonRenderer as F, RTEBlockquoteBlock as G, DeleteSelectedContentAction as H, InsertNodeToNearestRootAction as I, ActionHandlerInterceptor as J, RTETokenToolbarButtonRenderer as R, VegaLoader as V, VegaNotify as a, VegaEventManager$1 as b, VegaZIndexManager$1 as c, VegaSkeletonLoader as d, VegaTranslation as e, VegaRTETokenExtension as f, VegaRTELanguageExtension as g, VegaRTEDefaultLineHeightOptions as h, VegaRTEFunctionExtension as i, VegaRTETableExtension as j, VegaRTEHorizontalLineExtension as k, VegaRTEBlockquoteExtension as l, VegaRTESpecialCharactersExtension as m, VegaRTEFindReplaceExtension as n, VegaRTESpecialCharactersEssentials as o, VegaRTESpecialCharactersLatin as p, VegaRTESpecialCharactersMathematical as q, VegaRTESpecialCharactersArrows as r, VegaRTESpecialCharactersCurrency as s, VegaRTESpecialCharactersText as t, VegaRTELineHeightExtension as u, VegaRTEPasteExtension as v, waitForVega as w, VegaRTEFullscreenExtension as x, VegaRTECopyExtension as y, VegaRTECutExtension as z };