@globalpayments/vega 2.37.2 → 2.39.0

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

@@ -1,2954 +0,0 @@
-import { B as BlockAnnotation, a as BlockAnnotationTypeEnum, M as ModifyContentAction, b as ModifyContentActionType, s as stateEntityRenderingRegistry, N as NodeAnnotation, c as NodeAnnotationTypeEnum, R as RTENode, d as NodeTypeEnum, A as Annotation, I as InternalAnnotationTypeEnum, V as VegaThemeManager } from './node-annotation.abstract-b2e36bc4.js';
-import { C as ChangeManager } from './change-manager-6a7eb88c.js';
-import { d as domNodeSubjectFactory } from './dom-node-subject-factory-97deb349.js';
-import { V as VegaInternalRichTextEditorFlushChanges, b as VegaInternalRichTextEditorSelectionRangeChange } from './vega-internal-event-id-d0690d0d.js';
-import { i as isNonNullable } from './type-guard-158f6d7a.js';
-import './global-slimmer-registry-17c4efd4.js';
-import { g as generateUUID } from './create-public-api-runtime-metrics-slimmer-9ab05523.js';
-
-/**
- * Annotation to make block with horizontal alignment
- */
-class HorizontalAlignmentAnnotation extends BlockAnnotation {
-  constructor(textAlign) {
-    super();
-    this.type = BlockAnnotationTypeEnum.ALIGNMENT;
-    this.textAlign = textAlign;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {VegaRTEBlockAlignment} textAlign - Text alignment
-   * @returns {[BlockAnnotationTypeEnum.ALIGNMENT, HorizontalAlignmentAnnotation]} Map item for the annotation
-   */
-  static from(textAlign) {
-    return [BlockAnnotationTypeEnum.ALIGNMENT, new HorizontalAlignmentAnnotation(textAlign)];
-  }
-  /**
-   * Generate the JSON item of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      textAlign: this.textAlign,
-    };
-  }
-  /**
-   * Generate the class for the annotation
-   *
-   * @returns {string} - Annotation class
-   */
-  renderClass() {
-    return `v-rte--horizontal-alignment-${this.textAlign}`;
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
-   */
-  render() {
-    return null;
-  }
-}
-
-/**
- * Annotation for block indentation
- */
-class IndentAnnotation extends BlockAnnotation {
-  constructor(indent) {
-    super();
-    this.type = BlockAnnotationTypeEnum.INDENT;
-    this.indent = Math.max(0, indent);
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {number} indent - Text alignment
-   * @returns {[BlockAnnotationTypeEnum.INDENT, IndentAnnotation]} Map item for the annotation
-   */
-  static from(indent) {
-    return [BlockAnnotationTypeEnum.INDENT, new IndentAnnotation(indent)];
-  }
-  /**
-   * Generate the JSON item of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return this.indent > 0 ? { indent: this.indent } : null;
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
-   */
-  render() {
-    return this.indent > 0 ? { 'margin-left': `${this.indent * 16}px` } : null;
-  }
-}
-
-/** The class contains some common method to modify the blocks property */
-class BlockBaseOperator {
-  /**
-   * Replaces a specific block with an array of blocks within a RTEContentBlock array.
-   *
-   * @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(referBlock, blocks) {
-    if (this.blocks) {
-      blocks.forEach((block) => {
-        block.parent = this;
-      });
-      this.blocks = this.blocks.flatMap((block) => {
-        if (block === referBlock) {
-          return blocks;
-        }
-        else {
-          return block;
-        }
-      });
-    }
-  }
-  /**
-   * Appends new blocks to an array and sets their parent property to a specific type.
-   *
-   * @param {RTEBlock[]} newBlocks - An array of `RTEBlock` objects that are being passed to the `appendChildBlocks` method.
-   */
-  appendChildBlocks(newBlocks) {
-    if (this.blocks) {
-      newBlocks.forEach((block) => {
-        block.parent = this;
-      });
-      this.blocks = this.blocks.concat(newBlocks);
-    }
-  }
-  /**
-   * Removes a specified RTEBlock from an array of blocks.
-   *
-   * @param {RTEBlock} blockToBeRemoved - The block that needs to be removed from the `blocks` array.
-   */
-  removeChildBlock(blockToBeRemoved) {
-    if (this.blocks) {
-      this.blocks = this.blocks.filter((block) => block !== blockToBeRemoved);
-    }
-  }
-}
-
-/** Append blocks or nodes to a block */
-class AppendChildNodesAction extends ModifyContentAction {
-  constructor(childNodes) {
-    super();
-    this.type = ModifyContentActionType.APPEND_CHILD_NODES;
-    this.entityToBeAppended = childNodes;
-  }
-}
-
-/**
- * Delete child node or child block from the current list action
- *
- * @example needRemovedNode.parentBlock.apply(new RemoveChildAction(needRemovedNode))
- * @example needRemovedBlock.parent.apply(new RemoveChildAction(needRemovedBlock))
- */
-class RemoveChildAction extends ModifyContentAction {
-  constructor(childNode) {
-    super();
-    this.type = ModifyContentActionType.DELETE_CHILD;
-    this.entityToBeRemoved = childNode;
-  }
-}
-
-const RTE_TEXT_COLORS = [
-  {
-    key: 'black',
-    light: '#111128',
-    dark: '#E3E3E8',
-  },
-  {
-    key: 'gray',
-    light: '#5E5E6D',
-    dark: '#B9B9C1',
-  },
-  {
-    key: 'green',
-    light: '#01801F',
-    dark: '#59D977',
-  },
-  {
-    key: 'red',
-    light: '#BD2947',
-    dark: '#FFB2B5',
-  },
-  {
-    key: 'purple',
-    light: '#563D82',
-    dark: '#BEB2FF',
-  },
-  {
-    key: 'teal',
-    light: '#17758F',
-    dark: '#4CD8FF',
-  },
-];
-const ZERO_WIDTH_SPACE = '\u200b';
-
-/**
- * Abstract class for block
- */
-class RTEBlock extends BlockBaseOperator {
-  constructor(id) {
-    super();
-    this.annotationMap = new Map();
-    this.id = id;
-  }
-  /**
-   * The function `createAnnotationEntity` creates a block annotation entity based on the provided type
-   * and value.
-   *
-   * @param {keyof VegaRTEBlockAnnotations} type - The `type` parameter is a key of the `VegaRTEBlockAnnotations` enum, which specifies
-   * the type of annotation entity to create.
-   * @param {unknown} value - The `value` parameter in the `createAnnotationEntity` function is the value
-   * that will be used to create the annotation entity. It can be of any type depending on the specific
-   * annotation being created.
-   * @returns {Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>} The `createAnnotationEntity` function returns a nullable tuple containing a
-   * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
-   */
-  static createAnnotationEntity(type, value) {
-    switch (type) {
-      case 'textAlign':
-        return HorizontalAlignmentAnnotation.from(value);
-      case 'indent':
-        return IndentAnnotation.from(value);
-    }
-  }
-  /**
-   * Class to JSON object
-   *
-   * @returns {VegaRTEBlockBase} - JSON object
-   */
-  toJSON() {
-    const annotations = Array.from(this.annotationMap.values())
-      .filter((annotation) => annotation instanceof BlockAnnotation)
-      .reduce((record, annotation) => {
-      return Object.assign(Object.assign({}, record), annotation.toJSON());
-    }, {});
-    return Object.assign({ id: this.id }, (Object.keys(annotations).length > 0 ? { annotations } : {}));
-  }
-  /**
-   * Get annotation by type
-   *
-   * @param {keyof typeof BlockAnnotationTypeEnum} type - Annotation type
-   * @returns {Nullable<BlockAnnotation> | Nullable<LinkGroupAnnotation>} - Annotation
-   */
-  getAnnotationByType(type) {
-    return this.annotationMap.get(type);
-  }
-  /**
-   * Apply action to block
-   *
-   * @param {AnnotationAction} action - Annotation action
-   */
-  apply(action) {
-    this.doApply(action);
-    if (action.isFlushable) {
-      const domNode = stateEntityRenderingRegistry.getDOMByEntity(this);
-      if (domNode) {
-        const nodeSubject = domNodeSubjectFactory.getSubjectFromParentNodeByEventId(domNode, VegaInternalRichTextEditorFlushChanges);
-        if (nodeSubject) {
-          ChangeManager.notify(nodeSubject, {});
-        }
-      }
-    }
-  }
-  /**
-   * Apply action to block
-   *
-   * @param {AnnotationAction|ModifyContentAction} action - Annotation action
-   */
-  doApply(action) {
-    if (action instanceof ModifyContentAction) {
-      this.doModifyActionApply(action);
-    }
-    else {
-      this.applyAnnotationAction(action);
-    }
-  }
-  /**
-   * Apply annotation action to block
-   *
-   * @param {AnnotationAction} action - Annotation action
-   */
-  applyAnnotationAction(action) {
-    const annotation = action.toAnnotation();
-    this.annotationMap.set(annotation.type, annotation);
-    typeof this.doAnnotationActionApply === 'function' && this.doAnnotationActionApply(action);
-  }
-  /**
-   * Appends a list of RTENode objects to the current node's child nodes and sets the parent block of each node to the current node.
-   *
-   * @param {RTENode[]} nodesToBeAppended - An array of `RTENode` objects that you want to append to the current block.
-   */
-  appendChildNodes(nodesToBeAppended) {
-    nodesToBeAppended.forEach((node) => {
-      node.parentBlock = this;
-    });
-    this['nodes'] = this['nodes'].concat(nodesToBeAppended);
-  }
-  /**
-   * Merges the child nodes of two RTEBlocks if they have the same type or both are not images.
-   *
-   * @param {RTEBlock} secondBlock - A block of content in a rich text editor, such as a paragraph, heading, image, etc.
-   */
-  mergeTwoBlocksNodes(secondBlock) {
-    if (this.type === secondBlock.type || (this.type !== 'image' && secondBlock.type !== 'image')) {
-      let shouldMergeNodes = secondBlock['nodes'];
-      if (this.type !== 'image') {
-        shouldMergeNodes = secondBlock['nodes'].filter((node) => node['text'] && node['text'] !== ZERO_WIDTH_SPACE);
-      }
-      this.apply(new AppendChildNodesAction(shouldMergeNodes));
-      secondBlock.parent.apply(new RemoveChildAction(secondBlock));
-    }
-  }
-  /**
-   * 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['nodes']);
-        block.parent.apply(new RemoveChildAction(block));
-      }
-    });
-    return nodes;
-  }
-  /**
-   * Returns the previous node relative to the current node in a rich text editor structure.
-   *
-   * @param {RTENode} currentNode - An object of type `RTENode`.
-   * @returns {Nullable<RTENode>} the previous block last node
-   */
-  getPreviousNode(currentNode) {
-    const currentBlock = currentNode.parentBlock;
-    const currentIndex = currentBlock['nodes'].indexOf(currentNode);
-    if (currentIndex > 0) {
-      return currentBlock['nodes'][currentIndex - 1];
-    }
-    else if (currentBlock.parent) {
-      const previousBlock = this.getPreviousBlock(currentBlock);
-      if (previousBlock) {
-        return this.getBlockLastNode(previousBlock);
-      }
-    }
-  }
-  /**
-   * Returns the next node relative to the current node in a rich text editor structure.
-   *
-   * @param {RTENode} currentNode - An object of type `RTENode`.
-   * @returns {Nullable<RTENode>} the next block first node
-   */
-  getNextNode(currentNode) {
-    const currentBlock = currentNode.parentBlock;
-    const currentIndex = currentBlock['nodes'].indexOf(currentNode);
-    if (currentBlock['nodes'][currentIndex + 1]) {
-      return currentBlock['nodes'][currentIndex + 1];
-    }
-    else if (currentBlock.parent) {
-      const nextBlock = this.getNextBlock(currentBlock);
-      if (nextBlock) {
-        return this.getBlockFirstNode(nextBlock);
-      }
-    }
-  }
-  /**
-   * Determines if a given node is the first node within the current state.
-   *
-   * @param {RTENode} currentNode - An object representing a node in a rich text editor (RTE).
-   * @returns {boolean} True or false;
-   */
-  isContentFirstNode(currentNode) {
-    const currentBlock = currentNode.parentBlock;
-    const currentIndex = currentBlock['nodes'].indexOf(currentNode);
-    const parent = currentBlock.parent;
-    if (currentBlock.type === 'list-item') {
-      const listParent = parent.parent;
-      return (currentIndex === 0 &&
-        Array.isArray(parent.blocks) &&
-        parent.blocks[0] === currentBlock &&
-        listParent['type'] !== 'list-item' &&
-        Array.isArray(listParent.blocks) &&
-        listParent.blocks[0] === parent);
-    }
-    else {
-      return currentIndex === 0 && Array.isArray(parent.blocks) && parent.blocks[0] === currentBlock;
-    }
-  }
-  /**
-   * Returns the last node within a given RTE block, handling different block types accordingly.
-   *
-   * @param {RTEBlock} currentBlock - Returns the last node within that block.
-   * @returns {Nullable<RTENode>} Returns the last node of the given `currentBlock` object.
-   */
-  getBlockLastNode(currentBlock) {
-    if (currentBlock.type === 'list-item') {
-      if (currentBlock['children'] && currentBlock['children'].length > 0) {
-        return this.getBlockLastNode(currentBlock['children'][currentBlock['children'].length - 1]);
-      }
-      else {
-        return currentBlock['nodes'][currentBlock['nodes'].length - 1];
-      }
-    }
-    else if (currentBlock.type === 'number-list' || currentBlock.type === 'bullet-list') {
-      if (currentBlock.blocks) {
-        const lastListItem = currentBlock.blocks[currentBlock.blocks.length - 1];
-        return this.getBlockLastNode(lastListItem);
-      }
-    }
-    else {
-      if (currentBlock['nodes']) {
-        return currentBlock['nodes'][currentBlock['nodes'].length - 1];
-      }
-    }
-  }
-  /**
-   * Returns the first node within a given RTE block, handling different block types accordingly.
-   *
-   * @param {RTEBlock} currentBlock - Returns the first node within that block.
-   * @returns {Nullable<RTENode>} Returns the first node of the given `currentBlock` object.
-   */
-  getBlockFirstNode(currentBlock) {
-    if (currentBlock.type === 'number-list' || currentBlock.type === 'bullet-list') {
-      if (currentBlock.blocks) {
-        const firstListItem = currentBlock.blocks[0];
-        return this.getBlockFirstNode(firstListItem);
-      }
-    }
-    else {
-      if (currentBlock['nodes']) {
-        return currentBlock['nodes'][0];
-      }
-    }
-  }
-  /**
-   * TODO: The getPreviousBlock add nest list support
-   * This function retrieves the previous block in a rich text editor, considering different scenarios such as being in a bullet list.
-   *
-   * @param {RTEBlock} currentBlock - Used to retrieve the previous block relative to the given `currentBlock` within a rich text editor context.
-   * @returns {Nullable<RTEBlock>} The previous block if existing
-   */
-  getPreviousBlock(currentBlock) {
-    if (currentBlock && currentBlock.parent && currentBlock.parent.blocks) {
-      const currentBlockIndex = currentBlock.parent.blocks.indexOf(currentBlock);
-      if (currentBlockIndex > 0) {
-        return currentBlock.parent.blocks[currentBlockIndex - 1];
-      }
-      else if ((currentBlock.parent['type'] === 'number-list' ||
-        currentBlock.parent['type'] === 'bullet-list') &&
-        currentBlockIndex === 0) {
-        return this.getPreviousBlock(currentBlock.parent);
-      }
-    }
-  }
-  /**
-   * This function retrieves the next block in a rich text editor, considering different scenarios such as being in a bullet list.
-   *
-   * @param {RTEBlock} currentBlock - Used to retrieve the next block relative to the given `currentBlock` within a rich text editor context.
-   * @returns {Nullable<RTEBlock>} The next block if existing
-   */
-  getNextBlock(currentBlock) {
-    if (currentBlock && currentBlock.parent && currentBlock.parent.blocks) {
-      const currentBlockIndex = currentBlock.parent.blocks.indexOf(currentBlock);
-      if (currentBlock.parent.blocks[currentBlockIndex + 1]) {
-        return currentBlock.parent.blocks[currentBlockIndex + 1];
-      }
-      else if (currentBlock.type === 'list-item' &&
-        currentBlock.parent.blocks.length === currentBlockIndex + 1) {
-        return this.getNextBlock(currentBlock.parent);
-      }
-    }
-  }
-  /**
-   * Replaces a specific node with an array of nodes within a RTENode array.
-   *
-   * @param {RTENode} referNode - Used as a reference node to identify the node that needs to be replaced in the `nodes` array.
-   * @param {RTENode[]} nodes - An array of RTENode objects that you want to replace the `referNode` with in the `nodes` array.
-   */
-  replaceNodeWithNodes(referNode, nodes) {
-    if (this['nodes']) {
-      nodes.forEach((node) => {
-        node.parentBlock = this;
-      });
-      this['nodes'] = this['nodes'].flatMap((node) => {
-        if (node === referNode) {
-          return nodes;
-        }
-        else {
-          return node;
-        }
-      });
-    }
-  }
-}
-
-/**
- * Annotation for image
- */
-class ImageAnnotation extends NodeAnnotation {
-  constructor(size = 'md', alt) {
-    super();
-    this.type = NodeAnnotationTypeEnum.IMAGE;
-    this.size = size;
-    this.alt = alt;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {string} size - Image size
-   * @param {string} alt - Image alt
-   * @returns {[NodeAnnotationTypeEnum.IMAGE, ImageAnnotation]} Map item for the annotation
-   */
-  static from(size, alt) {
-    return [NodeAnnotationTypeEnum.IMAGE, new ImageAnnotation(size, alt)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Nullable<Record<string, unknown>>} JSON representation of the annotation
-   */
-  toJSON() {
-    return isNonNullable(this.alt)
-      ? {
-        size: this.size,
-        alt: this.alt,
-      }
-      : {
-        size: this.size,
-      };
-  }
-  /**
-   * Generate the style for the image
-   *
-   * @returns {Nullable<AnnotationStyle>} image style
-   */
-  render() {
-    switch (this.size) {
-      case 'sm': {
-        return { width: '25%' };
-      }
-      case 'md': {
-        return { width: '50%' };
-      }
-      case 'lg': {
-        return { width: '100%' };
-      }
-    }
-  }
-}
-
-/**
- * Image node
- */
-class RTEImageNode extends RTENode {
-  constructor(id, url, parentBlock, annotationMap) {
-    super(id, annotationMap);
-    this.type = NodeTypeEnum.IMAGE;
-    this.url = url;
-    this.parentBlock = parentBlock;
-  }
-  /**
-   * Converts a VegaRTEImageNode into an RTEImageNode by mapping nodes and creating annotations.
-   *
-   * @param {VegaRTEImageNode} node - The node to be converted.
-   * @param {RTEImageBlock} parentBlock - The parent block
-   * @returns {RTEImageBlock} An instance of `RTEImageBlock`
-   */
-  static from(node, parentBlock) {
-    const imageNode = new RTEImageNode(node.id, node.url, parentBlock);
-    let annotations;
-    if (!node.annotations || Object.keys(node.annotations).length === 0) {
-      annotations = { size: 'md' };
-    }
-    else {
-      annotations = node.annotations;
-    }
-    imageNode.annotationMap = new Map(Object.keys(annotations)
-      .map(() => ImageAnnotation.from(annotations.size, annotations.alt))
-      .filter(isNonNullable));
-    return imageNode;
-  }
-  /**
-   * @inheritDoc
-   */
-  toJSON() {
-    const imageAnnotation = this.annotationMap.get(NodeAnnotationTypeEnum.IMAGE);
-    const annotations = {};
-    if (imageAnnotation === null || imageAnnotation === void 0 ? void 0 : imageAnnotation.size) {
-      annotations.size = imageAnnotation.size;
-    }
-    if (imageAnnotation === null || imageAnnotation === void 0 ? void 0 : imageAnnotation.alt) {
-      annotations.alt = imageAnnotation.alt;
-    }
-    return Object.assign(Object.assign({ id: this.id }, (Object.keys(annotations).length > 0 ? { annotations } : {})), { type: 'image', url: this.url });
-  }
-  /**
-   * @inheritDoc
-   */
-  doAnnotationActionApply(action) {
-    const annotation = action.toAnnotation();
-    this.annotationMap.set(annotation.type, annotation);
-  }
-  // placeholder method
-  /* istanbul ignore next */
-  /**
-   * @inheritDoc
-   */
-  doModifyActionApply(action) {
-  }
-}
-
-/**
- * Clear the current block nodes and append new nodes
- *
- * @example block.apply(new ReplaceChildNodesAction(newNodes))
- */
-class ReplaceChildNodesAction extends ModifyContentAction {
-  constructor(newChildNodes) {
-    super();
-    this.type = ModifyContentActionType.REPLACE_CHILD_NODES;
-    this.newChildNodes = newChildNodes;
-  }
-}
-
-/**
- * Insert a new block after a existing block
- *
- * @example currentBlock.parent.apply(new InsertBlocksAfterAction(currentBlock, newBlock, ...))
- */
-class InsertBlocksAfterAction extends ModifyContentAction {
-  constructor(referBlock, ...blocksToBeInserted) {
-    super();
-    this.type = ModifyContentActionType.INSERT_BLOCKS_AFTER;
-    this.referBlock = referBlock;
-    this.blocksToBeInserted = blocksToBeInserted;
-  }
-}
-
-/**
- * Split the block with a split point node.
- * The property `newBlock` use to store the new create block if need.
- *
- * @example block.apply(new SplitBlockWithNodeAction(node, offset))
- */
-class SplitBlockWithNodeAction extends ModifyContentAction {
-  constructor(splitPointNode, startOffsetOfNode) {
-    super();
-    this.type = ModifyContentActionType.SPLIT_BLOCK_WITH_NODE;
-    this.splitPointNode = splitPointNode;
-    this.startOffsetOfNode = startOffsetOfNode;
-  }
-}
-
-/**
- * Abstract class for annotation actions
- */
-class AnnotationAction {
-}
-
-/**
- * Abstract class for which can be splittable
- */
-class TextSplittableAction extends AnnotationAction {
-  constructor() {
-    super(...arguments);
-    /**
-     * Whether the action should split the node
-     */
-    this.doSplit = true;
-  }
-}
-
-/**
- * Annotation to represent a selection range
- */
-class SelectionRangeAnnotation extends Annotation {
-  constructor(range) {
-    super();
-    this.type = InternalAnnotationTypeEnum.SELECTION_RANGE;
-    this.range = range;
-  }
-}
-
-/**
- * Annotation to make text with strikethrough
- */
-class StrikethroughAnnotation extends NodeAnnotation {
-  constructor(underline) {
-    super();
-    this.type = NodeAnnotationTypeEnum.STRIKETHROUGH;
-    this.strikethrough = underline;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {Nullable<boolean>} strikethrough - Strikethrough annotation
-   * @returns {[NodeAnnotationTypeEnum.STRIKETHROUGH, StrikethroughAnnotation]} Map item for the annotation
-   */
-  static from(strikethrough) {
-    return [NodeAnnotationTypeEnum.STRIKETHROUGH, new StrikethroughAnnotation(strikethrough)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      strikethrough: this.strikethrough,
-    };
-  }
-  /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
-   */
-  renderClass() {
-    return this.strikethrough ? 'v-rte--strikethrough' : null;
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
-   */
-  render() {
-    return null;
-  }
-}
-
-/**
- * Annotation to make text with underline
- */
-class UnderlineAnnotation extends NodeAnnotation {
-  constructor(underline) {
-    super();
-    this.type = NodeAnnotationTypeEnum.UNDERLINE;
-    this.underline = underline;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {boolean} underline - Underline annotation
-   * @returns {[NodeAnnotationTypeEnum.UNDERLINE, UnderlineAnnotation]} Map item for the annotation
-   */
-  static from(underline) {
-    return [NodeAnnotationTypeEnum.UNDERLINE, new UnderlineAnnotation(underline)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      underline: this.underline,
-    };
-  }
-  /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
-   */
-  renderClass() {
-    return this.underline ? 'v-rte--underline' : null;
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
-   */
-  render() {
-    return null;
-  }
-}
-
-/**
- * Annotation to make text Italic
- */
-class ItalicAnnotation extends NodeAnnotation {
-  constructor(italic) {
-    super();
-    this.type = NodeAnnotationTypeEnum.ITALIC;
-    this.italic = italic;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {boolean} italic - Italic annotation
-   * @returns {Nullable<[NodeAnnotationTypeEnum.ITALIC, ItalicAnnotation]>} Map item for the annotation
-   */
-  static from(italic) {
-    return [NodeAnnotationTypeEnum.ITALIC, new ItalicAnnotation(italic)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      italic: this.italic,
-    };
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Italic style
-   */
-  render() {
-    return this.italic ? { 'font-style': 'italic' } : null;
-  }
-}
-
-/**
- * Annotation to make text bold
- */
-class BoldAnnotation extends NodeAnnotation {
-  constructor(bold) {
-    super();
-    this.type = NodeAnnotationTypeEnum.BOLD;
-    this.bold = bold;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {boolean} bold - Bold annotation
-   * @returns {[NodeAnnotationTypeEnum.BOLD, BoldAnnotation]} Map item for the annotation
-   */
-  static from(bold) {
-    return [NodeAnnotationTypeEnum.BOLD, new BoldAnnotation(bold)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      bold: this.bold,
-    };
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Bold style
-   */
-  render() {
-    return this.bold ? { 'font-weight': '700' } : null;
-  }
-}
-
-/**
- * Annotation to host which annotations will be clear formatting
- */
-class ClearFormattingAnnotation extends Annotation {
-  constructor() {
-    super(...arguments);
-    this.type = InternalAnnotationTypeEnum.CLEAR_FORMATTING;
-    this.items = [
-      NodeAnnotationTypeEnum.BOLD,
-      NodeAnnotationTypeEnum.ITALIC,
-      NodeAnnotationTypeEnum.UNDERLINE,
-      NodeAnnotationTypeEnum.STRIKETHROUGH,
-      NodeAnnotationTypeEnum.TEXT_COLOR,
-      NodeAnnotationTypeEnum.CODE,
-    ];
-  }
-}
-
-/**
- * Annotation to make text code
- */
-class CodeAnnotation extends NodeAnnotation {
-  constructor(code) {
-    super();
-    this.type = NodeAnnotationTypeEnum.CODE;
-    this.code = code;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {boolean} code - Bold annotation
-   * @returns {[NodeAnnotationTypeEnum.CODE, CodeAnnotation]} Map item for the annotation
-   */
-  static from(code) {
-    return [NodeAnnotationTypeEnum.CODE, new CodeAnnotation(code)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      code: this.code,
-    };
-  }
-  /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
-   */
-  renderClass() {
-    return this.code ? 'v-rte--code' : null;
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Bold style
-   */
-  render() {
-    return null;
-  }
-}
-
-/**
- * Annotation to make text with text color
- */
-class TextColorAnnotation extends NodeAnnotation {
-  constructor(textColor) {
-    super();
-    this.type = NodeAnnotationTypeEnum.TEXT_COLOR;
-    this.textColor = this.formatTextColor(textColor);
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {string} textColor - text color annotation
-   * @returns {[NodeAnnotationTypeEnum.TEXT_COLOR, TextColorAnnotation]} Map item for the annotation
-   */
-  static from(textColor) {
-    return [NodeAnnotationTypeEnum.TEXT_COLOR, new TextColorAnnotation(textColor)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      textColor: this.textColor.key,
-    };
-  }
-  /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
-   */
-  renderClass() {
-    return null;
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
-   */
-  render() {
-    return {
-      color: VegaThemeManager.isDarkMode() ? this.textColor.dark : this.textColor.light,
-    };
-  }
-  /**
-   * format text color
-   *
-   * @param {string} textColor - text color
-   * @returns {VegaRTEColorSchema} - VegaRTEColorSchema
-   */
-  formatTextColor(textColor) {
-    return (RTE_TEXT_COLORS.find((item) => item.key === textColor) || RTE_TEXT_COLORS[0]);
-  }
-}
-
-/**
- * Annotation to make text a link
- */
-class LinkAnnotation extends NodeAnnotation {
-  constructor(link) {
-    super();
-    this.type = NodeAnnotationTypeEnum.LINK;
-    this.link = link;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {VegaRTELink} link - Bold annotation
-   * @returns {[NodeAnnotationTypeEnum.LINK, LinkAnnotation]} Map item for the annotation
-   */
-  static from(link) {
-    return [
-      NodeAnnotationTypeEnum.LINK,
-      new LinkAnnotation({ href: link.href, groupKey: link.groupKey }),
-    ];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return { link: { href: this.link.href, groupKey: this.link.groupKey } };
-  }
-  /**
-   * Verify whether two link annotation is same or not
-   *
-   * @param {LinkAnnotation} annotation - Compared annotation
-   * @returns {boolean} Whether two link annotation is same or not
-   */
-  toEqual(annotation) {
-    return this.link.groupKey === annotation.link.groupKey;
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Link style
-   */
-  render() {
-    return null;
-  }
-}
-
-/**
- * Action to toggle link annotation
- */
-class LinkAnnotationAction extends TextSplittableAction {
-  constructor({ link, newText, needMergeNode, doSplit, }) {
-    super();
-    this.isFlushable = true;
-    this.link = link;
-    this.needMergeNode = needMergeNode;
-    this.newText = newText;
-    if (isNonNullable(doSplit)) {
-      this.doSplit = doSplit;
-    }
-  }
-  /**
-   * Converts the action to an annotation
-   *
-   * @returns {LinkAnnotation} the annotation
-   */
-  toAnnotation() {
-    return new LinkAnnotation(this.link);
-  }
-}
-
-/**
- * Action to toggle code annotation
- */
-class CodeAnnotationAction extends TextSplittableAction {
-  constructor(code) {
-    super();
-    this.isFlushable = true;
-    this.code = code;
-  }
-  /**
-   * Converts the action to an annotation
-   *
-   * @returns {CodeAnnotation} the annotation
-   */
-  toAnnotation() {
-    return new CodeAnnotation(this.code);
-  }
-}
-
-/**
- * Action to toggle clear formatting
- */
-class ClearFormattingAnnotationAction extends TextSplittableAction {
-  constructor() {
-    super(...arguments);
-    this.isFlushable = true;
-  }
-  /**
-   * Converts the action to an annotation
-   *
-   * @returns {ClearFormattingAnnotation} the annotation
-   */
-  toAnnotation() {
-    return new ClearFormattingAnnotation();
-  }
-}
-
-/**
- * Update the text node property text action
- *
- * @example textNode.apply(new UpdateTextAction(newText))
- */
-class UpdateTextAction extends ModifyContentAction {
-  constructor(text) {
-    super();
-    this.type = ModifyContentActionType.UPDATE_TEXT;
-    this.newTextContent = '';
-    this.newTextContent = text;
-  }
-}
-
-/**
- * Annotation to represent a link of grouped nodes
- */
-class LinkGroupAnnotation extends Annotation {
-  constructor(groupKey) {
-    super();
-    this.type = InternalAnnotationTypeEnum.LINK_GROUP;
-    this.linkGroups = new Map();
-    this.linkGroups = new Map([[groupKey, []]]);
-  }
-}
-
-/**
- * Action to link a group of nodes
- */
-class LinkGroupAnnotationAction extends AnnotationAction {
-  constructor(groupKey, nodes) {
-    super();
-    this.isFlushable = false;
-    this.groupKey = groupKey;
-    this.nodes = nodes;
-  }
-  /**
-   * Converts the action to an annotation
-   *
-   * @returns {LinkGroupAnnotation} The annotation
-   */
-  toAnnotation() {
-    return new LinkGroupAnnotation(this.groupKey);
-  }
-}
-
-/**
- * Sync up selection action
- */
-class SyncUpSelectionAction extends AnnotationAction {
-  constructor() {
-    super();
-    this.isFlushable = false;
-  }
-  /**
-   * annotation null
-   *
-   * @returns {Nullable<Annotation>} null
-   */
-  toAnnotation() {
-    return null;
-  }
-}
-
-/**
- * Delete the node annotation by type
- */
-class DeleteNodeAnnotationAction extends AnnotationAction {
-  constructor(annotationType) {
-    super();
-    this.isFlushable = true;
-    this.annotationType = annotationType;
-  }
-  /**
-   * Don't need this for this action
-   *
-   * @returns {Nullable<Annotation>} undefined
-   */
-  toAnnotation() {
-    return undefined;
-  }
-}
-
-/**
- * Text node
- */
-class RTETextNode extends RTENode {
-  constructor(id, text, parentBlock, annotationMap) {
-    super(id, annotationMap);
-    this.type = NodeTypeEnum.TEXT;
-    this.parentBlock = parentBlock;
-    this.text = text;
-  }
-  /**
-   * Creates an RTETextNode from a VegaRTETextNode with annotations and a parent RTETextBlock.
-   *
-   * @param {VegaRTETextNode} richText - A rich text node
-   * @param {RTETextBlock} parentBlock - Parent block
-   * @returns {RTETextNode} an RTETextNode
-   */
-  static from(richText, parentBlock) {
-    const textNode = new RTETextNode(richText.id, richText.text, parentBlock);
-    const { annotations } = richText;
-    if (annotations) {
-      textNode.annotationMap = new Map(Object.keys(annotations)
-        .map((type) => {
-        if (annotations.link) {
-          parentBlock.apply(new LinkGroupAnnotationAction(annotations.link.groupKey, [textNode]));
-        }
-        return this.createAnnotationEntity(type, annotations[type]);
-      })
-        .filter(isNonNullable));
-    }
-    return textNode;
-  }
-  /**
-   * Creates different types of text annotations based on the provided type and value.
-   *
-   * @param {keyof VegaRTETextAnnotations} type - The key of the type.
-   * @param {unknown} value - The value that will be used to create the specific type of annotation entity based on the `type` provided.
-   * @returns {Nullable<[RTENodeAnnotationMapKey, RTENodeAnnotationMapValue]>} Returning a nullable tuple containing a key and a
-   * value from the `RTENodeAnnotationMapKey` and `RTENodeAnnotationMapValue` types.
-   */
-  static createAnnotationEntity(type, value) {
-    switch (type) {
-      case 'bold':
-        return BoldAnnotation.from(value);
-      case 'italic':
-        return ItalicAnnotation.from(value);
-      case 'underline':
-        return UnderlineAnnotation.from(value);
-      case 'strikethrough':
-        return StrikethroughAnnotation.from(value);
-      case 'code':
-        return CodeAnnotation.from(value);
-      case 'textColor':
-        return TextColorAnnotation.from(value);
-      case 'link':
-        return LinkAnnotation.from(value);
-    }
-  }
-  /**
-   * @inheritDoc
-   */
-  toJSON() {
-    const annotations = Array.from(this.annotationMap.values())
-      .filter((annotation) => annotation instanceof NodeAnnotation)
-      .reduce((record, annotation) => {
-      return Object.assign(Object.assign({}, record), annotation.toJSON());
-    }, {});
-    return Object.assign(Object.assign({ id: this.id }, (Object.keys(annotations).length > 0 ? { annotations } : {})), { type: 'text', text: this.text });
-  }
-  /**
-   * Creates a new RTETextNode with the specified text and copies the parent block and annotation map from the original node.
-   *
-   * @param {string} text - The text content of the RTETextNode that will be created.
-   * @returns {RTETextNode} An new RTETextNode
-   */
-  cloneWithText(text) {
-    return new RTETextNode(generateUUID(), text, this.parentBlock, new Map(this.annotationMap));
-  }
-  /**
-   * Checks if a node is empty
-   *
-   * @returns {boolean}  It returns `true` if the node is empty
-   */
-  isEmpty() {
-    return !this.text || this.text === ZERO_WIDTH_SPACE || this.text === '\n';
-  }
-  /**
-   * @inheritDoc
-   */
-  doAnnotationActionApply(action) {
-    const selectionRangeAnnotation = this.getAnnotationByType(InternalAnnotationTypeEnum.SELECTION_RANGE);
-    if (action instanceof TextSplittableAction && action.doSplit && selectionRangeAnnotation) {
-      const { startContainer, endContainer, startOffset, endOffset } = selectionRangeAnnotation.range;
-      const noTextRangeSelected = startContainer === endContainer && startOffset === endOffset;
-      this.parentBlock.nodes = this.parentBlock.nodes.flatMap((item) => {
-        if (item.id === this.id) {
-          if (noTextRangeSelected) {
-            return this.insertNewNode(startOffset, action);
-          }
-          if (this.shouldSplitSelection(selectionRangeAnnotation.range)) {
-            return this.splitTextNode(action, selectionRangeAnnotation.range);
-          }
-          else {
-            this.applyActionToNode(this, action);
-            return this;
-          }
-        }
-        return item;
-      });
-    }
-    else {
-      this.applyActionToNode(this, action);
-    }
-    this.parentBlock.mergeNodes(action);
-  }
-  /**
-   * @inheritDoc
-   */
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.UPDATE_TEXT:
-        this.updateText(action.newTextContent);
-        break;
-      case ModifyContentActionType.REPLACE_SELECTED_TEXT:
-        this.replaceSelectedText(action.textToBeInsert, action.currentRange);
-        break;
-    }
-  }
-  /**
-   * Split text node with range
-   *
-   * @param {TextSplittableAction} action - Annotation action
-   * @param {Range} range - Selection range
-   * @returns {RTETextNode[] | this} RTETextNode array
-   */
-  splitTextNode(action, range) {
-    const { startContainer, endContainer, startOffset } = range;
-    const startNode = startContainer.parentElement;
-    const endNode = endContainer.parentElement;
-    /**
-     * Split the text from the start offset to the end offset
-     *
-     * @param {string} text - The text string
-     * @param {number} startOffset - The start offset position
-     * @param {number} endOffset - The end offset position
-     * @returns {RTETextNode[]} - The split text node array
-     */
-    const splitText = (text, startOffset, endOffset) => {
-      const beforeText = text.substring(0, startOffset);
-      const selectedText = text.substring(startOffset, endOffset);
-      const afterText = text.substring(endOffset);
-      return [
-        this.cloneWithText(beforeText),
-        this.cloneWithText(selectedText),
-        this.cloneWithText(afterText),
-      ];
-    };
-    const startItemDto = startNode && stateEntityRenderingRegistry.getEntityByDOM(startNode);
-    const endItemDto = endNode && stateEntityRenderingRegistry.getEntityByDOM(endNode);
-    if (startItemDto && startItemDto.id === this.id) {
-      const endOffset = startContainer === endContainer ? range.endOffset : this.text.length;
-      const [beforeNode, selectedNode, afterNode] = splitText(this.text, startOffset, endOffset);
-      this.applyActionToNode(selectedNode, action);
-      return [beforeNode, selectedNode, afterNode].filter((node) => !!node.text);
-    }
-    else if (endItemDto && endItemDto.id === this.id) {
-      const [beforeNode, selectedNode, afterNode] = splitText(this.text, 0, range.endOffset);
-      this.applyActionToNode(selectedNode, action);
-      return [beforeNode, selectedNode, afterNode].filter((node) => !!node.text);
-    }
-    else {
-      this.applyActionToNode(this, action);
-      return this;
-    }
-  }
-  /**
-   * Apply action to node
-   *
-   * @param {RTETextNode} node - Text node
-   * @param {AnnotationAction} action - AnnotationAction
-   */
-  applyActionToNode(node, action) {
-    const annotation = action.toAnnotation();
-    if (action instanceof SyncUpSelectionAction) {
-      this.syncUpSelectedNodes(node);
-      return;
-    }
-    // Sync up RTETextNode selected state to selection controller for any action apply, except selection range change.
-    if (!(annotation instanceof SelectionRangeAnnotation)) {
-      this.syncUpSelectedNodes(node);
-    }
-    if (action instanceof DeleteNodeAnnotationAction) {
-      this.annotationMap.delete(action.annotationType);
-      return;
-    }
-    if (annotation instanceof ClearFormattingAnnotation) {
-      annotation.items.forEach((item) => {
-        node.deleteAnnotationByType(item);
-      });
-      return;
-    }
-    if (annotation instanceof NodeAnnotation || annotation instanceof SelectionRangeAnnotation) {
-      if (action instanceof LinkAnnotationAction) {
-        if (isNonNullable(action.newText)) {
-          node.text = action.newText;
-        }
-        this.parentBlock.apply(new LinkGroupAnnotationAction(action.link.groupKey, [node]));
-      }
-      if (action instanceof CodeAnnotationAction) {
-        this.applyActionToNode(node, new ClearFormattingAnnotationAction());
-      }
-      node.annotationMap.set(annotation.type, annotation);
-      return;
-    }
-  }
-  /**
-   * Replaces the selected text within a given range with a new text in a TypeScript class.
-   *
-   * @param {string} text - The new text that will replace the currently selected text within the specified range.
-   * @param {RTERange} currentRange - A range of text within a Rich Text Editor (RTE).
-   */
-  replaceSelectedText(text, currentRange) {
-    if (currentRange && currentRange.startContainer && currentRange.endContainer) {
-      const { startContainer, endContainer, startOffset, endOffset } = currentRange;
-      const startNode = startContainer.parentElement;
-      const endNode = endContainer.parentElement;
-      const startItemDto = startNode && stateEntityRenderingRegistry.getEntityByDOM(startNode);
-      const endItemDto = endNode && stateEntityRenderingRegistry.getEntityByDOM(endNode);
-      let startIndex = 0, endIndex = this.text.length;
-      if (startItemDto && startItemDto === this) {
-        startIndex = startOffset;
-        endIndex = startContainer === endContainer ? endOffset : endIndex;
-      }
-      else if (endItemDto && endItemDto === this) {
-        endIndex = endOffset;
-      }
-      this.apply(new UpdateTextAction(this.text.slice(0, startIndex) + text + this.text.slice(endIndex)));
-    }
-  }
-  /**
-   * Updates the text content of a node and unlink the node if it is a link node and the text is deleted.
-   *
-   * @param {string} newText - The new text string
-   */
-  updateText(newText) {
-    this.text = newText;
-    // The link node should unlink when delete all text
-    if (!this.text && this.isLinkNode()) {
-      this.annotationMap.delete(NodeAnnotationTypeEnum.LINK);
-    }
-  }
-  /**
-   * Checks if a node has an annotation with the key 'LINK'.
-   *
-   * @returns {boolean} A boolean value indicating whether the `annotationMap` has a key 'LINK'.
-   */
-  isLinkNode() {
-    return this.annotationMap.has('LINK');
-  }
-  /**
-   * Whether a given range should be split based on various conditions within the range.
-   *
-   * @param {Range} range - Selection range
-   * @returns {boolean} Returns a boolean value indicating whether the
-   * selection range should be split.
-   */
-  shouldSplitSelection(range) {
-    const { startContainer, endContainer, startOffset, endOffset } = range;
-    const isCrossNode = startContainer !== endContainer;
-    const isPartialStart = startOffset > 0;
-    const isPartialEnd = endOffset < (endContainer.textContent ? endContainer.textContent.length : 0);
-    const isPartialSelection = isPartialStart || isPartialEnd;
-    return isCrossNode || isPartialSelection;
-  }
-  /**
-   * Sync up the selected node by change manager
-   *
-   * @param {RTETextNode} selectedNode - The selected node
-   */
-  syncUpSelectedNodes(selectedNode) {
-    const currentNodeDom = stateEntityRenderingRegistry.getDOMByEntity(this);
-    if (currentNodeDom) {
-      const nodeSubject = domNodeSubjectFactory.getSubjectFromParentNodeByEventId(currentNodeDom, VegaInternalRichTextEditorSelectionRangeChange);
-      if (nodeSubject) {
-        ChangeManager.notify(nodeSubject, { node: selectedNode });
-      }
-    }
-  }
-  /**
-   * Insert the new node at the start offset
-   *
-   * @param {number} startOffset - The start position offset
-   * @param {AnnotationAction} action - AnnotationAction
-   * @returns {RTETextNode[]} - RTETextNode array
-   */
-  insertNewNode(startOffset, action) {
-    if (startOffset === 0) {
-      const newNode = this.cloneWithText('');
-      this.applyActionToNode(newNode, action);
-      return [newNode, this];
-    }
-    if (startOffset === this.text.length) {
-      const newNode = this.cloneWithText('');
-      this.applyActionToNode(newNode, action);
-      return [this, newNode];
-    }
-    const beforeNode = this.cloneWithText(this.text.substring(0, startOffset));
-    const newNode = this.cloneWithText('');
-    const afterNode = this.cloneWithText(this.text.substring(startOffset));
-    this.applyActionToNode(newNode, action);
-    return [beforeNode, newNode, afterNode];
-  }
-}
-
-/**
- * Text style annotation
- */
-class TextStyleAnnotation extends BlockAnnotation {
-  constructor(textStyle) {
-    super();
-    this.type = BlockAnnotationTypeEnum.TEXT_STYLE;
-    this.textStyle = textStyle;
-  }
-  /**
-   * Generate the map item for the annotations
-   *
-   * @param {VegaRTETextStyleType} textStyle - the text style type
-   * @returns {[BlockAnnotationTypeEnum.TEXT_STYLE, TextStyleAnnotation]} Map item for the annotation
-   */
-  static from(textStyle) {
-    return [BlockAnnotationTypeEnum.TEXT_STYLE, new TextStyleAnnotation(textStyle)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Nullable<Record<string, unknown>>} JSON representation of the annotation
-   */
-  toJSON() {
-    return { textStyle: this.textStyle };
-  }
-  /**
-   * Render the styles by block type
-   *
-   * @returns {AnnotationStyle} the styles to apply
-   */
-  render() {
-    const paragraphStyle = {
-      fontFamily: 'Inter',
-      fontSize: '16px',
-      lineHeight: '22px',
-      fontWeight: '500',
-    };
-    switch (this.textStyle) {
-      case 'paragraph': {
-        return paragraphStyle;
-      }
-      case 'title': {
-        return { fontFamily: 'Inter', fontSize: '36px', lineHeight: '40px', fontWeight: '500' };
-      }
-      case 'subtitle': {
-        return { fontFamily: 'Inter', fontSize: '28px', lineHeight: '32px', fontWeight: '500' };
-      }
-      case 'heading-1': {
-        return { fontFamily: 'Inter', fontSize: '22px', lineHeight: '24px', fontWeight: '500' };
-      }
-      case 'heading-2': {
-        return { fontFamily: 'Inter', fontSize: '20px', lineHeight: '24px', fontWeight: '500' };
-      }
-      case 'heading-3': {
-        return { fontFamily: 'Inter', fontSize: '18px', lineHeight: '22px', fontWeight: '500' };
-      }
-    }
-  }
-}
-
-/**
- * Action to change the text style of a block
- */
-class TextStyleAnnotationAction extends AnnotationAction {
-  constructor(textStyle, bold) {
-    super();
-    this.isFlushable = true;
-    this.textStyle = textStyle;
-    this.bold = bold;
-  }
-  /**
-   * Converts the action to a block annotation
-   *
-   * @returns {BlockAnnotation} the block annotation
-   */
-  toAnnotation() {
-    return new TextStyleAnnotation(this.textStyle);
-  }
-}
-
-/**
- * Action to toggle bold annotation
- */
-class BoldAnnotationAction extends TextSplittableAction {
-  constructor(bold) {
-    super();
-    this.isFlushable = true;
-    this.bold = bold;
-  }
-  /**
-   * Converts the action to an annotation
-   *
-   * @returns {BoldAnnotation} the annotation
-   */
-  toAnnotation() {
-    return new BoldAnnotation(this.bold);
-  }
-}
-
-/**
- * Merge the two blocks node into first block if the two blocks nodes type is same(text node or image node)
- *
- * @example firstBlock.apply(new MergeTwoBlocksNodesAction(secondBlock))
- */
-class MergeTwoBlocksNodesAction extends ModifyContentAction {
-  constructor(blockNeedToBeMerged) {
-    super();
-    this.type = ModifyContentActionType.MERGE_TWO_BLOCKS_NODES;
-    this.blockNeedToBeMerged = blockNeedToBeMerged;
-  }
-}
-
-/**
- * Insert a new block before a existing block
- *
- * @example currentBlock.parent.apply(new InsertBlocksBeforeAction(currentBlock, newBlock, ...))
- */
-class InsertBlocksBeforeAction extends ModifyContentAction {
-  constructor(referBlock, ...blocksToBeInserted) {
-    super();
-    this.type = ModifyContentActionType.INSERT_BLOCKS_BEFORE;
-    this.referBlock = referBlock;
-    this.blocksToBeInserted = blocksToBeInserted;
-  }
-}
-
-/**
- * Text block
- */
-class RTETextBlock extends RTEBlock {
-  constructor(id, type) {
-    super(id);
-    this.nodes = [];
-    this.type = type;
-    if (RTETextBlock.isAcceptableTextStyle(type)) {
-      this.annotationMap = new Map([TextStyleAnnotation.from(type)]);
-    }
-    else {
-      this.annotationMap = new Map([TextStyleAnnotation.from('paragraph')]);
-    }
-  }
-  /**
-   * Converts a VegaRTETextBlock into an RTETextBlock.
-   *
-   * @param {VegaRTETextBlock} block - The block object
-   * @returns {RTETextBlock} A RTETextBlock class
-   */
-  static from(block) {
-    const textBlock = new RTETextBlock(block.id, block.type);
-    const { annotations } = block;
-    textBlock.nodes = block.nodes.map((richText) => RTETextNode.from(richText, textBlock));
-    if (annotations) {
-      Object.entries(annotations).forEach(([type, value]) => {
-        const item = this.createAnnotationEntity(type, value);
-        if (isNonNullable(item)) {
-          textBlock.annotationMap.set(...item);
-        }
-      });
-    }
-    return textBlock;
-  }
-  /**
-   * The function `createAnnotationEntity` creates a block annotation entity based on the provided type
-   * and value.
-   *
-   * @param {keyof VegaRTEBlockAnnotations} type - The `type` parameter is a key of the `VegaRTEBlockAnnotations` enum, which specifies
-   * the type of annotation entity to create.
-   * @param {unknown} value - The `value` parameter in the `createAnnotationEntity` function is the value
-   * that will be used to create the annotation entity. It can be of any type depending on the specific
-   * annotation being created.
-   * @returns {Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>} The `createAnnotationEntity` function returns a nullable tuple containing a
-   * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
-   */
-  static createAnnotationEntity(type, value) {
-    if (type === 'textStyle') {
-      return TextStyleAnnotation.from(value);
-    }
-    else {
-      return super.createAnnotationEntity(type, value);
-    }
-  }
-  /**
-   * Checks if a given text block type is one of the acceptable text styles.
-   *
-   * @param {VegaRTETextBlockType} type - The text block type
-   * @returns {boolean} Return a boolean value indicating whether the `type` parameter is valid.
-   */
-  static isAcceptableTextStyle(type) {
-    return ['title', 'subtitle', 'paragraph', 'heading-1', 'heading-2', 'heading-3'].includes(type);
-  }
-  /**
-   * Merges RTETextNode nodes based on certain conditions.
-   *
-   * @param {AnnotationAction} action - AnnotationAction
-   */
-  mergeNodes(action) {
-    this.nodes = this.nodes.reduce((prev, cur) => {
-      const lastNode = prev.at(-1);
-      if (action instanceof LinkAnnotationAction && action.needMergeNode) {
-        const lastNodeLinkAnnotation = lastNode === null || lastNode === void 0 ? void 0 : lastNode.getAnnotationByType(NodeAnnotationTypeEnum.LINK);
-        const curNodeLinkAnnotation = cur.getAnnotationByType(NodeAnnotationTypeEnum.LINK);
-        if (lastNodeLinkAnnotation &&
-          curNodeLinkAnnotation &&
-          lastNodeLinkAnnotation.toEqual(curNodeLinkAnnotation)) {
-          return prev;
-        }
-      }
-      // TODO: handle other cases like merge bold nodes
-      return [...prev, cur];
-    }, []);
-  }
-  /**
-   * @inheritDoc
-   */
-  toJSON() {
-    return Object.assign(Object.assign({}, super.toJSON()), { type: this.type, nodes: this.nodes.map((node) => node.toJSON()) });
-  }
-  /**
-   * Clone the nodes to a new block
-   *
-   * @param {RTEBlock} nodes - The nodes will be copied
-   * @returns {RTEBlock} New block
-   */
-  cloneWithNodes(nodes) {
-    const block = new RTETextBlock(generateUUID(), this.type);
-    block.nodes = [];
-    block.apply(new AppendChildNodesAction(nodes));
-    return block;
-  }
-  /**
-   * @inheritDoc
-   */
-  isNotEmpty() {
-    return this.nodes.length > 0 && this.nodes.some((node) => !node.isEmpty());
-  }
-  /**
-   * @inheritDoc
-   */
-  getLastNode() {
-    return this.nodes[this.nodes.length - 1];
-  }
-  /**
-   * @inheritDoc
-   */
-  doAnnotationActionApply(action) {
-    if (action instanceof TextStyleAnnotationAction) {
-      if (this.type !== 'list-item') {
-        this.type = action.textStyle;
-      }
-      if (action.bold) {
-        this.nodes.forEach((node) => {
-          const boldAnnotationAction = new BoldAnnotationAction(true);
-          boldAnnotationAction.doSplit = false;
-          node.apply(boldAnnotationAction);
-        });
-      }
-      else {
-        this.nodes.forEach((node) => {
-          node.apply(new DeleteNodeAnnotationAction(NodeAnnotationTypeEnum.BOLD));
-        });
-      }
-      return;
-    }
-    if (action instanceof LinkGroupAnnotationAction) {
-      const linkGroupAnnotation = this.getAnnotationByType(InternalAnnotationTypeEnum.LINK_GROUP);
-      if (linkGroupAnnotation) {
-        const linkGroup = linkGroupAnnotation.linkGroups.get(action.groupKey);
-        linkGroupAnnotation.linkGroups.set(action.groupKey, [...linkGroup, ...action.nodes]);
-        this.annotationMap.set(InternalAnnotationTypeEnum.LINK_GROUP, linkGroupAnnotation);
-      }
-      return;
-    }
-  }
-  /**
-   * Apply a modify action to block
-   *
-   * @param {ModifyContentAction} action - Modify action
-   */
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeChildNode(action);
-        break;
-      case ModifyContentActionType.APPEND_CHILD_NODES:
-        this.appendChildNodes(action.entityToBeAppended);
-        break;
-      case ModifyContentActionType.CLEAR_CHILD_NODES:
-        this.nodes = [];
-        break;
-      case ModifyContentActionType.SPLIT_BLOCK_WITH_NODE:
-        action.newBlock = this.splitTextNodeBlock(action.splitPointNode, action.startOffsetOfNode);
-        break;
-      case ModifyContentActionType.REPLACE_CHILD_NODES:
-        this.nodes = [];
-        this.appendChildNodes(action.newChildNodes);
-        break;
-      case ModifyContentActionType.MERGE_TWO_BLOCKS_NODES:
-        this.mergeTwoBlocksNodes(action.blockNeedToBeMerged);
-        break;
-      case ModifyContentActionType.BREAK_SINGLE_BLOCK:
-        action.newBlock = this.breakSingleTextBlock(action.startContainerNode, action.startOffset);
-        break;
-      case ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK:
-        action.lineBreakNode = this.lineBreakSingleBlock(action.startContainerNode, action.startOffset);
-        break;
-      case ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS:
-        action.lineBreakNode = this.lineBreakMultipleBlocks(action.selectedBlocks);
-        break;
-      case ModifyContentActionType.TRANSFORM_LIST_BLOCK:
-        this.convertParagraphToList(action);
-        break;
-      case ModifyContentActionType.DELETE_BLOCK_CONTENT:
-        this.deleteNodeContent(action);
-        break;
-      case ModifyContentActionType.INSERT_IMAGE_TO_BLOCK:
-        this.insertImage(action);
-        break;
-      case ModifyContentActionType.INSERT_NODES_BEFORE:
-        this.replaceNodeWithNodes(action.referNode, [
-          ...action.nodesToBeInserted,
-          action.referNode,
-        ]);
-        break;
-    }
-  }
-  /**
-   * Splits a text node at a specified offset within a block of nodes and returns a new block with the split nodes.
-   *
-   * @param {RTETextNode} splitNode - The text node that will be split
-   * @param {number} startOffsetOfNode - The index at which will split the text content of the `splitNode`.
-   * @returns {Nullable<RTEBlock>} return either an RTEBlock object or null.
-   */
-  splitTextNodeBlock(splitNode, startOffsetOfNode) {
-    if (splitNode) {
-      const beforeText = splitNode.text.slice(0, startOffsetOfNode);
-      const afterText = splitNode.text.slice(startOffsetOfNode);
-      const nodesSplitIndex = this.nodes.indexOf(splitNode);
-      if (nodesSplitIndex > -1) {
-        const beforeNodes = this.nodes.slice(0, nodesSplitIndex);
-        const afterNodes = this.nodes.slice(nodesSplitIndex + 1);
-        if (beforeText) {
-          beforeNodes.push(splitNode.cloneWithText(beforeText));
-        }
-        if (afterText) {
-          afterNodes.unshift(splitNode.cloneWithText(afterText));
-        }
-        this.apply(new ReplaceChildNodesAction(beforeNodes));
-        const newBlock = this.cloneWithNodes(afterNodes);
-        this.parent.apply(new InsertBlocksAfterAction(this, newBlock));
-        return newBlock;
-      }
-    }
-  }
-  /**
-   * Checks if the caret position is at the start of a specified RTETextNode.
-   *
-   * @param {RTETextNode} node - `RTETextNode` - a node representing an image in a rich text editor.
-   * @param {number} startOffset - The position within the text node where the caret is located.
-   * @returns {boolean} a boolean value, which indicates whether the caret position is at the start of the RTETextNode.
-   */
-  isCaretPositionAtStart(node, startOffset) {
-    return node === this.nodes[0] && startOffset === 0;
-  }
-  /**
-   * Checks if the caret position is at the end of a specified RTETextNode.
-   *
-   * @param {RTETextNode} node - `RTETextNode` - a node representing an image in a rich text editor.
-   * @param {number} startOffset - The position within the text node where the caret is located.
-   * @returns {boolean} a boolean value, which indicates whether the caret position is at the start of the RTETextNode.
-   */
-  isCaretPositionAtEnd(node, startOffset) {
-    const lastNode = this.nodes[this.nodes.length - 1];
-    return node === lastNode && (node.isEmpty() || startOffset === lastNode.text.length);
-  }
-  /**
-   * lineBreakSingleBlock
-   *
-   * @param {RTETextNode} splitNode -
-   * @param {number} startOffsetOfNode -
-   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
-   */
-  lineBreakSingleBlock(splitNode, startOffsetOfNode) {
-    if (splitNode) {
-      const lineBreakNode = new RTETextNode(generateUUID(), '\n', this);
-      const beforeText = splitNode.text.slice(0, startOffsetOfNode);
-      const afterText = splitNode.text.slice(startOffsetOfNode);
-      const nodesSplitIndex = this.nodes.indexOf(splitNode);
-      if (nodesSplitIndex > -1) {
-        const beforeNodes = this.nodes.slice(0, nodesSplitIndex);
-        const afterNodes = this.nodes.slice(nodesSplitIndex + 1);
-        if (beforeText) {
-          beforeNodes.push(splitNode.cloneWithText(beforeText));
-        }
-        if (afterText) {
-          afterNodes.unshift(splitNode.cloneWithText(afterText));
-        }
-        this.mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes);
-      }
-      return lineBreakNode;
-    }
-  }
-  /**
-   * lineBreakMultipleBlocks
-   *
-   * @param {RTEBlock[]} selectedBlocks -
-   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
-   */
-  lineBreakMultipleBlocks(selectedBlocks) {
-    const beforeNodes = this['nodes'];
-    const lineBreakNode = new RTETextNode(generateUUID(), '\n', this);
-    const afterNodes = this.concatBlocksNodes(selectedBlocks.slice(1));
-    this.mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes);
-    return lineBreakNode;
-  }
-  /**
-   * deleteNodeContent
-   *
-   * @param {DeleteBlockContentAction} action - ModifyContentAction
-   */
-  deleteNodeContent(action) {
-    const startContainerNode = action.startContainerNode;
-    const startOffset = action.startOffset;
-    if (startOffset !== 0 && !startContainerNode.isEmpty()) {
-      const newText = startContainerNode.text.slice(0, startOffset - 1) +
-        startContainerNode.text.slice(startOffset);
-      startContainerNode.apply(new UpdateTextAction(newText));
-      if (newText) {
-        action.previousNode = startContainerNode;
-        return;
-      }
-      else {
-        const previousNode = this.getPreviousNode(startContainerNode);
-        // Remove the last character will not delete paragraph, the paragraph will removed after press delete again
-        if ((previousNode && previousNode.parentBlock === this && previousNode['text'] === '\n') ||
-          this.nodes.length === 1) {
-          action.previousNode = startContainerNode;
-          return;
-        }
-        else {
-          this.apply(new RemoveChildAction(startContainerNode));
-          action.previousNode = previousNode;
-          return;
-        }
-      }
-    }
-    else {
-      let previousNode = this.getPreviousNode(startContainerNode);
-      let nextNode = null;
-      if (this.nodes.length && previousNode && previousNode.parentBlock !== this) {
-        if (startContainerNode.isEmpty()) {
-          this.apply(new RemoveChildAction(startContainerNode));
-        }
-        previousNode.parentBlock.apply(new MergeTwoBlocksNodesAction(this));
-      }
-      else {
-        if (this.isContentFirstNode(startContainerNode) && startContainerNode.isEmpty()) {
-          nextNode = this.getNextNode(startContainerNode);
-        }
-        /**
-         * Remove line break
-         *
-         * @example caret at the first line
-         * \n
-         * test
-         */
-        if (startContainerNode.isEmpty()) {
-          this.apply(new RemoveChildAction(startContainerNode));
-        }
-        /**
-         * Remove line break
-         *
-         * @example caret at the begin of second line
-         * \n
-         * test
-         */
-        if (previousNode instanceof RTETextNode && previousNode.isEmpty()) {
-          const shouldRemoveNode = previousNode;
-          previousNode = this.getPreviousNode(previousNode);
-          shouldRemoveNode.parentBlock.apply(new RemoveChildAction(shouldRemoveNode));
-          if (!previousNode) {
-            nextNode = startContainerNode;
-          }
-        }
-      }
-      //Remove the paragraph block if the content is empty
-      if (this.nodes.length === 0) {
-        this.parent.apply(new RemoveChildAction(this));
-      }
-      if (previousNode) {
-        action.previousNode = previousNode;
-      }
-      else if (nextNode) {
-        action.nextNode = nextNode;
-      }
-    }
-  }
-  /**
-   * Remove the child node
-   *
-   * @param {RemoveChildAction} action - Modify action
-   */
-  removeChildNode(action) {
-    this.nodes = this.nodes.filter((node) => node !== action.entityToBeRemoved);
-    if (this.nodes.length === 0) {
-      this.parent.apply(new RemoveChildAction(this));
-    }
-  }
-  /**
-   * mergeLineBreakNodes
-   *
-   * @param {RTENode[]} beforeNodes -
-   * @param {RTETextNode} lineBreakNode -
-   * @param {RTENode[]} afterNodes -
-   */
-  mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes) {
-    if (afterNodes.length === 0 || (afterNodes[0] && afterNodes[0].text === '')) {
-      afterNodes.push(new RTETextNode(generateUUID(), '\n', this, beforeNodes[beforeNodes.length - 1] && beforeNodes[beforeNodes.length - 1].annotationMap));
-    }
-    this.apply(new ReplaceChildNodesAction([...beforeNodes, lineBreakNode, ...afterNodes]));
-  }
-  /**
-   * breakSingleTextBlock
-   *
-   * @param {RTETextNode} splitNode -
-   * @param {number} startOffsetOfNode -
-   * @returns {Nullable<RTEBlock>} Nullable<RTEBlock>
-   */
-  breakSingleTextBlock(splitNode, startOffsetOfNode) {
-    const newParagraph = this.copyInlineStyleToNewParagraph(splitNode);
-    if (this.isCaretPositionAtEnd(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksAfterAction(this, newParagraph));
-    }
-    else if (this.isCaretPositionAtStart(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, newParagraph));
-    }
-    else {
-      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      this.apply(splitBlockAction);
-      return splitBlockAction.newBlock;
-    }
-    return newParagraph;
-  }
-  /**
-   * convertParagraphToList
-   *
-   * @param {TransformListAction} action - ModifyContentAction
-   */
-  convertParagraphToList(action) {
-    const bulletList = this.parent.createList(action.listType);
-    const listItems = action.selectedBlocks.map((node) => this.parent.toListItem(node));
-    bulletList.apply(new AppendChildNodesAction(listItems));
-    this.parent.apply(new InsertBlocksAfterAction(action.selectedBlocks[0], bulletList));
-    action.selectedBlocks.forEach((node) => {
-      node.parent.apply(new RemoveChildAction(node));
-    });
-  }
-  /**
-   * insertImage
-   *
-   * @param {InsertImageToBlockAction} action - ModifyContentAction
-   */
-  insertImage(action) {
-    const splitNode = action.splitPointNode;
-    const startOffsetOfNode = action.startOffsetOfNode;
-    const newImageBlock = action.imageBlockToBeInserted;
-    if (this.isCaretPositionAtEnd(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksAfterAction(this, newImageBlock));
-    }
-    else if (this.isCaretPositionAtStart(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, newImageBlock));
-    }
-    else {
-      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      this.apply(splitBlockAction);
-      this.parent.apply(new InsertBlocksAfterAction(this, newImageBlock));
-    }
-  }
-  /**
-   * copyInlineStyleToNewParagraph
-   *
-   * @param {RTETextNode} needCopedNode -
-   * @returns {RTETextBlock} RTETextBlock
-   */
-  copyInlineStyleToNewParagraph(needCopedNode) {
-    const textNode = needCopedNode.cloneWithText('');
-    // The link annotation don't need inherited
-    textNode.annotationMap.delete(NodeAnnotationTypeEnum.LINK);
-    const newParagraph = new RTETextBlock(generateUUID(), 'paragraph');
-    newParagraph.apply(new AppendChildNodesAction([textNode]));
-    return newParagraph;
-  }
-}
-
-/**
- * Image block
- */
-class RTEImageBlock extends RTEBlock {
-  constructor(id) {
-    super(id);
-    this.type = 'image';
-    this.nodes = [];
-  }
-  /**
-   * 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.nodes = 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.nodes.map((node) => node.toJSON()) });
-  }
-  /**
-   * @inheritDoc
-   */
-  isNotEmpty() {
-    return this.nodes.length > 0 && this.nodes.some((node) => node.url.length > 0);
-  }
-  /**
-   * @inheritDoc
-   */
-  getLastNode() {
-    return this.nodes[this.nodes.length - 1];
-  }
-  /**
-   * Apply a modify action to block
-   *
-   * @param {ModifyContentAction} action - Modify action
-   */
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeChildNode(action);
-        break;
-      case ModifyContentActionType.CLEAR_CHILD_NODES:
-        this.nodes = [];
-        break;
-      case ModifyContentActionType.APPEND_CHILD_NODES:
-        this.appendChildNodes(action.entityToBeAppended);
-        break;
-      case ModifyContentActionType.REPLACE_CHILD_NODES:
-        this.nodes = [];
-        this.appendChildNodes(action.newChildNodes);
-        break;
-      case ModifyContentActionType.SPLIT_BLOCK_WITH_NODE:
-        action.newBlock = this.splitImageNodes(action.splitPointNode, action.startOffsetOfNode);
-        break;
-      case ModifyContentActionType.MERGE_TWO_BLOCKS_NODES:
-        this.mergeTwoBlocksNodes(action.blockNeedToBeMerged);
-        break;
-      case ModifyContentActionType.BREAK_SINGLE_BLOCK:
-        action.newBlock = this.breakSingleBlock(action.startContainerNode, action.startOffset);
-        break;
-      case ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK:
-        action.lineBreakNode = this.lineBreakSingleBlock(action.startContainerNode, action.startOffset);
-        break;
-      case ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS:
-        action.lineBreakNode = this.lineBreakMultipleBlocks(action.selectedBlocks);
-        break;
-      case ModifyContentActionType.DELETE_BLOCK_CONTENT:
-        this.deleteNodeContent(action);
-        break;
-      case ModifyContentActionType.INSERT_IMAGE_TO_BLOCK:
-        this.insertImage(action);
-        break;
-      case ModifyContentActionType.INSERT_NODES_AFTER:
-        this.replaceNodeWithNodes(action.referNode, [
-          action.referNode,
-          ...action.nodesToBeInserted,
-        ]);
-        break;
-      case ModifyContentActionType.INSERT_NODES_BEFORE:
-        this.replaceNodeWithNodes(action.referNode, [
-          ...action.nodesToBeInserted,
-          action.referNode,
-        ]);
-        break;
-    }
-  }
-  /**
-   * Removes a specified child node from a list of nodes and triggers a parent action if the list becomes empty.
-   *
-   * @param {RemoveChildAction} action - Action to be performed when removing a child node from the list of nodes.
-   */
-  removeChildNode(action) {
-    this.nodes = this.nodes.filter((node) => node !== action.entityToBeRemoved);
-    if (this.nodes.length === 0) {
-      this.parent.apply(new RemoveChildAction(this));
-    }
-  }
-  /**
-   * 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
-   * @returns {Nullable<RTEBlock>} The new block after split
-   */
-  splitImageNodes(imageNode, imageOffset) {
-    const nodesSplitIndex = this.nodes.indexOf(imageNode);
-    if (nodesSplitIndex > -1) {
-      const beforeNodes = this.nodes.slice(0, nodesSplitIndex + imageOffset);
-      const afterNodes = this.nodes.slice(nodesSplitIndex + imageOffset);
-      this.apply(new ReplaceChildNodesAction(beforeNodes));
-      const newBlock = this.cloneWithNodes(afterNodes);
-      this.parent.apply(new InsertBlocksAfterAction(this, 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.
-   * @returns {RTEImageBlock} A new `RTEImageBlock` object with the provided `nodes` appended to it.
-   */
-  cloneWithNodes(nodes) {
-    const block = new RTEImageBlock(generateUUID());
-    block.nodes = [];
-    block.apply(new AppendChildNodesAction(nodes));
-    return block;
-  }
-  /**
-   * 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.
-   * @returns {Nullable<RTEBlock>} Returns either a new paragraph block or the new block created after splitting the original block.
-   */
-  breakSingleBlock(splitNode, startOffsetOfNode) {
-    const newParagraph = RTETextBlock.from({
-      id: generateUUID(),
-      type: 'paragraph',
-      nodes: [{ id: generateUUID(), type: 'text', text: '' }],
-    });
-    if (this.isCaretPositionAtEnd(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksAfterAction(this, newParagraph));
-    }
-    else if (this.isCaretPositionAtStart(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, newParagraph));
-    }
-    else {
-      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      this.apply(splitBlockAction);
-      return splitBlockAction.newBlock;
-    }
-    return newParagraph;
-  }
-  /**
-   * Breaks a single block of text at a specified offset and returns the first node of the new paragraph if created.
-   *
-   * @param {RTEImageNode} splitNode - It represents a node in a rich text editor that contains an image.
-   * @param {number} startOffset - The index at which the line break should occur within the `RTEImageNode` block.
-   * @returns {Nullable<RTETextNode>} Returning the first node of the `newParagraph` block if `newParagraph` is not null.
-   */
-  lineBreakSingleBlock(splitNode, startOffset) {
-    const newParagraph = this.breakSingleBlock(splitNode, startOffset);
-    if (newParagraph) {
-      return newParagraph['nodes'][0];
-    }
-  }
-  /**
-   * Checks if the caret position is at the start of a specified RTEImageNode.
-   *
-   * @param {RTEImageNode} node - `RTEImageNode` - a node representing an image in a rich text editor.
-   * @param {number} startOffset - The position within the text node where the caret is located.
-   * @returns {boolean} a boolean value, which indicates whether the caret position is at the start of the RTEImageNode.
-   */
-  isCaretPositionAtStart(node, startOffset) {
-    return node === this.nodes[0] && startOffset === 0;
-  }
-  /**
-   * Checks if the caret position is at the end of a given RTEImageNode.
-   *
-   * @param {RTEImageNode} node - `node` is a RTEImageNode
-   * @param {number} startOffset - The position within the `RTEImageNode` where the caret is located.
-   * @returns {boolean}Returns a boolean value indicating whether the caret position is at the end of the `RTEImageNode`.
-   */
-  isCaretPositionAtEnd(node, startOffset) {
-    const lastNode = this.nodes[this.nodes.length - 1];
-    return node === lastNode && startOffset === 1;
-  }
-  /**
-   * 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.
-   * @returns {Nullable<RTETextNode>} Returns a Nullable RTETextNode.
-   */
-  lineBreakMultipleBlocks(selectedBlocks) {
-    const newParagraph = RTETextBlock.from({
-      id: generateUUID(),
-      type: 'paragraph',
-      nodes: [{ id: generateUUID(), type: 'text', text: '\n' }],
-    });
-    this.parent.apply(new InsertBlocksAfterAction(this, 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['nodes'][0];
-  }
-  /**
-   * Deletes content from a block node based on specific conditions.
-   *
-   * @param {DeleteBlockContentAction} action - Delete block content action
-   */
-  deleteNodeContent(action) {
-    const startContainerNode = action
-      .startContainerNode, startOffset = action.startOffset;
-    let previousNode = this.getPreviousNode(startContainerNode);
-    let nextNode = null;
-    if (startOffset === 1) {
-      const parentBlock = startContainerNode.parentBlock;
-      if (this.isContentFirstNode(startContainerNode)) {
-        nextNode = this.getNextNode(startContainerNode);
-      }
-      if (parentBlock.nodes.length === 1) {
-        parentBlock.parent.apply(new RemoveChildAction(parentBlock));
-      }
-      else {
-        startContainerNode.parentBlock.apply(new RemoveChildAction(startContainerNode));
-      }
-    }
-    else {
-      const shouldRemoveNode = previousNode;
-      if (shouldRemoveNode && shouldRemoveNode instanceof RTEImageNode) {
-        previousNode = this.getPreviousNode(shouldRemoveNode);
-        shouldRemoveNode.parentBlock.apply(new RemoveChildAction(shouldRemoveNode));
-        if (!previousNode) {
-          action.nextNode = startContainerNode;
-        }
-      }
-    }
-    if (previousNode) {
-      action.previousNode = previousNode;
-    }
-    else if (nextNode) {
-      action.nextNode = nextNode;
-    }
-  }
-  /**
-   * Image will always create new image block
-   *
-   * @param {InsertImageToBlockAction} action insert image to current block
-   */
-  insertImage(action) {
-    const splitNode = action.splitPointNode;
-    const startOffsetOfNode = action.startOffsetOfNode;
-    const newImageNodes = action.imageBlockToBeInserted.nodes;
-    const newImageBlock = action.imageBlockToBeInserted;
-    if (this.nodes.length < 1) {
-      this.apply(new AppendChildNodesAction(newImageNodes));
-    }
-    else if (this.isCaretPositionAtEnd(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksAfterAction(this, newImageBlock));
-    }
-    else if (this.isCaretPositionAtStart(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, newImageBlock));
-    }
-    else {
-      this.apply(new SplitBlockWithNodeAction(splitNode, startOffsetOfNode));
-      this.parent.apply(new InsertBlocksAfterAction(this, newImageBlock));
-    }
-  }
-}
-
-/**
- * List item block
- */
-class RTEListItemBlock extends RTETextBlock {
-  constructor(id, children) {
-    super(id, 'list-item');
-    this.children = [];
-    this.children = children;
-  }
-  /**
-   * Converts a VegaRTEListItemBlock object to an RTEListItemBlock
-   *
-   * @param {VegaRTEListBlock} block - Converts a `VegaRTEListItemBlock` object into an `RTEListItemBlock`.
-   * @returns {RTEListBlock} Return an instance of `RTEListItemBlock`
-   */
-  static from(block) {
-    const listItemBlock = new RTEListItemBlock(block.id);
-    listItemBlock.nodes = block.nodes.map((richText) => RTETextNode.from(richText, listItemBlock));
-    if (block.children) {
-      listItemBlock.children = 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.children) === null || _a === void 0 ? void 0 : _a.map((block) => block.toJSON()) });
-  }
-  /**
-   * @inheritDoc
-   */
-  cloneWithNodes(nodes) {
-    const block = new RTEListItemBlock(generateUUID());
-    block.nodes = [];
-    block.apply(new AppendChildNodesAction(nodes));
-    return block;
-  }
-  /**
-   * @inheritDoc
-   */
-  isNotEmpty() {
-    if (this.children) {
-      return super.isNotEmpty() || this.children.some((block) => block.isNotEmpty());
-    }
-    else {
-      return super.isNotEmpty();
-    }
-  }
-  /**
-   * @inheritDoc
-   */
-  getLastNode() {
-    if (this.children && this.children.length > 0) {
-      const childListBlock = this.children[this.children.length - 1];
-      return childListBlock.getLastNode();
-    }
-    return super.getLastNode();
-  }
-  /**
-   * Apply a modify action to block
-   *
-   * @param {ModifyContentAction} action - Modify action
-   */
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeListChildNode(action);
-        break;
-      case ModifyContentActionType.DELETE_NEST_LIST:
-        this.removeNestList(action);
-        break;
-      case ModifyContentActionType.APPEND_CHILD_NODES:
-        this.appendChildNodes(action.entityToBeAppended);
-        break;
-      case ModifyContentActionType.CLEAR_CHILD_NODES:
-        this.nodes = [];
-        break;
-      case ModifyContentActionType.SPLIT_BLOCK_WITH_NODE:
-        this.splitListItemBlock(action);
-        break;
-      case ModifyContentActionType.REPLACE_CHILD_NODES:
-        this.nodes = [];
-        this.appendChildNodes(action.newChildNodes);
-        break;
-      case ModifyContentActionType.REPLACE_NEST_LIST:
-        this.replaceNestList(action.newList);
-        break;
-      case ModifyContentActionType.MERGE_TWO_BLOCKS_NODES:
-        this.mergeTwoBlocksNodes(action.blockNeedToBeMerged);
-        break;
-      case ModifyContentActionType.BREAK_SINGLE_BLOCK:
-        action.newBlock = this.breakSingleListItemBlock(action.startContainerNode, action.startOffset);
-        break;
-      case ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK:
-        action.lineBreakNode = this.lineBreakSingleBlock(action.startContainerNode, action.startOffset);
-        break;
-      case ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS:
-        action.lineBreakNode = this.lineBreakMultipleBlocks(action.selectedBlocks);
-        break;
-      case ModifyContentActionType.DELETE_BLOCK_CONTENT:
-        this.deleteListNodeContent(action);
-        break;
-      case ModifyContentActionType.INSERT_IMAGE_TO_BLOCK:
-        this.parent.apply(action);
-        break;
-      case ModifyContentActionType.INSERT_NODES_BEFORE:
-        this.replaceNodeWithNodes(action.referNode, [
-          ...action.nodesToBeInserted,
-          action.referNode,
-        ]);
-        break;
-    }
-  }
-  /**
-   * Remove the list child node
-   *
-   * @param {RemoveChildAction} action - Modify action
-   */
-  removeListChildNode(action) {
-    this.nodes = this.nodes.filter((node) => node !== action.entityToBeRemoved);
-    if (this.nodes.length === 0 && (!this.children || !this.children.length)) {
-      this.parent.apply(new RemoveChildAction(this));
-    }
-  }
-  /**
-   * Remove the nest list
-   *
-   * @param {RemoveNestListAction} action - Modify action
-   */
-  removeNestList(action) {
-    if (this.children) {
-      if (this.children.length > 1) {
-        this.children = this.children.filter((child) => child !== action.nestListBlockToBeRemoved);
-      }
-      else {
-        this.children = undefined;
-      }
-    }
-  }
-  /**
-   * Iterates through a list of RTEListBlock and sets their parent property to the current object, then replaces the children property with the new list.
-   *
-   * @param {RTEListBlock[]} newList - new list that you want to replace the existing children of the current object with.
-   */
-  replaceNestList(newList) {
-    newList.forEach((listBlock) => {
-      listBlock.parent = this;
-    });
-    this.children = newList;
-  }
-  /**
-   * Split list item block
-   *
-   * @param {SplitBlockWithNodeAction} action - Modify action
-   */
-  splitListItemBlock(action) {
-    action.newBlock = this.splitTextNodeBlock(action.splitPointNode, action.startOffsetOfNode);
-  }
-  /**
-   * 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.
-   * @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) {
-    const newListItem = new RTEListItemBlock(generateUUID());
-    const newBreakNode = this.copyInlineStyleToNewNode(splitNode);
-    newListItem.apply(new AppendChildNodesAction([newBreakNode]));
-    if (this.isCaretPositionAtEnd(splitNode, startOffsetOfNode)) {
-      return this.breakListItemAtEnd(newListItem);
-    }
-    else if (this.isCaretPositionAtStart(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, newListItem));
-    }
-    else {
-      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      this.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.
-   * @returns {RTEBlock} Returns a `RTEBlock`.
-   */
-  breakListItemAtEnd(newListItem) {
-    const lastItem = this.parent.blocks[this.parent.blocks.length - 1];
-    const currentItemIsEmpty = this.nodes.length === 1 && this.nodes[0].isEmpty();
-    if (this === lastItem && currentItemIsEmpty) {
-      const parentParent = this.parent.parent;
-      if (parentParent['type'] !== 'list-item') {
-        const newParagraph = RTETextBlock.from({
-          id: generateUUID(),
-          type: 'paragraph',
-          nodes: [],
-        });
-        newParagraph.apply(new AppendChildNodesAction(newListItem.nodes));
-        parentParent.apply(new InsertBlocksAfterAction(this.parent, newParagraph));
-        this.parent.apply(new RemoveChildAction(this));
-        return newParagraph;
-      }
-      else {
-        parentParent.parent.apply(new InsertBlocksAfterAction(parentParent, newListItem));
-        this.parent.apply(new RemoveChildAction(this));
-      }
-    }
-    else {
-      this.parent.apply(new InsertBlocksAfterAction(this, newListItem));
-    }
-    return newListItem;
-  }
-  /**
-   * Delete list node content
-   *
-   * @param {DeleteBlockContentAction} action - Modify action
-   */
-  deleteListNodeContent(action) {
-    const startContainerNode = action.startContainerNode;
-    const listBlock = startContainerNode.parentBlock.parent;
-    this.deleteNodeContent(action);
-    if (listBlock.blocks.length === 0) {
-      listBlock.parent.apply(new RemoveChildAction(listBlock));
-    }
-  }
-  /**
-   * 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;
-  }
-}
-
-/**
- * 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
- */
-class RTEListBlock extends RTEBlock {
-  constructor(id, type) {
-    super(id);
-    this.type = 'bullet-list';
-    this.blocks = [];
-    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.blocks = 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.blocks.map((block) => block.toJSON()) });
-  }
-  /**
-   * @inheritDoc
-   */
-  isNotEmpty() {
-    return (this.blocks.length > 0 &&
-      this.blocks.some((listItemBlock) => listItemBlock.isNotEmpty()));
-  }
-  /**
-   * @inheritDoc
-   */
-  getLastNode() {
-    return this.blocks[this.blocks.length - 1].getLastNode();
-  }
-  /**
-   * Apply a modify action to block
-   *
-   * @param {ModifyContentAction} action - Modify action
-   */
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeListItemBlock(action.entityToBeRemoved);
-        break;
-      case ModifyContentActionType.INSERT_BLOCKS_AFTER:
-        this.replaceBlockWithBlocks(action.referBlock, [
-          action.referBlock,
-          ...action.blocksToBeInserted,
-        ]);
-        break;
-      case ModifyContentActionType.INSERT_BLOCKS_BEFORE:
-        this.replaceBlockWithBlocks(action.referBlock, [
-          ...action.blocksToBeInserted,
-          action.referBlock,
-        ]);
-        break;
-      case ModifyContentActionType.APPEND_CHILD_NODES:
-        this.appendChildBlocks(action.entityToBeAppended);
-        break;
-      case ModifyContentActionType.TRANSFORM_LIST_BLOCK:
-        this.convertToList(action);
-        break;
-      case ModifyContentActionType.TRANSFORM_PARAGRAPH_BLOCK:
-        this.convertToParagraph(action);
-        break;
-      case ModifyContentActionType.INSERT_IMAGE_TO_BLOCK:
-        this.insertImage(action);
-        break;
-    }
-  }
-  /**
-   * 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['nodes']));
-    textBlock['annotationMap'] = block['annotationMap'];
-    return textBlock;
-  }
-  /**
-   * Covert block to List
-   *
-   * @param {TransformListAction} action - Modify action
-   */
-  convertToList(action) {
-    const selectedBlocks = action.selectedBlocks;
-    const bulletList = this.parent.createList(action.listType);
-    const isSameList = selectedBlocks.every((block) => block.parent === this);
-    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(this.blocks));
-      this.parent.apply(new InsertBlocksAfterAction(this, bulletList));
-      this.parent.apply(new RemoveChildAction(this));
-      selectedBlocks.forEach((block) => block.nodes.map((node) => node.apply(new SyncUpSelectionAction())));
-    }
-    else {
-      const listItems = action.selectedBlocks.map((block) => this.parent.toListItem(block));
-      bulletList.apply(new AppendChildNodesAction(listItems));
-      this.parent.apply(new InsertBlocksAfterAction(this, bulletList));
-      action.selectedBlocks.forEach((block) => {
-        block.parent.apply(new RemoveChildAction(block));
-      });
-      if (this.blocks.length === 0) {
-        this.parent.apply(new RemoveChildAction(this));
-      }
-    }
-  }
-  /**
-   * Covert block to paragraph
-   *
-   * @param {TransformListAction} action - Modify action
-   */
-  convertToParagraph(action) {
-    let isSelectedFirstBlock = false;
-    let isSelectedLastBlock = false;
-    const selectedBlocks = action.selectedBlocks;
-    const currentParagraph = selectedBlocks.map((block) => {
-      block.nodes.map((node) => node.apply(new SyncUpSelectionAction()));
-      if (block === this.blocks[0])
-        isSelectedFirstBlock = true;
-      if (block === this.blocks[this.blocks.length - 1])
-        isSelectedLastBlock = true;
-      return this.toParagraph(block);
-    });
-    if (isSelectedFirstBlock) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, ...currentParagraph));
-    }
-    else if (isSelectedLastBlock) {
-      this.parent.apply(new InsertBlocksAfterAction(this, ...currentParagraph));
-    }
-    else {
-      const startIndex = this.blocks.indexOf(selectedBlocks[0]);
-      const lastIndex = this.blocks.indexOf(selectedBlocks[selectedBlocks.length - 1]);
-      const firstBulletList = this.parent.createList(this.type);
-      firstBulletList.apply(new AppendChildNodesAction(this.blocks.slice(0, startIndex)));
-      const lastBulletList = this.parent.createList(this.type);
-      lastBulletList.apply(new AppendChildNodesAction(this.blocks.slice(lastIndex + 1)));
-      this.parent.apply(new InsertBlocksBeforeAction(this, firstBulletList, ...currentParagraph, lastBulletList));
-      this.parent.apply(new RemoveChildAction(this));
-    }
-    selectedBlocks.map((block) => {
-      this.apply(new RemoveChildAction(block));
-    });
-    if (this.blocks.length === 0) {
-      this.parent.apply(new RemoveChildAction(this));
-    }
-  }
-  /**
-   * Inserts an image block into a rich text editor block based on the parent block type.
-   *
-   * @param {InsertImageToBlockAction} action - Modify action
-   */
-  insertImage(action) {
-    const imageBlock = action.imageBlockToBeInserted;
-    if (this.parent['type'] !== 'list-item') {
-      this.parent.apply(new InsertBlocksAfterAction(this, imageBlock));
-    }
-    else {
-      this.parent.apply(action);
-    }
-  }
-  /**
-   * Removes a specified block and handles the removal of nested lists if necessary.
-   *
-   * @param {RTEBlock} blockToBeRemoved - block that will be removed
-   */
-  removeListItemBlock(blockToBeRemoved) {
-    super.removeChildBlock(blockToBeRemoved);
-    if (this.blocks.length === 0 && this.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 (this.parent instanceof RTEListItemBlock) {
-        this.parent.apply(new RemoveNestListAction(this));
-      }
-      else {
-        this.parent.apply(new RemoveChildAction(this));
-      }
-    }
-  }
-}
-
-/**
- * Class representing the content state of the rich text editor.
- */
-class VegaRTEContent extends BlockBaseOperator {
-  constructor(blocks) {
-    super();
-    blocks.forEach((block) => {
-      block.parent = this;
-    });
-    this.blocks = blocks;
-  }
-  /**
-   * Converts a JSON array of blocks to a class array of RTEContentBlock.
-   *
-   * @param {VegaRTEContentBlock[]} value The JSON array of blocks to convert.
-   * @returns {RTEContentBlock[]} 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);
-        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.
-   *
-   * @returns {VegaRTEContent} The cloned content state.
-   */
-  clone() {
-    return new VegaRTEContent([...this.blocks]);
-  }
-  /**
-   * Converts the content state to a JSON array of blocks.
-   *
-   * @returns {VegaRTEContentBlock[]} The JSON array of blocks.
-   */
-  toJSON() {
-    return this.blocks.map((block) => block.toJSON());
-  }
-  /**
-   * Internal method to add the block item, remove the block item
-   *
-   * @param {ModifyContentAction} action - Modify content action
-   */
-  apply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeChildBlock(action.entityToBeRemoved);
-        break;
-      case ModifyContentActionType.APPEND_CHILD_NODES:
-        this.appendChildBlocks(action.entityToBeAppended);
-        break;
-      case ModifyContentActionType.INSERT_BLOCKS_AFTER:
-        this.replaceBlockWithBlocks(action.referBlock, [
-          action.referBlock,
-          ...action.blocksToBeInserted,
-        ]);
-        break;
-      case ModifyContentActionType.INSERT_BLOCKS_BEFORE:
-        this.replaceBlockWithBlocks(action.referBlock, [
-          ...action.blocksToBeInserted,
-          action.referBlock,
-        ]);
-        break;
-    }
-  }
-  /**
-   * Convert text to list.
-   *
-   * @param {RTETextBlock} block - block
-   * @returns {RTEListItemBlock} list item block dto.
-   */
-  toListItem(block) {
-    block.nodes.map((node) => node.apply(new SyncUpSelectionAction()));
-    const listItemBlock = new RTEListItemBlock(generateUUID());
-    listItemBlock.apply(new AppendChildNodesAction(block['nodes']));
-    listItemBlock['annotationMap'] = block['annotationMap'];
-    return listItemBlock;
-  }
-  /**
-   * create list.
-   *
-   * @param {ListType} type - type
-   * @returns {RTEListBlock} list block dto.
-   */
-  createList(type) {
-    return new RTEListBlock(generateUUID(), type);
-  }
-}
-
-export { AnnotationAction as A, BoldAnnotationAction as B, ClearFormattingAnnotationAction as C, HorizontalAlignmentAnnotation as H, ImageAnnotation as I, LinkAnnotationAction as L, MergeTwoBlocksNodesAction as M, RTETextBlock as R, StrikethroughAnnotation as S, TextSplittableAction as T, UnderlineAnnotation as U, VegaRTEContent as V, ZERO_WIDTH_SPACE as Z, RTEImageBlock as a, RTEListItemBlock as b, RTEListBlock as c, RTEBlock as d, RTEImageNode as e, RTETextNode as f, TextColorAnnotation as g, RTE_TEXT_COLORS as h, ItalicAnnotation as i, TextStyleAnnotationAction as j, TextStyleAnnotation as k, BoldAnnotation as l, CodeAnnotationAction as m, SelectionRangeAnnotation as n, IndentAnnotation as o, AppendChildNodesAction as p, UpdateTextAction as q, SplitBlockWithNodeAction as r, RemoveChildAction as s, ReplaceChildNodesAction as t, InsertBlocksBeforeAction as u, InsertBlocksAfterAction as v };