@globalpayments/vega 2.92.0 → 2.93.0

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

@@ -0,0 +1,48 @@
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { AnnotationStyle, RTERenderContext } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+export declare enum RTEBlockquoteExtensionAnnotationTypeEnum {
+  BLOCKQUOTE = "BLOCKQUOTE"
+}
+/**
+ * CSS class applied to `<blockquote>` elements rendered inside the editor.
+ */
+export declare const BLOCKQUOTE_CLASS_NAME: string;
+/**
+ * Default visual styles for the `<blockquote>` element in the RTE.
+ */
+export declare const BLOCKQUOTE_DEFAULT_STYLES: AnnotationStyle;
+/**
+ * Blockquote annotation.
+ */
+export declare class BlockquoteAnnotation extends BlockAnnotation<RTEBlockquoteExtensionAnnotationTypeEnum> {
+  readonly type: RTEBlockquoteExtensionAnnotationTypeEnum;
+  /**
+   * Generate the map item for the annotation.
+   *
+   * @returns {[RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE, BlockquoteAnnotation]} Map item.
+   */
+  static from(): [RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE, BlockquoteAnnotation];
+  /**
+   * Get the default CSS rule for the blockquote element.
+   *
+   * @returns {string} The default CSS rule.
+   */
+  static getDefaultCssText(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): Nullable<Record<string, unknown>>;
+  /**
+   * @inheritDoc
+   */
+  clone(): BlockquoteAnnotation;
+  /**
+   * @inheritDoc
+   */
+  renderClass(options?: RTERenderContext): Nullable<string>;
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
+}

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

@@ -0,0 +1,56 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTEContent } from '../../../dto/content-state';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../../interface';
+/**
+ * JSON payload shape for a blockquote block.
+ */
+export declare type VegaRTEBlockquoteBlock = VegaRTEBlockBase & {
+  type: 'blockquote';
+  children: VegaRTEContentBlock[];
+};
+/**
+ * Containers that may directly hold a blockquote block. Covers the editor
+ * root and any block container (e.g. an HTML wrapper or a table cell)
+ * without coupling this DTO to specific sibling extensions.
+ */
+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;
+  type: string;
+  parent: RTEBlockquoteParent;
+  children: RTEBlock[];
+  constructor(id: string, options?: VegaRTETransformOptions);
+  /**
+   * Convert a JSON block payload into an `RTEBlockquoteBlock` instance.
+   *
+   * @param {VegaRTEBlockquoteBlock} block - JSON payload.
+   * @param {VegaRTETransformOptions} [options] - Transform options.
+   * @returns {RTEBlockquoteBlock} The created blockquote block.
+   */
+  static from(block: VegaRTEBlockquoteBlock, options?: VegaRTETransformOptions): RTEBlockquoteBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTEBlockquoteParent): RTEBlockquoteBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(options?: VegaRTETransformOptions): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTEBlockquoteBlock;
+}

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

