@heartlandone/vega 2.95.0 → 2.96.0

package/dist/esm/{code-block-e12588fe.js → code-block-0a88b481.js}

@@ -137,6 +137,8 @@ var ModifyContentActionType;
   ModifyContentActionType["LINE_BREAK_MULTIPLE_BLOCKS"] = "LINE_BREAK_MULTIPLE_BLOCKS";
   ModifyContentActionType["TRANSFORM_LIST_BLOCK"] = "TRANSFORM_LIST_BLOCK";
   ModifyContentActionType["TRANSFORM_PARAGRAPH_BLOCK"] = "TRANSFORM_PARAGRAPH_BLOCK";
+  ModifyContentActionType["NEST_LIST_ITEMS"] = "NEST_LIST_ITEMS";
+  ModifyContentActionType["UNNEST_LIST_ITEMS"] = "UNNEST_LIST_ITEMS";
   ModifyContentActionType["DELETE_BLOCK_CONTENT"] = "DELETE_BLOCK_CONTENT";
   ModifyContentActionType["INSERT_IMAGE_TO_BLOCK"] = "INSERT_IMAGE_TO_BLOCK";
   ModifyContentActionType["UPDATE_IMAGE_NODE_URL"] = "UPDATE_IMAGE_NODE_URL";
@@ -4259,6 +4261,37 @@ class BlockInsertImageIntoTextStrategy extends ActionHandleStrategy {
   }
 }
 
+/**
+ * Normalize a mixed paragraph/list selection before rebuilding it as a list.
+ *
+ * Selected list items whose owning ancestor item is also selected remain inside
+ * that ancestor's nestList instead of being emitted again as flattened siblings.
+ * Their immediate list type is still updated because the nested item was part of
+ * the toolbar selection.
+ *
+ * @param {RTEBlock[]} selectedBlocks - Blocks selected by the toolbar action.
+ * @param {ListType} listType - Target list type.
+ * @returns {RTEBlock[]} Top-level selected blocks to emit into the rebuilt list.
+ */
+function normalizeMixedListSelection(selectedBlocks, listType) {
+  const selectedListItems = new Set(selectedBlocks.filter((block) => block.dtoName === 'RTEListItemBlock'));
+  return selectedBlocks.filter((block) => {
+    if (!(block.dtoName === 'RTEListItemBlock')) {
+      return true;
+    }
+    let parentList = block.parent;
+    while (parentList.parent && parentList.parent.dtoName === 'RTEListItemBlock') {
+      const ownerItem = parentList.parent;
+      if (selectedListItems.has(ownerItem)) {
+        block.parent.type = listType;
+        return false;
+      }
+      parentList = ownerItem.parent;
+    }
+    return true;
+  });
+}
+
 /**
  * Convert the selected blocks to list strategy.
  */
