@globalpayments/vega 2.98.0 → 2.100.0

package/dist/types/components/vega-rich-text-editor/extensions/table/vega-rich-text-table-setting/slimmers/renderers/row-button-slimmer.d.ts

@@ -1,8 +1,10 @@
 import { TableSettingButtonSlimmer } from './table-setting-button-slimmer.abstract';
+import { VegaRichTextTableSetting } from '../../vega-rich-text-table-setting';
 /**
  * Slimmer dedicated to building the row button.
  */
 export declare class RowButtonSlimmer extends TableSettingButtonSlimmer {
+  isRowDropdownOpen: VegaRichTextTableSetting['isRowDropdownOpen'];
   constructor();
   protected renderBtnWrapper(renderBtn: () => HTMLElement): HTMLElement;
   protected isDisabled(): boolean;
@@ -15,6 +17,7 @@ export declare class RowButtonSlimmer extends TableSettingButtonSlimmer {
    */
   private renderActionList;
   private handleDropdownItemClick;
+  private handleDropdownVisibilityChange;
   /**
    * Check if all selected rows are header rows.
    *

package/dist/types/components/vega-rich-text-editor/extensions/table/vega-rich-text-table-setting/slimmers/renderers/table-setting-button-slimmer.abstract.d.ts

@@ -4,6 +4,7 @@ export declare type RTETableSettingButtonProps = {
   icon: string;
   title: string;
   showArrowIcon?: boolean;
+  ariaLabel: string;
 };
 export declare abstract class TableSettingButtonSlimmer extends VegaSlimmer {
   protected hasCaption: VegaRichTextTableSetting['hasCaption'];
@@ -12,7 +13,8 @@ export declare abstract class TableSettingButtonSlimmer extends VegaSlimmer {
   protected readonly icon: RTETableSettingButtonProps['icon'];
   private readonly title;
   private readonly showArrowIcon;
-  protected constructor({ icon, title, showArrowIcon }: RTETableSettingButtonProps);
+  private readonly ariaLabel;
+  protected constructor({ icon, title, showArrowIcon, ariaLabel }: RTETableSettingButtonProps);
   render(): HTMLElement;
   protected emitClickEvent(setting: Array<string>): void;
   /**

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

@@ -28,6 +28,7 @@ export declare class VegaRichTextTableSetting {
   protected readonly mergeCellsButtonSlimmer: MergeCellsButtonSlimmer;
   host: HTMLVegaRichTextTableSettingElement;
   isColumnDropdownOpen: boolean;
+  isRowDropdownOpen: boolean;
   isMergeCellsDropdownOpen: boolean;
   /**
    * Indicates whether the current table already has a caption.

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

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

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

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

package/dist/types/components/vega-rich-text-editor/extensions/word-count/action-handler-interceptors/prevent-hard-limit-exceed-interceptor.d.ts

@@ -0,0 +1,38 @@
+import { ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { CommitValueAction } from '../../../dto/actions/commit-value-action';
+import type { VegaRTEContent } from '../../../dto/content-state';
+/**
+ * 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.
+ */
+export declare class PreventHardLimitExceedInterceptor extends ActionHandlerInterceptor<CommitValueAction, VegaRTEContent> {
+  /**
+   * 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: CommitValueAction): boolean;
+  /**
+   * Not invoke the origin action handle to veto the commit that would push the character count past the hard limit.
+   */
+  intercept(): void;
+  /**
+   * 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
+   */
+  private notifyCharsLimitExceeded;
+  /**
+   * 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
+   */
+  private isWordCountExtension;
+}

package/dist/types/components/vega-rich-text-editor/extensions/word-count/type.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Configurable options for the word count extension.
+ */
+export declare type VegaRTEWordCountConfig = {
+  /**
+   * Whether to display the character count UI in the editor footer.
+   */
+  showCharCount?: boolean;
+  /**
+   * Whether to count inline line breaks (soft breaks) as characters.
+   * Defaults to `false` to match the common editor behavior of not counting
+   * line breaks.
+   */
+  countInlineBreak?: boolean;
+  /**
+   * The maximum number of characters allowed in the editor content.
+   */
+  maxChars?: number;
+  /**
+   * Whether to enforce the maximum character limit by preventing further input.
+   * Defaults to `false`, which allows users to exceed the limit but still displays the count.
+   */
+  hardLimit?: boolean;
+  /**
+   * Callback fired when content exceeds the configured max character limit.
+   */
+  onCharsLimitExceeded?: (host: HTMLVegaRichTextEditorElement, maxChars: number) => void;
+};
+/**
+ * The data produced by the word count extension for a given plain text input.
+ */
+export declare type VegaRTEWordCountData = {
+  /**
+   * The number of characters in the editor content.
+   */
+  count: number;
+  /**
+   * The maximum number of characters allowed in the editor content which user set.
+   */
+  maxChars?: number;
+  /**
+   * Whether the maximum character limit is enforced by preventing further input.
+   */
+  hardLimit: boolean;
+};
+export declare type ResolvedRTEWordCountConfig = Required<Omit<VegaRTEWordCountConfig, 'maxChars' | 'onCharsLimitExceeded'>> & Pick<VegaRTEWordCountConfig, 'maxChars' | 'onCharsLimitExceeded'>;

package/dist/types/components/vega-rich-text-editor/extensions/word-count/word-count-extension.d.ts

@@ -0,0 +1,38 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { VegaRTEContent } from '../../dto/content-state';
+import { ResolvedRTEWordCountConfig, VegaRTEWordCountConfig, VegaRTEWordCountData } from './type';
+/**
+ * Default configuration applied when a word count option is not provided.
+ */
+export declare const DEFAULT_WORD_COUNT_CONFIG: ResolvedRTEWordCountConfig;
+/**
+ * Rich Text Editor extension that provides character counting.
+ */
+export declare class VegaRTEWordCountExtension extends VegaRTEExtension {
+  /**
+   * Runtime discriminator used by the core to identify this extension.
+   */
+  readonly type: string;
+  private readonly config;
+  constructor(config?: VegaRTEWordCountConfig);
+  /**
+   * Get the extension configuration.
+   *
+   * @returns {ResolvedRTEWordCountConfig} The word count configuration.
+   */
+  getConfig(): ResolvedRTEWordCountConfig;
+  /**
+   * 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: VegaRTEContent): VegaRTEWordCountData;
+  /**
+   * Get the character count for the given content string.
+   *
+   * @param {string} content - The content string.
+   * @returns {number} The character count.
+   */
+  calculateTextCount(content: string): number;
+}

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

@@ -20,6 +20,7 @@ import { RTERange, RTERangeOptions } from './dto/range';
 import { TranslationSlimmer } from '../../helpers/slimmers/translation';
 import type { RTENode } from './dto/nodes/node.abstract';
 import type { VegaRTEContent } from './dto/content-state';
+import type { BlockBoundaryRegistry } from './extensions/block-boundary-registry';
 
 /**
  * Configuration for a toolbar button.
@@ -33,6 +34,12 @@ export type ToolbarButtonConfig = {
 	 * Tooltip configuration for the button.
 	 */
 	tooltip: Partial<Pick<HTMLVegaTooltipElement, 'text'>>;
+	/**
+	 * Accessible name applied as `aria-label` on the underlying toolbar button.
+	 * Optional — when omitted, the button falls back to `tooltip.text` so icon-only
+	 * toolbar buttons still expose a meaningful name to screen readers.
+	 */
+	ariaLabel?: string;
 	/**
 	 * Whether to focus the content when clicked
 	 */
@@ -596,6 +603,11 @@ export type VegaRTETransformOptions = {
 	 * If `true`, filter inline styles when converting to HTML or refill inline styles when converting from HTML. Used in fromHtml and toHtml methods.
 	 */
 	filterInlineStyles?: boolean;
+	/**
+	 * Optional per-editor registry used by inline-continuation strategies to identify
+	 * extension-defined block boundaries.
+	 */
+	blockBoundaryRegistry?: BlockBoundaryRegistry;
 };
 
 /**
@@ -811,6 +823,10 @@ export type RTEExtensionContext = {
 	 * @param {HTMLElement} ref - The host element to schedule a re-render for.
 	 */
 	forceUpdate: (ref: HTMLElement) => void;
+	/**
+	 * Per-editor registry for extension-defined block boundary predicates.
+	 */
+	blockBoundaryRegistry?: BlockBoundaryRegistry;
 };
 
 /**
@@ -834,6 +850,12 @@ export type RTEToolbarButtonProps = {
 	 * When provided, the button will be wrapped in a vega-tooltip.
 	 */
 	tooltip?: Partial<Pick<HTMLVegaTooltipElement, 'text'>>;
+	/**
+	 * Accessible name applied as `aria-label` on the underlying toolbar button.
+	 * When omitted, falls back to `label` so icon-only buttons still expose a
+	 * meaningful name to screen readers.
+	 */
+	ariaLabel?: string;
 };
 
 /**

package/dist/types/components/vega-rich-text-editor/public-api.d.ts

@@ -29,6 +29,7 @@ export { VegaRTEPasteExtension } from './extensions/paste/paste-extension';
 export { VegaRTECopyExtension } from './extensions/copy/copy-extension';
 export { VegaRTECutExtension } from './extensions/cut/cut-extension';
 export { VegaRTEImageExtension } from './extensions/image/image-extension';
+export { VegaRTEWordCountExtension } from './extensions/word-count/word-count-extension';
 export { ModifyContentAction, ModifyContentActionType } from './dto/actions/modify-content-action.abstract';
 export { AppendChildrenAction } from './dto/actions/append-child-nodes-action';
 export { RemoveChildrenAction } from './dto/actions/remove-child-action';

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/text-style-annotation-handler.d.ts

@@ -20,7 +20,10 @@ export declare class TextStyleAnnotationHandler extends AnnotationGeneratorStrat
   handle(element: HTMLElement): VegaRTETextBlockAnnotations;
   /**
    * Get the node type of element. The element type is determined in the following
-   * order: "data-type" attribute, node name, font size and class name.
+   * order: "data-type" attribute, class name, node name, font size.
+   * Class name is checked before node name so that an explicit
+   * `v-rte--text-style-*` marker (e.g. applied by the Word paste transformer)
+   * takes precedence over the element's default tag-based role.
    *
    * @param {HTMLElement} element - element.
    * @returns {Nullable<VegaRTETextStyleType>} - node type.

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/continue-inline-to-rte-text-block-strategy.d.ts

@@ -40,6 +40,14 @@ export declare class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBloc
    * @returns {boolean} - Whether the element is an inline candidate.
    */
   private isInlineCandidate;
