@globalpayments/vega 2.92.0 → 2.94.0

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

@@ -0,0 +1,27 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { VegaRTEImageExtensionConfig } from './type';
+import { RTEExtensionStateStore } from '../rte-extension-state-store';
+/**
+ * Rich Text Editor extension that configures built-in image behavior.
+ */
+export declare class VegaRTEImageExtension extends VegaRTEExtension {
+  private readonly config;
+  /**
+   * Per-host config store. Declare as static readonly to isolate config per editor host.
+   *
+   * @type {RTEExtensionStateStore<VegaRTEImageExtensionConfig>}
+   */
+  static readonly configStore: RTEExtensionStateStore<VegaRTEImageExtensionConfig>;
+  constructor(config?: VegaRTEImageExtensionConfig);
+  /**
+   * Store config per host so both toolbar-image and inline-image editors
+   * can consistently read the extension settings.
+   *
+   * @param {HTMLElement} host - The host rich text editor element.
+   */
+  prepareBeforeLoad(host: HTMLVegaRichTextEditorElement): void;
+  /**
+   * Remove config for the current host when the extension is destroyed.
+   */
+  destroyExtension(): void;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Configurable options for the image extension.
+ */
+export declare type VegaRTEImageExtensionConfig = {
+  /**
+   * Whether to enable image upload functionality in the rich text editor.
+   */
+  enableImageUpload?: boolean;
+  /**
+   * Whether to enable image insertion via URL in the rich text editor.
+   */
+  enableImageURLInsertion?: boolean;
+};

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

@@ -0,0 +1,3 @@
+import { IconPayload } from '../../../../../helpers/icon/interface';
+declare const _default: IconPayload;
+export default _default;

package/dist/types/components/vega-rich-text-editor/extensions/paste/paste-chooser-ui.d.ts

@@ -0,0 +1,58 @@
+export declare type PasteMode = 'rich';
+export declare type PasteChooserPosition = {
+  left: number;
+  top: number;
+  placement: ['bottom', 'top'] | ['top', 'bottom'];
+};
+export declare type PasteChooserCallbacks = {
+  onModeSelect: (mode: PasteMode) => void;
+};
+/**
+ * Renders and manages the paste format chooser UI.
+ */
+export declare class RTEPasteChooserUI {
+  private readonly hostRoot;
+  private readonly callbacks;
+  static readonly CHOOSER_ATTR: string;
+  static readonly CHOOSER_RICH_ATTR: string;
+  static readonly CHOOSER_TRIGGER_ATTR: string;
+  private chooserEl;
+  private dropdownEl;
+  private triggerButtonEl;
+  constructor(hostRoot: ShadowRoot, callbacks: PasteChooserCallbacks);
+  /**
+   * Opens the paste-mode chooser at the given position.
+   *
+   * @param {PasteChooserPosition} position Viewport position for the chooser.
+   */
+  open(position: PasteChooserPosition): void;
+  /**
+   * Removes the chooser from the DOM.
+   */
+  destroy(): void;
+  /**
+   * Determines whether the given event path targets the chooser.
+   *
+   * @param {EventTarget[]} eventPath Composed path of an event.
+   * @returns {boolean} `true` when the path includes the chooser.
+   */
+  includesEventPath(eventPath: EventTarget[]): boolean;
+  /**
+   * Builds the dropdown element with the rich text paste option.
+   *
+   * @param {Document} doc Document used to create elements.
+   * @param {['bottom', 'top'] | ['top', 'bottom']} placement Preferred placement order.
+   * @returns {HTMLElement} Configured dropdown element.
+   */
+  private createPasteChooserDropdown;
+  /**
+   * Creates a single dropdown item element for a paste mode.
+   *
+   * @param {Document} doc Document used to create the element.
+   * @param {PasteMode} key Paste mode key for the item.
+   * @param {string} label Display label for the item.
+   * @param {string} dataAttrName Data attribute marker for the item.
+   * @returns {HTMLVegaDropdownItemElement} Configured dropdown item element.
+   */
+  private createDropdownItem;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * 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;

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

@@ -0,0 +1,150 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { RTEExtensionContext } from '../../interface';
+/**
+ * Vega Rich Text Editor paste extension.
+ * Intercepts keyboard paste and allows users to choose paste mode.
+ */
+export declare class VegaRTEPasteExtension extends VegaRTEExtension {
+  private hostEl;
+  private editableEl;
+  private contentHostEl;
+  private chooserUI;
+  private pendingPastePayload;
+  private listenerDocument;
+  private listenerWindow;
+  /** @inheritDoc */
+  initialExtensionAfterLoad(context: RTEExtensionContext): void;
+  /** @inheritDoc */
+  destroyExtension(): void;
+  /**
+   * Handles a native paste event by capturing the clipboard payload and
+   * rendering the paste-mode chooser.
+   *
+   * @param {ClipboardEvent} event Native clipboard paste event.
+   */
+  private readonly handlePasteEvent;
+  /**
+   * Dismisses the chooser when a pointer interaction occurs outside of it.
+   *
+   * @param {Event} event Pointer event captured on the document.
+   */
+  private readonly handleOutsidePointerDown;
+  /**
+   * Dismisses the chooser when the Escape key is pressed.
+   *
+   * @param {KeyboardEvent} event Keyboard event captured on the document.
+   */
+  private readonly handleOutsideKeyDown;
+  /**
+   * Dismisses the chooser when any relevant scroll container scrolls.
+   */
+  private readonly handleOutsideScroll;
+  /**
+   * Attaches the paste listener to the editable element.
+   */
+  private attachPasteListener;
+  /**
+   * Detaches the paste listener from the editable element.
+   */
+  private detachPasteListener;
+  /**
+   * Resolves the content host and editable element from the host shadow tree.
+   *
+   * @returns {EditorElements} Editor elements.
+   */
+  private getEditorElements;
+  /**
+   * Resolves the editable content element from the host shadow tree.
+   *
+   * @returns {HTMLDivElement | null} Editable element or `null` when unavailable.
+   */
+  private getEditableElement;
+  /**
+   * Clones the current selection range so it can be restored after the user
+   * chooses a paste mode.
+   *
+   * @returns {Range | null} Cloned range or `null` when there is no selection.
+   */
+  private cloneCurrentSelectionRange;
+  /**
+   * Renders the paste-mode chooser and wires up dismissal listeners.
+   *
+   * @param {ClipboardEvent} pasteEvent Originating paste event used for positioning.
+   */
+  private renderPasteChooser;
+  /**
+   * Computes the on-screen position for the chooser based on pointer or caret.
+   *
+   * @param {ClipboardEvent} event Originating paste event.
+   * @returns {ChooserPosition} Position in viewport coordinates.
+   */
+  private computeChooserPosition;
+  /**
+   * Resolves the bounding rect of the pending caret position.
+   *
+   * @returns {DOMRect | null} Caret rect or `null` when it cannot be determined.
+   */
+  private getCaretRect;
+  /**
+   * Returns whether the browser could not resolve a meaningful caret rectangle.
+   *
+   * @param {DOMRect} rect Candidate caret rect.
+   * @returns {boolean} Whether the rect is unusable.
+   */
+  private isUnavailableRect;
+  /**
+   * Falls back to the range container or neighbor child node bounds.
+   *
+   * @param {Range} range Caret/selection range.
+   * @returns {DOMRect | null} Best-effort caret anchor rectangle.
+   */
+  private getRangeContainerRect;
+  /**
+   * Returns an element-backed rectangle from a DOM node.
+   *
+   * @param {Node | null} node Candidate node.
+   * @returns {DOMRect | null} Node rectangle when resolvable.
+   */
+  private getNodeRect;
+  /**
+   * Applies the chosen paste mode by dispatching a synthetic paste input event.
+   *
+   * @param {PasteMode} mode Selected paste mode.
+   */
+  private applyPasteMode;
+  /**
+   * Restores SelectionController state from the captured selection so synthetic
+   * beforeinput paste can replace the selected content instead of appending.
+   *
+   * @param {PendingPastePayload} payload Pending paste payload.
+   */
+  private restoreSelectionControllerState;
+  /**
+   * Restores a previously cloned selection range.
+   *
+   * @param {Range | null} range Range to restore.
+   */
+  private restoreSelectionRange;
+  /**
+   * Dispatches a synthetic `beforeinput` paste event into the editor pipeline.
+   *
+   * @param {HTMLDivElement} editableEl Editable content element.
+   * @param {DataTransfer} dataTransfer Clipboard payload for the paste.
+   */
+  private dispatchBeforeInputPaste;
+  /**
+   * Builds a `DataTransfer` payload carrying the paste content and mode marker.
+   *
+   * @param {string} html HTML clipboard content.
+   * @param {string} text Plain text clipboard content.
+   * @param {PasteMode} [mode] Selected paste mode marker.
+   * @returns {DataTransfer} Populated data transfer payload.
+   */
+  private createDataTransfer;
+  /**
+   * Tears down the chooser UI and removes dismissal listeners.
+   *
+   * @param {boolean} [clearPayload] Whether to also clear the pending payload.
+   */
+  private clearPasteChooser;
+}

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

@@ -2,7 +2,33 @@ import { AnnotationStyle } from '../interface';
 /**
  * Creates a style map from the inline styles of an HTML element. This function extracts the 'style' attribute from the given element.
  *
+ * Manually parses the style string to handle complex CSS values that contain semicolons (e.g., data URLs),
+ * colons (e.g., https:// URLs), or commas (e.g., rgba, gradients). This approach avoids reliance on
+ * CSSStyleDeclaration's array-like behavior, which is inconsistent in Jest/JSDOM test environments.
+ *
  * @param {HTMLElement} element The HTML element from which to extract inline styles.
  * @returns {AnnotationStyle} An object representing the custom style annotations.
  */
 export declare function createStyleMapFromElement(element: HTMLElement): AnnotationStyle;
+/**
+ * Split a CSS style string by semicolons, but only those outside of parentheses.
+ * This ensures that semicolons inside url() or other functions are not treated as property separators.
+ *
+ * @param {string} styleAttr The style attribute string to split.
+ * @returns {string[]} Array of individual CSS property strings.
+ */
+export declare function splitStyleProperties(styleAttr: string): string[];
+/**
+ * Escape HTML-sensitive characters so text can be rendered literally in HTML.
+ *
+ * @param {string} text - Raw text content.
+ * @returns {string} Escaped text content.
+ */
+export declare function escapeHtml(text: string): string;
+/**
+ * Escape text for use inside a double-quoted HTML attribute value.
+ *
+ * @param {string} value - Raw attribute value.
+ * @returns {string} Escaped attribute-safe value.
+ */
+export declare function escapeHtmlAttribute(value: string): string;

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

@@ -481,6 +481,7 @@ export type VegaRTEToolbarItem =
 	| 'codeBlock'
 	| 'undo'
 	| 'redo'
+	| 'fullscreen'
 	| string; // Custom toolbar item types can be added here
 
 /**
@@ -795,6 +796,21 @@ export type RTEExtensionContext = {
 	 * @param {boolean} autoFocusLastNode - Whether to auto-focus the last node after flushing.
 	 */
 	flushValue: (value: VegaRTEContent, autoFocusLastNode?: boolean) => void;
+
+	/**
+	 * Triggers an immediate re-render of the host component without requiring
+	 * a reactive state change. Delegates to Stencil's `forceUpdate` internally.
+	 *
+	 * Common use cases in extensions:
+	 * - After toggling internal extension state (e.g. fullscreen active/inactive)
+	 *   that affects toolbar button appearance (icon, tooltip, selected state)
+	 *   but is not tracked by Stencil's reactive @State or @Prop.
+	 * - After imperative DOM manipulation that should be reflected in the
+	 *   next render cycle (e.g. injecting/removing style tags).
+	 *
+	 * @param {HTMLElement} ref - The host element to schedule a re-render for.
+	 */
+	forceUpdate: (ref: HTMLElement) => void;
 };
 
 /**
@@ -868,6 +884,10 @@ export type RTEToolbarDropdownProps = {
 	 * Dropdown source items.
 	 */
 	source?: (RTEDropdownListItem | RTEDropdownListGroup)[];
+	/**
+	 * Whether to position dropdown relative to the viewport.
+	 */
+	isScreenPosition?: boolean;
 	/**
 	 * Selection mode for the dropdown.
 	 */

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

@@ -17,13 +17,18 @@ export { VegaRTELanguageExtension } from './extensions/languages/language-extens
 export { VegaRTEFunctionExtension } from './extensions/functions/function-extension';
 export { VegaRTETableExtension } from './extensions/table/table-extension';
 export { VegaRTEHorizontalLineExtension } from './extensions/horizontal-line/horizontal-line-extension';
+export { VegaRTEBlockquoteExtension } from './extensions/blockquote/blockquote-extension';
+export { RTEBlockquoteBlock } from './extensions/blockquote/dto/rte-blockquote-block';
 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 { VegaRTEFullscreenExtension } from './extensions/fullscreen/fullscreen-extension';
+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 { 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/input-event-handler/insert-paste-handler.d.ts

@@ -9,6 +9,31 @@ export declare class InsertPasteHandler extends BaseHandler {
    * @param {InputEvent} event - Paste event.
    */
   handleEvent(event: InputEvent): void;
+  /**
+   * Inserts plain-text paste content into the current text node at caret position.
+   *
+   * @param {RTEPastePayload} payload - Clipboard payload.
+   * @param {RTERange} currentRange - Current selection range.
+   * @returns {boolean} True when inline insertion is handled.
+   */
+  private insertPlainTextInline;
+  /**
+   * Determines whether the payload should be inserted as inline plain text.
+   *
+   * @param {RTEPastePayload} payload - Clipboard payload.
+   * @param {RTERange} currentRange - Current selection range.
+   * @param {RTENode[]} selectedNodes - Currently selected nodes.
+   * @returns {boolean} True when inline plain-text insertion should be used.
+   */
+  private shouldPasteAsInlinePlainText;
+  /**
+   * Analyzes HTML content to extract plain text and detect inline formatting,
+   * parsing the HTML once to avoid redundant StylePreservation and DOMParser calls.
+   *
+   * @param {string} html - Clipboard text/html payload.
+   * @returns {HtmlAnalysisResult} Analysis result with plainText and hasFormatting properties.
+   */
+  private analyzeHtmlContent;
   /**
    * Insert the blocks to root
    *
@@ -16,15 +41,17 @@ export declare class InsertPasteHandler extends BaseHandler {
    */
   private insertBlocksToRoot;
   /**
-   * Insert the blocks to content
+   * Insert the blocks into the current content block at the specified range.
    *
    * @param { RTEContentBlock[]} blocks - blocks
+   * @param { RTERange } rteRange - rteRange
    */
   private insertBlocksToContent;
   /**
    * Insert the blocks before to current block
    *
    * @param { RTEContentBlock[]} blocks - blocks
+   * @param { RTERange } rteRange - rteRange
    */
   private insertBlocksBeforeEmptyBlock;
   /**
@@ -35,9 +62,24 @@ export declare class InsertPasteHandler extends BaseHandler {
    */
   private parsePastedElements;
   /**
-   * Moves the caret to the next block element in a rich text editor.
+   * Extracts readable plain text from clipboard HTML.
+   *
+   * @param {string} html - Clipboard text/html payload.
+   * @returns {string} - Plain text extracted from HTML.
+   */
+  private extractPlainTextFromHtml;
+  /**
+   * Builds plain-text paragraph blocks when element strategy parsing returns no output.
+   *
+   * @param {string} text - Plain text clipboard content.
+   * @returns {RTEContentBlock[]} Fallback text blocks.
+   */
+  private buildPlainTextFallbackBlocks;
+  /**
+   * Moves the caret to a block element in a rich text editor after paste.
    *
-   * @param {RTEBlock} newBlock - Represents a new create block element in a rich text editor.
+   * @param {RTEBlock} newBlock - Block element to move the caret to.
+   * @param {boolean} atEnd - When true, places the caret after the last character of the block's last node; otherwise at offset 0 of the first node.
    */
   private switchCaretPositionToNextElement;
   /**
@@ -47,4 +89,73 @@ export declare class InsertPasteHandler extends BaseHandler {
    * @returns {string} - The formatted HTML string.
    */
   private parsePlainText;
+  /**
+   * Detects whether plain text likely represents source code.
+   *
+   * @param {string} content - Clipboard plain text content.
+   * @returns {boolean} True when the content should render as a code block.
+   */
+  private shouldRenderAsCodeBlock;
+  /**
+   * Removes pasted website artifacts that can cause visual regressions in the editor,
+   * such as heading anchor tooltips and empty wrappers.
+   *
+   * @param {HTMLElement} body - Parsed clipboard html body.
+   */
+  private normalizeImportedHtmlArtifacts;
+  /**
+   * Removes heading copy-link/tooltip artifacts copied from documentation pages.
+   *
+   * @param {HTMLElement} body - Parsed clipboard html body.
+   */
+  private removeHeadingArtifacts;
+  /**
+   * Removes empty block wrappers introduced by web copy/paste.
+   *
+   * @param {HTMLElement} body - Parsed clipboard html body.
+   */
+  private removeEmptyBlocks;
+  /**
+   * Checks whether a block is visually empty and safe to remove.
+   *
+   * @param {HTMLElement} element - Block element to inspect.
+   * @returns {boolean} True when the block has no visible content.
+   */
+  private isEmptyVisualBlock;
+  /**
+   * Checks whether a text/html payload is effectively plain text.
+   *
+   * Some sources (e.g. terminals, code editors) place the copied text inside an
+   * off-screen / visually hidden wrapper such as
+   * `<pre><div style="position: absolute; left: -9999px;">text</div></pre>`.
+   * Preserving that markup as rich content would render the pasted text
+   * off-screen (appearing empty), so such payloads are treated as plain text.
+   *
+   * @param {string} html - Clipboard text/html payload.
+   * @returns {boolean} True when the payload has no visible rich content.
+   */
+  private shouldTreatAsPlainTextPayload;
+  /**
+   * Returns true when a CSS style string contains bold, italic, underline,
+   * strikethrough, or color declarations.
+   *
+   * @param {string} style - Inline CSS style string.
+   * @returns {boolean} True when the style contains rich formatting.
+   */
+  private styleContainsRichFormatting;
+  /**
+   * Determines whether an element is visually hidden or rendered off-screen
+   * via its inline style, indicating a clipboard plain-text wrapper.
+   *
+   * @param {HTMLElement} element - Element to inspect.
+   * @returns {boolean} True when the element is hidden or off-screen.
+   */
+  private isVisuallyHiddenElement;
+  /**
+   * Resolves paste payload from DataTransfer and synthetic-event fallback payload.
+   *
+   * @param {InputEvent} event - Paste event.
+   * @returns {RTEPastePayload} - Paste payload.
+   */
+  private getPastePayload;
 }

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

@@ -105,27 +105,36 @@ export declare class SelectionController extends AutoRunWhenReRenderTaskQueueSli
    */
   protected doTask: () => Promise<void>;
   /**
-   * Scroll the editor's scrollable viewport so the caret stays visible.
-   * Setting the selection range programmatically does not trigger the browser's
-   * native auto-scroll, so when the cursor is moved (e.g. after inserting a
-   * function block) it can land outside the visible area of a fixed-height
-   * (rows) editor. This keeps the caret within view.
+   * Keep the caret visible after the range is restored.
    *
-   * Note: This method performs getBoundingClientRect() reads and is called during
-   * the re-render task path every time the saved selection is restored.
+   * Applying a range in code does not trigger browser auto-scroll. We first
+   * check whether the caret is already visible, and only then call
+   * scrollIntoView with center alignment. This works for both fixed-height
+   * content hosts (rows mode) and page scrolling (stretch mode), while avoiding
+   * unnecessary jumps during normal typing.
    *
    * @param {Range} range - The range that was applied to the selection.
    */
   private scrollCaretIntoView;
   /**
-   * Get the bounding rect of the caret for the given range.
-   * A collapsed range inside an empty node can return an empty rect, so in that
-   * case fall back to the nearest element's bounding rect.
+   * Resolve the nearest element for the caret start container.
    *
-   * @param {Range} range - The range to measure.
-   * @returns {Nullable<DOMRect>} The caret bounding rect, or null if it cannot be resolved.
+   * @param {Range} range - The range to inspect.
+   * @returns {Nullable<HTMLElement>} The caret's nearest element, or null.
    */
-  private getCaretRect;
+  private getCaretElement;
+  /**
+   * Determine whether the caret is currently visible within the viewport.
+   *
+   * The visible area is the intersection of the window and the content host,
+   * because in fixed-height (`rows`) mode the host clips its content while in
+   * the stretch mode the window is the binding constraint.
+   *
+   * @param {Range} range - The range that was applied to the selection.
+   * @param {HTMLElement} element - The caret's nearest element.
+   * @returns {boolean} True when the caret is fully inside the visible area.
+   */
+  private isCaretWithinViewport;
   /**
    * Save the current selection range detail
    */

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

@@ -1,6 +1,7 @@
 import { ToolbarInternalButtonConfig } from './toolbar-button-slimmer.abstract';
 import { VegaRichTextEditor } from '../../../vega-rich-text-editor';
 import { VisualModeToolbarButtonSlimmer } from './visual-mode-toolbar-button-slimmer.abstract';
+import { Nullable } from '../../../../../types/general';
 export declare type InsertImageType = 'upload' | 'url';
 export declare type InsertImageItem = {
   key: InsertImageType;
@@ -10,7 +11,7 @@ export declare type InsertURLForm = {
   url: string;
 };
 export declare class ImageToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
-  private static readonly items;
+  private static readonly allItems;
   protected host: VegaRichTextEditor['host'];
   protected insertImageController: VegaRichTextEditor['insertImageController'];
   protected imageInsertedEventEmitter: VegaRichTextEditor['imageInsertedEventEmitter'];
@@ -24,17 +25,24 @@ export declare class ImageToolbarButtonSlimmer extends VisualModeToolbarButtonSl
   private currentSelectedBlocks;
   private currentSelectedNodes;
   constructor();
-  protected renderBtnWrapper(renderBtn: (toolbarInternalButton: ToolbarInternalButtonConfig) => HTMLElement): HTMLElement;
+  protected renderBtnWrapper(renderBtn: (toolbarInternalButton: ToolbarInternalButtonConfig) => HTMLElement): Nullable<HTMLElement>;
+  protected onClick(): void;
   protected isSelected(): boolean;
   protected isDisabled(): boolean;
   private renderDropdownContent;
+  private getItems;
   private renderUploadInput;
   private renderInsertURLModal;
   private addDropdownObserver;
   private addModalCancelObserver;
   private addModalInsertObserver;
+  private getImageExtensionConfig;
+  private isImageUploadEnabled;
+  private isImageURLInsertionEnabled;
+  private shouldRenderDropdown;
   private insertURLImage;
   private handleDropdownItemClick;
+  private openInsertURLModal;
   /**
    * The below method is e2e-test covered in
    * @see{module:should-update-url-properly-when-upload-images}

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

@@ -54,6 +54,11 @@ export declare class VegaRichTextEditorRenderer extends VegaSlimmer {
   private renderLabel;
   private renderHintMessage;
   private renderTextContent;
+  /**
+   * Propagates rich-text content scrolling inside shadow root so open appender
+   * can force position recalculation via ElementAppenderSlimmer.
+   */
+  private notifyContentScrolling;
   private renderCharacterCounter;
   private renderErrorMessage;
   private richTextContentFocus;

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

@@ -40,4 +40,12 @@ export declare class VegaRichTextEditorSourceViewRenderer extends VegaSlimmer {
    * @returns {string} The HTML template string
    */
   private getSourceTemplate;
+  /**
+   * Normalize source HTML for source-mode editing.
+   *
+   * `vega-code-block` renders code as HTML and will decode quote entities, so
+   * convert quote entities inside style attributes to single quotes before entering
+   * source mode. This preserves valid HTML when switching back to normal mode.
+   */
+  private normalizeSourceCodeForEditing;
 }

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

@@ -4,6 +4,7 @@ export declare class VegaRichTextEditorToolbarButtonRenderer extends VegaSlimmer
   private hidden;
   private selected;
   private showArrowIcon;
+  private arrowIcon;
   private icon;
   private iconColor;
   private clickEventEmitter;

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

@@ -39,6 +39,12 @@ export declare class VegaRichTextEditorToolbarButton {
    * @vegaVersion 2.34.0
    */
   showArrowIcon: boolean;
+  /**
+   * Specifies the arrow icon name when `showArrowIcon` is enabled.
+   *
+   * @vegaVersion 2.93.0
+   */
+  arrowIcon: string;
   /**
    * Specifies whether the toolbar button in the rich text editor is represented by an icon.
    *

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

@@ -163,10 +163,10 @@ export declare class VegaRichTextEditor {
    */
   hint: string;
   /**
-   * Specifies editable section rows for the rich text editor.
-   * When not set, the editor uses stretching behavior with a default visual height of 5 rows.
-   * When set, the editor height is fixed and content overflow is scrollable.
-   * The value accepts integers ≥ 2; for optimal display, values below 2 are internally normalized to 5 rows.
+   * Specifies the number of visible rows for the rich text editor.
+   * - If not specified, the editor uses a flexible height with a default of 5 rows.
+   * - If specified, the editor height becomes fixed, and overflowing content is scrollable.
+   * - Accepts integer values ≥ 2. For optimal display, values below 2 are automatically normalized to 5 rows.
    *
    * @vegaVersion 2.34.0
    */