@heartlandone/vega 2.67.0 → 2.68.0

package/dist/cjs/{code-block-ab97a0a0.js → code-block-39074880.js}

@@ -151,6 +151,7 @@ exports.ModifyContentActionType = void 0;
   ModifyContentActionType["UPDATE_CURSOR_POSITION"] = "UPDATE_CURSOR_POSITION";
   ModifyContentActionType["INSERT_TEXT_TO_DECORATOR_NODE"] = "INSERT_TEXT_TO_DECORATOR_NODE";
   ModifyContentActionType["INSERT_NODE_TO_NEAREST_ROOT"] = "INSERT_NODE_TO_NEAREST_ROOT";
+  ModifyContentActionType["PASTE_CONTENT"] = "PASTE_CONTENT";
 })(exports.ModifyContentActionType || (exports.ModifyContentActionType = {}));
 /**
  * Abstract class for update node content, delete node, insert node
@@ -385,6 +386,67 @@ class IndentAnnotation extends BlockAnnotation {
   }
 }
 
+/**
+ * Registry for action handler interceptors, which can register and retrieve interceptors for specific actions and targets.
+ */
+class ActionHandlerInterceptorRegistry {
+  /**
+   * Bind a specific strategy to a special action type of the rich text node.
+   *
+   * @param {string} actionType - The special action type or the action class name.
+   * @param {string} targetClass - The rich text node class name.
+   * @param {ActionHandlerInterceptor} strategy - The action handle strategy instance.
+   */
+  static register(actionType, targetClass, strategy) {
+    if (!this.registry.has(targetClass)) {
+      this.registry.set(targetClass, new Map());
+    }
+    /* eslint-disable @typescript-eslint/no-non-null-assertion */
+    if (!this.registry.get(targetClass).has(actionType)) {
+      this.registry.get(targetClass).set(actionType, new Set());
+    }
+    this.registry.get(targetClass).get(actionType).add(strategy);
+    /* eslint-enable @typescript-eslint/no-non-null-assertion */
+  }
+  /**
+   * Unregister the strategy for the specific action type and target class.
+   *
+   * @param {string} actionType - The special action type or the action class name.
+   * @param {string} targetClass - The rich text node class name.
+   * @param {ActionHandlerInterceptor} strategy - The action handler interceptor instance.
+   */
+  static unregister(actionType, targetClass, strategy) {
+    const strategyMap = this.registry.get(targetClass);
+    if (strategyMap) {
+      const strategySet = strategyMap.get(actionType);
+      if (strategySet) {
+        strategySet.delete(strategy);
+      }
+    }
+  }
+  /**
+   * Get the special interceptor strategy that before handle the action logic.
+   *
+   * @typedef T generic type
+   * @typedef target generic type
+   * @param {RTEActionType} action - The special action .
+   * @param {string} targetClass - The rich text node class name.
+   * @returns {Nullable<ActionHandlerInterceptor<T, target>>} - The action handler interceptor instance or null if not found.
+   */
+  static get(action, targetClass) {
+    const targetClassName = targetClass.constructor.name;
+    const actionType = action instanceof ModifyContentAction ? action.type : action.constructor.name;
+    const strategyMap = this.registry.get(targetClassName);
+    if (strategyMap) {
+      const set = strategyMap.get(actionType);
+      if (set && set.size > 0) {
+        return Array.from(set).find((interceptor) => interceptor.canIntercept(action, targetClass));
+      }
+    }
+  }
+}
+ActionHandlerInterceptorRegistry.registry = new Map();
+
 /**
  * The strategies registry, contains static methods `register`, `get` and `getStrategyAndExecute`.
  */
@@ -403,6 +465,18 @@ class ActionHandleStrategyRegistry {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     this.registry.get(targetClass).set(actionType, strategy);
   }
