@globalpayments/vega 2.91.0 → 2.92.0

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/helper/find-replace-highlight-manager.d.ts

@@ -0,0 +1,88 @@
+import type { FindMatch } from './find-replace-state';
+/**
+ * Manages highlights for the Find & Replace extension using a DOM overlay.
+ *
+ * Instead of modifying the RTE content tree (which causes re-renders, cursor
+ * jumping, and VegaChange events), this manager renders semi-transparent
+ * highlight rectangles in an absolutely-positioned overlay container.
+ *
+ * The overlay lives inside `.rich-text-editor-container` (the RTE's scroll
+ * container) so highlight divs scroll naturally with the text content.
+ * `pointer-events: none` ensures highlights don't interfere with user
+ * interaction (selection, typing, clicking).
+ *
+ * Position computation uses `Range.getClientRects()` on the actual text DOM
+ * nodes (resolved via `stateEntityRenderingRegistry.getDOMByEntity`).
+ */
+export declare class FindReplaceHighlightManager {
+  private overlayContainer;
+  constructor();
+  /**
+   * Renders highlight overlays for all matches, with the active match
+   * visually distinct. Clears any existing highlights before applying.
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The type of the host rich text editor element.
+   * @param {ReadonlyArray<FindMatch>} matches - All search results.
+   * @param {number} currentIndex - 0-based index of the active match (-1 = none).
+   * @param {HTMLVegaRichTextEditorElement} host - The RTE host element.
+   * @param {boolean} scrollToActive - Whether to scroll the active highlight into view.
+   */
+  apply(matches: ReadonlyArray<FindMatch>, currentIndex: number, host: HTMLVegaRichTextEditorElement, scrollToActive?: boolean): void;
+  /**
+   * Removes all highlight overlay elements.
+   * Safe to call multiple times or when no highlights are active.
+   */
+  clear(): void;
+  /**
+   * Gets the existing overlay container or creates one inside the RTE's
+   * scroll container (`.rich-text-editor-container`).
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The type of the host rich text editor element.
+   * @param {HTMLVegaRichTextEditorElement} host - The RTE host element.
+   * @returns {HTMLDivElement | null} The overlay container, or null in SSR environments.
+   */
+  private getOrCreateOverlay;
+  /**
+   * Creates absolutely-positioned highlight rectangles for a single node
+   * position within a match.
+   *
+   * Uses client rectangle extraction from `Range` to handle multi-line matches (where a
+   * single text range may produce multiple rectangles due to line wrapping).
+   *
+   * @param {HTMLDivElement} overlay - The overlay container.
+   * @param {DOMRect} overlayRect - The overlay's bounding client rect (for coordinate conversion).
+   * @param {NodePosition} nodePosition - The node and character offsets for this segment.
+   * @param {string} bg - The background color to apply.
+   * @returns {Nullable<HTMLDivElement>} The first created highlight div for this node segment.
+   */
+  private createHighlightRectangles;
+  /**
+   * Builds a DOM Range for the given node position.
+   *
+   * For standard text nodes (RTETextNode rendered as `<span>`), the first
+   * child is a Text node and offsets apply directly.
+   *
+   * For code block nodes (`<vega-code-block>` with shadow DOM), we traverse
+   * the shadow root's `<code>` element child spans to locate the correct
+   * text positions by accumulated character offset.
+   *
+   * @param {HTMLElement} domElement - The registered DOM element for the node.
+   * @param {NodePosition} nodePosition - The character offsets within the node.
+   * @returns {Nullable<Range>} A Range if successfully built, or null on failure.
+   */
+  private buildRange;
+  /**
+   * Builds a Range inside a `<vega-code-block>` shadow DOM element.
+   *
+   * `<vega-code-block>` renders its content inside a shadow root with a `<code>`
+   * element containing multiple child `<span>` nodes (one per syntax token).
+   * This method walks all Text nodes within that `<code>` element, accumulating
+   * character length until the positions corresponding to startOffset / endOffset
+   * are found.
+   *
+   * @param {HTMLElement} domElement - The `<vega-code-block>` host element.
+   * @param {NodePosition} nodePosition - The character offsets within the node.
+   * @returns {Range | null} A Range if successfully built, or null on failure.
+   */
+  private buildCodeBlockRange;
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/helper/find-replace-state.d.ts

@@ -0,0 +1,200 @@
+import { RTETextBlock } from '../../../../../dto/blocks/text-block';
+import { RTECodeBlock } from '../../../../../dto/blocks/code-block';
+import type { VegaRTEContent } from '../../../../../dto/content-state';
+import type { RTETextNode } from '../../../../../dto/nodes/text-node';
+import type { RTECodeBlockNode } from '../../../../../dto/nodes/code-block-node';
+/**
+ * The position of a match within a specific node, expressed as node-local offsets.
+ */
+export declare type NodePosition = {
+  node: RTETextNode | RTECodeBlockNode;
+  startOffset: number;
+  endOffset: number;
+};
+/**
+ * A single find result representing one regex match within a document block.
+ */
+export declare type FindMatch = {
+  /** The block containing the match. */
+  block: RTETextBlock | RTECodeBlock;
+  /** Ordered list of node-level positions that together compose this match. */
+  nodes: NodePosition[];
+  /** The matched text string as it appears in the document. */
+  matchText: string;
+};
+/**
+ * Options controlling the search behavior.
+ */
+export declare type FindOptions = {
+  /** When true, the search is case-sensitive. Defaults to false. */
+  matchCase?: boolean;
+  /** When true, only whole-word occurrences are matched. Defaults to false. */
+  wholeWords?: boolean;
+};
+/**
+ * Manages the in-memory state for a single Find & Replace session.
+ *
+ * One instance is created per editor host inside VegaRTEFindReplaceExtension
+ * during `initialExtensionAfterLoad`. It holds all search results, the
+ * current navigation index, and a per-block flat-text cache.
+ *
+ * Public API:
+ * - `search(content, keyword)` — run a search, replace current state using current options
+ * - `next()` / `prev()` — navigate through results
+ * - `getCurrentMatch()` / `getMatches()` / `getTotal()` / `getCurrentIndex()` — read state
+ * - `clear()` — reset everything
+ */
+export declare class FindReplaceState {
+  private matches;
+  private currentIndex;
+  private flatCache;
+  private cachedContent;
+  private matchCase;
+  private wholeWords;
+  /**
+   * Ordered strategy chain used to classify and traverse each block type.
+   * More specific types (RTEListItemBlock) must precede their parent class (RTETextBlock).
+   */
+  private readonly blockSearchStrategies;
+  /**
+   * Runs a fresh search over the given content and replaces all previous results.
+   *
+   * The flat-text cache is invalidated whenever the content reference changes
+   * (i.e. after the user edits the document). When only the keyword or options
+   * change (user typing in the find input), the cache is reused.
+   *
+   * @param {VegaRTEContent} content - The root content DTO to search.
+   * @param {string} keyword - The search keyword entered by the user.
+   * Uses the currently stored `matchCase` and `wholeWords` options.
+   */
+  search(content: VegaRTEContent, keyword: string): void;
+  /**
+   * Advances to the next match, wrapping around to the first.
+   */
+  next(): void;
+  /**
+   * Moves to the previous match, wrapping around to the last.
+   */
+  prev(): void;
+  /**
+   * Sets the current index directly. Clamps to valid range.
+   *
+   * @param {number} index - The desired index.
+   */
+  setCurrentIndex(index: number): void;
+  /**
+   * Returns the currently active match, or null if there are no results.
+   *
+   * @returns {FindMatch | null} The currently active match, or null if there are no results.
+   */
+  getCurrentMatch(): FindMatch | null;
+  /**
+   * Returns all matches from the last search.
+   *
+   * @returns {ReadonlyArray<FindMatch>} All matches from the last search.
+   */
+  getMatches(): ReadonlyArray<FindMatch>;
+  /**
+   * Returns the total number of matches from the last search.
+   *
+   * @returns {number} The total number of matches.
+   */
+  getTotal(): number;
+  /**
+   * Returns the 0-based index of the current match, or -1 when there are no results.
+   *
+   * @returns {number} The 0-based index, or -1 when there are no results.
+   */
+  getCurrentIndex(): number;
+  /**
+   * Resets only match results and navigation index.
+   * The flat-text cache and cached content reference are preserved so that
+   * a subsequent search on the same document (e.g. after a keyword change)
+   * can reuse the already-computed block flat texts.
+   */
+  clearResults(): void;
+  /**
+   * Resets all search state, including results, navigation index, and flat-text cache.
+   * Use this when the session ends (e.g. panel closed) or the host changes.
+   */
+  clear(): void;
+  /**
+   * Sets the matchCase search option.
+   *
+   * @param {boolean} enabled - Whether to enable case-sensitive matching.
+   */
+  setMatchCase(enabled: boolean): void;
+  /**
+   * Sets the wholeWords search option.
+   *
+   * @param {boolean} enabled - Whether to enable whole-word matching.
+   */
+  setWholeWords(enabled: boolean): void;
+  /**
+   * Invalidates the flat-text cache when the content reference has changed.
+   * Since flushChanges always produces a new VegaRTEContent via clone(), a
+   * changed reference reliably indicates the document has been edited.
+   *
+   * @param {VegaRTEContent} content - The incoming content reference.
+   */
+  private invalidateCacheIfNeeded;
+  /**
+   * Builds a RegExp from the keyword and search options.
+   *
+   * @param {string} keyword - The raw user input.
+   * @param {FindOptions} options - Search options.
+   * @returns {RegExp} The compiled regular expression.
+   */
+  private buildRegExp;
+  /**
+   * Escapes all regex special characters so the keyword is treated as literal text.
+   *
+   * @param {string} text - The raw input string.
+   * @returns {string} The escaped string safe for use in a RegExp constructor.
+   */
+  private escapeRegExp;
+  /**
+   * Recursively collects all searchable leaf blocks (RTETextBlock and RTECodeBlock)
+   * from a block tree in document order.
+   *
+   * Each block is dispatched to the first matching BlockSearchStrategy.
+   *
+   * @param {RTEBlock[]} blocks - The block array to traverse.
+   * @returns {(RTETextBlock | RTECodeBlock)[]} Ordered list of searchable leaf blocks.
+   */
+  private collectSearchableBlocks;
+  /**
+   * Builds the flat text and segment table for a RTETextBlock.
+   *
+   * Non-editable child nodes (e.g. tokens, which render as read-only chips)
+   * are excluded from the searchable flat text. Each is replaced by a single
+   * sentinel character so that adjacent editable segments cannot bridge across
+   * the token to form a false match, while keeping segment offsets aligned.
+   *
+   * @param {RTETextBlock} block - The text block to flatten.
+   * @returns {BlockFlatCache} The flat text string and segment mapping.
+   */
+  private buildTextBlockFlat;
+  /**
+   * Builds the flat text and segment table for a RTECodeBlock.
+   *
+   * @param {RTECodeBlock} block - The code block to flatten.
+   * @returns {BlockFlatCache} The flat text string and segment mapping.
+   */
+  private buildCodeBlockFlat;
+  /**
+   * Maps a flat [matchStart, matchEnd) range back to individual node positions.
+   *
+   * @param {(TextSegment | CodeSegment)[]} segments - The segment table.
+   * @param {number} matchStart - Inclusive start in the flat text.
+   * @param {number} matchEnd - Exclusive end in the flat text.
+   * @returns {NodePosition[]} Ordered list of node-local positions spanning the match.
+   */
+  private flatOffsetToNodePositions;
+  /**
+   * Builds the current find options from the shared context.
+   *
+   * @returns {FindOptions} The options for the search engine.
+   */
+  private getFindOptions;
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/replace-controller.d.ts

@@ -0,0 +1,73 @@
+import { FindReplaceControllerAbstract, FindReplaceControllerContext } from './find-replace-controller.abstract';
+import type { FindReplaceResult } from './find-replace-controller.abstract';
+import { VegaRTEContent } from '../../../../../../types/components.type';
+/**
+ * Replace controller — adds mutation capabilities on top of the shared
+ * find state.
+ *
+ * Shares state with {@link FindController} via the injected
+ * {@link FindReplaceControllerContext}, so both controllers always operate
+ * on the same search results and highlight overlays.
+ */
+export declare class ReplaceController extends FindReplaceControllerAbstract {
+  /** The replacement string used by replace() and replaceAll(). Updated via setReplacement(). */
+  private replacement;
+  private flushFn;
+  constructor(context: FindReplaceControllerContext);
+  /**
+   * Stores the flush callback used to commit content changes to the editor.
+   * Called by the toolbar renderer after obtaining it from the extension context.
+   *
+   * Calling `flushValue` once — even after mutating multiple nodes — creates a
+   * single entry in the editor's undo stack, so the entire replace/replaceAll
+   * operation is undone as one atomic step.
+   *
+   * @param {(value: VegaRTEContent) => void} fn - The flush function.
+   * @returns {void} No return value.
+   */
+  setFlushValue(fn: (value: VegaRTEContent) => void): void;
+  /**
+   * Stores the replacement text for the next replace() or replaceAll() call.
+   *
+   * @param {string} text - The replacement string.
+   * @returns {void} No return value.
+   */
+  setReplacement(text: string): void;
+  /**
+   * Replaces the current match with the stored replacement text,
+   * advances to the next match, and refreshes highlights.
+   * An empty replacement string deletes the matched text.
+   *
+   * No-op when there is no current match or no host.
+   *
+   * @returns {FindReplaceResult} Updated match position and total.
+   */
+  replace(): FindReplaceResult;
+  /**
+   * Replaces all matches with the stored replacement text in a single operation
+   * (one flushValue call = one Undo step), then re-runs the search.
+   * An empty replacement string deletes all matched text.
+   *
+   * No-op when there are no matches or no host.
+   *
+   * @returns {FindReplaceResult} Updated match position and total.
+   */
+  replaceAll(): FindReplaceResult;
+  /**
+   * Directly mutates the matched nodes in the live content tree.
+   * `position.node` is already a reference into `this.context.hostRef.value`,
+   * so no cloning or path navigation is needed.
+   *
+   * For multi-node (cross-span) matches the first node receives the replacement
+   * text and every subsequent node has its matched slice deleted.
+   *
+   * This method mutates the content tree in place. The caller is
+   * responsible for calling `state.clear()` afterwards to invalidate the
+   * flat-text cache, which uses reference equality and will not detect the
+   * in-place change automatically.
+   *
+   * @param {FindMatch} match - The match to replace.
+   * @returns {void} No return value.
+   */
+  private applyMatchReplacement;
+}

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

@@ -0,0 +1,64 @@
+import { VegaRTECreateElementFunction, VegaRTEToolbarRenderContext, VegaRTERenderResult } from '../../../../interface';
+import { VegaRTEToolbarButtonRenderer } from '../../../base-toolbar-button-renderer';
+/**
+ * Toolbar button renderer for the Find & Replace extension.
+ *
+ * Responsible only for UI concerns:
+ * - Renders the toolbar button wrapped in a vega-popover.
+ * - Wires panel events to the {@link FindController} and {@link ReplaceController}.
+ * - Pushes controller results back to the panel display.
+ *
+ * Both controllers share a single {@link FindReplaceControllerContext} so they
+ * operate on the same search state and highlight overlays.
+ */
+export declare class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  private readonly sharedContext;
+  private readonly findController;
+  private readonly replaceController;
+  private panelRef;
+  private popoverRef;
+  private isPopoverOpen;
+  private scrollOnNextRefresh;
+  private readonly debouncedRefresh;
+  private readonly panelActionHandlers;
+  /**
+   * @inheritDoc
+   */
+  render(h: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * Toggles the popover open/close when the toolbar button is clicked.
+   */
+  protected handleButtonClick(): void;
+  /**
+   * Not used — this button has no dropdown.
+   */
+  protected handleDropdownClick(): void;
+  /**
+   * Synchronizes internal state with the editor context on each render cycle.
+   * Registers the host reference and content-change listener, and hides the
+   * popover if the toolbar item becomes hidden while open.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context.
+   */
+  private syncEditorState;
+  /**
+   * Dispatches panel button actions to the controller.
+   *
+   * @param {FindReplacePanelAction} panelAction - The structured action emitted by the panel.
+   */
+  private handlePanelAction;
+  /**
+   * Pushes result to the panel counter display.
+   *
+   * @param {FindReplaceResult} result - The current/total values.
+   */
+  private updatePanel;
+  /**
+   * Content changed — ask the controller to refresh search results.
+   */
+  private onContentChanged;
+  /**
+   * Closes the panel popover.
+   */
+  private closePanel;
+}

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

@@ -0,0 +1,28 @@
+import { VegaSlimmer } from '../../../../../../../vega-slimmer/vega-slimmer-core';
+import type { VegaRichTextFindReplacePanel } from '../../vega-rich-text-find-replace-panel';
+export declare type FindReplacePanelAction = {
+  action: string;
+  data?: unknown;
+};
+/**
+ * Renderer slimmer for the Find & Replace panel.
+ * Renders a search input, a "current/total" counter, and prev/next/close icon buttons.
+ */
+export declare class FindReplacePanelRenderer extends VegaSlimmer {
+  changeEventEmitter: VegaRichTextFindReplacePanel['changeEventEmitter'];
+  clickEventEmitter: VegaRichTextFindReplacePanel['clickEventEmitter'];
+  currentIndex: VegaRichTextFindReplacePanel['currentIndex'];
+  total: VegaRichTextFindReplacePanel['total'];
+  matchCase: VegaRichTextFindReplacePanel['matchCase'];
+  wholeWords: VegaRichTextFindReplacePanel['wholeWords'];
+  render(): HTMLElement;
+  private renderHeader;
+  private renderNavButton;
+  private renderSearchOptionToggle;
+  private renderFindButton;
+  private renderActionButtons;
+  private onKeywordChange;
+  private onReplacementChange;
+  private onToggleSearchOption;
+  private emitAction;
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/vega-rich-text-find-replace-panel/vega-rich-text-find-replace-panel.d.ts

@@ -0,0 +1,56 @@
+import { EventEmitter } from '../../../../../stencil-public-runtime';
+import { GlobalSlimmers } from '../../../../../vega-slimmer/vega-slimmer-core';
+import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../../../helpers/slimmers/component-usage-runtime-metrics';
+import { EventEmitSlimmerBase } from '../../../../../helpers/event-manager/slimmers/event-emit-slimmer';
+import { FindReplacePanelRenderer } from './slimmers/renderers/find-replace-panel-renderer';
+/**
+ * Internal panel component for the Find & Replace extension.
+ * Renders a search input, match counter, and prev/next/close buttons.
+ *
+ * - Emits `vegaChange` (payload: { type, value }) when find/replace inputs change.
+ * - Emits `vegaClick` (payload: `{ action: string; data?: unknown }`) when a button is clicked.
+ * - Exposes `updateResult(currentIndex, total)` for the toolbar renderer to push match counts back.
+ *
+ * @vegaVersion 2.92.0
+ */
+export declare class VegaRichTextFindReplacePanel {
+  protected readonly globalSlimmers: GlobalSlimmers;
+  protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaRichTextFindReplacePanelElement>;
+  protected changeEventEmitter: EventEmitSlimmerBase;
+  protected clickEventEmitter: EventEmitSlimmerBase;
+  protected readonly renderer: FindReplacePanelRenderer;
+  host: HTMLVegaRichTextFindReplacePanelElement;
+  currentIndex: number;
+  total: number;
+  matchCase: boolean;
+  wholeWords: boolean;
+  /**
+   * Emitted when a panel input value changes.
+   * Payload includes the input type (`keyword` or `replace`) and value.
+   *
+   * @vegaVersion 2.92.0
+   */
+  vegaChange: EventEmitter<{
+    type: 'keyword' | 'replace';
+    value: string;
+  }>;
+  /**
+   * Emitted when a panel action button is clicked.
+   * Payload includes the action key and optional data.
+   *
+   * @vegaVersion 2.92.0
+   */
+  vegaClick: EventEmitter<{
+    action: string;
+    data?: unknown;
+  }>;
+  /**
+   * Updates the displayed match counter. Called by the toolbar renderer after each search or navigation.
+   *
+   * @param {number} currentIndex - 1-based index of the active match (0 when there are no matches).
+   * @param {number} total - Total number of matches.
+   * @vegaVersion 2.92.0
+   */
+  updateResult(currentIndex: number, total: number): Promise<void>;
+  render(): VegaRichTextFindReplacePanel;
+}

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

@@ -3,6 +3,7 @@ import { VegaRTEExtension } from '../extension.abstract';
  * Function extension class for Vega Rich Text Editor.
  */
 export declare class VegaRTEFunctionExtension extends VegaRTEExtension {
+  static readonly TOOLBAR_BUTTON_KEY: string;
   constructor();
   /** @inheritDoc */
   prepareBeforeLoad(host: HTMLVegaRichTextEditorElement): void;

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

@@ -3,6 +3,7 @@ import { VegaRTEExtension } from '../extension.abstract';
  * Extension that adds horizontal line (`<hr>`) support to the Vega Rich Text Editor.
  */
 export declare class VegaRTEHorizontalLineExtension extends VegaRTEExtension {
+  static readonly TOOLBAR_BUTTON_KEY: string;
   private blockRenderer;
   private toolbarButtonRenderer;
   constructor();

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

@@ -5,6 +5,7 @@ import { VegaRTEExtension } from '../extension.abstract';
  * This extension allows users to switch between different languages and maintain separate content for each language.
  */
 export declare class VegaRTELanguageExtension extends VegaRTEExtension {
+  static readonly TOOLBAR_BUTTON_KEY: string;
   private languageToolbarButtonRenderer;
   private readonly languageList;
   private languageState;

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

@@ -6,6 +6,7 @@ import { VegaRTEExtension } from '../extension.abstract';
  */
 export declare class VegaRTELineHeightExtension extends VegaRTEExtension {
   private readonly options;
+  static readonly TOOLBAR_BUTTON_KEY: string;
   private toolbarButtonRenderer;
   constructor(options?: VegaRTELineHeightOption[]);
   /**

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

@@ -6,6 +6,7 @@ import { VegaRTESpecialCharactersConfig } from './types';
  * for insertion into the editor content as plain text.
  */
 export declare class VegaRTESpecialCharactersExtension extends VegaRTEExtension {
+  static readonly TOOLBAR_BUTTON_KEY: string;
   private categories;
   constructor(config?: VegaRTESpecialCharactersConfig);
   /** @inheritDoc */

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

@@ -11,6 +11,7 @@ export declare type RTETableExtensionContext = RTEExtensionContext & {
  * Function extension class for Vega Rich Text Editor.
  */
 export declare class VegaRTETableExtension extends VegaRTEExtension {
+  static readonly TOOLBAR_BUTTON_KEY: string;
   private toolbarButtonRenderer;
   private tableBlockRenderer;
   private tableRowBlockRenderer;

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

@@ -4,6 +4,7 @@ import { VegaRTEExtension } from '../extension.abstract';
  * Vega Rich Text Editor Token Extension
  */
 export declare class VegaRTETokenExtension extends VegaRTEExtension {
+  static readonly TOOLBAR_BUTTON_KEY: string;
   private tokenRenderer;
   private readonly tokenList;
   constructor(tokenList?: (RTEDropdownListItem | RTEDropdownListGroup)[]);

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

@@ -18,9 +18,12 @@ export { VegaRTEFunctionExtension } from './extensions/functions/function-extens
 export { VegaRTETableExtension } from './extensions/table/table-extension';
 export { VegaRTEHorizontalLineExtension } from './extensions/horizontal-line/horizontal-line-extension';
 export { VegaRTESpecialCharactersExtension } from './extensions/special-characters/special-characters-extension';
+export { VegaRTEFindReplaceExtension } from './extensions/find-replace/find-replace-extension';
 export { VegaRTESpecialCharactersEssentials, VegaRTESpecialCharactersLatin, VegaRTESpecialCharactersMathematical, VegaRTESpecialCharactersArrows, VegaRTESpecialCharactersCurrency, VegaRTESpecialCharactersText, } from './extensions/special-characters/constants/default-categories';
 export { VegaRTELineHeightExtension } from './extensions/line-height/line-height-extension';
 export { VegaRTELinkExtension } from './extensions/link/link-extension';
+export { VegaRTECopyExtension } from './extensions/copy/copy-extension';
+export { VegaRTECutExtension } from './extensions/cut/cut-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';
@@ -29,6 +32,7 @@ export { InsertChildrenBeforeAction } from './dto/actions/insert-children-before
 export { InsertNodeToNearestRootAction } from './dto/actions/insert-node-to-nearest-root-action';
 export { UpdateCursorPositionAction } from './dto/actions/update-cursor-position-action';
 export { InsertNewParagraphAction } from './dto/actions/insert-new-paragraph-action';
+export { DeleteSelectedContentAction } from './dto/actions/delete-selected-content-action';
 export { CustomAttributeAnnotation } from './dto/annotations/custom-attribute-annotation';
 export { CustomClassAnnotation } from './dto/annotations/custom-class-annotation';
 export { CustomStyleAnnotation } from './dto/annotations/custom-style-annotation';

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/abstract-delete-content-handler.d.ts

@@ -0,0 +1,60 @@
+import { RTEBlock } from '../../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../../dto/nodes/node.abstract';
+import { Nullable } from '../../../../../../types/general';
+import { BaseHandler } from './base-handler';
+/** The resulting caret position after shifting one step to the right for forward deletion. */
+export interface ForwardDeletePosition {
+  node: RTENode;
+  offset: number;
+}
+/**
+ * Hosts the deletion logic shared by the forward and backward delete handlers. Subclasses implement
+ * the single-block deletion behaviour for their specific direction. User press backspace or delete
+ * will trigger one of those subclasses.
+ */
+export declare abstract class AbstractDeleteContentHandler extends BaseHandler {
+  /**
+   * Delete the selected node(s) from the current state.
+   */
+  handleEvent(): void;
+  /**
+   * Computes the caret position one step to the right, used to translate a forward delete into a backspace.
+   *
+   * @param {Nullable<RTENode>} node - The node the caret is currently in.
+   * @param {number} offset - The current caret offset within the node.
+   * @returns {Nullable<ForwardDeletePosition>} The shifted position, or null when the caret is at the end of the content.
+   */
+  protected getForwardDeletePosition(node: Nullable<RTENode>, offset: number): Nullable<ForwardDeletePosition>;
+  /**
+   * Returns the next node relative to the given node, crossing block boundaries when needed.
+   *
+   * @param {RTENode} node - The current node.
+   * @returns {Nullable<RTENode>} The next node, or null when the given node is the last node of the content.
+   */
+  protected getNextNode(node: RTENode): Nullable<RTENode>;
+  /**
+   * Returns the next block relative to the given block, ascending out of nested list structures when needed.
+   *
+   * @param {RTEBlock} block - The current block.
+   * @returns {Nullable<RTEBlock>} The next block, or null when the given block is the last block of the content.
+   */
+  protected getNextBlock(block: RTEBlock): Nullable<RTEBlock>;
+  /**
+   * Deletes the content within multiple nodes selected by the user.
+   */
+  protected deleteContentWithMultipleNodes(): void;
+  /**
+   * If the first block is not paragraph, convert the block to paragraph after delete all text
+   *
+   * @param {RTEBlock} block - The first block instance
+   */
+  protected convertFirstBlockToParagraph(block: RTEBlock): void;
+  /**
+   * Creates a new paragraph element with a text node and appends it to the current state.
+   */
+  protected insertDefaultParagraph(): void;
+  /**
+   * Handles a single-block deletion of content within an RTE editor for the handler's direction.
+   */
+  protected abstract deleteContentWithSingleBlock(): void;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/backward-delete-content-handler.d.ts

@@ -0,0 +1,8 @@
+import { AbstractDeleteContentHandler } from './abstract-delete-content-handler';
+/** Handles a backspace (leftward) deletion of content within a VegaRTE editor. User press backspace will trigger this method */
+export declare class BackwardDeleteContentHandler extends AbstractDeleteContentHandler {
+  /**
+   * Handles a backspace (leftward) deletion of content within a single block in an RTE editor.
+   */
+  protected deleteContentWithSingleBlock(): void;
+}