@globalpayments/vega 2.67.0 → 2.68.0

package/dist/esm/{code-block-11b2bc1c.js → code-block-e8839202.js}

@@ -149,6 +149,7 @@ var ModifyContentActionType;
   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";
 })(ModifyContentActionType || (ModifyContentActionType = {}));
 /**
  * Abstract class for update node content, delete node, insert node
@@ -383,6 +384,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`.
  */
@@ -401,6 +463,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.
    *
@@ -426,20 +500,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 {
+        LogUtility.warn(`Type ${actionType} action handle strategy is not registered in class ${RTEInstance.constructor.name}`);
+      }
+    };
+    if (interceptor) {
+      return interceptor.intercept(executeStrategy, action, RTEInstance);
     }
     else {
-      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) {
@@ -702,128 +787,184 @@ class InternalWrapperAnnotation extends BlockAnnotation {
   }
 }
 
+var NodeAnnotationTypeEnum;
+(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";
+})(NodeAnnotationTypeEnum || (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]) => `${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(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 (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(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;
+  }
+}
+
+var NodeTypeEnum;
+(function (NodeTypeEnum) {
+  NodeTypeEnum["TEXT"] = "TEXT";
+  NodeTypeEnum["IMAGE"] = "IMAGE";
+  NodeTypeEnum["CODE_BLOCK_NODE"] = "CODE_BLOCK_NODE";
+})(NodeTypeEnum || (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 = domNodeSubjectFactory.getSubjectFromParentNodeByEventId(domNode, VegaInternalRichTextEditorFlushChanges);
-        if (nodeSubject) {
-          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
@@ -832,21 +973,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(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(isNonNullable)
       .reduce((pre, cur) => [pre, cur].join(' ').trim(), '');
@@ -854,11 +992,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(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
    *
@@ -867,9 +1021,10 @@ class RTEBlock {
    */
   generateAttributeString(...attrs) {
     var _a;
-    const styles = Object.entries(Object.assign({}, this.getStyles({ standalone: true })))
-      .map(([key, value]) => `${camelToDashCase(key)}: ${value};`)
-      .join('');
+    const nodeAnnotationStyle = new RTEAnnotationStyle(this);
+    const styles = nodeAnnotationStyle.toCssText({ standalone: true }, [
+      'textDecoration',
+    ]);
     const customClassAnnotation = this.annotationMap.get(CommonAnnotationTypeEnum.CUSTOM_CLASS);
     const customAttributeString = ((_a = this.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.toString(attrs)) || [];
     const attributes = [
@@ -881,136 +1036,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 = domNodeSubjectFactory.getSubjectFromParentNodeByEventId(domNode, VegaInternalRichTextEditorFlushChanges);
+      if (nodeSubject) {
+        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) {
+  }
 }
 
-var NodeAnnotationTypeEnum;
-(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";
-})(NodeAnnotationTypeEnum || (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();
 
-var NodeTypeEnum;
-(function (NodeTypeEnum) {
-  NodeTypeEnum["TEXT"] = "TEXT";
-  NodeTypeEnum["IMAGE"] = "IMAGE";
-  NodeTypeEnum["CODE_BLOCK_NODE"] = "CODE_BLOCK_NODE";
-})(NodeTypeEnum || (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(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 (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(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 = domNodeSubjectFactory.getSubjectFromParentNodeByEventId(domNode, VegaInternalRichTextEditorFlushChanges);
+        if (nodeSubject) {
+          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
@@ -1019,21 +1286,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(isNonNullable)
       .reduce((pre, cur) => [pre, cur].join(' ').trim(), '');
@@ -1041,27 +1306,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(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
    *
@@ -1070,9 +1319,8 @@ class RTENode {
    */
   generateAttributeString(...attrs) {
     var _a;
-    const styles = Object.entries(Object.assign({}, this.getStyles({ standalone: true })))
-      .map(([key, value]) => `${camelToDashCase(key)}: ${value};`)
-      .join('');
+    const blockAnnotationStyle = new RTEAnnotationStyle(this);
+    const styles = blockAnnotationStyle.toCssText({ standalone: true });
     const customClassAnnotation = this.annotationMap.get(CommonAnnotationTypeEnum.CUSTOM_CLASS);
     const customAttributeString = ((_a = this.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.toString(attrs)) || [];
     const attributes = [
@@ -1084,82 +1332,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 = domNodeSubjectFactory.getSubjectFromParentNodeByEventId(domNode, VegaInternalRichTextEditorFlushChanges);
-      if (nodeSubject) {
-        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;
-  }
 }
 
 /**
@@ -1669,56 +1873,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.
  */
@@ -2470,6 +2624,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
  */
@@ -2656,6 +2829,13 @@ class RTETextNode extends RTENode {
       }
       ActionHandleStrategyRegistry.register(TextSplittableAction.name, dtoClassName, new NodeSplitTextStrategy());
       ActionHandleStrategyRegistry.register(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;
     }
@@ -2706,9 +2886,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) {
@@ -3544,11 +3721,7 @@ class RTETextBlock extends RTEBlock {
   toHtml() {
     const BlockTag = this.getBlockTag();
     const attrStr = super.generateAttributeString();
-    const linkGroupAnnotation = this.getAnnotationByType(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('');
@@ -3614,6 +3787,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(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
    */
@@ -3753,9 +3939,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);
       }
     }
@@ -3806,6 +3990,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';
+  }
 }
 
 /**
@@ -4220,4 +4413,4 @@ class RTECodeBlock extends RTEBlock {
 })();
 RTECodeBlock.CODE_BLOCK_PLACEHOLDER_CLASS_NAME = 'code-block-placeholder-element';
 
-export { ItalicAnnotationAction as $, ActionHandleStrategyRegistry as A, BlockInsertLineBreakStrategy as B, CustomStyleAnnotation as C, SplitBlockWithNodeAction as D, BlockUpdateHorizontalAlignmentStrategy as E, BlockDeleteNodeContentStrategy as F, RemoveChildrenStrategy as G, HorizontalAlignmentAnnotationAction as H, InsertChildrenAfterAction as I, RTENode as J, CodeLanguage as K, LinkAnnotationAction as L, ModifyContentAction as M, NodeAnnotation as N, InternalAnnotationTypeEnum as O, CommonAnnotationTypeEnum as P, UpdateCodeBlockAction as Q, RTEDTOClassManager$1 as R, SyncUpSelectionAction as S, SelectionChangeAction as T, UpdateTextAction as U, VegaRTEPresetToolbarItems as V, TextSplittableAction as W, TextColorAnnotation as X, RTECodeBlockNode as Y, ZERO_WIDTH_SPACE as Z, BoldAnnotationAction as _, RTETextNode as a, UnderlineAnnotationAction as a0, TextStyleAnnotationAction as a1, TextStyleAnnotation as a2, BoldAnnotation as a3, ClearFormattingAnnotationAction as a4, CodeAnnotationAction as a5, StrikethroughAnnotationAction as a6, IndentAnnotationAction as a7, ModifyContentActionType as b, ActionHandleStrategy as c, RTETextBlock as d, AppendChildrenAction as e, BlockInsertLineBreakWithBlocksStrategy as f, BlockSplitWithTextNodeStrategy as g, BlockReplaceNodesStrategy as h, BlockMergeNodesStrategy as i, RemoveChildrenAction as j, InsertChildrenBeforeAction as k, BlockAnnotation as l, BlockAnnotationTypeEnum as m, RTEBlock as n, CustomClassAnnotation as o, CustomAttributeAnnotation as p, RTECodeBlock as q, RTE_TEXT_COLORS as r, stateEntityRenderingRegistry as s, RTE_DEFAULT_TEXT_COLOR as t, NodeAnnotationTypeEnum as u, RTEDecoratorNode as v, NodeTypeEnum as w, CommonAnnotation as x, AnnotationAction as y, ReplaceChildNodesAction as z };
+export { TextColorAnnotationAction as $, ActionHandleStrategyRegistry as A, BlockUpdateTextStyleStrategy as B, CustomStyleAnnotation as C, NodeTypeEnum as D, CommonAnnotation as E, AnnotationAction as F, ReplaceChildNodesAction as G, HorizontalAlignmentAnnotationAction as H, InsertChildrenAfterAction as I, SplitBlockWithNodeAction as J, BlockDeleteNodeContentStrategy as K, RemoveChildrenStrategy as L, ModifyContentAction as M, NodeAnnotation as N, RTE_TEXT_COLORS as O, RTE_DEFAULT_TEXT_COLOR as P, CodeLanguage as Q, RTEDTOClassManager$1 as R, SyncUpSelectionAction as S, TextStyleAnnotationAction as T, UpdateTextAction as U, VegaRTEPresetToolbarItems as V, LinkAnnotationAction as W, CommonAnnotationTypeEnum as X, UpdateCodeBlockAction as Y, ZERO_WIDTH_SPACE as Z, SelectionChangeAction as _, ActionHandlerInterceptorRegistry as a, RTECodeBlockNode as a0, BoldAnnotationAction as a1, ItalicAnnotationAction as a2, UnderlineAnnotationAction as a3, TextStyleAnnotation as a4, BoldAnnotation as a5, ClearFormattingAnnotationAction as a6, CodeAnnotationAction as a7, StrikethroughAnnotationAction as a8, IndentAnnotationAction as a9, RTETextNode as b, ModifyContentActionType as c, ActionHandleStrategy as d, RTETextBlock as e, RTEBlock as f, RTEAnnotationStyle as g, AppendChildrenAction as h, RTENode as i, InsertChildrenBeforeAction as j, InternalAnnotationTypeEnum as k, BlockUpdateHorizontalAlignmentStrategy as l, BlockInsertLineBreakStrategy as m, BlockInsertLineBreakWithBlocksStrategy as n, BlockSplitWithTextNodeStrategy as o, BlockReplaceNodesStrategy as p, BlockMergeNodesStrategy as q, RemoveChildrenAction as r, stateEntityRenderingRegistry as s, BlockAnnotation as t, BlockAnnotationTypeEnum as u, CustomClassAnnotation as v, CustomAttributeAnnotation as w, RTECodeBlock as x, NodeAnnotationTypeEnum as y, RTEDecoratorNode as z };