@globalpayments/vega 2.58.0 → 2.59.0

package/dist/esm/content-state-a43e703e.js

@@ -1,1146 +0,0 @@
-import { B as BlockDeleteNodeContentStrategy, R as RemoveChildAction, a as RTEImageNode, A as ActionHandleStrategy, b as ReplaceChildNodesAction, I as InsertBlocksAfterAction, c as AppendChildNodesAction, d as RTETextBlock, e as InsertBlocksBeforeAction, S as SplitBlockWithNodeAction, M as ModifyContentAction, f as ModifyContentActionType, g as RTETextNode, h as BlockReplaceNodeWithNodesStrategy, i as RTEBlock, j as ActionHandleStrategyRegistry, k as BlockMergeNodesStrategy, l as BlockRemoveNodeStrategy, m as BlockAppendNodesStrategy, n as BlockReplaceNodesStrategy, o as BlockInsertNodesBeforeNodeStrategy, p as BlockDeleteTextContentStrategy, N as NodeAnnotationTypeEnum, q as BlockInsertLineBreakStrategy, r as BlockInsertLineBreakWithBlocksStrategy, s as BlockSplitWithTextNodeStrategy, t as SyncUpSelectionAction, u as RTECodeBlock } from './code-block-7bd4cb87.js';
-import { i as isNonNullable } from './type-guard-84b1f192.js';
-import { g as generateUUID } from './create-public-api-runtime-metrics-slimmer-bedf3a1e.js';
-
-/**
- * The image block delete the image node strategy.
- */
-class BlockDeleteImageStrategy extends BlockDeleteNodeContentStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    this.deleteNodeContent(action, target);
-  }
-  /**
-   * Deletes content from a block node based on specific conditions.
-   *
-   * @param {DeleteBlockContentAction} action - Delete block content action
-   * @param {RTEImageBlock} target - The image block.
-   */
-  deleteNodeContent(action, target) {
-    const startContainerNode = action
-      .startContainerNode, startOffset = action.startOffset;
-    let previousNode = this.getPreviousNode(startContainerNode);
-    let nextNode = null;
-    if (startOffset === 1) {
-      const parentBlock = target;
-      if (this.isContentFirstNode(startContainerNode)) {
-        nextNode = this.getNextNode(startContainerNode);
-      }
-      if (parentBlock.children.length === 1) {
-        parentBlock.parent.apply(new RemoveChildAction(parentBlock));
-      }
-      else {
-        parentBlock.apply(new RemoveChildAction(startContainerNode));
-      }
-    }
-    else {
-      const shouldRemoveNode = previousNode;
-      if (shouldRemoveNode && shouldRemoveNode instanceof RTEImageNode) {
-        previousNode = this.getPreviousNode(shouldRemoveNode);
-        shouldRemoveNode.parent.apply(new RemoveChildAction(shouldRemoveNode));
-        if (!previousNode) {
-          action.nextNode = startContainerNode;
-        }
-      }
-    }
-    if (previousNode) {
-      action.previousNode = previousNode;
-    }
-    else if (nextNode) {
-      action.nextNode = nextNode;
-    }
-  }
-}
-
-/**
- * Split the current image block with a special position strategy.
- */
-class BlockSplitWithImageNodeStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    action.newBlock = this.splitImageNodes(action.splitPointNode, action.startOffsetOfNode, target);
-  }
-  /**
-   * The image offset should be 0 or 1
-   * <vega-rich-text-image-editor><img /></vega-rich-text-image-editor>
-   *
-   * @param {RTEImageNode} imageNode The split point image node.
-   * @param {number} imageOffset The cursor point 0 | 1.
-   * @param {RTEImageBlock} target The image block.
-   * @returns {Nullable<RTEBlock>} The new block after split
-   */
-  splitImageNodes(imageNode, imageOffset, target) {
-    const nodesSplitIndex = target.children.indexOf(imageNode);
-    if (nodesSplitIndex > -1) {
-      const beforeNodes = target.children.slice(0, nodesSplitIndex + imageOffset);
-      const afterNodes = target.children.slice(nodesSplitIndex + imageOffset);
-      target.apply(new ReplaceChildNodesAction(beforeNodes));
-      const newBlock = this.cloneWithNodes(afterNodes, target);
-      target.parent.apply(new InsertBlocksAfterAction(target, newBlock));
-      return newBlock;
-    }
-  }
-  /**
-   * Creates a new RTEImageBlock instance with the provided RTEImageNode instances appended to it.
-   *
-   * @param {RTEImageNode[]} nodes - An array of RTEImageNode objects that will be used to create a new RTEImageBlock instance.
-   * @param {RTEImageBlock} target The image block.
-   * @returns {RTEImageBlock} A new `RTEImageBlock` object with the provided `nodes` appended to it.
-   */
-  cloneWithNodes(nodes, target) {
-    const block = target.createNewImageBlock();
-    block.children = [];
-    block.apply(new AppendChildNodesAction(nodes));
-    return block;
-  }
-}
-
-/**
- * Insert a new paragraph at the image block special position strategy.
- */
-class ImageInsertNewParagraphStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    action.newBlock = this.breakSingleBlock(action.startContainerNode, action.startOffset, target);
-  }
-  /**
-   * Used to split a block of text at a specific position and insert a new paragraph block.
-   *
-   * @param {RTEImageNode} splitNode - The node that needs to be split into separate blocks.
-   * @param {number} startOffsetOfNode - The index or position within the `splitNode` where the block should be broken or split.
-   * @param {RTEImageBlock} target - The image block.
-   * @returns {Nullable<RTEBlock>} Returns either a new paragraph block or the new block created after splitting the original block.
-   */
-  breakSingleBlock(splitNode, startOffsetOfNode, target) {
-    const newParagraph = RTETextBlock.from({
-      id: generateUUID(),
-      type: 'paragraph',
-      nodes: [{ id: generateUUID(), type: 'text', text: '' }],
-    });
-    if (this.isCaretPositionAtImageBlockEnd(target, splitNode, startOffsetOfNode)) {
-      target.parent.apply(new InsertBlocksAfterAction(target, newParagraph));
-    }
-    else if (this.isCaretPositionAtImageBlockStart(target, splitNode, startOffsetOfNode)) {
-      target.parent.apply(new InsertBlocksBeforeAction(target, newParagraph));
-    }
-    else {
-      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      target.apply(splitBlockAction);
-      return splitBlockAction.newBlock;
-    }
-    return newParagraph;
-  }
-}
-
-/**
- * Break the current block after press enter, this action is similar with the SplitBlockWithNodeAction,
- * The SplitBlockWithNodeAction split the current block to two same type blocks, but this action will create new paragraph or list item when break at start or end.
- * The property `newBlock` use to store the new create block if need.
- *
- * @example currentBlock.apply(new BreakSingleBlockAction(startContainerNode, startOffset))
- */
-class BreakSingleBlockAction extends ModifyContentAction {
-  constructor(startContainerNode, startOffset) {
-    super();
-    this.type = ModifyContentActionType.BREAK_SINGLE_BLOCK;
-    this.startContainerNode = startContainerNode;
-    this.startOffset = startOffset;
-  }
-}
-
-/**
- * The image block insert line break strategy.
- */
-class ImageInsertLineBreakStrategy extends ActionHandleStrategy {
-  /**
-   * The image block not support insert the line break node, so invoke the insert new paragraph logic directly.
-   *
-   * @param {LineBreakSingleBlockAction} action - The action instance.
-   * @param {RTEImageBlock} target - The image block.
-   */
-  handleAction(action, target) {
-    const insertNewParagraphAction = new BreakSingleBlockAction(action.startContainerNode, action.startOffset);
-    target.apply(insertNewParagraphAction);
-    const newBlock = insertNewParagraphAction.newBlock;
-    if (newBlock) {
-      action.lineBreakNode = newBlock.children[0];
-    }
-  }
-}
-
-/**
- * Insert a line break node into multiple blocks selection at special position strategy.
- */
-class ImageInsertLineBreakWithBlocksStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    action.lineBreakNode = this.lineBreakMultipleBlocks(action.selectedBlocks, target);
-  }
-  /**
-   * Inserts a new paragraph block with a line break after a selected block of text in a rich text editor.
-   *
-   * @param {RTEBlock[]} selectedBlocks - An array of RTEBlock objects that represent the blocks that have been selected for a specific action in the Rich Text Editor.
-   * @param {RTEImageBlock} target - The image block.
-   * @returns {Nullable<RTETextNode>} Returns a Nullable RTETextNode.
-   */
-  lineBreakMultipleBlocks(selectedBlocks, target) {
-    const newParagraph = RTETextBlock.from({
-      id: generateUUID(),
-      type: 'paragraph',
-      nodes: [{ id: generateUUID(), type: 'text', text: '\n' }],
-    });
-    target.parent.apply(new InsertBlocksAfterAction(target, newParagraph));
-    const afterNodes = this.concatBlocksNodes(selectedBlocks.slice(1));
-    if (afterNodes.length === 0 || (afterNodes[0] && afterNodes[0].text === '')) {
-      afterNodes.push(new RTETextNode(generateUUID(), '\n', newParagraph));
-    }
-    newParagraph.apply(new AppendChildNodesAction(afterNodes));
-    return newParagraph['children'][0];
-  }
-  /**
-   * Concat the child nodes of multiple RTEBlocks if both are not images.
-   *
-   * @param {RTEBlock[]} blocks - multiple block of content in a rich text editor, such as a paragraph, heading, image, etc.
-   * @returns {RTENode[]} Array of connected block nodes
-   */
-  concatBlocksNodes(blocks) {
-    const nodes = [];
-    blocks.map((block) => {
-      if (block.type !== 'image') {
-        nodes.push(...block.children);
-        block.parent.apply(new RemoveChildAction(block));
-      }
-    });
-    return nodes;
-  }
-}
-
-/**
- * Insert a image node at the special position of image block.
- */
-class ImageBlockInsertImageStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const splitNode = action.splitPointNode;
-    const startOffsetOfNode = action.startOffsetOfNode;
-    const newImageBlock = action.imageBlockToBeInserted;
-    const newImageNodes = newImageBlock.children;
-    if (target.children.length < 1) {
-      target.apply(new AppendChildNodesAction(newImageNodes));
-    }
-    else if (this.isCaretPositionAtImageBlockEnd(target, splitNode, startOffsetOfNode)) {
-      target.parent.apply(new InsertBlocksAfterAction(target, newImageBlock));
-    }
-    else if (this.isCaretPositionAtImageBlockStart(target, splitNode, startOffsetOfNode)) {
-      target.parent.apply(new InsertBlocksBeforeAction(target, newImageBlock));
-    }
-    else {
-      target.apply(new SplitBlockWithNodeAction(splitNode, startOffsetOfNode));
-      target.parent.apply(new InsertBlocksAfterAction(target, newImageBlock));
-    }
-  }
-}
-
-/**
- * Insert some text nodes at the behind of the node strategy.
- */
-class BlockInsertNodesAfterNodeStrategy extends BlockReplaceNodeWithNodesStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const referNode = action.referNode;
-    const nodes = [referNode, ...action.nodesToBeInserted];
-    this.replaceNodeWithNodes(target, referNode, nodes);
-  }
-}
-
-/**
- * Image block
- */
-class RTEImageBlock extends RTEBlock {
-  constructor(id) {
-    super(id);
-    this.type = 'image';
-    this.children = [];
-  }
-  /**
-   * Converts a VegaRTEImageBlock object into an RTEImageBlock object by mapping nodes and creating annotations.
-   *
-   * @param {VegaRTEImageBlock} block - The block object to be converted.
-   * @returns {RTEImageBlock} An instance of `RTEImageBlock`
-   */
-  static from(block) {
-    const imageBlock = new RTEImageBlock(block.id);
-    const { annotations } = block;
-    imageBlock.children = block.nodes.map((image) => RTEImageNode.from(image, imageBlock));
-    if (annotations) {
-      Object.entries(annotations).forEach(([type, value]) => {
-        const item = this.createAnnotationEntity(type, value);
-        if (isNonNullable(item)) {
-          imageBlock.annotationMap.set(...item);
-        }
-      });
-    }
-    return imageBlock;
-  }
-  /**
-   * @inheritDoc
-   */
-  toJSON() {
-    return Object.assign(Object.assign({}, super.toJSON()), { type: 'image', nodes: this.children.map((node) => node.toJSON()) });
-  }
-  /**
-   * @inheritDoc
-   */
-  isNotEmpty() {
-    return this.children.length > 0 && this.children.some((node) => node.url.length > 0);
-  }
-  /**
-   * @inheritDoc
-   */
-  getLastNode() {
-    return this.children[this.children.length - 1];
-  }
-  /**
-   * Create a new image block.
-   *
-   * @returns {RTEImageBlock} - The empty image block.
-   */
-  createNewImageBlock() {
-    return new RTEImageBlock(generateUUID());
-  }
-  /**
-   * @inheritDoc
-   */
-  clone() {
-    const clonedBlock = new RTEImageBlock(this.id);
-    clonedBlock.children = this.children.map((node) => {
-      const clonedNode = node.clone();
-      clonedNode.parent = clonedBlock;
-      return clonedNode;
-    });
-    clonedBlock.annotationMap = super.cloneAnnotations();
-    clonedBlock.parent = this.parent;
-    return clonedBlock;
-  }
-}
-(() => {
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_BLOCK_CONTENT, RTEImageBlock.name, new BlockDeleteImageStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTEImageBlock.name, new BlockMergeNodesStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, RTEImageBlock.name, new BlockRemoveNodeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, RTEImageBlock.name, new BlockAppendNodesStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_CHILD_NODES, RTEImageBlock.name, new BlockReplaceNodesStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTEImageBlock.name, new BlockSplitWithImageNodeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.BREAK_SINGLE_BLOCK, RTEImageBlock.name, new ImageInsertNewParagraphStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTEImageBlock.name, new ImageInsertLineBreakStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTEImageBlock.name, new ImageInsertLineBreakWithBlocksStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEImageBlock.name, new ImageBlockInsertImageStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_NODES_BEFORE, RTEImageBlock.name, new BlockInsertNodesBeforeNodeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_NODES_AFTER, RTEImageBlock.name, new BlockInsertNodesAfterNodeStrategy());
-})();
-
-/**
- * The list item block block delete text content strategy.
- */
-class ListItemDeleteTextContentStrategy extends BlockDeleteTextContentStrategy {
-  /**
-   * Delete the list item content and delete the parent list after delete the last item.
-   *
-   * @param {DeleteBlockContentAction} action - The delete block content action instance.
-   * @param {RTEListItemBlock} target - The list item block.
-   */
-  handleAction(action, target) {
-    const listBlock = target.parent;
-    this.deleteNodeContent(action, target);
-    if (listBlock.children.length === 0) {
-      listBlock.parent.apply(new RemoveChildAction(listBlock));
-    }
-  }
-}
-
-/**
- * Remove list item child node strategy.
- */
-class ListItemRemoveNodeStrategy extends ActionHandleStrategy {
-  /**
-   * Remove child node from the list item, remove the list item if the list item is empty.
-   *
-   * @param {RemoveChildAction} action - The remove child action instance.
-   * @param {RTEListItemBlock} target - The list item block.
-   */
-  handleAction(action, target) {
-    target.children = target.children.filter((node) => node !== action.entityToBeRemoved);
-    if (target.children.length === 0 && (!target.nestList || !target.nestList.length)) {
-      target.parent.apply(new RemoveChildAction(target));
-    }
-  }
-}
-
-/**
- * Remove list item nest list block strategy.
- */
-class ListItemRemoveNestListStrategy extends ActionHandleStrategy {
-  /**
-   * Remove the nest list block from the list item, clear the property children when the children is empty.
-   *
-   * @param {RemoveNestListAction} action - The action instance.
-   * @param {RTEListItemBlock} target - The list item block.
-   */
-  handleAction(action, target) {
-    if (target.nestList) {
-      if (target.nestList.length > 1) {
-        target.nestList = target.nestList.filter((child) => child !== action.nestListBlockToBeRemoved);
-      }
-      else {
-        target.nestList = undefined;
-      }
-    }
-  }
-}
-
-/**
- * Replace list item nest list strategy.
- */
-class ListItemReplaceNestListStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    action.newList.forEach((listBlock) => {
-      listBlock.parent = target;
-    });
-    target.nestList = action.newList;
-  }
-}
-
-/**
- * Insert new paragraph into current list item block at special position.
- */
-class ListItemInsertNewParagraphStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    action.newBlock = this.breakSingleListItemBlock(action.startContainerNode, action.startOffset, target);
-  }
-  /**
-   * Breaks a single list item block at a specific position.
-   *
-   * @param {RTETextNode} splitNode - The node that needs to be split within a list item block.
-   * @param {number} startOffsetOfNode - The index within the `splitNode` where the break operation should occur.
-   * @param {RTEListItemBlock} target - The list item block.
-   * @returns {Nullable<RTEBlock>} Returns either a new `RTEListItemBlock` if the caret
-   * position is at the end of the `splitNode`, or it returns the result of splitting the block at the
-   * caret position if it is neither at the start nor at the end.
-   */
-  breakSingleListItemBlock(splitNode, startOffsetOfNode, target) {
-    const newListItem = target.createNewListItem();
-    const newBreakNode = this.copyInlineStyleToNewNode(splitNode);
-    newListItem.apply(new AppendChildNodesAction([newBreakNode]));
-    if (this.isCaretPositionAtTextBlockEnd(target, splitNode, startOffsetOfNode)) {
-      return this.breakListItemAtEnd(newListItem, target);
-    }
-    else if (this.isCaretPositionAtTextBlockStart(target, splitNode, startOffsetOfNode)) {
-      target.parent.apply(new InsertBlocksBeforeAction(target, newListItem));
-    }
-    else {
-      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      target.apply(splitBlockAction);
-      return splitBlockAction.newBlock;
-    }
-    return newListItem;
-  }
-  /**
-   * Breaks a list item at the end and handles the insertion of a new list item or paragraph accordingly.
-   *
-   * @param {RTEListItemBlock} newListItem - Item that represents a new list item to be added to the existing list.
-   * @param {RTEListItemBlock} target - The list item block.
-   * @returns {RTEBlock} Returns a `RTEBlock`.
-   */
-  breakListItemAtEnd(newListItem, target) {
-    const lastItem = target.parent.children[target.parent.children.length - 1];
-    const currentItemIsEmpty = target.children.length === 1 && target.children[0].isEmpty();
-    if (target === lastItem && currentItemIsEmpty) {
-      const parentParent = target.parent.parent;
-      if (parentParent['type'] !== 'list-item') {
-        const newParagraph = RTETextBlock.from({
-          id: generateUUID(),
-          type: 'paragraph',
-          nodes: [],
-        });
-        newParagraph.apply(new AppendChildNodesAction(newListItem.children));
-        parentParent.apply(new InsertBlocksAfterAction(target.parent, newParagraph));
-        target.parent.apply(new RemoveChildAction(target));
-        return newParagraph;
-      }
-      else {
-        parentParent.parent.apply(new InsertBlocksAfterAction(parentParent, newListItem));
-        target.parent.apply(new RemoveChildAction(target));
-      }
-    }
-    else {
-      target.parent.apply(new InsertBlocksAfterAction(target, newListItem));
-    }
-    return newListItem;
-  }
-  /**
-   * Copy the inline style to new node
-   *
-   * @param {RTETextNode} needCopedNode - The node that needed to be copied to
-   * @returns {RTETextNode} Returns a `RTETextNode`.
-   */
-  copyInlineStyleToNewNode(needCopedNode) {
-    const textNode = needCopedNode.cloneWithText('');
-    // The link annotation doesn't need to inherit
-    textNode.annotationMap.delete(NodeAnnotationTypeEnum.LINK);
-    return textNode;
-  }
-}
-
-/**
- * Insert image node to list item block strategy.
- */
-class ListItemInsertImageStrategy extends ActionHandleStrategy {
-  /**
-   * The image node can not insert into list item block, so insert image after parent list block.
-   *
-   * @param {InsertImageToBlockAction} action - The action instance.
-   * @param {RTEListItemBlock} target - The list item block.
-   */
-  handleAction(action, target) {
-    target.parent.apply(action);
-  }
-}
-
-/**
- * List item block
- */
-class RTEListItemBlock extends RTETextBlock {
-  constructor(id, nestList) {
-    super(id, 'list-item');
-    /**
-     * TODO: Refactor the list item properties children and nestList, merge two properties together.
-     *
-     * 1. Update the type of `children` to include `RTEListBlock` as a possible type.
-     * 2. The list block children should text block array and nest list block array, The text block should wrap a `li` tag when rendering.
-     */
-    this.nestList = [];
-    this.nestList = nestList;
-  }
-  /**
-   * Converts a VegaRTEListItemBlock object to an RTEListItemBlock
-   *
-   * @param {VegaRTEListBlock} block - Converts a `VegaRTEListItemBlock` object into an `RTEListItemBlock`.
-   * @returns {RTEListItemBlock} Return an instance of `RTEListItemBlock`
-   */
-  static from(block) {
-    const listItemBlock = new RTEListItemBlock(block.id);
-    listItemBlock.children = block.nodes.map((richText) => RTETextNode.from(richText, listItemBlock));
-    if (block.children) {
-      listItemBlock.nestList = block.children.map((child) => {
-        const listBlock = RTEListBlock.from(child);
-        listBlock.parent = listItemBlock;
-        return listBlock;
-      });
-    }
-    const { annotations } = block;
-    if (annotations) {
-      Object.entries(annotations).forEach(([type, value]) => {
-        const item = this.createAnnotationEntity(type, value);
-        if (isNonNullable(item)) {
-          listItemBlock.annotationMap.set(...item);
-        }
-      });
-    }
-    return listItemBlock;
-  }
-  /**
-   * @inheritDoc
-   */
-  toJSON() {
-    var _a;
-    return Object.assign(Object.assign({}, super.toJSON()), { type: 'list-item', children: (_a = this.nestList) === null || _a === void 0 ? void 0 : _a.map((block) => block.toJSON()) });
-  }
-  /**
-   * @inheritDoc
-   */
-  cloneWithNodes(nodes) {
-    const block = new RTEListItemBlock(generateUUID());
-    block.children = [];
-    block.apply(new AppendChildNodesAction(nodes));
-    return block;
-  }
-  /**
-   * @inheritDoc
-   */
-  getLastNode() {
-    if (this.nestList && this.nestList.length > 0) {
-      const childListBlock = this.nestList[this.nestList.length - 1];
-      return childListBlock.getLastNode();
-    }
-    return super.getLastNode();
-  }
-  /**
-   * Create a new list item block.
-   *
-   * @returns {RTEListItemBlock} - A list item block.
-   */
-  createNewListItem() {
-    return new RTEListItemBlock(generateUUID());
-  }
-  /**
-   * @inheritDoc
-   */
-  clone() {
-    var _a;
-    const block = new RTEListItemBlock(this.id);
-    block.children = this.children.map((node) => {
-      const clonedNode = node.clone();
-      clonedNode.parent = block;
-      return clonedNode;
-    });
-    block.annotationMap = super.cloneAnnotations();
-    block.nestList = (_a = this.nestList) === null || _a === void 0 ? void 0 : _a.map((child) => {
-      const clonedChild = child.clone();
-      clonedChild.parent = block;
-      return clonedChild;
-    });
-    block.parent = this.parent;
-    return block;
-  }
-}
-(() => {
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_BLOCK_CONTENT, RTEListItemBlock.name, new ListItemDeleteTextContentStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTEListItemBlock.name, new BlockInsertLineBreakStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTEListItemBlock.name, new BlockInsertLineBreakWithBlocksStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, RTEListItemBlock.name, new ListItemRemoveNodeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_NEST_LIST, RTEListItemBlock.name, new ListItemRemoveNestListStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, RTEListItemBlock.name, new BlockAppendNodesStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTEListItemBlock.name, new BlockSplitWithTextNodeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_CHILD_NODES, RTEListItemBlock.name, new BlockReplaceNodesStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_NEST_LIST, RTEListItemBlock.name, new ListItemReplaceNestListStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTEListItemBlock.name, new BlockMergeNodesStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.BREAK_SINGLE_BLOCK, RTEListItemBlock.name, new ListItemInsertNewParagraphStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEListItemBlock.name, new ListItemInsertImageStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_NODES_BEFORE, RTEListItemBlock.name, new BlockInsertNodesBeforeNodeStrategy());
-})();
-
-/**
- * Insert block array at the front of the block strategy.
- */
-class BlockInsertBlocksBeforeStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    this.replaceBlockWithBlocks(target, action.referBlock, [
-      ...action.blocksToBeInserted,
-      action.referBlock,
-    ]);
-  }
-  /**
-   * Replaces a specific block with an array of blocks within a RTEContentBlock array.
-   *
-   * @param {RTEListBlock|VegaRTEContent} target - The list block or the VegaRTEContent instance.
-   * @param {RTEBlock} referBlock - Used as a reference block to identify the block that needs to be replaced in the `blocks` array.
-   * @param {RTEBlock[]} blocks - An array of RTEBlock objects that you want to replace the `referBlock` with in the `blocks` array.
-   */
-  replaceBlockWithBlocks(target, referBlock, blocks) {
-    if (target.children) {
-      blocks.forEach((block) => {
-        block.parent = target;
-      });
-      const arrayFixed = target.children;
-      target.children = arrayFixed.flatMap((block) => {
-        if (block === referBlock) {
-          return blocks;
-        }
-        else {
-          return block;
-        }
-      });
-    }
-  }
-}
-
-/**
- * Insert block array at the behind of the block strategy.
- */
-class BlockInsertBlocksAfterStrategy extends BlockInsertBlocksBeforeStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    this.replaceBlockWithBlocks(target, action.referBlock, [
-      action.referBlock,
-      ...action.blocksToBeInserted,
-    ]);
-  }
-}
-
-/**
- * Append new block array to list block or VegaRTEContent instance strategy.
- */
-class BlockAppendBlocksStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const newBlocks = action.entityToBeAppended;
-    if (target.children) {
-      newBlocks.forEach((block) => {
-        block.parent = target;
-      });
-      const arrayFixed = target.children;
-      target.children = arrayFixed.concat(newBlocks);
-    }
-  }
-}
-
-/**
- * Delete the nest list block action
- *
- * @example needRemovedNestList.parent.apply(new RemoveNestListAction(needRemovedNestList))
- */
-class RemoveNestListAction extends ModifyContentAction {
-  constructor(childList) {
-    super();
-    this.type = ModifyContentActionType.DELETE_NEST_LIST;
-    this.nestListBlockToBeRemoved = childList;
-  }
-}
-
-/**
- * List block or VegaRTEContent remove child block strategy.
- */
-class BlockRemoveChildBlockStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const blockToBeRemoved = action.entityToBeRemoved;
-    if (target.children) {
-      target.children = target.children.filter((block) => block !== blockToBeRemoved);
-    }
-  }
-}
-
-/**
- * List remove list item strategy.
- */
-class ListRemoveListItemStrategy extends BlockRemoveChildBlockStrategy {
-  /**
-   * Remove the list item, check the list item and remove self if the list item is empty.
-   *
-   * @param {RemoveChildAction} action - The remove action instance.
-   * @param {RTEListBlock} target - The list block.
-   */
-  handleAction(action, target) {
-    super.handleAction(action, target);
-    const parent = target.parent;
-    if (target.children.length === 0 && parent) {
-      // The parent is a list item mean the current block is a nest list, so we need to use RemoveNestListAction to remove the item
-      if (parent['type'] === 'list-item') {
-        parent.apply(new RemoveNestListAction(target));
-      }
-      else {
-        parent.apply(new RemoveChildAction(target));
-      }
-    }
-  }
-}
-
-/**
- * Convert the selected blocks to list strategy.
- */
-class ListTransformToListStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const selectedBlocks = action.selectedBlocks;
-    const bulletList = target.parent.createList(action.listType);
-    const isSameList = selectedBlocks.every((block) => block.parent === target);
-    if (isSameList) {
-      // Select one or more list items belonging to the same list, and all items in this list should be updated
-      bulletList.apply(new AppendChildNodesAction(target.children));
-      target.parent.apply(new InsertBlocksAfterAction(target, bulletList));
-      target.parent.apply(new RemoveChildAction(target));
-      selectedBlocks.forEach((block) => block.children.map((node) => node.apply(new SyncUpSelectionAction())));
-    }
-    else {
-      const listItems = action.selectedBlocks.map((block) => target.parent.toListItem(block));
-      bulletList.apply(new AppendChildNodesAction(listItems));
-      target.parent.apply(new InsertBlocksAfterAction(target, bulletList));
-      action.selectedBlocks.forEach((block) => {
-        block.parent.apply(new RemoveChildAction(block));
-      });
-      if (target.children.length === 0) {
-        target.parent.apply(new RemoveChildAction(target));
-      }
-    }
-  }
-}
-
-/**
- * Convert the selected list block to paragraph strategy.
- */
-class ListTransformToParagraphStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    let isSelectedFirstBlock = false;
-    let isSelectedLastBlock = false;
-    const selectedBlocks = action.selectedBlocks;
-    const currentParagraph = selectedBlocks.map((block) => {
-      block.children.map((node) => node.apply(new SyncUpSelectionAction()));
-      if (block === target.children[0])
-        isSelectedFirstBlock = true;
-      if (block === target.children[target.children.length - 1])
-        isSelectedLastBlock = true;
-      return this.toParagraph(block);
-    });
-    if (isSelectedFirstBlock) {
-      target.parent.apply(new InsertBlocksBeforeAction(target, ...currentParagraph));
-    }
-    else if (isSelectedLastBlock) {
-      target.parent.apply(new InsertBlocksAfterAction(target, ...currentParagraph));
-    }
-    else {
-      const startIndex = target.children.indexOf(selectedBlocks[0]);
-      const lastIndex = target.children.indexOf(selectedBlocks[selectedBlocks.length - 1]);
-      const firstBulletList = target.parent.createList(target.type);
-      firstBulletList.apply(new AppendChildNodesAction(target.children.slice(0, startIndex)));
-      const lastBulletList = target.parent.createList(target.type);
-      lastBulletList.apply(new AppendChildNodesAction(target.children.slice(lastIndex + 1)));
-      target.parent.apply(new InsertBlocksBeforeAction(target, firstBulletList, ...currentParagraph, lastBulletList));
-      target.parent.apply(new RemoveChildAction(target));
-    }
-    selectedBlocks.map((block) => {
-      target.apply(new RemoveChildAction(block));
-    });
-    if (target.children.length === 0) {
-      target.parent.apply(new RemoveChildAction(target));
-    }
-  }
-  /**
-   * Converts a RTEListItemBlock to a RTETextBlock representing a paragraph.
-   *
-   * @param {RTEListItemBlock} block - The block that will be covered
-   * @returns {RTETextBlock} Returns a `RTETextBlock`.
-   */
-  toParagraph(block) {
-    const textBlock = new RTETextBlock(generateUUID(), 'paragraph');
-    textBlock.apply(new AppendChildNodesAction(block['children']));
-    textBlock['annotationMap'] = block['annotationMap'];
-    return textBlock;
-  }
-}
-
-/**
- * Insert image to list block strategy.
- */
-class ListInsertImageStrategy extends ActionHandleStrategy {
-  /**
-   * Insert image block at behind of the list item block.
-   *
-   * @param {InsertImageToBlockAction} action - The insert image action instance.
-   * @param {RTEListBlock} target - The list block.
-   */
-  handleAction(action, target) {
-    const imageBlock = action.imageBlockToBeInserted;
-    if (target.parent['type'] !== 'list-item') {
-      target.parent.apply(new InsertBlocksAfterAction(target, imageBlock));
-    }
-    else {
-      target.parent.apply(action);
-    }
-  }
-}
-
-/**
- * List block
- */
-class RTEListBlock extends RTEBlock {
-  constructor(id, type) {
-    super(id);
-    this.type = 'bullet-list';
-    this.children = [];
-    this.type = type;
-  }
-  /**
-   * Converts a VegaRTEListBlock object to an RTEListBlock
-   *
-   * @param {VegaRTEListBlock} block - Converts a `VegaRTEListBlock` object into an `RTEListBlock`.
-   * @returns {RTEListBlock} Return an instance of `RTEListBlock`
-   */
-  static from(block) {
-    const listBlock = new RTEListBlock(block.id, block.type);
-    listBlock.children = block.blocks.map((item) => {
-      const listItemBlock = RTEListItemBlock.from(item);
-      listItemBlock.parent = listBlock;
-      return listItemBlock;
-    });
-    return listBlock;
-  }
-  /**
-   * @inheritDoc
-   */
-  toJSON() {
-    return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: this.type, blocks: this.children.map((block) => block.toJSON()) });
-  }
-  /**
-   * @inheritDoc
-   */
-  isNotEmpty() {
-    return this.children.length > 0;
-  }
-  /**
-   * @inheritDoc
-   */
-  getLastNode() {
-    return this.children[this.children.length - 1].getLastNode();
-  }
-  /**
-   * @inheritDoc
-   */
-  clone() {
-    const clonedListBlock = new RTEListBlock(this.id, this.type);
-    clonedListBlock.children = this.children.map((item) => {
-      const clonedListItemBlock = item.clone();
-      clonedListItemBlock.parent = clonedListBlock;
-      return clonedListItemBlock;
-    });
-    clonedListBlock.annotationMap = super.cloneAnnotations();
-    clonedListBlock.parent = this.parent;
-    return clonedListBlock;
-  }
-}
-(() => {
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, RTEListBlock.name, new ListRemoveListItemStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_BLOCKS_BEFORE, RTEListBlock.name, new BlockInsertBlocksBeforeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_BLOCKS_AFTER, RTEListBlock.name, new BlockInsertBlocksAfterStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, RTEListBlock.name, new BlockAppendBlocksStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_LIST_BLOCK, RTEListBlock.name, new ListTransformToListStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_PARAGRAPH_BLOCK, RTEListBlock.name, new ListTransformToParagraphStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEListBlock.name, new ListInsertImageStrategy());
-})();
-
-/**
- * Transform the selected text blocks to a code block strategy.
- */
-class BlockTransformToCodeBlockStrategy extends ActionHandleStrategy {
-  /**
-   * Get the all select text and create a new code block.
-   *
-   * @param {TransformToCodeBlockAction} action - The action instance.
-   * @param {VegaRTEContent} target - The block top parent instance.
-   */
-  handleAction(action, target) {
-    const selectedBlocks = action.selectedBlocks;
-    const codeBlock = new RTECodeBlock(generateUUID(), this.getCodeContent(selectedBlocks), 'plainText');
-    target.apply(new InsertBlocksBeforeAction(selectedBlocks[0], codeBlock));
-    action.newCodeBlock = codeBlock;
-    this.removeSelectBlocks(selectedBlocks, target);
-  }
-  /**
-   * Get the selected text block text content.
-   *
-   * @param {RTEBlock[]} selectedBlocks - The selected blocks.
-   * @returns {string} - The selected text content.
-   */
-  getCodeContent(selectedBlocks) {
-    const selectedTextBlocks = selectedBlocks.filter((item) => item.type !== 'image' && item.type !== 'list-item');
-    return selectedTextBlocks
-      .map((block) => {
-      return block.children.map((node) => node.text).join('');
-    })
-      .join('\n');
-  }
-  /**
-   * Remove the selected blocks after append new code block.
-   *
-   * @param {RTEBlock[]} selectedBlocks - The selected blocks.
-   * @param {VegaRTEContent} target - The selected block top parent object.
-   */
-  removeSelectBlocks(selectedBlocks, target) {
-    for (let i = 0; i < selectedBlocks.length; i++) {
-      target.apply(new RemoveChildAction(selectedBlocks[i]));
-    }
-  }
-}
-
-/**
- * Class representing the content state of the rich text editor.
- */
-class VegaRTEContent {
-  constructor(blocks) {
-    blocks.forEach((block) => {
-      block.parent = this;
-    });
-    this.children = blocks;
-  }
-  /**
-   * Converts a JSON array of blocks to a class array of RTEContentBlock.
-   *
-   * @param {VegaRTEContentBlock[]} value The JSON array of blocks to convert.
-   * @returns {VegaRTEContent} The converted array of RTEContentBlock.
-   */
-  static fromJSON(value) {
-    const blocks = value.map((block) => {
-      switch (block.type) {
-        case 'paragraph':
-        case 'title':
-        case 'subtitle':
-        case 'heading-1':
-        case 'heading-2':
-        case 'heading-3': {
-          return RTETextBlock.from(block);
-        }
-        case 'image':
-          return RTEImageBlock.from(block);
-        case 'bullet-list':
-        case 'number-list':
-          return RTEListBlock.from(block);
-        case 'code-block':
-          return RTECodeBlock.from(block);
-        default: {
-          throw new Error(`[Vega] Unknown block type: ${block.type}`);
-        }
-      }
-    });
-    return new VegaRTEContent(blocks);
-  }
-  /**
-   * Create an empty content state
-   *
-   * @returns {VegaRTEContent} An empty content state
-   */
-  static createEmptyContent() {
-    return VegaRTEContent.fromJSON([
-      {
-        id: generateUUID(),
-        type: 'paragraph',
-        nodes: [
-          {
-            id: generateUUID(),
-            type: 'text',
-            text: '',
-          },
-        ],
-      },
-    ]);
-  }
-  /**
-   * Clones the content state.
-   *
-   * @param {boolean} deep - If true, performs a deep clone of the content state.
-   * @returns {VegaRTEContent} The cloned content state.
-   */
-  clone(deep = false) {
-    return deep
-      ? new VegaRTEContent(this.children.map((block) => block.clone()))
-      : new VegaRTEContent([...this.children]);
-  }
-  /**
-   * Converts the content state to a JSON array of blocks.
-   *
-   * @returns {VegaRTEContentBlock[]} The JSON array of blocks.
-   */
-  toJSON() {
-    return this.children.map((block) => block.toJSON());
-  }
-  /**
-   * Internal method to add the block item, remove the block item
-   *
-   * @param {ModifyContentAction} action - Modify content action
-   */
-  apply(action) {
-    ActionHandleStrategyRegistry.executeTheStrategy(action, this);
-  }
-  /**
-   * Convert text to list.
-   *
-   * @param {RTETextBlock} block - block
-   * @returns {RTEListItemBlock} list item block dto.
-   */
-  toListItem(block) {
-    block.children.map((node) => node.apply(new SyncUpSelectionAction()));
-    const listItemBlock = new RTEListItemBlock(generateUUID());
-    listItemBlock.apply(new AppendChildNodesAction(block['children']));
-    listItemBlock['annotationMap'] = block['annotationMap'];
-    return listItemBlock;
-  }
-  /**
-   * create list.
-   *
-   * @param {ListType} type - type
-   * @returns {RTEListBlock} list block dto.
-   */
-  createList(type) {
-    return new RTEListBlock(generateUUID(), type);
-  }
-  /**
-   * Finds a node by its ID in the content.
-   *
-   * @param {string} id - The ID of the node to find.
-   * @returns {Nullable<RTENode>} The found node or null if not found.
-   */
-  findNodeById(id) {
-    return this.findNodeInBlocksById(id, this.children);
-  }
-  /**
-   * Recursively searches for a node by its ID in the given blocks.
-   *
-   * @param {string} id - The ID of the node to find.
-   * @param {RTEContentBlock[]} blocks - The blocks to search within.
-   * @returns {Nullable<RTENode>} The found node or null if not found.
-   */
-  findNodeInBlocksById(id, blocks) {
-    for (const block of blocks) {
-      if ('children' in block) {
-        for (const node of block.children) {
-          if (node.id === id) {
-            return node;
-          }
-        }
-      }
-      if (block instanceof RTEListItemBlock && block.nestList) {
-        for (const cBlock of block.nestList) {
-          const foundNode = this.findNodeInBlocksById(id, cBlock.children);
-          if (foundNode) {
-            return foundNode;
-          }
-        }
-      }
-      if (block instanceof RTEListBlock && block.children) {
-        const foundNode = this.findNodeInBlocksById(id, block.children);
-        if (foundNode) {
-          return foundNode;
-        }
-      }
-    }
-    return null;
-  }
-}
-(() => {
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, VegaRTEContent.name, new BlockRemoveChildBlockStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, VegaRTEContent.name, new BlockAppendBlocksStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_BLOCKS_BEFORE, VegaRTEContent.name, new BlockInsertBlocksBeforeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_BLOCKS_AFTER, VegaRTEContent.name, new BlockInsertBlocksAfterStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_TO_CODE_BLOCK, VegaRTEContent.name, new BlockTransformToCodeBlockStrategy());
-})();
-
-export { BreakSingleBlockAction as B, RTEImageBlock as R, VegaRTEContent as V, RTEListItemBlock as a, RTEListBlock as b };