@globalpayments/vega 2.101.0 → 2.103.0

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

@@ -489,6 +489,7 @@ export type VegaRTEToolbarItem =
 	| 'undo'
 	| 'redo'
 	| 'fullscreen'
+	| 'bookmark'
 	| string; // Custom toolbar item types can be added here
 
 /**
@@ -631,6 +632,20 @@ export type VegaRTETokenNode = VegaRTETextNode & {
 	token: string;
 };
 
+/**
+ * Bookmark node used as a named local link target.
+ */
+export type VegaRTEBookmarkNode = VegaRTETextNode & {
+	/**
+	 * Bookmark node type identifier.
+	 */
+	type: string;
+	/**
+	 * Unique bookmark name within the document.
+	 */
+	name: string;
+};
+
 /**
  * Render result returned from renderer helpers.
  */

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

@@ -17,6 +17,7 @@ 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 { VegaRTEBookmarkExtension } from './extensions/bookmark/bookmark-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';

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

@@ -18,12 +18,24 @@ export declare class FocusController extends VegaSlimmer {
   focusOnLastTextNode(options?: {
     newLine?: boolean;
   }): Promise<void>;
+  /**
+   * Restore focus to the current selection target without changing the document structure.
+   *
+   * @returns {Promise<void>} - A promise that resolves when the focus is set.
+   */
+  focusOnCurrentTextNode(): Promise<void>;
   /**
    * Do a focus on the last text node of the last block
    *
    * @param {RTEContentBlock} lastBlock - The last block of the content
    */
   private doFocusOnLastTextNode;
+  /**
+   * Do a focus on the provided text node.
+   *
+   * @param {RTENode} node - The node to focus.
+   */
+  private doFocusOnTextNode;
   /**
    * Move the caret to the end of the node
    *

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

@@ -4,7 +4,7 @@ import { RTEBlock } from '../../../../../dto/blocks/block.abstract';
 import { RTENode } from '../../../../../dto/nodes/node.abstract';
 import { ClassPrototype } from '../../../../../../../types/class.type';
 export declare type RTEDtoClassPrototype = ClassPrototype<RTEBlock | RTENode> & {
-  readonly dtoName: string;
+  readonly typeName: string;
 };
 export declare type HtmlElementToAnnotationGenerateOptions = {
   parentAnnotations?: VegaRTETextAnnotations;

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

@@ -1,3 +1,4 @@
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 import { RTEBlock } from '../../../../dto/blocks/block.abstract';
 import { RTENode } from '../../../../dto/nodes/node.abstract';
 import { Nullable } from '../../../../../../types/general';
@@ -15,8 +16,20 @@ export interface ForwardDeletePosition {
 export declare abstract class AbstractDeleteContentHandler extends BaseHandler {
   /**
    * Delete the selected node(s) from the current state.
+   *
+   * @returns {CompositionStep[]} The content + caret steps applied atomically as one flushable composition.
+   */
+  handleEvent(): CompositionStep[];
+  /**
+   * Builds the ordered steps for a single-block deletion: the delete runs first, then a caret step
+   * reads the delete action's post-apply `previousNode`/`nextNode` to decide where the caret lands.
+   *
+   * @param {RTENode} resolvedNode - The node the deletion is anchored on.
+   * @param {number} resolvedOffset - The caret offset within `resolvedNode` at deletion time.
+   * @param {Nullable<RTENode>} caretAnchor - A node the caret must stay on regardless of the delete result.
+   * @returns {CompositionStep[]} The delete step followed by the dependent caret step.
    */
-  handleEvent(): void;
+  protected buildDeleteSteps(resolvedNode: RTENode, resolvedOffset: number, caretAnchor: Nullable<RTENode>): CompositionStep[];
   /**
    * Computes the caret position one step to the right, used to translate a forward delete into a backspace.
    *
@@ -49,12 +62,10 @@ export declare abstract class AbstractDeleteContentHandler extends BaseHandler {
    * @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.
+   *
+   * @returns {CompositionStep[]} The content + caret steps for the deletion, empty when nothing is deleted.
    */
-  protected abstract deleteContentWithSingleBlock(): void;
+  protected abstract deleteContentWithSingleBlock(): CompositionStep[];
 }

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

