@globalpayments/vega 2.98.0 → 2.100.0

package/dist/types/components/vega-button/vega-button.d.ts

@@ -8,6 +8,7 @@ import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event
 import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 import { VegaButtonLoadingRenderer } from './slimmers/renderers/vega-button-loading-renderer';
+import { AriaAttributesValueMapper } from '../../helpers/slimmers/mutation-observer/aria-attributes-value-mapper';
 /**
  * Buttons are used for triggering actions.
  *
@@ -24,6 +25,7 @@ export declare class VegaButton {
   protected eventPrevent: ChildNodesEventPreventSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaButtonElement>;
   protected vegaButtonLoadingRenderer: VegaButtonLoadingRenderer;
+  protected ariaAttributesValueMapper: AriaAttributesValueMapper;
   host: HTMLVegaButtonElement;
   currentBreakpoint: BreakpointsTokenType;
   /**

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

@@ -46,25 +46,31 @@ export type ButtonItemsProps = {
 	/**
 	 * Icon name for the button.
 	 */
-	icon: string;
+	'icon': string;
 	/**
 	 * Label text for the button.
 	 */
-	label: string;
+	'label': string;
 	/**
 	 * Size of the button.
 	 */
-	size: VegaButtonGroupSize;
+	'size': VegaButtonGroupSize;
 	/**
 	 * Icon alignment within the button.
 	 */
-	iconAlign: VegaButtonGroupIconAlign;
+	'iconAlign': VegaButtonGroupIconAlign;
 	/**
 	 * Whether the button is disabled.
 	 */
-	disabled: boolean;
+	'disabled': boolean;
+	/**
+	 * Accessible name forwarded to the underlying button when the visible label
+	 * is suppressed (icon-only). Mapped to `aria-label` by the button's
+	 * `AriaAttributesValueMapper`.
+	 */
+	'data-aria-label'?: string;
 	/**
 	 * Ref callback for obtaining the element.
 	 */
-	ref: (node: HTMLElement) => void;
+	'ref': (node: HTMLElement) => void;
 };

package/dist/types/components/vega-calendar/vega-calendar-event-preview/slimmers/renderers/vega-calendar-event-preview-detail-renderer.d.ts

@@ -19,6 +19,8 @@ export declare class VegaCalendarEventPreviewDetailRenderer extends VegaSlimmer
   componentDidRender(): void;
   render(): HTMLElement;
   private renderActions;
+  private renderHeader;
+  private hasHeaderSlot;
   private renderBasicFields;
   private onHidePopover;
   private renderEventTitle;

package/dist/types/components/vega-dropdown/vega-dropdown-item/slimmers/renderers/vega-dropdown-item-renderer.d.ts

@@ -27,5 +27,6 @@ export declare class VegaDropdownItemRenderer extends VegaSlimmer {
   private renderCounter;
   private onSelect;
   private setLabelRef;
+  private getPlainTextLabel;
   private renderLabelWithTooltip;
 }

package/dist/types/components/vega-dropdown/vega-dropdown.d.ts

@@ -7,7 +7,7 @@ import { VegaDropdownCreateRenderer } from './slimmers/renderers/vega-dropdown-c
 import { VegaDropdownListRenderer } from './slimmers/renderers/vega-dropdown-list-renderer';
 import { VegaDropdownItemLevelRenderer } from './slimmers/renderers/vega-dropdown-item-level-renderer';
 import { VegaDropdownSearchRenderer } from './slimmers/renderers/vega-dropdown-search-renderer';
-import { VegaDropdownKeyboardController } from './slimmers/controllers/vega-dropdown-keyboard-conttroller';
+import { VegaDropdownKeyboardController } from './slimmers/controllers/vega-dropdown-keyboard-controller';
 import { VegaDropdownAppenderController } from './slimmers/controllers/vega-dropdown-appender-controller';
 import { VegaDropdownSearchTriggerEventDetail, VegaDropdownSearchTriggerByType, VegaDropdownSourceItem } from './types';
 import { VegaDropdownGroupLevelRenderer } from './slimmers/renderers/vega-dropdown-group-level-renderer';

package/dist/types/components/vega-field-label/slimmers/renderers/vega-field-label-label-announcement-renderer.d.ts