+  /**
+   * Unregister the strategy for the specific action type and target class.
+   *
+   * @param {string} actionType - The special action type or the action class name.
+   * @param {string} targetClass - The rich text node class name.
+   */
+  static unregister(actionType, targetClass) {
+    const strategyMap = this.registry.get(targetClass);
+    if (strategyMap) {
+      strategyMap.delete(actionType);
+    }
+  }
   /**
    * Get the special strategy that handle the action logic.
    *
@@ -428,20 +502,31 @@ class ActionHandleStrategyRegistry {
    * @returns {R | undefined} The return value of the strategy method execute invoke result.
    */
   static executeTheStrategy(action, RTEInstance) {
-    const actionType = action instanceof ModifyContentAction ? action.type : action.constructor.name;
-    const strategy = ActionHandleStrategyRegistry.get(actionType, RTEInstance.constructor.name);
-    if (strategy) {
-      return strategy.execute(action, RTEInstance);
+    const interceptor = ActionHandlerInterceptorRegistry.get(action, RTEInstance);
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    const executeStrategy = () => {
+      const actionType = action instanceof ModifyContentAction ? action.type : action.constructor.name;
+      const strategy = ActionHandleStrategyRegistry.get(actionType, RTEInstance.constructor.name);
+      if (strategy) {
+        action['executedFlag'] = true;
+        return strategy.execute(action, RTEInstance);
+      }
+      else {
+        globalSlimmerRegistry.LogUtility.warn(`Type ${actionType} action handle strategy is not registered in class ${RTEInstance.constructor.name}`);
+      }
+    };
+    if (interceptor) {
+      return interceptor.intercept(executeStrategy, action, RTEInstance);
     }
     else {
-      globalSlimmerRegistry.LogUtility.error(`Type ${actionType} action handle strategy is not registered in class ${RTEInstance.constructor.name}`);
+      return executeStrategy();
     }
   }
   /**
    * Check if the action type can be handled by strategy for the specific RTE instance.
    *
    * @param {string} actionType - The special action type or the action class name.
-   * @param {RTENode | RTEBlock} RTEInstance - The rich text editor node.
+   * @param {RTENode | RTEBlock | VegaRTEContent} RTEInstance - The rich text editor node.
    * @returns {boolean} - Whether the action type can be handled by the strategy.
    */
   static canHandle(actionType, RTEInstance) {
@@ -704,128 +789,184 @@ class InternalWrapperAnnotation extends BlockAnnotation {
   }
 }
 
+exports.NodeAnnotationTypeEnum = void 0;
+(function (NodeAnnotationTypeEnum) {
+  NodeAnnotationTypeEnum["BOLD"] = "BOLD";
+  NodeAnnotationTypeEnum["ITALIC"] = "ITALIC";
+  NodeAnnotationTypeEnum["UNDERLINE"] = "UNDERLINE";
+  NodeAnnotationTypeEnum["STRIKETHROUGH"] = "STRIKETHROUGH";
+  NodeAnnotationTypeEnum["SELECTION_RANGE"] = "SELECTION_RANGE";
+  NodeAnnotationTypeEnum["IMAGE"] = "IMAGE";
+  NodeAnnotationTypeEnum["CODE"] = "CODE";
+  NodeAnnotationTypeEnum["TEXT_COLOR"] = "TEXT_COLOR";
+  NodeAnnotationTypeEnum["LINK"] = "LINK";
+  NodeAnnotationTypeEnum["INLINE_HTML"] = "INLINE_HTML";
+  NodeAnnotationTypeEnum["PLAIN_TEXT"] = "PLAIN_TEXT";
+})(exports.NodeAnnotationTypeEnum || (exports.NodeAnnotationTypeEnum = {}));
 /**
- * Abstract class for block
+ * Abstract class for all annotations
  */
-class RTEBlock {
-  constructor(id) {
-    this.annotationMap = new Map();
-    this.id = id;
+class NodeAnnotation extends Annotation {
+}
+
+/**
+ * Class to handle the style representation of annotations for RTE blocks and nodes.
+ */
+class RTEAnnotationStyle {
+  constructor(dto) {
+    this.dtoType = dto instanceof RTEBlock ? 'block' : 'node';
+    this.annotationMap = dto.annotationMap;
   }
   /**
-   * Creates a new instance of the block from the given JSON object.
+   * Convert an AnnotationStyle object to a CSS text string.
    *
-   * @param {unknown} json - The JSON object to create the block from.
-   * @param {VegaRTETransformOptions} options - Options for transforming the block.
+   * @param {RTERenderContext} options - Rendering context options.
+   * @param {string[]} canMergeKeyList - List of style keys that can be merged by concatenation.
+   * @param {Nullable<AnnotationStyle>} annotationStyle - The annotation style object, if null, get from toJSON().
+   * @returns {string} A string representing the CSS text.
    */
-  static from(json, options) {
-    throw new Error(`[Vega] ${this.constructor.name}.from(${JSON.stringify(json)}, ${options}) is not implemented. Please implement this method in the subclass.`);
+  toCssText(options = { standalone: false }, canMergeKeyList, annotationStyle) {
+    annotationStyle = annotationStyle ? annotationStyle : this.toJSON(options, canMergeKeyList);
+    return Object.entries(Object.assign({}, annotationStyle))
+      .map(([key, value]) => `${string.camelToDashCase(key)}: ${value};`)
+      .join('');
   }
   /**
-   * The function `createAnnotationEntity` creates a block annotation entity based on the provided type
-   * and value.
+   * Convert the annotation map to a JSON representation.
    *
-   * @param {keyof VegaRTEBlockAnnotations} type - The `type` parameter is a key of the `VegaRTEBlockAnnotations` enum, which specifies
-   * the type of annotation entity to create.
-   * @param {unknown} value - The `value` parameter in the `createAnnotationEntity` function is the value
-   * that will be used to create the annotation entity. It can be of any type depending on the specific
-   * annotation being created.
-   * @returns {Nullable<BlockAnnotationsEntity>} The `createAnnotationEntity` function returns a nullable tuple containing a
-   * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
+   * @param {RTERenderContext} options - Rendering context options.
+   * @param {string[]} canMergeKeyList - List of style keys that can be merged by concatenation.
+   * @returns {AnnotationStyle} - The JSON representation of the annotation styles.
    */
-  static createAnnotationEntity(type, value) {
-    switch (type) {
-      case 'textAlign':
-        return HorizontalAlignmentAnnotation.from(value);
-      case 'indent':
-        return IndentAnnotation.from(value);
-      case 'customAttribute':
-        return CustomAttributeAnnotation.from(value);
-      case 'customClass':
-        return CustomClassAnnotation.from(value);
-      case 'customStyle':
-        return CustomStyleAnnotation.from(value);
-      case 'internalWrapper':
-        return InternalWrapperAnnotation.from(value);
+  toJSON(options = { standalone: false }, canMergeKeyList) {
+    const styles = Array.from(this.annotationMap.values())
+      .filter((annotation) => this.filterAnnotation(annotation) || annotation instanceof CustomStyleAnnotation)
+      .map((annotation) => annotation.renderStyle(options))
+      .filter(typeGuard.isNonNullable);
+    if (canMergeKeyList && canMergeKeyList.length > 0) {
+      return this.mergeAnnotationStyles(styles, canMergeKeyList);
+    }
+    else {
+      return styles.reduce((current, obj) => (Object.assign(Object.assign({}, current), obj)), {});
     }
   }
   /**
-   * Converts annotations to an array of block annotation entities.
+   * Filter annotations based on whether they are block or node annotations.
    *
-   * @param {BlockAnnotations} annotationMap - The map to store the converted annotations.
-   * @param {VegaRTEBlockAnnotations} annotations - The annotations to convert.
+   * @param {RTENodeAnnotationMapValue | RTEBlockAnnotationMapValue} annotation - The annotation to filter.
+   * @returns {boolean} - True if the annotation matches the DTO type, false otherwise.
    */
-  static convertAnnotationsToMap(annotationMap, annotations) {
-    Object.entries(annotations).forEach(([type, value]) => {
-      const item = this.createAnnotationEntity(type, value);
-      if (typeGuard.isNonNullable(item)) {
-        annotationMap.set(...item);
-      }
-    });
+  filterAnnotation(annotation) {
+    return this.dtoType === 'block'
+      ? annotation instanceof BlockAnnotation
+      : annotation instanceof NodeAnnotation;
   }
   /**
-   * Check if the block should be rendered as a wrapper.
+   * Merge an array of annotation styles into a single style object.
+   * e.g.,
+   * { textDecoration: 'underline', textDecoration: 'line-through' }
+   * -> { textDecoration: 'underline line-through' }
    *
-   * @returns {boolean} - Returns true if the block is an internal wrapper.
+   * @param {AnnotationStyle[]} styles - Array of annotation style objects to merge.
+   * @param {string[]} canMergeKeyList - List of style keys that can be merged by concatenation.
+   * @returns {AnnotationStyle} - The merged annotation style object.
    */
-  shouldRenderAsInternalWrapper() {
-    const internalWrapperAnnotation = this.getAnnotationByType(exports.BlockAnnotationTypeEnum.INTERNAL_WRAPPER);
-    if (internalWrapperAnnotation) {
-      return (internalWrapperAnnotation.internalWrapper &&
-        Array.from(this.annotationMap.values()).filter((annotation) => !(annotation instanceof LinkGroupAnnotation) &&
-          !(annotation instanceof InternalWrapperAnnotation)).length === 0);
+  mergeAnnotationStyles(styles, canMergeKeyList) {
+    const merged = {};
+    for (const style of styles) {
+      for (const key in style) {
+        const value = style[key];
+        const existing = merged[key];
+        if (typeof existing === 'string' &&
+          typeof value === 'string' &&
+          canMergeKeyList.includes(key)) {
+          merged[key] = Array.from(new Set(`${existing} ${value}`.split(/\s+/).filter(Boolean))).join(' ');
+        }
+        else {
+          merged[key] = value;
+        }
+      }
     }
-    else {
-      return false;
+    return merged;
+  }
+}
+
+exports.NodeTypeEnum = void 0;
+(function (NodeTypeEnum) {
+  NodeTypeEnum["TEXT"] = "TEXT";
+  NodeTypeEnum["IMAGE"] = "IMAGE";
+  NodeTypeEnum["CODE_BLOCK_NODE"] = "CODE_BLOCK_NODE";
+})(exports.NodeTypeEnum || (exports.NodeTypeEnum = {}));
+/**
+ * Abstract class for all nodes
+ */
+class RTENode {
+  constructor(id, annotationMap) {
+    this.annotationMap = new Map();
+    this.id = id;
+    if (annotationMap) {
+      this.annotationMap = annotationMap;
     }
   }
   /**
-   * Class to JSON object
+   * Creates a new instance of the RTENode from the given JSON data.
    *
-   * @returns {VegaRTEBlockBase} - JSON object
+   * @param {unknown} json - The JSON data to create the node from.
+   * @param {RTEBlock} parentBlock - The parent block of the node.
+   * @param {VegaRTETransformOptions} options - Options for transforming the node.
    */
-  toJSON() {
-    const annotations = Array.from(this.annotationMap.values())
-      .filter((annotation) => annotation instanceof BlockAnnotation || annotation instanceof CommonAnnotation)
-      .reduce((record, annotation) => {
-      return Object.assign(Object.assign({}, record), annotation.toJSON());
-    }, {});
-    return Object.assign({ id: this.id }, (Object.keys(annotations).length > 0 ? { annotations } : {}));
+  static from(json, parentBlock, options) {
+    throw new Error(`[Vega] ${this.constructor.name}.from(${JSON.stringify(json)}, ${parentBlock}, ${options}) is not implemented. Please implement this method in the subclass.`);
+  }
+  /**
+   * Creates different types of text annotations based on the provided type and value.
+   *
+   * @param {keyof VegaRTETextAnnotations} type - The key of the type.
+   * @param {unknown} value - The value that will be used to create the specific type of annotation entity based on the `type` provided.
+   * @returns {Nullable<[RTENodeAnnotationMapKey, RTENodeAnnotationMapValue]>} Returning a nullable tuple containing a key and a
+   * value from the `RTENodeAnnotationMapKey` and `RTENodeAnnotationMapValue` types.
+   */
+  static createAnnotationEntity(type, value) {
+    switch (type) {
+      case 'customAttribute':
+        return CustomAttributeAnnotation.from(value);
+      case 'customClass':
+        return CustomClassAnnotation.from(value);
+      case 'customStyle':
+        return CustomStyleAnnotation.from(value);
+    }
   }
   /**
    * Get annotation by type
    *
    * @typedef T generic type
-   * @param {keyof typeof BlockAnnotationTypeEnum} type - Annotation type
+   * @param {RTENodeAnnotationMapKey} type - Annotation type
    * @returns {Nullable<T>} - Annotation
    */
   getAnnotationByType(type) {
     return this.annotationMap.get(type);
   }
   /**
-   * Apply action to block
+   * Delete annotation by type
+   *
+   * @param {RTENodeAnnotationMapKey} type - Annotation type
+   */
+  deleteAnnotationByType(type) {
+    this.annotationMap.delete(type);
+    this.flushChange();
+  }
+  /**
+   * Apply action to node
    *
    * @param {AnnotationAction} action - Annotation action
+   * @returns {this} - Node
    */
   apply(action) {
     this.doApply(action);
     if (action.isFlushable) {
-      const domNode = stateEntityRenderingRegistry.getDOMByEntity(this);
-      if (domNode) {
-        const nodeSubject = domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubjectFromParentNodeByEventId(domNode, vegaInternalEventId.VegaInternalRichTextEditorFlushChanges);
-        if (nodeSubject) {
-          changeManager.ChangeManager.notify(nodeSubject, {});
-        }
-      }
+      this.flushChange();
     }
-  }
-  /**
-   * Check if the block is a list item block
-   *
-   * @returns {boolean} True if the block is a list item block, false otherwise.
-   */
-  isListItemBlock() {
-    return this.type === 'list-item';
+    return this;
   }
   /**
    * Get styles from annotations
@@ -834,21 +975,18 @@ class RTEBlock {
    * @returns {AnnotationStyle} - Annotation styles
    */
   getStyles(options = { standalone: false }) {
-    return Object.assign(Object.assign({}, Array.from(this.annotationMap.values())
-      .filter((annotation) => annotation instanceof BlockAnnotation || annotation instanceof CustomStyleAnnotation)
-      .map((annotation) => annotation.renderStyle(options))
-      .filter(typeGuard.isNonNullable)
-      .reduce((current, obj) => (Object.assign(Object.assign({}, current), obj)), {})), (this.shouldRenderAsInternalWrapper() ? { display: 'contents' } : {}));
+    const rteAnnotationStyle = new RTEAnnotationStyle(this);
+    return rteAnnotationStyle.toJSON(options, ['textDecoration']);
   }
   /**
    * Get classes from annotations
    *
-   * @param {RTERenderContext} [options={ standalone: false }] - Options to control standalone mode
+   * @param {RTERenderContext} [options={ standalone: false }] - Options to control style mode
    * @returns {string} - Annotation style
    */
   getClasses(options = { standalone: false }) {
     return Array.from(this.annotationMap.values())
-      .filter((annotation) => annotation instanceof BlockAnnotation || annotation instanceof CustomClassAnnotation)
+      .filter((annotation) => annotation instanceof NodeAnnotation || annotation instanceof CustomClassAnnotation)
       .map((annotation) => annotation.renderClass(options))
       .filter(typeGuard.isNonNullable)
       .reduce((pre, cur) => [pre, cur].join(' ').trim(), '');
@@ -856,11 +994,27 @@ class RTEBlock {
   /**
    * Get custom attribute annotation, excluding "class" and "style"
    *
-   * @returns {Nullable<CustomAttributeAnnotation>} - custom attribute annotation
+   * @returns {CustomAttributeAnnotation} - custom attribute annotation
    */
   getCustomAttributesAnnotation() {
     return this.annotationMap.get(exports.CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE);
   }
+  /**
+   * Check if the node is a text node.
+   *
+   * @returns {boolean} - True if the node is a text node, false otherwise.
+   */
+  isTextNode() {
+    return false;
+  }
+  /**
+   * Get the HTMLElement reference associated with this node.
+   *
+   * @returns {Nullable<HTMLElement>} The HTMLElement reference or null if not found.
+   */
+  getElementRef() {
+    return stateEntityRenderingRegistry.getDOMByEntity(this);
+  }
   /**
    * Generate attributes as string
    *
@@ -869,9 +1023,10 @@ class RTEBlock {
    */
   generateAttributeString(...attrs) {
     var _a;
-    const styles = Object.entries(Object.assign({}, this.getStyles({ standalone: true })))
-      .map(([key, value]) => `${string.camelToDashCase(key)}: ${value};`)
-      .join('');
+    const nodeAnnotationStyle = new RTEAnnotationStyle(this);
+    const styles = nodeAnnotationStyle.toCssText({ standalone: true }, [
+      'textDecoration',
+    ]);
     const customClassAnnotation = this.annotationMap.get(exports.CommonAnnotationTypeEnum.CUSTOM_CLASS);
     const customAttributeString = ((_a = this.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.toString(attrs)) || [];
     const attributes = [
@@ -883,136 +1038,248 @@ class RTEBlock {
     return attributes.length ? ` ${attributes.join(' ')}` : '';
   }
   /**
-   * Apply action to block
+   * apply annotation action or modify content action
    *
-   * @param {AnnotationAction|ModifyContentAction} action - Annotation action
+   * @param {AnnotationAction | ModifyContentAction} action annotation type action or modify content type action
    */
   doApply(action) {
     if (action instanceof ModifyContentAction) {
-      ActionHandleStrategyRegistry.executeTheStrategy(action, this);
+      this.doModifyActionApply(action);
     }
     else {
-      this.applyAnnotationAction(action);
+      this.doAnnotationActionApply(action);
     }
   }
   /**
-   * Apply annotation action to block
-   *
-   * @param {AnnotationAction} action - Annotation action
+   * Flush the value change
    */
-  applyAnnotationAction(action) {
-    const annotation = action.toAnnotation();
-    if (!(annotation instanceof LinkGroupAnnotation)) {
-      this.annotationMap.set(annotation.type, annotation);
+  flushChange() {
+    const domNode = stateEntityRenderingRegistry.getDOMByEntity(this);
+    if (domNode) {
+      const nodeSubject = domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubjectFromParentNodeByEventId(domNode, vegaInternalEventId.VegaInternalRichTextEditorFlushChanges);
+      if (nodeSubject) {
+        changeManager.ChangeManager.notify(nodeSubject, {});
+      }
     }
-    typeof this.doAnnotationActionApply === 'function' && this.doAnnotationActionApply(action);
   }
   /**
-   * clone annotations of the block
+   * Clones the annotations of the current RTETextNode.
    *
-   * @returns {BlockAnnotations} - Cloned annotations
+   * @returns {NodeAnnotations} A new Map containing cloned annotations.
    */
   cloneAnnotations() {
     return new Map(Array.from(this.annotationMap.entries()).map(([key, value]) => [key, value.clone()]));
   }
+  /* istanbul ignore next */
+  /**
+   * Placeholder for the method to be implemented in sub classes.
+   *
+   * @param {AnnotationAction} action Annotation action
+   */
+  doAnnotationActionApply(action) {
+  }
+  /* istanbul ignore next */
+  /**
+   * Placeholder for the method to be implemented in sub classes.
+   *
+   * @param {ModifyContentAction} action ModifyContentAction
+   */
+  doModifyActionApply(action) {
+  }
 }
 
-exports.NodeAnnotationTypeEnum = void 0;
-(function (NodeAnnotationTypeEnum) {
-  NodeAnnotationTypeEnum["BOLD"] = "BOLD";
-  NodeAnnotationTypeEnum["ITALIC"] = "ITALIC";
-  NodeAnnotationTypeEnum["UNDERLINE"] = "UNDERLINE";
-  NodeAnnotationTypeEnum["STRIKETHROUGH"] = "STRIKETHROUGH";
-  NodeAnnotationTypeEnum["SELECTION_RANGE"] = "SELECTION_RANGE";
-  NodeAnnotationTypeEnum["IMAGE"] = "IMAGE";
-  NodeAnnotationTypeEnum["CODE"] = "CODE";
-  NodeAnnotationTypeEnum["TEXT_COLOR"] = "TEXT_COLOR";
-  NodeAnnotationTypeEnum["LINK"] = "LINK";
-  NodeAnnotationTypeEnum["INLINE_HTML"] = "INLINE_HTML";
-  NodeAnnotationTypeEnum["PLAIN_TEXT"] = "PLAIN_TEXT";
-})(exports.NodeAnnotationTypeEnum || (exports.NodeAnnotationTypeEnum = {}));
 /**
- * Abstract class for all annotations
+ * RTEDTOClassManager is a singleton class that manages the registration and retrieval of RTE DTO classes.
+ * It allows for the dynamic handling of different RTE blocks and nodes by their types.
  */
-class NodeAnnotation extends Annotation {
+class RTEDTOClassManager {
+  constructor() {
+    // Register RTE Block DTO classes.
+    this.RTE_BLOCK_DTO_CLASS_MAP = new Map();
+    // Register RTE Block DTO classes.
+    this.RTE_NODE_DTO_CLASS_MAP = new Map();
+  }
+  /**
+   * Registers a new RTE DTO class.
+   *
+   * @typedef T - The type of the RTE DTO class to register.
+   * @param {string} type - The type identifier for the RTE DTO class.
+   * @param {ClassType<T>} RTEDTOClass - The class constructor for the RTE DTO.
+   */
+  registerRTEDTOClass(type, RTEDTOClass) {
+    if (RTEDTOClass.prototype instanceof RTEBlock) {
+      this.RTE_BLOCK_DTO_CLASS_MAP.set(type, RTEDTOClass);
+    }
+    else if (RTEDTOClass.prototype instanceof RTENode) {
+      this.RTE_NODE_DTO_CLASS_MAP.set(type, RTEDTOClass);
+    }
+    else {
+      throw new Error(`Invalid RTE DTO class type: ${type}`);
+    }
+  }
+  /**
+   * Retrieves the RTE block class for a given type.
+   *
+   * @param {string} type - The type identifier for the RTE block.
+   * @returns {Nullable<RTEBlockDTOClass>} - The class constructor for the RTE block, or null if not found.
+   */
+  getRTEBlockClass(type) {
+    return this.RTE_BLOCK_DTO_CLASS_MAP.get(type);
+  }
+  /**
+   * Retrieves the RTE node class for a given type.
+   *
+   * @param {string} type - The type identifier for the RTE node.
+   * @returns {Nullable<RTENodeDTOClass>} - The class constructor for the RTE node, or null if not found.
+   */
+  getRTENodeClass(type) {
+    return this.RTE_NODE_DTO_CLASS_MAP.get(type);
+  }
 }
+const RTEDTOClassManager$1 = new RTEDTOClassManager();
 
-exports.NodeTypeEnum = void 0;
-(function (NodeTypeEnum) {
-  NodeTypeEnum["TEXT"] = "TEXT";
-  NodeTypeEnum["IMAGE"] = "IMAGE";
-  NodeTypeEnum["CODE_BLOCK_NODE"] = "CODE_BLOCK_NODE";
-})(exports.NodeTypeEnum || (exports.NodeTypeEnum = {}));
 /**
- * Abstract class for all nodes
+ * Abstract class for block
  */
-class RTENode {
-  constructor(id, annotationMap) {
+class RTEBlock {
+  constructor(id) {
     this.annotationMap = new Map();
     this.id = id;
-    if (annotationMap) {
-      this.annotationMap = annotationMap;
+  }
+  /**
+   * Creates a new instance of the block from the given JSON object.
+   *
+   * @param {unknown} json - The JSON object to create the block from.
+   * @param {VegaRTETransformOptions} options - Options for transforming the block.
+   */
+  static from(json, options) {
+    throw new Error(`[Vega] ${this.constructor.name}.from(${JSON.stringify(json)}, ${options}) is not implemented. Please implement this method in the subclass.`);
+  }
+  /**
+   * Generates block children from an array of VegaRTEContentBlock.
+   *
+   * @param {VegaRTEContentBlock[]} blockArray - The array of VegaRTEContentBlock to generate children from.
+   * @param {VegaRTETransformOptions} [options] - Optional transformation options.
+   * @param {VegaRTEContent | RTEBlock} [parentBlock] - Optional parent block.
+   * @returns {RTEBlock[]} An array of generated RTEBlock children.
+   */
+  static generateBlockChildren(blockArray, options, parentBlock) {
+    return blockArray
+      .map((child) => {
+      const BlockClass = RTEDTOClassManager$1.getRTEBlockClass(child.type);
+      if (BlockClass) {
+        const block = BlockClass.from(child, options);
+        block.parent = parentBlock;
+        return block;
+      }
+    })
+      .filter(typeGuard.isNonNullable);
+  }
+  /**
+   * The function `createAnnotationEntity` creates a block annotation entity based on the provided type
+   * and value.
+   *
+   * @param {keyof VegaRTEBlockAnnotations} type - The `type` parameter is a key of the `VegaRTEBlockAnnotations` enum, which specifies
+   * the type of annotation entity to create.
+   * @param {unknown} value - The `value` parameter in the `createAnnotationEntity` function is the value
+   * that will be used to create the annotation entity. It can be of any type depending on the specific
+   * annotation being created.
+   * @returns {Nullable<BlockAnnotationsEntity>} The `createAnnotationEntity` function returns a nullable tuple containing a
+   * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
+   */
+  static createAnnotationEntity(type, value) {
+    switch (type) {
+      case 'textAlign':
+        return HorizontalAlignmentAnnotation.from(value);
+      case 'indent':
+        return IndentAnnotation.from(value);
+      case 'customAttribute':
+        return CustomAttributeAnnotation.from(value);
+      case 'customClass':
+        return CustomClassAnnotation.from(value);
+      case 'customStyle':
+        return CustomStyleAnnotation.from(value);
+      case 'internalWrapper':
+        return InternalWrapperAnnotation.from(value);
     }
   }
   /**
-   * Creates a new instance of the RTENode from the given JSON data.
+   * Converts annotations to an array of block annotation entities.
+   *
+   * @param {BlockAnnotations} annotationMap - The map to store the converted annotations.
+   * @param {VegaRTEBlockAnnotations} annotations - The annotations to convert.
+   */
+  static convertAnnotationsToMap(annotationMap, annotations) {
+    Object.entries(annotations).forEach(([type, value]) => {
+      const item = this.createAnnotationEntity(type, value);
+      if (typeGuard.isNonNullable(item)) {
+        annotationMap.set(...item);
+      }
+    });
+  }
+  /**
+   * Check if the block should be rendered as a wrapper.
    *
-   * @param {unknown} json - The JSON data to create the node from.
-   * @param {RTEBlock} parentBlock - The parent block of the node.
-   * @param {VegaRTETransformOptions} options - Options for transforming the node.
+   * @returns {boolean} - Returns true if the block is an internal wrapper.
    */
-  static from(json, parentBlock, options) {
-    throw new Error(`[Vega] ${this.constructor.name}.from(${JSON.stringify(json)}, ${parentBlock}, ${options}) is not implemented. Please implement this method in the subclass.`);
+  shouldRenderAsInternalWrapper() {
+    const internalWrapperAnnotation = this.getAnnotationByType(exports.BlockAnnotationTypeEnum.INTERNAL_WRAPPER);
+    if (internalWrapperAnnotation) {
+      return (internalWrapperAnnotation.internalWrapper &&
+        Array.from(this.annotationMap.values()).filter((annotation) => !(annotation instanceof LinkGroupAnnotation) &&
+          !(annotation instanceof InternalWrapperAnnotation)).length === 0);
+    }
+    else {
+      return false;
+    }
   }
   /**
-   * Creates different types of text annotations based on the provided type and value.
+   * Class to JSON object
    *
-   * @param {keyof VegaRTETextAnnotations} type - The key of the type.
-   * @param {unknown} value - The value that will be used to create the specific type of annotation entity based on the `type` provided.
-   * @returns {Nullable<[RTENodeAnnotationMapKey, RTENodeAnnotationMapValue]>} Returning a nullable tuple containing a key and a
-   * value from the `RTENodeAnnotationMapKey` and `RTENodeAnnotationMapValue` types.
+   * @returns {VegaRTEBlockBase} - JSON object
    */
-  static createAnnotationEntity(type, value) {
-    switch (type) {
-      case 'customAttribute':
-        return CustomAttributeAnnotation.from(value);
-      case 'customClass':
-        return CustomClassAnnotation.from(value);
-      case 'customStyle':
-        return CustomStyleAnnotation.from(value);
-    }
+  toJSON() {
+    const annotations = Array.from(this.annotationMap.values())
+      .filter((annotation) => annotation instanceof BlockAnnotation || annotation instanceof CommonAnnotation)
+      .reduce((record, annotation) => {
+      return Object.assign(Object.assign({}, record), annotation.toJSON());
+    }, {});
+    return Object.assign({ id: this.id }, (Object.keys(annotations).length > 0 ? { annotations } : {}));
   }
   /**
    * Get annotation by type
    *
    * @typedef T generic type
-   * @param {RTENodeAnnotationMapKey} type - Annotation type
+   * @param {keyof typeof BlockAnnotationTypeEnum} type - Annotation type
    * @returns {Nullable<T>} - Annotation
    */
   getAnnotationByType(type) {
     return this.annotationMap.get(type);
   }
   /**
-   * Delete annotation by type
-   *
-   * @param {RTENodeAnnotationMapKey} type - Annotation type
-   */
-  deleteAnnotationByType(type) {
-    this.annotationMap.delete(type);
-    this.flushChange();
-  }
-  /**
-   * Apply action to node
+   * Apply action to block
    *
    * @param {AnnotationAction} action - Annotation action
-   * @returns {this} - Node
    */
   apply(action) {
     this.doApply(action);
     if (action.isFlushable) {
-      this.flushChange();
+      const domNode = stateEntityRenderingRegistry.getDOMByEntity(this);
+      if (domNode) {
+        const nodeSubject = domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubjectFromParentNodeByEventId(domNode, vegaInternalEventId.VegaInternalRichTextEditorFlushChanges);
+        if (nodeSubject) {
+          changeManager.ChangeManager.notify(nodeSubject, {});
+        }
+      }
     }
-    return this;
+  }
+  /**
+   * Check if the block is a list item block
+   *
+   * @returns {boolean} True if the block is a list item block, false otherwise.
+   */
+  isListItemBlock() {
+    return this.type === 'list-item';
   }
   /**
    * Get styles from annotations
@@ -1021,21 +1288,19 @@ class RTENode {
    * @returns {AnnotationStyle} - Annotation styles
    */
   getStyles(options = { standalone: false }) {
-    const styles = Array.from(this.annotationMap.values())
-      .filter((annotation) => annotation instanceof NodeAnnotation || annotation instanceof CustomStyleAnnotation)
-      .map((annotation) => annotation.renderStyle(options))
-      .filter(Boolean);
-    return this.mergeAnnotationStyles(styles, ['textDecoration']);
+    const rteAnnotationStyle = new RTEAnnotationStyle(this);
+    const blockAnnotationStyle = rteAnnotationStyle.toJSON(options);
+    return Object.assign(Object.assign({}, blockAnnotationStyle), (this.shouldRenderAsInternalWrapper() ? { display: 'contents' } : {}));
   }
   /**
    * Get classes from annotations
    *
-   * @param {RTERenderContext} [options={ standalone: false }] - Options to control style mode
+   * @param {RTERenderContext} [options={ standalone: false }] - Options to control standalone mode
    * @returns {string} - Annotation style
    */
   getClasses(options = { standalone: false }) {
     return Array.from(this.annotationMap.values())
-      .filter((annotation) => annotation instanceof NodeAnnotation || annotation instanceof CustomClassAnnotation)
+      .filter((annotation) => annotation instanceof BlockAnnotation || annotation instanceof CustomClassAnnotation)
       .map((annotation) => annotation.renderClass(options))
       .filter(typeGuard.isNonNullable)
       .reduce((pre, cur) => [pre, cur].join(' ').trim(), '');
@@ -1043,27 +1308,11 @@ class RTENode {
   /**
    * Get custom attribute annotation, excluding "class" and "style"
    *
-   * @returns {CustomAttributeAnnotation} - custom attribute annotation
+   * @returns {Nullable<CustomAttributeAnnotation>} - custom attribute annotation
    */
   getCustomAttributesAnnotation() {
     return this.annotationMap.get(exports.CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE);
   }
-  /**
-   * Check if the node is a text node.
-   *
-   * @returns {boolean} - True if the node is a text node, false otherwise.
-   */
-  isTextNode() {
-    return false;
-  }
-  /**
-   * Get the HTMLElement reference associated with this node.
-   *
-   * @returns {Nullable<HTMLElement>} The HTMLElement reference or null if not found.
-   */
-  getElementRef() {
-    return stateEntityRenderingRegistry.getDOMByEntity(this);
-  }
   /**
    * Generate attributes as string
    *
@@ -1072,9 +1321,8 @@ class RTENode {
    */
   generateAttributeString(...attrs) {
     var _a;
-    const styles = Object.entries(Object.assign({}, this.getStyles({ standalone: true })))
-      .map(([key, value]) => `${string.camelToDashCase(key)}: ${value};`)
-      .join('');
+    const blockAnnotationStyle = new RTEAnnotationStyle(this);
+    const styles = blockAnnotationStyle.toCssText({ standalone: true });
     const customClassAnnotation = this.annotationMap.get(exports.CommonAnnotationTypeEnum.CUSTOM_CLASS);
     const customAttributeString = ((_a = this.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.toString(attrs)) || [];
     const attributes = [
@@ -1086,82 +1334,38 @@ class RTENode {
     return attributes.length ? ` ${attributes.join(' ')}` : '';
   }
   /**
-   * apply annotation action or modify content action
+   * Apply action to block
    *
-   * @param {AnnotationAction | ModifyContentAction} action annotation type action or modify content type action
+   * @param {AnnotationAction|ModifyContentAction} action - Annotation action
    */
   doApply(action) {
     if (action instanceof ModifyContentAction) {
-      this.doModifyActionApply(action);
+      ActionHandleStrategyRegistry.executeTheStrategy(action, this);
     }
     else {
-      this.doAnnotationActionApply(action);
+      this.applyAnnotationAction(action);
     }
   }
   /**
-   * Flush the value change
+   * Apply annotation action to block
+   *
+   * @param {AnnotationAction} action - Annotation action
    */
-  flushChange() {
-    const domNode = stateEntityRenderingRegistry.getDOMByEntity(this);
-    if (domNode) {
-      const nodeSubject = domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubjectFromParentNodeByEventId(domNode, vegaInternalEventId.VegaInternalRichTextEditorFlushChanges);
-      if (nodeSubject) {
-        changeManager.ChangeManager.notify(nodeSubject, {});
-      }
+  applyAnnotationAction(action) {
+    const annotation = action.toAnnotation();
+    if (!(annotation instanceof LinkGroupAnnotation)) {
+      this.annotationMap.set(annotation.type, annotation);
     }
+    typeof this.doAnnotationActionApply === 'function' && this.doAnnotationActionApply(action);
   }
   /**
-   * Clones the annotations of the current RTETextNode.
+   * clone annotations of the block
    *
-   * @returns {NodeAnnotations} A new Map containing cloned annotations.
+   * @returns {BlockAnnotations} - Cloned annotations
    */
   cloneAnnotations() {
     return new Map(Array.from(this.annotationMap.entries()).map(([key, value]) => [key, value.clone()]));
   }
-  /* istanbul ignore next */
-  /**
-   * Placeholder for the method to be implemented in sub classes.
-   *
-   * @param {AnnotationAction} action Annotation action
-   */
-  doAnnotationActionApply(action) {
-  }
-  /* istanbul ignore next */
-  /**
-   * Placeholder for the method to be implemented in sub classes.
-   *
-   * @param {ModifyContentAction} action ModifyContentAction
-   */
-  doModifyActionApply(action) {
-  }
-  /**
-   * Merge an array of annotation styles into a single style object.
-   * e.g.,
-   * { textDecoration: 'underline', textDecoration: 'line-through' }
-   * -> { textDecoration: 'underline line-through' }
-   *
-   * @param {AnnotationStyle[]} styles - Array of annotation style objects to merge.
-   * @param {string[]} canMergeKeyList - List of style keys that can be merged by concatenation.
-   * @returns {AnnotationStyle} - The merged annotation style object.
-   */
-  mergeAnnotationStyles(styles, canMergeKeyList) {
-    const merged = {};
-    for (const style of styles) {
-      for (const key in style) {
-        const value = style[key];
-        const existing = merged[key];
-        if (typeof existing === 'string' &&
-          typeof value === 'string' &&
-          canMergeKeyList.includes(key)) {
-          merged[key] = Array.from(new Set(`${existing} ${value}`.split(/\s+/).filter(Boolean))).join(' ');
-        }
-        else {
-          merged[key] = value;
-        }
-      }
-    }
-    return merged;
-  }
 }
 
 /**
@@ -1671,56 +1875,6 @@ class SyncUpSelectionAction extends AnnotationAction {
   }
 }
 
-/**
- * RTEDTOClassManager is a singleton class that manages the registration and retrieval of RTE DTO classes.
- * It allows for the dynamic handling of different RTE blocks and nodes by their types.
- */
-class RTEDTOClassManager {
-  constructor() {
-    // Register RTE Block DTO classes.
-    this.RTE_BLOCK_DTO_CLASS_MAP = new Map();
-    // Register RTE Block DTO classes.
-    this.RTE_NODE_DTO_CLASS_MAP = new Map();
-  }
-  /**
-   * Registers a new RTE DTO class.
-   *
-   * @typedef T - The type of the RTE DTO class to register.
-   * @param {string} type - The type identifier for the RTE DTO class.
-   * @param {ClassType<T>} RTEDTOClass - The class constructor for the RTE DTO.
-   */
-  registerRTEDTOClass(type, RTEDTOClass) {
-    if (RTEDTOClass.prototype instanceof RTEBlock) {
-      this.RTE_BLOCK_DTO_CLASS_MAP.set(type, RTEDTOClass);
-    }
-    else if (RTEDTOClass.prototype instanceof RTENode) {
-      this.RTE_NODE_DTO_CLASS_MAP.set(type, RTEDTOClass);
-    }
-    else {
-      throw new Error(`Invalid RTE DTO class type: ${type}`);
-    }
-  }
-  /**
-   * Retrieves the RTE block class for a given type.
-   *
-   * @param {string} type - The type identifier for the RTE block.
-   * @returns {Nullable<RTEBlockDTOClass>} - The class constructor for the RTE block, or null if not found.
-   */
-  getRTEBlockClass(type) {
-    return this.RTE_BLOCK_DTO_CLASS_MAP.get(type);
-  }
-  /**
-   * Retrieves the RTE node class for a given type.
-   *
-   * @param {string} type - The type identifier for the RTE node.
-   * @returns {Nullable<RTENodeDTOClass>} - The class constructor for the RTE node, or null if not found.
-   */
-  getRTENodeClass(type) {
-    return this.RTE_NODE_DTO_CLASS_MAP.get(type);
-  }
-}
-const RTEDTOClassManager$1 = new RTEDTOClassManager();
-
 /**
  * The base action handle strategy class, use to modify the rich text node content or modify the annotation.
  */
@@ -2472,6 +2626,25 @@ class PlainTextAnnotation extends NodeAnnotation {
   }
 }
 
+/**
+ * Action to toggle the text color annotation visibility/state.
+ */
+class TextColorAnnotationAction extends TextSplittableAction {
+  constructor(textColor) {
+    super();
+    this.isFlushable = true;
+    this.textColor = textColor;
+  }
+  /**
+   * Converts the action into a text color annotation.
+   *
+   * @returns {Annotation} the annotation
+   */
+  toAnnotation() {
+    return new TextColorAnnotation(this.textColor);
+  }
+}
+
 /**
  * Text node
  */
@@ -2658,6 +2831,13 @@ class RTETextNode extends RTENode {
       }
       ActionHandleStrategyRegistry.register(TextSplittableAction.name, dtoClassName, new NodeSplitTextStrategy());
       ActionHandleStrategyRegistry.register(exports.ModifyContentActionType.DELETE_LINK_GROUP, dtoClassName, new DeleteLinkGroupStrategy());
+      ActionHandleStrategyRegistry.register(BoldAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(ClearFormattingAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(ItalicAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(UnderlineAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(TextColorAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(StrikethroughAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(CodeAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
       ActionHandleStrategyRegistry.register(AnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
       RTETextNode.registerActionStrategyStatus[dtoClassName] = true;
     }
@@ -2708,9 +2888,6 @@ class RTETextNode extends RTENode {
     /**
      * 1. Try to get the specific strategy for the action and node type first (e.g., LinkAnnotationAction on RTETextNode).
      * 2. If no specific strategy found, try to get the generic NodeUpdateAnnotationMapStrategy for AnnotationAction on RTETextNode.
-     *
-     * This is useful when we want to check if there is a specific strategy for an action-node combination first, we can use the specific strategy to check if the special toolbar button should be enabled or disabled.
-     * TODO: Update the other annotation actions to follow this pattern. https://gethired.atlassian.net/browse/VD-7367
      */
     const strategy = ActionHandleStrategyRegistry.get(action.constructor.name, node.constructor.name);
     if (strategy) {
@@ -3546,11 +3723,7 @@ class RTETextBlock extends RTEBlock {
   toHtml() {
     const BlockTag = this.getBlockTag();
     const attrStr = super.generateAttributeString();
-    const linkGroupAnnotation = this.getAnnotationByType(exports.InternalAnnotationTypeEnum.LINK_GROUP);
-    let nodesHtml = this.children.map((node) => node.toHtml()).join('');
-    if (linkGroupAnnotation && this.children.length > 0) {
-      nodesHtml = this.generateLinkHtml(linkGroupAnnotation, nodesHtml);
-    }
+    const nodesHtml = this.getChildrenHtml();
     return super.shouldRenderAsInternalWrapper()
       ? nodesHtml
       : [`<${BlockTag}${attrStr}>`, nodesHtml, `</${BlockTag}>`].join('');
@@ -3616,6 +3789,19 @@ class RTETextBlock extends RTEBlock {
         return 'p';
     }
   }
+  /**
+   * Get the HTML string for the children nodes, including handling link group annotations.
+   *
+   * @returns {string} The HTML string representing the children nodes.
+   */
+  getChildrenHtml() {
+    const linkGroupAnnotation = this.getAnnotationByType(exports.InternalAnnotationTypeEnum.LINK_GROUP);
+    let nodesHtml = this.children.map((node) => node.toHtml()).join('');
+    if (linkGroupAnnotation && this.children.length > 0) {
+      nodesHtml = this.generateLinkHtml(linkGroupAnnotation, nodesHtml);
+    }
+    return nodesHtml;
+  }
   /**
    * @inheritDoc
    */
@@ -3755,9 +3941,7 @@ class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
       if (currentBlockIndex > 0) {
         return currentBlock.parent.children[currentBlockIndex - 1];
       }
-      else if ((currentBlock.parent['type'] === 'number-list' ||
-        currentBlock.parent['type'] === 'bullet-list') &&
-        currentBlockIndex === 0) {
+      else if (this.isRTEBlock(currentBlock.parent) && currentBlockIndex === 0) {
         return this.getPreviousBlock(currentBlock.parent);
       }
     }
@@ -3808,6 +3992,15 @@ class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
       }
     }
   }
+  /**
+   * Checks if the given instance is not the root content block.
+   *
+   * @param {RTEBlock | VegaRTEContent} block - The instance to check.
+   * @returns {boolean} True if the block is not the root content block, false otherwise.
+   */
+  isRTEBlock(block) {
+    return block && block.constructor.name !== 'VegaRTEContent';
+  }
 }
 
 /**
@@ -4224,6 +4417,7 @@ RTECodeBlock.CODE_BLOCK_PLACEHOLDER_CLASS_NAME = 'code-block-placeholder-element
 
 exports.ActionHandleStrategy = ActionHandleStrategy;
 exports.ActionHandleStrategyRegistry = ActionHandleStrategyRegistry;
+exports.ActionHandlerInterceptorRegistry = ActionHandlerInterceptorRegistry;
 exports.AnnotationAction = AnnotationAction;
 exports.AppendChildrenAction = AppendChildrenAction;
 exports.BlockAnnotation = BlockAnnotation;
@@ -4234,6 +4428,7 @@ exports.BlockMergeNodesStrategy = BlockMergeNodesStrategy;
 exports.BlockReplaceNodesStrategy = BlockReplaceNodesStrategy;
 exports.BlockSplitWithTextNodeStrategy = BlockSplitWithTextNodeStrategy;
 exports.BlockUpdateHorizontalAlignmentStrategy = BlockUpdateHorizontalAlignmentStrategy;
+exports.BlockUpdateTextStyleStrategy = BlockUpdateTextStyleStrategy;
 exports.BoldAnnotation = BoldAnnotation;
 exports.BoldAnnotationAction = BoldAnnotationAction;
 exports.ClearFormattingAnnotationAction = ClearFormattingAnnotationAction;
@@ -4250,6 +4445,7 @@ exports.ItalicAnnotationAction = ItalicAnnotationAction;
 exports.LinkAnnotationAction = LinkAnnotationAction;
 exports.ModifyContentAction = ModifyContentAction;
 exports.NodeAnnotation = NodeAnnotation;
+exports.RTEAnnotationStyle = RTEAnnotationStyle;
 exports.RTEBlock = RTEBlock;
 exports.RTECodeBlock = RTECodeBlock;
 exports.RTECodeBlockNode = RTECodeBlockNode;
@@ -4267,8 +4463,7 @@ exports.SelectionChangeAction = SelectionChangeAction;
 exports.SplitBlockWithNodeAction = SplitBlockWithNodeAction;
 exports.StrikethroughAnnotationAction = StrikethroughAnnotationAction;
 exports.SyncUpSelectionAction = SyncUpSelectionAction;
-exports.TextColorAnnotation = TextColorAnnotation;
-exports.TextSplittableAction = TextSplittableAction;
+exports.TextColorAnnotationAction = TextColorAnnotationAction;
 exports.TextStyleAnnotation = TextStyleAnnotation;
 exports.TextStyleAnnotationAction = TextStyleAnnotationAction;
 exports.UnderlineAnnotationAction = UnderlineAnnotationAction;