@@ -1,8 +1,12 @@
+import { Nullable } from '../../../../../../types/general';
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 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.
+   *
+   * @returns {Nullable<CompositionStep[]>} The delete + caret steps, empty when the deletion is delegated or a no-op.
    */
-  protected deleteContentWithSingleBlock(): void;
+  protected deleteContentWithSingleBlock(): Nullable<CompositionStep[]>;
 }

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

@@ -1,5 +1,7 @@
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 import { RTETextBlock } from '../../../../dto/blocks/text-block';
 import { VegaRTEContent } from '../../../../dto/content-state';
+import { RTEFlushChangesPayload } from '../../../../dto/flush-changes-payload';
 import { RTENode } from '../../../../dto/nodes/node.abstract';
 import { SelectionController } from '../../selection-controller';
 /** This code snippet is defining an abstract class named `BaseHandler` with an abstract method `execute`. */
@@ -7,15 +9,35 @@ export declare abstract class BaseHandler<TEvent extends Event = InputEvent> {
   protected currentState: VegaRTEContent;
   protected selectionController: SelectionController;
   protected richTextEditorRef: HTMLVegaRichTextEditorElement;
+  /**
+   * Default flush payload emitted after `handleEvent` completes. This is the single source of
+   * truth for the defaults — the observer does not re-apply any fallback values. Subclasses may override
+   * this field to opt out of flushing (assign `undefined`) or to change the defaults. Each instance
+   * owns its own copy so mutations from within `handleEvent` (e.g. `InsertTextHandler` updating
+   * `updateSource`) never leak across handler instances.
+   */
+  protected flushOptions: RTEFlushChangesPayload | undefined;
   /**
    * The function `execute` initializes the current state and selection, and then handles an event if provided.
    *
+   * Contract: `handleEvent` MUST be synchronous. A handler that mutates the value returns the
+   * `CompositionStep[]` it applied through `applyComposition`; the flush is then routed through the
+   * shared action pipeline. Handlers that do not mutate the value return nothing
+   *
    * @param {VegaRTEContent} currentState - The current state of the VegaRTE content.
    * @param {SelectionController} selectionController - Manages the selection of items in the user interface.
    * @param {HTMLElement} richTextEditor - The current rich text editor component
    * @param {Event} [event] - It is used to pass an input event to the method for handling.
    */
   execute(currentState: VegaRTEContent, selectionController: SelectionController, richTextEditor: HTMLVegaRichTextEditorElement, event?: TEvent): void;
+  /**
+   * Applies the collected leaf actions as a single flushable `SequentialCompositionAction`, so the value
+   * update and its flush run through the same action pipeline used by every other flushable operation.
+   * Handlers call this before enqueuing selection so caret math reads post-apply node state.
+   *
+   * @param {CompositionStep[]} steps - The ordered leaf actions to apply against their own targets.
+   */
+  protected applyComposition(steps: CompositionStep[] | void): void;
   /**
    * The function `isRootContainer` checks if an HTML element is a root container with a class of 'rich-text-content'.
    *
@@ -57,5 +79,12 @@ export declare abstract class BaseHandler<TEvent extends Event = InputEvent> {
    * @param {HTMLElement} richTextEditor - The current rich text editor component
    */
   private setCurrentRichTextEditor;
-  abstract handleEvent(event?: TEvent): void;
+  /**
+   * Handles an input event in the rich text editor.
+   * If an array or non-empty steps are returned, it means the content has been modified and subsequent processing steps are required to update the component value;
+   * otherwise, the content has not been modified and no further action is needed.
+   *
+   * @param {Event} event - The input event triggered in the rich text editor.
+   */
+  abstract handleEvent(event?: TEvent): CompositionStep[] | void;
 }

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

