@heartlandone/vega 2.94.0 → 2.96.0

package/dist/cjs/{code-block-493c7ce7.js → code-block-4126dc3b.js}

@@ -139,6 +139,8 @@ exports.ModifyContentActionType = void 0;
   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";
@@ -4261,6 +4263,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.
  */
@@ -4272,12 +4305,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));
     });
@@ -4674,78 +4711,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 (typeGuard.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(misc.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(misc.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(exports.ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTEListItemBlock.name, new BlockInsertLineBreakStrategy());
+  ActionHandleStrategyRegistry.register(exports.ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTEListItemBlock.name, new BlockInsertLineBreakWithBlocksStrategy());
+  ActionHandleStrategyRegistry.register(exports.ModifyContentActionType.DELETE_NEST_LIST, RTEListItemBlock.name, new ListItemRemoveNestListStrategy());
+  ActionHandleStrategyRegistry.register(exports.ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTEListItemBlock.name, new BlockSplitWithTextNodeStrategy());
+  ActionHandleStrategyRegistry.register(exports.ModifyContentActionType.REPLACE_CHILD_NODES, RTEListItemBlock.name, new BlockReplaceNodesStrategy());
+  ActionHandleStrategyRegistry.register(exports.ModifyContentActionType.REPLACE_NEST_LIST, RTEListItemBlock.name, new ListItemReplaceNestListStrategy());
+  ActionHandleStrategyRegistry.register(exports.ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTEListItemBlock.name, new BlockMergeNodesStrategy());
+  ActionHandleStrategyRegistry.register(exports.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 = exports.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 = exports.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(misc.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(misc.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 = exports.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(misc.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 = exports.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(exports.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 (typeGuard.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(exports.ModifyContentActionType.TRANSFORM_LIST_BLOCK, RTEListBlock.name, new ListTransformToListStrategy());
+  ActionHandleStrategyRegistry.register(exports.ModifyContentActionType.TRANSFORM_PARAGRAPH_BLOCK, RTEListBlock.name, new ListTransformToParagraphStrategy());
+  ActionHandleStrategyRegistry.register(exports.ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEListBlock.name, new ListInsertImageStrategy());
+  ActionHandleStrategyRegistry.register(exports.ModifyContentActionType.NEST_LIST_ITEMS, RTEListBlock.name, new ListNestItemsStrategy());
+  ActionHandleStrategyRegistry.register(exports.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) {
@@ -5326,13 +6770,9 @@ exports.BOLD_FONT_WEIGHT = BOLD_FONT_WEIGHT;
 exports.BOLD_FONT_WEIGHT_KEYWORD = BOLD_FONT_WEIGHT_KEYWORD;
 exports.BlockAnnotation = BlockAnnotation;
 exports.BlockDeleteNodeContentStrategy = BlockDeleteNodeContentStrategy;
-exports.BlockInsertLineBreakStrategy = BlockInsertLineBreakStrategy;
-exports.BlockInsertLineBreakWithBlocksStrategy = BlockInsertLineBreakWithBlocksStrategy;
 exports.BlockMergeNodesStrategy = BlockMergeNodesStrategy;
 exports.BlockReplaceNodesStrategy = BlockReplaceNodesStrategy;
-exports.BlockSplitWithTextNodeStrategy = BlockSplitWithTextNodeStrategy;
 exports.BlockUpdateHorizontalAlignmentStrategy = BlockUpdateHorizontalAlignmentStrategy;
-exports.BlockUpdateTextStyleStrategy = BlockUpdateTextStyleStrategy;
 exports.BoldAnnotation = BoldAnnotation;
 exports.BoldAnnotationAction = BoldAnnotationAction;
 exports.ClearFormattingAnnotationAction = ClearFormattingAnnotationAction;
@@ -5344,7 +6784,6 @@ exports.CommonAnnotation = CommonAnnotation;
 exports.CustomAttributeAnnotation = CustomAttributeAnnotation;
 exports.CustomClassAnnotation = CustomClassAnnotation;
 exports.CustomStyleAnnotation = CustomStyleAnnotation;
-exports.HTML_VOID_TAGS = HTML_VOID_TAGS;
 exports.HorizontalAlignmentAnnotation = HorizontalAlignmentAnnotation;
 exports.HorizontalAlignmentAnnotationAction = HorizontalAlignmentAnnotationAction;
 exports.ITALIC_FONT_STYLE = ITALIC_FONT_STYLE;
@@ -5354,6 +6793,7 @@ exports.InsertChildrenBeforeAction = InsertChildrenBeforeAction;
 exports.ItalicAnnotationAction = ItalicAnnotationAction;
 exports.LinkAnnotationAction = LinkAnnotationAction;
 exports.LinkFilterStylesStrategy = LinkFilterStylesStrategy;
+exports.ListAnnotation = ListAnnotation;
 exports.ModifyContentAction = ModifyContentAction;
 exports.NodeAnnotation = NodeAnnotation;
 exports.Predicate = Predicate;
@@ -5365,6 +6805,9 @@ exports.RTEDTOClassManager = RTEDTOClassManager$1;
 exports.RTEDecoratorNode = RTEDecoratorNode;
 exports.RTEFilterStylesStrategy = RTEFilterStylesStrategy;
 exports.RTEFilterStylesStrategyRegistry = RTEFilterStylesStrategyRegistry;
+exports.RTEHtmlBlock = RTEHtmlBlock;
+exports.RTEListBlock = RTEListBlock;
+exports.RTEListItemBlock = RTEListItemBlock;
 exports.RTENode = RTENode;
 exports.RTETextBlock = RTETextBlock;
 exports.RTETextNode = RTETextNode;
@@ -5372,7 +6815,9 @@ exports.RTE_DEFAULT_TEXT_COLOR = RTE_DEFAULT_TEXT_COLOR;
 exports.RTE_TEXT_COLORS = RTE_TEXT_COLORS;
 exports.RemoveChildrenAction = RemoveChildrenAction;
 exports.RemoveChildrenStrategy = RemoveChildrenStrategy;
+exports.RemoveNestListAction = RemoveNestListAction;
 exports.ReplaceChildNodesAction = ReplaceChildNodesAction;
+exports.ReplaceNestListAction = ReplaceNestListAction;
 exports.STRIKETHROUGH_TEXT_DECORATION = STRIKETHROUGH_TEXT_DECORATION;
 exports.SelectionChangeAction = SelectionChangeAction;
 exports.SplitBlockWithNodeAction = SplitBlockWithNodeAction;
@@ -5381,6 +6826,7 @@ exports.SyncUpSelectionAction = SyncUpSelectionAction;
 exports.TextColorAnnotationAction = TextColorAnnotationAction;
 exports.TextStyleAnnotation = TextStyleAnnotation;
 exports.TextStyleAnnotationAction = TextStyleAnnotationAction;
+exports.TransformParagraphAction = TransformParagraphAction;
 exports.UNDERLINE_TEXT_DECORATION = UNDERLINE_TEXT_DECORATION;
 exports.UnderlineAnnotationAction = UnderlineAnnotationAction;
 exports.UpdateCodeBlockAction = UpdateCodeBlockAction;