@globalpayments/vega 2.92.0 → 2.93.0

package/dist/cjs/{token-extension-3aec039f.js → token-extension-d217914d.js}

@@ -7,18 +7,18 @@ const createPublicApiRuntimeMetricsSlimmer = require('./create-public-api-runtim
 const internalVegaZIndexManager = require('./internal-vega-z-index-manager-f03ddb37.js');
 const dynamicSlimmer = require('./dynamic-slimmer-f31fdfd7.js');
 const pageResizeObserverSlimmer = require('./page-resize-observer-slimmer-273d62ef.js');
-const internalVegaEventManager = require('./internal-vega-event-manager-7196a847.js');
-const internalTranslationController = require('./internal-translation-controller-48ebfd0f.js');
-const internalCalendarPeriodFactory = require('./internal-calendar-period-factory-6187ec4c.js');
-const contentState = require('./content-state-96ec9114.js');
-const codeBlock = require('./code-block-6435d641.js');
-const typeGuard = require('./type-guard-7ab48d6c.js');
-const linkExtension = require('./link-extension-28d95849.js');
+const internalVegaEventManager = require('./internal-vega-event-manager-13c4012b.js');
+const internalTranslationController = require('./internal-translation-controller-31f2b057.js');
+const internalCalendarPeriodFactory = require('./internal-calendar-period-factory-7a0ecdb1.js');
+const linkExtension = require('./link-extension-455c02b3.js');
+const contentState = require('./content-state-13daf87a.js');
+const codeBlock = require('./code-block-2f3d0f38.js');
+const typeGuard = require('./type-guard-1c3770d4.js');
 const internalIconManager = require('./internal-icon-manager-40bcac72.js');
 const vegaNonceManager = require('./vega-nonce-manager-df69d3ed.js');
 const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-c82df135.js');
-const vegaEventId = require('./vega-event-id-df22d80e.js');
-const splitCellOperation = require('./split-cell-operation-9e3ab88d.js');
+const vegaEventId = require('./vega-event-id-58afed7a.js');
+const splitCellOperation = require('./split-cell-operation-2fa5c9e4.js');
 const changeManager = require('./change-manager-a297e4d2.js');
 const vegaInternalEventId = require('./vega-internal-event-id-ecc5b87a.js');
 const remoteInvocationRegistry = require('./remote-invocation-registry-fc22fdd0.js');
@@ -27,7 +27,8 @@ const tryGetDocument = require('./try-get-document-c0ebd39a.js');
 const pixel = require('./pixel-98f2a10c.js');
 const object = require('./object-b53e9416.js');
 const timer = require('./timer-5f33058b.js');
-const replaceSelectedTextAction = require('./replace-selected-text-action-a31563ed.js');
+const string = require('./string-39438062.js');
+const replaceSelectedTextAction = require('./replace-selected-text-action-a80f5a6a.js');
 const copy = require('./copy-d021c780.js');
 
 const VegaLoaderRuntimeMetricsPayloadDefinition = [
@@ -3806,7 +3807,7 @@ class RTETableBlockRenderer extends linkExtension.VegaRTEExtensionRenderer {
    * @param {HTMLElement} tableRef - The element that can triggered the table popover open.
    */
   handleTableRemove(renderData, tableRef) {
-    renderData.parent.apply(new DeleteTableBlockAction(renderData));
+    renderData.apply(new DeleteTableBlockAction(renderData));
     this.destroySelectionAnchor(tableRef);
   }
   /**
@@ -7370,9 +7371,10 @@ class VegaRTETableExtension extends linkExtension.VegaRTEExtension {
   const insertTableBlockStrategy = new InsertTableBlockStrategy();
   const deleteTableBlockStrategy = new DeleteTableBlockStrategy();
   linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.VegaRTEContent.name, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.VegaRTEContent.name, DELETE_TABLE_BLOCK, deleteTableBlockStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableCellBlock.name, DELETE_TABLE_BLOCK, deleteTableBlockStrategy);
-  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableHeadCellBlock.name, DELETE_TABLE_BLOCK, deleteTableBlockStrategy);
+  // Registered on the table block itself (not its parent) so a table can always be
+  // deleted regardless of which block type it is nested in (root content, table cell,
+  // blockquote, or any future container).
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, DELETE_TABLE_BLOCK, deleteTableBlockStrategy);
   linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.name, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
   linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.RTEImageBlock.name, INSERT_TABLE_BLOCK, insertTableBlockStrategy);
   linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableBlock.name, splitCellOperation.INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, new InsertTableRowIntoDifferentSectionStrategy());
@@ -7919,6 +7921,694 @@ class VegaRTEHorizontalLineExtension extends linkExtension.VegaRTEExtension {
 })();
 VegaRTEHorizontalLineExtension.TOOLBAR_BUTTON_KEY = 'horizontalLine';
 
+var RTEBlockquoteExtensionAnnotationTypeEnum;
+(function (RTEBlockquoteExtensionAnnotationTypeEnum) {
+  RTEBlockquoteExtensionAnnotationTypeEnum["BLOCKQUOTE"] = "BLOCKQUOTE";
+})(RTEBlockquoteExtensionAnnotationTypeEnum || (RTEBlockquoteExtensionAnnotationTypeEnum = {}));
+/**
+ * CSS class applied to `<blockquote>` elements rendered inside the editor.
+ */
+const BLOCKQUOTE_CLASS_NAME = 'v-rte-blockquote';
+/**
+ * Default visual styles for the `<blockquote>` element in the RTE.
+ */
+const BLOCKQUOTE_DEFAULT_STYLES = {
+  overflow: 'hidden',
+  marginInline: '0',
+  paddingInline: '24px',
+  borderInlineStart: 'solid 5px hsl(0, 0%, 80%)',
+};
+/**
+ * Blockquote annotation.
+ */
+class BlockquoteAnnotation extends codeBlock.BlockAnnotation {
+  constructor() {
+    super(...arguments);
+    this.type = RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE;
+  }
+  /**
+   * Generate the map item for the annotation.
+   *
+   * @returns {[RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE, BlockquoteAnnotation]} Map item.
+   */
+  static from() {
+    return [RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE, new BlockquoteAnnotation()];
+  }
+  /**
+   * Get the default CSS rule for the blockquote element.
+   *
+   * @returns {string} The default CSS rule.
+   */
+  static getDefaultCssText() {
+    const declarations = Object.entries(BLOCKQUOTE_DEFAULT_STYLES)
+      .map(([key, value]) => `\t${string.camelToDashCase(key)}: ${value};`)
+      .join('\n');
+    return `.${BLOCKQUOTE_CLASS_NAME} {\n${declarations}\n}`;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    // Blockquote identity is captured by the block type; nothing to serialize.
+    return null;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone() {
+    return new BlockquoteAnnotation();
+  }
+  /**
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return BLOCKQUOTE_CLASS_NAME;
+  }
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return BLOCKQUOTE_DEFAULT_STYLES;
+  }
+}
+
+/**
+ * DTO representing a `<blockquote>` block.
+ */
+class RTEBlockquoteBlock extends codeBlock.RTEBlock {
+  constructor(id, options) {
+    super(id);
+    this.dtoName = RTEBlockquoteBlock.dtoName;
+    this.type = 'blockquote';
+    this.children = [];
+    const { autoMatchFormat = true } = options !== null && options !== void 0 ? options : {};
+    if (autoMatchFormat) {
+      this.annotationMap = new Map([BlockquoteAnnotation.from()]);
+    }
+  }
+  /**
+   * 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, options) {
+    const blockquote = new RTEBlockquoteBlock(block.id, options);
+    if (block.annotations) {
+      codeBlock.RTEBlock.convertAnnotationsToMap(blockquote.annotationMap, block.annotations);
+    }
+    blockquote.children = codeBlock.RTEBlock.generateBlockChildren(block.children, options, blockquote);
+    return blockquote;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    const cloned = new RTEBlockquoteBlock(this.id);
+    const clonedAsChildParent = cloned;
+    cloned.children = this.children.map((child) => child.clone(clonedAsChildParent));
+    cloned.annotationMap = this.cloneAnnotations();
+    cloned.parent = parent;
+    return cloned;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastNode() {
+    return this.children[this.children.length - 1].getLastNode();
+  }
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty() {
+    return this.children.length > 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  toHtml(options) {
+    const attrStr = this.generateAttributeString(options);
+    const inner = this.children.map((child) => child.toHtml(options)).join('');
+    return `<blockquote${attrStr}>${inner}</blockquote>`;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: 'blockquote', children: this.children.map((child) => child.toJSON()) });
+  }
+}
+RTEBlockquoteBlock.dtoName = 'RTEBlockquoteBlock';
+
+/**
+ * Wrap the selected blocks into a new `<blockquote>` block while preserving
+ * their order.
+ */
+class BlockTransformToBlockquoteStrategy extends codeBlock.ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const selectedBlocks = action.selectedBlocks;
+    const children = target.children;
+    const selectedSet = new Set(selectedBlocks);
+    const firstIndex = children.indexOf(selectedBlocks[0]);
+    // The selected blocks may not be contiguous in `children` (e.g. a table
+    // sitting between two selected paragraphs must stay untouched), so the
+    // insert position is the first selected block's index, adjusted for any
+    // non-selected siblings that come before it.
+    const insertIndex = children
+      .slice(0, firstIndex)
+      .filter((block) => !selectedSet.has(block)).length;
+    const blockquote = new RTEBlockquoteBlock(misc.generateUUID());
+    blockquote.parent = target;
+    blockquote.children = selectedBlocks;
+    selectedBlocks.forEach((block) => {
+      block.parent = blockquote;
+    });
+    // Remove selected blocks individually rather than assuming a single
+    // contiguous run, so non-selected siblings interleaved with the
+    // selection (e.g. a table) are preserved instead of being spliced away.
+    for (let i = children.length - 1; i >= 0; i--) {
+      if (selectedSet.has(children[i])) {
+        children.splice(i, 1);
+      }
+    }
+    children.splice(insertIndex, 0, blockquote);
+  }
+}
+
+/**
+ * Unwrap a `<blockquote>` — lift its children to the parent in their original
+ * order and remove the blockquote.
+ */
+class RemoveBlockquoteStrategy extends codeBlock.ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(_action, target) {
+    const parent = target.parent;
+    const childrenToLift = [...target.children];
+    if (childrenToLift.length > 0) {
+      parent.apply(new codeBlock.InsertChildrenBeforeAction(target, ...childrenToLift));
+    }
+    parent.apply(new codeBlock.RemoveChildrenAction(target));
+  }
+}
+
+/**
+ * Lets the caret exit the blockquote via the keyboard. Pressing Enter on an empty
+ * trailing paragraph inside a blockquote (i.e. the second Enter press at the end of
+ * the quote) moves that empty paragraph out to a new paragraph after the blockquote,
+ * instead of stacking another empty line inside the quote.
+ */
+class BlockquoteExitOnEnterInterceptor extends ActionHandlerInterceptor {
+  /**
+   * Intercept only when the caret sits in an empty paragraph that is the last child of a blockquote.
+   *
+   * @param {InsertNewParagraphAction} _action - the action to be intercepted
+   * @param {RTETextBlock} target - the paragraph block receiving the Enter key press
+   * @returns {boolean} - whether the action should be intercepted
+   */
+  canIntercept(_action, target) {
+    const parent = target.parent;
+    return (parent instanceof RTEBlockquoteBlock &&
+      !target.isNotEmpty() &&
+      parent.children[parent.children.length - 1] === target);
+  }
+  /**
+   * Move the empty paragraph out of the blockquote and place a new paragraph after it.
+   *
+   * @param {ActionHandlerExecution} _execution - the original execution function
+   * @param {InsertNewParagraphAction} action - the action containing insert metadata
+   * @param {RTETextBlock} target - the empty paragraph block to move out of the blockquote
+   */
+  intercept(_execution, action, target) {
+    const blockquote = target.parent;
+    const newParagraph = this.createNewParagraph('');
+    if (newParagraph) {
+      // Insert the replacement paragraph after the blockquote before removing the
+      // empty one so the blockquote is still present as an anchor for the insert.
+      blockquote.parent.apply(new codeBlock.InsertChildrenAfterAction(blockquote, newParagraph));
+      blockquote.apply(new codeBlock.RemoveChildrenAction(target));
+      action.newBlock = newParagraph;
+    }
+  }
+  /**
+   * Create a new empty paragraph block.
+   *
+   * @param {string} text - paragraph text
+   * @returns {Nullable<RTETextBlock>} - paragraph block when paragraph dto class is available
+   */
+  createNewParagraph(text) {
+    const dtoClass = codeBlock.RTEDTOClassManager.getRTEBlockClass('paragraph');
+    if (dtoClass) {
+      return dtoClass.from({
+        id: misc.generateUUID(),
+        type: 'paragraph',
+        nodes: [{ id: misc.generateUUID(), type: 'text', text }],
+      });
+    }
+  }
+}
+
+/**
+ * Action type discriminator. Plain string constant — intentionally NOT added
+ * to {@link ModifyContentActionType} enum to keep the extension self-contained.
+ */
+const TRANSFORM_TO_BLOCKQUOTE = 'TRANSFORM_TO_BLOCKQUOTE';
+/**
+ * Wrap the supplied blocks into a new `<blockquote>` block while preserving
+ * their order. Strategy reads `selectedBlocks` and replaces them in-place
+ * with a single `RTEBlockquoteBlock` that adopts them as children.
+ */
+class TransformToBlockquoteAction extends codeBlock.ModifyContentAction {
+  constructor(selectedBlocks) {
+    super();
+    this.isFlushable = true;
+    this.type = TRANSFORM_TO_BLOCKQUOTE;
+    this.selectedBlocks = selectedBlocks;
+  }
+}
+
+/**
+ * Action type discriminator. Plain string constant — intentionally NOT added
+ * to {@link ModifyContentActionType} enum to keep the extension self-contained.
+ */
+const REMOVE_BLOCKQUOTE = 'REMOVE_BLOCKQUOTE';
+/**
+ * Unwrap a `<blockquote>` block — lift its children into the parent in place
+ * and remove the blockquote wrapper. Targets the blockquote block itself.
+ */
+class RemoveBlockquoteAction extends codeBlock.ModifyContentAction {
+  constructor() {
+    super(...arguments);
+    this.isFlushable = true;
+    this.type = REMOVE_BLOCKQUOTE;
+  }
+}
+
+/**
+ * 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.
+ */
+class BlockquoteToBlockquoteBlockStrategy extends contentState.ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray, currentIndex) {
+    return elementsArray[currentIndex].tagName === 'BLOCKQUOTE' ? 1 : 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray, options) {
+    const element = elementsArray[0];
+    const annotations = contentState.htmlElementToAnnotationGenerator.generate(RTEBlockquoteBlock, element, options);
+    return RTEBlockquoteBlock.from({
+      id: misc.generateUUID(),
+      type: 'blockquote',
+      annotations,
+      children: [],
+    }, options);
+  }
+  /**
+   * 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, childBlocks) {
+    const flattened = childBlocks.flatMap((child) => child instanceof RTEBlockquoteBlock ? child.children : [child]);
+    currentBlock.children = flattened.map((block) => {
+      block.parent = currentBlock;
+      return block;
+    });
+  }
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren() {
+    return true;
+  }
+}
+
+/**
+ * Renderer for blockquote blocks in the rich text editor.
+ */
+class RTEBlockquoteBlockRenderer extends linkExtension.VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(createElement, block, rteContext) {
+    var _a;
+    return createElement('blockquote', Object.assign({ key: block.id, class: block.getClasses(rteContext), style: block.getStyles(rteContext), ref: this.useRef(block) }, (_a = block.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.render()));
+  }
+  /**
+   * @inheritDoc
+   */
+  injectRTEScopeStyles() {
+    return BlockquoteAnnotation.getDefaultCssText();
+  }
+}
+const RTEBlockquoteBlockRenderer$1 = new RTEBlockquoteBlockRenderer();
+
+// FontAwesome 7.2.0 — `quote-left` (solid).
+const QuoteLeftIcon = {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><path fill="currentColor" d="M0 216C0 149.7 53.7 96 120 96l8 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-8 0c-30.9 0-56 25.1-56 56l0 8 64 0c35.3 0 64 28.7 64 64l0 64c0 35.3-28.7 64-64 64l-64 0c-35.3 0-64-28.7-64-64L0 216zm256 0c0-66.3 53.7-120 120-120l8 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-8 0c-30.9 0-56 25.1-56 56l0 8 64 0c35.3 0 64 28.7 64 64l0 64c0 35.3-28.7 64-64 64l-64 0c-35.3 0-64-28.7-64-64l0-136z"/></svg>`,
+};
+
+/**
+ * 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}).
+ */
+class RTEBlockquoteToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  /**
+   * @inheritDoc
+   */
+  render(createElement, editorContext) {
+    return this.renderButton(createElement, editorContext, {
+      icon: 'quote-left',
+      tooltip: { text: 'Block quote' },
+    });
+  }
+  /**
+   * @inheritDoc
+   */
+  isSelected(editorContext) {
+    const startNode = this.getStartNode(editorContext);
+    return startNode ? this.findBlockquoteAncestor(startNode) !== null : false;
+  }
+  /**
+   * @inheritDoc
+   */
+  isDisabled(editorContext) {
+    if (editorContext.host.disabled) {
+      return true;
+    }
+    const startNode = this.getStartNode(editorContext);
+    // No selection — click appends a new blockquote at the end.
+    // Inside a blockquote — click toggles it off.
+    // Either way, the button stays enabled.
+    if (!startNode || this.findBlockquoteAncestor(startNode) !== null) {
+      return false;
+    }
+    const { container } = this.resolveWrapAnchor(startNode.parent);
+    return !codeBlock.ActionHandleStrategyRegistry.canHandle(TRANSFORM_TO_BLOCKQUOTE, container);
+  }
+  /**
+   * @inheritDoc
+   */
+  handleButtonClick(editorContext) {
+    const context = this.getExtensionContext(editorContext.host);
+    if (context) {
+      const { host, getSelectedNodes } = context;
+      const selectedNodes = getSelectedNodes();
+      const startNode = selectedNodes[0];
+      if (!startNode) {
+        // No active selection → append a new empty blockquote at the end (mirrors text-style toolbar).
+        this.appendEmptyBlockquote(host.value);
+        return;
+      }
+      // Direction is decided by the first selected block only.
+      if (this.findBlockquoteAncestor(startNode)) {
+        const blockquoteAncestors = this.collectBlockquoteAncestors(selectedNodes);
+        blockquoteAncestors.forEach((blockquote) => {
+          blockquote.apply(new RemoveBlockquoteAction());
+        });
+      }
+      else {
+        this.wrapSelectedBlocks(selectedNodes);
+      }
+      host.value.apply(new contentState.UpdateCursorPositionAction(startNode, editorContext.rteRange.startOffset));
+    }
+  }
+  /* istanbul ignore next */
+  /**
+   * @inheritDoc
+   */
+  handleDropdownClick() {
+    // No dropdown — single toggle button.
+  }
+  /**
+   * 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.
+   */
+  appendEmptyBlockquote(content) {
+    if (content.children.length > 0) {
+      const lastBlock = content.children[content.children.length - 1];
+      const newBlock = codeBlock.RTETextBlock.from({
+        id: misc.generateUUID(),
+        type: 'paragraph',
+        nodes: [{ id: misc.generateUUID(), type: 'text', text: '' }],
+      });
+      content.apply(new codeBlock.InsertChildrenAfterAction(lastBlock, newBlock));
+      content.apply(new TransformToBlockquoteAction([newBlock]));
+      content.apply(new contentState.UpdateCursorPositionAction(newBlock.getLastNode(), 0));
+    }
+  }
+  /**
+   * 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.
+   */
+  wrapSelectedBlocks(selectedNodes) {
+    var _a, _b;
+    const uniqueBlocks = this.getUniqueBlocks(selectedNodes);
+    // If the selection spans more than one top-level block, force every
+    // anchor resolution to escalate all the way to the root, ignoring any
+    // scoped container (e.g. a table cell) it passes through.
+    const rootAncestors = new Set(uniqueBlocks.map((block) => { var _a; return (_a = this.resolveWrapAnchor(block, true).wrapBlock) !== null && _a !== void 0 ? _a : block; }));
+    const forceRootScope = rootAncestors.size > 1;
+    // Pass 1: unwrap any existing blockquote reachable from the selection so it merges instead of nesting.
+    const alreadyUnwrapped = new Set();
+    for (const block of uniqueBlocks) {
+      const { wrapBlock } = this.resolveWrapAnchor(block, forceRootScope);
+      if (wrapBlock instanceof RTEBlockquoteBlock && !alreadyUnwrapped.has(wrapBlock)) {
+        alreadyUnwrapped.add(wrapBlock);
+        wrapBlock.apply(new RemoveBlockquoteAction());
+      }
+    }
+    // Pass 2: group targets by their resolved container so each container is wrapped independently.
+    const containerMap = new Map();
+    for (const block of uniqueBlocks) {
+      const anchor = this.resolveWrapAnchor(block, forceRootScope);
+      const { container } = anchor;
+      if (container) {
+        const target = (_a = anchor.wrapBlock) !== null && _a !== void 0 ? _a : block;
+        const targets = (_b = containerMap.get(container)) !== null && _b !== void 0 ? _b : new Set();
+        targets.add(target);
+        containerMap.set(container, targets);
+      }
+    }
+    for (const [container, targets] of containerMap) {
+      container.apply(new TransformToBlockquoteAction([...targets]));
+    }
+  }
+  /**
+   * 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.
+   */
+  getStartNode(editorContext) {
+    const context = this.getExtensionContext(editorContext.host);
+    return context === null || context === void 0 ? void 0 : context.getSelectedNodes()[0];
+  }
+  /**
+   * 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.
+   */
+  collectBlockquoteAncestors(nodes) {
+    const ancestors = new Set();
+    nodes.forEach((node) => {
+      const ancestor = this.findBlockquoteAncestor(node);
+      if (ancestor) {
+        ancestors.add(ancestor);
+      }
+    });
+    return ancestors;
+  }
+  /**
+   * 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.
+   */
+  findBlockquoteAncestor(node) {
+    let current = node.parent;
+    while (current && !(current instanceof contentState.VegaRTEContent)) {
+      if (current instanceof RTEBlockquoteBlock) {
+        return current;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+  /**
+   * 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.
+   */
+  getUniqueBlocks(nodes) {
+    const seen = new Set();
+    const result = [];
+    nodes.forEach((node) => {
+      const block = node.parent;
+      if (block && !seen.has(block)) {
+        seen.add(block);
+        result.push(block);
+      }
+    });
+    return result;
+  }
+  /**
+   * 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.
+   */
+  resolveWrapAnchor(block, forceRootScope = false) {
+    let current = block;
+    while (current.parent &&
+      !(current.parent instanceof contentState.VegaRTEContent) &&
+      (forceRootScope ||
+        !codeBlock.ActionHandleStrategyRegistry.canHandle(TRANSFORM_TO_BLOCKQUOTE, current.parent))) {
+      current = current.parent;
+    }
+    const wrapBlock = current !== block ? current : null;
+    const container = current.parent;
+    return { wrapBlock, container };
+  }
+}
+(() => {
+  internalIconManager.VegaInternalIconManager.register({ 'quote-left': QuoteLeftIcon });
+})();
+
+/**
+ * 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.
+ */
+class BlockquoteFilterStylesStrategy extends codeBlock.RTEFilterStylesStrategy {
+  constructor() {
+    super(...arguments);
+    this.stylesToBeFiltered = BLOCKQUOTE_DEFAULT_STYLES;
+    this.elementTagName = 'blockquote';
+  }
+  /**
+   * 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.
+   */
+  static isBlockquoteBlock(className) {
+    return className === 'RTEBlockquoteBlock';
+  }
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance) {
+    return BlockquoteFilterStylesStrategy.isBlockquoteBlock(blockOrNodeInstance.dtoName);
+  }
+  /**
+   * @inheritDoc
+   */
+  canRefill(_blockOrNodeClassName, element) {
+    return element.tagName.toLowerCase() === this.elementTagName;
+  }
+  /**
+   * @inheritDoc
+   */
+  toCssText() {
+    return this.buildCssTextForStyles(this.elementTagName, this.classNameToBeAdded);
+  }
+}
+
+/**
+ * Adds `<blockquote>` support to the Vega Rich Text Editor.
+ */
+class VegaRTEBlockquoteExtension extends linkExtension.VegaRTEExtension {
+  constructor() {
+    super();
+    this.toolbarButtonRenderer = new RTEBlockquoteToolbarButtonRenderer();
+    this.registerBlockBasicStrategies(RTEBlockquoteBlock.name);
+    this.registerNode('blockquote', RTEBlockquoteBlock);
+    this.registerRenderer('blockquote', RTEBlockquoteBlockRenderer$1);
+    this.registerToolbarButtonRenderer(VegaRTEBlockquoteExtension.TOOLBAR_BUTTON_KEY, this.toolbarButtonRenderer);
+    this.registerElementToBlockDTOClassStrategy(new BlockquoteToBlockquoteBlockStrategy());
+    // Register filter styles strategy for source edit round-trip.
+    linkExtension.VegaRTEExtension.registerFilterStylesStrategy(RTEBlockquoteBlock.dtoName, new BlockquoteFilterStylesStrategy());
+  }
+}
+(() => {
+  const wrapStrategy = new BlockTransformToBlockquoteStrategy();
+  // Root container — wrap top-level blocks.
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(contentState.VegaRTEContent.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  // Table cells (body + header) — wrap is scoped to the closest cell.
+  // Other container blocks (code, list item, function) are intentionally
+  // not registered, so the toolbar stays disabled inside them.
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableCellBlock.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(splitCellOperation.RTETableHeadCellBlock.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(RTEBlockquoteBlock.name, REMOVE_BLOCKQUOTE, new RemoveBlockquoteStrategy());
+  // Enables exiting the blockquote via the keyboard: pressing Enter on an empty
+  // trailing paragraph breaks out to a new paragraph after the blockquote.
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(codeBlock.RTETextBlock.name, codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, new BlockquoteExitOnEnterInterceptor());
+})();
+VegaRTEBlockquoteExtension.TOOLBAR_BUTTON_KEY = 'blockquote';
+
 const ARROW_CHARACTERS = [
   { character: '←', title: 'leftwards simple arrow' },
   { character: '→', title: 'rightwards simple arrow' },
@@ -10040,6 +10730,599 @@ class VegaRTELineHeightExtension extends linkExtension.VegaRTEExtension {
 })();
 VegaRTELineHeightExtension.TOOLBAR_BUTTON_KEY = 'lineHeight';
 
+const paste = {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Pro 6.3.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><path fill="currentColor" d="M80 96v16c0 17.7 14.3 32 32 32h60.8c16.6-28.7 47.6-48 83.2-48h62c-7.1-27.6-32.2-48-62-48H215.4C211.6 20.9 188.2 0 160 0s-51.6 20.9-55.4 48H64C28.7 48 0 76.7 0 112V384c0 35.3 28.7 64 64 64h96V400H64c-8.8 0-16-7.2-16-16V112c0-8.8 7.2-16 16-16H80zm64-40a16 16 0 1 1 32 0 16 16 0 1 1 -32 0zM256 464c-8.8 0-16-7.2-16-16V192c0-8.8 7.2-16 16-16H384v48c0 17.7 14.3 32 32 32h48V448c0 8.8-7.2 16-16 16H256zm192 48c35.3 0 64-28.7 64-64V227.9c0-12.7-5.1-24.9-14.1-33.9l-51.9-51.9c-9-9-21.2-14.1-33.9-14.1H256c-35.3 0-64 28.7-64 64V448c0 35.3 28.7 64 64 64H448z"/></svg>`,
+};
+
+/**
+ * Renders and manages the paste format chooser UI.
+ */
+class RTEPasteChooserUI {
+  constructor(hostRoot, callbacks) {
+    this.hostRoot = hostRoot;
+    this.callbacks = callbacks;
+    this.chooserEl = null;
+    this.dropdownEl = null;
+    this.triggerButtonEl = null;
+  }
+  /**
+   * Opens the paste-mode chooser at the given position.
+   *
+   * @param {PasteChooserPosition} position Viewport position for the chooser.
+   */
+  open(position) {
+    this.destroy();
+    const doc = this.hostRoot.ownerDocument;
+    const chooser = doc.createElement('div');
+    chooser.setAttribute(RTEPasteChooserUI.CHOOSER_ATTR, 'true');
+    chooser.style.position = 'fixed';
+    chooser.style.zIndex = '1000';
+    chooser.style.left = `${position.left}px`;
+    chooser.style.top = `${position.top}px`;
+    const dropdownEl = this.createPasteChooserDropdown(doc, position.placement);
+    dropdownEl.placement = position.placement;
+    chooser.append(dropdownEl);
+    this.hostRoot.appendChild(chooser);
+    this.chooserEl = chooser;
+    this.dropdownEl = dropdownEl;
+    dropdownEl.addEventListener('vegaShow', () => {
+      if (this.triggerButtonEl) {
+        this.triggerButtonEl.selected = true;
+      }
+    });
+    dropdownEl.addEventListener('vegaHide', () => {
+      if (this.triggerButtonEl) {
+        this.triggerButtonEl.selected = false;
+      }
+    });
+  }
+  /**
+   * Removes the chooser from the DOM.
+   */
+  destroy() {
+    var _a;
+    if (this.dropdownEl && typeof this.dropdownEl.hide === 'function') {
+      void this.dropdownEl.hide();
+    }
+    if ((_a = this.chooserEl) === null || _a === void 0 ? void 0 : _a.parentNode) {
+      this.chooserEl.parentNode.removeChild(this.chooserEl);
+    }
+    if (this.triggerButtonEl) {
+      this.triggerButtonEl.selected = false;
+    }
+    this.dropdownEl = null;
+    this.chooserEl = null;
+    this.triggerButtonEl = null;
+  }
+  /**
+   * 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) {
+    if (!this.chooserEl) {
+      return false;
+    }
+    const isDropdownContentClick = eventPath.some((target) => {
+      return 'tagName' in target && target.tagName === 'VEGA-DROPDOWN-CONTENT-BOX';
+    });
+    return eventPath.includes(this.chooserEl) || isDropdownContentClick;
+  }
+  /**
+   * 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.
+   */
+  createPasteChooserDropdown(doc, placement) {
+    const dropdownEl = doc.createElement('vega-dropdown');
+    dropdownEl.trigger = 'click';
+    dropdownEl.selectType = 'single';
+    dropdownEl.selectedSourceKey = 'rich';
+    dropdownEl.maxWidth = 220;
+    dropdownEl.alignment = 'start';
+    dropdownEl.itemDisplayRule = 'ellipsis';
+    const triggerButton = doc.createElement('vega-rich-text-editor-toolbar-button');
+    const arrowIcon = placement[0] === 'top' ? 'chevron-up' : 'chevron-down';
+    triggerButton.setAttribute(RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR, 'true');
+    triggerButton.setAttribute('aria-label', internalTranslationController.VegaInternalTranslation.t('Paste options'));
+    triggerButton.setAttribute('arrow-icon', arrowIcon);
+    triggerButton.icon = 'rte-paste';
+    triggerButton.showArrowIcon = true;
+    triggerButton.selected = false;
+    this.triggerButtonEl = triggerButton;
+    const tooltipEl = doc.createElement('vega-tooltip');
+    tooltipEl.text = internalTranslationController.VegaInternalTranslation.t('Paste options');
+    tooltipEl.placement = ['bottom', 'top'];
+    tooltipEl.append(triggerButton);
+    dropdownEl.append(tooltipEl);
+    const itemsContainer = doc.createElement('div');
+    itemsContainer.setAttribute('slot', 'items');
+    itemsContainer.append(this.createDropdownItem(doc, 'rich', internalTranslationController.VegaInternalTranslation.t('Use rich text'), RTEPasteChooserUI.CHOOSER_RICH_ATTR));
+    dropdownEl.append(itemsContainer);
+    dropdownEl.addEventListener('vegaDropdownClick', (event) => {
+      const mode = event.detail;
+      if (mode === 'rich') {
+        this.callbacks.onModeSelect(mode);
+      }
+    });
+    return dropdownEl;
+  }
+  /**
+   * 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.
+   */
+  createDropdownItem(doc, key, label, dataAttrName) {
+    const itemEl = doc.createElement('vega-dropdown-item');
+    itemEl.itemKey = key;
+    itemEl.label = label;
+    itemEl.setAttribute(dataAttrName, 'true');
+    return itemEl;
+  }
+}
+(() => {
+  internalIconManager.VegaInternalIconManager.register({
+    'rte-paste': paste,
+  });
+})();
+RTEPasteChooserUI.CHOOSER_ATTR = 'data-rte-paste-chooser';
+RTEPasteChooserUI.CHOOSER_RICH_ATTR = 'data-rte-paste-type-rich';
+RTEPasteChooserUI.CHOOSER_TRIGGER_ATTR = 'data-rte-paste-trigger';
+
+/**
+ * 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.
+ */
+const RTE_PASTE_MODE_DATA_TYPE = 'application/x-vega-rte-paste-mode';
+
+/**
+ * Vega Rich Text Editor paste extension.
+ * Intercepts keyboard paste and allows users to choose paste mode.
+ */
+class VegaRTEPasteExtension extends linkExtension.VegaRTEExtension {
+  constructor() {
+    super(...arguments);
+    this.editableEl = null;
+    this.contentHostEl = null;
+    this.chooserUI = null;
+    this.pendingPastePayload = null;
+    this.listenerDocument = null;
+    this.listenerWindow = null;
+    /**
+     * Handles a native paste event by capturing the clipboard payload and
+     * rendering the paste-mode chooser.
+     *
+     * @param {ClipboardEvent} event Native clipboard paste event.
+     */
+    this.handlePasteEvent = (event) => {
+      var _a, _b;
+      const clipboardData = event.clipboardData;
+      if (!clipboardData) {
+        return;
+      }
+      // HTML is sanitized via DOMParser and ElementToDtoStrategyProcessor pipeline
+      const html = clipboardData.getData('text/html') || '';
+      const text = clipboardData.getData('text/plain') || '';
+      if (!html && !text) {
+        // Empty clipboard paste should not mutate editor content.
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      const range = this.cloneCurrentSelectionRange();
+      const selectedNodes = ((_b = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelectedNodes) === null || _b === void 0 ? void 0 : _b.call(_a)) || [];
+      this.pendingPastePayload = { html, text, range, selectedNodes: [...selectedNodes] };
+      this.renderPasteChooser(event);
+    };
+    /**
+     * Dismisses the chooser when a pointer interaction occurs outside of it.
+     *
+     * @param {Event} event Pointer event captured on the document.
+     */
+    this.handleOutsidePointerDown = (event) => {
+      if (!this.chooserUI) {
+        return;
+      }
+      const eventPath = typeof event.composedPath === 'function' ? event.composedPath() : [];
+      if (this.chooserUI.includesEventPath(eventPath)) {
+        return;
+      }
+      this.clearPasteChooser();
+    };
+    /**
+     * Dismisses the chooser when the Escape key is pressed.
+     *
+     * @param {KeyboardEvent} event Keyboard event captured on the document.
+     */
+    this.handleOutsideKeyDown = (event) => {
+      if (event.key === 'Escape') {
+        this.clearPasteChooser();
+      }
+    };
+    /**
+     * Dismisses the chooser when any relevant scroll container scrolls.
+     */
+    this.handleOutsideScroll = () => {
+      this.clearPasteChooser();
+    };
+  }
+  /** @inheritDoc */
+  initialExtensionAfterLoad(context) {
+    super.initialExtensionAfterLoad(context);
+    this.hostEl = context.host;
+    this.attachPasteListener();
+  }
+  /** @inheritDoc */
+  destroyExtension() {
+    this.detachPasteListener();
+    this.clearPasteChooser();
+  }
+  /**
+   * Attaches the paste listener to the editable element.
+   */
+  attachPasteListener() {
+    const { editableEl, contentHostEl, } = this.getEditorElements();
+    this.editableEl = editableEl;
+    this.contentHostEl = contentHostEl;
+    if (this.editableEl) {
+      this.editableEl.addEventListener('paste', this.handlePasteEvent);
+    }
+  }
+  /**
+   * Detaches the paste listener from the editable element.
+   */
+  detachPasteListener() {
+    if (this.editableEl) {
+      this.editableEl.removeEventListener('paste', this.handlePasteEvent);
+    }
+    this.editableEl = null;
+    this.contentHostEl = null;
+  }
+  /**
+   * Resolves the content host and editable element from the host shadow tree.
+   *
+   * @returns {EditorElements} Editor elements.
+   */
+  getEditorElements() {
+    var _a, _b, _c, _d, _e;
+    const contentHostEl = (_c = (_b = (_a = this.hostEl) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('vega-rich-text-content')) !== null && _c !== void 0 ? _c : null;
+    const editableEl = (_e = (_d = contentHostEl === null || contentHostEl === void 0 ? void 0 : contentHostEl.shadowRoot) === null || _d === void 0 ? void 0 : _d.querySelector('.rich-text-content')) !== null && _e !== void 0 ? _e : null;
+    return { editableEl, contentHostEl };
+  }
+  /**
+   * Resolves the editable content element from the host shadow tree.
+   *
+   * @returns {HTMLDivElement | null} Editable element or `null` when unavailable.
+   */
+  getEditableElement() {
+    const { editableEl } = this.getEditorElements();
+    return editableEl;
+  }
+  /**
+   * 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.
+   */
+  cloneCurrentSelectionRange() {
+    var _a;
+    const selection = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelection();
+    if (selection && selection.rangeCount > 0) {
+      return selection.getRangeAt(0).cloneRange();
+    }
+    return null;
+  }
+  /**
+   * Renders the paste-mode chooser and wires up dismissal listeners.
+   *
+   * @param {ClipboardEvent} pasteEvent Originating paste event used for positioning.
+   */
+  renderPasteChooser(pasteEvent) {
+    var _a, _b;
+    const hostRoot = (_b = (_a = this.hostEl) === null || _a === void 0 ? void 0 : _a.shadowRoot) !== null && _b !== void 0 ? _b : null;
+    if (!hostRoot) {
+      return;
+    }
+    this.clearPasteChooser(false);
+    const position = this.computeChooserPosition(pasteEvent);
+    this.chooserUI = new RTEPasteChooserUI(hostRoot, {
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      onModeSelect: (mode) => {
+        this.applyPasteMode(mode);
+      },
+    });
+    this.chooserUI.open(position);
+    this.listenerDocument = this.hostEl.ownerDocument;
+    this.listenerWindow = this.listenerDocument.defaultView;
+    this.listenerDocument.addEventListener('mousedown', this.handleOutsidePointerDown, true);
+    this.listenerDocument.addEventListener('keydown', this.handleOutsideKeyDown, true);
+    this.listenerDocument.addEventListener('scroll', this.handleOutsideScroll, true);
+    if (this.listenerWindow) {
+      this.listenerWindow.addEventListener('scroll', this.handleOutsideScroll, true);
+    }
+    if (this.contentHostEl) {
+      this.contentHostEl.addEventListener('scroll', this.handleOutsideScroll);
+    }
+  }
+  /**
+   * 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.
+   */
+  computeChooserPosition(event) {
+    var _a, _b, _c;
+    const hostRect = this.hostEl.getBoundingClientRect();
+    const viewportHeight = (_b = (_a = this.hostEl.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.innerHeight) !== null && _b !== void 0 ? _b : window.innerHeight;
+    const pointerEvent = event;
+    const hasPointer = typeof pointerEvent.clientX === 'number' &&
+      pointerEvent.clientX > 0 &&
+      typeof pointerEvent.clientY === 'number' &&
+      pointerEvent.clientY > 0;
+    // For keyboard-initiated paste (Command/Control+V) clientX/Y are 0, so anchor
+    // the chooser to the current caret instead of a fixed host-relative spot.
+    const caretRect = hasPointer ? null : this.getCaretRect();
+    const CHOOSER_GAP_PX = 8;
+    const CHOOSER_MIN_MARGIN_PX = 12;
+    const CHOOSER_WIDTH_PX = 220;
+    const CHOOSER_FALLBACK_OFFSET_PX = 40;
+    const CHOOSER_MIN_VISIBLE_BELOW_SPACE_PX = 88;
+    const baseLeft = hasPointer
+      ? pointerEvent.clientX
+      : (_c = caretRect === null || caretRect === void 0 ? void 0 : caretRect.left) !== null && _c !== void 0 ? _c : hostRect.left + CHOOSER_MIN_MARGIN_PX;
+    const baseTop = hasPointer
+      ? pointerEvent.clientY
+      : caretRect
+        ? caretRect.bottom
+        : hostRect.top + CHOOSER_FALLBACK_OFFSET_PX;
+    const maxLeft = Math.max(hostRect.left + CHOOSER_MIN_MARGIN_PX, hostRect.right - CHOOSER_WIDTH_PX);
+    const left = Math.min(Math.max(baseLeft, hostRect.left + CHOOSER_MIN_MARGIN_PX), maxLeft);
+    const top = Math.max(baseTop + CHOOSER_GAP_PX, hostRect.top + CHOOSER_MIN_MARGIN_PX);
+    const availableBelow = viewportHeight - top - CHOOSER_MIN_MARGIN_PX;
+    const availableAbove = top - CHOOSER_MIN_MARGIN_PX;
+    const placement = availableBelow >= CHOOSER_MIN_VISIBLE_BELOW_SPACE_PX || availableBelow >= availableAbove
+      ? ['bottom', 'top']
+      : ['top', 'bottom'];
+    return { left, top, placement };
+  }
+  /**
+   * Resolves the bounding rect of the pending caret position.
+   *
+   * @returns {DOMRect | null} Caret rect or `null` when it cannot be determined.
+   */
+  getCaretRect() {
+    var _a, _b;
+    const range = (_b = (_a = this.pendingPastePayload) === null || _a === void 0 ? void 0 : _a.range) !== null && _b !== void 0 ? _b : this.cloneCurrentSelectionRange();
+    if (!range) {
+      return null;
+    }
+    const rect = range.getBoundingClientRect();
+    if (this.isUnavailableRect(rect)) {
+      // eslint-disable-next-line spellcheck/spell-checker
+      const domRectList = range.getClientRects();
+      if (domRectList.length > 0) {
+        return domRectList[0];
+      }
+      return this.getRangeContainerRect(range);
+    }
+    return rect;
+  }
+  /**
+   * Returns whether the browser could not resolve a meaningful caret rectangle.
+   *
+   * @param {DOMRect} rect Candidate caret rect.
+   * @returns {boolean} Whether the rect is unusable.
+   */
+  isUnavailableRect(rect) {
+    return rect.width === 0 && rect.height === 0 && rect.left === 0 && rect.top === 0;
+  }
+  /**
+   * 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.
+   */
+  getRangeContainerRect(range) {
+    var _a, _b, _c, _d, _e, _f;
+    const containerNode = (_a = range.startContainer) !== null && _a !== void 0 ? _a : null;
+    if (!containerNode) {
+      return null;
+    }
+    if (containerNode.nodeType === Node.ELEMENT_NODE) {
+      const containerElement = containerNode;
+      const previousNode = (_b = containerElement.childNodes[range.startOffset - 1]) !== null && _b !== void 0 ? _b : null;
+      const currentNode = (_c = containerElement.childNodes[range.startOffset]) !== null && _c !== void 0 ? _c : null;
+      return ((_e = (_d = this.getNodeRect(previousNode)) !== null && _d !== void 0 ? _d : this.getNodeRect(currentNode)) !== null && _e !== void 0 ? _e : this.getNodeRect(containerElement));
+    }
+    return (_f = this.getNodeRect(containerNode)) !== null && _f !== void 0 ? _f : this.getNodeRect(containerNode.parentNode);
+  }
+  /**
+   * Returns an element-backed rectangle from a DOM node.
+   *
+   * @param {Node | null} node Candidate node.
+   * @returns {DOMRect | null} Node rectangle when resolvable.
+   */
+  getNodeRect(node) {
+    var _a, _b;
+    if (!node) {
+      return null;
+    }
+    if (node.nodeType === Node.TEXT_NODE) {
+      return (_b = (_a = node.parentElement) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect()) !== null && _b !== void 0 ? _b : null;
+    }
+    if (node.nodeType === Node.ELEMENT_NODE) {
+      const rect = node.getBoundingClientRect();
+      return this.isUnavailableRect(rect) ? null : rect;
+    }
+    return null;
+  }
+  /**
+   * Applies the chosen paste mode by dispatching a synthetic paste input event.
+   *
+   * @param {PasteMode} mode Selected paste mode.
+   */
+  applyPasteMode(mode) {
+    var _a;
+    if (!this.pendingPastePayload) {
+      this.clearPasteChooser();
+      return;
+    }
+    const editableEl = (_a = this.editableEl) !== null && _a !== void 0 ? _a : this.getEditableElement();
+    if (!editableEl) {
+      this.clearPasteChooser();
+      return;
+    }
+    editableEl.focus();
+    this.restoreSelectionRange(this.pendingPastePayload.range);
+    this.restoreSelectionControllerState(this.pendingPastePayload);
+    const dataTransfer = this.createDataTransfer(this.pendingPastePayload.html, this.pendingPastePayload.text, mode);
+    this.dispatchBeforeInputPaste(editableEl, dataTransfer);
+    this.clearPasteChooser();
+  }
+  /**
+   * 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.
+   */
+  restoreSelectionControllerState(payload) {
+    if (!payload.range || !this.extensionContext) {
+      return;
+    }
+    const rangeOptions = {
+      startNode: payload.range.startContainer,
+      endNode: payload.range.endContainer,
+      startOffset: payload.range.startOffset,
+      endOffset: payload.range.endOffset,
+    };
+    this.extensionContext.setSelectedNodes(payload.selectedNodes || [], rangeOptions);
+  }
+  /**
+   * Restores a previously cloned selection range.
+   *
+   * @param {Range | null} range Range to restore.
+   */
+  restoreSelectionRange(range) {
+    var _a;
+    if (!range) {
+      return;
+    }
+    const selection = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelection();
+    if (selection) {
+      selection.removeAllRanges();
+      selection.addRange(range);
+    }
+  }
+  /**
+   * Dispatches a synthetic `beforeinput` paste event into the editor pipeline.
+   *
+   * @param {HTMLDivElement} editableEl Editable content element.
+   * @param {DataTransfer} dataTransfer Clipboard payload for the paste.
+   */
+  dispatchBeforeInputPaste(editableEl, dataTransfer) {
+    // This synthetic beforeinput event intentionally reuses the existing
+    // UserInputController -> insertFromPaste -> InsertPasteHandler pipeline.
+    const beforeInputEvent = new CustomEvent('beforeinput', {
+      bubbles: true,
+      cancelable: true,
+    });
+    try {
+      Object.defineProperties(beforeInputEvent, {
+        inputType: {
+          value: 'insertFromPaste',
+          configurable: true,
+        },
+        dataTransfer: {
+          value: dataTransfer,
+          configurable: true,
+        },
+      });
+    }
+    catch (_a) {
+      Object.assign(beforeInputEvent, {
+        inputType: 'insertFromPaste',
+        dataTransfer,
+      });
+    }
+    editableEl.dispatchEvent(beforeInputEvent);
+  }
+  /**
+   * 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.
+   */
+  createDataTransfer(html, text, mode) {
+    if (typeof DataTransfer !== 'undefined') {
+      const dataTransfer = new DataTransfer();
+      if (html) {
+        dataTransfer.setData('text/html', html);
+      }
+      if (text) {
+        dataTransfer.setData('text/plain', text);
+      }
+      if (mode) {
+        dataTransfer.setData(RTE_PASTE_MODE_DATA_TYPE, mode);
+      }
+      return dataTransfer;
+    }
+    return {
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      getData: (type) => {
+        if (type === 'text/html') {
+          return html;
+        }
+        if (type === 'text/plain') {
+          return text;
+        }
+        if (type === RTE_PASTE_MODE_DATA_TYPE) {
+          return mode !== null && mode !== void 0 ? mode : '';
+        }
+        return '';
+      },
+    };
+  }
+  /**
+   * Tears down the chooser UI and removes dismissal listeners.
+   *
+   * @param {boolean} [clearPayload] Whether to also clear the pending payload.
+   */
+  clearPasteChooser(clearPayload = true) {
+    if (this.contentHostEl) {
+      this.contentHostEl.removeEventListener('scroll', this.handleOutsideScroll);
+    }
+    if (this.listenerWindow) {
+      this.listenerWindow.removeEventListener('scroll', this.handleOutsideScroll, true);
+      this.listenerWindow = null;
+    }
+    if (this.listenerDocument) {
+      this.listenerDocument.removeEventListener('mousedown', this.handleOutsidePointerDown, true);
+      this.listenerDocument.removeEventListener('keydown', this.handleOutsideKeyDown, true);
+      this.listenerDocument.removeEventListener('scroll', this.handleOutsideScroll, true);
+      this.listenerDocument = null;
+    }
+    if (this.chooserUI) {
+      this.chooserUI.destroy();
+    }
+    this.chooserUI = null;
+    if (clearPayload) {
+      this.pendingPastePayload = null;
+    }
+  }
+}
+
 /**
  * Action to extract the currently selected content (HTML and plain text) from the editor.
  *
@@ -10560,6 +11843,7 @@ VegaRTETokenExtension.TOOLBAR_BUTTON_KEY = 'token';
 exports.ActionHandlerInterceptor = ActionHandlerInterceptor;
 exports.DeleteSelectedContentAction = DeleteSelectedContentAction;
 exports.InsertNodeToNearestRootAction = InsertNodeToNearestRootAction;
+exports.RTEBlockquoteBlock = RTEBlockquoteBlock;
 exports.RTELanguageToolbarButtonRenderer = RTELanguageToolbarButtonRenderer;
 exports.RTETokenNode = RTETokenNode;
 exports.RTETokenNodeRenderer = RTETokenNodeRenderer;
@@ -10568,6 +11852,7 @@ exports.VegaCalendarPeriodFactory = VegaCalendarPeriodFactory;
 exports.VegaEventManager = VegaEventManager$1;
 exports.VegaLoader = VegaLoader;
 exports.VegaNotify = VegaNotify;
+exports.VegaRTEBlockquoteExtension = VegaRTEBlockquoteExtension;
 exports.VegaRTECopyExtension = VegaRTECopyExtension;
 exports.VegaRTECutExtension = VegaRTECutExtension;
 exports.VegaRTEDefaultLineHeightOptions = VegaRTEDefaultLineHeightOptions;
@@ -10576,6 +11861,7 @@ exports.VegaRTEFunctionExtension = VegaRTEFunctionExtension;
 exports.VegaRTEHorizontalLineExtension = VegaRTEHorizontalLineExtension;
 exports.VegaRTELanguageExtension = VegaRTELanguageExtension;
 exports.VegaRTELineHeightExtension = VegaRTELineHeightExtension;
+exports.VegaRTEPasteExtension = VegaRTEPasteExtension;
 exports.VegaRTESpecialCharactersArrows = VegaRTESpecialCharactersArrows;
 exports.VegaRTESpecialCharactersCurrency = VegaRTESpecialCharactersCurrency;
 exports.VegaRTESpecialCharactersEssentials = VegaRTESpecialCharactersEssentials;