@heartlandone/vega 2.67.0 → 2.68.0

package/dist/cjs/{dto-renderer-manager-d0f0f2c0.js → dto-renderer-manager-b7969d6c.js}

@@ -1,13 +1,13 @@
 'use strict';
 
-const codeBlock = require('./code-block-ab97a0a0.js');
+const codeBlock = require('./code-block-39074880.js');
 const createPublicApiRuntimeMetricsSlimmer = require('./create-public-api-runtime-metrics-slimmer-e2e274e1.js');
 const typeGuard = require('./type-guard-f12b5bae.js');
-const string = require('./string-39438062.js');
-const ui = require('./ui-9e181079.js');
 const changeManager = require('./change-manager-a297e4d2.js');
 const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-f040608b.js');
 const vegaInternalEventId = require('./vega-internal-event-id-6d4a2c53.js');
+const string = require('./string-39438062.js');
+const ui = require('./ui-9e181079.js');
 const object = require('./object-e2e28e3d.js');
 const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
 
@@ -165,6 +165,8 @@ class RTEListItemBlock extends codeBlock.RTETextBlock {
   }
 }
 (() => {
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.TextStyleAnnotationAction.name, RTEListItemBlock.name, new codeBlock.BlockUpdateTextStyleStrategy());
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.HorizontalAlignmentAnnotationAction.name, RTEListItemBlock.name, new codeBlock.BlockUpdateHorizontalAlignmentStrategy());
   codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTEListItemBlock.name, new codeBlock.BlockInsertLineBreakStrategy());
   codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTEListItemBlock.name, new codeBlock.BlockInsertLineBreakWithBlocksStrategy());
   codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.DELETE_NEST_LIST, RTEListItemBlock.name, new ListItemRemoveNestListStrategy());
@@ -486,2077 +488,2090 @@ class BlockTransformToCodeBlockStrategy extends codeBlock.ActionHandleStrategy {
 }
 
 /**
- * Abstract class to define handler for generate the annotations
+ * Abstract class to define strategies for processing HTML elements
  */
