@globalpayments/vega 2.101.0 → 2.103.0

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

@@ -19,6 +19,7 @@ export declare class RTEPasteChooserUI {
   private readonly options;
   static readonly CHOOSER_ATTR: string;
   static readonly CHOOSER_RICH_ATTR: string;
+  static readonly CHOOSER_PLAIN_ATTR: string;
   static readonly CHOOSER_WORD_ATTR: string;
   static readonly CHOOSER_TRIGGER_ATTR: string;
   private chooserEl;

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

@@ -1,15 +1,17 @@
 import { VegaRTEExtension } from '../extension.abstract';
+import { RTEPasteChooserUI } from './paste-chooser-ui';
+import { PasteStrategySelector } from './strategies/paste-strategy-selector';
 import { RTEExtensionContext } from '../../interface';
-export declare type ClipboardFileContent = {
-  files: File[];
-  rtf: string;
-};
-export declare type VegaRTEPasteImage = {
-  /** Unique identifier used to fill in the uploaded URL later. */
-  id: string;
-  /** Pasted image file to upload. */
-  file: File;
-};
+import { PasteImageParser } from './parse-local-images-helper/paste-image-parser';
+import { PendingImageRegistry } from './parse-local-images-helper/pending-image-registry';
+import { ChooserPositioner } from './controllers/chooser-positioner';
+import { VegaRTEPasteImage } from './type';
+import { PasteProcessingPipeline } from './pipeline/paste-processing-pipeline';
+import { PasteDataTransferBuilder } from './pipeline/data-transfer-builder';
+import { PasteDispatcher } from './pipeline/paste-dispatcher';
+import { SelectionSnapshotService } from './controllers/selection-snapshot-service';
+import { PasteEventInterceptor } from './controllers/paste-event-interceptor';
+import { PasteChooserController } from './controllers/paste-chooser-controller';
 export declare type VegaRTEPasteExtensionOptions = {
   enableWordPaste?: boolean;
   imageInsertedCallback?: (images: VegaRTEPasteImage[], replaceUrl: (imageId: string, url: string) => void) => void;
@@ -19,47 +21,51 @@ export declare type VegaRTEPasteExtensionOptions = {
  * Intercepts keyboard paste and allows users to choose paste mode.
  */
 export declare class VegaRTEPasteExtension extends VegaRTEExtension {
+  protected readonly strategySelector: PasteStrategySelector;
+  protected readonly imageParser: PasteImageParser;
+  protected readonly pendingImageRegistry: PendingImageRegistry;
+  protected readonly chooserPositioner: ChooserPositioner;
+  protected readonly processingPipeline: PasteProcessingPipeline;
+  protected readonly dataTransferBuilder: PasteDataTransferBuilder;
+  protected readonly pasteDispatcher: PasteDispatcher;
+  protected readonly selectionSnapshotService: SelectionSnapshotService;
+  protected readonly pasteEventInterceptor: PasteEventInterceptor;
+  protected readonly pasteChooserController: PasteChooserController;
   private hostEl;
   private editableEl;
   private contentHostEl;
-  private chooserUI;
   private pendingPastePayload;
-  private listenerDocument;
-  private listenerWindow;
   private options;
-  private strategySelector;
-  private clipboardFileContent;
-  private imageParser;
-  /** Owns pending pasted-image previews awaiting upload and their URL replacement. */
-  private readonly pendingImageRegistry;
   constructor(options?: VegaRTEPasteExtensionOptions);
   /** @inheritDoc */
   initialExtensionAfterLoad(context: RTEExtensionContext): void;
   /** @inheritDoc */
   destroyExtension(): void;
+  /** @returns {RTEPasteChooserUI | null} Currently open chooser UI, or `null` when closed. */
+  protected get chooserUI(): RTEPasteChooserUI | null;
   /**
    * 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;
+  protected readonly handlePasteEvent: (event: ClipboardEvent) => void;
   /**
    * Dismisses the chooser when a pointer interaction occurs outside of it.
    *
    * @param {Event} event Pointer event captured on the document.
    */
-  private readonly handleOutsidePointerDown;
+  protected readonly handleOutsidePointerDown: (event: Event) => void;
   /**
    * Dismisses the chooser when the Escape key is pressed.
    *
    * @param {KeyboardEvent} event Keyboard event captured on the document.
    */
-  private readonly handleOutsideKeyDown;
+  protected readonly handleOutsideKeyDown: (event: KeyboardEvent) => void;
   /**
    * Dismisses the chooser when any relevant scroll container scrolls.
    */
-  private readonly handleOutsideScroll;
+  protected readonly handleOutsideScroll: () => void;
   /**
    * Attaches the paste listener to the editable element.
    */
@@ -93,40 +99,6 @@ export declare class VegaRTEPasteExtension extends VegaRTEExtension {
    * @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.
    *
@@ -136,48 +108,11 @@ export declare class VegaRTEPasteExtension extends VegaRTEExtension {
    * @param {RTEPasteMode} mode Selected paste mode.
    */
   private applyPasteMode;
-  /**
-   * Parses local images from the HTML and emits events for further processing.
-   *
-   * @param {string} html HTML content to parse.
-   * @param {ClipboardFileContent} clipboardFileContent Clipboard file content for image extraction.
-   * @returns {string} Processed HTML with local image references replaced.
-   */
-  private parseLocalImages;
   /**
    * Emits the `imageInsertedCallback` for any pending previews, allowing the
    * consumer to upload them and resolve their URLs.
    */
   private emitLocalImageInsertedEvent;
-  /**
-   * 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 {RTEPasteMode} [mode] Selected paste mode marker.
-   * @returns {DataTransfer} Populated data transfer payload.
-   */
-  private createDataTransfer;
   /**
    * Tears down the chooser UI and removes dismissal listeners.
    *

package/dist/types/components/vega-rich-text-editor/extensions/paste/pipeline/data-transfer-builder.d.ts

@@ -0,0 +1,10 @@
+import { PasteOutput } from '../type';
+/** Builds the DataTransfer contract consumed by InsertPasteHandler. */
+export declare class PasteDataTransferBuilder {
+  private static readonly RESERVED_KEYS;
+  /**
+   * @param {PasteOutput} output Processed paste output to serialize.
+   * @returns {DataTransfer} Data transfer payload consumed by the paste handler.
+   */
+  build(output: PasteOutput): DataTransfer;
+}

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

@@ -0,0 +1,8 @@
+/** Dispatches processed paste data through the editor's existing beforeinput pipeline. */
+export declare class PasteDispatcher {
+  /**
+   * @param {HTMLDivElement} editableEl Editable content element receiving the event.
+   * @param {DataTransfer} dataTransfer Processed clipboard payload.
+   */
+  dispatch(editableEl: HTMLDivElement, dataTransfer: DataTransfer): void;
+}

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

@@ -0,0 +1,18 @@
+import { PendingImageRegistry } from '../parse-local-images-helper/pending-image-registry';
+import { PasteStrategySelector } from '../strategies/paste-strategy-selector';
+import { RTEPasteMode } from '../strategies/paste-processing-strategy.abstract';
+import { ImageExtractor } from '../parse-local-images-helper/image-extractor';
+import { PasteOutput, PendingPastePayload } from '../type';
+/** Selects and executes one paste strategy, then performs declared post-processing. */
+export declare class PasteProcessingPipeline {
+  private readonly selector;
+  private readonly imageExtractor;
+  private readonly pendingImageRegistry;
+  constructor(selector: PasteStrategySelector, imageExtractor: ImageExtractor, pendingImageRegistry: PendingImageRegistry);
+  /**
+   * @param {PendingPastePayload} payload Captured clipboard and selection data.
+   * @param {RTEPasteMode} explicitMode Paste mode selected by the user.
+   * @returns {PasteOutput} Processed paste output and image extraction metadata.
+   */
+  process(payload: PendingPastePayload, explicitMode: RTEPasteMode): PasteOutput;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/strategies/paste-processing-strategy.abstract.d.ts

@@ -1,5 +1,7 @@
+import type { PasteInput, PasteOutput } from '../type';
 export declare enum RTEPasteMode {
   RICH = "rich",
+  PLAIN = "plain",
   WORD = "word"
 }
 /**
@@ -44,18 +46,38 @@ export declare abstract class AbstractPasteProcessingStrategy {
    * @returns {boolean} `false` unless a strategy opts into image processing.
    */
   get supportsImageProcessing(): boolean;
+  /** @returns {boolean} Whether this strategy consumes `text/plain` instead of `text/html` (default: false). */
+  get consumesPlainText(): boolean;
+  /**
+   * Owns the complete content policy for this paste mode. Subclasses that
+   * only need a different source string should override {@link getSourceContent}
+   * instead of re-implementing this method.
+   *
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {PasteOutput} Complete downstream paste contract.
+   */
+  transform(input: PasteInput): PasteOutput;
+  /**
+   * Resolves the source string passed to {@link process}. Defaults to
+   * `input.text` when {@link consumesPlainText} is true, otherwise `input.html`.
+   *
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {string} Content to feed into `process`.
+   */
+  protected getSourceContent(input: PasteInput): string;
   /**
    * Detect whether this strategy should handle the given HTML content.
    *
-   * @param html Raw clipboard HTML
-   * @returns true if this strategy should process the content
+   * @param {string} html Raw clipboard HTML.
+   * @returns {boolean} Whether this strategy should process the content.
    */
   abstract canHandle(html: string): boolean;
   /**
-   * Transform/sanitize the HTML content for this paste source.
+   * Transform clipboard content for the RTE pipeline.
+   * Receives `text/html` by default or `text/plain` if {@link consumesPlainText} is true.
    *
-   * @param html Raw clipboard HTML
-   * @returns Processed HTML ready for the RTE pipeline
+   * @param {string} content Raw clipboard content (HTML or plain text).
+   * @returns {string} Processed HTML.
    */
-  abstract process(html: string): string;
+  abstract process(content: string): string;
 }

package/dist/types/components/vega-rich-text-editor/extensions/paste/strategies/paste-strategy-selector.d.ts

@@ -1,5 +1,6 @@
 import { AbstractPasteProcessingStrategy } from './paste-processing-strategy.abstract';
 import { RTEPasteMode } from './paste-processing-strategy.abstract';
+import { PasteInput } from '../type';
 /**
  * Centralized selector for paste processing strategies.
  *
@@ -11,6 +12,18 @@ import { RTEPasteMode } from './paste-processing-strategy.abstract';
 export declare class PasteStrategySelector {
   private readonly defaultStrategy;
   private strategies;
+  /**
+   * Selects the strategy that will process this paste.
+   *
+   * When `explicitMode` is provided and not `rich`, the strategy registered for that mode
+   * is used. Otherwise the highest-priority strategy whose `canHandle` matches the HTML
+   * wins, falling back to the default pass-through strategy.
+   *
+   * @param {PasteInput} input Captured clipboard payload used for auto-detection.
+   * @param {RTEPasteMode} [explicitMode] Paste mode the user picked from the chooser.
+   * @returns {AbstractPasteProcessingStrategy} Strategy to run for this paste.
+   */
+  select(input: PasteInput, explicitMode?: RTEPasteMode): AbstractPasteProcessingStrategy;
   /**
    * Select the appropriate strategy for the given HTML content.
    * Returns the highest-priority strategy that can handle the content.

package/dist/types/components/vega-rich-text-editor/extensions/paste/strategies/plain-paste-strategy.d.ts

@@ -0,0 +1,29 @@
+import { AbstractPasteProcessingStrategy, RTEPasteMode } from './paste-processing-strategy.abstract';
+import { PasteInput, PasteOutput } from '../type';
+/** Converts plain-text clipboard to paragraph-per-line HTML. */
+export declare class PlainPasteProcessingStrategy extends AbstractPasteProcessingStrategy {
+  /** @returns {RTEPasteMode} Plain-text paste mode. */
+  get type(): RTEPasteMode;
+  /** @returns {boolean} Always `true`; consumes `text/plain` instead of `text/html`. */
+  get consumesPlainText(): boolean;
+  /** @returns {boolean} Always `false`; never auto-selected. */
+  canHandle(): boolean;
+  /**
+   * Converts plain text to paragraph HTML; every `\n` starts a new paragraph.
+   *
+   * @param {string} text - Clipboard `text/plain` payload.
+   * @param {boolean} decodeEncodedWhitespace - Decode markers emitted by HTML conversion.
+   * @returns {string} Paragraph HTML.
+   */
+  process(text: string, decodeEncodedWhitespace?: boolean): string;
+  /**
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {PasteOutput} Plain HTML, canonical text, and whitespace marker contract.
+   */
+  transform(input: PasteInput): PasteOutput;
+  /**
+   * @param {PasteInput} input Clipboard content used to derive canonical plain text.
+   * @returns {PlainTextSource} Canonical text and whether it contains whitespace sentinels.
+   */
+  private getPlainTextSource;
+}

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

@@ -0,0 +1,35 @@
+import { RTEExtensionContext } from '../../interface';
+import type { RTEPasteMode } from './strategies/paste-processing-strategy.abstract';
+export declare type SelectedNodes = ReturnType<RTEExtensionContext['getSelectedNodes']>;
+export declare type PendingPastePayload = {
+  html: string;
+  text: string;
+  range: Range | null;
+  selectedNodes: SelectedNodes;
+  files: File[];
+  rtf: string;
+};
+export declare type ClipboardFileContent = {
+  files: File[];
+  rtf: string;
+};
+export declare type PasteInput = {
+  html: string;
+  text: string;
+  files: File[];
+  rtf: string;
+};
+export declare type PasteOutput = {
+  html: string;
+  text: string;
+  mode: RTEPasteMode;
+  markers: Record<string, string>;
+  extractImages: boolean;
+  imagesToExtract: File[];
+};
+export declare type VegaRTEPasteImage = {
+  /** Unique identifier used to fill in the uploaded URL later. */
+  id: string;
+  /** Pasted image file to upload. */
+  file: File;
+};

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/table-annotations-action.d.ts

@@ -6,6 +6,7 @@ import { VegaRTETableAnnotation } from '../annotations/table-annotation';
  * Action to apply annotations to a table.
  */
 export declare class RTETableAnnotationsAction extends AnnotationAction {
+  static readonly typeName: string;
   isFlushable: boolean;
   table: VegaRTETableAnnotation;
   constructor(table: VegaRTETableAnnotation);

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/table-cell-annotations-action.d.ts

@@ -4,6 +4,7 @@ import { RTETableCellAnnotation, VegaRTETableCellAnnotation } from '../annotatio
  * Action to apply annotations to a table cell.
  */
 export declare class RTETableCellAnnotationsAction extends AnnotationAction {
+  static readonly typeName: string;
   isFlushable: boolean;
   cellAnnotation: VegaRTETableCellAnnotation;
   originAnnotation: RTETableCellAnnotation;

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/table-head-cell-annotations-action.d.ts

@@ -5,6 +5,7 @@ import { RTETableCellAnnotationsAction } from './table-cell-annotations-action';
  * Action to apply annotations to a table head cell.
  */
 export declare class RTETableHeadCellAnnotationsAction extends RTETableCellAnnotationsAction {
+  static readonly typeName: string;
   isFlushable: boolean;
   constructor(cellAnnotation: VegaRTETableCellAnnotation, originAnnotation: RTETableCellAnnotation);
   /**

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

@@ -6,6 +6,7 @@ export declare const UPDATE_TABLE_PROPERTIES: string;
  * Action to update table properties
  */
 export declare class UpdateTablePropertiesAction extends AnnotationAction {
+  static readonly typeName: string;
   isFlushable: boolean;
   private tableProperties;
   constructor(tableProperties: RTETablePropertiesType);

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

@@ -24,8 +24,7 @@ export declare type VegaRTETableChildType = RTETableHeadBlock | RTETableBodyBloc
  * Class representing a table block in the rich text editor.
  */
 export declare class RTETableBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, VegaRTETableChildType> {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   type: string;
   parent: VegaRTEContent | RTEHtmlBlock;
   children: VegaRTETableChildType[];

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

@@ -11,8 +11,7 @@ export declare type VegaRTETableBodyBlock = VegaRTEBlockBase & {
  * Class representing a table body block in the rich text editor.
  */
 export declare class RTETableBodyBlock extends RTEBlock<RTETableBlock, RTETableRowBlock> {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   type: string;
   parent: RTETableBlock;
   children: RTETableRowBlock[];

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

@@ -13,8 +13,7 @@ export declare type VegaRTETableCaptionBlock = VegaRTEBlockBase & {
  * Represents the optional caption block for a table.
  */
 export declare class RTETableCaptionBlock extends RTEBlock<RTETableBlock, RTEBlock> {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   type: string;
   parent: RTETableBlock;
   children: RTEBlock[];

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

@@ -14,8 +14,7 @@ export declare type VegaRTETableCellBlock = VegaRTEBlockBase & {
  * Class representing a table cell block in the rich text editor.
  */
 export declare class RTETableCellBlock extends RTEBlock<RTETableRowBlock, RTEBlock> {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   type: string;
   parent: RTETableRowBlock;
   children: RTEBlock[];

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

@@ -11,8 +11,7 @@ export declare type VegaRTETableHeadBlock = VegaRTEBlockBase & {
  * Class representing a table head block in the rich text editor.
  */
 export declare class RTETableHeadBlock extends RTEBlock<RTETableBlock, RTETableRowBlock> {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   type: string;
   parent: RTETableBlock;
   children: RTETableRowBlock[];

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-head-cell-block.d.ts

@@ -13,8 +13,7 @@ export declare type VegaRTETableHeadCellBlock = VegaRTEBlockBase & {
  * Class representing a table head block in the rich text editor.
  */
 export declare class RTETableHeadCellBlock extends RTETableCellBlock {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   type: string;
   constructor(id: string, options?: VegaRTETransformOptions);
   /**

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

@@ -13,8 +13,7 @@ export declare type VegaRTETableRowBlock = VegaRTEBlockBase & {
  * Class representing a table row block in the rich text editor.
  */
 export declare class RTETableRowBlock extends RTEBlock<RTETableBodyBlock | RTETableHeadBlock, RTETableCellBlock | RTETableHeadCellBlock> {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   type: string;
   parent: RTETableBodyBlock | RTETableHeadBlock;
   children: (RTETableCellBlock | RTETableHeadCellBlock)[];

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

@@ -5,6 +5,7 @@ import { RTETableBodyBlock } from '../dto/table-body-block';
  * Renders a table body block in the rich text editor.
  */
 export declare class RTETableBodyRenderer extends VegaRTEExtensionRenderer {
+  static readonly typeName: string;
   /**
    * @inheritDoc
    */

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

@@ -6,6 +6,7 @@ export declare const TABLE_CAPTION_PLACEHOLDER_TEXT: string;
  * Renderer for the optional table caption node.
  */
 export declare class RTETableCaptionRenderer extends VegaRTEExtensionRenderer {
+  static readonly typeName: string;
   /**
    * @inheritDoc
    */

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

@@ -5,6 +5,7 @@ import { RTETableCellBlock } from '../dto/table-cell-block';
  * Renders a table cell block in the rich text editor.
  */
 export declare class RTETableCellRenderer extends VegaRTEExtensionRenderer {
+  static readonly typeName: string;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-head-cell-renderer.d.ts

@@ -5,6 +5,7 @@ import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
  * Renders a head cell block in the rich text editor.
  */
 export declare class RTETableHeadCellRenderer extends RTETableCellRenderer {
+  static readonly typeName: string;
   /**
    * @inheritDoc
    */

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

@@ -5,6 +5,7 @@ import { RTETableBlock } from '../dto/table-block';
  * Renders a logic control block in the rich text editor.
  */
 export declare class RTETableHeadRenderer extends VegaRTEExtensionRenderer {
+  static readonly typeName: string;
   /**
    * @inheritDoc
    */

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

@@ -5,6 +5,7 @@ import { RTETableBlock } from '../dto/table-block';
  * Renderer for the RTETableBlock.
  */
 export declare class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
+  static readonly typeName: string;
   private tableToolbar;
   /**
    * @inheritDoc

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

@@ -5,6 +5,7 @@ import { RTETableRowBlock } from '../dto/table-row-block';
  * Renders a logic control block in the rich text editor.
  */
 export declare class RTETableRowBlockRenderer extends VegaRTEExtensionRenderer {
+  static readonly typeName: string;
   /**
    * @inheritDoc
    */

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

@@ -5,6 +5,7 @@ import { RTETokenNode } from './token-node';
  * Token node renderer for the rich text editor.
  */
 export declare class RTETokenNodeRenderer extends VegaRTEExtensionRenderer {
+  static readonly typeName: string;
   /**
    * Renders the token node as a DOM element.
    *

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

@@ -5,8 +5,7 @@ import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTETokenNode, V
  * Token node for the Vega Rich Text Editor.
  */
 export declare class RTETokenNode extends RTETextNode {
-  static dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   type: string;
   token: string;
   constructor(id: string, token: string, text: string, parentBlock: RTETextBlock, annotations?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);

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

@@ -39,3 +39,50 @@ export declare function escapeHtml(text: string): string;
  * @returns {string} Escaped attribute-safe value.
  */
 export declare function escapeHtmlAttribute(value: string): string;
+/**
+ * Normalizes clipboard line endings and splits into lines. Low-level primitive behind
+ * `toPlainPasteLines`, which layers boundary-whitespace handling on top and is the single
+ * conversion source used by plain-mode paste.
+ *
+ * @param {string} text Raw clipboard plain text.
+ * @returns {string[]} Lines with `\r\n`/`\r` normalized to `\n` and split on `\n`.
+ */
+export declare function normalizePlainTextLines(text: string): string[];
+/**
+ * Sentinels for whitespace that must survive plain-mode boundary collapsing (e.g. code-block
+ * indentation derived from HTML). `htmlToPlainText` can emit these in place of real spaces/tabs so
+ * that `toPlainPasteLines` leaves them untouched — they are not matched by `\s` — and decodes them
+ * back to real characters after collapsing the paste's insignificant leading/trailing whitespace.
+ */
+export declare const PRESERVED_SPACE: string;
+export declare const PRESERVED_TAB: string;
+/**
+ * Single source of truth for plain-mode paste conversion: turns raw clipboard text into
+ * the canonical list of lines used by both representations of the pasted content — the
+ * `text/html` payload emitted by `PlainPasteProcessingStrategy` and the RTE text/newline
+ * nodes built by `InsertPasteHandler`. Both must derive from this helper so whitespace and
+ * boundary handling cannot drift apart.
+ *
+ * Per-paragraph handling: lines carrying {@link PRESERVED_SPACE}/{@link PRESERVED_TAB}
+ * sentinels come from code-block sources (via the preservation branch of
+ * `extractBlockAwareText`) and are kept verbatim so significant indentation survives;
+ * all other lines get a normal `String.prototype.trim()` (including NBSP) so
+ * paragraph-boundary whitespace from non-code sources is treated as noise.
+ * When `decodeEncodedWhitespace` is enabled, sentinels are decoded back to real
+ * space/tab characters after the per-line pass.
+ *
+ * @param {string} text Raw clipboard plain text.
+ * @param {boolean} decodeEncodedWhitespace Whether HTML-derived sentinels should be decoded.
+ * @returns {string[]} Canonical plain-mode lines.
+ */
+export declare function toPlainPasteLines(text: string, decodeEncodedWhitespace?: boolean): string[];
+/**
+ * Serializes canonical plain-mode lines into paragraph-per-line HTML.
+ *
+ * Built as a string rather than via DOM `outerHTML` serialization, which collapses
+ * consecutive spaces in non-`<pre>` text nodes and would lose intentional whitespace.
+ *
+ * @param {string[]} lines Canonical plain-mode lines from {@link toPlainPasteLines}.
+ * @returns {string} Paragraph HTML where each line is an individual paragraph.
+ */
+export declare function plainPasteLinesToHtml(lines: string[]): string;