@@ -0,0 +1,35 @@
+import { Nullable } from '../../../../../types/general';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { ElementToDTOStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+import { RTEBlockquoteBlock } from '../dto/rte-blockquote-block';
+import { VegaRTETransformOptions } from '../../../interface';
+/**
+ * Claim every `<blockquote>` element encountered during HTML → DTO conversion
+ * and produce an {@link RTEBlockquoteBlock}.
+ *
+ * Nested `<blockquote>` elements are flattened to a single level in
+ * {@link appendChildBlocks}: any direct child that arrives as another
+ * `<blockquote>` is replaced by its own children, lifting them one level up.
+ */
+export declare class BlockquoteToBlockquoteBlockStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlockquoteBlock>;
+  /**
+   * Flatten nested `<blockquote>` elements: any direct child that is itself
+   * an {@link RTEBlockquoteBlock} is replaced by its own children, lifting
+   * them one level up.
+   *
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTEBlockquoteBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/filter-styles-strategies/blockquote-block/blockquote-filter-styles-strategy.d.ts

@@ -0,0 +1,31 @@
+import { RTEBlock } from '../../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../../dto/nodes/node.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../../../../dto/filter-styles-strategies/filter-styles-strategy.abstract';
+/**
+ * Filter styles strategy for blockquote blocks.
+ * Strips default blockquote visual styles during output and refills them during input,
+ * ensuring source edit round-trips do not lose information.
+ */
+export declare class BlockquoteFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  /**
+   * Checks if the given block dto class name corresponds to a blockquote block.
+   *
+   * @param {string} className The class name to check.
+   * @returns {boolean} True if the class name corresponds to a blockquote block, false otherwise.
+   */
+  private static isBlockquoteBlock;
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(_blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+}

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

@@ -0,0 +1,18 @@
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { RTEBlockquoteBlock } from '../dto/rte-blockquote-block';
+/**
+ * Renderer for blockquote blocks in the rich text editor.
+ */
+export declare class RTEBlockquoteBlockRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(createElement: VegaRTECreateElementFunction, block: RTEBlockquoteBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+  /**
+   * @inheritDoc
+   */
+  injectRTEScopeStyles(): string;
+}
+declare const _default: RTEBlockquoteBlockRenderer;
+export default _default;

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

@@ -0,0 +1,113 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult, VegaRTEToolbarRenderContext } from '../../../interface';
+import { VegaRTEToolbarButtonRenderer } from '../../base-toolbar-button-renderer';
+/**
+ * Toolbar button renderer for the blockquote extension.
+ *
+ * Behaviors implemented:
+ * - Active (`selected`) when the caret/selection is inside any blockquote
+ *   ancestor.
+ * - Click wraps the current block(s) into a new `<blockquote>`, or unwraps
+ *   the nearest blockquote ancestor when active. Inside a list, the entire
+ *   list is wrapped (escalating to the outermost list block). With no
+ *   selection, a new empty blockquote is appended at the end and focused.
+ * - Disabled when the wrap container does not support the wrap strategy
+ *   (e.g. inside a code block or function block); the button remains
+ *   enabled inside a blockquote so it can be toggled off, and with no
+ *   selection so it can append a new blockquote.
+ * - Hidden in source-edit mode (inherited from {@link VegaRTEToolbarButtonRenderer}).
+ */
+export declare class RTEBlockquoteToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  /**
+   * @inheritDoc
+   */
+  render(createElement: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * @inheritDoc
+   */
+  protected isSelected(editorContext: VegaRTEToolbarRenderContext): boolean;
+  /**
+   * @inheritDoc
+   */
+  protected isDisabled(editorContext: VegaRTEToolbarRenderContext): boolean;
+  /**
+   * @inheritDoc
+   */
+  protected handleButtonClick(editorContext: VegaRTEToolbarRenderContext): void;
+  /**
+   * @inheritDoc
+   */
+  protected handleDropdownClick(): void;
+  /**
+   * Append an empty paragraph wrapped in a new blockquote to the end of the
+   * content and place the caret inside it.
+   *
+   * @param {VegaRTEContent} content - Editor content to append to.
+   */
+  private appendEmptyBlockquote;
+  /**
+   * Wrap the selection's unique parent blocks into a new blockquote. Blocks
+   * inside a list or other nested container escalate to the top-level block.
+   * When the selection spans multiple top-level (root) blocks, any scoped
+   * container touched along the way (e.g. a table cell) is treated as an
+   * opaque block instead of an independent wrap target — the whole
+   * selection wraps as one, and any blockquote nested deeper than the
+   * top-level block (e.g. inside a table cell) is left untouched. Existing
+   * top-level blockquote blocks in the selection are merged (flattened)
+   * into the new one rather than nested.
+   *
+   * @param {RTENode[]} selectedNodes - Currently selected nodes.
+   */
+  private wrapSelectedBlocks;
+  /**
+   * Resolve the starting node of the current toolbar selection, if any.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - Render context.
+   * @returns {Nullable<RTENode>} The first selected node, or null.
+   */
+  private getStartNode;
+  /**
+   * Collect the unique closest blockquote ancestors of every selected node.
+   * Multiple selected nodes that share the same blockquote ancestor collapse
+   * into a single entry, so applying {@link RemoveBlockquoteAction} to each
+   * result unwraps every distinct blockquote in the selection exactly once.
+   *
+   * @param {RTENode[]} nodes - Selected nodes.
+   * @returns {Set<RTEBlockquoteBlock>} Unique blockquote ancestors, preserving insertion order.
+   */
+  private collectBlockquoteAncestors;
+  /**
+   * Walk up the block ancestors of the supplied node looking for an
+   * {@link RTEBlockquoteBlock}.
+   *
+   * @param {RTENode} node - Starting node.
+   * @returns {Nullable<RTEBlockquoteBlock>} The closest blockquote ancestor, or null.
+   */
+  private findBlockquoteAncestor;
+  /**
+   * Collect unique block ancestors (immediate parent blocks) from a list of
+   * selected nodes, preserving order of first appearance.
+   *
+   * @param {RTENode[]} nodes - Selected nodes.
+   * @returns {RTEBlock[]} Unique parent blocks.
+   */
+  private getUniqueBlocks;
+  /**
+   * Walk up from `block` to find the nearest ancestor that is a direct child
+   * of a container registered to handle {@link TRANSFORM_TO_BLOCKQUOTE}
+   * (e.g. {@link VegaRTEContent}, {@link RTETableCellBlock}).
+   *
+   * Stops as soon as the parent can handle the wrap action, so that blocks
+   * inside a table cell are scoped to the cell (not escalated to the root)
+   * while blocks inside a list are still escalated to the top-level list.
+   * Pass `forceRootScope` to ignore scoped containers and always escalate
+   * to the root — used when the overall selection spans multiple top-level
+   * blocks, so a table (or any other scoped container) is wrapped as a
+   * single opaque block alongside its siblings instead of independently.
+   *
+   * @param {RTEBlock} block - Immediate parent block of the selected node.
+   * @param {boolean} [forceRootScope] - Ignore scoped containers and escalate to the root.
+   * @returns {WrapAnchor} `wrapBlock` is the top-level ancestor when the block
+   *   is nested (otherwise null); `container` is the nearest wrap-capable parent.
+   */
+  private resolveWrapAnchor;
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Custom DataTransfer MIME type used to tag a synthetic paste with the chosen
+ * paste mode (e.g. 'rich' or 'plain'), so downstream paste handling can decide
+ * whether to preserve the original inline styles.
+ */
+export declare const RTE_PASTE_MODE_DATA_TYPE: string;

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

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

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

@@ -6,3 +6,10 @@ import { AnnotationStyle } from '../interface';
  * @returns {AnnotationStyle} An object representing the custom style annotations.
  */
 export declare function createStyleMapFromElement(element: HTMLElement): AnnotationStyle;
+/**
+ * Escape HTML-sensitive characters so text can be rendered literally in HTML.
+ *
+ * @param {string} text - Raw text content.
+ * @returns {string} Escaped text content.
+ */
+export declare function escapeHtml(text: string): string;

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

@@ -17,11 +17,14 @@ export { VegaRTELanguageExtension } from './extensions/languages/language-extens
 export { VegaRTEFunctionExtension } from './extensions/functions/function-extension';
 export { VegaRTETableExtension } from './extensions/table/table-extension';
 export { VegaRTEHorizontalLineExtension } from './extensions/horizontal-line/horizontal-line-extension';
+export { VegaRTEBlockquoteExtension } from './extensions/blockquote/blockquote-extension';
+export { RTEBlockquoteBlock } from './extensions/blockquote/dto/rte-blockquote-block';
 export { VegaRTESpecialCharactersExtension } from './extensions/special-characters/special-characters-extension';
 export { VegaRTEFindReplaceExtension } from './extensions/find-replace/find-replace-extension';
 export { VegaRTESpecialCharactersEssentials, VegaRTESpecialCharactersLatin, VegaRTESpecialCharactersMathematical, VegaRTESpecialCharactersArrows, VegaRTESpecialCharactersCurrency, VegaRTESpecialCharactersText, } from './extensions/special-characters/constants/default-categories';
 export { VegaRTELineHeightExtension } from './extensions/line-height/line-height-extension';
 export { VegaRTELinkExtension } from './extensions/link/link-extension';
+export { VegaRTEPasteExtension } from './extensions/paste/paste-extension';
 export { VegaRTECopyExtension } from './extensions/copy/copy-extension';
 export { VegaRTECutExtension } from './extensions/cut/cut-extension';
 export { ModifyContentAction, ModifyContentActionType } from './dto/actions/modify-content-action.abstract';