@@ -1,8 +1,12 @@
+import { Nullable } from '../../../../../../types/general';
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 import { AbstractDeleteContentHandler } from './abstract-delete-content-handler';
 /** Handles a delete (rightward) deletion of content within a VegaRTE editor. User press delete will trigger this method */
 export declare class ForwardDeleteContentHandler extends AbstractDeleteContentHandler {
   /**
    * Handles a delete (rightward) deletion of content within a single block in an RTE editor.
+   *
+   * @returns {Nullable<CompositionStep[]>} The delete + caret steps, empty when the deletion is delegated or a no-op.
    */
-  protected deleteContentWithSingleBlock(): void;
+  protected deleteContentWithSingleBlock(): Nullable<CompositionStep[]>;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/insert-line-break-handler.d.ts

@@ -1,16 +1,22 @@
 import { BaseHandler } from './base-handler';
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
+import { Nullable } from '../../../../../../types/general';
 /** User press shift + enter will tigger this callback */
 export declare class InsertLineBreakHandler extends BaseHandler {
   /**
    * Create new line break node and add node to state value
+   *
+   * @returns {Nullable<CompositionStep[]>} The content + caret steps applied atomically as one flushable composition.
    */
-  handleEvent(): void;
+  handleEvent(): Nullable<CompositionStep[]>;
   /**
    * Insert the \n in text element when root container is empty, should create text block and text node
    * <p>
    *  <span></span>
    *  <span></span>
    * </p>
+   *
+   * @returns {Nullable<CompositionStep[]>} The content + caret steps for the empty root break.
    */
   private breakNewBlock;
   /**
@@ -24,18 +30,29 @@ export declare class InsertLineBreakHandler extends BaseHandler {
    *  <br>
    *  <span>xt</span>
    * </p>
+   *
+   * @returns {CompositionStep[]} The content + caret steps for the single-block break.
    */
   private breakSingleBlock;
   /**
    * Handles breaking blocks in an RTE editor based on the current selection and position.
+   *
+   * @returns {CompositionStep[]} The content + caret steps for the multi-block break.
    */
   private breakMultipleBlocks;
   /**
-   * Moves the caret to the next node element in a rich text editor.
+   * Builds the caret step that reads the applied single-block line break to place the caret after it.
+   *
+   * @returns {CompositionStep} The dependent caret step.
+   */
+  private caretToSingleBlockNextNode;
+  /**
+   * Builds the caret operation that moves onto the node following the inserted line break.
    *
-   * @param {RTENode} lineBreakNode - Represents a node element in a rich text editor.
+   * @param {RTENode} lineBreakNode - The inserted line break node.
+   * @returns {CompositionOperation} The caret operation.
    */
-  private switchCaretPositionToSpecifiedNode;
+  private caretOperationToNextNode;
   /**
    * Returns the next sibling node of a given block element in a rich text editor.
    *

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/insert-paragraph-handler.d.ts

@@ -1,22 +1,30 @@
 import { BaseHandler } from './base-handler';
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 /** Insert a paragraph in a rich text editor based on the current selection and event. User type enter will trigger this callback */
 export declare class InsertParagraphHandler extends BaseHandler {
   /**
    * Create new paragraph node and add node to state value
+   *
+   * @returns {CompositionStep[] | void} The content + caret steps applied atomically as one flushable composition.
    */
-  handleEvent(): void;
+  handleEvent(): CompositionStep[] | void;
   /**
    * Handles breaking blocks in an RTE editor based on the current selection and position.
+   *
+   * @returns {CompositionStep[]} The content + caret steps for the multi-block break.
    */
   private breakMultipleBlocks;
   /**
    * Handles breaking a single block in an RTE editor based on the current selection and position.
+   *
+   * @returns {CompositionStep[]} The content + caret steps for the single-block break.
    */
   private breakSingleBlock;
   /**
-   * Moves the caret to the next block element in a rich text editor.
+   * Builds the caret operation that moves onto the first child of the newly created block.
    *
-   * @param {RTEBlock} newBlock - Represents a new create block element in a rich text editor.
+   * @param {Nullable<RTEBlock>} newBlock - The block created by the break, or null when none was created.
+   * @returns {CompositionOperation | void} The caret operation, or nothing when there is no target block.
    */
-  private switchCaretPositionToNextElement;
+  private caretToNextElement;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/insert-paste-handler.d.ts

@@ -1,4 +1,5 @@
 import { BaseHandler } from './base-handler';
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 /**
  * Handle user paste
  */
@@ -7,14 +8,15 @@ export declare class InsertPasteHandler extends BaseHandler {
    * Update the state value when user paste html elements.
    *
    * @param {InputEvent} event - Paste event.
+   * @returns {CompositionStep[]} The content + caret steps applied atomically as one flushable composition.
    */
-  handleEvent(event: InputEvent): void;
+  handleEvent(event: InputEvent): CompositionStep[];
   /**
    * 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.
+   * @returns {CompositionStep[] | undefined} The content + caret steps when inline insertion applies, otherwise undefined.
    */
   private insertPlainTextInline;
   /**
@@ -38,6 +40,7 @@ export declare class InsertPasteHandler extends BaseHandler {
    * Insert the blocks to root
    *
    * @param { RTEContentBlock[]} blocks - blocks
+   * @returns {CompositionStep[]} The append step for the root.
    */
   private insertBlocksToRoot;
   /**
@@ -45,6 +48,7 @@ export declare class InsertPasteHandler extends BaseHandler {
    *
    * @param { RTEContentBlock[]} blocks - blocks
    * @param { RTERange } rteRange - rteRange
+   * @returns {CompositionStep[]} The content + caret steps for the content branch.
    */
   private insertBlocksToContent;
   /**
@@ -52,19 +56,24 @@ export declare class InsertPasteHandler extends BaseHandler {
    *
    * @param { RTEContentBlock[]} blocks - blocks
    * @param { RTERange } rteRange - rteRange
+   * @returns {CompositionStep[]} The content + caret steps for the empty-paragraph branch.
    */
   private insertBlocksBeforeEmptyBlock;
   /**
    * Format and parse elements from user paste with simple style preservation.
    *
    * @param {InputEvent} event - Paste event.
+   * @param {RTERange} [currentRange] - Optional range used to resolve the paste location.
    * @returns {RTEContentBlock[]} - RTEContentBlock.
    */
   private parsePastedElements;
   /**
-   * Extracts readable plain text from clipboard HTML.
+   * Extracts plain text from HTML when clipboard lacks `text/plain`.
    *
    * @param {string} html - Clipboard text/html payload.
+   * @param {boolean} keepPreservedWhitespaceMarkers - Keep code-block indentation as sentinels so
+   * the plain-mode boundary collapse in `toPlainPasteLines` does not strip it (that helper decodes
+   * the sentinels). Must stay `false` for the rich path, which feeds `parsePlainText` directly.
    * @returns {string} - Plain text extracted from HTML.
    */
   private extractPlainTextFromHtml;
@@ -76,12 +85,36 @@ export declare class InsertPasteHandler extends BaseHandler {
    */
   private buildPlainTextFallbackBlocks;
   /**
-   * Moves the caret to a block element in a rich text editor after paste.
+   * Builds plain-text paragraphs by splitting on `\n`.
+   *
+   * Shares `toPlainPasteLines` with `PlainPasteProcessingStrategy` so both
+   * representations of plain-mode content (HTML and RTE nodes) agree on line
+   * boundaries and boundary whitespace.
+   *
+   * @param {string} text - Plain text clipboard content.
+   * @param {RTETextNode} [styleSource] - Optional style to preserve in all nodes.
+   * @param {boolean} decodeEncodedWhitespace - Decode HTML-derived whitespace markers.
+   * @returns {RTEContentBlock[]} Paragraph-per-line blocks.
+   */
+  private buildPlainTextParagraph;
+  /**
+   * Creates a text node for plain paste; optionally inherits style from source node.
+   *
+   * @param {RTETextBlock} paragraph - Parent paragraph.
+   * @param {number} index - Character index for node ID generation.
+   * @param {string} text - Text content.
+   * @param {RTETextNode} [styleSource] - Optional style to inherit.
+   * @returns {RTETextNode} Created text node.
+   */
+  private createPlainTextNode;
+  /**
+   * Builds the caret operation that moves onto a block element in a rich text editor after paste.
    *
    * @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.
+   * @returns {CompositionOperation | void} The caret operation, or nothing when the block has no children.
    */
-  private switchCaretPositionToNextElement;
+  private caretToBlockOperation;
   /**
    * Parses the content of a plain text and formats it into HTML.
    *

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

@@ -1,17 +1,21 @@
 import { BaseHandler } from './base-handler';
+import { Nullable } from '../../../../../../types/general';
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 /** Handles inserting text into a VegaRTEContent based on the current selection and input event. User input character will trigger this callback */
 export declare class InsertTextHandler extends BaseHandler {
   /**
    * Update the state value when user type character
    *
    * @param {InputEvent} event - The input event object
+   * @returns {Nullable<CompositionStep[]>} The content actions the base handler applies as one flushable unit.
    */
-  handleEvent(event: InputEvent): void;
+  handleEvent(event: InputEvent): Nullable<CompositionStep[]>;
   /**
    * Insert the text in root element when root container is empty, should create text block and text node
    *
    * @param {string} text The insert text
-   * @returns {RTETextNode} The new create text node
+   * @param {CompositionStep[]} steps The composition steps collector to append the update action to
+   * @returns {Nullable<RTETextNode>} The new create text node
    */
   private insertTextToRoot;
   /**
@@ -19,6 +23,7 @@ export declare class InsertTextHandler extends BaseHandler {
    *
    * @param {RTETextNode} lineBreakNode The current line break node, the text value is \n
    * @param {string} text The text need to insert
+   * @param {CompositionStep[]} steps The composition steps collector to append the resulting action to
    * @returns {Nullable<RTETextNode>} The new text node or the current line break node
    */
   private insertTextToLineBreakNode;

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

@@ -32,6 +32,8 @@ export declare class UserInputController extends VegaSlimmer {
   private handleKeyboardAction;
   /**
    * When a user performs an input action within the editable element, this function is triggered.
+   * Each handler owns its own `flushOptions` on `BaseHandler`, so the value update flows through
+   * the shared flush-changes action pipeline without this method having to construct or forward it.
    *
    * @param {InputEvent} e the before input event object
    */

package/dist/types/components/vega-rich-text-editor/utils/html-to-plain-text-utils.d.ts

@@ -0,0 +1,31 @@
+declare type HtmlToPlainTextOptions = {
+  preserveBoundaryBlankLines?: boolean;
+  /**
+   * Keep significant whitespace encoded as {@link PRESERVED_SPACE}/{@link PRESERVED_TAB} sentinels
+   * instead of decoding it to real spaces/tabs. Plain-mode paste sets this so the downstream
+   * `toPlainPasteLines` boundary collapse does not strip code-block indentation; it decodes the
+   * sentinels itself afterwards.
+   */
+  keepPreservedWhitespaceMarkers?: boolean;
+};
+/**
+ * Converts HTML to plain text, preserving line breaks introduced by block-level elements and `<br>`.
+ * Used as a fallback when clipboard data lacks a `text/plain` payload, so structural breaks
+ * (e.g. `<h1>Heading</h1><p>Body</p>`) survive as `Heading\nBody` instead of being flattened.
+ *
+ * @param {string} html HTML content to convert.
+ * @param {HtmlToPlainTextOptions} options Plain-text conversion options.
+ * @returns {string} Block-aware plain text with normalized `\n` line endings.
+ */
+export declare function htmlToPlainText(html: string, options?: HtmlToPlainTextOptions): string;
+/**
+ * Detects whether the clipboard HTML contains a table anywhere. Plain paste uses this together
+ * with a tab check on `text/plain`: a tab-separated `text/plain` only reflects a table's row/
+ * column layout when the clipboard actually has a table, so that combination is pasted from
+ * `text/plain` verbatim (its line breaks are trusted as-is), regardless of any surrounding content.
+ *
+ * @param {string} html HTML content to inspect.
+ * @returns {boolean} Whether the HTML contains a table.
+ */
+export declare function htmlContainsTable(html: string): boolean;
+export {};

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

@@ -16,6 +16,8 @@ export declare class LinkEditorController extends VegaSlimmer {
   protected linkEditorStateManager: VegaRichTextLinkEditor['linkEditorStateManager'];
   private readonly linkUrlNormalizer;
   private readonly linkTypeHandlers;
+  private pendingBookmarkSyncEcho;
+  private pendingUrlSyncEcho;
   /**
    * The element the trigger click listener is currently attached to (the link
    * wrapper acting as the popover target).
@@ -72,6 +74,15 @@ export declare class LinkEditorController extends VegaSlimmer {
    * @returns {void} No return value.
    */
   handleUrlVegaChange(e: CustomEvent<string>): void;
+  /**
+   * Updates the URL field from a selected bookmark target.
+   *
+   * @param {CustomEvent<string | string[]>} e - Bookmark selection change event.
+   * @returns {Promise<void>} Resolves after updating the URL field.
+   */
+  handleBookmarkVegaChange(e: CustomEvent<string | string[]>): Promise<void>;
+  /** Navigates to the current link's bookmark within the same rich text content root. */
+  handleBookmarkNavigation(): Promise<void>;
   /**
    * Submits the current link when Enter is pressed or hides the popover when Escape is pressed.
    *

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

@@ -50,6 +50,25 @@ export declare class LinkTypeConfigController extends VegaSlimmer {
    * @returns {VegaRTELinkExtensionConfig} The active link configuration.
    */
   getLinkConfig(): VegaRTELinkExtensionConfig;
+  /**
+   * Returns valid bookmark names from the current rich text document in document order.
+   *
+   * @returns {string[]} Available bookmark names.
+   */
+  getBookmarkNames(): string[];
+  /**
+   * Returns whether bookmark URL suggestions are enabled.
+   *
+   * @returns {boolean} True when bookmark suggestions are configured.
+   */
+  isBookmarkEnabled(): boolean;
+  /**
+   * Returns the bookmark name matching a fragment URL.
+   *
+   * @param {string} url - URL to match against current bookmarks.
+   * @returns {string} The matching bookmark name, or an empty string.
+   */
+  getBookmarkNameForUrl(url?: string): string;
   /**
    * Normalizes configured link types and filters unsupported entries.
    *
@@ -79,4 +98,11 @@ export declare class LinkTypeConfigController extends VegaSlimmer {
    * @returns {string} The translated label for the link type.
    */
   private getDefaultLinkTypeLabel;
+  /**
+   * Returns the rich text editor containing this link editor.
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The rich text editor host element type.
+   * @returns {HTMLVegaRichTextEditorElement | null} The containing editor, when available.
+   */
+  private getRTEHost;
 }

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

@@ -2,12 +2,14 @@ import { VegaSlimmer } from '../../../../../vega-slimmer/vega-slimmer-core';
 import { Nullable } from '../../../../../types/general';
 import { VegaRichTextLinkEditor } from '../../vega-rich-text-link-editor';
 export declare class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
+  private static readonly BOOKMARK_LABEL_MAX_LENGTH;
   protected host: VegaRichTextLinkEditor['host'];
   protected status: VegaRichTextLinkEditor['status'];
   protected translationSlimmer: VegaRichTextLinkEditor['translationSlimmer'];
   protected linkEditorController: VegaRichTextLinkEditor['linkEditorController'];
   protected linkTypeConfigController: VegaRichTextLinkEditor['linkTypeConfigController'];
   protected linkEditorStateManager: VegaRichTextLinkEditor['linkEditorStateManager'];
+  protected record: VegaRichTextLinkEditor['record'];
   private formRef;
   private popoverRef;
   private popoverContentRef;
@@ -20,11 +22,13 @@ export declare class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
   getTextInputRef(): Nullable<HTMLVegaInputElement>;
   render(): HTMLElement;
   private renderLinkUnlinkContent;
+  private getBookmarkLabel;
   private renderLinkEditContent;
   private renderCurrentLinkTypeEditFields;
   private renderTextInput;
   private renderEmailLinkEditFields;
   private renderUrlLinkEditFields;
+  private renderBookmarkUrlSuggestions;
   private renderLinkTypeSelector;
   private renderActionButtons;
   private readonly handlePopoverRef;
@@ -35,6 +39,10 @@ export declare class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
   private readonly handleTextInputRef;
   private readonly handleLinkFieldKeyDown;
   private readonly handleUrlVegaChange;
+  private readonly handleBookmarkVegaChange;
+  private readonly handleBookmarkInputSelectRef;
+  private readonly handleBookmarkMouseDown;
+  private setUrlAutoValidation;
   private readonly handleLinkTypeSelectRef;
   private readonly handleCancelButtonRef;
   private readonly handleSubmitButtonRef;

package/dist/types/components/vega-tab-group/helpers/vega-tab-group-width-layout-helper.d.ts

@@ -0,0 +1,63 @@
+import { TabConfig } from '../types';
+import { ResponsiveType, WidthType } from '../../../types/ui.type';
+import { Nullable } from '../../../types/general';
+/**
+ * Tab-width layout modes:
+ * - Adaptive: no global or per-item widths; tabs retain their natural widths.
+ * - Mixed: only some items define widths; configured items use their widths and
+ *   remaining items retain adaptive sizing.
+ * - Constrained: a global width is set or every item defines a width; the tab
+ *   list uses a stable width for consistent percentage-based sizing.
+ *
+ * `shouldUseConstrainedWidthLayout` selects constrained mode. The percentage
+ * helpers support renderer sizing and constrained-layout pagination.
+ */
+/**
+ * Determines whether constrained layout mode should be used.
+ *
+ * Constrained layout is intentionally enabled only when:
+ * - a global width is configured, or
+ * - all tab items explicitly define width.
+ *
+ * @param {ResponsiveType<WidthType> | undefined} tabItemWidth - Global tab item width configuration.
+ * @param {TabConfig[]} items - Tab item definitions.
+ * @returns {boolean} True when constrained layout mode should be applied.
+ */
+export declare function shouldUseConstrainedWidthLayout(tabItemWidth: ResponsiveType<WidthType> | undefined, items: TabConfig[]): boolean;
+/**
+ * Determines whether a width configuration includes a percentage value.
+ *
+ * @param {ResponsiveType<WidthType> | undefined} width - Width configuration to evaluate.
+ * @returns {boolean} True when at least one configured value uses `%`.
+ */
+export declare function isPercentageWidthValue(width: ResponsiveType<WidthType> | undefined): boolean;
+/**
+ * Determines whether the effective configured width for a tab item is percentage-based.
+ *
+ * Per-item `width` takes priority over component-level `tabItemWidth`.
+ *
+ * @param {TabConfig} item - Tab item definition.
+ * @param {ResponsiveType<WidthType> | undefined} tabItemWidth - Global width configuration.
+ * @returns {boolean} True when the resolved configured width uses `%`.
+ */
+export declare function hasPercentageConfiguredWidth(item: TabConfig, tabItemWidth: ResponsiveType<WidthType> | undefined): boolean;
+/**
+ * Gets the resolved percentage width for a tab item.
+ *
+ * Per-item `width` takes priority over component-level `tabItemWidth`.
+ *
+ * @param {TabConfig} item - Tab item definition.
+ * @param {ResponsiveType<WidthType> | undefined} tabItemWidth - Global width configuration.
+ * @returns {Nullable<number>} The resolved percentage value, or `null` when the configured width is not a percentage.
+ */
+export declare function getConfiguredPercentageWidthValue(item: TabConfig, tabItemWidth: ResponsiveType<WidthType> | undefined): Nullable<number>;
+/**
+ * Determines whether the tab list should use a stable container width.
+ *
+ * Mixed layouts that include percentage-based per-item widths require a stable
+ * container width so percentages resolve consistently.
+ *
+ * @param {TabConfig[]} items - Tab item definitions.
+ * @returns {boolean} True when any item uses a percentage width.
+ */
+export declare function hasAnyPercentageTabWidth(items: TabConfig[]): boolean;