@@ -1,5 +1,4 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
-import { Nullable } from '../../../../types/general';
 export declare class VegaFieldLabelLabelAnnouncementRenderer extends VegaSlimmer {
   private label;
   private isFieldRequired;
@@ -7,15 +6,9 @@ export declare class VegaFieldLabelLabelAnnouncementRenderer extends VegaSlimmer
   private disabled;
   private translationSlimmer;
   /**
-   * Render a label announcement.
+   * Build the visually-hidden state suffix (the part after the label text).
    *
-   * @returns {Nullable<HTMLElement>}
+   * @returns {string} e.g. ", Required, Disabled", or '' when there is no state to announce.
    */
-  render(): Nullable<HTMLElement>;
-  /**
-   * Generate a screen-reader-friendly announcement string that concatenates the label text with the field's required/optional and disabled states.
-   *
-   * @returns {string} The generated announcement string.
-   */
-  private generateAnnouncement;
+  getStateSuffix(): string;
 }

package/dist/types/components/vega-input-select/slimmers/renderers/vega-input-select-dropdown-renderer.d.ts

@@ -30,6 +30,14 @@ export declare class VegaInputSelectDropdownRenderer extends VegaSlimmer {
   render(): HTMLVegaDropdownElement;
   private renderItemsSlot;
   private renderContainer;
+  /**
+   * VD-9605: open/close the dropdown on both Enter and Space, matching native button
+   * semantics. Space is preventDefaulted so activating the trigger does not scroll the page.
+   *
+   * @param {KeyboardEvent} e - keydown event on the select trigger.
+   * @returns {void}
+   */
+  private handleTriggerKeyDown;
   private renderPrefixIcon;
   private renderToggleIcon;
   private renderSelectContainer;

package/dist/types/components/vega-modal/slimmers/controllers/vega-modal-open-state-controller.d.ts

@@ -21,6 +21,23 @@ export declare class VegaModalOpenStateController extends VegaSlimmer {
   protected readonly ariaDialogFocusableTrapSlimmer: AriaDialogFocusableTrapSlimmer;
   private backdropMouseDownOnHost;
   private backdropMouseUpOnHost;
+  /**
+   * Component lifecycle - [connectedCallback]
+   *
+   * Capture-phase Escape listener is registered here (rather than
+   * `componentDidLoad`) so it is re-added whenever the modal element is moved
+   * in the DOM (e.g. RTE's Insert-via-URL modal is moved to `host.parentElement`
+   * before being shown — that triggers disconnect+connect but does not re-fire
+   * `componentDidLoad`).
+   *
+   * Capture-phase Escape listener so ancestor focus-trap containers (e.g. a
+   * Bootstrap modal whose own keydown handler is attached to the modal
+   * element) do not also react to the same Escape press while a vega-modal
+   * is open inside them. Capture phase fires before any descendant bubble
+   * listener; calling `stopPropagation` then prevents those listeners from
+   * running. We only intervene when this is the topmost open vega-modal.
+   */
+  connectedCallback(): void;
   /**
    * Component lifecycle - [disconnectedCallback]
    */
@@ -95,6 +112,22 @@ export declare class VegaModalOpenStateController extends VegaSlimmer {
    * @param {VegaModalOpenStateChangeTrigger} triggerBy - Source that initiated the change.
    */
   changeOpenState(isOpen: boolean, triggerBy: VegaModalOpenStateChangeTrigger): void;
+  /**
+   * Capture-phase document `keydown` listener for Escape. When this modal is
+   * the topmost open vega-modal we close it and stop propagation so that
+   * ancestor focus traps (e.g. a Bootstrap modal which closes itself on
+   * Escape via its own keydown listener attached to the modal element) do
+   * not also react to the same key press and close themselves.
+   *
+   * If an inner overlay (vega-dropdown / vega-popover) already handled this
+   * Escape press, it calls `markOverlayHandledEscape(event)` from its own
+   * capture-phase listener. `isOverlayHandledEscape` detects this so this
+   * modal does not also close — meaning Escape closes only the innermost
+   * overlay.
+   *
+   * @param {KeyboardEvent} event - The keydown event.
+   */
+  private handleEscapeCapture;
   /**
    * Manages the visibility and behavior of a modal by updating various properties
    * and emitting an event.

package/dist/types/components/vega-modal/types.d.ts

@@ -28,4 +28,5 @@ export type VegaModalOpenStateChangeTrigger =
 	| 'method' // The public modal('hide/show') method triggers to close or show modal by user.
 	| 'property' // The `open` property is changed by user.
 	| 'data-target' // The target element clicked has a `data-target='modal'` attribute and open the modal.
-	| 'data-dismiss'; // The target element clicked has a `data-dismiss='modal'` attribute and close the modal.
+	| 'data-dismiss' // The target element clicked has a `data-dismiss='modal'` attribute and close the modal.
+	| 'escape'; // User presses the Escape key while this modal is the topmost open vega-modal.

package/dist/types/components/vega-popover/slimmers/renderers/vega-popover-appender-renderer.d.ts

@@ -16,6 +16,15 @@ export declare class VegaPopoverAppenderRenderer extends VegaSlimmer {
    * @returns {HTMLVegaPopoverContentBoxElement} An HTMLVegaPopoverContentBoxElement is being returned.
    */
   getPopoverContentBox(): HTMLVegaPopoverContentBoxElement;
+  /**
+   * Whether an inner overlay (e.g. an open `vega-input-select`/`vega-dropdown`
+   * or a nested popover) is currently displayed inside this popover's content
+   * box. Such overlays own the Escape key, so the popover must not close while
+   * one of them is open.
+   *
+   * @returns {boolean} True when a visible nested overlay content box exists.
+   */
+  hasOpenNestedOverlay(): boolean;
   /**
    * The `render` function returns a JSX element for a `vega-popover-content-box` component with a ref assigned to `this.popoverContentBox`.
    *

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

@@ -2,6 +2,11 @@ import { VegaRTEColorSchema, VegaRTETextStyleItem, VegaRTEToolbarItem } from '..
 export declare const RTE_DEFAULT_TEXT_COLOR: VegaRTEColorSchema;
 export declare const RTE_TEXT_COLORS: VegaRTEColorSchema[];
 export declare const ZERO_WIDTH_SPACE: string;
+export declare enum RTEUpdateSource {
+  Default = "default",
+  Composition = "composition"
+}
+export declare const RTE_UPDATE_SOURCE_KEY: string;
 export declare const VegaRTEDefaultTextStyleItems: VegaRTETextStyleItem[];
 export declare const VegaRTEPresetToolbarItems: VegaRTEToolbarItem[][];
 /**
@@ -17,3 +22,20 @@ export declare const VegaRTEOneRowHeightPx: number;
 export declare const RTE_DEFAULT_LINK_TYPE_KEY: string;
 export declare const RTE_EMAIL_LINK_TYPE_KEY: string;
 export declare const RTE_SUPPORTED_LINK_TYPE_KEYS: string[];
+/**
+ * Semantic marker used by renderers to identify elements that terminate
+ * continue-inline grouping during HTML -> DTO conversion.
+ */
+export declare const RTE_BLOCK_BOUNDARY_ATTRIBUTE: string;
+/**
+ * Custom DataTransfer MIME type used to tag a synthetic paste with the chosen
+ * paste mode (e.g. 'rich' or 'plain'), so downstream paste handling can decide
+ * whether to preserve the original inline styles.
+ */
+export declare const RTE_PASTE_MODE_DATA_TYPE: string;
+/**
+ * Custom DataTransfer MIME type value used to indicate that the paste content
+ * originated from Microsoft Word.
+ */
+export declare const RTE_PASTE_MODE_WORD: string;
+export declare const RTE_WORD_COUNT_KEY: string;

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/commit-value-strategy.d.ts

@@ -0,0 +1,13 @@
+import { CommitValueAction } from '../../actions/commit-value-action';
+import type { VegaRTEContent } from '../../content-state';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Default commit strategy — the candidate becomes the committed value. Rejection
+ * is handled exclusively by interceptors that veto the commit by not executing.
+ */
+export declare class CommitValueStrategy extends ActionHandleStrategy<CommitValueAction, VegaRTEContent, VegaRTEContent> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: CommitValueAction): VegaRTEContent;
+}

package/dist/types/components/vega-rich-text-editor/dto/actions/commit-value-action.d.ts

@@ -0,0 +1,20 @@
+import { Nullable } from '../../../../types/general';
+import type { VegaRTEContent } from '../content-state';
+import { ModifyContentAction } from './modify-content-action.abstract';
+/**
+ * Action type discriminator. Plain string constant — intentionally NOT added to
+ * {@link ModifyContentActionType} enum to keep the commit-validation flow self-contained.
+ */
+export declare const COMMIT_VALUE: string;
+/**
+ * Dispatched before the editor commits a candidate value. The default strategy
+ * commits the candidate as-is; interceptors are the only place a commit is vetoed.
+ */
+export declare class CommitValueAction extends ModifyContentAction {
+  readonly candidate: VegaRTEContent;
+  readonly previous: Nullable<VegaRTEContent>;
+  readonly host: HTMLVegaRichTextEditorElement;
+  isFlushable: boolean;
+  type: string;
+  constructor(candidate: VegaRTEContent, previous: Nullable<VegaRTEContent>, host: HTMLVegaRichTextEditorElement);
+}

package/dist/types/components/vega-rich-text-editor/dto/annotations/text-style-default-styles.d.ts

@@ -1,3 +1,4 @@
 import { AnnotationStyle, VegaRTETextStyleType } from '../../interface';
+export declare const TEXT_STYLE_DEFAULT_FONT_WEIGHT: string;
 export declare const TEXT_STYLE_VALUES: VegaRTETextStyleType[];
 export declare const TEXT_STYLE_DEFAULTS: Record<VegaRTETextStyleType, AnnotationStyle>;

package/dist/types/components/vega-rich-text-editor/dto/blocks/block.abstract.d.ts

@@ -89,12 +89,27 @@ export declare abstract class RTEBlock<P = RTEBlockParentType, C = RTEBlockChild
    * @param {AnnotationAction} action - Annotation action
    */
   apply(action: AnnotationAction | ModifyContentAction): void;
+  /**
+   * Whether caret nearest-element detection may descend into this block's children.
+   * Transparent wrappers (e.g. html-block) return true so the caret resolves to the
+   * real inner node; atomic widgets like the table block return false so the caret
+   * stays anchored to the block boundary.
+   *
+   * @returns {boolean} True when descending is allowed.
+   */
+  allowsCaretDescend(): boolean;
   /**
    * Get the first node of the block
    *
    * @returns {Nullable<RTENode>} The first RTENode or null if no children exist.
    */
   getFirstNode(): Nullable<RTENode>;
+  /**
+   * Get the plain text content of the block, used for character counting.
+   *
+   * @returns {string} The concatenated plain text of all child nodes and blocks.
+   */
+  getPlainText(): string;
   /**
    * Check if the block is a list item block
    *

package/dist/types/components/vega-rich-text-editor/dto/blocks/list-item-block.d.ts

@@ -45,6 +45,10 @@ export declare class RTEListItemBlock extends RTETextBlock {
    * @inheritDoc
    */
   getLastNode(): RTETextNode;
+  /**
+   * @inheritDoc
+   */
+  getPlainText(): string;
   /**
    * Create a new list item block.
    *

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

@@ -83,6 +83,12 @@ export declare class VegaRTEContent {
    * @returns {Nullable<RTENode>} The last node in the content or null if there are no nodes.
    */
   getLastNode(): Nullable<RTENode>;
+  /**
+   * Get the plain text content of the whole document, used for character counting.
+   *
+   * @returns {string} The concatenated plain text of all top-level blocks.
+   */
+  getPlainText(): string;
   /**
    * Convert text to list.
    *

package/dist/types/components/vega-rich-text-editor/dto/filter-styles-strategies/filter-styles-strategy-registry.d.ts

@@ -35,6 +35,7 @@ export declare class RTEFilterStylesStrategyRegistry {
    * @param {RTEFilterStyles} styles - The full set of styles to filter.
    * @param {string[]} classNames - The class names to consider.
    * @returns {RTEFilterInlineStylesResult} The result of filtering, including the remaining styles and class names.
+   * The instance is also passed to matched strategies so they can make decisions from DTO annotations.
    */
   static executeTheStrategyFilterAction(blockOrNodeInstance: RTEBlock | RTENode, styles: RTEFilterStyles, classNames: string[]): RTEFilterInlineStylesResult;
   /**

package/dist/types/components/vega-rich-text-editor/dto/filter-styles-strategies/filter-styles-strategy.abstract.d.ts

@@ -38,13 +38,14 @@ export declare abstract class RTEFilterStylesStrategy {
    */
   filterAnnotations(annotations: VegaRTEAnnotations): VegaRTEAnnotations;
   /**
-   * Filters and deletes the matched styles from the full styles object, add the corresponding class name if necessary, and returns the result.
+   * Filters and deletes matched styles from the full styles object, adds the corresponding class name if necessary, and returns the result.
    *
    * @param {RTEFilterStyles} fullStyles - The full set of styles to filter.
    * @param {string[]} classNames - The class names to consider.
+   * @param {RTEBlock | RTENode} [_blockOrNodeInstance] - The block or node the styles belong to. It is optional for strategies that only need styles and class names.
    * @returns {RTEFilterInlineStylesResult} The filtered styles and class names.
    */
-  filterAndDeleteStyles(fullStyles: Nullable<RTEFilterStyles>, classNames: Nullable<string[]>): RTEFilterInlineStylesResult;
+  filterAndDeleteStyles(fullStyles: Nullable<RTEFilterStyles>, classNames: Nullable<string[]>, _blockOrNodeInstance?: RTEBlock | RTENode): RTEFilterInlineStylesResult;
   /**
    * Refills the external styles for a given HTML element based on a matched external style rule.
    *

package/dist/types/components/vega-rich-text-editor/dto/filter-styles-strategies/text-node/title-heading-node-filter-styles-strategy.d.ts

@@ -1,13 +1,21 @@
-import { VegaRTEAnnotations } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+import { RTEFilterInlineStylesResult, VegaRTEAnnotations } from '../../../interface';
 import type { RTEBlock } from '../../blocks/block.abstract';
 import type { RTENode } from '../../nodes/node.abstract';
 import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
 /**
- * The TitleHeadingNodeFilterStylesStrategy is responsible for filtering styles from text nodes that are children of title and heading blocks.
- * In title and heading blocks, the text nodes will have a default bold style.
+ * Filters the default bold style from text nodes inside title and heading blocks.
+ * The source DTO distinguishes an explicitly non-bold node (`bold: false`) from
+ * a node with no bold annotation, even though both initially produce no weight in `fullStyles`.
+ *
+ * Bold nodes keep the existing strip/refill behaviour. Default nodes without a bold annotation
+ * remain bare for compatibility, while explicitly non-bold nodes receive the base weight so
+ * source-mode refill does not restore bold (VD-9375).
  */
 export declare class TitleHeadingNodeFilterStylesStrategy extends RTEFilterStylesStrategy {
   static BOLD_STYLES: RTEFilterStyles;
+  /** Base weight used to preserve an explicitly non-bold title or heading node. */
+  static NON_BOLD_FONT_WEIGHT: string;
   static NON_HEADING_TITLE_ELEMENT_TAGS: string[];
   protected stylesToBeFiltered: RTEFilterStyles;
   protected elementTagName: string;
@@ -20,6 +28,12 @@ export declare class TitleHeadingNodeFilterStylesStrategy extends RTEFilterStyle
    * @inheritDoc
    */
   filterAnnotations(annotations: VegaRTEAnnotations): VegaRTEAnnotations;
+  /**
+   * Removes the default bold weight and preserves an explicit non-bold marker when needed.
+   *
+   * @inheritDoc
+   */
+  filterAndDeleteStyles(fullStyles: Nullable<RTEFilterStyles>, classNames: Nullable<string[]>, blockOrNodeInstance?: RTEBlock | RTENode): RTEFilterInlineStylesResult;
   /**
    * Determines whether the dto instance is text node and its parent block is a heading or title.
    *
@@ -39,6 +53,14 @@ export declare class TitleHeadingNodeFilterStylesStrategy extends RTEFilterStyle
    * @inheritDoc
    */
   toCssText(): string;
+  /**
+   * Checks the annotation rather than `fullStyles`, because both an explicit `bold: false` node and
+   * a node without a bold annotation produce no font weight before this strategy runs.
+   *
+   * @param {RTEBlock | RTENode} [blockOrNodeInstance] - The block or node the styles belong to.
+   * @returns {boolean} True when the node has a `bold: false` annotation.
+   */
+  private isExplicitlyNonBold;
   /**
    * Checks if the parent block of the given node instance is a heading or title.
    *

package/dist/types/components/vega-rich-text-editor/dto/nodes/code-block-node.d.ts

@@ -32,6 +32,10 @@ export declare class RTECodeBlockNode extends RTEDecoratorNode<RTECodeBlock> {
    * @returns {VegaRTECodeNode} - An object contains content property.
    */
   toJSON(): VegaRTECodeNode;
+  /**
+   * @inheritDoc
+   */
+  getPlainText(): string;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/dto/nodes/node.abstract.d.ts

@@ -90,6 +90,12 @@ export declare abstract class RTENode<P extends RTEBlock = RTEBlock> {
    * @returns {boolean} - True if the node is a text node, false otherwise.
    */
   isTextNode(): this is RTETextNode;
+  /**
+   * Get the plain text content of the node, used for character counting. Default implementation returns an empty string, subclasses should override this method to provide the actual plain text content.
+   *
+   * @returns {string} The plain text content of the node.
+   */
+  getPlainText(): string;
   /**
    * Get the HTMLElement reference associated with this node.
    *

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

@@ -103,6 +103,10 @@ export declare class RTETextNode extends RTENode<RTETextBlock> {
    * @inheritDoc
    */
   isContentEditable(): boolean;
+  /**
+   * @inheritDoc
+   */
+  getPlainText(): string;
   /**
    * Returns the inline HTML wrapper descriptor at the given depth in the
    * annotation chain. Depth 0 is the outermost wrapper, depth 1 is its child, etc.

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/block-text-nodes-renderer.abstract.d.ts

@@ -39,4 +39,11 @@ export declare abstract class RTEBlockTextNodesRenderer extends RTEBlockRenderer
    * @returns {HTMLElement | VNode} The rendered node.
    */
   private renderNodeFromDepth;
+  /**
+   * Resolves the registered renderer for the given node's type.
+   *
+   * @param {RTETextNode} node - The node whose renderer is needed.
+   * @returns {VegaRTEBaseRenderer<RTENode, VNode>} The node renderer.
+   */
+  private getNodeRenderer;
 }

package/dist/types/components/vega-rich-text-editor/dto/renderers/nodes/text-node-renderer.d.ts

@@ -1,3 +1,4 @@
+import { VNode } from '../../../../../stencil-public-runtime';
 import { RTENodeRenderer } from './node-renderer.abstract';
 import { RTETextNode } from '../../nodes/text-node';
 import { Nullable } from '../../../../../types/general';
@@ -13,6 +14,16 @@ declare class RTETextNodeRenderer extends RTENodeRenderer {
    * @returns {HTMLElement} The rendered element.
    */
   renderFromAnnotation(node: RTETextNode, annotation: Nullable<InlineHtmlAnnotation>): HTMLElement;
+  /**
+   * Wrap an already-rendered inner element with the given inline HTML annotation chain.
+   * Lets non-text nodes (e.g. tokens) keep their own markup while still being nested
+   * inside a shared inline HTML wrapper emitted by the grouped node renderer.
+   *
+   * @param {HTMLElement} inner - The already-rendered inner element to wrap.
+   * @param {InlineHtmlAnnotation} annotation - The inline HTML annotation chain to apply.
+   * @returns {HTMLElement} The wrapped element.
+   */
+  wrapWithInlineHtml(inner: HTMLElement | VNode, annotation: InlineHtmlAnnotation): HTMLElement;
   render(node: RTETextNode): HTMLElement;
   private renderWithWrapper;
   private renderText;

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

@@ -114,6 +114,11 @@ export declare abstract class VegaRTEToolbarButtonRenderer {
    * @param {MouseEvent} e The mouse event to prevent default action for.
    */
   protected preventDefault(e: MouseEvent): void;
+  /**
+   * Moves focus to the toolbar button. Targets the inner focusable `<button>`
+   * inside the button's shadow root, falling back to the host element.
+   */
+  protected focusToolbarButton(): void;
   /**
    * Recursively searches for a dropdown list item by its key.
    *

package/dist/types/components/vega-rich-text-editor/extensions/block-boundary-registry.d.ts

@@ -0,0 +1,21 @@
+export declare type BlockBoundaryPredicate = (element: HTMLElement) => boolean;
+/**
+ * Per-editor registry for block-boundary predicates contributed by extensions.
+ */
+export declare class BlockBoundaryRegistry {
+  private predicates;
+  /**
+   * Register a block-boundary predicate.
+   *
+   * @param {BlockBoundaryPredicate} predicate - Predicate to register.
+   * @returns {() => void} Unregister callback.
+   */
+  register(predicate: BlockBoundaryPredicate): () => void;
+  /**
+   * Returns true when any registered predicate marks the element as a boundary.
+   *
+   * @param {HTMLElement} element - Element to inspect.
+   * @returns {boolean} Whether the element is a boundary.
+   */
+  isBoundary(element: HTMLElement): boolean;
+}

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

@@ -15,6 +15,7 @@ import { AnnotationAction } from '../dto/actions/annotation-action.abstract';
 import { RTEFilterStylesStrategy } from '../dto/filter-styles-strategies/filter-styles-strategy.abstract';
 import type { VegaRTEBlockBase, VegaRTETransformOptions } from '../interface';
 import { RTEExtensionStateStore } from './rte-extension-state-store';
+import type { BlockBoundaryPredicate } from './block-boundary-registry';
 declare type BlockClassWithFrom = ClassType<RTEBlock> & {
   from(block: VegaRTEBlockBase, options?: VegaRTETransformOptions): RTEBlock;
 };
@@ -178,5 +179,19 @@ export declare abstract class VegaRTEExtension {
    * @param {AnnotationGeneratorStrategyAbstract} handler - The annotation handler to register.
    */
   protected registerAnnotationHandler(handler: AnnotationGeneratorStrategyAbstract): void;
+  /**
+   * Register an extension-defined block-boundary predicate for the current editor instance.
+   *
+   * @param {BlockBoundaryPredicate} predicate - Predicate to register.
+   * @returns {Nullable<() => void>} Unregister callback when context is available.
+   */
+  protected registerBlockBoundaryPredicate(predicate: BlockBoundaryPredicate): Nullable<() => void>;
+  /**
+   * Get the registered dto by dom element.
+   *
+   * @param {HTMLElement} el - The DOM element to get the registered DTO for.
+   * @returns {Nullable<RTENode | RTEBlock>} - The registered DTO associated with the DOM element.
+   */
+  protected getDTOEntityByDom(el: HTMLElement): Nullable<RTENode | RTEBlock>;
 }
 export {};

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/renderers/find-replace-toolbar-button-renderer.d.ts

@@ -61,4 +61,23 @@ export declare class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButt
    * Closes the panel popover.
    */
   private closePanel;
+  /**
+   * 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.
+   */
+  private shouldRestoreFocusToButton;
+  /**
+   * 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.
+   */
+  private isElementWithinPanel;
 }

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

@@ -0,0 +1,4 @@
+export declare const FUNCTION_BLOCK_CLASS: string;
+export declare const FUNCTION_CONTENT_CLASS: string;
+export declare const FUNCTION_SYNTAX_CLASS: string;
+export declare const FUNCTION_ELEMENT_CLASSES: string[];

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

@@ -42,6 +42,13 @@ export declare class RTEFunctionBlock extends RTEBlock<VegaRTEContent | RTEHtmlB
    * @inheritDoc
    */
   getLastNode(): RTENode;
+  /**
+   * The function block is an atomic caret boundary: descending would resolve the caret onto a
+   * `contenteditable="false"` logic-control node instead of staying anchored to the block.
+   *
+   * @inheritDoc
+   */
+  allowsCaretDescend(): boolean;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/extensions/functions/dto/logic-control-node.d.ts

@@ -47,4 +47,8 @@ export declare class RTELogicControlNode extends RTENode {
    * @returns {boolean} - The content editable state of the node.
    */
   isContentEditable(): boolean;
+  /**
+   * @inheritDoc
+   */
+  getPlainText(): string;
 }

package/dist/types/components/vega-rich-text-editor/extensions/functions/element-to-dto-strategies/div-containing-function-block-strategy.d.ts

@@ -0,0 +1,8 @@
+import { HtmlBlockStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/html-block-strategy';
+/** Preserve a div that contains a function block during auto-formatting. */
+export declare class FunctionBlockContainerStrategy extends HtmlBlockStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/function-extension.d.ts

@@ -1,12 +1,18 @@
 import { VegaRTEExtension } from '../extension.abstract';
+import { RTEExtensionContext } from '../../interface';
 /**
  * Function extension class for Vega Rich Text Editor.
  */
 export declare class VegaRTEFunctionExtension extends VegaRTEExtension {
   static readonly TOOLBAR_BUTTON_KEY: string;
+  private unregisterBlockBoundaryPredicate;
   constructor();
   /** @inheritDoc */
   prepareBeforeLoad(host: HTMLVegaRichTextEditorElement): void;
+  /** @inheritDoc */
+  initialExtensionAfterLoad(context: RTEExtensionContext): void;
+  /** @inheritDoc */
+  destroyExtension(): void;
   /**
    * Remove the appen children strategies to prevent default insert new paragraph logic in function block
    */