@@ -4270,12 +4303,16 @@ class BlockTransformToListStrategy extends ActionHandleStrategy {
    * @param {RTETextBlock} target - The first item of the selected block.
    */
   handleAction(action, target) {
-    const contentState = target.parent;
+    const contentState = this.getRootContent(target);
+    if (!contentState) {
+      return;
+    }
+    const container = target.parent;
     const bulletList = contentState.createList(action.listType);
-    const selectedBlocks = action.selectedBlocks;
+    const selectedBlocks = normalizeMixedListSelection(action.selectedBlocks, action.listType);
     const listItems = selectedBlocks.map((block) => contentState.toListItem(block));
     bulletList.apply(new AppendChildrenAction(listItems));
-    contentState.apply(new InsertChildrenAfterAction(action.selectedBlocks[0], bulletList));
+    container.apply(new InsertChildrenAfterAction(action.selectedBlocks[0], bulletList));
     selectedBlocks.forEach((block) => {
       block.parent.apply(new RemoveChildrenAction(block));
     });
@@ -4672,78 +4709,1485 @@ class RTETextBlock extends RTEBlock {
 RTETextBlock.dtoName = 'RTETextBlock';
 
 /**
- * The delete node content contains some common functions that used for image block delete the image node or text block delete text node.
+ * Remove list item nest list block strategy.
  */
-class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
+class ListItemRemoveNestListStrategy extends ActionHandleStrategy {
   /**
-   * Returns the previous node relative to the current node in a rich text editor structure.
+   * Remove the nest list block from the list item, clear the property children when the children is empty.
    *
-   * @param {RTENode} currentNode - An object of type `RTENode`.
-   * @returns {Nullable<RTENode>} the previous block last node
+   * @param {RemoveNestListAction} action - The action instance.
+   * @param {RTEListItemBlock} target - The list item block.
    */
-  getPreviousNode(currentNode) {
-    const currentBlock = currentNode.parent;
-    const currentIndex = currentBlock.children.indexOf(currentNode);
-    if (currentIndex > 0) {
-      return currentBlock.children[currentIndex - 1];
+  handleAction(action, target) {
+    if (target.nestList) {
+      if (target.nestList.length > 1) {
+        target.nestList = target.nestList.filter((child) => child !== action.nestListBlockToBeRemoved);
+      }
+      else {
+        target.nestList = undefined;
+      }
     }
-    else if (currentBlock.parent) {
-      const previousBlock = this.getPreviousBlock(currentBlock);
-      if (previousBlock) {
-        return this.getBlockLastNode(previousBlock);
+  }
+}
+
+/**
+ * Base strategy for list operations that reconstruct or merge list containers.
+ * Keeps annotation cloning and equality rules consistent across those operations.
+ */
+class ListAnnotationStrategy extends ActionHandleStrategy {
+  /**
+   * Copy list-container annotations without sharing mutable annotation instances.
+   * Factory-provided defaults remain intact unless the source supplies the same key.
+   *
+   * @param {RTEListBlock} source - List whose annotations should be copied.
+   * @param {RTEListBlock} target - Newly created list receiving the annotations.
+   */
+  copyListAnnotations(source, target) {
+    source.annotationMap.forEach((annotation, key) => {
+      target.annotationMap.set(key, annotation.clone());
+    });
+  }
+  /**
+   * Compare list annotations independently of map/object insertion order. Map keys
+   * are compared separately because rendering annotations such as LIST intentionally
+   * do not serialize to the DTO but still affect the rendered list.
+   * Array order remains significant because it can affect rendered class order.
+   *
+   * @param {RTEListBlock} first - First list to compare.
+   * @param {RTEListBlock} second - Second list to compare.
+   * @returns {boolean} Whether both list containers have equivalent annotations.
+   */
+  haveSameListAnnotations(first, second) {
+    var _a, _b;
+    const firstKeys = Array.from(first.annotationMap.keys()).sort();
+    const secondKeys = Array.from(second.annotationMap.keys()).sort();
+    if (JSON.stringify(firstKeys) !== JSON.stringify(secondKeys)) {
+      return false;
+    }
+    return (JSON.stringify(this.normalizeAnnotationValue((_a = first.toJSON().annotations) !== null && _a !== void 0 ? _a : {})) ===
+      JSON.stringify(this.normalizeAnnotationValue((_b = second.toJSON().annotations) !== null && _b !== void 0 ? _b : {})));
+  }
+  /**
+   * Recursively sort object keys for stable annotation comparison.
+   *
+   * @param {unknown} value - Annotation value to normalize.
+   * @returns {unknown} Normalized annotation value.
+   */
+  normalizeAnnotationValue(value) {
+    if (Array.isArray(value)) {
+      return value.map((item) => this.normalizeAnnotationValue(item));
+    }
+    if (value && typeof value === 'object') {
+      const record = value;
+      return Object.keys(record)
+        .sort()
+        .reduce((normalized, key) => {
+        normalized[key] = this.normalizeAnnotationValue(record[key]);
+        return normalized;
+      }, {});
+    }
+    return value;
+  }
+}
+
+/**
+ * Replace list item nest list strategy.
+ *
+ * This is the single write-through point for `nestList` mutations. It automatically
+ * normalizes the incoming array by merging adjacent lists only when their types
+ * and container annotations match. Styled list boundaries remain independent.
+ */
+class ListItemReplaceNestListStrategy extends ListAnnotationStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const normalized = this.mergeAdjacentSameType(action.newList);
+    normalized.forEach((listBlock) => {
+      listBlock.parent = target;
+    });
+    target.nestList = normalized;
+  }
+  /**
+   * Merge adjacent entries that share the same list type and annotations.
+   * This is an idempotent O(n) pass — calling it on an already-normalized array is a no-op.
+   *
+   * @param {RTEListBlock[]} lists - The nest list array to normalize.
+   * @returns {RTEListBlock[]} A new array with adjacent same-type entries merged.
+   */
+  mergeAdjacentSameType(lists) {
+    if (lists.length <= 1) {
+      return lists;
+    }
+    const merged = [lists[0]];
+    for (let i = 1; i < lists.length; i++) {
+      const prev = merged[merged.length - 1];
+      const current = lists[i];
+      if (prev.type === current.type && this.haveSameListAnnotations(prev, current)) {
+        current.children.forEach((item) => {
+          item.parent = prev;
+        });
+        prev.children = prev.children.concat(current.children);
+      }
+      else {
+        merged.push(current);
       }
     }
+    return merged;
   }
+}
+
+/**
+ * Insert image node to list item block strategy.
+ */
+class ListItemInsertImageStrategy extends ActionHandleStrategy {
   /**
-   * Returns the next node relative to the current node in a rich text editor structure.
+   * The image node can not insert into list item block, so insert image after parent list block.
    *
-   * @param {RTENode} currentNode - An object of type `RTENode`.
-   * @returns {Nullable<RTENode>} the next block first node
+   * @param {InsertImageToBlockAction} action - The action instance.
+   * @param {RTEListItemBlock} target - The list item block.
    */
-  getNextNode(currentNode) {
-    const currentBlock = currentNode.parent;
-    const currentIndex = currentBlock.children.indexOf(currentNode);
-    if (currentBlock.children[currentIndex + 1]) {
-      return currentBlock.children[currentIndex + 1];
+  handleAction(action, target) {
+    target.parent.apply(action);
+  }
+}
+
+/**
+ * List item block.
+ *
+ * Bidirectional nesting contract:
+ * - nestList stores nested list blocks owned by this list item.
+ * - Every nested list block must have listBlock.parent === this list item.
+ */
+class RTEListItemBlock extends RTETextBlock {
+  constructor(id, nestList, options) {
+    super(id, 'list-item', options);
+    this.dtoName = RTEListItemBlock.dtoName;
+    /**
+     * TODO: Refactor the list item properties children and nestList, merge two properties together.
+     *
+     * 1. Update the type of `children` to include `RTEListBlock` as a possible type.
+     * 2. The list block children should text block array and nest list block array, The text block should wrap a `li` tag when rendering.
+     */
+    this.nestList = [];
+    this.nestList = nestList;
+  }
+  /**
+   * Converts a VegaRTEListItemBlock object to an RTEListItemBlock
+   *
+   * @param {VegaRTEListBlock} block - Converts a `VegaRTEListItemBlock` object into an `RTEListItemBlock`.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
+   * @returns {RTEListItemBlock} Return an instance of `RTEListItemBlock`
+   */
+  static from(block, options = { autoMatchFormat: true }) {
+    const listItemBlock = new RTEListItemBlock(block.id, undefined, options);
+    listItemBlock.children = block.nodes.map((richText) => RTETextNode.from(richText, listItemBlock, options));
+    if (block.children) {
+      listItemBlock.nestList = block.children.map((child) => {
+        const listBlock = RTEListBlock.from(child, options);
+        listBlock.parent = listItemBlock;
+        return listBlock;
+      });
     }
-    else if (currentBlock.parent) {
-      const nextBlock = this.getNextBlock(currentBlock);
-      if (nextBlock) {
-        return this.getBlockFirstNode(nextBlock);
+    const { annotations } = block;
+    if (annotations) {
+      Object.entries(annotations).forEach(([type, value]) => {
+        const item = this.createAnnotationEntity(type, value);
+        if (isNonNullable(item)) {
+          listItemBlock.annotationMap.set(...item);
+        }
+      });
+    }
+    return listItemBlock;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    var _a;
+    return Object.assign(Object.assign({}, super.toJSON()), { type: 'list-item', children: (_a = this.nestList) === null || _a === void 0 ? void 0 : _a.map((block) => block.toJSON()) });
+  }
+  /**
+   * @inheritDoc
+   */
+  toHtml(options) {
+    var _a;
+    const attrStr = super.generateAttributeString(options);
+    const nestListHtml = ((_a = this.nestList) === null || _a === void 0 ? void 0 : _a.length)
+      ? this.nestList.map((list) => list.toHtml(options)).join('')
+      : '';
+    return [`<li${attrStr}>`, this.getChildrenHtml(options), nestListHtml, `</li>`].join('');
+  }
+  /**
+   * @inheritDoc
+   */
+  cloneWithNodes(nodes) {
+    const block = new RTEListItemBlock(generateUUID());
+    block.children = [];
+    block.apply(new AppendChildrenAction(nodes));
+    return block;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastNode() {
+    if (this.nestList && this.nestList.length > 0) {
+      const childListBlock = this.nestList[this.nestList.length - 1];
+      return childListBlock.getLastNode();
+    }
+    return super.getLastNode();
+  }
+  /**
+   * Create a new list item block.
+   *
+   * @returns {RTEListItemBlock} - A list item block.
+   */
+  createNewListItem() {
+    return new RTEListItemBlock(generateUUID());
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    var _a;
+    const block = new RTEListItemBlock(this.id);
+    block.children = this.children.map((node) => node.clone(block));
+    block.annotationMap = super.cloneAnnotations();
+    block.nestList = (_a = this.nestList) === null || _a === void 0 ? void 0 : _a.map((child) => child.clone(block));
+    block.parent = parent;
+    return block;
+  }
+}
+(() => {
+  ActionHandleStrategyRegistry.register(TextStyleAnnotationAction.name, RTEListItemBlock.name, new BlockUpdateTextStyleStrategy());
+  ActionHandleStrategyRegistry.register(HorizontalAlignmentAnnotationAction.name, RTEListItemBlock.name, new BlockUpdateHorizontalAlignmentStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTEListItemBlock.name, new BlockInsertLineBreakStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTEListItemBlock.name, new BlockInsertLineBreakWithBlocksStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_NEST_LIST, RTEListItemBlock.name, new ListItemRemoveNestListStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTEListItemBlock.name, new BlockSplitWithTextNodeStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_CHILD_NODES, RTEListItemBlock.name, new BlockReplaceNodesStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_NEST_LIST, RTEListItemBlock.name, new ListItemReplaceNestListStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTEListItemBlock.name, new BlockMergeNodesStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEListItemBlock.name, new ListItemInsertImageStrategy());
+})();
+RTEListItemBlock.dtoName = 'RTEListItemBlock';
+
+/**
+ * Replace the nest list with new list array
+ *
+ * @example listItemBlock.apply(new ReplaceNestListAction(newListBlockArray))
+ */
+class ReplaceNestListAction extends ModifyContentAction {
+  constructor(newList) {
+    super();
+    this.type = ModifyContentActionType.REPLACE_NEST_LIST;
+    this.newList = newList;
+  }
+}
+
+/**
+ * Convert the selected blocks to list strategy.
+ */
+class ListTransformToListStrategy extends ListAnnotationStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    var _a;
+    const selectedBlocks = action.selectedBlocks;
+    const isSameList = selectedBlocks.every((block) => block.parent === target);
+    const rootContent = this.getRootContent(target);
+    if (!rootContent) {
+      return;
+    }
+    // Nested list case: target.parent is RTEListItemBlock, not VegaRTEContent.
+    // Replace the entry in the parent item's nestList using the existing ReplaceNestListAction.
+    if (target.parent instanceof RTEListItemBlock) {
+      if (isSameList) {
+        const newList = this.createListFromSource(rootContent, target, action.listType);
+        newList.apply(new AppendChildrenAction(target.children));
+        const parentListItem = target.parent;
+        const newNestList = ((_a = parentListItem.nestList) !== null && _a !== void 0 ? _a : []).map((list) => (list === target ? newList : list));
+        // Adjacent same-type merge is handled automatically by ListItemReplaceNestListStrategy.
+        parentListItem.apply(new ReplaceNestListAction(newNestList));
+        selectedBlocks.forEach((block) => block.children.map((node) => node.apply(new SyncUpSelectionAction())));
+      }
+      else {
+        this.handleCrossListTransform(action, target);
+      }
+      return;
+    }
+    // Root list case: target.parent is VegaRTEContent.
+    // When all selected blocks are list items from different lists, convert each
+    // affected list's type in place (preserving nesting), then normalize adjacent
+    // same-type root lists into one.
+    if (!isSameList && selectedBlocks.every((block) => block instanceof RTEListItemBlock)) {
+      const affectedLists = new Set(selectedBlocks.map((block) => block.parent));
+      // Track which root lists result from conversion (new lists replace old ones).
+      const convertedRootLists = new Set();
+      affectedLists.forEach((list) => {
+        if (list.type !== action.listType) {
+          this.convertListTypeInPlace(list, action.listType);
+        }
+      });
+      // Collect current top-level lists that contain any selected item, grouped
+      // by their root or HTML-block container.
+      const affectedContainers = new Set();
+      selectedBlocks.forEach((block) => {
+        const parentList = block.parent;
+        if (!(parentList.parent instanceof RTEListItemBlock)) {
+          convertedRootLists.add(parentList);
+          affectedContainers.add(parentList.parent);
+        }
+      });
+      // Only merge adjacent root lists when BOTH are affected by this transform.
+      affectedContainers.forEach((container) => {
+        for (let i = 0; i < container.children.length - 1;) {
+          const current = container.children[i];
+          const next = container.children[i + 1];
+          if (current instanceof RTEListBlock &&
+            next instanceof RTEListBlock &&
+            current.type === next.type &&
+            this.haveSameListAnnotations(current, next) &&
+            convertedRootLists.has(current) &&
+            convertedRootLists.has(next)) {
+            current.apply(new AppendChildrenAction([...next.children]));
+            container.apply(new RemoveChildrenAction(next));
+            convertedRootLists.delete(next);
+          }
+          else {
+            i++;
+          }
+        }
+      });
+      selectedBlocks.forEach((block) => block.children.map((node) => node.apply(new SyncUpSelectionAction())));
+      return;
+    }
+    const bulletList = this.createListFromSource(rootContent, target, action.listType);
+    const targetContainer = target.parent;
+    if (isSameList) {
+      // Select one or more list items belonging to the same list, and all items in this list should be updated
+      bulletList.apply(new AppendChildrenAction(target.children));
+      targetContainer.apply(new InsertChildrenAfterAction(target, bulletList));
+      targetContainer.apply(new RemoveChildrenAction(target));
+      selectedBlocks.forEach((block) => block.children.map((node) => node.apply(new SyncUpSelectionAction())));
+    }
+    else {
+      const mixedSelection = normalizeMixedListSelection(action.selectedBlocks, action.listType);
+      const listItems = mixedSelection.map((block) => rootContent.toListItem(block));
+      bulletList.apply(new AppendChildrenAction(listItems));
+      targetContainer.apply(new InsertChildrenAfterAction(target, bulletList));
+      mixedSelection.forEach((block) => {
+        block.parent.apply(new RemoveChildrenAction(block));
+      });
+      if (target.children.length === 0) {
+        targetContainer.apply(new RemoveChildrenAction(target));
       }
     }
   }
   /**
-   * Determines if a given node is the first node within the current state.
+   * Convert a single list's type in place, preserving its items and their nested
+   * structure. Root lists are swapped in the content children; nested lists are
+   * swapped inside their parent item's nestList.
    *
-   * @param {RTENode} currentNode - An object representing a node in a rich text editor (RTE).
-   * @returns {boolean} True or false;
+   * @param {RTEListBlock} list - The list whose type should be converted.
+   * @param {RTEListBlock['type']} listType - The target list type.
    */
-  isContentFirstNode(currentNode) {
-    const currentBlock = currentNode.parent;
-    const currentIndex = currentBlock.children.indexOf(currentNode);
-    const parent = currentBlock.parent;
-    if (currentBlock.isListItemBlock()) {
-      const listParent = parent.parent;
-      return (currentIndex === 0 &&
-        Array.isArray(parent.children) &&
-        parent.children[0] === currentBlock &&
-        listParent['type'] !== 'list-item' &&
-        Array.isArray(listParent.children) &&
-        listParent.children[0] === parent);
+  convertListTypeInPlace(list, listType) {
+    var _a;
+    const rootContent = this.getRootContent(list);
+    if (!rootContent) {
+      return;
+    }
+    const parent = list.parent;
+    const newList = this.createListFromSource(rootContent, list, listType);
+    newList.apply(new AppendChildrenAction([...list.children]));
+    if (parent instanceof RTEListItemBlock) {
+      // Adjacent same-type merge is handled automatically by ListItemReplaceNestListStrategy.
+      const newNestList = ((_a = parent.nestList) !== null && _a !== void 0 ? _a : []).map((entry) => entry === list ? newList : entry);
+      parent.apply(new ReplaceNestListAction(newNestList));
     }
     else {
-      return (currentIndex === 0 && Array.isArray(parent.children) && parent.children[0] === currentBlock);
+      parent.apply(new InsertChildrenAfterAction(list, newList));
+      parent.apply(new RemoveChildrenAction(list));
     }
   }
   /**
-   * TODO: The getPreviousBlock add nest list support
-   * This function retrieves the previous block in a rich text editor, considering different scenarios such as being in a bullet list.
+   * Handle the case where selected blocks span multiple nestLists under the same parent item.
+   * Transform each affected list and then merge adjacent same-type lists.
    *
-   * @param {RTEBlock} currentBlock - Used to retrieve the previous block relative to the given `currentBlock` within a rich text editor context.
-   * @returns {Nullable<RTEBlock>} The previous block if existing
+   * @param {TransformListAction} action - The transform action with selection and target list type.
+   * @param {RTEListBlock} target - The nested list where transformation starts.
    */
-  getPreviousBlock(currentBlock) {
+  handleCrossListTransform(action, target) {
+    if (!(target.parent instanceof RTEListItemBlock)) {
+      return;
+    }
+    const rootContent = this.getRootContent(target);
+    if (!rootContent) {
+      return;
+    }
+    const parentListItem = target.parent;
+    const parentNestLists = parentListItem.nestList;
+    const affectedLists = new Set(action.selectedBlocks
+      .filter((block) => block instanceof RTEListItemBlock)
+      .map((block) => block.parent)
+      .filter((list) => parentNestLists.includes(list)));
+    if (!affectedLists.size) {
+      return;
+    }
+    const newNestList = parentNestLists.map((list) => {
+      if (!affectedLists.has(list)) {
+        return list;
+      }
+      const newList = this.createListFromSource(rootContent, list, action.listType);
+      newList.apply(new AppendChildrenAction(list.children));
+      return newList;
+    });
+    // Adjacent same-type merge is handled automatically by ListItemReplaceNestListStrategy.
+    parentListItem.apply(new ReplaceNestListAction(newNestList));
+    action.selectedBlocks.forEach((block) => block.children.map((node) => node.apply(new SyncUpSelectionAction())));
+  }
+  /**
+   * Create a replacement list through the owning content factory while retaining
+   * the source list's container annotations.
+   *
+   * @param {VegaRTEContent} rootContent - Editor content owning the factory.
+   * @param {RTEListBlock} source - List whose annotations should be retained.
+   * @param {RTEListBlock['type']} listType - Replacement list type.
+   * @returns {RTEListBlock} New annotated list shell.
+   */
+  createListFromSource(rootContent, source, listType) {
+    const list = rootContent.createList(listType);
+    this.copyListAnnotations(source, list);
+    return list;
+  }
+}
+
+/**
+ * Action to toggle bullet annotation
+ */
+class TransformParagraphAction extends ModifyContentAction {
+  constructor(selectedBlocks) {
+    super();
+    this.type = ModifyContentActionType.TRANSFORM_PARAGRAPH_BLOCK;
+    this.isFlushable = true;
+    this.selectedBlocks = selectedBlocks;
+  }
+}
+
+/**
+ * HTML Block
+ */
+class RTEHtmlBlock extends RTEBlock {
+  constructor(id, htmlTag) {
+    super(id);
+    this.dtoName = RTEHtmlBlock.dtoName;
+    this.type = 'html-block';
+    this.children = [];
+    this.htmlTag = htmlTag;
+  }
+  /**
+   * Converts a VegaRTEHtmlBlock to an RTEHtmlBlock.
+   *
+   * @param {VegaRTEHtmlBlock} block - The VegaRTEHtmlBlock to convert.
+   * @param {VegaRTETransformOptions} [options] - Optional transformation options.
+   * @returns {RTEHtmlBlock} The converted RTEHtmlBlock.
+   */
+  static from(block, options) {
+    const htmlBlock = new RTEHtmlBlock(block.id, block.htmlTag);
+    const { annotations } = block;
+    if (annotations) {
+      super.convertAnnotationsToMap(htmlBlock.annotationMap, annotations);
+    }
+    htmlBlock.children = this.generateBlockChildren(block.children, options, htmlBlock);
+    return htmlBlock;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    const clonedBlock = new RTEHtmlBlock(this.id, this.htmlTag);
+    clonedBlock.children = this.children.map((child) => child.clone(clonedBlock));
+    clonedBlock.annotationMap = super.cloneAnnotations();
+    clonedBlock.parent = parent;
+    return clonedBlock;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastNode() {
+    return this.children[this.children.length - 1].getLastNode();
+  }
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty() {
+    // Any RTEHtmlBlock — whether void (hr, br), childless (canvas, iframe),
+    // or with children — represents real user content. Only the default empty
+    // text paragraph should make the editor report as empty.
+    return true;
+  }
+  /**
+   * @inheritDoc
+   */
+  toHtml(options) {
+    const BlockTag = this.htmlTag;
+    const attrStr = super.generateAttributeString(options);
+    // Handle void/self-closing tags (hr, input, col, etc.)
+    // Uses HTML5 syntax without self-closing slash for consistency with img and br tags
+    if (HTML_VOID_TAGS.has(this.htmlTag)) {
+      return `<${BlockTag}${attrStr}>`;
+    }
+    // Handle normal tags with children
+    return [
+      `<${BlockTag}${attrStr}>`,
+      this.children.map((block) => block.toHtml(options)).join(''),
+      `</${BlockTag}>`,
+    ].join('');
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: this.type, htmlTag: this.htmlTag, children: this.children.map((child) => child.toJSON()) });
+  }
+}
+RTEHtmlBlock.dtoName = 'RTEHtmlBlock';
+
+/**
+ * Convert the selected list block to paragraph strategy.
+ */
+class ListTransformToParagraphStrategy extends ListAnnotationStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const selectedSegments = this.getSelectedSegments(action.selectedBlocks);
+    if (selectedSegments.length === 0 || !this.hasConsistentTargetAndRoot(selectedSegments, target)) {
+      return;
+    }
+    this.syncSelection(selectedSegments);
+    [...selectedSegments]
+      .reverse()
+      .forEach((segment) => this.transformSegment(segment));
+  }
+  /**
+   * Ensure the action is applied to the first selected item's parent list and
+   * every selected item belongs to the same editor content.
+   *
+   * @param {RTEListItemBlock[][]} selectedSegments - Normalized selection segments.
+   * @param {RTEListBlock} target - List receiving the transform action.
+   * @returns {boolean} Whether the target and root content are consistent.
+   */
+  hasConsistentTargetAndRoot(selectedSegments, target) {
+    if (selectedSegments[0][0].parent !== target) {
+      return false;
+    }
+    const targetRoot = this.getRootContent(target);
+    return Boolean(targetRoot &&
+      selectedSegments.every((segment) => segment.every((item) => this.getRootContent(item) === targetRoot)));
+  }
+  /**
+   * Capture selected text nodes in document order before reverse-order tree
+   * mutations move them into paragraphs.
+   *
+   * @param {RTEListItemBlock[][]} selectedSegments - Normalized selection segments.
+   */
+  syncSelection(selectedSegments) {
+    selectedSegments.forEach((segment) => {
+      segment.forEach((block) => {
+        block.children.forEach((node) => node.apply(new SyncUpSelectionAction()));
+      });
+    });
+  }
+  /**
+   * Transform one normalized segment without recursively dispatching another
+   * flushable action.
+   *
+   * @param {RTEListItemBlock[]} segment - Contiguous items sharing one parent list.
+   */
+  transformSegment(segment) {
+    const segmentTarget = segment[0].parent;
+    const normalizedAction = new TransformParagraphAction(segment);
+    if (segmentTarget.parent instanceof RTEListItemBlock) {
+      this.handleNestedListCase(normalizedAction, segmentTarget);
+      return;
+    }
+    this.handleRootListCase(normalizedAction, segmentTarget);
+  }
+  /**
+   * Handle the case where the target list is at root level (parent is VegaRTEContent).
+   *
+   * @param {TransformParagraphAction} action - The paragraph transform action.
+   * @param {RTEListBlock} target - The root list being transformed.
+   */
+  handleRootListCase(action, target) {
+    // handleAction validates that the target belongs to an editor content root.
+    const rootContent = this.getRootContent(target);
+    let isSelectedFirstBlock = false;
+    let isSelectedLastBlock = false;
+    const selectedBlocks = action.selectedBlocks;
+    // Build an operation-local insertion sequence. Paragraphs are merge
+    // boundaries; only consecutive same-type promoted lists are merged.
+    const insertionBlocks = [];
+    selectedBlocks.forEach((block) => {
+      var _a;
+      if (block === target.children[0])
+        isSelectedFirstBlock = true;
+      if (block === target.children[target.children.length - 1])
+        isSelectedLastBlock = true;
+      insertionBlocks.push(this.toParagraph(block));
+      for (const nestList of (_a = block.nestList) !== null && _a !== void 0 ? _a : []) {
+        this.appendListBlock(insertionBlocks, nestList);
+      }
+    });
+    if (isSelectedFirstBlock) {
+      target.parent.apply(new InsertChildrenBeforeAction(target, ...insertionBlocks));
+    }
+    else if (isSelectedLastBlock) {
+      target.parent.apply(new InsertChildrenAfterAction(target, ...insertionBlocks));
+    }
+    else {
+      const startIndex = target.children.indexOf(selectedBlocks[0]);
+      const lastIndex = target.children.indexOf(selectedBlocks[selectedBlocks.length - 1]);
+      const firstBulletList = this.createListFromSource(rootContent, target);
+      firstBulletList.apply(new AppendChildrenAction(target.children.slice(0, startIndex)));
+      const lastBulletList = this.createListFromSource(rootContent, target);
+      lastBulletList.apply(new AppendChildrenAction(target.children.slice(lastIndex + 1)));
+      // Merge last insertionBlock with lastBulletList if same type
+      const lastInsertion = insertionBlocks[insertionBlocks.length - 1];
+      if (lastInsertion instanceof RTEListBlock &&
+        lastBulletList.children.length > 0 &&
+        lastInsertion.type === lastBulletList.type &&
+        this.haveSameListAnnotations(lastInsertion, lastBulletList)) {
+        lastInsertion.apply(new AppendChildrenAction(lastBulletList.children));
+        target.parent.apply(new InsertChildrenBeforeAction(target, firstBulletList, ...insertionBlocks));
+      }
+      else {
+        target.parent.apply(new InsertChildrenBeforeAction(target, firstBulletList, ...insertionBlocks, lastBulletList));
+      }
+      target.parent.apply(new RemoveChildrenAction(target));
+    }
+    selectedBlocks.map((block) => {
+      // Clear nestList before removal to prevent ListRemoveListItemStrategy
+      // from promoting the same nested lists a second time.
+      block.nestList = [];
+      target.apply(new RemoveChildrenAction(block));
+    });
+    if (target.children.length === 0) {
+      target.parent.apply(new RemoveChildrenAction(target));
+    }
+    else if (isSelectedFirstBlock) {
+      // When removing the first item(s), a promoted same-type nestList (last
+      // insertionBlock) ends up immediately before the remaining target. Merge
+      // them so the user doesn't see two adjacent same-type lists.
+      const lastInserted = insertionBlocks[insertionBlocks.length - 1];
+      if (lastInserted instanceof RTEListBlock &&
+        lastInserted.type === target.type &&
+        this.haveSameListAnnotations(lastInserted, target)) {
+        lastInserted.apply(new AppendChildrenAction([...target.children]));
+        target.parent.apply(new RemoveChildrenAction(target));
+      }
+    }
+  }
+  /**
+   * Handle the case where the target list is nested (parent is RTEListItemBlock).
+   *
+   * Algorithm:
+   * 1. Build the ancestor path from root list down to the target nested list.
+   * 2. At each level on the path, collect "trailing" items (items after the ancestor).
+   * 3. Trim each list along the path to keep only the "before" portion.
+   * 4. Collect trailing items from all levels + selected item's own nestList children.
+   * 5. Group trailing items into lists by consecutive type.
+   * 6. Insert into content: [before-root-list, paragraphs, ...after-lists].
+   *
+   * @param {TransformParagraphAction} action - The paragraph transform action.
+   * @param {RTEListBlock} target - The nested list being transformed.
+   */
+  handleNestedListCase(action, target) {
+    const selectedBlocks = action.selectedBlocks;
+    const rootContent = this.getRootContent(target);
+    const selectedItem = selectedBlocks[0];
+    const selectedIndex = target.children.indexOf(selectedItem);
+    // Emit each selected item as paragraph + its own nested lists so that
+    // selecting multiple levels never moves a child list past another paragraph.
+    const insertions = [];
+    selectedBlocks.forEach((block) => {
+      var _a;
+      insertions.push(this.toParagraph(block));
+      for (const nestList of (_a = block.nestList) !== null && _a !== void 0 ? _a : []) {
+        this.appendListBlock(insertions, nestList);
+      }
+    });
+    const lastSelectedIndex = target.children.indexOf(selectedBlocks[selectedBlocks.length - 1]);
+    // Collect trailing items from the nested list (items AFTER the last selected)
+    const nestedTrailingItems = target.children.slice(lastSelectedIndex + 1);
+    const ancestorPath = [];
+    let currentList = target;
+    while (currentList.parent instanceof RTEListItemBlock) {
+      const parentItem = currentList.parent;
+      const grandParentList = parentItem.parent;
+      const ancestorIndex = grandParentList.children.indexOf(parentItem);
+      // Collect nestLists of parentItem that are AFTER currentList
+      const parentNestLists = parentItem.nestList;
+      const nestListIndex = parentNestLists.indexOf(currentList);
+      const trailingNestLists = parentNestLists.slice(nestListIndex + 1);
+      ancestorPath.push({ list: grandParentList, ancestorIndex, trailingNestLists });
+      currentList = grandParentList;
+    }
+    // currentList is now the root-level list
+    const rootList = currentList;
+    const rootContainer = rootList.parent;
+    const trailingGroups = [];
+    // 1. Trailing items from the target nested list (same type as target)
+    if (nestedTrailingItems.length > 0) {
+      trailingGroups.push({ items: nestedTrailingItems, sourceList: target });
+    }
+    // 2. Trailing nestLists from ancestors (innermost to outermost)
+    // 3. Trailing items from each ancestor level's list
+    for (const level of ancestorPath) {
+      // Trailing nestLists from the ancestor item
+      for (const trailingNest of level.trailingNestLists) {
+        if (trailingNest.children.length > 0) {
+          trailingGroups.push({ items: [...trailingNest.children], sourceList: trailingNest });
+        }
+      }
+      // Trailing items from ancestor's list (items after the ancestor item)
+      const trailingFromLevel = level.list.children.slice(level.ancestorIndex + 1);
+      if (trailingFromLevel.length > 0) {
+        trailingGroups.push({ items: trailingFromLevel, sourceList: level.list });
+      }
+    }
+    // Merge only groups whose list type and container annotations match. Different
+    // class/style/attribute boundaries must survive the structural reconstruction.
+    const mergedGroups = [];
+    for (const group of trailingGroups) {
+      const prev = mergedGroups[mergedGroups.length - 1];
+      if (prev &&
+        prev.sourceList.type === group.sourceList.type &&
+        this.haveSameListAnnotations(prev.sourceList, group.sourceList)) {
+        prev.items.push(...group.items);
+      }
+      else {
+        mergedGroups.push({ items: [...group.items], sourceList: group.sourceList });
+      }
+    }
+    // Build the "after" lists
+    const afterLists = mergedGroups.map((group) => {
+      const newList = this.createListFromSource(rootContent, group.sourceList);
+      newList.apply(new AppendChildrenAction(group.items));
+      return newList;
+    });
+    afterLists.forEach((list) => this.appendListBlock(insertions, list));
+    // --- Now trim the "before" portion ---
+    // Trim target nested list: keep only items before selected
+    target.children = target.children.slice(0, selectedIndex);
+    // Clean up the target nested list's parent item's nestList
+    const targetParentItem = target.parent;
+    const targetParentNestLists = targetParentItem.nestList;
+    const targetNestIndex = targetParentNestLists.indexOf(target);
+    // Keep only nestLists up to and including the target (remove trailing ones we already collected)
+    let trimmedNestList = targetParentNestLists.slice(0, targetNestIndex + 1);
+    // If target is now empty, remove it too
+    if (target.children.length === 0) {
+      trimmedNestList = trimmedNestList.filter((l) => l !== target);
+    }
+    targetParentItem.apply(new ReplaceNestListAction(trimmedNestList));
+    // Trim ancestor levels: remove trailing items and trailing nestLists
+    for (const level of ancestorPath) {
+      // Remove trailing items from the ancestor's list
+      level.list.children = level.list.children.slice(0, level.ancestorIndex + 1);
+      // Remove trailing nestLists from the ancestor item
+      if (level.trailingNestLists.length > 0) {
+        const ancestorItem = level.list.children[level.ancestorIndex];
+        const ancestorNestLists = ancestorItem.nestList;
+        const firstTrailingNestIndex = ancestorNestLists.indexOf(level.trailingNestLists[0]);
+        if (firstTrailingNestIndex >= 0) {
+          const keptNestLists = ancestorNestLists.slice(0, firstTrailingNestIndex);
+          ancestorItem.apply(new ReplaceNestListAction(keptNestLists));
+        }
+      }
+    }
+    rootContainer.apply(new InsertChildrenAfterAction(rootList, ...insertions));
+  }
+  /**
+   * Normalize selected items into document order and split them into contiguous
+   * segments that share the same immediate parent list. Unlike Shift+Tab, the
+   * toolbar action keeps selected descendants so every selected item becomes a
+   * paragraph.
+   *
+   * @param {RTEBlock[]} selectedBlocks - Raw selected blocks.
+   * @returns {RTEListItemBlock[][]} Parent-based contiguous selection segments.
+   */
+  getSelectedSegments(selectedBlocks) {
+    const selectedItems = Array.from(new Set(selectedBlocks.filter((block) => block instanceof RTEListItemBlock)))
+      .map((item) => ({ item, path: this.getStructuralPath(item) }))
+      .filter((entry) => entry.path !== null)
+      .sort((a, b) => this.compareStructuralPaths(a.path, b.path))
+      .map((entry) => entry.item);
+    const segments = [];
+    for (const item of selectedItems) {
+      const segment = segments[segments.length - 1];
+      const previousItem = segment === null || segment === void 0 ? void 0 : segment[segment.length - 1];
+      const isContiguousSibling = (previousItem === null || previousItem === void 0 ? void 0 : previousItem.parent) === item.parent &&
+        item.parent.children.indexOf(item) - item.parent.children.indexOf(previousItem) === 1;
+      if (isContiguousSibling) {
+        segment.push(item);
+      }
+      else {
+        segments.push([item]);
+      }
+    }
+    return segments;
+  }
+  /**
+   * Resolve a list item's structural document path, including the positions of
+   * root lists, owning list items, nested lists, and the item itself.
+   *
+   * @param {RTEListItemBlock} item - Selected list item.
+   * @returns {number[] | null} Structural path, or null for a detached item.
+   */
+  getStructuralPath(item) {
+    var _a;
+    const path = [];
+    const visitedLists = new Set();
+    let currentItem = item;
+    let currentList = item.parent;
+    while (!visitedLists.has(currentList)) {
+      visitedLists.add(currentList);
+      const itemIndex = currentList.children.indexOf(currentItem);
+      if (itemIndex < 0) {
+        return null;
+      }
+      path.unshift(itemIndex);
+      if (currentList.parent.dtoName === 'VegaRTEContent' ||
+        currentList.parent.dtoName === 'RTEHtmlBlock') {
+        const containerPath = this.getContainerPath(currentList);
+        return containerPath ? [...containerPath, ...path] : null;
+      }
+      if (!(currentList.parent instanceof RTEListItemBlock)) {
+        return null;
+      }
+      const ownerItem = currentList.parent;
+      const nestListIndex = ((_a = ownerItem.nestList) !== null && _a !== void 0 ? _a : []).indexOf(currentList);
+      if (nestListIndex < 0) {
+        return null;
+      }
+      path.unshift(nestListIndex);
+      currentItem = ownerItem;
+      currentList = ownerItem.parent;
+    }
+    return null;
+  }
+  /**
+   * Resolve a root list's path through zero or more HTML containers to the
+   * editor content.
+   *
+   * @param {RTEListBlock} rootList - List whose parent is a content container.
+   * @returns {number[] | null} Container path, or null for detached/cyclic ownership.
+   */
+  getContainerPath(rootList) {
+    const path = [];
+    const visitedContainers = new Set();
+    let child = rootList;
+    let container = rootList.parent;
+    while (container instanceof RTEHtmlBlock) {
+      if (visitedContainers.has(container)) {
+        return null;
+      }
+      visitedContainers.add(container);
+      const childIndex = container.children.indexOf(child);
+      if (childIndex < 0) {
+        return null;
+      }
+      path.unshift(childIndex);
+      child = container;
+      container = container.parent;
+    }
+    const rootChildIndex = container.children.indexOf(child);
+    if (rootChildIndex < 0) {
+      return null;
+    }
+    path.unshift(rootChildIndex);
+    return path;
+  }
+  /**
+   * Compare two structural paths in document order.
+   *
+   * @param {number[]} firstPath - First structural path.
+   * @param {number[]} secondPath - Second structural path.
+   * @returns {number} Relative document order.
+   */
+  compareStructuralPaths(firstPath, secondPath) {
+    const length = Math.min(firstPath.length, secondPath.length);
+    for (let index = 0; index < length; index++) {
+      if (firstPath[index] !== secondPath[index]) {
+        return firstPath[index] - secondPath[index];
+      }
+    }
+    return firstPath.length - secondPath.length;
+  }
+  /**
+   * Append a list to an operation-local block sequence, merging only with the
+   * immediately preceding same-type list in that sequence.
+   *
+   * @param {RTEBlock[]} blocks - Operation-local output sequence.
+   * @param {RTEListBlock} list - List to append or merge.
+   */
+  appendListBlock(blocks, list) {
+    const previousBlock = blocks[blocks.length - 1];
+    if (previousBlock instanceof RTEListBlock &&
+      previousBlock.type === list.type &&
+      this.haveSameListAnnotations(previousBlock, list)) {
+      previousBlock.apply(new AppendChildrenAction([...list.children]));
+      return;
+    }
+    blocks.push(list);
+  }
+  /**
+   * Create a list through the content factory and retain the source list's
+   * container annotations when a structural split requires a new list block.
+   *
+   * @param {VegaRTEContent} rootContent - Editor content that owns the factory.
+   * @param {RTEListBlock} source - List whose type and annotations should be retained.
+   * @returns {RTEListBlock} Newly created list shell.
+   */
+  createListFromSource(rootContent, source) {
+    const list = rootContent.createList(source.type);
+    this.copyListAnnotations(source, list);
+    return list;
+  }
+  /**
+   * Converts a RTEListItemBlock to a RTETextBlock representing a paragraph.
+   *
+   * @param {RTEListItemBlock} block - The block that will be covered
+   * @returns {RTETextBlock} Returns a `RTETextBlock`.
+   */
+  toParagraph(block) {
+    const textBlock = new RTETextBlock(generateUUID(), 'paragraph');
+    textBlock.apply(new AppendChildrenAction(block['children']));
+    textBlock['annotationMap'] = block['annotationMap'];
+    return textBlock;
+  }
+}
+
+/**
+ * Insert image to list block strategy.
+ */
+class ListInsertImageStrategy extends ActionHandleStrategy {
+  /**
+   * Insert image block at behind of the list item block.
+   *
+   * @param {InsertImageToBlockAction} action - The insert image action instance.
+   * @param {RTEListBlock} target - The list block.
+   */
+  handleAction(action, target) {
+    const imageBlock = action.imageBlockToBeInserted;
+    if (target.parent['type'] !== 'list-item') {
+      target.parent.apply(new InsertChildrenAfterAction(target, imageBlock));
+    }
+    else {
+      target.parent.apply(action);
+    }
+  }
+}
+
+/**
+ * Shared base strategy for list-item operations that require ordered contiguous
+ * item selection within the same target list.
+ */
+class AbstractListItemsStrategy extends ActionHandleStrategy {
+  /**
+   * Returns selected list items ordered by their position in target and validated
+   * as a contiguous range. Returns an empty array when selection is invalid.
+   *
+   * @param {RTEListBlock} target - The target list block containing selected items.
+   * @param {RTEListItemBlock[]} selectedBlocks - Selected list items from action payload.
+   * @returns {RTEListItemBlock[]} Ordered contiguous selected items, or empty array.
+   */
+  getOrderedContiguousItems(target, selectedBlocks) {
+    const orderedItems = [...selectedBlocks].sort((a, b) => target.children.indexOf(a) - target.children.indexOf(b));
+    const startIndex = target.children.indexOf(orderedItems[0]);
+    if (startIndex < 0) {
+      return [];
+    }
+    return target.children
+      .slice(startIndex, startIndex + orderedItems.length)
+      .every((item, index) => item === orderedItems[index])
+      ? orderedItems
+      : [];
+  }
+}
+
+/**
+ * Move selected list items into a nested list under the previous sibling.
+ */
+class ListNestItemsStrategy extends AbstractListItemsStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    var _a, _b;
+    const selectedItems = this.getOrderedContiguousItems(target, action.selectedBlocks);
+    if (!selectedItems.length) {
+      return;
+    }
+    const startIndex = target.children.indexOf(selectedItems[0]);
+    if (startIndex <= 0) {
+      return;
+    }
+    const previousSibling = target.children[startIndex - 1];
+    const selectedItemSet = new Set(selectedItems);
+    // Tab behavior intentionally keeps using the last nested list entry if present,
+    // even when mixed nested-list types exist, to preserve current behavior.
+    // This also matches the behavior of other rich text editors, especially CKEditor.
+    let nestedList = (_a = previousSibling.nestList) === null || _a === void 0 ? void 0 : _a[previousSibling.nestList.length - 1];
+    if (!nestedList) {
+      nestedList = new RTEListBlock(generateUUID(), target.type);
+      previousSibling.apply(new ReplaceNestListAction([...((_b = previousSibling.nestList) !== null && _b !== void 0 ? _b : []), nestedList]));
+    }
+    target.children = target.children.filter((item) => !selectedItemSet.has(item));
+    nestedList.children = nestedList.children.concat(selectedItems);
+    selectedItems.forEach((item) => {
+      var _a;
+      item.parent = nestedList;
+      if ((_a = item.nestList) === null || _a === void 0 ? void 0 : _a.length) {
+        this.unifyDescendantNestLists(item, item.nestList[0].type);
+      }
+      item.children.forEach((node) => node.apply(new SyncUpSelectionAction()));
+    });
+  }
+  /**
+   * Recursively unify all nestLists of a list item (and its descendants) to the given type.
+   * Adjacent same-type merge is handled automatically by ListItemReplaceNestListStrategy
+   * when ReplaceNestListAction is applied, so this method only needs to set the type.
+   *
+   * @param {RTEListItemBlock} item - The list item whose descendants should be normalized.
+   * @param {RTEListBlock['type']} targetType - The target list type used for normalization.
+   */
+  unifyDescendantNestLists(item, targetType) {
+    var _a;
+    if (!((_a = item.nestList) === null || _a === void 0 ? void 0 : _a.length)) {
+      return;
+    }
+    let typeChanged = false;
+    for (const list of item.nestList) {
+      if (list.type !== targetType) {
+        list.type = targetType;
+        typeChanged = true;
+      }
+      // Recursively unify children
+      for (const child of list.children) {
+        this.unifyDescendantNestLists(child, targetType);
+      }
+    }
+    // If any type was changed, re-apply through ReplaceNestListAction so that the
+    // centralized normalize in ListItemReplaceNestListStrategy merges adjacent same-type entries.
+    if (typeChanged) {
+      item.apply(new ReplaceNestListAction([...item.nestList]));
+    }
+  }
+}
+
+/**
+ * Delete the nest list block action
+ *
+ * @example needRemovedNestList.parent.apply(new RemoveNestListAction(needRemovedNestList))
+ */
+class RemoveNestListAction extends ModifyContentAction {
+  constructor(childList) {
+    super();
+    this.type = ModifyContentActionType.DELETE_NEST_LIST;
+    this.nestListBlockToBeRemoved = childList;
+  }
+}
+
+/**
+ * Promote selected nested list items one level up.
+ */
+class ListUnnestItemsStrategy extends AbstractListItemsStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    var _a;
+    const selectedItems = this.getOrderedContiguousItems(target, action.selectedBlocks);
+    const parentListParent = target.parent;
+    if (!selectedItems.length || !(parentListParent instanceof RTEListItemBlock)) {
+      return;
+    }
+    const selectedStartIndex = target.children.indexOf(selectedItems[0]);
+    const selectedEndIndex = target.children.indexOf(selectedItems[selectedItems.length - 1]);
+    if (selectedStartIndex < 0 || selectedEndIndex < selectedStartIndex) {
+      return;
+    }
+    const parentListItem = parentListParent;
+    const grandParentList = parentListItem.parent;
+    const insertAfterIndex = grandParentList.children.indexOf(parentListItem);
+    if (insertAfterIndex < 0) {
+      return;
+    }
+    const trailingSiblingItems = target.children.slice(selectedEndIndex + 1);
+    const selectedItemSet = new Set(selectedItems);
+    target.children = target.children.filter((item) => !selectedItemSet.has(item));
+    grandParentList.children = [
+      ...grandParentList.children.slice(0, insertAfterIndex + 1),
+      ...selectedItems,
+      ...grandParentList.children.slice(insertAfterIndex + 1),
+    ];
+    selectedItems.forEach((item) => {
+      item.parent = grandParentList;
+      item.children.forEach((node) => node.apply(new SyncUpSelectionAction()));
+    });
+    if (trailingSiblingItems.length > 0) {
+      const trailingSiblingSet = new Set(trailingSiblingItems);
+      target.children = target.children.filter((item) => !trailingSiblingSet.has(item));
+      const newParentItem = selectedItems[selectedItems.length - 1];
+      let nestedList = (_a = newParentItem.nestList) === null || _a === void 0 ? void 0 : _a[newParentItem.nestList.length - 1];
+      // Shift+Tab follows same-type guard: when the last nested list has a
+      // different type, create a new child list of target.type instead of merging.
+      if (nestedList && nestedList.type !== target.type) {
+        nestedList = null;
+      }
+      if (!nestedList) {
+        nestedList = new RTEListBlock(generateUUID(), target.type);
+        const existingNestLists = Array.isArray(newParentItem.nestList)
+          ? newParentItem.nestList
+          : [];
+        newParentItem.apply(new ReplaceNestListAction([...existingNestLists, nestedList]));
+      }
+      nestedList.children = nestedList.children.concat(trailingSiblingItems);
+      trailingSiblingItems.forEach((item) => {
+        item.parent = nestedList;
+      });
+    }
+    // Lists after target are visually after every target item. Once selected items
+    // move above their former parent, transfer those later branches to the last
+    // selected item even when target still contains leading items; otherwise the
+    // branches render before the promoted selection and document order changes.
+    const trailingNestLists = this.collectTrailingNestLists(parentListItem, target);
+    if (trailingNestLists.length > 0) {
+      const lastSelected = selectedItems[selectedItems.length - 1];
+      const existingNest = Array.isArray(lastSelected.nestList)
+        ? lastSelected.nestList
+        : [];
+      lastSelected.apply(new ReplaceNestListAction([...existingNest, ...trailingNestLists]));
+    }
+    if (target.children.length === 0) {
+      parentListItem.apply(new RemoveNestListAction(target));
+    }
+  }
+  /**
+   * Collect and remove nestList entries that appear after the given target list
+   * in the parent item's nestList array. These trailing entries need to be
+   * transferred to the unnested item to preserve visual document order.
+   *
+   * @param {RTEListItemBlock} parentListItem - The list item owning the nestList.
+   * @param {RTEListBlock} target - The list being removed (used as the reference point).
+   * @returns {RTEListBlock[]} The trailing nestList entries (already removed from parentListItem).
+   */
+  collectTrailingNestLists(parentListItem, target) {
+    var _a;
+    const nestLists = (_a = parentListItem.nestList) !== null && _a !== void 0 ? _a : [];
+    const targetIndex = nestLists.indexOf(target);
+    if (targetIndex < 0 || targetIndex >= nestLists.length - 1) {
+      return [];
+    }
+    const trailing = nestLists.slice(targetIndex + 1);
+    // Keep only entries up to and including target (target will be removed separately).
+    parentListItem.apply(new ReplaceNestListAction(nestLists.slice(0, targetIndex + 1)));
+    return trailing;
+  }
+}
+
+/**
+ * List annotation
+ */
+class ListAnnotation extends BlockAnnotation {
+  constructor() {
+    super(...arguments);
+    this.type = BlockAnnotationTypeEnum.LIST;
+  }
+  /**
+   * Get the default standalone styles for a list block.
+   *
+   * @returns {AnnotationStyle} The default styles.
+   */
+  static getDefaultStyles() {
+    return {
+      paddingLeft: '8px',
+      marginLeft: '16px',
+    };
+  }
+  /**
+   * Get the default standalone styles for a list block's item marker
+   * (`li::marker`). Capping the marker font-size keeps bullets/numbers
+   * at a normal size when list items are styled as title/subtitle.
+   *
+   * @returns {AnnotationStyle} The default marker styles.
+   */
+  static getDefaultMarkerStyles() {
+    return {
+      fontSize: '16px',
+    };
+  }
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return ListAnnotation.getDefaultStyles();
+  }
+  /**
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return 'v-rte--list';
+  }
+  /**
+   * @inheritDoc
+   */
+  clone() {
+    return new ListAnnotation();
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return undefined;
+  }
+}
+
+/**
+ * List block.
+ *
+ * Bidirectional nesting contract:
+ * - Every child list item must have item.parent === this list block.
+ * - If this list block is nested, its parent must be a list item and that
+ *   list item keeps this block in listItem.nestList.
+ */
+class RTEListBlock extends RTEBlock {
+  constructor(id, type, options) {
+    super(id);
+    this.dtoName = RTEListBlock.dtoName;
+    this.type = 'bullet-list';
+    this.children = [];
+    this.type = type;
+    const { autoMatchFormat } = options || { autoMatchFormat: true };
+    if (autoMatchFormat) {
+      this.annotationMap.set(BlockAnnotationTypeEnum.LIST, new ListAnnotation());
+    }
+  }
+  /**
+   * Converts a VegaRTEListBlock object to an RTEListBlock
+   *
+   * @param {VegaRTEListBlock} block - Converts a `VegaRTEListBlock` object into an `RTEListBlock`.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
+   * @returns {RTEListBlock} Return an instance of `RTEListBlock`
+   */
+  static from(block, options = { autoMatchFormat: true }) {
+    const listBlock = new RTEListBlock(block.id, block.type, options);
+    const { annotations } = block;
+    if (annotations) {
+      Object.entries(annotations).forEach(([type, value]) => {
+        const item = this.createAnnotationEntity(type, value);
+        if (isNonNullable(item)) {
+          listBlock.annotationMap.set(...item);
+        }
+      });
+    }
+    listBlock.children = block.blocks.map((item) => {
+      const listItemBlock = RTEListItemBlock.from(item, options);
+      listItemBlock.parent = listBlock;
+      return listItemBlock;
+    });
+    return listBlock;
+  }
+  /**
+   * 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 'customAttribute':
+        return CustomAttributeAnnotation.from(value);
+      case 'customClass':
+        return CustomClassAnnotation.from(value);
+      case 'customStyle':
+        return CustomStyleAnnotation.from(value);
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: this.type, blocks: this.children.map((block) => block.toJSON()) });
+  }
+  /**
+   * @inheritDoc
+   */
+  toHtml(options) {
+    const BlockTag = this.getBlockTag();
+    const attrStr = super.generateAttributeString(options);
+    return [
+      `<${BlockTag}${attrStr}>`,
+      this.children.map((block) => block.toHtml(options)).join(''),
+      `</${BlockTag}>`,
+    ].join('');
+  }
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty() {
+    return this.children.length > 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastNode() {
+    return this.children[this.children.length - 1].getLastNode();
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    const clonedListBlock = new RTEListBlock(this.id, this.type);
+    clonedListBlock.children = this.children.map((item) => item.clone(clonedListBlock));
+    clonedListBlock.annotationMap = super.cloneAnnotations();
+    clonedListBlock.parent = parent;
+    return clonedListBlock;
+  }
+  /**
+   * Returns the block tag based on the type of the list block.
+   *
+   * @returns {RTEListBlockTagType} - The block tag for the list block, either 'ol' or 'ul'.
+   */
+  getBlockTag() {
+    return this.type === 'number-list' ? 'ol' : 'ul';
+  }
+}
+(() => {
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_LIST_BLOCK, RTEListBlock.name, new ListTransformToListStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_PARAGRAPH_BLOCK, RTEListBlock.name, new ListTransformToParagraphStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEListBlock.name, new ListInsertImageStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.NEST_LIST_ITEMS, RTEListBlock.name, new ListNestItemsStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.UNNEST_LIST_ITEMS, RTEListBlock.name, new ListUnnestItemsStrategy());
+})();
+RTEListBlock.dtoName = 'RTEListBlock';
+
+/**
+ * The delete node content contains some common functions that used for image block delete the image node or text block delete text node.
+ */
+class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
+  /**
+   * Returns the previous node relative to the current node in a rich text editor structure.
+   *
+   * @param {RTENode} currentNode - An object of type `RTENode`.
+   * @returns {Nullable<RTENode>} the previous block last node
+   */
+  getPreviousNode(currentNode) {
+    var _a;
+    const currentBlock = currentNode.parent;
+    const currentIndex = currentBlock.children.indexOf(currentNode);
+    if (currentIndex > 0) {
+      return currentBlock.children[currentIndex - 1];
+    }
+    else if (currentBlock.parent) {
+      // Special case: cursor is at the start of the first item in a nested list.
+      // Return the last direct text node of the grandparent list item so that
+      // Backspace correctly merges the nested item into the parent item rather
+      // than descending into the nested list's own descendants.
+      if (currentBlock.isListItemBlock() &&
+        currentBlock.parent.children.indexOf(currentBlock) === 0 &&
+        currentBlock.parent.parent instanceof RTEListItemBlock) {
+        const grandParentItem = currentBlock.parent.parent;
+        const nestedListIndex = ((_a = grandParentItem.nestList) !== null && _a !== void 0 ? _a : []).indexOf(currentBlock.parent);
+        if (nestedListIndex !== 0) {
+          const previousBlock = this.getPreviousBlock(currentBlock);
+          return previousBlock ? this.getBlockLastNode(previousBlock) : null;
+        }
+        const textNodes = grandParentItem.children;
+        return textNodes.length > 0 ? textNodes[textNodes.length - 1] : null;
+      }
+      const previousBlock = this.getPreviousBlock(currentBlock);
+      if (previousBlock) {
+        return this.getBlockLastNode(previousBlock);
+      }
+    }
+  }
+  /**
+   * Returns the next node relative to the current node in a rich text editor structure.
+   *
+   * @param {RTENode} currentNode - An object of type `RTENode`.
+   * @returns {Nullable<RTENode>} the next block first node
+   */
+  getNextNode(currentNode) {
+    const currentBlock = currentNode.parent;
+    const currentIndex = currentBlock.children.indexOf(currentNode);
+    if (currentBlock.children[currentIndex + 1]) {
+      return currentBlock.children[currentIndex + 1];
+    }
+    else if (currentBlock.parent) {
+      const nextBlock = this.getNextBlock(currentBlock);
+      if (nextBlock) {
+        return this.getBlockFirstNode(nextBlock);
+      }
+    }
+  }
+  /**
+   * Determines if a given node is the first node within the current state.
+   *
+   * @param {RTENode} currentNode - An object representing a node in a rich text editor (RTE).
+   * @returns {boolean} True or false;
+   */
+  isContentFirstNode(currentNode) {
+    const currentBlock = currentNode.parent;
+    const currentIndex = currentBlock.children.indexOf(currentNode);
+    const parent = currentBlock.parent;
+    if (currentBlock.isListItemBlock()) {
+      const listParent = parent.parent;
+      return (currentIndex === 0 &&
+        Array.isArray(parent.children) &&
+        parent.children[0] === currentBlock &&
+        listParent['type'] !== 'list-item' &&
+        Array.isArray(listParent.children) &&
+        listParent.children[0] === parent);
+    }
+    else {
+      return (currentIndex === 0 && Array.isArray(parent.children) && parent.children[0] === currentBlock);
+    }
+  }
+  /**
+   * TODO: The getPreviousBlock add nest list support
+   * This function retrieves the previous block in a rich text editor, considering different scenarios such as being in a bullet list.
+   *
+   * @param {RTEBlock} currentBlock - Used to retrieve the previous block relative to the given `currentBlock` within a rich text editor context.
+   * @returns {Nullable<RTEBlock>} The previous block if existing
+   */
+  getPreviousBlock(currentBlock) {
+    var _a;
+    if (currentBlock.parent instanceof RTEListItemBlock) {
+      const nestedLists = (_a = currentBlock.parent.nestList) !== null && _a !== void 0 ? _a : [];
+      const nestedListIndex = nestedLists.indexOf(currentBlock);
+      if (nestedListIndex > 0) {
+        return nestedLists[nestedListIndex - 1];
+      }
+      if (nestedListIndex === 0) {
+        return currentBlock.parent;
+      }
+    }
     if (currentBlock && currentBlock.parent && currentBlock.parent.children) {
       const currentBlockIndex = currentBlock.parent.children.indexOf(currentBlock);
       if (currentBlockIndex > 0) {
@@ -5315,4 +6759,4 @@ class RTECodeBlock extends RTEBlock {
 RTECodeBlock.CODE_BLOCK_PLACEHOLDER_CLASS_NAME = 'code-block-placeholder-element';
 RTECodeBlock.dtoName = 'RTECodeBlock';
 
-export { RTE_DEFAULT_TEXT_COLOR as $, ActionHandleStrategyRegistry as A, BlockAnnotation as B, CommonAnnotationTypeEnum as C, BlockMergeNodesStrategy as D, SyncUpSelectionAction as E, BlockAnnotationTypeEnum as F, CustomClassAnnotation as G, HorizontalAlignmentAnnotationAction as H, InsertChildrenAfterAction as I, NodeAnnotation as J, NodeTypeEnum as K, CommonAnnotation as L, ModifyContentAction as M, NodeAnnotationTypeEnum as N, ReplaceChildNodesAction as O, HTML_VOID_TAGS as P, BlockDeleteNodeContentStrategy as Q, RTETextNode as R, SplitBlockWithNodeAction as S, TextStyleAnnotationAction as T, UpdateTextAction as U, VegaRTEPresetToolbarItems as V, RemoveChildrenStrategy as W, BOLD_FONT_WEIGHT_KEYWORD as X, BOLD_FONT_WEIGHT as Y, createStyleMapFromElement as Z, RTE_TEXT_COLORS as _, RTEBlock as a, ITALIC_FONT_STYLE as a0, STRIKETHROUGH_TEXT_DECORATION as a1, UNDERLINE_TEXT_DECORATION as a2, TextStyleAnnotation as a3, Predicate as a4, HorizontalAlignmentAnnotation as a5, CodeAnnotation as a6, LinkFilterStylesStrategy as a7, CodeBlockFilterStylesStrategy as a8, CodeBlockNodeFilterStylesStrategy as a9, ActionHandlerInterceptorRegistry as aa, CodeLanguage as ab, VegaRTEDefaultTextStyleItems as ac, ZERO_WIDTH_SPACE as ad, LinkAnnotationAction as ae, UpdateCodeBlockAction as af, SelectionChangeAction as ag, TextColorAnnotationAction as ah, VegaRTEOneRowHeightPx as ai, BoldAnnotationAction as aj, ItalicAnnotationAction as ak, UnderlineAnnotationAction as al, BoldAnnotation as am, ClearFormattingAnnotationAction as an, CodeAnnotationAction as ao, StrikethroughAnnotationAction as ap, IndentAnnotationAction as aq, escapeHtml as ar, RTETextBlock as b, RTEAnnotationStyle as c, ActionHandleStrategy as d, AppendChildrenAction as e, RTENode as f, InsertChildrenBeforeAction as g, InternalAnnotationTypeEnum as h, ModifyContentActionType as i, AnnotationAction as j, RemoveChildrenAction as k, CustomAttributeAnnotation as l, RTEDTOClassManager$1 as m, RTEFilterStylesStrategy as n, RTEDecoratorNode as o, RTECodeBlock as p, RTECodeBlockNode as q, CustomStyleAnnotation as r, stateEntityRenderingRegistry as s, RTEFilterStylesStrategyRegistry as t, BlockUpdateTextStyleStrategy as u, BlockUpdateHorizontalAlignmentStrategy as v, BlockInsertLineBreakStrategy as w, BlockInsertLineBreakWithBlocksStrategy as x, BlockSplitWithTextNodeStrategy as y, BlockReplaceNodesStrategy as z };
+export { RTEHtmlBlock as $, ActionHandleStrategyRegistry as A, BlockAnnotation as B, CommonAnnotationTypeEnum as C, BlockReplaceNodesStrategy as D, BlockUpdateHorizontalAlignmentStrategy as E, BlockDeleteNodeContentStrategy as F, RemoveChildrenStrategy as G, HorizontalAlignmentAnnotationAction as H, InsertChildrenAfterAction as I, RemoveNestListAction as J, ReplaceNestListAction as K, RTEListBlock as L, ModifyContentAction as M, NodeAnnotationTypeEnum as N, BOLD_FONT_WEIGHT_KEYWORD as O, BOLD_FONT_WEIGHT as P, createStyleMapFromElement as Q, RTETextNode as R, SplitBlockWithNodeAction as S, RTE_TEXT_COLORS as T, UpdateTextAction as U, VegaRTEPresetToolbarItems as V, RTE_DEFAULT_TEXT_COLOR as W, ITALIC_FONT_STYLE as X, STRIKETHROUGH_TEXT_DECORATION as Y, UNDERLINE_TEXT_DECORATION as Z, TextStyleAnnotation as _, RTEBlock as a, Predicate as a0, ListAnnotation as a1, HorizontalAlignmentAnnotation as a2, CodeAnnotation as a3, LinkFilterStylesStrategy as a4, CodeBlockFilterStylesStrategy as a5, CodeBlockNodeFilterStylesStrategy as a6, SyncUpSelectionAction as a7, ActionHandlerInterceptorRegistry as a8, CodeLanguage as a9, CustomClassAnnotation as aa, VegaRTEDefaultTextStyleItems as ab, ZERO_WIDTH_SPACE as ac, LinkAnnotationAction as ad, UpdateCodeBlockAction as ae, SelectionChangeAction as af, TextColorAnnotationAction as ag, VegaRTEOneRowHeightPx as ah, BoldAnnotationAction as ai, ItalicAnnotationAction as aj, UnderlineAnnotationAction as ak, TextStyleAnnotationAction as al, BoldAnnotation as am, BlockAnnotationTypeEnum as an, ClearFormattingAnnotationAction as ao, CodeAnnotationAction as ap, StrikethroughAnnotationAction as aq, IndentAnnotationAction as ar, TransformParagraphAction as as, escapeHtml as at, RTETextBlock as b, RTEAnnotationStyle as c, ActionHandleStrategy as d, AppendChildrenAction as e, RTENode as f, InsertChildrenBeforeAction as g, InternalAnnotationTypeEnum as h, ModifyContentActionType as i, AnnotationAction as j, RemoveChildrenAction as k, CustomAttributeAnnotation as l, RTEDTOClassManager$1 as m, RTEFilterStylesStrategy as n, RTEDecoratorNode as o, RTECodeBlock as p, RTEListItemBlock as q, RTECodeBlockNode as r, stateEntityRenderingRegistry as s, CustomStyleAnnotation as t, RTEFilterStylesStrategyRegistry as u, NodeAnnotation as v, NodeTypeEnum as w, CommonAnnotation as x, ReplaceChildNodesAction as y, BlockMergeNodesStrategy as z };