@globalpayments/vega 2.101.0 → 2.103.0

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

@@ -10,8 +10,7 @@ import { RTETextBlock } from './text-block';
  * - Every nested list block must have listBlock.parent === this list item.
  */
 export declare class RTEListItemBlock extends RTETextBlock {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   /**
    * TODO: Refactor the list item properties children and nestList, merge two properties together.
    *

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

@@ -11,8 +11,7 @@ export declare type RTETextBlockTagType = 'div' | 'h1' | 'h2' | 'h3' | 'h4' | 'h
  * Text block
  */
 export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock | RTEHtmlBlock, RTETextNode> {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   type: VegaRTETextBlockType;
   children: RTETextNode[];
   parent: VegaRTEContent | RTEListBlock | RTEHtmlBlock;
@@ -27,7 +26,7 @@ export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock
   static from(block: VegaRTETextBlock, options?: VegaRTETransformOptions): RTETextBlock;
   /**
    * Convert raw node payloads to their registered `RTENode` subclasses via
-   * `RTEDTOClassManager`, preserving custom types (e.g. `RTETokenNode`).
+   * `RTEDTOClassManager`, preserving custom types (e.g. `RTETokenNode`, `RTEBookmarkNode`).
    *
    * @param {VegaRTETextNode[]} nodes - Raw node payloads.
    * @param {RTETextBlock} parent - Parent block for the converted nodes.

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

@@ -6,13 +6,13 @@ import { RTEListItemBlock } from './blocks/list-item-block';
 import { RTENode } from './nodes/node.abstract';
 import { Nullable } from '../../../types/general';
 import './setup';
+import { Discriminated } from '../../../helpers/discriminator/discriminated';
 /**
  * Class representing the content state of the rich text editor.
  */
-export declare class VegaRTEContent {
+export declare class VegaRTEContent extends Discriminated {
   /** Minimize-safe type discriminator for VegaRTEContent. */
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   children: RTEContentBlock[];
   constructor(blocks: RTEContentBlock[]);
   /**

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

@@ -17,7 +17,7 @@ export declare class RTEFilterStylesStrategyRegistry {
    * Registers a filter styles strategy for a specific DTO class name.
    * Duplicate strategy instances are ignored.
    *
-   * @param {string} dtoClassName - The DTO class name (e.g. `RTEListBlock.name`).
+   * @param {string} dtoClassName - The DTO class name (e.g. `RTEListBlock.typeName`).
    * @param {RTEFilterStylesStrategy} strategy - The strategy instance to register.
    */
   static register(dtoClassName: string, strategy: RTEFilterStylesStrategy): void;

package/dist/types/components/vega-rich-text-editor/dto/flush-changes-payload.d.ts

@@ -0,0 +1,16 @@
+import { RTEUpdateSource } from '../constants/constant';
+/**
+ * Payload dispatched with `VegaInternalRichTextEditorFlushChanges` notifications.
+ * Carries the parameters that the `ValueController` flush observer needs so it can
+ * invoke the flush immediately (bypassing the debounce) for `beforeinput`-driven
+ * updates instead of relying on the debounced default path.
+ *
+ * Owned by handlers (see `BaseHandler.flushOptions`). The observer treats a missing
+ * payload — or missing fields — as "use the debounced default"; the defaults live
+ * on the emitter side so there is a single source of truth.
+ */
+export interface RTEFlushChangesPayload {
+  bypassDebounce?: boolean;
+  recordHistory?: boolean;
+  updateSource?: RTEUpdateSource;
+}

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

@@ -18,8 +18,7 @@ declare type CodeBlockNodeAnnotationValue = SelectionRangeAnnotation | CustomSty
  * RTE code node DTO class.
  */
 export declare class RTECodeBlockNode extends RTEDecoratorNode<RTECodeBlock> {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   type: NodeTypeEnum;
   parent: RTECodeBlock;
   text: string;

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

@@ -5,6 +5,7 @@ import { RTENode } from './node.abstract';
  * Abstract class for decorator nodes. A decorator node modifies content like an image node that will delete the whole node when the delete button is pressed.
  */
 export declare abstract class RTEDecoratorNode<P extends RTEBlock = RTEBlock> extends RTENode<P> {
+  static readonly typeName: string;
   static DECORATOR_CONTAINER_CLASS: string;
   static DECORATOR_NODE_CLASS: string;
   type: string;

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

@@ -8,8 +8,7 @@ import { RTEDecoratorNode } from './decorator-node';
  * Image node
  */
 export declare class RTEImageNode extends RTEDecoratorNode<RTEImageBlock> {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   readonly type: NodeTypeEnum;
   parent: RTEImageBlock;
   url: string;

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

@@ -6,6 +6,7 @@ import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import { CustomAttributeAnnotation } from '../annotations/custom-attribute-annotation';
 import { ClassType } from '../../../../types/class.type';
 import type { RTETextNode } from './text-node';
+import { Discriminated } from '../../../../helpers/discriminator/discriminated';
 export declare enum NodeTypeEnum {
   TEXT = "TEXT",
   IMAGE = "IMAGE",
@@ -15,14 +16,10 @@ export declare type NodeAnnotations = Map<RTENodeAnnotationMapKey, RTENodeAnnota
 /**
  * Abstract class for all nodes
  */
-export declare abstract class RTENode<P extends RTEBlock = RTEBlock> {
+export declare abstract class RTENode<P extends RTEBlock = RTEBlock> extends Discriminated {
+  static readonly typeName: string;
   id: string;
   annotationMap: NodeAnnotations;
-  /**
-   * Minimize-safe type discriminator. Each concrete sub-class declares its own
-   * `static readonly dtoName = 'ClassName'`.
-   */
-  readonly dtoName: string;
   abstract readonly type: string;
   abstract parent: P;
   protected constructor(id: string, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);

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

@@ -20,8 +20,7 @@ export declare type InlineHtmlTagDescriptor = {
 export declare class RTETextNode extends RTENode<RTETextBlock> {
   static registerActionStrategyStatus: Record<string, boolean>;
   static readonly htmlTag: 'span';
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   readonly type: NodeTypeEnum | string;
   text: string;
   parent: RTETextBlock;
@@ -177,6 +176,14 @@ export declare class RTETextNode extends RTENode<RTETextBlock> {
    * @returns {string} The HTML string representation of the text node.
    */
   private renderTextStr;
+  /**
+   * Formatting toggles at a collapsed caret intentionally keep empty marker
+   * nodes in the live model so future typing inherits the pending style. Those
+   * nodes are not semantic content and should not appear in serialized HTML.
+   *
+   * @returns {boolean} True when the node is an empty formatting-only marker that should be omitted from serialized HTML.
+   */
+  private shouldSkipEmptyFormattingMarker;
   /**
    * Determines if the text node should be rendered as plain text.
    *

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

@@ -1,9 +1,11 @@
 import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../interface';
 import { RTEBlock } from '../blocks/block.abstract';
 import { RTENode } from '../nodes/node.abstract';
+import { Discriminated } from '../../../../helpers/discriminator/discriminated';
 /**
  * Base renderer class for the rich text editor.
  */
-export declare abstract class VegaRTEBaseRenderer<T extends RTENode | RTEBlock, R extends VegaRTERenderResult | HTMLElement> {
+export declare abstract class VegaRTEBaseRenderer<T extends RTENode | RTEBlock, R extends VegaRTERenderResult | HTMLElement> extends Discriminated {
+  static readonly typeName: string;
   abstract render(entity: T, renderContext?: RTERenderContext, createElement?: VegaRTECreateElementFunction): R;
 }

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

@@ -3,6 +3,7 @@ import { Nullable } from '../../../../../types/general';
 import { RTERenderContext, VegaRTECreateElementFunction } from '../../../interface';
 import { VegaRTEBaseRenderer } from '../base-renderer';
 export declare abstract class RTEBlockRenderer extends VegaRTEBaseRenderer<RTEBlock, HTMLElement> {
+  static readonly typeName: string;
   abstract render(block: RTEBlock, renderContext: RTERenderContext, createElement?: VegaRTECreateElementFunction): HTMLElement;
   protected registerRef(ref: Nullable<HTMLElement>, block: RTEBlock): void;
   /**

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

@@ -7,6 +7,7 @@ import { RTEBlockRenderer } from './block-renderer.abstract';
  * Abstract class for rendering blocks that contain text nodes with support for rendering text with link styles.
  */
 export declare abstract class RTEBlockTextNodesRenderer extends RTEBlockRenderer {
+  static readonly typeName: string;
   /**
    * Renders the text nodes of the block(RTETextBlock, RTEListItemBlock), applying link group annotation rendering if present.
    *

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

@@ -5,6 +5,7 @@ import { RTECodeBlock } from '../../blocks/code-block';
  * The code block renderer.
  */
 declare class RTECodeBlockRenderer extends RTEBlockRenderer {
+  static readonly typeName: string;
   /**
    * Render the code block.
    *

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

@@ -2,6 +2,7 @@ import type { RTEHtmlBlock } from '../../blocks/html-block';
 import { RTERenderContext } from '../../../interface';
 import { RTEBlockRenderer } from './block-renderer.abstract';
 declare class RTEHTMLBlockRenderer extends RTEBlockRenderer {
+  static readonly typeName: string;
   render(block: RTEHtmlBlock, renderContext: RTERenderContext): HTMLElement;
 }
 declare const _default: RTEHTMLBlockRenderer;

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

@@ -2,6 +2,7 @@ import { RTEImageBlock } from '../../blocks/image-block';
 import { RTEBlockRenderer } from './block-renderer.abstract';
 import { RTERenderContext } from '../../../interface';
 declare class RTEImageBlockRenderer extends RTEBlockRenderer {
+  static readonly typeName: string;
   render(block: RTEImageBlock, renderContext: RTERenderContext): HTMLElement;
 }
 declare const _default: RTEImageBlockRenderer;

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

@@ -13,11 +13,12 @@ declare class RTELinkWrapperRenderer {
    * @param {RTERenderContext} context - Context containing render options.
    * @returns {VegaRTERenderResult[]} - Array of rendered HTML elements.
    */
-  render(nodes: RTETextNode[], linkGroupAnnotation: LinkGroupAnnotation, { editable, host }: RTERenderContext): VegaRTERenderResult[];
+  render(nodes: RTETextNode[], linkGroupAnnotation: LinkGroupAnnotation, renderContext: RTERenderContext): VegaRTERenderResult[];
   private groupNodesByLink;
   private isLinkGroup;
   private renderLinkEditorWrapper;
   private renderLink;
+  private handleBookmarkNavigation;
   private normalizeLinkNodesByDefaultProtocol;
   private normalizeUrlByDefaultProtocol;
   private handleChange;

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

@@ -2,6 +2,7 @@ import { RTEBlockRenderer } from './block-renderer.abstract';
 import { RTEListBlock } from '../../blocks/list-block';
 import { RTERenderContext } from '../../../interface';
 declare class RTEListBlockRenderer extends RTEBlockRenderer {
+  static readonly typeName: string;
   render(block: RTEListBlock, renderContext: RTERenderContext): HTMLElement;
   private resolveListMarker;
   private getListDepth;

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

@@ -2,6 +2,7 @@ import { RTEListItemBlock } from '../../blocks/list-item-block';
 import { RTERenderContext } from '../../../interface';
 import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
 declare class RTEListItemBlockRenderer extends RTEBlockTextNodesRenderer {
+  static readonly typeName: string;
   render(block: RTEListItemBlock, renderContext: RTERenderContext): HTMLElement;
   /**
    * Include structural ownership and direct nested-list identity in the key so

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

@@ -2,6 +2,7 @@ import { RTERenderContext } from '../../../interface';
 import { RTETextBlock } from '../../blocks/text-block';
 import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
 declare class RTETextBlockRenderer extends RTEBlockTextNodesRenderer {
+  static readonly typeName: string;
   render(block: RTETextBlock, renderContext: RTERenderContext): HTMLElement;
   /**
    * Returns the promotable inline HTML tag when the block wraps exactly one

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

@@ -2,6 +2,7 @@ import { RTENodeRenderer } from './node-renderer.abstract';
 import { RTERenderContext } from '../../../interface';
 import { RTECodeBlockNode } from '../../nodes/code-block-node';
 declare class RTECodeBlockNodeRenderer extends RTENodeRenderer {
+  static readonly typeName: string;
   render(node: RTECodeBlockNode, renderContext: RTERenderContext): HTMLElement;
   /**
    * Sync the code block DTO language and content when the component change event emit.

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

@@ -2,6 +2,7 @@ import { RTENodeRenderer } from './node-renderer.abstract';
 import { RTEImageNode } from '../../nodes/image-node';
 import { RTERenderContext } from '../../../interface';
 declare class RTEImageNodeRenderer extends RTENodeRenderer {
+  static readonly typeName: string;
   render(node: RTEImageNode, renderContext: RTERenderContext): HTMLElement;
   /**
    * The function will render an image.

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

@@ -3,6 +3,7 @@ import { Nullable } from '../../../../../types/general';
 import { RTENode } from '../../nodes/node.abstract';
 import { VegaRTEBaseRenderer } from '../base-renderer';
 export declare abstract class RTENodeRenderer extends VegaRTEBaseRenderer<RTENode, HTMLElement> {
+  static readonly typeName: string;
   abstract render(node: RTENode, renderContext?: RTERenderContext): HTMLElement;
   protected registerRef(ref: Nullable<HTMLElement>, node: RTENode): void;
 }

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

@@ -4,6 +4,7 @@ import { RTETextNode } from '../../nodes/text-node';
 import { Nullable } from '../../../../../types/general';
 import { InlineHtmlAnnotation } from '../../annotations/inline-html-annotation';
 declare class RTETextNodeRenderer extends RTENodeRenderer {
+  static readonly typeName: string;
   /**
    * Renders the text node wrapped in the given annotation chain starting from the
    * provided annotation level. Used by the grouped node renderer to render a node

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

@@ -9,6 +9,7 @@ declare type VegaRTEUseRef = (element: HTMLElement) => void;
  * Base renderer for Vega Rich Text Editor.
  */
 export declare abstract class VegaRTEExtensionRenderer extends VegaRTEBaseRenderer<RTEBlock | RTENode, VegaRTERenderResult> {
+  static readonly typeName: string;
   static REGISTER_REF_FLAG: string;
   /**
    * Returns the styles to be injected into the RTE scope.

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

@@ -19,8 +19,7 @@ export declare type RTEBlockquoteParent = VegaRTEContent | RTEBlock;
  * DTO representing a `<blockquote>` block.
  */
 export declare class RTEBlockquoteBlock extends RTEBlock<RTEBlockquoteParent, RTEBlock> {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   type: string;
   parent: RTEBlockquoteParent;
   children: RTEBlock[];

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/renderers/blockquote-block-renderer.d.ts

@@ -5,6 +5,7 @@ import { RTEBlockquoteBlock } from '../dto/rte-blockquote-block';
  * Renderer for blockquote blocks in the rich text editor.
  */
 export declare class RTEBlockquoteBlockRenderer extends VegaRTEExtensionRenderer {
+  static readonly typeName: string;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/action-handler-interceptors/delete-bookmark-before-text-interceptor.d.ts

@@ -0,0 +1,16 @@
+import { ActionHandlerExecution, ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { DeleteBlockContentAction } from '../../../dto/actions/delete-block-content-action';
+import type { RTETextBlock } from '../../../dto/blocks/text-block';
+/**
+ * Removes a bookmark when Backspace is pressed at the start of its following text node.
+ */
+export declare class DeleteBookmarkBeforeTextInterceptor extends ActionHandlerInterceptor<DeleteBlockContentAction, RTETextBlock> {
+  /**
+   * @inheritDoc
+   */
+  canIntercept(action: DeleteBlockContentAction, target: RTETextBlock): boolean;
+  /**
+   * @inheritDoc
+   */
+  intercept(_execution: ActionHandlerExecution, action: DeleteBlockContentAction, target: RTETextBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/action-handler-strategies/insert-bookmark-node-strategy.d.ts

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import type { RTETextBlock } from '../../../dto/blocks/text-block';
+import { InsertBookmarkNodeAction } from '../actions/insert-bookmark-node-action';
+/**
+ * Strategy to handle the insertion of a bookmark node into the nearest root block.
+ */
+export declare class InsertBookmarkNodeStrategy extends ActionHandleStrategy<InsertBookmarkNodeAction, RTETextBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertBookmarkNodeAction, block: RTETextBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/action-handler-strategies/update-bookmark-name-strategy.d.ts

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { RTEBookmarkNode } from '../bookmark-node';
+import { UpdateBookmarkNameAction } from '../actions/update-bookmark-name-action';
+/**
+ * Strategy to rename an existing bookmark node.
+ */
+export declare class UpdateBookmarkNameStrategy extends ActionHandleStrategy<UpdateBookmarkNameAction, RTEBookmarkNode> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: UpdateBookmarkNameAction, node: RTEBookmarkNode): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/actions/insert-bookmark-node-action.d.ts

@@ -0,0 +1,16 @@
+import { Nullable } from '../../../../../types/general';
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTERange } from '../../../dto/range';
+export declare const INSERT_BOOKMARK_NODE: string;
+/**
+ * Action to insert a bookmark node at a specified range in the Rich Text Editor.
+ *
+ * @example block.apply(new InsertBookmarkNodeAction(rteRange, 'Rights'));
+ */
+export declare class InsertBookmarkNodeAction extends ModifyContentAction {
+  type: string;
+  name: string;
+  rteRange: Nullable<RTERange>;
+  actionHandleResult: boolean;
+  constructor(rteRange: Nullable<RTERange>, name: string);
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/actions/update-bookmark-name-action.d.ts

@@ -0,0 +1,12 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+export declare const UPDATE_BOOKMARK_NAME: string;
+/**
+ * Action to rename an existing bookmark node.
+ *
+ * @example bookmarkNode.apply(new UpdateBookmarkNameAction('Rights'));
+ */
+export declare class UpdateBookmarkNameAction extends ModifyContentAction {
+  type: string;
+  name: string;
+  constructor(name: string);
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/anchor-to-bookmark-node-strategy.d.ts

@@ -0,0 +1,52 @@
+import { Nullable } from '../../../../types/general';
+import { VegaRTECustomNode } from '../../interface';
+import { ElementToDTOStrategy } from '../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+/**
+ * Strategy to convert anchor elements into bookmark nodes.
+ *
+ * Supported inputs:
+ * - `<a id="Rights"></a>` — the CKEditor 5 bookmark contract.
+ * - `<a name="Rights"></a>` — the legacy CKEditor 4 anchor format.
+ *
+ * Only empty named anchors become bookmarks. Anchors with content, or anchors carrying an `href`,
+ * are left untouched so existing link/text handling is preserved.
+ */
+export declare class AnchorToBookmarkNodeStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[]): Nullable<VegaRTECustomNode>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+  /**
+   * Checks whether the element is an anchor that represents a bookmark target.
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @returns {boolean} True when the element is a bookmark anchor.
+   */
+  private isBookmarkAnchor;
+  /**
+   * Reads the bookmark name from the anchor, preferring `id` over the legacy `name` attribute.
+   *
+   * @param {HTMLElement} element - The anchor element.
+   * @returns {string} The bookmark name, or an empty string when absent.
+   */
+  private resolveBookmarkName;
+  /**
+   * Checks whether the anchor has no meaningful content.
+   *
+   * @param {HTMLElement} element - The anchor element.
+   * @returns {boolean} True when the anchor is effectively empty.
+   */
+  private isEmptyAnchor;
+}

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

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

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

@@ -0,0 +1,16 @@
+import { VegaRTEExtension } from '../extension.abstract';
+/**
+ * Extension that adds bookmark (named anchor) support to the Vega Rich Text Editor.
+ *
+ * A bookmark is a zero-width, named marker that serializes to `<a id="name"></a>` so it can
+ * be used as a local link target.
+ */
+export declare class VegaRTEBookmarkExtension extends VegaRTEExtension {
+  static readonly TOOLBAR_BUTTON_KEY: string;
+  private bookmarkRenderer;
+  constructor();
+  /** @inheritDoc */
+  prepareBeforeLoad(host: HTMLVegaRichTextEditorElement): void;
+  /** Removes the per-host bookmark selection listener when the editor is destroyed. */
+  destroyExtension(): void;
+}

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

@@ -0,0 +1,62 @@
+import { AnnotationAction } from '../../dto/actions/annotation-action.abstract';
+import { RTETextBlock } from '../../dto/blocks/text-block';
+import { RTETextNode } from '../../dto/nodes/text-node';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTEBookmarkNode } from '../../interface';
+/**
+ * Bookmark node for the Vega Rich Text Editor.
+ *
+ * A bookmark is a named, zero-width marker that can be used as a local link target.
+ * It carries no text content and is never directly editable by the user.
+ */
+export declare class RTEBookmarkNode extends RTETextNode {
+  static readonly typeName: string;
+  static dtoName: string;
+  readonly dtoName: string;
+  readonly type: string;
+  name: string;
+  constructor(id: string, name: string, parentBlock: RTETextBlock, annotations?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  /**
+   * @inheritDoc
+   */
+  static from(value: VegaRTEBookmarkNode, parent: RTETextBlock): RTEBookmarkNode;
+  /**
+   * Converts the bookmark node to a JSON representation.
+   *
+   * @returns {VegaRTEBookmarkNode} - The JSON representation of the bookmark node.
+   */
+  toJSON(): VegaRTEBookmarkNode;
+  /**
+   * Bookmarks are markers only, so their content can never be edited directly.
+   *
+   * @returns {boolean} - Always returns false for bookmark nodes.
+   */
+  isContentEditable(): boolean;
+  /**
+   * Clones the bookmark node.
+   *
+   * @param {RTETextBlock} parent - The parent block for the cloned node.
+   * @returns {RTEBookmarkNode} - The cloned bookmark node.
+   */
+  clone(parent: RTETextBlock): RTEBookmarkNode;
+  /**
+   * Checks if a node is empty
+   *
+   * @returns {boolean}  It returns `true` if the node is empty
+   */
+  isEmpty(): boolean;
+  /**
+   * Converts the bookmark node to an HTML representation.
+   *
+   * The output matches the CKEditor 5 bookmark contract so the value stays
+   * compatible with other editors and remains a valid local link target.
+   *
+   * @returns {string} - The HTML representation of the bookmark node.
+   */
+  toHtml(): string;
+  /**
+   * Bookmarks do not accept text formatting, but still process selection annotations.
+   *
+   * @param {AnnotationAction} action - The annotation action to apply.
+   */
+  protected doAnnotationActionApply(action: AnnotationAction): void;
+}