-class AnnotationGeneratorStrategyAbstract {
+class ElementToDTOStrategy {
 }
-
-/** Handle bold annotation */
-class BoldAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
-  /**
-   * @inheritDoc
-   */
-  canHandle(targetDto) {
-    return targetDto.name === 'RTETextNode';
+/**
+ * Class to represent the output of a strategy applied to HTML elements
+ */
+class ElementToDTOStrategyOutput {
+  constructor(currentStrategy, currentElements) {
+    this.childrenOutput = [];
+    this.currentStrategy = currentStrategy;
+    this.currentElements = currentElements;
   }
   /**
-   * Handle annotation.
+   * Set children output.
    *
-   * @param {HTMLElement} element - Current elements.
-   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
-   * @returns {VegaRTETextAnnotations} - Annotation.
+   * @param {ElementToDTOStrategyOutput[]} childrenOutput - children outputs.
    */
-  handle(element, parentAnnotations = {}) {
-    return this.isBold(element) || parentAnnotations.bold ? { bold: true } : {};
+  setChildrenOutput(childrenOutput) {
+    this.childrenOutput = childrenOutput;
   }
   /**
-   * Is bold element.
+   * Transform current output and children output to DTO
    *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
+   * @returns {Nullable<RTEContentBlock>} - DTO.
    */
-  isBold(element) {
-    return (element.nodeName === 'STRONG' ||
-      element.nodeName === 'B' ||
-      element.style.fontWeight === 'bold' ||
-      element.style.fontWeight === '700' ||
-      element.classList.contains('v-rte--bold'));
+  toDto(options = { autoMatchFormat: true, skipCustomAnnotations: true }) {
+    const currentBlock = this.currentStrategy.handle(this.currentElements, options);
+    if (this.childrenOutput.length > 0 && currentBlock) {
+      this.currentStrategy.appendChildBlocks(currentBlock, this.childrenOutput
+        .map((childOutput) => childOutput.toDto(options))
+        .filter(typeGuard.isNonNullable));
+    }
+    return currentBlock;
   }
 }
 
-/** Handle custom attribute annotation */
-class CustomAttributeAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
-  /**
-   * Can be handle.
-   *
-   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
-   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options for annotation generator.
-   * @returns {boolean} - .
-   */
-  canHandle(targetDto, options) {
-    return !options.skipCustomAnnotations && !!targetDto;
-  }
-  /**
-   * Handle annotation.
-   *
-   * @param {HTMLElement} element - Current elements.
-   * @returns {VegaRTETextAnnotations} - Annotation.
-   */
-  handle(element) {
-    const attributes = this.getAttributes(element);
-    return Object.keys(attributes).length > 0 ? { customAttribute: attributes } : {};
+/**
+ * Manager for registering and retrieving strategies that convert HTML elements to DTOs.
+ */
+class elementToDTOClassStrategyManager {
+  constructor() {
+    this.elementToBlockStrategies = [];
+    this.elementToNodeStrategies = [];
   }
   /**
-   * Obtain the custom attributes of element, excluding 'style' and 'class'.
+   * Registers a element to block strategy for converting HTML elements to DTOs. The new strategy is added to the beginning of the list to give it higher priority.
    *
-   * @param {HTMLElement} element - current element.
-   * @returns {Record<string, string>} - Record<string, string>.
+   * @param {ElementToDTOStrategy} strategy - The strategy to register.
    */
-  getAttributes(element) {
-    const attributeNames = element
-      .getAttributeNames()
-      .filter((attr) => attr !== 'style' && attr !== 'class' && this.isValidAttr(attr));
-    return attributeNames.reduce((acc, item) => {
-      acc[item] = element.getAttribute(item);
-      return acc;
-    }, {});
+  registerElementToBlockStrategy(strategy) {
+    if (!this.hasDuplicateStrategy(strategy, this.elementToBlockStrategies)) {
+      this.elementToBlockStrategies.unshift(strategy);
+    }
   }
   /**
-   * Check if the attribute name is valid.
+   * Registers an element to node strategy for converting HTML elements to DTOs. The new strategy is added to the beginning of the list to give it higher priority.
    *
-   * @param {string} attr - Attribute name.
-   * @returns {boolean} - True if valid, false otherwise.
+   * @param {ElementToDTOStrategy} strategy - The strategy to register.
    */
-  isValidAttr(attr) {
-    return /^[a-zA-Z_][\w-]*$/.test(attr);
+  registerElementToNodeStrategy(strategy) {
+    if (!this.hasDuplicateStrategy(strategy, this.elementToNodeStrategies)) {
+      this.elementToNodeStrategies.unshift(strategy);
+    }
   }
-}
-
-/** Handle custom class annotation */
-class CustomClassAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
-   * Can be handle.
+   * Retrieves all registered element to block strategies for converting HTML elements to DTOs.
    *
-   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
-   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options for annotation generator.
-   * @returns {boolean} - .
+   * @returns {ElementToDTOStrategy[]} - A set of all registered element to block strategies.
    */
-  canHandle(targetDto, options) {
-    return !options.skipCustomAnnotations && !!targetDto;
+  getElementToBlockStrategies() {
+    return this.elementToBlockStrategies;
   }
   /**
-   * Handle annotation.
+   * Retrieves all registered element to node strategies for converting HTML elements to DTOs.
    *
-   * @param {HTMLElement} element - Current elements.
-   * @returns {VegaRTETextAnnotations} - Annotation.
+   * @returns {ElementToDTOStrategy[]} - A set of all registered element to node strategies.
    */
-  handle(element) {
-    const classes = this.getCustomClass(element);
-    return classes.length > 0 ? { customClass: classes } : {};
+  getElementToNodeStrategies() {
+    return this.elementToNodeStrategies;
   }
   /**
-   * Get the custom class
+   * Checks if a strategy is already registered in the provided strategy list.
    *
-   * @param {HTMLElement} element - current element.
-   * @returns {string[]} - the class after .
+   * @param {ElementToDTOStrategy} strategy - The strategy to check for duplicates.
+   * @param {ElementToDTOStrategy[]} strategyList - The list of strategies to check against.
+   * @returns {boolean} - True if the strategy is a duplicate, false otherwise.
    */
-  getCustomClass(element) {
-    return element.classList
-      .toString()
-      .split(' ')
-      .filter((item) => !item.includes('v-rte') && item !== '');
+  hasDuplicateStrategy(strategy, strategyList) {
+    return strategyList.includes(strategy);
   }
 }
+const ElementToDTOClassStrategyManager = new elementToDTOClassStrategyManager();
 
-/** Handle custom style annotation */
-class CustomStyleAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+/** Element to DTO processor */
+class ElementToDtoStrategyProcessor {
   /**
-   * Can be handle.
+   * Transform process.
    *
-   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
-   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options for annotation generator.
-   * @returns {boolean} - .
+   * @param {HTMLElement[]} elements - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
+   * @returns {ElementToDTOStrategyOutput[]} - outputs.
    */
-  canHandle(targetDto, options) {
-    return !options.skipCustomAnnotations && !!targetDto;
+  process(elements, options = { autoMatchFormat: true, skipCustomAnnotations: true }) {
+    const strategies = this.getElementToBlockStrategies();
+    const outputs = [];
+    for (let i = 0; i < elements.length; i++) {
+      if (this.isInvalidElement(elements[i]))
+        continue;
+      let canHandledCount = 0;
+      for (const strategy of strategies) {
+        canHandledCount = strategy.canHandle(elements, i, options);
+        if (canHandledCount > 0) {
+          const handledElements = elements.slice(i, i + canHandledCount);
+          const output = new ElementToDTOStrategyOutput(strategy, handledElements);
+          if (canHandledCount === 1 && strategy.shouldProceedToElementChildren()) {
+            output.setChildrenOutput(this.process(Array.from(handledElements[0].childNodes), options));
+          }
+          outputs.push(output);
+          i += canHandledCount - 1;
+          break;
+        }
+      }
+      if (canHandledCount === 0 && i < elements.length) {
+        const elementChildren = Array.from(elements[i].childNodes);
+        const childrenOutputs = this.process(Array.from(elementChildren), options);
+        if (childrenOutputs.length > 0) {
+          outputs.push(...childrenOutputs);
+        }
+      }
+    }
+    return outputs;
   }
   /**
-   * Handle annotation.
+   * Checks if the given element is valid to parse.
    *
-   * @param {HTMLElement} element - Current elements.
-   * @returns {VegaRTETextAnnotations} - Annotation.
+   * @param {HTMLElement} element - The pasted element.
+   * @returns {boolean} Is valid
    */
-  handle(element) {
-    const styles = this.generateCustomStyleAnnotations(element);
-    return Object.keys(styles).length > 0 ? { customStyle: styles } : {};
+  isInvalidElement(element) {
+    if (element.nodeType === Node.COMMENT_NODE)
+      return true;
+    return ['META', 'STYLE'].includes(element.nodeName);
   }
   /**
-   * Obtain and format the style of element.
+   * Get the register element to block strategies.
    *
-   * @param {HTMLElement} element - current element.
-   * @returns {AnnotationStyle} - Record<string, string>.
+   * @returns {ElementToDTOStrategy[]} - The register element to block strategies.
    */
-  generateCustomStyleAnnotations(element) {
-    const customStyle = element.getAttribute('style');
-    if (!customStyle)
-      return {};
-    const styleValue = customStyle.split(';').filter(Boolean);
-    return styleValue
-      .filter((key) => key !== ' ')
-      .map((key) => {
-      // to remove redundant quote pairs if needed, for example: ['fontFamily: "Roboto Mono"'] will be updated to ['fontFamily: Roboto Mono']
-      const styleObject = key.replace(/(['"])(.*?)\1/g, '$2').split(':');
-      const styleKey = string.dashCaseToCamel(styleObject[0].trim());
-      return {
-        [styleKey]: styleObject[1].trim().replace(';', ''),
-      };
-    })
-      .reduce((current, obj) => (Object.assign(Object.assign({}, current), obj)), {});
+  getElementToBlockStrategies() {
+    return ElementToDTOClassStrategyManager.getElementToBlockStrategies();
   }
 }
+const ElementToDtoStrategyProcessor$1 = new ElementToDtoStrategyProcessor();
 
-/** Handle indent annotation */
-class IndentAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+/**
+ * Update the cursor position in the editor.
+ */
+class UpdateCursorPositionStrategy extends codeBlock.ActionHandleStrategy {
   /**
    * @inheritDoc
    */
-  canHandle(targetDto) {
-    return ['RTETextBlock', 'RTEListItemBlock', 'RTEListBlock'].includes(targetDto.name);
+  handleAction(action, target) {
+    const { offset, nextFocusNode, immediatelyRun } = action;
+    const host = codeBlock.stateEntityRenderingRegistry.getDOMByEntity(target);
+    if (host) {
+      changeManager.ChangeManager.notify(domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubject(host, vegaInternalEventId.VegaInternalUpdateRTECursorPosition), {
+        node: nextFocusNode,
+        offset,
+        updateDirectly: immediatelyRun,
+      });
+    }
   }
+}
+
+/**
+ * Append new block array or node array to block or VegaRTEContent instance strategy.
+ */
+class AppendChildrenStrategy extends codeBlock.ActionHandleStrategy {
   /**
-   * Handle annotation.
-   *
-   * @param {HTMLElement} element - Current elements.
-   * @returns {VegaRTEBlockAnnotations} - Annotation.
-   */
-  handle(element) {
-    const indent = this.getIndent(element);
-    return indent ? { indent: indent } : {};
-  }
-  /**
-   * Get indent of current element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {Nullable<number>} - Indent.
+   * @inheritDoc
    */
-  getIndent(element) {
-    const style = element.style;
-    let marginLeft;
-    if (style.marginLeft) {
-      marginLeft = style.marginLeft;
-    }
-    else if (style.margin) {
-      const margins = style.margin.split(' ');
-      switch (margins.length) {
-        case 4:
-          marginLeft = margins[3];
-          break;
-        case 2:
-        case 3:
-          marginLeft = margins[1];
-          break;
-        default:
-          marginLeft = margins[0];
-          break;
-      }
-    }
-    else {
-      return null;
+  handleAction(action, target) {
+    const newBlocks = action.entityToBeAppended;
+    if (target.children) {
+      newBlocks.forEach((block) => {
+        block.parent = target;
+      });
+      // This line is used to fix the typescript error `This expression is not callable`. https://github.com/microsoft/TypeScript/issues/44373
+      const arrayFixed = target.children;
+      target.children = arrayFixed.concat(newBlocks);
     }
-    const marginLeftNumber = Number(marginLeft.replace('px', ''));
-    return marginLeftNumber && marginLeftNumber >= 0 ? Math.floor(marginLeftNumber / 16) : null;
   }
 }
 
-/** Handle text align annotation */
-class TextAlignAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
-  /**
-   * Can be handle.
-   *
-   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
-   * @returns {boolean} - .
-   */
-  canHandle(targetDto) {
-    return ['RTETextBlock', 'RTEListItemBlock', 'RTEListBlock'].includes(targetDto.name);
-  }
+/**
+ * Insert children at the front of the block strategy.
+ */
+class InsertChildrenBeforeStrategy extends codeBlock.ActionHandleStrategy {
   /**
-   * Handle annotation.
-   *
-   * @param {HTMLElement} element - Current elements.
-   * @returns {VegaRTEBlockAnnotations} - Annotation.
+   * @inheritDoc
    */
-  handle(element) {
-    const textAlign = this.getTextAlign(element);
-    return textAlign ? { textAlign: textAlign } : {};
+  handleAction(action, target) {
+    this.replaceElementWithElements(target, action.referChildren, [
+      ...action.childrenToBeInserted,
+      action.referChildren,
+    ]);
   }
   /**
-   * Get text align of current element.
+   * Replaces a specific block or node with an array of blocks or nodes within RTEContentBlock array.
    *
-   * @param {HTMLElement} element - current element.
-   * @returns {Nullable<VegaRTEBlockAlignment>} - Text align.
+   * @param {RTEBlock | VegaRTEContent} target - The block or the VegaRTEContent instance.
+   * @param {RTEBlock | RTENode} referElement - Used as a reference element to identify the element that needs to be replaced in the array.
+   * @param {RTEBlock[] | RTENode[]} elements - An array of block or node objects that you want to replace the `referElement` with in the array.
    */
-  getTextAlign(element) {
-    const classList = element.classList;
-    if (classList.contains(`v-rte--horizontal-alignment-left`)) {
-      return 'left';
-    }
-    else if (classList.contains(`v-rte--horizontal-alignment-center`)) {
-      return 'center';
-    }
-    else if (classList.contains(`v-rte--horizontal-alignment-right`)) {
-      return 'right';
-    }
-    else if (classList.contains(`v-rte--horizontal-alignment-justify`)) {
-      return 'justify';
-    }
-    const style = element.style;
-    switch (style.textAlign) {
-      case 'center':
-        return 'center';
-      case 'right':
-        return 'right';
-      case 'justify':
-        return 'justify';
-      case 'left':
-        return 'left';
-      default:
-        return null;
+  replaceElementWithElements(target, referElement, elements) {
+    if (target.children) {
+      elements.forEach((block) => {
+        block.parent = target;
+      });
+      const arrayFixed = target.children;
+      target.children = arrayFixed.flatMap((block) => {
+        if (block === referElement) {
+          return elements;
+        }
+        else {
+          return block;
+        }
+      });
     }
   }
 }
 
-/** Handle code annotation */
-class CodeAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+/**
+ * Insert children at the front of the block strategy.
+ */
+class InsertChildrenAfterStrategy extends InsertChildrenBeforeStrategy {
   /**
    * @inheritDoc
    */
-  canHandle(targetDto) {
-    return targetDto.name === 'RTETextNode';
+  handleAction(action, target) {
+    this.replaceElementWithElements(target, action.referChildren, [
+      action.referChildren,
+      ...action.childrenToBeInserted,
+    ]);
+  }
+}
+
+/**
+ * Annotation for image
+ */
+class ImageAnnotation extends codeBlock.NodeAnnotation {
+  constructor(size, alt) {
+    super();
+    this.type = codeBlock.NodeAnnotationTypeEnum.IMAGE;
+    this.size = size;
+    this.alt = alt;
   }
   /**
-   * Handle annotation.
+   * Generate the map item for the annotation
    *
-   * @param {HTMLElement} element - Current elements.
-   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
-   * @returns {VegaRTETextAnnotations} - Annotation.
+   * @param {string} size - Image size
+   * @param {string} alt - Image alt
+   * @returns {[NodeAnnotationTypeEnum.IMAGE, ImageAnnotation]} Map item for the annotation
    */
-  handle(element, parentAnnotations = {}) {
-    return this.isCode(element) || parentAnnotations.code ? { code: true } : {};
+  static from(size, alt) {
+    return [codeBlock.NodeAnnotationTypeEnum.IMAGE, new ImageAnnotation(size, alt)];
   }
   /**
-   * Is code element.
+   * Generate the JSON representation of the annotation
    *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
+   * @returns {Nullable<Record<string, unknown>>} JSON representation of the annotation
    */
-  isCode(element) {
-    return (element.classList.contains('v-rte--code') ||
-      element.nodeName === 'CODE' ||
-      element.nodeName === 'PRE' ||
-      element.style.fontFamily === 'monospace' ||
-      element.style.fontFamily.replace(/["']/g, '') === 'Roboto Mono');
+  toJSON() {
+    return typeGuard.isNonNullable(this.alt)
+      ? {
+        size: this.size,
+        alt: this.alt,
+      }
+      : {
+        size: this.size,
+      };
   }
-}
-
-/** Handle color annotation */
-class ColorAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
    * @inheritDoc
    */
-  canHandle(targetDto) {
-    return targetDto.name === 'RTETextNode';
+  clone() {
+    return new ImageAnnotation(this.size, this.alt);
   }
   /**
-   * Handle annotation.
-   *
-   * @param {HTMLElement} element - Current elements.
-   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
-   * @returns {VegaRTETextAnnotations} - Annotation.
+   * @inheritDoc
    */
-  handle(element, parentAnnotations = {}) {
-    const color = this.getColor(element) || parentAnnotations.textColor;
-    return color ? { textColor: color } : {};
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return this.size ? `v-rte--image-size-${this.size}` : null;
   }
   /**
-   * Get current color of element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {Nullable<string>} - color.
+   * @inheritDoc
    */
-  getColor(element) {
-    var _a;
-    const color = element.style.color;
-    const hexColor = (_a = ui.rgbToHex(color)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-    if (hexColor) {
-      // We don't display default text color as inline style, because we defined it in the vega-rich-text-content.scss.
-      const colorSchema = codeBlock.RTE_TEXT_COLORS.filter((item) => item.key !== codeBlock.RTE_DEFAULT_TEXT_COLOR.key).find((schema) => schema.light === hexColor || schema.dark === hexColor);
-      if (colorSchema)
-        return colorSchema.key;
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
       return null;
-    }
-    else {
-      for (const color of codeBlock.RTE_TEXT_COLORS) {
-        if (element.style.color.includes(color.key)) {
-          return color.key;
-        }
+    const baseStyle = { verticalAlign: 'bottom' };
+    switch (this.size) {
+      case 'sm': {
+        return Object.assign(Object.assign({}, baseStyle), { width: '25%' });
+      }
+      case 'md': {
+        return Object.assign(Object.assign({}, baseStyle), { width: '50%' });
+      }
+      case 'lg': {
+        return Object.assign(Object.assign({}, baseStyle), { width: '100%' });
       }
-      return null;
     }
   }
 }
 
-/** Handle italic annotation */
-class ItalicAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+/**
+ * Update the image node annotation map strategy.
+ */
+class ImageSetAnnotationMapStrategy extends codeBlock.ActionHandleStrategy {
   /**
    * @inheritDoc
    */
-  canHandle(targetDto) {
-    return targetDto.name === 'RTETextNode';
+  handleAction(action, target) {
+    const annotation = action.toAnnotation();
+    target.annotationMap.set(annotation.type, annotation);
   }
+}
+
+/**
+ * The image node update property url strategy.
+ */
+class ImageUpdateUrlStrategy extends codeBlock.ActionHandleStrategy {
   /**
-   * Handle annotation.
-   *
-   * @param {HTMLElement} element - Current elements.
-   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
-   * @returns {VegaRTETextAnnotations} - Annotation.
+   * @inheritDoc
    */
-  handle(element, parentAnnotations = {}) {
-    return this.isItalic(element) || parentAnnotations.italic ? { italic: true } : {};
-  }
-  /**
-   * Is italic element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
-   */
-  isItalic(element) {
-    return (element.nodeName === 'I' ||
-      element.style.fontStyle === 'italic' ||
-      element.nodeName === 'EM' ||
-      element.classList.contains('v-rte--italic'));
+  handleAction(action, target) {
+    target.url = action.url;
   }
 }
 
-/** Handle link annotation */
-class LinkAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
-  constructor() {
-    super(...arguments);
-    this.handlers = [
-      new CustomAttributeAnnotationHandler(),
-      new CustomClassAnnotationHandler(),
-      new CustomStyleAnnotationHandler(),
-    ];
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+/**
+ * Image node
+ */
+class RTEImageNode extends codeBlock.RTEDecoratorNode {
+  constructor(id, url, parentBlock, annotationMap) {
+    super(id, annotationMap);
+    this.type = codeBlock.NodeTypeEnum.IMAGE;
+    this.url = url;
+    this.parent = parentBlock;
   }
   /**
-   * Can be handle.
+   * Converts a VegaRTEImageNode into an RTEImageNode by mapping nodes and creating annotations.
    *
-   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
-   * @returns {boolean} - .
+   * @param {VegaRTEImageNode} node - The node to be converted.
+   * @param {RTEImageBlock} parentBlock - The parent block
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
+   * @returns {RTEImageNode} An instance of `RTEImageBlock`
    */
-  canHandle(targetDto) {
-    return targetDto.name === 'RTETextNode';
+  static from(node, parentBlock, options = { autoMatchFormat: true }) {
+    const imageNode = new RTEImageNode(node.id, node.url, parentBlock);
+    const autoMatchFormat = !!options.autoMatchFormat;
+    const _a = Object.assign({}, node.annotations), { size } = _a, otherAnnotations = __rest(_a, ["size"]);
+    const annotations = Object.assign(Object.assign({}, otherAnnotations), { size: size !== null && size !== void 0 ? size : (autoMatchFormat ? 'md' : undefined) });
+    imageNode.annotationMap = new Map(Object.keys(annotations)
+      .map((type) => {
+      if (type === 'size' || type === 'alt') {
+        return ImageAnnotation.from(annotations.size, annotations.alt);
+      }
+      return this.createAnnotationEntity(type, annotations[type]);
+    })
+      .filter(typeGuard.isNonNullable));
+    return imageNode;
   }
   /**
-   * Handle annotation.
-   *
-   * @param {HTMLElement} element - Current elements.
-   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
-   * @returns {VegaRTETextAnnotations} - Annotation.
+   * @inheritDoc
    */
-  handle(element, parentAnnotations = {}) {
-    if (parentAnnotations.link)
-      return { link: parentAnnotations.link };
-    return element.tagName === 'A' ? { link: this.generateLinkAnnotations(element) } : {};
+  toJSON() {
+    const annotations = Array.from(this.annotationMap.values())
+      .filter((annotation) => annotation instanceof ImageAnnotation || annotation instanceof codeBlock.CommonAnnotation)
+      .reduce((record, annotation) => {
+      return Object.assign(Object.assign({}, record), annotation.toJSON());
+    }, {});
+    if (annotations.alt == '')
+      delete annotations.alt;
+    return Object.assign(Object.assign({ id: this.id }, (Object.keys(annotations).length > 0 ? { annotations } : {})), { type: 'image', url: this.url });
   }
   /**
-   * Generate link annotations.
-   *
-   * @param {HTMLElement} element - Current elements.
-   * @returns {VegaRTELink} - link annotations.
+   * @inheritDoc
    */
-  generateLinkAnnotations(element) {
-    const annotations = {
-      href: element.getAttribute('href') || '',
-      groupKey: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
-    };
-    this.handlers.forEach((handler) => {
-      Object.assign(annotations, handler.handle(element));
-    });
-    return annotations;
+  clone(parent) {
+    return new RTEImageNode(this.id, this.url, parent, super.cloneAnnotations());
   }
-}
-
-/** Handle strike through annotation */
-class StrikeThroughAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
    * @inheritDoc
    */
-  canHandle(targetDto) {
-    return targetDto.name === 'RTETextNode';
+  toHtml() {
+    const imageAnnotation = this.getAnnotationByType(codeBlock.NodeAnnotationTypeEnum.IMAGE);
+    const attrStr = super.generateAttributeString(...[
+      imageAnnotation && imageAnnotation.alt ? `alt="${imageAnnotation.alt}"` : null,
+      `src="${this.url}"`,
+      imageAnnotation && imageAnnotation.size ? `data-size="${imageAnnotation.size}"` : null,
+    ].filter(typeGuard.isNonNullable));
+    return `<img${attrStr}>`;
   }
   /**
-   * Handle annotation.
-   *
-   * @param {HTMLElement} element - Current elements.
-   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
-   * @returns {VegaRTETextAnnotations} - Annotation.
+   * @inheritDoc
    */
-  handle(element, parentAnnotations = {}) {
-    return this.isStrikethrough(element) || parentAnnotations.strikethrough
-      ? { strikethrough: true }
-      : {};
+  doAnnotationActionApply(action) {
+    const strategy = codeBlock.ActionHandleStrategyRegistry.get(codeBlock.AnnotationAction.name, RTEImageNode.name);
+    if (strategy) {
+      strategy.execute(action, this);
+    }
   }
   /**
-   * Is strikethrough element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
+   * @inheritDoc
    */
-  isStrikethrough(element) {
-    return (element.style.textDecoration.includes('line-through') ||
-      element.nodeName === 'S' ||
-      element.nodeName === 'DEL' ||
-      element.classList.contains('v-rte--strikethrough'));
+  doModifyActionApply(action) {
+    codeBlock.ActionHandleStrategyRegistry.executeTheStrategy(action, this);
   }
 }
+(() => {
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.UPDATE_IMAGE_NODE_URL, RTEImageNode.name, new ImageUpdateUrlStrategy());
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.AnnotationAction.name, RTEImageNode.name, new ImageSetAnnotationMapStrategy());
+})();
 
-/** Handle underline annotation */
-class UnderlineAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+/**
+ * Split the current image block with a special position strategy.
+ */
+class BlockSplitWithImageNodeStrategy extends codeBlock.ActionHandleStrategy {
   /**
    * @inheritDoc
    */
-  canHandle(targetDto) {
-    return targetDto.name === 'RTETextNode';
+  handleAction(action, target) {
+    action.newBlock = this.splitImageNodes(action.splitPointNode, action.startOffsetOfNode, target);
   }
   /**
-   * Handle annotation.
+   * The image offset should be 0 or 1
+   * <vega-rich-text-image-editor><img /></vega-rich-text-image-editor>
    *
-   * @param {HTMLElement} element - Current elements.
-   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
-   * @returns {VegaRTETextAnnotations} - Annotation.
+   * @param {RTEImageNode} imageNode The split point image node.
+   * @param {number} imageOffset The cursor point 0 | 1.
+   * @param {RTEImageBlock} target The image block.
+   * @returns {Nullable<RTEBlock>} The new block after split
    */
-  handle(element, parentAnnotations = {}) {
-    return this.isUnderline(element) || parentAnnotations.underline ? { underline: true } : {};
+  splitImageNodes(imageNode, imageOffset, target) {
+    const nodesSplitIndex = target.children.indexOf(imageNode);
+    if (nodesSplitIndex > -1) {
+      const beforeNodes = target.children.slice(0, nodesSplitIndex + imageOffset);
+      const afterNodes = target.children.slice(nodesSplitIndex + imageOffset);
+      target.apply(new codeBlock.ReplaceChildNodesAction(beforeNodes));
+      const newBlock = this.cloneWithNodes(afterNodes, target);
+      target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newBlock));
+      return newBlock;
+    }
   }
   /**
-   * Is underline element.
+   * Creates a new RTEImageBlock instance with the provided RTEImageNode instances appended to it.
    *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
+   * @param {RTEImageNode[]} nodes - An array of RTEImageNode objects that will be used to create a new RTEImageBlock instance.
+   * @param {RTEImageBlock} target The image block.
+   * @returns {RTEImageBlock} A new `RTEImageBlock` object with the provided `nodes` appended to it.
    */
-  isUnderline(element) {
-    return (element.style.textDecoration.includes('underline') ||
-      element.nodeName === 'U' ||
-      element.nodeName === 'INS' ||
-      element.classList.contains('v-rte--underline'));
+  cloneWithNodes(nodes, target) {
+    const block = target.createNewImageBlock();
+    block.children = [];
+    block.apply(new codeBlock.AppendChildrenAction(nodes));
+    return block;
   }
 }
 
-/** Handle text style annotation */
-class TextStyleAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+/**
+ * Break the current block after press enter, this action is similar with the SplitBlockWithNodeAction,
+ * The SplitBlockWithNodeAction split the current block to two same type blocks, but this action will create new paragraph or list item when break at start or end.
+ * The property `newBlock` use to store the new create block if need.
+ *
+ * @example currentBlock.apply(new InsertNewParagraphAction(startContainerNode, startOffset))
+ */
+class InsertNewParagraphAction extends codeBlock.ModifyContentAction {
+  constructor(startContainerNode, startOffset) {
+    super();
+    this.type = codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH;
+    this.startContainerNode = startContainerNode;
+    this.startOffset = startOffset;
+  }
+}
+
+/**
+ * The image block insert line break strategy.
+ */
+class ImageInsertLineBreakStrategy extends codeBlock.ActionHandleStrategy {
   /**
-   * Can be handle.
+   * The image block not support insert the line break node, so invoke the insert new paragraph logic directly.
    *
-   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
-   * @param {HtmlElementToAnnotationGenerateOptions} options - Options for annotation generator.
-   * @returns {boolean} - .
+   * @param {LineBreakSingleBlockAction} action - The action instance.
+   * @param {RTEImageBlock} target - The image block.
    */
-  canHandle(targetDto, options) {
-    return !!options.autoMatchFormat && targetDto.name === 'RTETextBlock';
+  handleAction(action, target) {
+    const insertNewParagraphAction = new InsertNewParagraphAction(action.startContainerNode, action.startOffset);
+    target.apply(insertNewParagraphAction);
+    const newBlock = insertNewParagraphAction.newBlock;
+    if (newBlock) {
+      action.lineBreakNode = newBlock.children[0];
+    }
   }
+}
+
+/**
+ * Insert a line break node into multiple blocks selection at special position strategy.
+ */
+class ImageInsertLineBreakWithBlocksStrategy extends codeBlock.ActionHandleStrategy {
   /**
-   * Handle annotation.
-   *
-   * @param {HTMLElement} element - Current elements.
-   * @returns {VegaRTETextBlockAnnotations} - Annotation.
+   * @inheritDoc
    */
-  handle(element) {
-    const textStyle = this.getTextStyle(element);
-    return textStyle ? { textStyle: textStyle } : {};
+  handleAction(action, target) {
+    action.lineBreakNode = this.lineBreakMultipleBlocks(action.selectedBlocks, target);
   }
   /**
-   * Get the node type of element. The element type is determined in the following
-   * order: "data-type" attribute, node name, font size and class name.
+   * Inserts a new paragraph block with a line break after a selected block of text in a rich text editor.
    *
-   * @param {HTMLElement} element - element.
-   * @returns {Nullable<VegaRTETextStyleType>} - node type.
-   */
-  getTextStyle(element) {
-    const byDataType = this.getElementTypeByDataType(element);
-    if (byDataType)
-      return byDataType;
-    const byNodeName = this.getElementTypeByNodeName(element);
-    if (byNodeName)
-      return byNodeName;
-    const byFontSize = this.getElementTypeByFontSize(element);
-    if (byFontSize)
-      return byFontSize;
-    const byClassName = this.getElementTypeByClassName(element);
-    if (byClassName)
-      return byClassName;
-    return null;
-  }
-  /**
-   * Get the element type by data-type attribute.
-   *
-   * @param {HTMLElement} element - element.
-   * @returns {Nullable<VegaRTETextStyleType>} - element type or null if not found.
+   * @param {RTEBlock[]} selectedBlocks - An array of RTEBlock objects that represent the blocks that have been selected for a specific action in the Rich Text Editor.
+   * @param {RTEImageBlock} target - The image block.
+   * @returns {Nullable<RTETextNode>} Returns a Nullable RTETextNode.
    */
-  getElementTypeByDataType(element) {
-    if (element.nodeType !== Node.TEXT_NODE && element.hasAttribute('data-type')) {
-      return element.getAttribute('data-type');
+  lineBreakMultipleBlocks(selectedBlocks, target) {
+    const newParagraph = codeBlock.RTETextBlock.from({
+      id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+      type: 'paragraph',
+      nodes: [{ id: createPublicApiRuntimeMetricsSlimmer.generateUUID(), type: 'text', text: '\n' }],
+    });
+    target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newParagraph));
+    const afterNodes = this.concatBlocksNodes(selectedBlocks.slice(1));
+    if (afterNodes.length === 0 || (afterNodes[0] && afterNodes[0].text === '')) {
+      afterNodes.push(new codeBlock.RTETextNode(createPublicApiRuntimeMetricsSlimmer.generateUUID(), '\n', newParagraph));
     }
-    return null;
+    newParagraph.apply(new codeBlock.AppendChildrenAction(afterNodes));
+    return newParagraph['children'][0];
   }
   /**
-   * Get the element type by font size.
+   * Concat the child nodes of multiple RTEBlocks if both are not images.
    *
-   * @param {HTMLElement} element - element.
-   * @returns {Nullable<VegaRTETextStyleType>} - element type or null if not found.
+   * @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
    */
-  getElementTypeByFontSize(element) {
-    var _a;
-    switch ((_a = element.style) === null || _a === void 0 ? void 0 : _a.fontSize) {
-      case '36px':
-        return 'title';
-      case '28px':
-        return 'subtitle';
-      case '22px':
-        return 'heading-1';
-      case '20px':
-        return 'heading-2';
-      case '18px':
-        return 'heading-3';
-      default:
-        return null;
-    }
+  concatBlocksNodes(blocks) {
+    const nodes = [];
+    blocks.map((block) => {
+      if (block.type !== 'image') {
+        nodes.push(...block.children);
+        block.parent.apply(new codeBlock.RemoveChildrenAction(block));
+      }
+    });
+    return nodes;
   }
+}
+
+/**
+ * Insert a image node at the special position of image block.
+ */
+class ImageBlockInsertImageStrategy extends codeBlock.ActionHandleStrategy {
   /**
-   * Get the element type by node name.
-   *
-   * @param {HTMLElement} element - element.
-   * @returns {Nullable<VegaRTETextStyleType>} - element type or null if not found.
+   * @inheritDoc
    */
-  getElementTypeByNodeName(element) {
-    switch (element.nodeName) {
-      case 'H1':
-        return 'heading-1';
-      case 'H2':
-        return 'heading-2';
-      case 'H3':
-        return 'heading-3';
-      case 'H4':
-        return 'heading-4';
-      case 'H5':
-        return 'heading-5';
-      case 'H6':
-        return 'heading-6';
-      default:
-        return null;
+  handleAction(action, target) {
+    const splitNode = action.splitPointNode;
+    const startOffsetOfNode = action.startOffsetOfNode;
+    const newImageBlock = action.imageBlockToBeInserted;
+    const newImageNodes = newImageBlock.children;
+    if (target.children.length < 1) {
+      target.apply(new codeBlock.AppendChildrenAction(newImageNodes));
+    }
+    else if (this.isCaretPositionAtBlockEnd(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newImageBlock));
+    }
+    else if (this.isCaretPositionAtBlockStart(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new codeBlock.InsertChildrenBeforeAction(target, newImageBlock));
+    }
+    else {
+      target.apply(new codeBlock.SplitBlockWithNodeAction(splitNode, startOffsetOfNode));
+      target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newImageBlock));
     }
   }
+}
+
+/**
+ * Image block
+ */
+class RTEImageBlock extends codeBlock.RTEBlock {
+  constructor(id) {
+    super(id);
+    this.type = 'image';
+    this.children = [];
+  }
   /**
-   * Get the element type by class name.
+   * Converts a VegaRTEImageBlock object into an RTEImageBlock object by mapping nodes and creating annotations.
    *
-   * @param {HTMLElement} element - element.
-   * @returns {Nullable<VegaRTETextStyleType>} - element type or null if not found.
+   * @param {VegaRTEImageBlock} block - The block object to be converted.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
+   * @returns {RTEImageBlock} An instance of `RTEImageBlock`
    */
-  getElementTypeByClassName(element) {
-    if (element.className) {
-      const match = /\bv-rte--text-style-(title|subtitle|heading-1|heading-2|heading-3|paragraph)\b/.exec(element.className);
-      if (match) {
-        return match[1];
-      }
+  static from(block, options = { autoMatchFormat: true }) {
+    const imageBlock = new RTEImageBlock(block.id);
+    const { annotations } = block;
+    imageBlock.children = block.nodes.map((image) => RTEImageNode.from(image, imageBlock, options));
+    if (annotations) {
+      super.convertAnnotationsToMap(imageBlock.annotationMap, annotations);
     }
-    return null;
+    return imageBlock;
   }
-}
-
-/** Handle image size annotation */
-class ImageSizeAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
    * @inheritDoc
    */
-  canHandle(targetDto) {
-    return targetDto.name === 'RTEImageNode';
+  toJSON() {
+    return Object.assign(Object.assign({}, super.toJSON()), { type: 'image', nodes: this.children.map((node) => node.toJSON()) });
   }
   /**
-   * Handle annotation.
-   *
-   * @param {HTMLElement} element - Current elements.
-   * @returns {VegaRTEImageAnnotations} - Annotation.
+   * @inheritDoc
    */
-  handle(element) {
-    const size = this.getImageSize(element);
-    return size ? { size: size } : {};
+  toHtml() {
+    const attrStr = super.generateAttributeString();
+    const children = this.children.map((node) => node.toHtml()).join('');
+    return super.shouldRenderAsInternalWrapper()
+      ? children
+      : [`<div${attrStr}>`, children, `</div>`].join('');
   }
   /**
-   * Determine the image display size based on the width of the current element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {Nullable<VegaRichTextImageEditorSizeType>} -Image size, default 'md'.
+   * @inheritDoc
    */
-  getImageSize(element) {
-    if (element.getAttribute('data-size')) {
-      return element.getAttribute('data-size');
-    }
-    return null;
+  isNotEmpty() {
+    return this.children.length > 0 && this.children.some((node) => node.url.length > 0);
   }
-}
-
-/** Handle image alt annotation */
-class ImageAltAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
    * @inheritDoc
    */
-  canHandle(targetDto) {
-    return targetDto.name === 'RTEImageNode';
+  getLastNode() {
+    return this.children[this.children.length - 1];
   }
   /**
-   * Handle annotation.
+   * Create a new image block.
    *
-   * @param {HTMLElement} element - Current elements.
-   * @returns {VegaRTEImageAnnotations} - Annotation.
+   * @returns {RTEImageBlock} - The empty image block.
    */
-  handle(element) {
-    return element.hasAttribute('alt') ? { alt: element.getAttribute('alt') } : {};
+  createNewImageBlock() {
+    return new RTEImageBlock(createPublicApiRuntimeMetricsSlimmer.generateUUID());
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    const clonedBlock = new RTEImageBlock(this.id);
+    clonedBlock.children = this.children.map((node) => node.clone(clonedBlock));
+    clonedBlock.annotationMap = super.cloneAnnotations();
+    clonedBlock.parent = parent;
+    return clonedBlock;
   }
 }
+(() => {
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTEImageBlock.name, new codeBlock.BlockMergeNodesStrategy());
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.REPLACE_CHILD_NODES, RTEImageBlock.name, new codeBlock.BlockReplaceNodesStrategy());
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTEImageBlock.name, new BlockSplitWithImageNodeStrategy());
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTEImageBlock.name, new ImageInsertLineBreakStrategy());
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTEImageBlock.name, new ImageInsertLineBreakWithBlocksStrategy());
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEImageBlock.name, new ImageBlockInsertImageStrategy());
+  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.HorizontalAlignmentAnnotationAction.name, RTEImageBlock.name, new codeBlock.BlockUpdateHorizontalAlignmentStrategy());
+})();
 
 /**
- * Handle inline html annotation
+ * HTML Block
  */
-class InlineHtmlAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
-  constructor() {
-    super(...arguments);
-    this.customAttributeHandler = new CustomAttributeAnnotationHandler();
-    this.customStyleAnnotationHandler = new CustomStyleAnnotationHandler();
-    this.customClassAnnotationHandler = new CustomClassAnnotationHandler();
+class RTEHtmlBlock extends codeBlock.RTEBlock {
+  constructor(id, htmlTag) {
+    super(id);
+    this.type = 'html-block';
+    this.children = [];
+    this.htmlTag = htmlTag;
+  }
+  /**
+   * Converts a VegaRTEHtmlBlock to an RTEHtmlBlock.
+   *
+   * @param {VegaRTEHtmlBlock} block - The VegaRTEHtmlBlock to convert.
+   * @param {VegaRTETransformOptions} [options] - Optional transformation options.
+   * @returns {RTEHtmlBlock} The converted RTEHtmlBlock.
+   */
+  static from(block, options) {
+    const htmlBlock = new RTEHtmlBlock(block.id, block.htmlTag);
+    const { annotations } = block;
+    if (annotations) {
+      super.convertAnnotationsToMap(htmlBlock.annotationMap, annotations);
+    }
+    htmlBlock.children = this.generateBlockChildren(block.children, options, htmlBlock);
+    return htmlBlock;
   }
   /**
    * @inheritDoc
    */
-  canHandle(targetDto, options) {
-    return targetDto.name === 'RTETextNode' && options.autoMatchFormat === false;
+  clone(parent) {
+    const clonedBlock = new RTEHtmlBlock(this.id, this.htmlTag);
+    clonedBlock.children = this.children.map((child) => child.clone(clonedBlock));
+    clonedBlock.annotationMap = super.cloneAnnotations();
+    clonedBlock.parent = parent;
+    return clonedBlock;
   }
   /**
    * @inheritDoc
    */
-  handle(element, parentAnnotations) {
-    const canHandle = InlineHtmlAnnotationHandler.canHandleTags.includes(element.nodeName);
-    if (canHandle) {
-      const inlineHtml = this.generateInlineHtmlAnnotation(element, Object.assign({}, parentAnnotations));
-      if (inlineHtml) {
-        return { inlineHtml: inlineHtml };
-      }
-    }
-    return {};
+  getLastNode() {
+    return this.children[this.children.length - 1].getLastNode();
   }
   /**
-   * Generate inline html annotation.
-   *
-   * @param {HTMLElement} child - Current element.
-   * @param {VegaRTETextAnnotations} annotations - Current annotations.
-   * @returns {Nullable<VegaInlineHtmlSchema>} - Inline html annotation.
+   * @inheritDoc
    */
-  generateInlineHtmlAnnotation(child, annotations) {
-    let { inlineHtml } = annotations;
-    if (!codeBlock.RTETextNode.supportsHtmlTag(child.nodeName.toLowerCase()) ||
-      (child.childNodes.length === 1 && child.childNodes[0].nodeType !== Node.TEXT_NODE)) {
-      const childInlineHtmlNode = {
-        htmlTag: child.nodeName.toLowerCase(),
-        customAttribute: this.customAttributeHandler.handle(child).customAttribute,
-        customStyle: this.customStyleAnnotationHandler.handle(child).customStyle,
-        customClass: this.customClassAnnotationHandler.handle(child).customClass,
-      };
-      if (!inlineHtml) {
-        inlineHtml = childInlineHtmlNode;
-      }
-      else {
-        let lastChild = inlineHtml;
-        while (lastChild.child &&
-          child.parentNode &&
-          lastChild.child.htmlTag === child.parentNode.nodeName.toLowerCase()) {
-          lastChild = lastChild.child;
-        }
-        lastChild.child = childInlineHtmlNode;
-      }
-    }
-    return inlineHtml ? Object.assign({}, inlineHtml) : null;
-  }
-}
-InlineHtmlAnnotationHandler.canHandleTags = [
-  'A',
-  'ABBR',
-  'AUDIO',
-  'B',
-  'BDI',
-  'BDO',
-  'CITE',
-  'CODE',
-  'DEL',
-  'DFN',
-  'EMBED',
-  'EM',
-  'I',
-  'INS',
-  'KBD',
-  'MARK',
-  'METER',
-  'OUTPUT',
-  'PROGRESS',
-  'Q',
-  'S',
-  'SMALL',
-  'SPAN',
-  'STRONG',
-  'SUB',
-  'SUP',
-  'TIME',
-  'U',
-  'VAR',
-  'VIDEO',
-];
-
-/** Html element to annotations generator */
-class HtmlElementToAnnotationGenerator {
-  constructor() {
-    this.handlers = [
-      new TextAlignAnnotationHandler(),
-      new IndentAnnotationHandler(),
-      new BoldAnnotationHandler(),
-      new ItalicAnnotationHandler(),
-      new UnderlineAnnotationHandler(),
-      new StrikeThroughAnnotationHandler(),
-      new ColorAnnotationHandler(),
-      new LinkAnnotationHandler(),
-      new CodeAnnotationHandler(),
-      new ImageSizeAnnotationHandler(),
-      new ImageAltAnnotationHandler(),
-      new CustomAttributeAnnotationHandler(),
-      new CustomClassAnnotationHandler(),
-      new CustomStyleAnnotationHandler(),
-      new LinkAnnotationHandler(),
-      new TextStyleAnnotationHandler(),
-      new InlineHtmlAnnotationHandler(),
-    ];
+  isNotEmpty() {
+    return this.children.length > 0;
   }
   /**
-   * The function generates annotations for a given target DTO and HTML element based on a set of
-   * strategies.
-   *
-   * @typedef T class name of target DTO
-   * @typedef V generated annotations type
-   * @param {T} targetDto - Which DTO is the generated annotations to set.
-   * @param {HTMLElement} element - Current html element.
-   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options
-   * @returns {V} Generated annotations.
+   * @inheritDoc
    */
-  generate(targetDto, element, options = { autoMatchFormat: true }) {
-    const isLinkElement = element.tagName === 'A';
-    return this.handlers
-      .filter((handler) => !options.autoMatchFormat && isLinkElement ? handler instanceof LinkAnnotationHandler : true)
-      .filter((handler) => element.nodeType !== Node.TEXT_NODE &&
-      handler.canHandle(targetDto, {
-        skipCustomAnnotations: options.skipCustomAnnotations || isLinkElement,
-        autoMatchFormat: options.autoMatchFormat,
-      }))
-      .reduce((annotations, handler) => {
-      const result = handler.handle(element, options.parentAnnotations);
-      return Object.assign(Object.assign({}, annotations), result);
-    }, {});
+  toHtml() {
+    const BlockTag = this.htmlTag;
+    const attrStr = super.generateAttributeString();
+    return [
+      `<${BlockTag}${attrStr}>`,
+      this.children.map((block) => block.toHtml()).join(''),
+      `</${BlockTag}>`,
+    ].join('');
   }
-}
-const htmlElementToAnnotationGenerator = new HtmlElementToAnnotationGenerator();
-
-/**
- * Abstract class to define strategies for processing HTML elements
- */
-class ElementToDTOStrategy {
   /**
-   * Convert element style attributes to text annotations.
-   *
-   * @param {HTMLElement} element - Current html element.
-   * @param {HtmlElementToAnnotationGenerateOptions} options - Options for generating annotations.
-   * @returns {VegaRTEAnnotations} - Generated annotations.
+   * @inheritDoc
    */
-  generateTextStyleAnnotations(element, options) {
-    return htmlElementToAnnotationGenerator.generate(codeBlock.RTETextNode, element, options);
+  toJSON() {
+    return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: this.type, htmlTag: this.htmlTag, children: this.children.map((child) => child.toJSON()) });
   }
 }
+
 /**
- * Class to represent the output of a strategy applied to HTML elements
+ * 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 ElementToDTOStrategyOutput {
-  constructor(currentStrategy, currentElements) {
-    this.childrenOutput = [];
-    this.currentStrategy = currentStrategy;
-    this.currentElements = currentElements;
-  }
-  /**
-   * Set children output.
-   *
-   * @param {ElementToDTOStrategyOutput[]} childrenOutput - children outputs.
-   */
-  setChildrenOutput(childrenOutput) {
-    this.childrenOutput = childrenOutput;
-  }
-  /**
-   * Transform current output and children output to DTO
-   *
-   * @param {VegaRTETransformOptions} [options] - Options for transformation.
-   * @returns {Nullable<RTEContentBlock>} - DTO.
-   */
-  toDto(options = { autoMatchFormat: true, skipCustomAnnotations: true }) {
-    const currentBlock = this.currentStrategy.handle(this.currentElements, options);
-    if (this.childrenOutput.length > 0 && currentBlock) {
-      this.currentStrategy.appendChildBlocks(currentBlock, this.childrenOutput
-        .map((childOutput) => childOutput.toDto(options))
-        .filter(typeGuard.isNonNullable));
-    }
-    return currentBlock;
+class MergeTwoBlocksNodesAction extends codeBlock.ModifyContentAction {
+  constructor(blockNeedToBeMerged) {
+    super();
+    this.type = codeBlock.ModifyContentActionType.MERGE_TWO_BLOCKS_NODES;
+    this.blockNeedToBeMerged = blockNeedToBeMerged;
   }
 }
 
 /**
- * Manager for registering and retrieving strategies that convert HTML elements to DTOs.
+ * Block delete text or decorator node strategy.
  */
-class elementToDTOClassStrategyManager {
-  constructor() {
-    this.elementToBlockStrategies = [];
-    this.elementToNodeStrategies = [];
-  }
+class BlockDeleteTextOrDecoratorNodeStrategy extends codeBlock.BlockDeleteNodeContentStrategy {
   /**
-   * Registers a element to block strategy for converting HTML elements to DTOs. The new strategy is added to the beginning of the list to give it higher priority.
-   *
-   * @param {ElementToDTOStrategy} strategy - The strategy to register.
+   * @inheritDoc
    */
-  registerElementToBlockStrategy(strategy) {
-    if (!this.hasDuplicateStrategy(strategy, this.elementToBlockStrategies)) {
-      this.elementToBlockStrategies.unshift(strategy);
+  handleAction(action, target) {
+    const { startContainerNode } = action;
+    if (!startContainerNode.isContentEditable()) {
+      this.deleteDecoratorNodeContent(action, target);
+    }
+    else if (startContainerNode.isTextNode()) {
+      this.deleteTextNodeContent(action, target);
+    }
+    const parent = target.parent;
+    if (parent && target.isListItemBlock() && parent.children.length === 0) {
+      parent.parent.apply(new codeBlock.RemoveChildrenAction(parent));
     }
   }
   /**
-   * Registers an element to node strategy for converting HTML elements to DTOs. The new strategy is added to the beginning of the list to give it higher priority.
+   * Handle the delete text logic when press delete key.
    *
-   * @param {ElementToDTOStrategy} strategy - The strategy to register.
+   * @param {DeleteBlockContentAction} action - ModifyContentAction
+   * @param {RTETextBlock} target - Current text block
    */
-  registerElementToNodeStrategy(strategy) {
-    if (!this.hasDuplicateStrategy(strategy, this.elementToNodeStrategies)) {
-      this.elementToNodeStrategies.unshift(strategy);
+  deleteTextNodeContent(action, target) {
+    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 codeBlock.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.parent === target && previousNode['text'] === '\n') ||
+          target.children.length === 1) {
+          action.previousNode = startContainerNode;
+          return;
+        }
+        else {
+          target.apply(new codeBlock.RemoveChildrenAction(startContainerNode));
+          action.previousNode = previousNode;
+          return;
+        }
+      }
+    }
+    else {
+      let previousNode = this.getPreviousNode(startContainerNode);
+      let nextNode = null;
+      const isCurrentNodeEmpty = startContainerNode.isEmpty();
+      if (target.children.length && previousNode && previousNode.parent !== target) {
+        if (isCurrentNodeEmpty) {
+          target.apply(new codeBlock.RemoveChildrenAction(startContainerNode));
+        }
+        if (target.type === previousNode.parent.type) {
+          previousNode.parent.apply(new MergeTwoBlocksNodesAction(target));
+        }
+      }
+      else {
+        if (this.isContentFirstNode(startContainerNode) && isCurrentNodeEmpty) {
+          nextNode = this.getNextNode(startContainerNode);
+        }
+        /**
+         * Remove line break
+         *
+         * @example caret at the first line
+         * \n
+         * test
+         */
+        if (isCurrentNodeEmpty) {
+          target.apply(new codeBlock.RemoveChildrenAction(startContainerNode));
+        }
+        /**
+         * Remove line break or non-editable node
+         *
+         * @example caret at the begin of second line
+         * \n
+         * test
+         * @example caret at the end of non-editable node and start of the text node
+         * <img/><span>test</span>
+         */
+        if (previousNode &&
+          previousNode.isTextNode() &&
+          (previousNode.isEmpty() ||
+            (!previousNode.isContentEditable() && previousNode.parent === target))) {
+          const shouldRemoveNode = previousNode;
+          previousNode = this.getPreviousNode(previousNode);
+          shouldRemoveNode.parent.apply(new codeBlock.RemoveChildrenAction(shouldRemoveNode));
+          if (!previousNode && !isCurrentNodeEmpty) {
+            nextNode = startContainerNode;
+          }
+        }
+      }
+      // Remove the paragraph block if the content is empty
+      // TODO: Check whether need to remove below logic because already handled the same logic in remove node strategy
+      if (target.children.length === 0) {
+        target.parent.apply(new codeBlock.RemoveChildrenAction(target));
+      }
+      if (previousNode) {
+        action.previousNode = previousNode;
+      }
+      else if (nextNode) {
+        action.nextNode = nextNode;
+      }
     }
   }
   /**
-   * Retrieves all registered element to block strategies for converting HTML elements to DTOs.
-   *
-   * @returns {ElementToDTOStrategy[]} - A set of all registered element to block strategies.
-   */
-  getElementToBlockStrategies() {
-    return this.elementToBlockStrategies;
-  }
-  /**
-   * Retrieves all registered element to node strategies for converting HTML elements to DTOs.
+   * Delete decorator node content
    *
-   * @returns {ElementToDTOStrategy[]} - A set of all registered element to node strategies.
+   * @param {DeleteBlockContentAction} action - The delete block content action
+   * @param {RTEBlock} target - The target block
    */
-  getElementToNodeStrategies() {
-    return this.elementToNodeStrategies;
+  deleteDecoratorNodeContent(action, target) {
+    const startContainerNode = action.startContainerNode, startOffset = action.startOffset;
+    let previousNode = this.getPreviousNode(startContainerNode);
+    let nextNode = null;
+    if (startOffset !== 0) {
+      const parentBlock = target;
+      if (this.isContentFirstNode(startContainerNode)) {
+        nextNode = this.getNextNode(startContainerNode);
+      }
+      if (parentBlock.children.length === 1) {
+        parentBlock.parent.apply(new codeBlock.RemoveChildrenAction(parentBlock));
+      }
+      else {
+        parentBlock.apply(new codeBlock.RemoveChildrenAction(startContainerNode));
+      }
+    }
+    else {
+      const shouldRemoveNode = previousNode;
+      if (shouldRemoveNode && !shouldRemoveNode.isContentEditable()) {
+        previousNode = this.getPreviousNode(shouldRemoveNode);
+        shouldRemoveNode.parent.apply(new codeBlock.RemoveChildrenAction(shouldRemoveNode));
+        if (!previousNode) {
+          action.nextNode = startContainerNode;
+        }
+      }
+    }
+    if (previousNode) {
+      action.previousNode = previousNode;
+    }
+    else if (nextNode) {
+      action.nextNode = nextNode;
+    }
   }
+}
+
+/**
+ * Insert new paragraph into current block at special position.
+ */
+class BlockInsertNewParagraphStrategy extends codeBlock.ActionHandleStrategy {
   /**
-   * Checks if a strategy is already registered in the provided strategy list.
-   *
-   * @param {ElementToDTOStrategy} strategy - The strategy to check for duplicates.
-   * @param {ElementToDTOStrategy[]} strategyList - The list of strategies to check against.
-   * @returns {boolean} - True if the strategy is a duplicate, false otherwise.
+   * @inheritDoc
    */
-  hasDuplicateStrategy(strategy, strategyList) {
-    return strategyList.includes(strategy);
+  handleAction(action, target) {
+    const { startContainerNode } = action;
+    action.newBlock = this.breakSingleBlock(startContainerNode, action.startOffset, target);
   }
-}
-const ElementToDTOClassStrategyManager = new elementToDTOClassStrategyManager();
-
-/** Element to DTO processor */
-class ElementToDtoStrategyProcessor {
   /**
-   * Transform process.
+   * breakSingleTextBlock
    *
-   * @param {HTMLElement[]} elements - Current elements.
-   * @param {VegaRTETransformOptions} [options] - Options for transformation.
-   * @returns {ElementToDTOStrategyOutput[]} - outputs.
+   * @param {RTETextNode} splitNode -
+   * @param {number} startOffsetOfNode -
+   * @param {RTEBlock} target -
+   * @returns {Nullable<RTEBlock>} Nullable<RTEBlock>
    */
-  process(elements, options = { autoMatchFormat: true, skipCustomAnnotations: true }) {
-    const strategies = this.getElementToBlockStrategies();
-    const outputs = [];
-    for (let i = 0; i < elements.length; i++) {
-      if (this.isInvalidElement(elements[i]))
-        continue;
-      let canHandledCount = 0;
-      for (const strategy of strategies) {
-        canHandledCount = strategy.canHandle(elements, i, options);
-        if (canHandledCount > 0) {
-          const handledElements = elements.slice(i, i + canHandledCount);
-          const output = new ElementToDTOStrategyOutput(strategy, handledElements);
-          if (canHandledCount === 1 && strategy.shouldProceedToElementChildren()) {
-            output.setChildrenOutput(this.process(Array.from(handledElements[0].childNodes), options));
-          }
-          outputs.push(output);
-          i += canHandledCount - 1;
-          break;
-        }
+  breakSingleBlock(splitNode, startOffsetOfNode, target) {
+    const newParagraph = this.getNewParagraph(splitNode);
+    if (newParagraph) {
+      if (this.isCaretPositionAtBlockEnd(target, splitNode, startOffsetOfNode)) {
+        target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newParagraph));
       }
-      if (canHandledCount === 0 && i < elements.length) {
-        const elementChildren = Array.from(elements[i].childNodes);
-        const childrenOutputs = this.process(Array.from(elementChildren), options);
-        if (childrenOutputs.length > 0) {
-          outputs.push(...childrenOutputs);
-        }
+      else if (this.isCaretPositionAtBlockStart(target, splitNode, startOffsetOfNode)) {
+        target.parent.apply(new codeBlock.InsertChildrenBeforeAction(target, newParagraph));
+      }
+      else {
+        const splitBlockAction = new codeBlock.SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
+        target.apply(splitBlockAction);
+        return splitBlockAction.newBlock;
       }
+      return newParagraph;
     }
-    return outputs;
-  }
-  /**
-   * Checks if the given element is valid to parse.
-   *
-   * @param {HTMLElement} element - The pasted element.
-   * @returns {boolean} Is valid
-   */
-  isInvalidElement(element) {
-    if (element.nodeType === Node.COMMENT_NODE)
-      return true;
-    return ['META', 'STYLE'].includes(element.nodeName);
   }
   /**
-   * Get the register element to block strategies.
+   * Create new Paragraph
    *
-   * @returns {ElementToDTOStrategy[]} - The register element to block strategies.
+   * @param {RTENode} splitNode - The split node of the block.
+   * @returns {Nullable<RTETextBlock>} - The new text block.
    */
-  getElementToBlockStrategies() {
-    return ElementToDTOClassStrategyManager.getElementToBlockStrategies();
+  getNewParagraph(splitNode) {
+    const newParagraph = this.createNewParagraph('');
+    if (newParagraph) {
+      let textNode = newParagraph.children[0];
+      if (splitNode.isTextNode() && splitNode.isContentEditable()) {
+        newParagraph.children = [];
+        textNode = splitNode.cloneWithText('');
+        // The link annotation don't need inherited
+        textNode.annotationMap.delete(codeBlock.NodeAnnotationTypeEnum.LINK);
+        newParagraph.apply(new codeBlock.AppendChildrenAction([textNode]));
+      }
+      return newParagraph;
+    }
   }
 }
-const ElementToDtoStrategyProcessor$1 = new ElementToDtoStrategyProcessor();
 
 /**
  * Update the cursor position in the editor.
+ *
+ * @example richEditorRef.value.apply(new UpdateCursorPositionAction(nextFocusNode, [offset], [immediatelyRun]))
  */
-class UpdateCursorPositionStrategy extends codeBlock.ActionHandleStrategy {
+class UpdateCursorPositionAction extends codeBlock.ModifyContentAction {
   /**
-   * @inheritDoc
+   * Set the cursor position at end of the current node.
+   *
+   * @param {RTENode} nextFocusNode - The rich text editor needs focus node.
+   * @param {number} offset - The cursor offset position.
+   * @param {boolean} immediatelyRun - Whether to immediately set the cursor position after applying it. Usually the set action will trigger after the UI renders.
    */
-  handleAction(action, target) {
-    const { offset, nextFocusNode, immediatelyRun } = action;
-    const host = codeBlock.stateEntityRenderingRegistry.getDOMByEntity(target);
-    if (host) {
-      changeManager.ChangeManager.notify(domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubject(host, vegaInternalEventId.VegaInternalUpdateRTECursorPosition), {
-        node: nextFocusNode,
-        offset,
-        updateDirectly: immediatelyRun,
-      });
+  constructor(nextFocusNode, offset, immediatelyRun = false) {
+    super();
+    this.isFlushable = true;
+    this.type = codeBlock.ModifyContentActionType.UPDATE_CURSOR_POSITION;
+    this.immediatelyRun = false;
+    this.nextFocusNode = nextFocusNode;
+    this.offset = offset;
+    this.immediatelyRun = immediatelyRun;
+    // Don't flush changes if we want to immediately run the cursor update. Usually the current value is the latest value.
+    if (this.immediatelyRun) {
+      this.isFlushable = false;
     }
   }
 }
 
 /**
- * Append new block array or node array to block or VegaRTEContent instance strategy.
+ * Insert a new node in nearest position of parent block strategy.
  */
-class AppendChildrenStrategy extends codeBlock.ActionHandleStrategy {
+class InsertNodeToNearestRootStrategy extends codeBlock.ActionHandleStrategy {
   /**
    * @inheritDoc
    */
   handleAction(action, target) {
-    const newBlocks = action.entityToBeAppended;
-    if (target.children) {
-      newBlocks.forEach((block) => {
-        block.parent = target;
-      });
-      // This line is used to fix the typescript error `This expression is not callable`. https://github.com/microsoft/TypeScript/issues/44373
-      const arrayFixed = target.children;
-      target.children = arrayFixed.concat(newBlocks);
+    const { rteRange, nodeToBeInserted } = action;
+    const { startNode, startOffset } = rteRange;
+    if (startNode) {
+      const parent = target;
+      if (startNode.isContentEditable() && startNode.isTextNode()) {
+        if (startNode.text === '\n' || !startNode.text || startOffset === 0) {
+          parent.apply(new codeBlock.InsertChildrenBeforeAction(startNode, nodeToBeInserted));
+        }
+        else {
+          const startText = startNode.text.substring(0, startOffset);
+          const endText = startNode.text.substring(startOffset);
+          const startTextNode = startNode.cloneWithText(startText);
+          const endTextNode = startNode.cloneWithText(endText);
+          const insertNodes = [startTextNode, nodeToBeInserted];
+          if (endText) {
+            insertNodes.push(endTextNode);
+          }
+          parent.apply(new codeBlock.InsertChildrenBeforeAction(startNode, ...insertNodes));
+          parent.apply(new codeBlock.RemoveChildrenAction(startNode));
+        }
+      }
+      else {
+        if (startOffset !== 0) {
+          parent.apply(new codeBlock.InsertChildrenAfterAction(startNode, nodeToBeInserted));
+        }
+        else {
+          parent.apply(new codeBlock.InsertChildrenBeforeAction(startNode, nodeToBeInserted));
+        }
+      }
+      this.updateCursorPosition(nodeToBeInserted);
     }
   }
-}
-
-/**
- * Insert children at the front of the block strategy.
- */
-class InsertChildrenBeforeStrategy extends codeBlock.ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    this.replaceElementWithElements(target, action.referChildren, [
-      ...action.childrenToBeInserted,
-      action.referChildren,
-    ]);
-  }
   /**
-   * Replaces a specific block or node with an array of blocks or nodes within RTEContentBlock array.
+   * Update the cursor position to end of the inserted node.
    *
-   * @param {RTEBlock | VegaRTEContent} target - The block or the VegaRTEContent instance.
-   * @param {RTEBlock | RTENode} referElement - Used as a reference element to identify the element that needs to be replaced in the array.
-   * @param {RTEBlock[] | RTENode[]} elements - An array of block or node objects that you want to replace the `referElement` with in the array.
-   */
-  replaceElementWithElements(target, referElement, elements) {
-    if (target.children) {
-      elements.forEach((block) => {
-        block.parent = target;
-      });
-      const arrayFixed = target.children;
-      target.children = arrayFixed.flatMap((block) => {
-        if (block === referElement) {
-          return elements;
-        }
-        else {
-          return block;
-        }
-      });
+   * @param {RTENode} node - node to find root content
+   */
+  updateCursorPosition(node) {
+    const root = this.getRootContent(node.parent);
+    if (root) {
+      root.apply(new UpdateCursorPositionAction(node));
     }
   }
 }
 
 /**
- * Insert children at the front of the block strategy.
+ * Strategy for inserting text into a decorator node. The decorator can not edit, so we insert the text as a new child.
  */
-class InsertChildrenAfterStrategy extends InsertChildrenBeforeStrategy {
+class InsertTextToDecoratorNodeStrategy extends codeBlock.ActionHandleStrategy {
   /**
    * @inheritDoc
    */
   handleAction(action, target) {
-    this.replaceElementWithElements(target, action.referChildren, [
-      action.referChildren,
-      ...action.childrenToBeInserted,
-    ]);
+    const { text, offset, decoratorNode } = action;
+    const paragraph = this.createNewParagraph(text);
+    if (paragraph) {
+      const newTextNode = paragraph.children[0];
+      if (offset !== 0) {
+        target.apply(new codeBlock.InsertChildrenAfterAction(decoratorNode, newTextNode));
+      }
+      else {
+        target.apply(new codeBlock.InsertChildrenBeforeAction(decoratorNode, newTextNode));
+      }
+      this.setTheCursorPosition(newTextNode);
+    }
+  }
+  /**
+   * Set the cursor position to the new text node.
+   *
+   * @param {RTENode} focusNode - The new text node to focus on.
+   */
+  setTheCursorPosition(focusNode) {
+    const rootContent = this.getRootContent(focusNode.parent);
+    if (rootContent) {
+      rootContent.apply(new UpdateCursorPositionAction(focusNode));
+    }
   }
 }
 
 /**
- * Annotation for image
+ * Insert new paragraph into current list item block at special position.
  */
-class ImageAnnotation extends codeBlock.NodeAnnotation {
-  constructor(size, alt) {
-    super();
-    this.type = codeBlock.NodeAnnotationTypeEnum.IMAGE;
-    this.size = size;
-    this.alt = alt;
+class ListItemInsertNewParagraphStrategy extends codeBlock.ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    action.newBlock = this.breakSingleListItemBlock(action.startContainerNode, action.startOffset, target);
   }
   /**
-   * Generate the map item for the annotation
+   * Breaks a single list item block at a specific position.
    *
-   * @param {string} size - Image size
-   * @param {string} alt - Image alt
-   * @returns {[NodeAnnotationTypeEnum.IMAGE, ImageAnnotation]} Map item for the annotation
+   * @param {RTETextNode} splitNode - The node that needs to be split within a list item block.
+   * @param {number} startOffsetOfNode - The index within the `splitNode` where the break operation should occur.
+   * @param {RTEListItemBlock} target - The list item block.
+   * @returns {Nullable<RTEBlock>} Returns either a new `RTEListItemBlock` if the caret
+   * position is at the end of the `splitNode`, or it returns the result of splitting the block at the
+   * caret position if it is neither at the start nor at the end.
    */
-  static from(size, alt) {
-    return [codeBlock.NodeAnnotationTypeEnum.IMAGE, new ImageAnnotation(size, alt)];
+  breakSingleListItemBlock(splitNode, startOffsetOfNode, target) {
+    const newListItem = target.createNewListItem();
+    const newBreakNode = this.copyInlineStyleToNewNode(splitNode);
+    newListItem.apply(new codeBlock.AppendChildrenAction([newBreakNode]));
+    if (this.isCaretPositionAtBlockEnd(target, splitNode, startOffsetOfNode)) {
+      return this.breakListItemAtEnd(newListItem, target);
+    }
+    else if (this.isCaretPositionAtBlockStart(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new codeBlock.InsertChildrenBeforeAction(target, newListItem));
+    }
+    else {
+      const splitBlockAction = new codeBlock.SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
+      target.apply(splitBlockAction);
+      return splitBlockAction.newBlock;
+    }
+    return newListItem;
   }
   /**
-   * Generate the JSON representation of the annotation
+   * Breaks a list item at the end and handles the insertion of a new list item or paragraph accordingly.
    *
-   * @returns {Nullable<Record<string, unknown>>} JSON representation of the annotation
+   * @param {RTEListItemBlock} newListItem - Item that represents a new list item to be added to the existing list.
+   * @param {RTEListItemBlock} target - The list item block.
+   * @returns {RTEBlock} Returns a `RTEBlock`.
    */
-  toJSON() {
-    return typeGuard.isNonNullable(this.alt)
-      ? {
-        size: this.size,
-        alt: this.alt,
+  breakListItemAtEnd(newListItem, target) {
+    const lastItem = target.parent.children[target.parent.children.length - 1];
+    const currentItemIsEmpty = target.children.length === 1 && target.children[0].isEmpty();
+    if (target === lastItem && currentItemIsEmpty) {
+      const parentParent = target.parent.parent;
+      if (parentParent['type'] !== 'list-item') {
+        const newParagraph = codeBlock.RTETextBlock.from({
+          id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+          type: 'paragraph',
+          nodes: [],
+        });
+        newParagraph.apply(new codeBlock.AppendChildrenAction(newListItem.children));
+        parentParent.apply(new codeBlock.InsertChildrenAfterAction(target.parent, newParagraph));
+        target.parent.apply(new codeBlock.RemoveChildrenAction(target));
+        return newParagraph;
       }
-      : {
-        size: this.size,
-      };
+      else {
+        parentParent.parent.apply(new codeBlock.InsertChildrenAfterAction(parentParent, newListItem));
+        target.parent.apply(new codeBlock.RemoveChildrenAction(target));
+      }
+    }
+    else {
+      target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newListItem));
+    }
+    return newListItem;
   }
   /**
-   * @inheritDoc
+   * Copy the inline style to new node
+   *
+   * @param {RTETextNode} needCopedNode - The node that needed to be copied to
+   * @returns {RTETextNode} Returns a `RTETextNode`.
    */
-  clone() {
-    return new ImageAnnotation(this.size, this.alt);
+  copyInlineStyleToNewNode(needCopedNode) {
+    const textNode = needCopedNode.cloneWithText('');
+    // The link annotation doesn't need to inherit
+    textNode.annotationMap.delete(codeBlock.NodeAnnotationTypeEnum.LINK);
+    return textNode;
   }
-  /**
-   * @inheritDoc
-   */
-  renderClass(options) {
-    if (options === null || options === void 0 ? void 0 : options.standalone)
-      return null;
-    return this.size ? `v-rte--image-size-${this.size}` : null;
+}
+
+/**
+ * Delete the nest list block action
+ *
+ * @example needRemovedNestList.parent.apply(new RemoveNestListAction(needRemovedNestList))
+ */
+class RemoveNestListAction extends codeBlock.ModifyContentAction {
+  constructor(childList) {
+    super();
+    this.type = codeBlock.ModifyContentActionType.DELETE_NEST_LIST;
+    this.nestListBlockToBeRemoved = childList;
   }
+}
+
+/**
+ * List remove list item strategy.
+ */
+class ListRemoveListItemStrategy extends codeBlock.RemoveChildrenStrategy {
   /**
-   * @inheritDoc
+   * Remove the list item, check the list item and remove self if the list item is empty.
+   *
+   * @param {RemoveChildrenAction} action - The remove action instance.
+   * @param {RTEListBlock} target - The list block.
    */
-  renderStyle(options) {
-    if (!(options === null || options === void 0 ? void 0 : options.standalone))
-      return null;
-    const baseStyle = { verticalAlign: 'bottom' };
-    switch (this.size) {
-      case 'sm': {
-        return Object.assign(Object.assign({}, baseStyle), { width: '25%' });
-      }
-      case 'md': {
-        return Object.assign(Object.assign({}, baseStyle), { width: '50%' });
+  handleAction(action, target) {
+    super.handleAction(action, target);
+    const parent = target.parent;
+    if (target.children.length === 0 && parent) {
+      // The parent is a list item mean the current block is a nest list, so we need to use RemoveNestListAction to remove the item
+      if (parent['type'] === 'list-item') {
+        parent.apply(new RemoveNestListAction(target));
       }
-      case 'lg': {
-        return Object.assign(Object.assign({}, baseStyle), { width: '100%' });
+      else {
+        parent.apply(new codeBlock.RemoveChildrenAction(target));
       }
     }
   }
 }
 
 /**
- * Update the image node annotation map strategy.
+ * Strategy to handle the paste content into function block.
  */
-class ImageSetAnnotationMapStrategy extends codeBlock.ActionHandleStrategy {
+class PasteContentStrategy extends codeBlock.ActionHandleStrategy {
   /**
    * @inheritDoc
    */
   handleAction(action, target) {
-    const annotation = action.toAnnotation();
-    target.annotationMap.set(annotation.type, annotation);
+    if (target.parent) {
+      const { blocksToBeInserted, startNode, startOffset } = action;
+      let futureFocusBlock = target;
+      if (startNode === target.children[0] && startOffset === 0) {
+        target.parent.apply(new codeBlock.InsertChildrenBeforeAction(target, ...blocksToBeInserted));
+      }
+      else {
+        const breakAction = new codeBlock.SplitBlockWithNodeAction(startNode, startOffset);
+        target.apply(breakAction);
+        target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, ...blocksToBeInserted));
+        futureFocusBlock = breakAction.newBlock;
+      }
+      action.futureFocusBlock = futureFocusBlock;
+    }
   }
 }
 
 /**
- * The image node update property url strategy.
+ * Manager class for registering DTO action strategies.
  */
-class ImageUpdateUrlStrategy extends codeBlock.ActionHandleStrategy {
+class RTEDTOActionStrategyManager {
   /**
-   * @inheritDoc
+   * Registers basic strategies for a given DTO class.
+   *
+   * @param {string} dtoClassName - The name of the RTE block class name.
    */
-  handleAction(action, target) {
-    target.url = action.url;
+  registerBlockBasicStrategies(dtoClassName) {
+    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.DELETE_CHILDREN, dtoClassName, dtoClassName === RTEListBlock.name
+      ? new ListRemoveListItemStrategy()
+      : new codeBlock.RemoveChildrenStrategy());
+    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.APPEND_CHILDREN, dtoClassName, new AppendChildrenStrategy());
+    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_CHILDREN_BEFORE, dtoClassName, new InsertChildrenBeforeStrategy());
+    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_CHILDREN_AFTER, dtoClassName, new InsertChildrenAfterStrategy());
+    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.DELETE_BLOCK_CONTENT, dtoClassName, new BlockDeleteTextOrDecoratorNodeStrategy());
+    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, dtoClassName, dtoClassName === RTEListItemBlock.name
+      ? new ListItemInsertNewParagraphStrategy()
+      : new BlockInsertNewParagraphStrategy());
+    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_TEXT_TO_DECORATOR_NODE, dtoClassName, new InsertTextToDecoratorNodeStrategy());
+    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_NODE_TO_NEAREST_ROOT, dtoClassName, new InsertNodeToNearestRootStrategy());
+    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.PASTE_CONTENT, dtoClassName, new PasteContentStrategy());
   }
 }
+const RTEDTOActionStrategyManager$1 = new RTEDTOActionStrategyManager();
 
-var __rest = (undefined && undefined.__rest) || function (s, e) {
-  var t = {};
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-    t[p] = s[p];
-  if (s != null && typeof Object.getOwnPropertySymbols === "function")
-    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-        t[p[i]] = s[p[i]];
-    }
-  return t;
-};
 /**
- * Image node
+ * Abstract class to define handler for generate the annotations
  */
-class RTEImageNode extends codeBlock.RTEDecoratorNode {
-  constructor(id, url, parentBlock, annotationMap) {
-    super(id, annotationMap);
-    this.type = codeBlock.NodeTypeEnum.IMAGE;
-    this.url = url;
-    this.parent = parentBlock;
+class AnnotationGeneratorStrategyAbstract {
+}
+
+/** Handle bold annotation */
+class BoldAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle(targetDto) {
+    return targetDto.name === 'RTETextNode';
+  }
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
+   */
+  handle(element, parentAnnotations = {}) {
+    return this.isBold(element) || parentAnnotations.bold ? { bold: true } : {};
+  }
+  /**
+   * Is bold element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
+   */
+  isBold(element) {
+    return (element.nodeName === 'STRONG' ||
+      element.nodeName === 'B' ||
+      element.style.fontWeight === 'bold' ||
+      element.style.fontWeight === '700' ||
+      element.classList.contains('v-rte--bold'));
   }
+}
+
+/** Handle custom attribute annotation */
+class CustomAttributeAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
-   * Converts a VegaRTEImageNode into an RTEImageNode by mapping nodes and creating annotations.
+   * Can be handle.
    *
-   * @param {VegaRTEImageNode} node - The node to be converted.
-   * @param {RTEImageBlock} parentBlock - The parent block
-   * @param {VegaRTETransformOptions} options - Optional transformation options.
-   * @returns {RTEImageNode} An instance of `RTEImageBlock`
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options for annotation generator.
+   * @returns {boolean} - .
    */
-  static from(node, parentBlock, options = { autoMatchFormat: true }) {
-    const imageNode = new RTEImageNode(node.id, node.url, parentBlock);
-    const autoMatchFormat = !!options.autoMatchFormat;
-    const _a = Object.assign({}, node.annotations), { size } = _a, otherAnnotations = __rest(_a, ["size"]);
-    const annotations = Object.assign(Object.assign({}, otherAnnotations), { size: size !== null && size !== void 0 ? size : (autoMatchFormat ? 'md' : undefined) });
-    imageNode.annotationMap = new Map(Object.keys(annotations)
-      .map((type) => {
-      if (type === 'size' || type === 'alt') {
-        return ImageAnnotation.from(annotations.size, annotations.alt);
-      }
-      return this.createAnnotationEntity(type, annotations[type]);
-    })
-      .filter(typeGuard.isNonNullable));
-    return imageNode;
+  canHandle(targetDto, options) {
+    return !options.skipCustomAnnotations && !!targetDto;
   }
   /**
-   * @inheritDoc
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTETextAnnotations} - Annotation.
    */
-  toJSON() {
-    const annotations = Array.from(this.annotationMap.values())
-      .filter((annotation) => annotation instanceof ImageAnnotation || annotation instanceof codeBlock.CommonAnnotation)
-      .reduce((record, annotation) => {
-      return Object.assign(Object.assign({}, record), annotation.toJSON());
+  handle(element) {
+    const attributes = this.getAttributes(element);
+    return Object.keys(attributes).length > 0 ? { customAttribute: attributes } : {};
+  }
+  /**
+   * Obtain the custom attributes of element, excluding 'style' and 'class'.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Record<string, string>} - Record<string, string>.
+   */
+  getAttributes(element) {
+    const attributeNames = element
+      .getAttributeNames()
+      .filter((attr) => attr !== 'style' && attr !== 'class' && this.isValidAttr(attr));
+    return attributeNames.reduce((acc, item) => {
+      acc[item] = element.getAttribute(item);
+      return acc;
     }, {});
-    if (annotations.alt == '')
-      delete annotations.alt;
-    return Object.assign(Object.assign({ id: this.id }, (Object.keys(annotations).length > 0 ? { annotations } : {})), { type: 'image', url: this.url });
   }
   /**
-   * @inheritDoc
+   * Check if the attribute name is valid.
+   *
+   * @param {string} attr - Attribute name.
+   * @returns {boolean} - True if valid, false otherwise.
    */
-  clone(parent) {
-    return new RTEImageNode(this.id, this.url, parent, super.cloneAnnotations());
+  isValidAttr(attr) {
+    return /^[a-zA-Z_][\w-]*$/.test(attr);
   }
+}
+
+/** Handle custom class annotation */
+class CustomClassAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
-   * @inheritDoc
+   * Can be handle.
+   *
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options for annotation generator.
+   * @returns {boolean} - .
    */
-  toHtml() {
-    const imageAnnotation = this.getAnnotationByType(codeBlock.NodeAnnotationTypeEnum.IMAGE);
-    const attrStr = super.generateAttributeString(...[
-      imageAnnotation && imageAnnotation.alt ? `alt="${imageAnnotation.alt}"` : null,
-      `src="${this.url}"`,
-      imageAnnotation && imageAnnotation.size ? `data-size="${imageAnnotation.size}"` : null,
-    ].filter(typeGuard.isNonNullable));
-    return `<img${attrStr}>`;
+  canHandle(targetDto, options) {
+    return !options.skipCustomAnnotations && !!targetDto;
   }
   /**
-   * @inheritDoc
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTETextAnnotations} - Annotation.
    */
-  doAnnotationActionApply(action) {
-    const strategy = codeBlock.ActionHandleStrategyRegistry.get(codeBlock.AnnotationAction.name, RTEImageNode.name);
-    if (strategy) {
-      strategy.execute(action, this);
-    }
+  handle(element) {
+    const classes = this.getCustomClass(element);
+    return classes.length > 0 ? { customClass: classes } : {};
   }
   /**
-   * @inheritDoc
+   * Get the custom class
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {string[]} - the class after .
    */
-  doModifyActionApply(action) {
-    codeBlock.ActionHandleStrategyRegistry.executeTheStrategy(action, this);
+  getCustomClass(element) {
+    return element.classList
+      .toString()
+      .split(' ')
+      .filter((item) => !item.includes('v-rte') && item !== '');
   }
 }
-(() => {
-  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.UPDATE_IMAGE_NODE_URL, RTEImageNode.name, new ImageUpdateUrlStrategy());
-  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.AnnotationAction.name, RTEImageNode.name, new ImageSetAnnotationMapStrategy());
-})();
 
-/**
- * Split the current image block with a special position strategy.
- */
-class BlockSplitWithImageNodeStrategy extends codeBlock.ActionHandleStrategy {
+/** Handle custom style annotation */
+class CustomStyleAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
-   * @inheritDoc
+   * Can be handle.
+   *
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options for annotation generator.
+   * @returns {boolean} - .
    */
-  handleAction(action, target) {
-    action.newBlock = this.splitImageNodes(action.splitPointNode, action.startOffsetOfNode, target);
+  canHandle(targetDto, options) {
+    return !options.skipCustomAnnotations && !!targetDto;
   }
   /**
-   * The image offset should be 0 or 1
-   * <vega-rich-text-image-editor><img /></vega-rich-text-image-editor>
+   * Handle annotation.
    *
-   * @param {RTEImageNode} imageNode The split point image node.
-   * @param {number} imageOffset The cursor point 0 | 1.
-   * @param {RTEImageBlock} target The image block.
-   * @returns {Nullable<RTEBlock>} The new block after split
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTETextAnnotations} - Annotation.
    */
-  splitImageNodes(imageNode, imageOffset, target) {
-    const nodesSplitIndex = target.children.indexOf(imageNode);
-    if (nodesSplitIndex > -1) {
-      const beforeNodes = target.children.slice(0, nodesSplitIndex + imageOffset);
-      const afterNodes = target.children.slice(nodesSplitIndex + imageOffset);
-      target.apply(new codeBlock.ReplaceChildNodesAction(beforeNodes));
-      const newBlock = this.cloneWithNodes(afterNodes, target);
-      target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newBlock));
-      return newBlock;
-    }
+  handle(element) {
+    const styles = this.generateCustomStyleAnnotations(element);
+    return Object.keys(styles).length > 0 ? { customStyle: styles } : {};
   }
   /**
-   * Creates a new RTEImageBlock instance with the provided RTEImageNode instances appended to it.
+   * Obtain and format the style of element.
    *
-   * @param {RTEImageNode[]} nodes - An array of RTEImageNode objects that will be used to create a new RTEImageBlock instance.
-   * @param {RTEImageBlock} target The image block.
-   * @returns {RTEImageBlock} A new `RTEImageBlock` object with the provided `nodes` appended to it.
+   * @param {HTMLElement} element - current element.
+   * @returns {AnnotationStyle} - Record<string, string>.
    */
-  cloneWithNodes(nodes, target) {
-    const block = target.createNewImageBlock();
-    block.children = [];
-    block.apply(new codeBlock.AppendChildrenAction(nodes));
-    return block;
+  generateCustomStyleAnnotations(element) {
+    const customStyle = element.getAttribute('style');
+    if (!customStyle)
+      return {};
+    const styleValue = customStyle.split(';').filter(Boolean);
+    return styleValue
+      .filter((key) => key !== ' ')
+      .map((key) => {
+      // to remove redundant quote pairs if needed, for example: ['fontFamily: "Roboto Mono"'] will be updated to ['fontFamily: Roboto Mono']
+      const styleObject = key.replace(/(['"])(.*?)\1/g, '$2').split(':');
+      const styleKey = string.dashCaseToCamel(styleObject[0].trim());
+      return {
+        [styleKey]: styleObject[1].trim().replace(';', ''),
+      };
+    })
+      .reduce((current, obj) => (Object.assign(Object.assign({}, current), obj)), {});
   }
 }
 
-/**
- * Break the current block after press enter, this action is similar with the SplitBlockWithNodeAction,
- * The SplitBlockWithNodeAction split the current block to two same type blocks, but this action will create new paragraph or list item when break at start or end.
- * The property `newBlock` use to store the new create block if need.
- *
- * @example currentBlock.apply(new InsertNewParagraphAction(startContainerNode, startOffset))
- */
-class InsertNewParagraphAction extends codeBlock.ModifyContentAction {
-  constructor(startContainerNode, startOffset) {
-    super();
-    this.type = codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH;
-    this.startContainerNode = startContainerNode;
-    this.startOffset = startOffset;
+/** Handle indent annotation */
+class IndentAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle(targetDto) {
+    return ['RTETextBlock', 'RTEListItemBlock', 'RTEListBlock'].includes(targetDto.name);
   }
-}
-
-/**
- * The image block insert line break strategy.
- */
-class ImageInsertLineBreakStrategy extends codeBlock.ActionHandleStrategy {
   /**
-   * The image block not support insert the line break node, so invoke the insert new paragraph logic directly.
+   * Handle annotation.
    *
-   * @param {LineBreakSingleBlockAction} action - The action instance.
-   * @param {RTEImageBlock} target - The image block.
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTEBlockAnnotations} - Annotation.
    */
-  handleAction(action, target) {
-    const insertNewParagraphAction = new InsertNewParagraphAction(action.startContainerNode, action.startOffset);
-    target.apply(insertNewParagraphAction);
-    const newBlock = insertNewParagraphAction.newBlock;
-    if (newBlock) {
-      action.lineBreakNode = newBlock.children[0];
+  handle(element) {
+    const indent = this.getIndent(element);
+    return indent ? { indent: indent } : {};
+  }
+  /**
+   * Get indent of current element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Nullable<number>} - Indent.
+   */
+  getIndent(element) {
+    const style = element.style;
+    let marginLeft;
+    if (style.marginLeft) {
+      marginLeft = style.marginLeft;
+    }
+    else if (style.margin) {
+      const margins = style.margin.split(' ');
+      switch (margins.length) {
+        case 4:
+          marginLeft = margins[3];
+          break;
+        case 2:
+        case 3:
+          marginLeft = margins[1];
+          break;
+        default:
+          marginLeft = margins[0];
+          break;
+      }
     }
+    else {
+      return null;
+    }
+    const marginLeftNumber = Number(marginLeft.replace('px', ''));
+    return marginLeftNumber && marginLeftNumber >= 0 ? Math.floor(marginLeftNumber / 16) : null;
   }
 }
 
-/**
- * Insert a line break node into multiple blocks selection at special position strategy.
- */
-class ImageInsertLineBreakWithBlocksStrategy extends codeBlock.ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    action.lineBreakNode = this.lineBreakMultipleBlocks(action.selectedBlocks, target);
-  }
+/** Handle text align annotation */
+class TextAlignAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
-   * Inserts a new paragraph block with a line break after a selected block of text in a rich text editor.
+   * Can be handle.
    *
-   * @param {RTEBlock[]} selectedBlocks - An array of RTEBlock objects that represent the blocks that have been selected for a specific action in the Rich Text Editor.
-   * @param {RTEImageBlock} target - The image block.
-   * @returns {Nullable<RTETextNode>} Returns a Nullable RTETextNode.
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @returns {boolean} - .
    */
-  lineBreakMultipleBlocks(selectedBlocks, target) {
-    const newParagraph = codeBlock.RTETextBlock.from({
-      id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
-      type: 'paragraph',
-      nodes: [{ id: createPublicApiRuntimeMetricsSlimmer.generateUUID(), type: 'text', text: '\n' }],
-    });
-    target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newParagraph));
-    const afterNodes = this.concatBlocksNodes(selectedBlocks.slice(1));
-    if (afterNodes.length === 0 || (afterNodes[0] && afterNodes[0].text === '')) {
-      afterNodes.push(new codeBlock.RTETextNode(createPublicApiRuntimeMetricsSlimmer.generateUUID(), '\n', newParagraph));
-    }
-    newParagraph.apply(new codeBlock.AppendChildrenAction(afterNodes));
-    return newParagraph['children'][0];
+  canHandle(targetDto) {
+    return ['RTETextBlock', 'RTEListItemBlock', 'RTEListBlock'].includes(targetDto.name);
   }
   /**
-   * Concat the child nodes of multiple RTEBlocks if both are not images.
+   * Handle annotation.
    *
-   * @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
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTEBlockAnnotations} - Annotation.
    */
-  concatBlocksNodes(blocks) {
-    const nodes = [];
-    blocks.map((block) => {
-      if (block.type !== 'image') {
-        nodes.push(...block.children);
-        block.parent.apply(new codeBlock.RemoveChildrenAction(block));
-      }
-    });
-    return nodes;
+  handle(element) {
+    const textAlign = this.getTextAlign(element);
+    return textAlign ? { textAlign: textAlign } : {};
   }
-}
-
-/**
- * Insert a image node at the special position of image block.
- */
-class ImageBlockInsertImageStrategy extends codeBlock.ActionHandleStrategy {
   /**
-   * @inheritDoc
+   * Get text align of current element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Nullable<VegaRTEBlockAlignment>} - Text align.
    */
-  handleAction(action, target) {
-    const splitNode = action.splitPointNode;
-    const startOffsetOfNode = action.startOffsetOfNode;
-    const newImageBlock = action.imageBlockToBeInserted;
-    const newImageNodes = newImageBlock.children;
-    if (target.children.length < 1) {
-      target.apply(new codeBlock.AppendChildrenAction(newImageNodes));
+  getTextAlign(element) {
+    const classList = element.classList;
+    if (classList.contains(`v-rte--horizontal-alignment-left`)) {
+      return 'left';
     }
-    else if (this.isCaretPositionAtBlockEnd(target, splitNode, startOffsetOfNode)) {
-      target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newImageBlock));
+    else if (classList.contains(`v-rte--horizontal-alignment-center`)) {
+      return 'center';
     }
-    else if (this.isCaretPositionAtBlockStart(target, splitNode, startOffsetOfNode)) {
-      target.parent.apply(new codeBlock.InsertChildrenBeforeAction(target, newImageBlock));
+    else if (classList.contains(`v-rte--horizontal-alignment-right`)) {
+      return 'right';
     }
-    else {
-      target.apply(new codeBlock.SplitBlockWithNodeAction(splitNode, startOffsetOfNode));
-      target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newImageBlock));
+    else if (classList.contains(`v-rte--horizontal-alignment-justify`)) {
+      return 'justify';
+    }
+    const style = element.style;
+    switch (style.textAlign) {
+      case 'center':
+        return 'center';
+      case 'right':
+        return 'right';
+      case 'justify':
+        return 'justify';
+      case 'left':
+        return 'left';
+      default:
+        return null;
     }
   }
 }
 
-/**
- * Image block
- */
-class RTEImageBlock extends codeBlock.RTEBlock {
-  constructor(id) {
-    super(id);
-    this.type = 'image';
-    this.children = [];
-  }
-  /**
-   * Converts a VegaRTEImageBlock object into an RTEImageBlock object by mapping nodes and creating annotations.
-   *
-   * @param {VegaRTEImageBlock} block - The block object to be converted.
-   * @param {VegaRTETransformOptions} options - Optional transformation options.
-   * @returns {RTEImageBlock} An instance of `RTEImageBlock`
-   */
-  static from(block, options = { autoMatchFormat: true }) {
-    const imageBlock = new RTEImageBlock(block.id);
-    const { annotations } = block;
-    imageBlock.children = block.nodes.map((image) => RTEImageNode.from(image, imageBlock, options));
-    if (annotations) {
-      super.convertAnnotationsToMap(imageBlock.annotationMap, annotations);
-    }
-    return imageBlock;
-  }
+/** Handle code annotation */
+class CodeAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
    * @inheritDoc
    */
-  toJSON() {
-    return Object.assign(Object.assign({}, super.toJSON()), { type: 'image', nodes: this.children.map((node) => node.toJSON()) });
+  canHandle(targetDto) {
+    return targetDto.name === 'RTETextNode';
   }
   /**
-   * @inheritDoc
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
    */
-  toHtml() {
-    const attrStr = super.generateAttributeString();
-    const children = this.children.map((node) => node.toHtml()).join('');
-    return super.shouldRenderAsInternalWrapper()
-      ? children
-      : [`<div${attrStr}>`, children, `</div>`].join('');
+  handle(element, parentAnnotations = {}) {
+    return this.isCode(element) || parentAnnotations.code ? { code: true } : {};
   }
   /**
-   * @inheritDoc
+   * Is code element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
    */
-  isNotEmpty() {
-    return this.children.length > 0 && this.children.some((node) => node.url.length > 0);
+  isCode(element) {
+    return (element.classList.contains('v-rte--code') ||
+      element.nodeName === 'CODE' ||
+      element.nodeName === 'PRE' ||
+      element.style.fontFamily === 'monospace' ||
+      element.style.fontFamily.replace(/["']/g, '') === 'Roboto Mono');
   }
+}
+
+/** Handle color annotation */
+class ColorAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
    * @inheritDoc
    */
-  getLastNode() {
-    return this.children[this.children.length - 1];
+  canHandle(targetDto) {
+    return targetDto.name === 'RTETextNode';
   }
   /**
-   * Create a new image block.
+   * Handle annotation.
    *
-   * @returns {RTEImageBlock} - The empty image block.
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
    */
-  createNewImageBlock() {
-    return new RTEImageBlock(createPublicApiRuntimeMetricsSlimmer.generateUUID());
+  handle(element, parentAnnotations = {}) {
+    const color = this.getColor(element) || parentAnnotations.textColor;
+    return color ? { textColor: color } : {};
   }
   /**
-   * @inheritDoc
+   * Get current color of element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Nullable<string>} - color.
    */
-  clone(parent) {
-    const clonedBlock = new RTEImageBlock(this.id);
-    clonedBlock.children = this.children.map((node) => node.clone(clonedBlock));
-    clonedBlock.annotationMap = super.cloneAnnotations();
-    clonedBlock.parent = parent;
-    return clonedBlock;
+  getColor(element) {
+    var _a;
+    const color = element.style.color;
+    const hexColor = (_a = ui.rgbToHex(color)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+    if (hexColor) {
+      // We don't display default text color as inline style, because we defined it in the vega-rich-text-content.scss.
+      const colorSchema = codeBlock.RTE_TEXT_COLORS.filter((item) => item.key !== codeBlock.RTE_DEFAULT_TEXT_COLOR.key).find((schema) => schema.light === hexColor || schema.dark === hexColor);
+      if (colorSchema)
+        return colorSchema.key;
+      return null;
+    }
+    else {
+      for (const color of codeBlock.RTE_TEXT_COLORS) {
+        if (element.style.color.includes(color.key)) {
+          return color.key;
+        }
+      }
+      return null;
+    }
   }
 }
-(() => {
-  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTEImageBlock.name, new codeBlock.BlockMergeNodesStrategy());
-  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.REPLACE_CHILD_NODES, RTEImageBlock.name, new codeBlock.BlockReplaceNodesStrategy());
-  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTEImageBlock.name, new BlockSplitWithImageNodeStrategy());
-  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTEImageBlock.name, new ImageInsertLineBreakStrategy());
-  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTEImageBlock.name, new ImageInsertLineBreakWithBlocksStrategy());
-  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEImageBlock.name, new ImageBlockInsertImageStrategy());
-  codeBlock.ActionHandleStrategyRegistry.register(codeBlock.HorizontalAlignmentAnnotationAction.name, RTEImageBlock.name, new codeBlock.BlockUpdateHorizontalAlignmentStrategy());
-})();
 
-/**
- * HTML Block
- */
-class RTEHtmlBlock extends codeBlock.RTEBlock {
-  constructor(id, htmlTag) {
-    super(id);
-    this.type = 'html-block';
-    this.children = [];
-    this.htmlTag = htmlTag;
-  }
+/** Handle italic annotation */
+class ItalicAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
-   * Converts a VegaRTEHtmlBlock to an RTEHtmlBlock.
-   *
-   * @param {VegaRTEHtmlBlock} block - The VegaRTEHtmlBlock to convert.
-   * @param {VegaRTETransformOptions} [options] - Optional transformation options.
-   * @returns {RTEHtmlBlock} The converted RTEHtmlBlock.
+   * @inheritDoc
    */
-  static from(block, options) {
-    const htmlBlock = new RTEHtmlBlock(block.id, block.htmlTag);
-    const { annotations } = block;
-    if (annotations) {
-      super.convertAnnotationsToMap(htmlBlock.annotationMap, annotations);
-    }
-    htmlBlock.children = block.children
-      .map((child) => {
-      const BlockClass = codeBlock.RTEDTOClassManager.getRTEBlockClass(child.type);
-      if (BlockClass) {
-        const block = BlockClass.from(child, options);
-        block.parent = htmlBlock;
-        return block;
-      }
-    })
-      .filter(typeGuard.isNonNullable);
-    return htmlBlock;
+  canHandle(targetDto) {
+    return targetDto.name === 'RTETextNode';
   }
   /**
-   * @inheritDoc
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
    */
-  clone(parent) {
-    const clonedBlock = new RTEHtmlBlock(this.id, this.htmlTag);
-    clonedBlock.children = this.children.map((child) => child.clone(clonedBlock));
-    clonedBlock.annotationMap = super.cloneAnnotations();
-    clonedBlock.parent = parent;
-    return clonedBlock;
+  handle(element, parentAnnotations = {}) {
+    return this.isItalic(element) || parentAnnotations.italic ? { italic: true } : {};
   }
   /**
-   * @inheritDoc
+   * Is italic element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
    */
-  getLastNode() {
-    return this.children[this.children.length - 1].getLastNode();
+  isItalic(element) {
+    return (element.nodeName === 'I' ||
+      element.style.fontStyle === 'italic' ||
+      element.nodeName === 'EM' ||
+      element.classList.contains('v-rte--italic'));
+  }
+}
+
+/** Handle link annotation */
+class LinkAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  constructor() {
+    super(...arguments);
+    this.handlers = [
+      new CustomAttributeAnnotationHandler(),
+      new CustomClassAnnotationHandler(),
+      new CustomStyleAnnotationHandler(),
+    ];
   }
   /**
-   * @inheritDoc
+   * Can be handle.
+   *
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @returns {boolean} - .
    */
-  isNotEmpty() {
-    return this.children.length > 0;
+  canHandle(targetDto) {
+    return targetDto.name === 'RTETextNode';
   }
   /**
-   * @inheritDoc
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
    */
-  toHtml() {
-    const BlockTag = this.htmlTag;
-    const attrStr = super.generateAttributeString();
-    return [
-      `<${BlockTag}${attrStr}>`,
-      this.children.map((block) => block.toHtml()).join(''),
-      `</${BlockTag}>`,
-    ].join('');
+  handle(element, parentAnnotations = {}) {
+    if (parentAnnotations.link)
+      return { link: parentAnnotations.link };
+    return element.tagName === 'A' ? { link: this.generateLinkAnnotations(element) } : {};
   }
   /**
-   * @inheritDoc
+   * Generate link annotations.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTELink} - link annotations.
    */
-  toJSON() {
-    return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: this.type, htmlTag: this.htmlTag, children: this.children.map((child) => child.toJSON()) });
-  }
-}
-
-/**
- * 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 codeBlock.ModifyContentAction {
-  constructor(blockNeedToBeMerged) {
-    super();
-    this.type = codeBlock.ModifyContentActionType.MERGE_TWO_BLOCKS_NODES;
-    this.blockNeedToBeMerged = blockNeedToBeMerged;
+  generateLinkAnnotations(element) {
+    const annotations = {
+      href: element.getAttribute('href') || '',
+      groupKey: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+    };
+    this.handlers.forEach((handler) => {
+      Object.assign(annotations, handler.handle(element));
+    });
+    return annotations;
   }
 }
 
-/**
- * Block delete text or decorator node strategy.
- */
-class BlockDeleteTextOrDecoratorNodeStrategy extends codeBlock.BlockDeleteNodeContentStrategy {
+/** Handle strike through annotation */
+class StrikeThroughAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
    * @inheritDoc
    */
-  handleAction(action, target) {
-    const { startContainerNode } = action;
-    if (!startContainerNode.isContentEditable()) {
-      this.deleteDecoratorNodeContent(action, target);
-    }
-    else if (startContainerNode.isTextNode()) {
-      this.deleteTextNodeContent(action, target);
-    }
-    const parent = target.parent;
-    if (parent && target.isListItemBlock() && parent.children.length === 0) {
-      parent.parent.apply(new codeBlock.RemoveChildrenAction(parent));
-    }
+  canHandle(targetDto) {
+    return targetDto.name === 'RTETextNode';
   }
   /**
-   * Handle the delete text logic when press delete key.
+   * Handle annotation.
    *
-   * @param {DeleteBlockContentAction} action - ModifyContentAction
-   * @param {RTETextBlock} target - Current text block
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
    */
-  deleteTextNodeContent(action, target) {
-    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 codeBlock.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.parent === target && previousNode['text'] === '\n') ||
-          target.children.length === 1) {
-          action.previousNode = startContainerNode;
-          return;
-        }
-        else {
-          target.apply(new codeBlock.RemoveChildrenAction(startContainerNode));
-          action.previousNode = previousNode;
-          return;
-        }
-      }
-    }
-    else {
-      let previousNode = this.getPreviousNode(startContainerNode);
-      let nextNode = null;
-      const isCurrentNodeEmpty = startContainerNode.isEmpty();
-      if (target.children.length && previousNode && previousNode.parent !== target) {
-        if (isCurrentNodeEmpty) {
-          target.apply(new codeBlock.RemoveChildrenAction(startContainerNode));
-        }
-        if (target.type === previousNode.parent.type) {
-          previousNode.parent.apply(new MergeTwoBlocksNodesAction(target));
-        }
-      }
-      else {
-        if (this.isContentFirstNode(startContainerNode) && isCurrentNodeEmpty) {
-          nextNode = this.getNextNode(startContainerNode);
-        }
-        /**
-         * Remove line break
-         *
-         * @example caret at the first line
-         * \n
-         * test
-         */
-        if (isCurrentNodeEmpty) {
-          target.apply(new codeBlock.RemoveChildrenAction(startContainerNode));
-        }
-        /**
-         * Remove line break or non-editable node
-         *
-         * @example caret at the begin of second line
-         * \n
-         * test
-         * @example caret at the end of non-editable node and start of the text node
-         * <img/><span>test</span>
-         */
-        if (previousNode &&
-          previousNode.isTextNode() &&
-          (previousNode.isEmpty() ||
-            (!previousNode.isContentEditable() && previousNode.parent === target))) {
-          const shouldRemoveNode = previousNode;
-          previousNode = this.getPreviousNode(previousNode);
-          shouldRemoveNode.parent.apply(new codeBlock.RemoveChildrenAction(shouldRemoveNode));
-          if (!previousNode && !isCurrentNodeEmpty) {
-            nextNode = startContainerNode;
-          }
-        }
-      }
-      //Remove the paragraph block if the content is empty
-      if (target.children.length === 0) {
-        target.parent.apply(new codeBlock.RemoveChildrenAction(target));
-      }
-      if (previousNode) {
-        action.previousNode = previousNode;
-      }
-      else if (nextNode) {
-        action.nextNode = nextNode;
-      }
-    }
+  handle(element, parentAnnotations = {}) {
+    return this.isStrikethrough(element) || parentAnnotations.strikethrough
+      ? { strikethrough: true }
+      : {};
   }
   /**
-   * Delete decorator node content
+   * Is strikethrough element.
    *
-   * @param {DeleteBlockContentAction} action - The delete block content action
-   * @param {RTEBlock} target - The target block
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
    */
-  deleteDecoratorNodeContent(action, target) {
-    const startContainerNode = action.startContainerNode, startOffset = action.startOffset;
-    let previousNode = this.getPreviousNode(startContainerNode);
-    let nextNode = null;
-    if (startOffset !== 0) {
-      const parentBlock = target;
-      if (this.isContentFirstNode(startContainerNode)) {
-        nextNode = this.getNextNode(startContainerNode);
-      }
-      if (parentBlock.children.length === 1) {
-        parentBlock.parent.apply(new codeBlock.RemoveChildrenAction(parentBlock));
-      }
-      else {
-        parentBlock.apply(new codeBlock.RemoveChildrenAction(startContainerNode));
-      }
-    }
-    else {
-      const shouldRemoveNode = previousNode;
-      if (shouldRemoveNode && !shouldRemoveNode.isContentEditable()) {
-        previousNode = this.getPreviousNode(shouldRemoveNode);
-        shouldRemoveNode.parent.apply(new codeBlock.RemoveChildrenAction(shouldRemoveNode));
-        if (!previousNode) {
-          action.nextNode = startContainerNode;
-        }
-      }
-    }
-    if (previousNode) {
-      action.previousNode = previousNode;
-    }
-    else if (nextNode) {
-      action.nextNode = nextNode;
-    }
+  isStrikethrough(element) {
+    return (element.style.textDecoration.includes('line-through') ||
+      element.nodeName === 'S' ||
+      element.nodeName === 'DEL' ||
+      element.classList.contains('v-rte--strikethrough'));
   }
 }
 
-/**
- * Insert new paragraph into current block at special position.
- */
-class BlockInsertNewParagraphStrategy extends codeBlock.ActionHandleStrategy {
+/** Handle underline annotation */
+class UnderlineAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
    * @inheritDoc
    */
-  handleAction(action, target) {
-    const { startContainerNode } = action;
-    action.newBlock = this.breakSingleBlock(startContainerNode, action.startOffset, target);
+  canHandle(targetDto) {
+    return targetDto.name === 'RTETextNode';
   }
   /**
-   * breakSingleTextBlock
+   * Handle annotation.
    *
-   * @param {RTETextNode} splitNode -
-   * @param {number} startOffsetOfNode -
-   * @param {RTEBlock} target -
-   * @returns {Nullable<RTEBlock>} Nullable<RTEBlock>
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
    */
-  breakSingleBlock(splitNode, startOffsetOfNode, target) {
-    const newParagraph = this.getNewParagraph(splitNode);
-    if (newParagraph) {
-      if (this.isCaretPositionAtBlockEnd(target, splitNode, startOffsetOfNode)) {
-        target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newParagraph));
-      }
-      else if (this.isCaretPositionAtBlockStart(target, splitNode, startOffsetOfNode)) {
-        target.parent.apply(new codeBlock.InsertChildrenBeforeAction(target, newParagraph));
-      }
-      else {
-        const splitBlockAction = new codeBlock.SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-        target.apply(splitBlockAction);
-        return splitBlockAction.newBlock;
-      }
-      return newParagraph;
-    }
+  handle(element, parentAnnotations = {}) {
+    return this.isUnderline(element) || parentAnnotations.underline ? { underline: true } : {};
   }
   /**
-   * Create new Paragraph
+   * Is underline element.
    *
-   * @param {RTENode} splitNode - The split node of the block.
-   * @returns {Nullable<RTETextBlock>} - The new text block.
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
    */
-  getNewParagraph(splitNode) {
-    const newParagraph = this.createNewParagraph('');
-    if (newParagraph) {
-      let textNode = newParagraph.children[0];
-      if (splitNode.isTextNode() && splitNode.isContentEditable()) {
-        newParagraph.children = [];
-        textNode = splitNode.cloneWithText('');
-        // The link annotation don't need inherited
-        textNode.annotationMap.delete(codeBlock.NodeAnnotationTypeEnum.LINK);
-        newParagraph.apply(new codeBlock.AppendChildrenAction([textNode]));
-      }
-      return newParagraph;
-    }
+  isUnderline(element) {
+    return (element.style.textDecoration.includes('underline') ||
+      element.nodeName === 'U' ||
+      element.nodeName === 'INS' ||
+      element.classList.contains('v-rte--underline'));
   }
 }
 
-/**
- * Update the cursor position in the editor.
- *
- * @example richEditorRef.value.apply(new UpdateCursorPositionAction(nextFocusNode, [offset], [immediatelyRun]))
- */
-class UpdateCursorPositionAction extends codeBlock.ModifyContentAction {
+/** Handle text style annotation */
+class TextStyleAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
-   * Set the cursor position at end of the current node.
+   * Can be handle.
    *
-   * @param {RTENode} nextFocusNode - The rich text editor needs focus node.
-   * @param {number} offset - The cursor offset position.
-   * @param {boolean} immediatelyRun - Whether to immediately set the cursor position after applying it. Usually the set action will trigger after the UI renders.
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @param {HtmlElementToAnnotationGenerateOptions} options - Options for annotation generator.
+   * @returns {boolean} - .
    */
-  constructor(nextFocusNode, offset, immediatelyRun = false) {
-    super();
-    this.type = codeBlock.ModifyContentActionType.UPDATE_CURSOR_POSITION;
-    this.immediatelyRun = false;
-    this.nextFocusNode = nextFocusNode;
-    this.offset = offset;
-    this.immediatelyRun = immediatelyRun;
+  canHandle(targetDto, options) {
+    return !!options.autoMatchFormat && targetDto.name === 'RTETextBlock';
   }
-}
-
-/**
- * Insert a new node in nearest position of parent block strategy.
- */
-class InsertNodeToNearestRootStrategy extends codeBlock.ActionHandleStrategy {
   /**
-   * @inheritDoc
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTETextBlockAnnotations} - Annotation.
    */
-  handleAction(action, target) {
-    const { rteRange, nodeToBeInserted } = action;
-    const { startNode, startOffset } = rteRange;
-    if (startNode) {
-      const parent = target;
-      if (startNode.isContentEditable() && startNode.isTextNode()) {
-        if (startNode.text === '\n' || !startNode.text || startOffset === 0) {
-          parent.apply(new codeBlock.InsertChildrenBeforeAction(startNode, nodeToBeInserted));
-        }
-        else {
-          const startText = startNode.text.substring(0, startOffset);
-          const endText = startNode.text.substring(startOffset);
-          const startTextNode = startNode.cloneWithText(startText);
-          const endTextNode = startNode.cloneWithText(endText);
-          const insertNodes = [startTextNode, nodeToBeInserted];
-          if (endText) {
-            insertNodes.push(endTextNode);
-          }
-          parent.apply(new codeBlock.InsertChildrenBeforeAction(startNode, ...insertNodes));
-          parent.apply(new codeBlock.RemoveChildrenAction(startNode));
-        }
-      }
-      else {
-        if (startOffset !== 0) {
-          parent.apply(new codeBlock.InsertChildrenAfterAction(startNode, nodeToBeInserted));
-        }
-        else {
-          parent.apply(new codeBlock.InsertChildrenBeforeAction(startNode, nodeToBeInserted));
-        }
-      }
-      this.updateCursorPosition(nodeToBeInserted);
+  handle(element) {
+    const textStyle = this.getTextStyle(element);
+    return textStyle ? { textStyle: textStyle } : {};
+  }
+  /**
+   * Get the node type of element. The element type is determined in the following
+   * order: "data-type" attribute, node name, font size and class name.
+   *
+   * @param {HTMLElement} element - element.
+   * @returns {Nullable<VegaRTETextStyleType>} - node type.
+   */
+  getTextStyle(element) {
+    const byDataType = this.getElementTypeByDataType(element);
+    if (byDataType)
+      return byDataType;
+    const byNodeName = this.getElementTypeByNodeName(element);
+    if (byNodeName)
+      return byNodeName;
+    const byFontSize = this.getElementTypeByFontSize(element);
+    if (byFontSize)
+      return byFontSize;
+    const byClassName = this.getElementTypeByClassName(element);
+    if (byClassName)
+      return byClassName;
+    return null;
+  }
+  /**
+   * Get the element type by data-type attribute.
+   *
+   * @param {HTMLElement} element - element.
+   * @returns {Nullable<VegaRTETextStyleType>} - element type or null if not found.
+   */
+  getElementTypeByDataType(element) {
+    if (element.nodeType !== Node.TEXT_NODE && element.hasAttribute('data-type')) {
+      return element.getAttribute('data-type');
     }
+    return null;
   }
   /**
-   * Update the cursor position to end of the inserted node.
+   * Get the element type by font size.
    *
-   * @param {RTENode} node - node to find root content
+   * @param {HTMLElement} element - element.
+   * @returns {Nullable<VegaRTETextStyleType>} - element type or null if not found.
    */
-  updateCursorPosition(node) {
-    const root = this.getRootContent(node.parent);
-    if (root) {
-      root.apply(new UpdateCursorPositionAction(node));
+  getElementTypeByFontSize(element) {
+    var _a;
+    switch ((_a = element.style) === null || _a === void 0 ? void 0 : _a.fontSize) {
+      case '36px':
+        return 'title';
+      case '28px':
+        return 'subtitle';
+      case '22px':
+        return 'heading-1';
+      case '20px':
+        return 'heading-2';
+      case '18px':
+        return 'heading-3';
+      default:
+        return null;
     }
   }
-}
-
-/**
- * Strategy for inserting text into a decorator node. The decorator can not edit, so we insert the text as a new child.
- */
-class InsertTextToDecoratorNodeStrategy extends codeBlock.ActionHandleStrategy {
   /**
-   * @inheritDoc
+   * Get the element type by node name.
+   *
+   * @param {HTMLElement} element - element.
+   * @returns {Nullable<VegaRTETextStyleType>} - element type or null if not found.
    */
-  handleAction(action, target) {
-    const { text, offset, decoratorNode } = action;
-    const paragraph = this.createNewParagraph(text);
-    if (paragraph) {
-      const newTextNode = paragraph.children[0];
-      if (offset !== 0) {
-        target.apply(new codeBlock.InsertChildrenAfterAction(decoratorNode, newTextNode));
-      }
-      else {
-        target.apply(new codeBlock.InsertChildrenBeforeAction(decoratorNode, newTextNode));
-      }
-      this.setTheCursorPosition(newTextNode);
+  getElementTypeByNodeName(element) {
+    switch (element.nodeName) {
+      case 'H1':
+        return 'heading-1';
+      case 'H2':
+        return 'heading-2';
+      case 'H3':
+        return 'heading-3';
+      case 'H4':
+        return 'heading-4';
+      case 'H5':
+        return 'heading-5';
+      case 'H6':
+        return 'heading-6';
+      default:
+        return null;
     }
   }
   /**
-   * Set the cursor position to the new text node.
+   * Get the element type by class name.
    *
-   * @param {RTENode} focusNode - The new text node to focus on.
+   * @param {HTMLElement} element - element.
+   * @returns {Nullable<VegaRTETextStyleType>} - element type or null if not found.
    */
-  setTheCursorPosition(focusNode) {
-    const rootContent = this.getRootContent(focusNode.parent);
-    if (rootContent) {
-      rootContent.apply(new UpdateCursorPositionAction(focusNode));
+  getElementTypeByClassName(element) {
+    if (element.className) {
+      const match = /\bv-rte--text-style-(title|subtitle|heading-1|heading-2|heading-3|paragraph)\b/.exec(element.className);
+      if (match) {
+        return match[1];
+      }
     }
+    return null;
   }
 }
 
-/**
- * Insert new paragraph into current list item block at special position.
- */
-class ListItemInsertNewParagraphStrategy extends codeBlock.ActionHandleStrategy {
+/** Handle image size annotation */
+class ImageSizeAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
    * @inheritDoc
    */
-  handleAction(action, target) {
-    action.newBlock = this.breakSingleListItemBlock(action.startContainerNode, action.startOffset, target);
+  canHandle(targetDto) {
+    return targetDto.name === 'RTEImageNode';
+  }
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTEImageAnnotations} - Annotation.
+   */
+  handle(element) {
+    const size = this.getImageSize(element);
+    return size ? { size: size } : {};
   }
   /**
-   * Breaks a single list item block at a specific position.
+   * Determine the image display size based on the width of the current element.
    *
-   * @param {RTETextNode} splitNode - The node that needs to be split within a list item block.
-   * @param {number} startOffsetOfNode - The index within the `splitNode` where the break operation should occur.
-   * @param {RTEListItemBlock} target - The list item block.
-   * @returns {Nullable<RTEBlock>} Returns either a new `RTEListItemBlock` if the caret
-   * position is at the end of the `splitNode`, or it returns the result of splitting the block at the
-   * caret position if it is neither at the start nor at the end.
+   * @param {HTMLElement} element - current element.
+   * @returns {Nullable<VegaRichTextImageEditorSizeType>} -Image size, default 'md'.
    */
-  breakSingleListItemBlock(splitNode, startOffsetOfNode, target) {
-    const newListItem = target.createNewListItem();
-    const newBreakNode = this.copyInlineStyleToNewNode(splitNode);
-    newListItem.apply(new codeBlock.AppendChildrenAction([newBreakNode]));
-    if (this.isCaretPositionAtBlockEnd(target, splitNode, startOffsetOfNode)) {
-      return this.breakListItemAtEnd(newListItem, target);
-    }
-    else if (this.isCaretPositionAtBlockStart(target, splitNode, startOffsetOfNode)) {
-      target.parent.apply(new codeBlock.InsertChildrenBeforeAction(target, newListItem));
-    }
-    else {
-      const splitBlockAction = new codeBlock.SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      target.apply(splitBlockAction);
-      return splitBlockAction.newBlock;
+  getImageSize(element) {
+    if (element.getAttribute('data-size')) {
+      return element.getAttribute('data-size');
     }
-    return newListItem;
+    return null;
   }
+}
+
+/** Handle image alt annotation */
+class ImageAltAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
-   * Breaks a list item at the end and handles the insertion of a new list item or paragraph accordingly.
-   *
-   * @param {RTEListItemBlock} newListItem - Item that represents a new list item to be added to the existing list.
-   * @param {RTEListItemBlock} target - The list item block.
-   * @returns {RTEBlock} Returns a `RTEBlock`.
+   * @inheritDoc
    */
-  breakListItemAtEnd(newListItem, target) {
-    const lastItem = target.parent.children[target.parent.children.length - 1];
-    const currentItemIsEmpty = target.children.length === 1 && target.children[0].isEmpty();
-    if (target === lastItem && currentItemIsEmpty) {
-      const parentParent = target.parent.parent;
-      if (parentParent['type'] !== 'list-item') {
-        const newParagraph = codeBlock.RTETextBlock.from({
-          id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
-          type: 'paragraph',
-          nodes: [],
-        });
-        newParagraph.apply(new codeBlock.AppendChildrenAction(newListItem.children));
-        parentParent.apply(new codeBlock.InsertChildrenAfterAction(target.parent, newParagraph));
-        target.parent.apply(new codeBlock.RemoveChildrenAction(target));
-        return newParagraph;
-      }
-      else {
-        parentParent.parent.apply(new codeBlock.InsertChildrenAfterAction(parentParent, newListItem));
-        target.parent.apply(new codeBlock.RemoveChildrenAction(target));
-      }
-    }
-    else {
-      target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newListItem));
-    }
-    return newListItem;
+  canHandle(targetDto) {
+    return targetDto.name === 'RTEImageNode';
   }
   /**
-   * Copy the inline style to new node
+   * Handle annotation.
    *
-   * @param {RTETextNode} needCopedNode - The node that needed to be copied to
-   * @returns {RTETextNode} Returns a `RTETextNode`.
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTEImageAnnotations} - Annotation.
    */
-  copyInlineStyleToNewNode(needCopedNode) {
-    const textNode = needCopedNode.cloneWithText('');
-    // The link annotation doesn't need to inherit
-    textNode.annotationMap.delete(codeBlock.NodeAnnotationTypeEnum.LINK);
-    return textNode;
+  handle(element) {
+    return element.hasAttribute('alt') ? { alt: element.getAttribute('alt') } : {};
   }
 }
 
 /**
- * Delete the nest list block action
- *
- * @example needRemovedNestList.parent.apply(new RemoveNestListAction(needRemovedNestList))
+ * Handle inline html annotation
  */
-class RemoveNestListAction extends codeBlock.ModifyContentAction {
-  constructor(childList) {
-    super();
-    this.type = codeBlock.ModifyContentActionType.DELETE_NEST_LIST;
-    this.nestListBlockToBeRemoved = childList;
+class InlineHtmlAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  constructor() {
+    super(...arguments);
+    this.customAttributeHandler = new CustomAttributeAnnotationHandler();
+    this.customStyleAnnotationHandler = new CustomStyleAnnotationHandler();
+    this.customClassAnnotationHandler = new CustomClassAnnotationHandler();
   }
-}
-
-/**
- * List remove list item strategy.
- */
-class ListRemoveListItemStrategy extends codeBlock.RemoveChildrenStrategy {
   /**
-   * Remove the list item, check the list item and remove self if the list item is empty.
+   * @inheritDoc
+   */
+  canHandle(targetDto, options) {
+    return targetDto.name === 'RTETextNode' && options.autoMatchFormat === false;
+  }
+  /**
+   * @inheritDoc
+   */
+  handle(element, parentAnnotations) {
+    const canHandle = InlineHtmlAnnotationHandler.canHandleTags.includes(element.nodeName);
+    if (canHandle) {
+      const inlineHtml = this.generateInlineHtmlAnnotation(element, Object.assign({}, parentAnnotations));
+      if (inlineHtml) {
+        return { inlineHtml: inlineHtml };
+      }
+    }
+    return {};
+  }
+  /**
+   * Generate inline html annotation.
    *
-   * @param {RemoveChildrenAction} action - The remove action instance.
-   * @param {RTEListBlock} target - The list block.
+   * @param {HTMLElement} child - Current element.
+   * @param {VegaRTETextAnnotations} annotations - Current annotations.
+   * @returns {Nullable<VegaInlineHtmlSchema>} - Inline html annotation.
    */
-  handleAction(action, target) {
-    super.handleAction(action, target);
-    const parent = target.parent;
-    if (target.children.length === 0 && parent) {
-      // The parent is a list item mean the current block is a nest list, so we need to use RemoveNestListAction to remove the item
-      if (parent['type'] === 'list-item') {
-        parent.apply(new RemoveNestListAction(target));
+  generateInlineHtmlAnnotation(child, annotations) {
+    let { inlineHtml } = annotations;
+    if (!codeBlock.RTETextNode.supportsHtmlTag(child.nodeName.toLowerCase()) ||
+      (child.childNodes.length === 1 && child.childNodes[0].nodeType !== Node.TEXT_NODE)) {
+      const childInlineHtmlNode = {
+        htmlTag: child.nodeName.toLowerCase(),
+        customAttribute: this.customAttributeHandler.handle(child).customAttribute,
+        customStyle: this.customStyleAnnotationHandler.handle(child).customStyle,
+        customClass: this.customClassAnnotationHandler.handle(child).customClass,
+      };
+      if (!inlineHtml) {
+        inlineHtml = childInlineHtmlNode;
       }
       else {
-        parent.apply(new codeBlock.RemoveChildrenAction(target));
+        let lastChild = inlineHtml;
+        while (lastChild.child &&
+          child.parentNode &&
+          lastChild.child.htmlTag === child.parentNode.nodeName.toLowerCase()) {
+          lastChild = lastChild.child;
+        }
+        lastChild.child = childInlineHtmlNode;
       }
     }
+    return inlineHtml ? Object.assign({}, inlineHtml) : null;
   }
 }
+InlineHtmlAnnotationHandler.canHandleTags = [
+  'A',
+  'ABBR',
+  'AUDIO',
+  'B',
+  'BDI',
+  'BDO',
+  'CITE',
+  'CODE',
+  'DEL',
+  'DFN',
+  'EMBED',
+  'EM',
+  'I',
+  'INS',
+  'KBD',
+  'MARK',
+  'METER',
+  'OUTPUT',
+  'PROGRESS',
+  'Q',
+  'S',
+  'SMALL',
+  'SPAN',
+  'STRONG',
+  'SUB',
+  'SUP',
+  'TIME',
+  'U',
+  'VAR',
+  'VIDEO',
+];
 
-/**
- * Manager class for registering DTO action strategies.
- */
-class RTEDTOActionStrategyManager {
+/** Html element to annotations generator */
+class HtmlElementToAnnotationGenerator {
+  constructor() {
+    this.handlers = [
+      new TextAlignAnnotationHandler(),
+      new IndentAnnotationHandler(),
+      new BoldAnnotationHandler(),
+      new ItalicAnnotationHandler(),
+      new UnderlineAnnotationHandler(),
+      new StrikeThroughAnnotationHandler(),
+      new ColorAnnotationHandler(),
+      new LinkAnnotationHandler(),
+      new CodeAnnotationHandler(),
+      new ImageSizeAnnotationHandler(),
+      new ImageAltAnnotationHandler(),
+      new CustomAttributeAnnotationHandler(),
+      new CustomClassAnnotationHandler(),
+      new CustomStyleAnnotationHandler(),
+      new LinkAnnotationHandler(),
+      new TextStyleAnnotationHandler(),
+      new InlineHtmlAnnotationHandler(),
+    ];
+  }
   /**
-   * Registers basic strategies for a given DTO class.
+   * The function generates annotations for a given target DTO and HTML element based on a set of
+   * strategies.
    *
-   * @param {string} dtoClassName - The name of the RTE block class name.
+   * @typedef T class name of target DTO
+   * @typedef V generated annotations type
+   * @param {T} targetDto - Which DTO is the generated annotations to set.
+   * @param {HTMLElement} element - Current html element.
+   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options
+   * @returns {V} Generated annotations.
    */
-  registerBlockBasicStrategies(dtoClassName) {
-    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.DELETE_CHILDREN, dtoClassName, dtoClassName === RTEListBlock.name
-      ? new ListRemoveListItemStrategy()
-      : new codeBlock.RemoveChildrenStrategy());
-    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.APPEND_CHILDREN, dtoClassName, new AppendChildrenStrategy());
-    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_CHILDREN_BEFORE, dtoClassName, new InsertChildrenBeforeStrategy());
-    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_CHILDREN_AFTER, dtoClassName, new InsertChildrenAfterStrategy());
-    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.DELETE_BLOCK_CONTENT, dtoClassName, new BlockDeleteTextOrDecoratorNodeStrategy());
-    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_NEW_PARAGRAPH, dtoClassName, dtoClassName === RTEListItemBlock.name
-      ? new ListItemInsertNewParagraphStrategy()
-      : new BlockInsertNewParagraphStrategy());
-    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_TEXT_TO_DECORATOR_NODE, dtoClassName, new InsertTextToDecoratorNodeStrategy());
-    codeBlock.ActionHandleStrategyRegistry.register(codeBlock.ModifyContentActionType.INSERT_NODE_TO_NEAREST_ROOT, dtoClassName, new InsertNodeToNearestRootStrategy());
+  generate(targetDto, element, options = { autoMatchFormat: true }) {
+    const isLinkElement = element.tagName === 'A';
+    return this.handlers
+      .filter((handler) => !options.autoMatchFormat && isLinkElement ? handler instanceof LinkAnnotationHandler : true)
+      .filter((handler) => element.nodeType !== Node.TEXT_NODE &&
+      handler.canHandle(targetDto, {
+        skipCustomAnnotations: options.skipCustomAnnotations || isLinkElement,
+        autoMatchFormat: options.autoMatchFormat,
+      }))
+      .reduce((annotations, handler) => {
+      const result = handler.handle(element, options.parentAnnotations);
+      return Object.assign(Object.assign({}, annotations), result);
+    }, {});
   }
 }
-const RTEDTOActionStrategyManager$1 = new RTEDTOActionStrategyManager();
+const htmlElementToAnnotationGenerator = new HtmlElementToAnnotationGenerator();
 
 /** Abstract class for block html element to RTE block dto */
 class BlockToRTEBlockStrategyAbstract extends ElementToDTOStrategy {
@@ -3745,6 +3760,13 @@ class VegaRTEContent {
    */
   apply(action) {
     codeBlock.ActionHandleStrategyRegistry.executeTheStrategy(action, this);
+    // Check if the action has been executed and is flushable
+    if (action['executedFlag'] && action.isFlushable) {
+      const host = codeBlock.stateEntityRenderingRegistry.getDOMByEntity(this);
+      if (host) {
+        changeManager.ChangeManager.notify(domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubject(host, vegaInternalEventId.VegaInternalRichTextEditorFlushChanges), {});
+      }
+    }
   }
   /**
    * Get the last node in the content.
@@ -3887,6 +3909,7 @@ class RTEDTORendererManager {
 }
 const RTEDTORendererManager$1 = new RTEDTORendererManager();
 
+exports.BlockToRTEBlockStrategyAbstract = BlockToRTEBlockStrategyAbstract;
 exports.ElementToDTOClassStrategyManager = ElementToDTOClassStrategyManager;
 exports.ElementToDTOStrategy = ElementToDTOStrategy;
 exports.ElementToDtoStrategyProcessor = ElementToDtoStrategyProcessor$1;
@@ -3902,3 +3925,4 @@ exports.RTEListItemBlock = RTEListItemBlock;
 exports.StylePreservator = StylePreservator;
 exports.UpdateCursorPositionAction = UpdateCursorPositionAction;
 exports.VegaRTEContent = VegaRTEContent;
+exports.htmlElementToAnnotationGenerator = htmlElementToAnnotationGenerator;