+  /**
+   * Check whether an element marks a block boundary.
+   *
+   * @param {HTMLElement} element - Element to inspect.
+   * @param {VegaRTETransformOptions} options - Transformation options.
+   * @returns {boolean} Whether the element is a boundary.
+   */
+  private isBlockBoundaryElement;
   /**
    * Returns true when the tag has a dedicated block strategy (excludes inline annotation tags CODE and A).
    *

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/value-controller.d.ts

@@ -1,6 +1,7 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaRichTextEditor } from '../../vega-rich-text-editor';
 import { VegaRTEContent } from '../../dto/content-state';
+import { RTEUpdateSource } from '../../constants/constant';
 /**
  * The value controller is responsible for updating the value of the rich text editor.
  */
@@ -12,8 +13,11 @@ export declare class ValueController extends VegaSlimmer {
   valueController: VegaRichTextEditor['valueController'];
   historyController: VegaRichTextEditor['historyController'];
   selectionController: VegaRichTextEditor['selectionController'];
+  wordCountController: VegaRichTextEditor['wordCountController'];
+  vegaRichTextEditorRenderer: VegaRichTextEditor['vegaRichTextEditorRenderer'];
   sourceEditConfig: VegaRichTextEditor['sourceEditConfig'];
   private flushChangeObserver;
+  private committedSnapshot;
   /**
    * Component lifecycle - [connectedCallback]{@link VegaRichTextEditor.connectedCallback}
    */
@@ -30,13 +34,19 @@ export declare class ValueController extends VegaSlimmer {
    * Watches the value of the editor and updates the internal value.
    */
   watchValueUpdate(): void;
+  /**
+   * Seeds the rollback snapshot from the current value while a commit interceptor is active.
+   * Runs on load and on extension changes so runtime re-registration stays protected.
+   */
+  seedCommittedSnapshot(): void;
   /**
    * Updates the value of the editor and restore the selection.
    *
    * @param {VegaRTEContent} newValue The new value to set.
    * @param {boolean} recordHistory - Whether to record the change in history.
+   * @param {RTEUpdateSource} updateSource - The source of the update, defaulting to 'default'.
    */
-  flushChanges(newValue: VegaRTEContent, recordHistory?: boolean): Promise<void>;
+  flushChanges(newValue: VegaRTEContent, recordHistory?: boolean, updateSource?: RTEUpdateSource): Promise<void>;
   /**
    * Determines whether the observer should accept changes.
    *

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/word-count-controller.d.ts

@@ -0,0 +1,40 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaRichTextEditor } from '../../vega-rich-text-editor';
+import { Nullable } from '../../../../types/general';
+import type { VegaRTEWordCountData } from '../../extensions/word-count/type';
+/**
+ * Bridges the word count extension to the editor component so the footer UI can
+ * read whether the character count should be shown and its current value.
+ */
+export declare class WordCountController extends VegaSlimmer {
+  protected extensions: VegaRichTextEditor['extensions'];
+  protected host: HTMLVegaRichTextEditorElement;
+  private cachedValue;
+  private cachedConfig;
+  private cachedData;
+  /**
+   * Whether the character count UI should be rendered.
+   *
+   * @returns {boolean} True when a word count extension requests the UI.
+   */
+  shouldShowUI(): boolean;
+  /**
+   * Compute the current character count data from the editor content.
+   *
+   * @returns {Nullable<VegaRTEWordCountData>} The count data or null when no word count extension is registered.
+   */
+  getData(): Nullable<VegaRTEWordCountData>;
+  /**
+   * Whether the word count extension gates commits with a hard character limit.
+   *
+   * @returns {boolean} True when a hard limit with a max character count is configured for this host.
+   */
+  hasWordCountHardLimit(): boolean;
+  /**
+   * Locate the word count extension by its runtime `type` discriminator.
+   * Use this way instead of instanceof to avoid direct dependency on the extension class.
+   *
+   * @returns {Nullable<VegaRTEWordCountExtension>} The word count extension or null.
+   */
+  private findWordCountExtension;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/link-toolbar-button-slimmer.d.ts

@@ -8,10 +8,24 @@ export declare class LinkToolbarButtonSlimmer extends VisualModeToolbarButtonSli
   private linkEditorRef;
   private currentSelectedText;
   private linkBtnWrapperRef;
+  private escapePressedDuringPopover;
+  private documentKeydownRegistered;
+  /**
+   * Component lifecycle - [disconnectedCallback]
+   *
+   * Removes the document-level Escape listener registered in the wrapper
+   * ref callback so the slimmer instance is not retained by document after
+   * the rich-text editor is destroyed.
+   */
+  disconnectedCallback(): void;
   constructor();
   protected renderBtnWrapper(renderBtn: (toolbarInternalButton?: ToolbarInternalButtonConfig) => HTMLElement): HTMLElement;
   protected isSelected(): boolean;
   protected isDisabled(): boolean;
   protected onClick(): void;
   private handleLinkEditorChange;
+  private handleWrapperClickCapture;
+  private handlePopoverShow;
+  private handleDocumentKeydown;
+  private handlePopoverHide;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/source-edit-toolbar-button-slimmer.d.ts

@@ -2,13 +2,16 @@ import { ToolbarButtonSlimmer } from './toolbar-button-slimmer.abstract';
 import { VegaRichTextEditor } from '../../../vega-rich-text-editor';
 export declare class SourceEditToolbarButtonSlimmer extends ToolbarButtonSlimmer {
   sourceView: VegaRichTextEditor['sourceView'];
-  selectionController: VegaRichTextEditor['selectionController'];
   valueController: VegaRichTextEditor['valueController'];
   richTextEditorSourceViewRenderer: VegaRichTextEditor['richTextEditorSourceViewRenderer'];
   sourceEditConfig: VegaRichTextEditor['sourceEditConfig'];
+  host: VegaRichTextEditor['host'];
   value: VegaRichTextEditor['value'];
   constructor();
   protected onClick(): Promise<void>;
+  protected preventLostFocus(): {
+    onMouseDown?: (e: Event) => void;
+  };
   protected isSelected(): boolean;
   protected isDisabled(): boolean;
   private saveSourceCode;

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/toolbar-button-slimmer.abstract.d.ts

@@ -13,8 +13,9 @@ export declare abstract class ToolbarButtonSlimmer extends VegaSlimmer {
   protected readonly disabled: VegaRichTextEditor['disabled'];
   private icon;
   private readonly tooltip;
+  private readonly ariaLabel;
   private readonly autoFocusOnClick;
-  protected constructor({ icon, tooltip, autoFocusOnClick }: ToolbarButtonConfig);
+  protected constructor({ icon, tooltip, ariaLabel, autoFocusOnClick }: ToolbarButtonConfig);
   setIcon(icon: string): void;
   /**
    * Whether the button is hidden or not.
@@ -41,7 +42,7 @@ export declare abstract class ToolbarButtonSlimmer extends VegaSlimmer {
    */
   protected isDisabled(): boolean;
   protected preventLostFocus(): {
-    onMouseDown: (e: Event) => void;
+    onMouseDown?: (e: Event) => void;
   };
   private renderBtn;
   /**

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

@@ -17,6 +17,7 @@ export declare class VegaRichTextEditorRenderer extends VegaSlimmer {
   sourceEditConfig: VegaRichTextEditor['sourceEditConfig'];
   allowSourceEdit: VegaRichTextEditor['allowSourceEdit'];
   extensions: VegaRichTextEditor['extensions'];
+  wordCountController: VegaRichTextEditor['wordCountController'];
   richTextEditorSourceViewRenderer: VegaRichTextEditor['richTextEditorSourceViewRenderer'];
   private richTextContainerRef;
   private richTextContentRef;
@@ -49,6 +50,17 @@ export declare class VegaRichTextEditorRenderer extends VegaSlimmer {
    * @returns {Nullable<HTMLDivElement>} The div element which has property contenteditable
    */
   getRTEEditableElementRef(): Nullable<HTMLDivElement>;
+  /**
+   * Re-injects the zero-width space placeholder into empty text spans.
+   * When a commit is rejected and the model rolls back unchanged, the framework
+   * short-circuits the text diff and leaves the span empty, collapsing the line
+   * height, so the placeholder is restored here.
+   */
+  restoreEmptyTextPlaceholders(): void;
+  /**
+   * Forces a re-render of the rich text content component, which is useful when the content has changed but the framework has not detected it.
+   */
+  forceContentRepaint(): void;
   render(): VegaRichTextEditor;
   private renderRichTextEditor;
   private renderLabel;

package/dist/types/components/vega-rich-text-editor/vega-rich-text-editor-toolbar-button/vega-rich-text-editor-toolbar-button.d.ts

@@ -5,6 +5,7 @@ import { EventEmitSlimmerBase } from '../../../helpers/event-manager/slimmers/ev
 import { VegaRichTextEditorToolbarButtonRenderer } from './slimmers/renderers/vega-rich-text-editor-toolbar-button-renderer';
 import { ChildNodesEventPreventSlimmer } from '../../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
 import { TextColorsTokenType } from '../../../types/design-token.type';
+import { AriaAttributesValueMapper } from '../../../helpers/slimmers/mutation-observer/aria-attributes-value-mapper';
 /**
 + * @vegaVersion 2.34.0
 + */
@@ -14,6 +15,7 @@ export declare class VegaRichTextEditorToolbarButton {
   protected clickEventEmitter: EventEmitSlimmerBase;
   protected eventPrevent: ChildNodesEventPreventSlimmer;
   protected readonly renderer: VegaRichTextEditorToolbarButtonRenderer;
+  protected ariaAttributesValueMapper: AriaAttributesValueMapper;
   host: HTMLVegaRichTextEditorToolbarButtonElement;
   /**
    * Specifies whether the rich text editor toolbar button element is disabled.

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

@@ -45,7 +45,9 @@ import { InternalCodeBlockSelectionController } from './slimmers/controllers/int
 import { SourceEditToolbarButtonSlimmer } from './slimmers/renderers/tools/source-edit-toolbar-button-slimmer';
 import { VegaRTEExtension } from './extensions/extension.abstract';
 import { RTEExtensionController } from './slimmers/controllers/extension-controller';
+import { WordCountController } from './slimmers/controllers/word-count-controller';
 import { VegaRichTextEditorSourceViewRenderer } from './slimmers/renderers/vega-rich-text-editor-source-view-renderer';
+import { AriaAttributesValueMapper } from '../../helpers/slimmers/mutation-observer/aria-attributes-value-mapper';
 /**
  * The rich text editor enables users to format text for a variety of publishers.
  *
@@ -53,6 +55,7 @@ import { VegaRichTextEditorSourceViewRenderer } from './slimmers/renderers/vega-
  */
 export declare class VegaRichTextEditor {
   protected readonly globalSlimmers: GlobalSlimmers;
+  protected ariaAttributesValueMapper: AriaAttributesValueMapper;
   protected translationSlimmer: TranslationSlimmer<HTMLVegaRichTextEditorElement>;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaRichTextEditorElement>;
   protected formFieldController: FormFieldControllerSlimmer<VegaRTEContentBlock[]>;
@@ -93,6 +96,7 @@ export declare class VegaRichTextEditor {
   protected readonly historyController: HistoryController;
   protected readonly internalCodeBlockSelectionController: InternalCodeBlockSelectionController;
   protected readonly rteExtensionController: RTEExtensionController;
+  protected readonly wordCountController: WordCountController;
   protected readonly sourceCodeChangeEventEmitter: EventEmitSlimmerBase;
   protected readonly richTextEditorSourceViewRenderer: VegaRichTextEditorSourceViewRenderer;
   host: HTMLVegaRichTextEditorElement;

package/dist/types/components/vega-rich-text-editor/vega-rich-text-link-editor/slimmers/controllers/link-editor-controller.d.ts

@@ -16,6 +16,22 @@ export declare class LinkEditorController extends VegaSlimmer {
   protected linkEditorStateManager: VegaRichTextLinkEditor['linkEditorStateManager'];
   private readonly linkUrlNormalizer;
   private readonly linkTypeHandlers;
+  /**
+   * The element the trigger click listener is currently attached to (the link
+   * wrapper acting as the popover target).
+   */
+  private triggerListenerEl;
+  /**
+   * Whether the popover was opened via a keyboard or screen-reader (VoiceOver)
+   * activation. When true, focus is moved into the popover so screen reader
+   * users land on the Edit button.
+   */
+  private isVoiceOverTrigger;
+  /**
+   * The element that had focus when the VoiceOver activation happened, so focus
+   * can be restored to the link once the popover is hidden.
+   */
+  private focusReturnEl;
   /** Initializes the popover target after the component loads. */
   componentDidLoad(): void;
   /** Notifies observers after each render cycle. */
@@ -88,6 +104,58 @@ export declare class LinkEditorController extends VegaSlimmer {
    * @returns {void} No return value.
    */
   private updatePopoverTarget;
+  /**
+   * Attaches a capture-phase click listener to the link wrapper (the popover
+   * target) so a keyboard/VoiceOver activation can be distinguished from a real
+   * pointer click before the popover opens. Re-attaches when the target changes.
+   *
+   * @returns {void} No return value.
+   */
+  private attachTriggerListener;
+  /**
+   * Removes the trigger listener from the previously observed element.
+   *
+   * @returns {void} No return value.
+   */
+  private detachTriggerListener;
+  /**
+   * Records whether the popover was opened via a keyboard/VoiceOver activation
+   * and, if so, the element to restore focus to when the popover closes.
+   *
+   * @param {MouseEvent} e - The click event on the link wrapper.
+   * @returns {void} No return value.
+   */
+  private readonly handleTriggerClick;
+  /**
+   * Determines whether a click on the link wrapper came from a keyboard or
+   * screen reader (VoiceOver) rather than a real pointer.
+   *
+   * A genuine pointer click lands inside the activated element. Keyboard (Enter,
+   * `detail === 0`) and VoiceOver activations dispatch a click with coordinates
+   * that are not on the element, so we treat any click whose point falls outside
+   * the wrapper as an assistive-technology activation.
+   *
+   * @param {MouseEvent} e - The click event on the link wrapper.
+   * @returns {boolean} True when the activation is keyboard/screen-reader driven.
+   */
+  private isKeyboardOrScreenReaderActivation;
+  /**
+   * Moves focus to the first focusable element within the popover content (the
+   * Edit button) so VoiceOver users land inside the opened toolbar.
+   *
+   * Deferred to the next macrotask so it runs after the editor has finished
+   * placing the caret/focus into the content area on the activating click.
+   *
+   * @returns {void} No return value.
+   */
+  private focusPopoverContentForVoiceOver;
+  /**
+   * Restores focus to the link wrapper after the popover is hidden following a
+   * VoiceOver activation.
+   *
+   * @returns {void} No return value.
+   */
+  private restoreFocusAfterVoiceOver;
   /**
    * Preserves an unchanged mailto URL when the form edits are equivalent.
    *

package/dist/types/components/vega-rich-text-editor/vega-rich-text-link-editor/slimmers/renderers/vega-rich-text-link-editor-renderer.d.ts

@@ -10,9 +10,11 @@ export declare class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
   protected linkEditorStateManager: VegaRichTextLinkEditor['linkEditorStateManager'];
   private formRef;
   private popoverRef;
+  private popoverContentRef;
   private urlInputRef;
   private textInputRef;
   getPopoverRef(): HTMLVegaPopoverElement;
+  getPopoverContentRef(): Nullable<HTMLElement>;
   getFormRef(): Nullable<HTMLVegaFormElement>;
   getUrlInputRef(): Nullable<HTMLVegaInputElement>;
   getTextInputRef(): Nullable<HTMLVegaInputElement>;
@@ -28,6 +30,7 @@ export declare class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
   private readonly handlePopoverRef;
   private readonly handleButtonGroupRef;
   private readonly handleFormRef;
+  private readonly handlePopoverContentRef;
   private readonly handleUrlInputRef;
   private readonly handleTextInputRef;
   private readonly handleLinkFieldKeyDown;

package/dist/types/components/vega-tab-group/slimmers/vega-tab-group/renderers/vega-tab-group-tab-list-renderer.d.ts

@@ -13,6 +13,7 @@ export declare class VegaTabGroupTabListRenderer extends VegaSlimmer {
   private closeButtonRenderer;
   private selectedTargetController;
   private voiceOverFocusController;
+  private translationSlimmer;
   /** The `getCarouselDomRef` method is a getter function that returns the reference to the `carouselDom`
   element. It is used to access the `carouselDom` element from outside the class. By returning the
   reference to the `carouselDom` element, other parts of the code can interact with the `carouselDom`

package/dist/types/components/vega-tab-group/types.d.ts

@@ -46,7 +46,9 @@ export type TabGroupVariant = 'primary' | 'secondary';
 /**
  * Props forwarded to a counter badge used in a tab group.
  */
-export type VegaTabGroupCounterBadgeProps = Partial<Pick<HTMLVegaCounterBadgeElement, 'color' | 'count'>>;
+export type VegaTabGroupCounterBadgeProps = Partial<
+	Pick<HTMLVegaCounterBadgeElement, 'color' | 'count' | 'dot'>
+>;
 
 /**
  * Overflow handling strategies for tab groups.