@globalpayments/vega 2.97.0 → 2.99.0

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

@@ -6,6 +6,8 @@ import { VegaPopoverAppenderRenderer } from './slimmers/renderers/vega-popover-a
 import { VegaPopoverAppenderController } from './slimmers/controllers/vega-popover-appender-controller';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 /**
+ * A Popover is an overlaid window that displays rich content, and is visually tethered to the element that triggers it.
+ *
  * @vegaVersion 1.19.0
  */
 export declare class VegaPopover {

package/dist/types/components/vega-progress-tracker/vega-progress-tracker.d.ts

@@ -13,6 +13,8 @@ import { VegaProgressTrackerCurrentStepsController } from './slimmers/controller
 import { VegaProgressTrackerRenderModeController } from './slimmers/controllers/vega-progress-tracker-render-mode-controller';
 import { VegaProgressTrackerCurrentDirectionController } from './slimmers/controllers/vega-progress-tracker-current-direction-controller';
 /**
+ * The Progress Tracker guides users through a sequential process towards completing a specific goal.
+ *
  * @vegaVersion 1.0.7
  */
 export declare class VegaProgressTracker {

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

@@ -4,6 +4,8 @@ import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event
 import { VegaRadioShowErrorController } from './slimmers/controllers/vega-radio-show-error-controller';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 /**
+ * A Radio Button is used within a Radio Button Group to display a set of mutually exclusive options, where only one choice can be selected at a time.
+ *
  * @vegaVersion 1.0.7
  */
 export declare class VegaRadio {

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

@@ -17,3 +17,19 @@ export declare const VegaRTEOneRowHeightPx: number;
 export declare const RTE_DEFAULT_LINK_TYPE_KEY: string;
 export declare const RTE_EMAIL_LINK_TYPE_KEY: string;
 export declare const RTE_SUPPORTED_LINK_TYPE_KEYS: string[];
+/**
+ * Semantic marker used by renderers to identify elements that terminate
+ * continue-inline grouping during HTML -> DTO conversion.
+ */
+export declare const RTE_BLOCK_BOUNDARY_ATTRIBUTE: string;
+/**
+ * Custom DataTransfer MIME type used to tag a synthetic paste with the chosen
+ * paste mode (e.g. 'rich' or 'plain'), so downstream paste handling can decide
+ * whether to preserve the original inline styles.
+ */
+export declare const RTE_PASTE_MODE_DATA_TYPE: string;
+/**
+ * Custom DataTransfer MIME type value used to indicate that the paste content
+ * originated from Microsoft Word.
+ */
+export declare const RTE_PASTE_MODE_WORD: string;

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

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

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

@@ -89,6 +89,15 @@ export declare abstract class RTEBlock<P = RTEBlockParentType, C = RTEBlockChild
    * @param {AnnotationAction} action - Annotation action
    */
   apply(action: AnnotationAction | ModifyContentAction): void;
+  /**
+   * Whether caret nearest-element detection may descend into this block's children.
+   * Transparent wrappers (e.g. html-block) return true so the caret resolves to the
+   * real inner node; atomic widgets like the table block return false so the caret
+   * stays anchored to the block boundary.
+   *
+   * @returns {boolean} True when descending is allowed.
+   */
+  allowsCaretDescend(): boolean;
   /**
    * Get the first node of the block
    *

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+/**
+ * Returns true when the element belongs to function extension blocks by semantic
+ * boundary attribute or known function element classes.
+ *
+ * Use this helper for broad detection (e.g., extension-level boundary predicate
+ * registration) where both container and child function elements should be
+ * treated as part of the function block structure.
+ *
+ * @param {HTMLElement} element - Element to inspect.
+ * @returns {boolean} Whether the element belongs to a function block structure.
+ * @example
+ * this.registerBlockBoundaryPredicate(isFunctionBlockElement);
+ */
+export declare const isFunctionBlockElement: (element: HTMLElement) => boolean;
+/**
+ * Returns true when the element is a function block boundary container.
+ *
+ * Use this helper when conversion logic must identify only the function block
+ * container element (the DIV that maps to RTEFunctionBlock), not function child
+ * elements such as syntax/content nodes.
+ *
+ * @param {HTMLElement} element - Element to inspect.
+ * @returns {boolean} Whether the element is a function block boundary container.
+ * @example
+ * if (isFunctionBoundaryContainer(element)) {
+ *     // map the DIV to RTEFunctionBlock
+ * }
+ */
+export declare const isFunctionBoundaryContainer: (element: HTMLElement) => boolean;

package/dist/types/components/vega-rich-text-editor/extensions/paste/action-handler-strategies/image-replace-src-strategy.d.ts

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { RTEImageNode } from '../../../dto/nodes/image-node';
+import { ImageReplaceSrcAction } from '../actions/image-replace-src-action';
+/**
+ * Strategy to handle the `ImageReplaceSrcAction` for replacing the `src` attribute of an `<img>` element in the RTE content.
+ */
+export declare class ImageReplaceSrcStrategy extends ActionHandleStrategy<ImageReplaceSrcAction, RTEImageNode> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: ImageReplaceSrcAction, target: RTEImageNode): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/actions/image-replace-src-action.d.ts

@@ -0,0 +1,11 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+export declare const REPLACE_IMAGE_SRC: string;
+/**
+ * Action to replace the `src` attribute of an `<img>` element in the RTE content.
+ */
+export declare class ImageReplaceSrcAction extends ModifyContentAction {
+  type: string;
+  img: HTMLImageElement;
+  url: string;
+  constructor(imageElement: HTMLImageElement, url: string);
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/parse-local-images-helper/paste-image-parser.d.ts

@@ -0,0 +1,136 @@
+import { ClipboardFileContent, VegaRTEPasteImage } from '../paste-extension';
+/**
+ * A pasted image whose upload is still pending: the public
+ * {@link VegaRTEPasteImage} payload plus the local object URL currently used as
+ * its preview `src`.
+ */
+export declare type PasteImagePreview = VegaRTEPasteImage & {
+  /** Local object URL used as the temporary preview source. */
+  objectUrl: string;
+};
+export declare type ParseLocalImagesResult = {
+  /** Rewritten HTML with `<img>` elements swapped to local object-URL previews. */
+  html: string;
+  /** Previews for the images that were resolved to a file. */
+  previews: PasteImagePreview[];
+};
+/**
+ * Extracts pasted image files from clipboard payloads and swaps matching
+ * `<img>` elements to local object-URL previews.
+ *
+ * The parser is stateless: callers own the returned {@link PasteImagePreview}
+ * list and decide how to track pending uploads.
+ */
+export declare class PasteImageParser {
+  static PREVIEW_IMG_KEY: string;
+  /**
+   * Parses local `file://` images from the HTML, swaps matching `<img>`
+   * elements to object-URL previews, and returns the rewritten HTML alongside
+   * the resolved pending previews.
+   *
+   * When no local images are resolved, the original HTML is returned unchanged
+   * with an empty preview list.
+   *
+   * @param {string} html HTML content to parse.
+   * @param {ClipboardFileContent | null} clipboardFileContent Clipboard payload for image extraction.
+   * @returns {ParseLocalImagesResult} Rewritten HTML and resolved previews.
+   */
+  parseLocalImages(html: string, clipboardFileContent: ClipboardFileContent | null): ParseLocalImagesResult;
+  /**
+   * Swaps each `<img>` src to a local object-URL preview using the provided
+   * image files (paired by order), returning one preview per resolved image.
+   *
+   * Images that live inside a list are dropped instead of being previewed: the
+   * RTE does not support list images. They are removed here (after holding their
+   * position while the RTF images are paired by order) so the remaining images
+   * stay aligned with their files even when a list image is not the last one.
+   *
+   * @param {HTMLImageElement[]} images Placeholder `<img>` elements in document order.
+   * @param {File[]} files Image files to pair with the elements, in the same order.
+   * @returns {PasteImagePreview[]} Previews for the images that were resolved to a file.
+   */
+  createImagePreviews(images: HTMLImageElement[], files: File[]): PasteImagePreview[];
+  /**
+   * Extracts image files from clipboard data, preferring Word RTF-decoded
+   * images and falling back to the clipboard file list when RTF yields none.
+   *
+   * @param {ClipboardFileContent | null} clipboardFileContent Clipboard payload from a paste event.
+   * @param {HTMLElement[]} images `<img>` elements the files will be paired with.
+   * @returns {File[]} Image files found on the clipboard.
+   */
+  extractImageFiles(clipboardFileContent: ClipboardFileContent | null, images: HTMLElement[]): File[];
+  /**
+   * Safely extracts image files from Word RTF clipboard data.
+   *
+   * @param {string} rtf Clipboard payload from a paste event.
+   * @param {HTMLElement[]} images Array of `<img>` elements that may be updated with staged previews.
+   * @returns {File[]} Image files found in the clipboard data.
+   */
+  private safeExtractWordImages;
+  /**
+   * Removes Word list-table picture-bullet definitions from the RTF so they are
+   * not counted as content images.
+   *
+   * Word declares a list's picture bullet once as a `{\*\listpicture ...}`
+   * destination inside the list table. It renders nothing on its own, so its
+   * blip has no matching content `<img>`; leaving it in shifts the ordinal
+   * pairing and makes the first real image resolve to the bullet. The per-item
+   * `{\listtext ...}` bullets are intentionally left untouched because each is
+   * kept as a placeholder `<img>` that consumes its blip downstream.
+   *
+   * @param {string} rtf Full RTF clipboard payload.
+   * @returns {string} RTF with list-table picture-bullet definitions removed.
+   */
+  private stripListPictureDefinitions;
+  /**
+   * Removes every balanced-brace RTF group that starts with the given marker.
+   *
+   * @param {string} rtf RTF payload to scan.
+   * @param {string} marker Opening delimiter of the group to remove (including its `{`).
+   * @returns {string} RTF with the matching groups removed.
+   */
+  private removeBalancedGroups;
+  /**
+   * Finds the index just past the brace that closes the group opened at `start`.
+   *
+   * A backslash escapes the next character (such as `\{` or `\}`) so escaped
+   * braces are not counted. When the group is unbalanced the RTF length is
+   * returned so the trailing remainder is dropped.
+   *
+   * @param {string} rtf RTF payload to scan.
+   * @param {number} start Index of the group's opening `{`.
+   * @returns {number} Index immediately after the matching closing `}`.
+   */
+  private findGroupEnd;
+  /**
+   * Extracts the raw image bytes that follow a Word RTF blip marker.
+   *
+   * Starting just after the blip control word, RTF control words (such as
+   * `\bliptag`) and nested groups (such as `{\*\blipuid ...}`) are skipped so
+   * their hex is not mistaken for image data. Hex digits are decoded into bytes
+   * until the enclosing `{\pict}` group is closed.
+   *
+   * @param {string} rtf Full RTF clipboard payload.
+   * @param {number} startIndex Index immediately after the blip marker.
+   * @returns {number[]} Decoded image byte values.
+   */
+  private extractImageBytes;
+  /**
+   * Converts a single hex character to its numeric value.
+   *
+   * @param {string} char Candidate hex character.
+   * @returns {number} Value in `[0, 15]`, or `-1` when not a hex digit.
+   */
+  private hexNibble;
+  /**
+   * Returns whether an `<img>` element is nested inside list content.
+   *
+   * The Word paste sanitizer strips non-allowlisted attributes but keeps the
+   * `ul`/`ol`/`li` structure, so list membership is detected by DOM ancestry
+   * here rather than by a marker attribute set upstream.
+   *
+   * @param {HTMLImageElement} imageElement Image element to test.
+   * @returns {boolean} Whether the image is part of list content.
+   */
+  private isListImage;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/parse-local-images-helper/pending-image-registry.d.ts

@@ -0,0 +1,68 @@
+import { RTEImageNode } from '../../../dto/nodes/image-node';
+import { PasteImagePreview } from './paste-image-parser';
+import type { VegaRTEPasteImage } from '../paste-extension';
+/** Consumer callback invoked once pasted images are inserted into the editor. */
+export declare type ImageInsertedCallback = (images: VegaRTEPasteImage[], replaceUrl: (imageId: string, url: string) => void) => void;
+/** Resolves the editable content element currently backing the editor. */
+export declare type GetEditableElement = () => HTMLDivElement | null;
+/** Resolves the image DTO node for a live preview `<img>` element. */
+export declare type ResolveImageNode = (imageElement: HTMLImageElement) => RTEImageNode | null;
+/**
+ * Owns the lifecycle of pasted images awaiting upload: it tracks their local
+ * object-URL previews, notifies the consumer once they are inserted, applies the
+ * uploaded URL back onto the live preview, and revokes object URLs on teardown.
+ *
+ * Keeping this state here rather than on the paste extension keeps the extension
+ * focused on clipboard capture and the chooser UI.
+ */
+export declare class PendingImageRegistry {
+  /**
+   * Pasted images awaiting upload, keyed by their {@link VegaRTEPasteImage.id}.
+   *
+   * Shared statically across instances so previews survive a paste-extension
+   * re-instantiation: the consumer may resolve `replaceUrl` after the editor
+   * has re-mounted and created a new extension/registry instance.
+   */
+  private static readonly pendingImages;
+  /** Ids of pending images still holding an object URL owned by this registry. */
+  private readonly ownedImageIds;
+  /** Ids queued for the next {@link notifyInserted} call. */
+  private pendingNotifyImageIds;
+  /**
+   * Registers freshly created previews so they can be notified and later
+   * resolved to their uploaded URLs.
+   *
+   * @param {PasteImagePreview[]} previews Previews produced for the current paste.
+   */
+  register(previews: PasteImagePreview[]): void;
+  /**
+   * @returns {boolean} Whether previews are queued for notification.
+   */
+  hasPendingNotifications(): boolean;
+  /**
+   * Notifies the consumer about newly inserted pasted images so they can upload
+   * them and fill in the real URLs via the supplied `replaceUrl` callback.
+   *
+   * @param {ImageInsertedCallback | undefined} callback Consumer callback to invoke.
+   * @param {GetEditableElement} getEditableElement Resolves the live editable element.
+   * @param {ResolveImageNode} resolveImageNode Resolves the DTO node for a preview element.
+   */
+  notifyInserted(callback: ImageInsertedCallback | undefined, getEditableElement: GetEditableElement, resolveImageNode: ResolveImageNode): void;
+  /**
+   * Revokes and forgets only previews that were never handed to a consumer for
+   * upload. Previews already notified via {@link notifyInserted} are left intact
+   * so an async {@link replaceUrl} can still resolve them after the extension is
+   * recreated; that callback owns their teardown.
+   */
+  discardUnsentPreviews(): void;
+  /**
+   * Applies the uploaded URL for a pending pasted image, replacing its local
+   * preview `src` and revoking the object URL.
+   *
+   * @param {string} imageId Pending image id supplied to the consumer callback.
+   * @param {string} url Uploaded image URL to apply.
+   * @param {GetEditableElement} getEditableElement Resolves the live editable element.
+   * @param {ResolveImageNode} resolveImageNode Resolves the DTO node for a preview element.
+   */
+  private replaceUrl;
+}

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

@@ -1,11 +1,14 @@
-export declare type PasteMode = 'rich';
+import { RTEPasteMode } from './strategies/paste-processing-strategy.abstract';
 export declare type PasteChooserPosition = {
   left: number;
   top: number;
   placement: ['bottom', 'top'] | ['top', 'bottom'];
 };
 export declare type PasteChooserCallbacks = {
-  onModeSelect: (mode: PasteMode) => void;
+  onModeSelect: (mode: RTEPasteMode) => void;
+};
+export declare type PasteChooserOptions = {
+  showWordOption?: boolean;
 };
 /**
  * Renders and manages the paste format chooser UI.
@@ -13,13 +16,15 @@ export declare type PasteChooserCallbacks = {
 export declare class RTEPasteChooserUI {
   private readonly hostRoot;
   private readonly callbacks;
+  private readonly options;
   static readonly CHOOSER_ATTR: string;
   static readonly CHOOSER_RICH_ATTR: string;
+  static readonly CHOOSER_WORD_ATTR: string;
   static readonly CHOOSER_TRIGGER_ATTR: string;
   private chooserEl;
   private dropdownEl;
   private triggerButtonEl;
-  constructor(hostRoot: ShadowRoot, callbacks: PasteChooserCallbacks);
+  constructor(hostRoot: ShadowRoot, callbacks: PasteChooserCallbacks, options?: PasteChooserOptions);
   /**
    * Opens the paste-mode chooser at the given position.
    *
@@ -49,7 +54,7 @@ export declare class RTEPasteChooserUI {
    * 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 {RTEPasteMode} 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.