superdoc 0.30.0-next.9 → 0.30.0

package/dist/super-editor/chunks/{editor-DmfydVEc.js → editor-CNJV20ln.js}

@@ -9,11 +9,11 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _Attribute_static, getGlobalAttributes_fn, getNodeAndMarksAttributes_fn, _Schema_static, createNodesSchema_fn, createMarksSchema_fn, _events, _ExtensionService_instances, setupExtensions_fn, attachEditorEvents_fn, _editor, _stateValidators, _xmlValidators, _requiredNodeTypes, _requiredMarkTypes, _SuperValidator_instances, initializeValidators_fn, collectValidatorRequirements_fn, analyzeDocument_fn, _commandService, _Editor_instances, initContainerElement_fn, init_fn, initRichText_fn, onFocus_fn, checkHeadless_fn, registerCopyHandler_fn, insertNewFileData_fn, createExtensionService_fn, createCommandService_fn, createConverter_fn, initMedia_fn, initFonts_fn, checkFonts_fn, determineUnsupportedFonts_fn, createSchema_fn, generatePmData_fn, createView_fn, onCollaborationReady_fn, initComments_fn, initPagination_fn, dispatchTransaction_fn, handleNodeSelection_fn, prepareDocumentForImport_fn, prepareDocumentForExport_fn, endCollaboration_fn, validateDocumentInit_fn, validateDocumentExport_fn, initDevTools_fn, _DocumentSectionView_instances, init_fn2, addToolTip_fn, _ParagraphNodeView_instances, updateHTMLAttributes_fn, updateListStyles_fn, initList_fn, checkIsList_fn, createMarker_fn, createSeparator_fn, calculateTabSeparatorStyle_fn, calculateMarkerStyle_fn, removeList_fn, getParagraphContext_fn, scheduleAnimation_fn, cancelScheduledAnimation_fn, _FieldAnnotationView_instances, createAnnotation_fn, _AutoPageNumberNodeView_instances, renderDom_fn, scheduleUpdateNodeStyle_fn;
+var _Attribute_static, getGlobalAttributes_fn, getNodeAndMarksAttributes_fn, _Schema_static, createNodesSchema_fn, createMarksSchema_fn, _events, _ExtensionService_instances, setupExtensions_fn, attachEditorEvents_fn, _editor, _stateValidators, _xmlValidators, _requiredNodeTypes, _requiredMarkTypes, _SuperValidator_instances, initializeValidators_fn, collectValidatorRequirements_fn, analyzeDocument_fn, _commandService, _Editor_instances, initContainerElement_fn, init_fn, initRichText_fn, onFocus_fn, checkHeadless_fn, registerCopyHandler_fn, insertNewFileData_fn, createExtensionService_fn, createCommandService_fn, createConverter_fn, initMedia_fn, initFonts_fn, checkFonts_fn, determineUnsupportedFonts_fn, createSchema_fn, generatePmData_fn, createView_fn, onCollaborationReady_fn, initComments_fn, initPagination_fn, dispatchTransaction_fn, handleNodeSelection_fn, prepareDocumentForImport_fn, prepareDocumentForExport_fn, endCollaboration_fn, validateDocumentInit_fn, validateDocumentExport_fn, initDevTools_fn, _DocumentSectionView_instances, init_fn2, addToolTip_fn, _ListItemNodeView_instances, init_fn3, applyIndentStyling_fn, _FieldAnnotationView_instances, createAnnotation_fn, _AutoPageNumberNodeView_instances, renderDom_fn, scheduleUpdateNodeStyle_fn;
 import * as Y from "yjs";
 import { UndoManager, Item as Item$1, ContentType, Text as Text$1, XmlElement, encodeStateAsUpdate } from "yjs";
-import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, B as Buffer2, f as callOrGet, g as getExtensionConfigField, h as getMarkType, i as getMarksFromSelection, j as getNodeType, k as getSchemaTypeNameByName, l as Schema$1, m as cleanSchemaItem, n as canSplit, o as defaultBlockAt$1, q as liftTarget, r as canJoin, s as joinPoint, t as replaceStep$1, R as ReplaceAroundStep$1, u as isTextSelection, v as getMarkRange, w as isMarkActive, x as isNodeActive, y as deleteProps, z as processContent, C as htmlHandler, E as ReplaceStep, L as ListHelpers, G as updateNumberingProperties, H as changeListLevel, I as findParentNode, J as isList, K as isMacOS, O as isIOS, Q as getSchemaTypeByName, U as inputRulesPlugin, V as TrackDeleteMarkName, W as TrackInsertMarkName, X as v4, Y as TrackFormatMarkName, Z as comments_module_events, _ as findMark, $ as objectIncludes, a0 as AddMarkStep, a1 as RemoveMarkStep, a2 as twipsToLines, a3 as pixelsToTwips, a4 as helpers, a5 as posToDOMRect, a6 as CommandService, a7 as SuperConverter, a8 as createDocument, a9 as createDocFromMarkdown, aa as createDocFromHTML, ab as EditorState, ac as hasSomeParentWithClass, ad as isActive, ae as unflattenListsInHtml, af as parseSizeUnit, ag as minMax, ah as getLineHeightValueString, ai as updateDOMAttributes, aj as findChildren$5, ak as generateRandomSigned32BitIntStrId, al as kebabCase, am as twipsToPixels, an as halfPointToPixels, ao as getUnderlineCssString, ap as findParentNodeClosestToPos, aq as resolveRunProperties, ar as encodeCSSFromRPr, as as docxNumberingHelpers, at as InputRule, au as resolveParagraphProperties, av as eighthPointsToPixels, aw as linesToTwips, ax as PIXELS_PER_INCH, ay as SelectionRange, az as Transform, aA as isInTable$1, aB as generateDocxRandomId, aC as insertNewRelationship, aD as inchesToPixels } from "./converter-a0L8wNod.js";
-import { D as DocxZipper } from "./docx-zipper-S0E2rgnn.js";
+import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, B as Buffer2, f as callOrGet, g as getExtensionConfigField, h as getMarkType, i as getMarksFromSelection, j as getNodeType, k as getSchemaTypeNameByName, l as Schema$1, m as cleanSchemaItem, n as canSplit, o as defaultBlockAt$1, q as liftTarget, r as canJoin, s as joinPoint, t as replaceStep$1, R as ReplaceAroundStep$1, u as isTextSelection, v as getMarkRange, w as isMarkActive, x as isNodeActive, y as deleteProps, z as processContent, C as ReplaceStep, E as NodeRange, G as findWrapping, L as ListHelpers, H as findParentNode, I as isMacOS, J as isIOS, K as getSchemaTypeByName, O as inputRulesPlugin, Q as TrackDeleteMarkName, U as TrackInsertMarkName, V as v4, W as TrackFormatMarkName, X as comments_module_events, Y as findMark, Z as objectIncludes, _ as AddMarkStep, $ as RemoveMarkStep, a0 as twipsToLines, a1 as pixelsToTwips, a2 as helpers, a3 as posToDOMRect, a4 as CommandService, a5 as SuperConverter, a6 as createDocument, a7 as createDocFromMarkdown, a8 as createDocFromHTML, a9 as EditorState, aa as hasSomeParentWithClass, ab as isActive, ac as unflattenListsInHtml, ad as parseSizeUnit, ae as minMax, af as getLineHeightValueString, ag as updateDOMAttributes, ah as findChildren$5, ai as htmlHandler, aj as generateRandomSigned32BitIntStrId, ak as InputRule, al as kebabCase, am as findParentNodeClosestToPos, an as getListItemStyleDefinitions, ao as docxNumberingHelpers, ap as parseIndentElement, aq as combineIndents, ar as twipsToPixels, as as PIXELS_PER_INCH, at as SelectionRange, au as Transform, av as isInTable$1, aw as generateDocxRandomId, ax as insertNewRelationship, ay as inchesToPixels } from "./converter-DrPdSxVd.js";
+import { D as DocxZipper } from "./docx-zipper-IcLp4qO8.js";
 import { ref, computed, createElementBlock, openBlock, withModifiers, Fragment as Fragment$1, renderList, normalizeClass, createCommentVNode, toDisplayString, createElementVNode, createApp } from "vue";
 var GOOD_LEAF_SIZE = 200;
 var RopeSequence = function RopeSequence2() {
@@ -8251,15 +8251,12 @@ const ensureMarks = (state, splittableMarks) => {
     state.tr.ensureMarks(filtered);
   }
 };
-const splitBlock$1 = ({ keepMarks = true, attrsToRemoveOverride = [] } = {}) => (props) => {
+const splitBlock$1 = ({ keepMarks = true } = {}) => (props) => {
   const { tr, state, dispatch, editor } = props;
   const { selection, doc: doc2 } = tr;
   const { $from, $to } = selection;
   const extensionAttrs = editor.extensionService.attributes;
-  let newAttrs = Attribute.getSplittedAttributes(extensionAttrs, $from.node().type.name, $from.node().attrs);
-  if (attrsToRemoveOverride.length > 0) {
-    newAttrs = deleteAttributes(newAttrs, attrsToRemoveOverride);
-  }
+  const newAttrs = Attribute.getSplittedAttributes(extensionAttrs, $from.node().type.name, $from.node().attrs);
   if (selection instanceof NodeSelection && selection.node.isBlock) {
     if (!$from.parentOffset || !canSplit(doc2, $from.pos)) return false;
     if (dispatch) {
@@ -8294,23 +8291,6 @@ const splitBlock$1 = ({ keepMarks = true, attrsToRemoveOverride = [] } = {}) =>
   }
   return true;
 };
-function deleteAttributes(attrs, attrsToRemove) {
-  const newAttrs = { ...attrs };
-  attrsToRemove.forEach((attrName) => {
-    const parts = attrName.split(".");
-    if (parts.length === 1) {
-      delete newAttrs[attrName];
-    } else {
-      let current = newAttrs;
-      for (let i = 0; i < parts.length - 1; i++) {
-        if (current[parts[i]] == null) return;
-        current = current[parts[i]];
-      }
-      delete current[parts[parts.length - 1]];
-    }
-  });
-  return newAttrs;
-}
 const deleteSelection$1 = (state, dispatch) => {
   if (state.selection.empty)
     return false;
@@ -9131,7 +9111,7 @@ const selectNodeBackward = () => ({ state, dispatch }) => {
 const selectNodeForward = () => ({ state, dispatch }) => selectNodeForward$1(state, dispatch);
 const selectTextblockStart = () => ({ state, dispatch }) => selectTextblockStart$1(state, dispatch);
 const selectTextblockEnd = () => ({ state, dispatch }) => selectTextblockEnd$1(state, dispatch);
-const insertContent = (value, options = {}) => ({ tr, commands: commands2, editor }) => {
+const insertContent = (value, options = {}) => ({ tr, state, commands: commands2, editor }) => {
   if (options.contentType) {
     const validTypes = ["html", "markdown", "text", "schema"];
     if (!validTypes.includes(options.contentType)) {
@@ -9142,7 +9122,7 @@ const insertContent = (value, options = {}) => ({ tr, commands: commands2, edito
       const processedDoc = processContent({
         content: value,
         type: options.contentType,
-        editor
+        schema: state.schema
       });
       const jsonContent = processedDoc.toJSON();
       const ok = commands2.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, jsonContent, options);
@@ -9169,13 +9149,12 @@ const removeWhitespaces = (node) => {
   }
   return node;
 };
-function elementFromString(value, editor) {
+function elementFromString(value) {
   const wrappedValue = `<body>${value}</body>`;
-  const html = htmlHandler(wrappedValue, editor);
+  const html = new window.DOMParser().parseFromString(wrappedValue, "text/html").body;
   return removeWhitespaces(html);
 }
-function createNodeFromContent(content, editor, options) {
-  const schema = editor.schema;
+function createNodeFromContent(content, schema, options) {
   options = {
     slice: true,
     parseOptions: {},
@@ -9199,7 +9178,7 @@ function createNodeFromContent(content, editor, options) {
         throw new Error("[super-editor error]: Invalid JSON content", { cause: error });
       }
       console.warn("[super-editor warn]: Invalid content.", "Passed value:", content, "Error:", error);
-      return createNodeFromContent("", editor, options);
+      return createNodeFromContent("", schema, options);
     }
   }
   if (isTextContent) {
@@ -9229,9 +9208,9 @@ function createNodeFromContent(content, editor, options) {
         })
       });
       if (options.slice) {
-        DOMParser$1.fromSchema(contentCheckSchema).parseSlice(elementFromString(content, editor), options.parseOptions);
+        DOMParser$1.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
       } else {
-        DOMParser$1.fromSchema(contentCheckSchema).parse(elementFromString(content, editor), options.parseOptions);
+        DOMParser$1.fromSchema(contentCheckSchema).parse(elementFromString(content), options.parseOptions);
       }
       if (options.errorOnInvalidContent && hasInvalidContent) {
         throw new Error("[super-editor error]: Invalid HTML content", {
@@ -9241,11 +9220,11 @@ function createNodeFromContent(content, editor, options) {
     }
     const parser = DOMParser$1.fromSchema(schema);
     if (options.slice) {
-      return parser.parseSlice(elementFromString(content, editor), options.parseOptions).content;
+      return parser.parseSlice(elementFromString(content), options.parseOptions).content;
     }
-    return parser.parse(elementFromString(content, editor), options.parseOptions);
+    return parser.parse(elementFromString(content), options.parseOptions);
   }
-  return createNodeFromContent("", editor, options);
+  return createNodeFromContent("", schema, options);
 }
 function selectionToInsertionEnd(tr, startLen, bias) {
   const last = tr.steps.length - 1;
@@ -9281,7 +9260,7 @@ const insertContentAt = (position, value, options) => ({ tr, dispatch, editor })
   };
   let content;
   try {
-    content = createNodeFromContent(value, editor, {
+    content = createNodeFromContent(value, editor.schema, {
       parseOptions: {
         preserveWhitespace: "full",
         ...options.parseOptions
@@ -9368,112 +9347,539 @@ const undoInputRule = () => ({ state, dispatch }) => {
   }
   return false;
 };
-const toggleList = (listType) => ({ editor, state, tr, dispatch }) => {
-  let predicate;
-  if (listType === "orderedList") {
-    predicate = (n) => n.attrs.numberingProperties && n.attrs.listRendering && n.attrs.listRendering.numberingType !== "bullet";
-  } else if (listType === "bulletList") {
-    predicate = (n) => n.attrs.numberingProperties && n.attrs.listRendering && n.attrs.listRendering.numberingType === "bullet";
-  } else {
+function wrapInList$1(listType, attrs = null) {
+  return function(state, dispatch) {
+    let { $from, $to } = state.selection;
+    let range = $from.blockRange($to);
+    if (!range)
+      return false;
+    let tr = dispatch ? state.tr : null;
+    if (!wrapRangeInList(tr, range, listType, attrs))
+      return false;
+    if (dispatch)
+      dispatch(tr.scrollIntoView());
+    return true;
+  };
+}
+function wrapRangeInList(tr, range, listType, attrs = null) {
+  let doJoin = false, outerRange = range, doc2 = range.$from.doc;
+  if (range.depth >= 2 && range.$from.node(range.depth - 1).type.compatibleContent(listType) && range.startIndex == 0) {
+    if (range.$from.index(range.depth - 1) == 0)
+      return false;
+    let $insert = doc2.resolve(range.start - 2);
+    outerRange = new NodeRange($insert, $insert, range.depth);
+    if (range.endIndex < range.parent.childCount)
+      range = new NodeRange(range.$from, doc2.resolve(range.$to.end(range.depth)), range.depth);
+    doJoin = true;
+  }
+  let wrap = findWrapping(outerRange, listType, attrs, range);
+  if (!wrap)
     return false;
+  if (tr)
+    doWrapInList(tr, range, wrap, doJoin, listType);
+  return true;
+}
+function doWrapInList(tr, range, wrappers, joinBefore, listType) {
+  let content = Fragment.empty;
+  for (let i = wrappers.length - 1; i >= 0; i--)
+    content = Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
+  tr.step(new ReplaceAroundStep$1(range.start - (joinBefore ? 2 : 0), range.end, range.start, range.end, new Slice(content, 0, 0), wrappers.length, true));
+  let found = 0;
+  for (let i = 0; i < wrappers.length; i++)
+    if (wrappers[i].type == listType)
+      found = i + 1;
+  let splitDepth = wrappers.length - found;
+  let splitPos = range.start + wrappers.length - (joinBefore ? 2 : 0), parent = range.parent;
+  for (let i = range.startIndex, e = range.endIndex, first2 = true; i < e; i++, first2 = false) {
+    if (!first2 && canSplit(tr.doc, splitPos, splitDepth)) {
+      tr.split(splitPos, splitDepth);
+      splitPos += 2 * splitDepth;
+    }
+    splitPos += parent.child(i).nodeSize;
   }
-  const { selection } = state;
-  const { from: from2, to } = selection;
-  let firstListNode = null;
-  let hasNonListParagraphs = false;
-  let paragraphsInSelection = [];
-  state.doc.nodesBetween(from2, to, (node, pos) => {
-    if (node.type.name === "paragraph") {
-      paragraphsInSelection.push({ node, pos });
-      if (!firstListNode && predicate(node)) {
-        firstListNode = node;
-      } else if (!predicate(node)) {
-        hasNonListParagraphs = true;
-      }
+  return tr;
+}
+function liftListItem$1(itemType) {
+  return function(state, dispatch) {
+    let { $from, $to } = state.selection;
+    let range = $from.blockRange($to, (node) => node.childCount > 0 && node.firstChild.type == itemType);
+    if (!range)
       return false;
+    if (!dispatch)
+      return true;
+    if ($from.node(range.depth - 1).type == itemType)
+      return liftToOuterList(state, dispatch, itemType, range);
+    else
+      return liftOutOfList(state, dispatch, range);
+  };
+}
+function liftToOuterList(state, dispatch, itemType, range) {
+  let tr = state.tr, end2 = range.end, endOfList = range.$to.end(range.depth);
+  if (end2 < endOfList) {
+    tr.step(new ReplaceAroundStep$1(end2 - 1, endOfList, end2, endOfList, new Slice(Fragment.from(itemType.create(null, range.parent.copy())), 1, 0), 1, true));
+    range = new NodeRange(tr.doc.resolve(range.$from.pos), tr.doc.resolve(endOfList), range.depth);
+  }
+  const target = liftTarget(range);
+  if (target == null)
+    return false;
+  tr.lift(range, target);
+  let $after = tr.doc.resolve(tr.mapping.map(end2, -1) - 1);
+  if (canJoin(tr.doc, $after.pos) && $after.nodeBefore.type == $after.nodeAfter.type)
+    tr.join($after.pos);
+  dispatch(tr.scrollIntoView());
+  return true;
+}
+function liftOutOfList(state, dispatch, range) {
+  let tr = state.tr, list = range.parent;
+  for (let pos = range.end, i = range.endIndex - 1, e = range.startIndex; i > e; i--) {
+    pos -= list.child(i).nodeSize;
+    tr.delete(pos - 1, pos + 1);
+  }
+  let $start = tr.doc.resolve(range.start), item = $start.nodeAfter;
+  if (tr.mapping.map(range.end) != range.start + $start.nodeAfter.nodeSize)
+    return false;
+  let atStart = range.startIndex == 0, atEnd = range.endIndex == list.childCount;
+  let parent = $start.node(-1), indexBefore = $start.index(-1);
+  if (!parent.canReplace(indexBefore + (atStart ? 0 : 1), indexBefore + 1, item.content.append(atEnd ? Fragment.empty : Fragment.from(list))))
+    return false;
+  let start2 = $start.pos, end2 = start2 + item.nodeSize;
+  tr.step(new ReplaceAroundStep$1(start2 - (atStart ? 1 : 0), end2 + (atEnd ? 1 : 0), start2 + 1, end2 - 1, new Slice((atStart ? Fragment.empty : Fragment.from(list.copy(Fragment.empty))).append(atEnd ? Fragment.empty : Fragment.from(list.copy(Fragment.empty))), atStart ? 0 : 1, atEnd ? 0 : 1), atStart ? 0 : 1));
+  dispatch(tr.scrollIntoView());
+  return true;
+}
+function sinkListItem$1(itemType) {
+  return function(state, dispatch) {
+    let { $from, $to } = state.selection;
+    let range = $from.blockRange($to, (node) => node.childCount > 0 && node.firstChild.type == itemType);
+    if (!range)
+      return false;
+    let startIndex = range.startIndex;
+    if (startIndex == 0)
+      return false;
+    let parent = range.parent, nodeBefore = parent.child(startIndex - 1);
+    if (nodeBefore.type != itemType)
+      return false;
+    if (dispatch) {
+      let nestedBefore = nodeBefore.lastChild && nodeBefore.lastChild.type == parent.type;
+      let inner = Fragment.from(nestedBefore ? itemType.create() : null);
+      let slice2 = new Slice(Fragment.from(itemType.create(null, Fragment.from(parent.type.create(null, inner)))), nestedBefore ? 3 : 1, 0);
+      let before = range.start, after = range.end;
+      dispatch(state.tr.step(new ReplaceAroundStep$1(before - (nestedBefore ? 3 : 1), after, before, after, slice2, 1, true)).scrollIntoView());
     }
     return true;
-  });
-  if (!firstListNode && from2 > 0) {
-    const $from = state.doc.resolve(from2);
-    const parentIndex = $from.index(-1);
-    if (parentIndex > 0) {
-      const beforeNode = $from.node(-1).child(parentIndex - 1);
-      if (beforeNode && beforeNode.type.name === "paragraph" && predicate(beforeNode)) {
-        firstListNode = beforeNode;
-      }
+  };
+}
+const wrapInList = (typeOrName, attrs = {}) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return wrapInList$1(type, attrs)(state, dispatch);
+};
+function nearestListAt($pos, OrderedType, BulletType) {
+  for (let d2 = $pos.depth; d2 >= 0; d2--) {
+    const node = $pos.node(d2);
+    if (node.type === OrderedType || node.type === BulletType) {
+      return { node, pos: $pos.before(d2), depth: d2 };
     }
   }
-  let mode = null;
-  let sharedNumberingProperties = null;
-  if (firstListNode) {
-    if (!hasNonListParagraphs) {
-      mode = "remove";
-    } else {
-      mode = "reuse";
-      const baseNumbering = firstListNode.attrs.numberingProperties || {};
-      sharedNumberingProperties = {
-        ...baseNumbering,
-        ilvl: baseNumbering.ilvl ?? 0
-      };
+  return null;
+}
+function getEffectiveListKind(node) {
+  if (!node) return null;
+  const typeName = node.type?.name;
+  const style = node.attrs?.["list-style-type"];
+  if (typeName === "bulletList") return "bullet";
+  if (typeName === "orderedList") {
+    if (style === "bullet") return "bullet";
+    const firstLI = node.firstChild;
+    const liFmt = firstLI?.attrs?.listNumberingType;
+    if (liFmt === "bullet") return "bullet";
+    return "ordered";
+  }
+  return null;
+}
+function collectIntersectingTopLists({ doc: doc2, selection, OrderedType, BulletType }) {
+  const { from: from2, to, $from, $to } = selection;
+  const hit = /* @__PURE__ */ new Map();
+  const startList = nearestListAt($from, OrderedType, BulletType);
+  if (startList) hit.set(startList.pos, startList);
+  const endList = nearestListAt($to, OrderedType, BulletType);
+  if (endList) hit.set(endList.pos, endList);
+  const a = $from.nodeAfter;
+  if (a && (a.type === OrderedType || a.type === BulletType)) {
+    hit.set($from.pos, { node: a, pos: $from.pos, depth: null });
+  }
+  const b = $to.nodeBefore;
+  if (b && (b.type === OrderedType || b.type === BulletType)) {
+    const posB = $to.pos - b.nodeSize;
+    hit.set(posB, { node: b, pos: posB, depth: null });
+  }
+  doc2.nodesBetween(from2, to, (node, pos, parent) => {
+    const isList2 = node.type === OrderedType || node.type === BulletType;
+    if (!isList2) return true;
+    const parentIsList = parent && (parent.type === OrderedType || parent.type === BulletType);
+    if (!parentIsList) hit.set(pos, { node, pos, depth: null });
+    return false;
+  });
+  return Array.from(hit.values()).sort((a2, b2) => b2.pos - a2.pos);
+}
+function computeListLevels(liNodes) {
+  const levelsOut = [];
+  const counters = [];
+  for (let i = 0; i < liNodes.length; i++) {
+    const lvl = Math.max(0, Number(liNodes[i]?.attrs?.level ?? 0));
+    while (counters.length <= lvl) counters.push(0);
+    counters.splice(lvl + 1);
+    counters[lvl] = (counters[lvl] ?? 0) + 1;
+    levelsOut.push(counters.slice(0, lvl + 1));
+  }
+  return levelsOut;
+}
+function rebuildListNodeWithNewNum({ oldList, toType, editor, schema, fixedNumId }) {
+  const OrderedType = schema.nodes.orderedList;
+  const isOrdered = toType === OrderedType;
+  const numId = fixedNumId ?? ListHelpers.getNewListId(editor);
+  if (fixedNumId == null) {
+    ListHelpers.generateNewListDefinition?.({ numId: Number(numId), listType: toType, editor });
+  }
+  const liNodes = [];
+  for (let i = 0; i < oldList.childCount; i++) {
+    const li = oldList.child(i);
+    if (li?.type?.name === "listItem") liNodes.push(li);
+  }
+  const computedLevels = isOrdered ? computeListLevels(liNodes) : [];
+  const items = [];
+  for (let i = 0; i < liNodes.length; i++) {
+    const li = liNodes[i];
+    const level = Math.max(0, Number(li.attrs?.level ?? 0));
+    const listLevel = isOrdered ? computedLevels[i] ?? [i + 1] : Array.isArray(li.attrs?.listLevel) ? li.attrs.listLevel : [level + 1];
+    const details = ListHelpers.getListDefinitionDetails?.({ numId: Number(numId), level, listType: toType, editor }) || {};
+    const effectiveFmt = isOrdered ? details.numFmt || "decimal" : details.numFmt || "bullet";
+    const effectiveLvlText = isOrdered ? details.lvlText || "%1." : details.lvlText || "•";
+    const baseAttrs = li.attrs || {};
+    const itemAttrs = {
+      ...baseAttrs,
+      level,
+      listLevel,
+      numId,
+      numPrType: "inline",
+      listNumberingType: effectiveFmt,
+      lvlText: effectiveLvlText
+    };
+    const contentJSON = li.content && li.content.size > 0 ? li.content.toJSON() : [{ type: "paragraph", content: [] }];
+    items.push({
+      type: "listItem",
+      attrs: itemAttrs,
+      content: contentJSON
+    });
+  }
+  const containerJSON = {
+    type: isOrdered ? "orderedList" : "bulletList",
+    attrs: {
+      listId: numId,
+      "list-style-type": isOrdered ? items[0]?.attrs?.listNumberingType ?? "decimal" : items[0]?.attrs?.listNumberingType ?? "bullet",
+      ...isOrdered ? { order: 1 } : {}
+    },
+    content: items
+  };
+  return editor.schema.nodeFromJSON(containerJSON);
+}
+function buildListContainersFromParagraphs({ paragraphs, targetKind, editor, schema }) {
+  const OrderedType = schema.nodes.orderedList;
+  const BulletType = schema.nodes.bulletList;
+  const toType = targetKind === "ordered" ? OrderedType : BulletType;
+  const numId = ListHelpers.getNewListId(editor);
+  ListHelpers.generateNewListDefinition?.({ numId, listType: toType, editor });
+  const isOrdered = targetKind === "ordered";
+  const containers = [];
+  for (let i = 0; i < paragraphs.length; i++) {
+    const { node } = paragraphs[i];
+    const level = 0;
+    const listLevel = [1];
+    const numFmt = isOrdered ? "decimal" : "bullet";
+    const lvlText = isOrdered ? "%1." : "•";
+    const itemJSON = ListHelpers.createListItemNodeJSON({
+      level,
+      listLevel,
+      numId,
+      numFmt,
+      lvlText,
+      contentNode: node.toJSON()
+      // preserve runs
+    });
+    itemJSON.attrs = {
+      ...itemJSON.attrs || {},
+      level,
+      listLevel,
+      numId,
+      numPrType: "inline",
+      listNumberingType: numFmt,
+      lvlText
+    };
+    const containerJSON = {
+      type: isOrdered ? "orderedList" : "bulletList",
+      attrs: {
+        listId: numId,
+        "list-style-type": isOrdered ? "decimal" : "bullet",
+        ...isOrdered ? { order: 1 } : {}
+      },
+      content: [itemJSON]
+    };
+    containers.push(editor.schema.nodeFromJSON(containerJSON));
+  }
+  return containers;
+}
+function setMappedSelectionSpan(tr, fromBefore, toBefore) {
+  const mappedFrom = tr.mapping.map(fromBefore, -1);
+  const mappedTo = tr.mapping.map(toBefore, 1);
+  const $from = tr.doc.resolve(Math.max(1, Math.min(mappedFrom, tr.doc.content.size)));
+  const $to = tr.doc.resolve(Math.max(1, Math.min(mappedTo, tr.doc.content.size)));
+  tr.setSelection(TextSelection.between($from, $to));
+}
+function setCaretInsideFirstTextblockOfNodeAt(tr, containerPos) {
+  const node = tr.doc.nodeAt(containerPos);
+  if (!node) return;
+  let found = null;
+  node.descendants((n, p) => {
+    if (n.isTextblock) {
+      found = containerPos + p + 2;
+      return false;
     }
+    return true;
+  });
+  if (found != null) {
+    tr.setSelection(TextSelection.create(tr.doc, found, found));
   } else {
-    mode = "create";
-    const numId = ListHelpers.getNewListId(editor);
-    ListHelpers.generateNewListDefinition({ numId: Number(numId), listType, editor });
-    sharedNumberingProperties = {
-      numId: Number(numId),
-      ilvl: 0
-    };
+    const fallback = Math.min(tr.doc.content.size, Math.max(1, containerPos + 1));
+    tr.setSelection(TextSelection.create(tr.doc, fallback, fallback));
   }
-  for (const { node, pos } of paragraphsInSelection) {
-    if (mode === "remove") {
-      updateNumberingProperties(null, node, pos, editor, tr);
-      continue;
+}
+const toggleList = (listType) => ({ editor, state, tr, dispatch }) => {
+  const { selection, doc: doc2 } = state;
+  const OrderedType = editor.schema.nodes.orderedList;
+  const BulletType = editor.schema.nodes.bulletList;
+  const TargetType = typeof listType === "string" ? editor.schema.nodes[listType] : listType;
+  const targetKind = TargetType === OrderedType ? "ordered" : "bullet";
+  const isListNode = (n) => !!n && (n.type === OrderedType || n.type === BulletType);
+  let near = nearestListAt(selection.$from, OrderedType, BulletType);
+  if (!near) {
+    const after = selection.$from.nodeAfter;
+    if (isListNode(after)) {
+      near = { node: after, pos: selection.$from.pos, depth: selection.$from.depth + 1 };
+    } else {
+      const before = selection.$from.nodeBefore;
+      if (isListNode(before)) {
+        const pos2 = selection.$from.pos - before.nodeSize;
+        near = { node: before, pos: pos2, depth: selection.$from.depth + 1 };
+      }
+    }
+  }
+  const nearKind = near ? getEffectiveListKind(near.node) : null;
+  if (near) {
+    const isSameAsTarget = nearKind === targetKind;
+    if (isSameAsTarget) {
+      const candidateLists = collectIntersectingTopLists({ doc: doc2, selection, OrderedType, BulletType });
+      let listsToUnwrap = candidateLists.filter(({ node }) => getEffectiveListKind(node) === targetKind);
+      if (listsToUnwrap.length === 0 && getEffectiveListKind(near.node) === targetKind) {
+        listsToUnwrap = [{ node: near.node, pos: near.pos, depth: near.depth ?? null }];
+      }
+      if (listsToUnwrap.length === 0) return false;
+      let spanFromBefore2 = listsToUnwrap[0].pos;
+      let spanToBefore2 = listsToUnwrap[0].pos + listsToUnwrap[0].node.nodeSize;
+      for (let i = 1; i < listsToUnwrap.length; i++) {
+        const { node, pos: pos2 } = listsToUnwrap[i];
+        spanFromBefore2 = Math.min(spanFromBefore2, pos2);
+        spanToBefore2 = Math.max(spanToBefore2, pos2 + node.nodeSize);
+      }
+      const ParagraphType = editor.schema.nodes.paragraph;
+      listsToUnwrap.sort((a, b) => b.pos - a.pos);
+      for (const { node, pos: pos2 } of listsToUnwrap) {
+        const mappedFrom = tr.mapping.map(pos2, -1);
+        const mappedTo = tr.mapping.map(pos2 + node.nodeSize, 1);
+        const currentListNode = tr.doc.nodeAt(mappedFrom);
+        const sourceListNode = currentListNode && (currentListNode.type === OrderedType || currentListNode.type === BulletType) ? currentListNode : node;
+        const paragraphs = [];
+        for (let i = 0; i < sourceListNode.childCount; i++) {
+          const li = sourceListNode.child(i);
+          if (li.type !== editor.schema.nodes.listItem) continue;
+          const firstChild = li.firstChild;
+          paragraphs.push(firstChild || ParagraphType.create());
+        }
+        if (paragraphs.length === 0) {
+          paragraphs.push(ParagraphType.create());
+        }
+        const replacement = paragraphs.length === 1 ? paragraphs[0] : Fragment.from(paragraphs);
+        tr.replaceWith(mappedFrom, mappedTo, replacement);
+      }
+      setMappedSelectionSpan(tr, spanFromBefore2, spanToBefore2);
+      if (dispatch) dispatch(tr);
+      return true;
     }
-    if (mode === "reuse" && predicate(node)) {
-      continue;
+    let touchedLists = collectIntersectingTopLists({ doc: doc2, selection, OrderedType, BulletType });
+    if (touchedLists.length === 0) {
+      touchedLists = [{ node: near.node, pos: near.pos, depth: near.depth }];
+    }
+    let spanFromBefore = Infinity;
+    let spanToBefore = -Infinity;
+    for (const { node, pos: pos2 } of touchedLists) {
+      spanFromBefore = Math.min(spanFromBefore, pos2);
+      spanToBefore = Math.max(spanToBefore, pos2 + node.nodeSize);
+    }
+    const sharedNumId = ListHelpers.getNewListId(editor);
+    ListHelpers.generateNewListDefinition?.({ numId: sharedNumId, listType: TargetType, editor });
+    touchedLists.sort((a, b) => b.pos - a.pos);
+    for (const { node: oldList, pos: pos2 } of touchedLists) {
+      const mapped = tr.mapping.map(pos2);
+      const newList = rebuildListNodeWithNewNum({
+        oldList,
+        toType: TargetType,
+        editor,
+        schema: editor.schema,
+        fixedNumId: String(sharedNumId)
+      });
+      tr.replaceWith(mapped, mapped + oldList.nodeSize, newList);
+    }
+    setMappedSelectionSpan(tr, spanFromBefore, spanToBefore);
+    if (dispatch) dispatch(tr);
+    return true;
+  }
+  const { from: from2, to, empty: empty2 } = selection;
+  const collectParagraphs = () => {
+    const out = [];
+    doc2.nodesBetween(from2, to, (node, pos2) => {
+      if (node.type.name === "paragraph") {
+        const nodeFrom = pos2;
+        const nodeTo = pos2 + node.nodeSize;
+        if (nodeFrom < to && nodeTo > from2) out.push({ node, pos: pos2 });
+        return false;
+      }
+      return true;
+    });
+    return out;
+  };
+  if (!empty2 && from2 !== to) {
+    const paragraphs = collectParagraphs();
+    if (paragraphs.length >= 1) {
+      const first2 = paragraphs[0];
+      const last = paragraphs[paragraphs.length - 1];
+      const spanFromBefore = first2.pos;
+      const spanToBefore = last.pos + last.node.nodeSize;
+      const containers2 = buildListContainersFromParagraphs({
+        paragraphs,
+        targetKind,
+        editor,
+        schema: editor.schema
+      });
+      const replacement = paragraphs.length === 1 ? containers2[0] : Fragment.from(containers2);
+      tr.replaceWith(spanFromBefore, spanToBefore, replacement);
+      if (paragraphs.length === 1) {
+        setCaretInsideFirstTextblockOfNodeAt(tr, spanFromBefore);
+      } else {
+        setMappedSelectionSpan(tr, spanFromBefore, spanToBefore);
+      }
+      if (dispatch) dispatch(tr);
+      return true;
     }
-    updateNumberingProperties(sharedNumberingProperties, node, pos, editor, tr);
   }
+  const paraAtCursor = findParentNode((n) => n.type.name === "paragraph")(selection);
+  if (!paraAtCursor) return false;
+  const { node: paragraph, pos } = paraAtCursor;
+  const containers = buildListContainersFromParagraphs({
+    paragraphs: [{ node: paragraph, pos }],
+    targetKind,
+    editor,
+    schema: editor.schema
+  });
+  tr.replaceWith(pos, pos + paragraph.nodeSize, containers[0]);
+  setCaretInsideFirstTextblockOfNodeAt(tr, pos);
   if (dispatch) dispatch(tr);
   return true;
 };
-const increaseListIndent = () => ({ editor, tr, dispatch }) => {
-  const handled = changeListLevel(1, editor, tr);
-  if (handled && dispatch) {
-    dispatch(tr);
-  }
-  return handled;
+const LIST_NODE_NAMES = /* @__PURE__ */ new Set(["orderedList", "bulletList"]);
+const parseLevel = (value) => {
+  if (typeof value === "number") return value;
+  const parsed = parseInt(value, 10);
+  return Number.isNaN(parsed) ? 0 : parsed;
 };
-const decreaseListIndent = () => ({ editor, tr, dispatch }) => {
-  const handled = changeListLevel(-1, editor, tr);
-  if (handled && dispatch) {
-    dispatch(tr);
+const resolveParentList = ($pos) => {
+  if (!$pos) return null;
+  for (let depth = $pos.depth; depth >= 0; depth--) {
+    const node = $pos.node(depth);
+    if (node?.type && LIST_NODE_NAMES.has(node.type.name)) {
+      return node;
+    }
   }
-  return handled;
+  return null;
 };
-const removeNumberingProperties = ({ checkType = "startParagraph" } = {}) => (props) => {
-  const { tr, state, editor, dispatch } = props;
-  const { node: paragraph, pos } = findParentNode(isList)(state.selection) || {};
-  if (!paragraph) return false;
-  if (checkType === "empty" && !isVisuallyEmptyParagraph(paragraph)) return false;
-  if (checkType === "startParagraph") {
-    const { $from, empty: empty2 } = state.selection;
-    if ((!empty2 || $from.parentOffset !== 0) && !isVisuallyEmptyParagraph(paragraph)) return false;
-  }
-  const ilvl = paragraph.attrs.numberingProperties.ilvl;
-  if (ilvl > 0) {
-    const outdented = decreaseListIndent()(props);
-    if (outdented) {
-      tr.scrollIntoView();
+const collectTargetListItemPositions = (state, fallbackPos) => {
+  const doc2 = state?.doc;
+  const listItemType = state?.schema?.nodes?.listItem;
+  if (!doc2 || !listItemType) {
+    return typeof fallbackPos === "number" ? [fallbackPos] : [];
+  }
+  const candidates = [];
+  const { from: from2, to } = state.selection;
+  doc2.nodesBetween(from2, to, (node, pos) => {
+    if (node.type === listItemType) {
+      const size = typeof node.nodeSize === "number" ? node.nodeSize : 0;
+      candidates.push({ node, pos, end: pos + size });
     }
-    return outdented;
-  } else {
-    updateNumberingProperties(null, paragraph, pos, editor, tr);
+  });
+  if (!candidates.length && typeof fallbackPos === "number") {
+    return [fallbackPos];
   }
-  if (dispatch) dispatch(tr);
-  return true;
+  const filtered = candidates.filter(({ pos, end: end2 }) => {
+    return !candidates.some((other) => other.pos > pos && other.pos < end2);
+  });
+  const sorted = filtered.map(({ pos }) => pos).sort((a, b) => a - b);
+  return sorted.filter((pos, index2) => index2 === 0 || pos !== sorted[index2 - 1]);
+};
+const decreaseListIndent = (_targetPositions) => ({ editor, tr }) => {
+  const { state } = editor;
+  const currentItem = ListHelpers.getCurrentListItem && ListHelpers.getCurrentListItem(state) || findParentNode((n) => n.type && n.type.name === "listItem")(state.selection);
+  const parentOrderedHelper = ListHelpers.getParentOrderedList && ListHelpers.getParentOrderedList(state);
+  const parentBulletHelper = ListHelpers.getParentBulletList && ListHelpers.getParentBulletList(state);
+  const targetPositions = _targetPositions || collectTargetListItemPositions(state, currentItem?.pos);
+  if (!targetPositions.length) return false;
+  let parentListsMap = {};
+  const mappedNodes = targetPositions.map((originalPos) => {
+    const mappedPos = tr.mapping ? tr.mapping.map(originalPos) : originalPos;
+    const node = tr.doc && tr.doc.nodeAt(mappedPos) || (currentItem && originalPos === currentItem.pos ? currentItem.node : null);
+    return { originalPos, mappedPos, node };
+  });
+  const validNodes = mappedNodes.filter(({ node }) => node && node.type.name === "listItem");
+  validNodes.forEach(({ mappedPos, node }) => {
+    const attrs = node.attrs || {};
+    const currLevel = parseLevel(attrs.level);
+    if (currLevel <= 0) {
+      return;
+    }
+    const newLevel = currLevel - 1;
+    const $pos = tr.doc ? tr.doc.resolve(mappedPos) : null;
+    const parentListNode = resolveParentList($pos) || parentOrderedHelper?.node || parentBulletHelper?.node || parentOrderedHelper || parentBulletHelper;
+    parentListsMap[mappedPos] = parentListNode;
+    if (!parentListNode) {
+      return;
+    }
+    const fallbackListId = parentListNode.attrs?.listId ?? null;
+    let numId = fallbackListId ?? attrs.numId ?? null;
+    let createdNewId = false;
+    if (numId == null && ListHelpers.getNewListId) {
+      numId = ListHelpers.getNewListId(editor);
+      createdNewId = numId != null;
+    }
+    if (createdNewId && numId != null && ListHelpers.generateNewListDefinition) {
+      ListHelpers.generateNewListDefinition({
+        numId,
+        listType: parentListNode.type,
+        editor
+      });
+    }
+    tr.setNodeMarkup(mappedPos, null, {
+      ...attrs,
+      level: newLevel,
+      numId
+    });
+  });
+  return Object.values(parentListsMap).length ? !Object.values(parentListsMap).every((pos) => !pos) : true;
 };
 function isVisuallyEmptyParagraph(node) {
   if (!node || node.type.name !== "paragraph") return false;
@@ -9490,7 +9896,7 @@ function isVisuallyEmptyParagraph(node) {
   if (text.length > 0) return false;
   let hasInlineLeaf = false;
   node.descendants((n) => {
-    if (n.isInline && n.isLeaf && n.type?.name !== "hardBreak" && n.type?.name !== "run") {
+    if (n.isInline && n.isLeaf && n.type?.name !== "hardBreak") {
       hasInlineLeaf = true;
       return false;
     }
@@ -9499,6 +9905,468 @@ function isVisuallyEmptyParagraph(node) {
   if (hasInlineLeaf) return false;
   return true;
 }
+function tryOutdentOneLevel(props) {
+  return decreaseListIndent()(props);
+}
+const splitListItem = () => (props) => {
+  const { tr, state, dispatch } = props;
+  const type = getNodeType("listItem", state.schema);
+  const { $from, $to, empty: empty2 } = state.selection;
+  tr.setMeta("updateListSync", true);
+  const listItemPM = findParentNode((n) => n.type === type)(state.selection);
+  if (!listItemPM) return false;
+  const { node: listItemNode } = listItemPM;
+  if (state.selection.node && state.selection.node.isBlock || $from.depth < 2 || !$from.sameParent($to)) {
+    return false;
+  }
+  const paraPM = findParentNode((n) => n.type.name === "paragraph")(state.selection);
+  if (!paraPM) return false;
+  const originalParagraphNode = paraPM.node;
+  const paraStart = paraPM.pos + 1;
+  const listPM = findParentNode((n) => ["orderedList", "bulletList"].includes(n.type.name))(state.selection);
+  if (!listPM) return false;
+  const { node: parentListNode, pos: listStart } = listPM;
+  const listEnd = listStart + parentListNode.nodeSize;
+  let offsetInParagraph;
+  if (empty2) {
+    offsetInParagraph = state.selection.from - paraStart;
+  } else {
+    offsetInParagraph = $from.pos - paraStart;
+  }
+  const parentPara = $from.parent;
+  const isEmptyPara = isVisuallyEmptyParagraph(parentPara);
+  const atEndOfListItem = $from.node(-1).childCount === $from.indexAfter(-1);
+  if (isEmptyPara && atEndOfListItem) {
+    const currentLevel = typeof listItemNode?.attrs?.level === "number" ? listItemNode.attrs.level : 0;
+    if (currentLevel > 0) {
+      const outdented = tryOutdentOneLevel(props);
+      if (outdented) {
+        tr.scrollIntoView();
+        if (dispatch) dispatch(tr);
+        return true;
+      }
+    }
+    return handleSplitInEmptyBlock(props, listItemPM);
+  }
+  if (isVisuallyEmptyParagraph(originalParagraphNode)) {
+    const currentLevel = typeof listItemNode?.attrs?.level === "number" ? listItemNode.attrs.level : 0;
+    if (currentLevel > 0) {
+      const outdented = tryOutdentOneLevel(props);
+      if (outdented) {
+        tr.scrollIntoView();
+        if (dispatch) dispatch(tr);
+        return true;
+      }
+    }
+    return handleSplitInEmptyBlock(props, listItemPM);
+  }
+  let paragraphContentToSplit = originalParagraphNode.content;
+  if (!empty2) {
+    const selectionStart = $from.pos - paraStart;
+    const selectionEnd = $to.pos - paraStart;
+    paragraphContentToSplit = originalParagraphNode.content.cut(0, selectionStart).append(originalParagraphNode.content.cut(selectionEnd));
+    offsetInParagraph = selectionStart;
+  }
+  const beforeCursor = paragraphContentToSplit.cut(0, Math.max(0, offsetInParagraph));
+  const afterCursor = paragraphContentToSplit.cut(Math.max(0, offsetInParagraph));
+  const paragraphIndex = $from.index(-1);
+  const listItemHasMultipleParagraphs = listItemNode.childCount > 1;
+  let firstLI, secondLI;
+  if (listItemHasMultipleParagraphs) {
+    const contentBefore = [];
+    for (let i = 0; i < paragraphIndex; i++) contentBefore.push(listItemNode.child(i));
+    const contentAfter = [];
+    for (let i = paragraphIndex + 1; i < listItemNode.childCount; i++) contentAfter.push(listItemNode.child(i));
+    const firstParas = [
+      ...contentBefore,
+      originalParagraphNode.type.create(originalParagraphNode.attrs, beforeCursor.size ? beforeCursor : null)
+    ].filter(Boolean);
+    if (firstParas.length === 0) {
+      firstParas.push(state.schema.nodes.paragraph.create(originalParagraphNode.attrs));
+    }
+    const secondParas = [
+      originalParagraphNode.type.create(originalParagraphNode.attrs, afterCursor.size ? afterCursor : null),
+      ...contentAfter
+    ].filter(Boolean);
+    if (secondParas.length === 0) {
+      secondParas.push(state.schema.nodes.paragraph.create(originalParagraphNode.attrs));
+    }
+    firstLI = state.schema.nodes.listItem.create({ ...listItemNode.attrs }, Fragment.from(firstParas));
+    secondLI = state.schema.nodes.listItem.create({ ...listItemNode.attrs }, Fragment.from(secondParas));
+  } else {
+    const firstParagraph = originalParagraphNode.type.create(
+      originalParagraphNode.attrs,
+      beforeCursor.size ? beforeCursor : null
+    );
+    const secondParagraph = originalParagraphNode.type.create(
+      originalParagraphNode.attrs,
+      afterCursor.size ? afterCursor : null
+    );
+    firstLI = state.schema.nodes.listItem.create({ ...listItemNode.attrs }, firstParagraph);
+    secondLI = state.schema.nodes.listItem.create({ ...listItemNode.attrs }, secondParagraph);
+  }
+  if (!firstLI || !secondLI) return false;
+  const ListType = parentListNode.type;
+  const firstList = ListType.createAndFill(parentListNode.attrs, Fragment.from(firstLI));
+  const secondList = ListType.createAndFill(parentListNode.attrs, Fragment.from(secondLI));
+  if (!firstList || !secondList) return false;
+  tr.replaceWith(listStart, listEnd, firstList);
+  const insertAfterFirst = listStart + firstList.nodeSize;
+  tr.insert(insertAfterFirst, secondList);
+  const cursorPos = insertAfterFirst + 3;
+  tr.setSelection(TextSelection.near(tr.doc.resolve(cursorPos), 1)).scrollIntoView();
+  tr.setMeta("splitListItem", true);
+  if (dispatch) dispatch(tr);
+  return true;
+};
+const handleSplitInEmptyBlock = (props, currentListItem) => {
+  const { state, editor, tr } = props;
+  const { schema } = state;
+  const { $from } = state.selection;
+  const extensionAttrs = editor.extensionService.attributes;
+  const listItemNode = currentListItem.node;
+  const isEmptyParagraph = isVisuallyEmptyParagraph($from.parent);
+  const listItemHasOtherContent = listItemNode.content.size > $from.parent.nodeSize;
+  const isAtEndOfListItem = $from.indexAfter(-1) === $from.node(-1).childCount;
+  if (isEmptyParagraph && listItemHasOtherContent && isAtEndOfListItem) {
+    try {
+      const listTypes2 = ["orderedList", "bulletList"];
+      const parentList2 = findParentNode((n) => listTypes2.includes(n.type.name))(state.selection);
+      if (!parentList2) return false;
+      const newParagraphAttrs2 = Attribute.getSplittedAttributes(extensionAttrs, "paragraph", {});
+      const newParagraph2 = schema.nodes.paragraph.create(newParagraphAttrs2);
+      const newListItem = schema.nodes.listItem.create({ ...listItemNode.attrs }, newParagraph2);
+      const ListType = parentList2.node.type;
+      const newList = ListType.createAndFill(parentList2.node.attrs, Fragment.from(newListItem));
+      if (!newList) return false;
+      const insertPos = parentList2.pos + parentList2.node.nodeSize;
+      tr.insert(insertPos, newList);
+      const newPos2 = insertPos + 3;
+      tr.setSelection(TextSelection.near(tr.doc.resolve(newPos2)));
+      tr.scrollIntoView();
+      return true;
+    } catch (e) {
+      console.error("Error creating new list item:", e);
+      return false;
+    }
+  }
+  if (isEmptyParagraph && listItemHasOtherContent && !isAtEndOfListItem) return false;
+  const listTypes = ["orderedList", "bulletList"];
+  const parentList = findParentNode((n) => listTypes.includes(n.type.name))(state.selection);
+  if (!parentList) return false;
+  const newParagraphAttrs = Attribute.getSplittedAttributes(extensionAttrs, "paragraph", {});
+  let newParagraph = schema.nodes.paragraph.createAndFill(newParagraphAttrs);
+  if (!newParagraph) newParagraph = schema.nodes.paragraph.create();
+  const listStart = parentList.pos;
+  const listEnd = parentList.pos + parentList.node.nodeSize;
+  tr.replaceWith(listStart, listEnd, newParagraph);
+  const newPos = listStart + 1;
+  tr.setSelection(TextSelection.near(tr.doc.resolve(newPos)));
+  tr.scrollIntoView();
+  return true;
+};
+const sinkListItem = (typeOrName) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return sinkListItem$1(type)(state, dispatch);
+};
+const liftListItem = (typeOrName) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return liftListItem$1(type)(state, dispatch);
+};
+const deleteListItem = () => (props) => {
+  const { tr, state } = props;
+  const { selection } = state;
+  tr.setMeta("updateListSync", true);
+  if (!selection.empty) {
+    const { from: from2, to } = selection;
+    const fullySelectedBlocks = [];
+    state.doc.nodesBetween(from2, to, (node, pos) => {
+      if (node.isBlock && pos >= from2 && pos + node.nodeSize <= to) {
+        fullySelectedBlocks.push({ pos, size: node.nodeSize });
+      }
+    });
+    if (fullySelectedBlocks.length) {
+      fullySelectedBlocks.sort((a, b) => b.pos - a.pos).forEach(({ pos, size }) => {
+        tr.delete(pos, pos + size);
+      });
+      const $new = tr.doc.resolve(from2);
+      tr.setSelection(TextSelection.near($new));
+      return true;
+    }
+    return false;
+  }
+  const { $from } = state.selection;
+  if ($from.parentOffset !== 0) return false;
+  const currentListItem = findParentNode((n) => n.type.name === "listItem")(state.selection);
+  if (!currentListItem) return false;
+  const listTypes = ["orderedList", "bulletList"];
+  const parentList = findParentNode((n) => listTypes.includes(n.type.name))(state.selection);
+  if (!parentList) return false;
+  const currentParagraphNode = findParentNode((n) => n.type.name === "paragraph")(state.selection);
+  const paragraphNode = currentListItem.node.content.firstChild;
+  if (paragraphNode !== currentParagraphNode.node) return false;
+  const listFrom = parentList.pos;
+  const listTo = listFrom + parentList.node.nodeSize;
+  if (currentListItem.node.content.size === 0) {
+    tr.delete(listFrom, listTo);
+    return true;
+  }
+  const listItemContent = currentListItem.node.content;
+  const nodes = [];
+  listItemContent.forEach((child) => {
+    nodes.push(child);
+  });
+  tr.replaceWith(listFrom, listTo, nodes);
+  const $pos = tr.doc.resolve(listFrom + 1);
+  tr.setSelection(TextSelection.near($pos));
+  return true;
+};
+const increaseListIndent = (_targetPositions) => ({ editor, tr }) => {
+  const { state } = editor;
+  const currentItem = ListHelpers.getCurrentListItem && ListHelpers.getCurrentListItem(state) || findParentNode((n) => n.type && n.type.name === "listItem")(state.selection);
+  const parentOrderedHelper = ListHelpers.getParentOrderedList && ListHelpers.getParentOrderedList(state);
+  const parentBulletHelper = ListHelpers.getParentBulletList && ListHelpers.getParentBulletList(state);
+  const targetPositions = _targetPositions || collectTargetListItemPositions(state, currentItem?.pos);
+  if (!targetPositions.length) return false;
+  let parentListsMap = {};
+  const mappedNodes = targetPositions.map((originalPos) => {
+    const mappedPos = tr.mapping ? tr.mapping.map(originalPos) : originalPos;
+    const node = tr.doc && tr.doc.nodeAt(mappedPos) || (currentItem && originalPos === currentItem.pos ? currentItem.node : null);
+    return { originalPos, mappedPos, node };
+  });
+  const validNodes = mappedNodes.filter(({ node }) => node && node.type.name === "listItem");
+  validNodes.forEach(({ mappedPos, node }) => {
+    const attrs = node.attrs || {};
+    const currentLevel = parseLevel(attrs.level);
+    const newLevel = currentLevel + 1;
+    const $pos = tr.doc ? tr.doc.resolve(mappedPos) : null;
+    const parentListNode = resolveParentList($pos) || parentOrderedHelper?.node || parentBulletHelper?.node || parentOrderedHelper || parentBulletHelper;
+    parentListsMap[mappedPos] = parentListNode;
+    if (!parentListNode) {
+      return;
+    }
+    let numId = attrs.numId;
+    if (numId == null) {
+      const fallbackListId = parentListNode.attrs?.listId ?? null;
+      numId = fallbackListId ?? (ListHelpers.getNewListId ? ListHelpers.getNewListId(editor) : null);
+      if (numId != null && ListHelpers.generateNewListDefinition) {
+        ListHelpers.generateNewListDefinition({
+          numId,
+          listType: parentListNode.type,
+          editor
+        });
+      }
+    }
+    tr.setNodeMarkup(mappedPos, null, {
+      ...attrs,
+      level: newLevel,
+      numId
+    });
+  });
+  return Object.values(parentListsMap).length ? !Object.values(parentListsMap).every((pos) => !pos) : true;
+};
+const isList = (n) => !!n && (n.type?.name === "orderedList" || n.type?.name === "bulletList");
+const findNodePosition = (doc2, targetNode) => {
+  let nodePos = null;
+  doc2.descendants((node, pos) => {
+    if (node === targetNode) {
+      nodePos = pos;
+      return false;
+    }
+    return true;
+  });
+  return nodePos;
+};
+function getListContext(state) {
+  const { $from } = state.selection;
+  for (let d2 = $from.depth; d2 > 0; d2--) {
+    const node = $from.node(d2 - 1);
+    if (isList(node)) {
+      const listDepth = d2 - 1;
+      const listPos = $from.before(listDepth);
+      const listNode = node;
+      const liNode = listNode.firstChild || null;
+      if (!liNode || liNode.type.name !== "listItem") return null;
+      return { listDepth, listPos, listNode, liNode };
+    }
+  }
+  return null;
+}
+const handleBackspaceNextToList = () => ({ state, dispatch, editor }) => {
+  const { selection, doc: doc2, schema } = state;
+  const { $from } = selection;
+  if (!selection.empty) return false;
+  if ($from.parent.type.name !== "paragraph") return false;
+  const ctx = getListContext(state);
+  if (ctx) {
+    const { listPos, listNode, liNode } = ctx;
+    const atStartOfParagraph = $from.parentOffset === 0;
+    const itemIsEmpty = liNode.childCount > 0 ? liNode.firstChild?.content.size === 0 : true;
+    if (!atStartOfParagraph && !itemIsEmpty) return false;
+    const level = Number(liNode.attrs?.level ?? 0);
+    if (level > 0) {
+      const tr1 = state.tr.setMeta("updateListSync", true);
+      const didOutdent = typeof decreaseListIndent === "function" && decreaseListIndent()({
+        editor,
+        state,
+        tr: tr1,
+        dispatch: (t) => dispatch && t && dispatch(t)
+      });
+      if (didOutdent) return true;
+      const liPos = listPos + 1;
+      const newLevel = Math.max(0, level - 1);
+      const trFallback = state.tr.setMeta("updateListSync", true);
+      trFallback.setNodeMarkup(liPos, null, { ...liNode.attrs, level: newLevel });
+      dispatch(trFallback);
+      return true;
+    }
+    const replacement = liNode && liNode.content && liNode.content.size > 0 ? liNode.content : Fragment.from(schema.nodes.paragraph.create());
+    const from2 = listPos;
+    const to = listPos + listNode.nodeSize;
+    const tr2 = state.tr.setMeta("updateListSync", true);
+    tr2.replaceWith(from2, to, replacement);
+    const newPos = from2 + 1;
+    tr2.setSelection(TextSelection.near(tr2.doc.resolve(newPos), 1)).scrollIntoView();
+    dispatch(tr2);
+    return true;
+  }
+  if ($from.parentOffset !== 0) return false;
+  const parentDepth = $from.depth - 1;
+  if (parentDepth < 0) return false;
+  const container = $from.node(parentDepth);
+  const idx = $from.index(parentDepth);
+  if (idx === 0) return false;
+  const beforeNode = container.child(idx - 1);
+  if (!beforeNode || !isList(beforeNode)) return false;
+  const listItem = beforeNode.lastChild;
+  if (!listItem || listItem.type.name !== "listItem") return false;
+  const targetPara = listItem.lastChild;
+  if (!targetPara || targetPara.type.name !== "paragraph") return false;
+  const paraStartPos = findNodePosition(doc2, targetPara);
+  if (paraStartPos == null) return false;
+  const inlineContent = Fragment.from($from.parent.content);
+  const tr = state.tr.setMeta("updateListSync", true);
+  const thisParaStart = $from.before();
+  tr.delete(thisParaStart, thisParaStart + $from.parent.nodeSize);
+  const insertPos = paraStartPos + 1 + targetPara.content.size;
+  tr.insert(insertPos, inlineContent);
+  tr.setSelection(TextSelection.near(tr.doc.resolve(insertPos), 1));
+  dispatch(tr);
+  return true;
+};
+function getParaCtx(state) {
+  const { $from } = state.selection;
+  for (let d2 = $from.depth; d2 >= 0; d2--) {
+    const n = $from.node(d2);
+    if (n.type.name === "paragraph") {
+      const before = $from.before(d2);
+      const endInside = before + 1 + n.content.size;
+      return { para: n, paraDepth: d2, before, endInside };
+    }
+  }
+  return null;
+}
+function atVisualParaEnd(state, ctx) {
+  const { $from } = state.selection;
+  const { para, paraDepth, endInside } = ctx;
+  if ($from.parent.type.name === "paragraph" && $from.parentOffset === $from.parent.content.size) return true;
+  if ($from.parent.type.name === "run" && $from.parentOffset === $from.parent.content.size) {
+    const idxInPara = $from.index(paraDepth);
+    return idxInPara === para.childCount - 1;
+  }
+  return $from.pos === endInside;
+}
+function getNextSiblingAtDepth(state, depth) {
+  const pos = state.selection.$from.after(depth);
+  if (pos == null) return { pos: null, next: null };
+  const $pos = state.doc.resolve(pos);
+  return { pos, next: $pos.nodeAfter || null };
+}
+const handleDeleteNextToList = () => ({ state, dispatch }) => {
+  const { selection } = state;
+  const { $from } = selection;
+  if (!selection.empty) return false;
+  const ctx = getParaCtx(state);
+  if (!ctx) return false;
+  const { paraDepth, endInside: paraEnd } = ctx;
+  if (!atVisualParaEnd(state, ctx)) return false;
+  const tr = state.tr;
+  tr.setMeta("suppressAutoList", true);
+  const insertAtParaEnd = (frag) => {
+    const mapped = tr.mapping.map(paraEnd, 1);
+    tr.insert(mapped, frag);
+    return mapped;
+  };
+  let listItemDepth = -1;
+  let listDepth = -1;
+  for (let d2 = $from.depth; d2 > 0; d2--) {
+    const maybeLI = $from.node(d2 - 1);
+    if (maybeLI.type.name === "listItem") {
+      listItemDepth = d2 - 1;
+      if (d2 - 2 >= 0 && isList($from.node(d2 - 2))) listDepth = d2 - 2;
+      break;
+    }
+  }
+  if (listItemDepth !== -1 && listDepth !== -1) {
+    const li = $from.node(listItemDepth);
+    const paraIdxInLI = $from.index(listItemDepth + 1);
+    if (paraIdxInLI < li.childCount - 1) return false;
+  }
+  const currentBlockDepth = listItemDepth !== -1 && listDepth !== -1 ? listDepth : paraDepth;
+  const { pos: nextBeforePos, next: nextNode } = getNextSiblingAtDepth(state, currentBlockDepth);
+  if (nextBeforePos == null || !nextNode) return false;
+  const mergeParagraphAt = (beforePos) => {
+    const livePara = tr.doc.resolve(beforePos).nodeAfter;
+    if (!livePara || livePara.type.name !== "paragraph") return false;
+    if (livePara.content.size === 0) {
+      tr.delete(beforePos, beforePos + livePara.nodeSize);
+      dispatch?.(tr);
+      return true;
+    }
+    const ins = insertAtParaEnd(Fragment.from(livePara.content));
+    const delFrom = tr.mapping.map(beforePos, 1);
+    const delTo = tr.mapping.map(beforePos + livePara.nodeSize, 1);
+    tr.delete(delFrom, delTo);
+    const selPos = tr.mapping.map(ins + livePara.content.size, -1);
+    tr.setSelection(TextSelection.near(tr.doc.resolve(selPos), -1)).scrollIntoView();
+    dispatch?.(tr);
+    return true;
+  };
+  const mergeListAt = (beforePos) => {
+    const liveList = tr.doc.resolve(beforePos).nodeAfter;
+    if (!liveList || !isList(liveList)) return true;
+    const li = liveList.firstChild;
+    if (!li || li.type.name !== "listItem" || li.childCount === 0) {
+      tr.delete(beforePos, beforePos + liveList.nodeSize);
+      dispatch?.(tr);
+      return true;
+    }
+    let content = null;
+    for (let i = 0; i < li.childCount; i++) {
+      const ch = li.child(i);
+      if (ch.type.name === "paragraph" && ch.content.size > 0) {
+        content = ch.content;
+        break;
+      }
+    }
+    if (content) insertAtParaEnd(Fragment.from(content));
+    const delFrom = tr.mapping.map(beforePos, 1);
+    const delTo = tr.mapping.map(beforePos + liveList.nodeSize, 1);
+    tr.delete(delFrom, delTo);
+    const endPos = tr.mapping.map(paraEnd + (content ? content.size : 0), -1);
+    tr.setSelection(TextSelection.near(tr.doc.resolve(endPos), -1)).scrollIntoView();
+    dispatch?.(tr);
+    return true;
+  };
+  if (nextNode.isTextblock) {
+    const changed = mergeParagraphAt(nextBeforePos);
+    return changed ? true : false;
+  }
+  if (isList(nextNode)) {
+    return mergeListAt(nextBeforePos);
+  }
+  return false;
+};
 const restoreSelection = () => ({ editor, state, tr }) => {
   if (editor.options.lastSelection) {
     const selectionTr = tr.setSelection(
@@ -9552,18 +10420,23 @@ const getSelectionMarks = () => ({ state, tr }) => {
 };
 const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  changeListLevel,
+  atVisualParaEnd,
   clearNodes,
+  collectIntersectingTopLists,
   command,
   createParagraphNear,
   decreaseListIndent,
   defaultStyleDetector,
+  deleteListItem,
   deleteSelection,
   exitCode,
   first,
   getEffectiveStyleId,
+  getParaCtx,
   getSelectionMarks,
   getStyleIdFromMarks,
+  handleBackspaceNextToList,
+  handleDeleteNextToList,
   increaseListIndent,
   insertContent,
   insertContentAt,
@@ -9576,9 +10449,11 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   joinForward,
   joinUp,
   liftEmptyBlock,
+  liftListItem,
   mapMarkToStyleKey,
+  nearestListAt,
   newlineInCode,
-  removeNumberingProperties,
+  rebuildListNodeWithNewNum,
   resetAttributes,
   restoreSelection,
   selectAll,
@@ -9586,11 +10461,14 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   selectNodeForward,
   selectTextblockEnd,
   selectTextblockStart,
+  setMappedSelectionSpan,
   setMark,
   setMeta,
   setNode,
   setTextSelection,
+  sinkListItem,
   splitBlock: splitBlock$1,
+  splitListItem,
   toggleList,
   toggleMark,
   toggleMarkCascade,
@@ -9599,7 +10477,7 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   unsetAllMarks,
   unsetMark,
   updateAttributes,
-  updateNumberingProperties
+  wrapInList
 }, Symbol.toStringTag, { value: "Module" }));
 const Commands = Extension.create({
   name: "commands",
@@ -9624,7 +10502,8 @@ const handleBackspace = (editor) => {
       return false;
     },
     () => commands2.deleteSelection(),
-    () => commands2.removeNumberingProperties(),
+    () => commands2.handleBackspaceNextToList(),
+    () => commands2.deleteListItem(),
     () => commands2.joinBackward(),
     () => commands2.selectNodeBackward()
   ]);
@@ -9632,6 +10511,7 @@ const handleBackspace = (editor) => {
 const handleDelete = (editor) => {
   return editor.commands.first(({ commands: commands2 }) => [
     () => commands2.deleteSelection(),
+    () => commands2.handleDeleteNextToList(),
     () => commands2.joinForward(),
     () => commands2.selectNodeForward()
   ]);
@@ -10148,8 +11028,7 @@ const _ExtensionService = class _ExtensionService {
           getPos,
           decorations,
           htmlAttributes,
-          extension,
-          extensionAttrs
+          extension
         });
       };
       return [extension.name, nodeview];
@@ -14202,7 +15081,7 @@ const _Editor = class _Editor extends EventEmitter {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      import("./index-CGz3-6gE.js"),
+      import("./index-D04RPnYX.js"),
       import("./index-DRCvimau.js"),
       import("./index-C_x_N6Uh.js"),
       import("./index-D_sWOSiG.js"),
@@ -14420,7 +15299,7 @@ const _Editor = class _Editor extends EventEmitter {
    * @returns {Object | void} Migration results
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "0.30.0-next.9");
+    console.debug("[checkVersionMigrations] Current editor version", "0.30.0");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -14525,7 +15404,7 @@ const _Editor = class _Editor extends EventEmitter {
     if (!targetNode || !html) return;
     const start2 = targetNode.pos;
     const end2 = start2 + targetNode.node.nodeSize;
-    const htmlNode = createDocFromHTML(html, this);
+    const htmlNode = createDocFromHTML(html, this.schema);
     tr.replaceWith(start2, end2, htmlNode);
     dispatch(tr);
   }
@@ -14900,14 +15779,14 @@ generatePmData_fn = function() {
         doc2 = createDocument(this.converter, this.schema, this);
         doc2 = __privateMethod(this, _Editor_instances, prepareDocumentForImport_fn).call(this, doc2);
         if (this.options.markdown) {
-          doc2 = createDocFromMarkdown(this.options.markdown, this, { isImport: true });
-        } else if (this.options.html) doc2 = createDocFromHTML(this.options.html, this, { isImport: true });
+          doc2 = createDocFromMarkdown(this.options.markdown, this.schema, { isImport: true });
+        } else if (this.options.html) doc2 = createDocFromHTML(this.options.html, this.schema, { isImport: true });
         else if (this.options.jsonOverride) doc2 = this.schema.nodeFromJSON(this.options.jsonOverride);
         if (fragment) doc2 = yXmlFragmentToProseMirrorRootNode(fragment, this.schema);
       }
     } else if (mode === "text" || mode === "html") {
       if (loadFromSchema) doc2 = this.schema.nodeFromJSON(content);
-      else if (content) doc2 = createDocFromHTML(content, this);
+      else if (content) doc2 = createDocFromHTML(content, this.schema);
       else doc2 = this.schema.topNodeType.createAndFill();
     }
   } catch (err) {
@@ -17749,7 +18628,7 @@ const splitRun = () => (props) => {
   const { $from, empty: empty2 } = state.selection;
   if (!empty2) return false;
   if ($from.parent.type.name !== "run") return false;
-  const handled = splitBlockPatch(state, (transaction) => {
+  const handled = splitBlock(state, (transaction) => {
     view.dispatch(transaction);
   });
   if (handled) {
@@ -17757,48 +18636,6 @@ const splitRun = () => (props) => {
   }
   return handled;
 };
-function splitBlockPatch(state, dispatch) {
-  let { $from } = state.selection;
-  if (state.selection instanceof NodeSelection && state.selection.node.isBlock) {
-    if (!$from.parentOffset || !canSplit(state.doc, $from.pos)) return false;
-    if (dispatch) dispatch(state.tr.split($from.pos).scrollIntoView());
-    return true;
-  }
-  if (!$from.depth) return false;
-  let types = [];
-  let splitDepth, deflt, atEnd = false, atStart = false;
-  for (let d2 = $from.depth; ; d2--) {
-    let node = $from.node(d2);
-    if (node.isBlock) {
-      atEnd = $from.end(d2) == $from.pos + ($from.depth - d2);
-      atStart = $from.start(d2) == $from.pos - ($from.depth - d2);
-      deflt = defaultBlockAt$1($from.node(d2 - 1).contentMatchAt($from.indexAfter(d2 - 1)));
-      types.unshift(null);
-      splitDepth = d2;
-      break;
-    } else {
-      if (d2 == 1) return false;
-      types.unshift(null);
-    }
-  }
-  let tr = state.tr;
-  if (state.selection instanceof TextSelection || state.selection instanceof AllSelection) tr.deleteSelection();
-  let splitPos = tr.mapping.map($from.pos);
-  let can = canSplit(tr.doc, splitPos, types.length, types);
-  if (!can) {
-    types[0] = deflt ? { type: deflt } : null;
-    can = canSplit(tr.doc, splitPos, types.length, types);
-  }
-  if (!can) return false;
-  tr.split(splitPos, types.length, types);
-  if (!atEnd && atStart && $from.node(splitDepth).type != deflt) {
-    let first2 = tr.mapping.map($from.before(splitDepth)), $first = tr.doc.resolve(first2);
-    if (deflt && $from.node(splitDepth - 1).canReplaceWith($first.index(), $first.index() + 1, deflt))
-      tr.setNodeMarkup(tr.mapping.map($from.before(splitDepth)), deflt);
-  }
-  if (dispatch) dispatch(tr.scrollIntoView());
-  return true;
-}
 const Run = OxmlNode.create({
   name: "run",
   oXmlName: "w:r",
@@ -17851,6 +18688,387 @@ const Run = OxmlNode.create({
     return ["span", base2, 0];
   }
 });
+const inputRegex$1 = /^\s*([-+*])\s$/;
+const BulletList = Node$1.create({
+  name: "bulletList",
+  group: "block list",
+  selectable: false,
+  content() {
+    return `${this.options.itemTypeName}+`;
+  },
+  addOptions() {
+    return {
+      itemTypeName: "listItem",
+      htmlAttributes: {
+        "aria-label": "Bullet list node"
+      },
+      keepMarks: true,
+      keepAttributes: false
+    };
+  },
+  parseDOM() {
+    return [{ tag: "ul" }];
+  },
+  renderDOM({ htmlAttributes }) {
+    const attributes = Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+    return ["ul", attributes, 0];
+  },
+  addAttributes() {
+    return {
+      "list-style-type": {
+        default: "bullet",
+        rendered: false
+      },
+      listId: {
+        rendered: false
+      },
+      sdBlockId: {
+        default: null,
+        keepOnSplit: false,
+        parseDOM: (elem) => elem.getAttribute("data-sd-block-id"),
+        renderDOM: (attrs) => {
+          return attrs.sdBlockId ? { "data-sd-block-id": attrs.sdBlockId } : {};
+        }
+      },
+      attributes: {
+        rendered: false,
+        keepOnSplit: true
+      }
+    };
+  },
+  addCommands() {
+    return {
+      /**
+       * Toggle a bullet list at the current selection
+       * @category Command
+       * @example
+       * // Toggle bullet list on selected text
+       * editor.commands.toggleBulletList()
+       * @note Converts selected paragraphs to list items or removes list formatting
+       */
+      toggleBulletList: () => (params2) => {
+        return toggleList(this.type)(params2);
+      }
+    };
+  },
+  addShortcuts() {
+    return {
+      "Mod-Shift-8": () => {
+        return this.editor.commands.toggleBulletList();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      new InputRule({
+        match: inputRegex$1,
+        handler: ({ state, range }) => {
+          const $pos = state.selection.$from;
+          const listItemType = state.schema.nodes.listItem;
+          for (let depth = $pos.depth; depth >= 0; depth--) {
+            if ($pos.node(depth).type === listItemType) {
+              return null;
+            }
+          }
+          const { tr } = state;
+          tr.delete(range.from, range.to);
+          ListHelpers.createNewList({
+            listType: this.type,
+            tr,
+            editor: this.editor
+          });
+        }
+      })
+    ];
+  }
+});
+const inputRegex = /^(\d+)\.\s$/;
+const OrderedList = Node$1.create({
+  name: "orderedList",
+  group: "block list",
+  selectable: false,
+  content() {
+    return `${this.options.itemTypeName}+`;
+  },
+  addOptions() {
+    return {
+      itemTypeName: "listItem",
+      htmlAttributes: {
+        "aria-label": "Ordered list node"
+      },
+      keepMarks: true,
+      keepAttributes: false,
+      listStyleTypes: ["decimal", "lowerAlpha", "lowerRoman"]
+    };
+  },
+  addAttributes() {
+    return {
+      order: {
+        default: 1,
+        parseDOM: (element) => {
+          return element.hasAttribute("start") ? parseInt(element.getAttribute("start") || "", 10) : 1;
+        },
+        renderDOM: (attrs) => {
+          return {
+            start: attrs.order
+          };
+        }
+      },
+      sdBlockId: {
+        default: null,
+        keepOnSplit: false,
+        parseDOM: (elem) => elem.getAttribute("data-sd-block-id"),
+        renderDOM: (attrs) => {
+          return attrs.sdBlockId ? { "data-sd-block-id": attrs.sdBlockId } : {};
+        }
+      },
+      syncId: {
+        default: null,
+        parseDOM: (elem) => elem.getAttribute("data-sync-id"),
+        renderDOM: (attrs) => {
+          if (!attrs.syncId) return {};
+          return {
+            "data-sync-id": attrs.syncId
+          };
+        }
+        // rendered: false,
+      },
+      listId: {
+        keepOnSplit: true,
+        parseDOM: (elem) => elem.getAttribute("data-list-id"),
+        renderDOM: (attrs) => {
+          if (!attrs.listId) return {};
+          return {
+            "data-list-id": attrs.listId
+          };
+        }
+      },
+      "list-style-type": {
+        default: "decimal",
+        rendered: false
+      },
+      attributes: {
+        rendered: false,
+        keepOnSplit: true
+      }
+    };
+  },
+  parseDOM() {
+    return [{ tag: "ol" }];
+  },
+  renderDOM({ htmlAttributes }) {
+    const { start: start2, ...restAttributes } = htmlAttributes;
+    return start2 === 1 ? ["ol", Attribute.mergeAttributes(this.options.htmlAttributes, restAttributes), 0] : ["ol", Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+  },
+  addCommands() {
+    return {
+      /**
+       * Toggle ordered list formatting
+       * @category Command
+       * @example
+       * editor.commands.toggleOrderedList()
+       * @note Converts selection to ordered list or back to paragraphs
+       */
+      toggleOrderedList: () => (params2) => {
+        return toggleList(this.type)(params2);
+      },
+      /**
+       * Restart list node numbering
+       * @category Command
+       * @param {Array} followingNodes - Nodes to restart
+       * @param {number} pos - Starting position
+       * @example
+       * editor.commands.restartListNodes(nodes, position)
+       * @note Resets list numbering for specified nodes
+       */
+      restartListNodes: (followingNodes, pos) => ({ tr }) => {
+        let currentNodePos = pos;
+        const nodes = followingNodes.map((node) => {
+          const resultNode = {
+            node,
+            pos: currentNodePos
+          };
+          currentNodePos += node.nodeSize;
+          return resultNode;
+        });
+        nodes.forEach((item) => {
+          const { pos: pos2 } = item;
+          const newPos = tr.mapping.map(pos2);
+          tr.setNodeMarkup(newPos, void 0, {});
+        });
+        return true;
+      },
+      /**
+       * Update ordered list style type based on nesting level
+       * @category Command
+       * @example
+       * editor.commands.updateOrderedListStyleType()
+       * @note Cycles through decimal -> lowerAlpha -> lowerRoman based on depth
+       */
+      updateOrderedListStyleType: () => ({ dispatch, tr }) => {
+        let list = findParentNode((node) => node.type.name === this.name)(tr.selection);
+        if (!list) {
+          return true;
+        }
+        if (dispatch) {
+          let listLevel = (list.depth - 1) / 2;
+          let listStyleTypes = this.options.listStyleTypes;
+          let listStyle = listStyleTypes[listLevel % listStyleTypes.length];
+          let currentListStyle = list.node.attrs["list-style-type"];
+          let nodeAtPos = tr.doc.nodeAt(list.pos);
+          if (currentListStyle !== listStyle && nodeAtPos.eq(list.node)) {
+            tr.setNodeMarkup(list.pos, void 0, {
+              ...list.node.attrs,
+              ...{
+                "list-style-type": listStyle
+              }
+            });
+          }
+        }
+        return true;
+      }
+    };
+  },
+  addShortcuts() {
+    return {
+      "Mod-Shift-7": () => {
+        return this.editor.commands.toggleOrderedList();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      new InputRule({
+        match: inputRegex,
+        handler: ({ state, range }) => {
+          const $pos = state.selection.$from;
+          const listItemType = state.schema.nodes.listItem;
+          for (let depth = $pos.depth; depth >= 0; depth--) {
+            if ($pos.node(depth).type === listItemType) {
+              return null;
+            }
+          }
+          const { tr } = state;
+          tr.delete(range.from, range.to);
+          ListHelpers.createNewList({
+            listType: this.type,
+            tr,
+            editor: this.editor
+          });
+        }
+      })
+    ];
+  }
+});
+const generateOrderedListIndex = ({ listLevel, lvlText, listNumberingType, customFormat }) => {
+  const handler = listIndexMap[listNumberingType];
+  return handler ? handler(listLevel, lvlText, customFormat) : null;
+};
+const handleDecimal = (path, lvlText) => generateNumbering(path, lvlText, String);
+const handleRoman = (path, lvlText) => generateNumbering(path, lvlText, intToRoman);
+const handleLowerRoman = (path, lvlText) => handleRoman(path, lvlText).toLowerCase();
+const handleLowerAlpha = (path, lvlText) => handleAlpha(path, lvlText).toLowerCase();
+const handleAlpha = (path, lvlText) => generateNumbering(path, lvlText, (p) => intToAlpha(p));
+const handleOrdinal = (path, lvlText) => generateNumbering(path, lvlText, ordinalFormatter);
+const handleCustom = (path, lvlText, customFormat) => generateFromCustom(path, lvlText, customFormat);
+const handleJapaneseCounting = (path, lvlText) => generateNumbering(path, lvlText, intToJapaneseCounting);
+const listIndexMap = {
+  decimal: handleDecimal,
+  lowerRoman: handleLowerRoman,
+  upperRoman: handleRoman,
+  lowerLetter: handleLowerAlpha,
+  upperLetter: handleAlpha,
+  ordinal: handleOrdinal,
+  custom: handleCustom,
+  japaneseCounting: handleJapaneseCounting
+};
+const createNumbering = (values, lvlText) => {
+  return values.reduce((acc, value, index2) => {
+    return value > 9 ? acc.replace(/^0/, "").replace(`%${index2 + 1}`, value) : acc.replace(`%${index2 + 1}`, value);
+  }, lvlText);
+};
+const generateNumbering = (path, lvlText, formatter) => {
+  const formattedValues = path.map(formatter);
+  return createNumbering(formattedValues, lvlText);
+};
+const ordinalFormatter = (level) => {
+  const suffixes = ["th", "st", "nd", "rd"];
+  const value = level % 100;
+  const suffix = suffixes[(value - 20) % 10] || suffixes[value] || suffixes[0];
+  const p = level + suffix;
+  return p;
+};
+const generateFromCustom = (path, lvlText, customFormat) => {
+  if (customFormat !== "001, 002, 003, ...") return generateNumbering(path, lvlText, String);
+  const match = customFormat.match(/(\d+)/);
+  if (!match) throw new Error("Invalid format string: no numeric pattern found");
+  const sample = match[1];
+  const digitCount = sample.length;
+  const index2 = path.pop();
+  return String(index2).padStart(digitCount, "0");
+};
+const intToRoman = (num) => {
+  const romanNumeralMap = [
+    { value: 1e3, numeral: "M" },
+    { value: 900, numeral: "CM" },
+    { value: 500, numeral: "D" },
+    { value: 400, numeral: "CD" },
+    { value: 100, numeral: "C" },
+    { value: 90, numeral: "XC" },
+    { value: 50, numeral: "L" },
+    { value: 40, numeral: "XL" },
+    { value: 10, numeral: "X" },
+    { value: 9, numeral: "IX" },
+    { value: 5, numeral: "V" },
+    { value: 4, numeral: "IV" },
+    { value: 1, numeral: "I" }
+  ];
+  let result = "";
+  for (const { value, numeral } of romanNumeralMap) {
+    while (num >= value) {
+      result += numeral;
+      num -= value;
+    }
+  }
+  return result;
+};
+const intToAlpha = (num) => {
+  let result = "";
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  while (num > 0) {
+    let index2 = (num - 1) % 26;
+    result = alphabet[index2] + result;
+    num = Math.floor((num - 1) / 26);
+  }
+  return result;
+};
+const intToJapaneseCounting = (num) => {
+  const digits = ["", "一", "二", "三", "四", "五", "六", "七", "八", "九"];
+  const units = ["", "十", "百", "千"];
+  if (num === 0) return "零";
+  if (num < 10) return digits[num];
+  let result = "";
+  let tempNum = num;
+  let unitIndex = 0;
+  while (tempNum > 0) {
+    const digit = tempNum % 10;
+    if (digit !== 0) {
+      const digitStr = digit === 1 && unitIndex > 0 ? "" : digits[digit];
+      result = digitStr + (unitIndex > 0 ? units[unitIndex] : "") + result;
+    } else if (result && tempNum > 0) {
+      if (!result.startsWith("零") && tempNum % 100 !== 0) {
+        result = "零" + result;
+      }
+    }
+    tempNum = Math.floor(tempNum / 10);
+    unitIndex++;
+    if (unitIndex > 3) break;
+  }
+  if (num >= 10 && num < 20) {
+    result = result.replace(/^一十/, "十");
+  }
+  return result;
+};
 const isKeyboardInvocation = (event) => {
   return event.type === "contextmenu" && typeof event.detail === "number" && event.detail === 0 && (event.button === 0 || event.button === void 0) && event.clientX === 0 && event.clientY === 0;
 };
@@ -18139,53 +19357,20 @@ const getLinkedStyle = (styleId, styles = []) => {
   return { linkedStyle, basedOnStyle };
 };
 const getSpacingStyle = (spacing) => {
-  const { lineSpaceBefore, lineSpaceAfter, line, lineRule, beforeAutoSpacing, afterAutoSpacing } = spacing;
+  const { lineSpaceBefore, lineSpaceAfter, line, lineRule } = spacing;
   const lineHeightResult = getLineHeightValueString(line, "", lineRule, true);
   const lineHeightStyles = typeof lineHeightResult === "object" && lineHeightResult !== null ? lineHeightResult : {};
-  const result = {};
-  if (!beforeAutoSpacing) {
-    result["margin-top"] = lineSpaceBefore + "px";
-  }
-  if (!afterAutoSpacing) {
-    result["margin-bottom"] = lineSpaceAfter + "px";
-  }
   return {
-    ...result,
+    "margin-top": lineSpaceBefore + "px",
+    "margin-bottom": lineSpaceAfter + "px",
     ...lineHeightStyles
   };
 };
-const getSpacingStyleString = (spacing, marks, isListItem) => {
-  let { before, after, line, lineRule, beforeAutospacing, afterAutospacing } = spacing;
-  line = twipsToLines(line);
-  if (line != null && line < 1) {
-    line = 1;
-  }
-  if (lineRule === "exact" && line) {
-    line = String(line);
-  }
-  const textStyleMark = marks?.find((mark) => mark.type === "textStyle");
-  const fontSize = textStyleMark?.attrs?.fontSize;
-  before = twipsToPixels(before);
-  if (beforeAutospacing) {
-    if (fontSize) {
-      before += halfPointToPixels(parseInt(fontSize) * 0.5);
-    }
-    if (isListItem) {
-      before = 0;
-    }
-  }
-  after = twipsToPixels(after);
-  if (afterAutospacing) {
-    if (fontSize) {
-      after += halfPointToPixels(parseInt(fontSize) * 0.5);
-    }
-    if (isListItem) {
-      after = 0;
-    }
-  }
+const getSpacingStyleString = (spacing) => {
+  const { lineSpaceBefore, lineSpaceAfter, line } = spacing;
   return `
-    ${before ? `margin-top: ${before}px;` : ""}
-    ${after ? `margin-bottom: ${after}px;` : ""}
+    ${lineSpaceBefore ? `margin-top: ${lineSpaceBefore}px;` : ""}
+    ${lineSpaceAfter ? `margin-bottom: ${lineSpaceAfter}px;` : ""}
     ${line ? getLineHeightValueString(line, "") : ""}
   `.trim();
 };
@@ -18683,1073 +19868,850 @@ const LinkedStyles = Extension.create({
     };
   }
 });
-const getDefaultSpacing = () => ({
-  after: null,
-  before: null,
-  line: null,
-  lineRule: "auto"
-});
-const restartNumbering = ({ editor, tr, state, dispatch }) => {
-  const { node: paragraph, pos } = findParentNode(isList)(state.selection) || {};
-  if (!paragraph) return false;
-  const allParagraphs = [{ node: paragraph, pos }];
-  const startPos = pos + paragraph.nodeSize;
-  const myNumId = paragraph.attrs.numberingProperties.numId;
-  let stop = false;
-  state.doc.nodesBetween(startPos, state.doc.content.size, (node, nodePos) => {
-    if (node.type.name === "paragraph") {
-      if (isList(node) && node.attrs.paragraphProperties?.numberingProperties?.numId === myNumId) {
-        allParagraphs.push({ node, pos: nodePos });
-      } else {
-        stop = true;
-      }
-      return false;
-    }
-    return !stop;
-  });
-  const { numberingType } = paragraph.attrs.listRendering || {};
-  const listType = numberingType === "bullet" ? "bulletList" : "orderedList";
-  const numId = ListHelpers.getNewListId(editor);
-  ListHelpers.generateNewListDefinition({ numId: Number(numId), listType, editor });
-  allParagraphs.forEach(({ node, pos: pos2 }) => {
-    updateNumberingProperties(
-      {
-        ...node.attrs.numberingProperties,
-        numId: Number(numId)
-      },
-      node,
-      pos2,
-      editor,
-      tr
-    );
-  });
-  if (dispatch) dispatch(tr);
-  return true;
-};
-const defaultTabDistance = 48;
-const defaultLineLength = 816;
-const getTabDecorations = (doc2, view, helpers2, from2 = 0, to = null) => {
-  const decorations = [];
-  const paragraphCache = /* @__PURE__ */ new Map();
-  const coordCache = /* @__PURE__ */ new Map();
-  const domPosCache = /* @__PURE__ */ new Map();
-  const end2 = to ?? doc2.content.size;
-  doc2.nodesBetween(from2, end2, (node, pos) => {
-    if (node.type.name !== "tab") return;
-    const $pos = doc2.resolve(pos);
-    const paragraphContext = findParagraphContext($pos, paragraphCache, helpers2);
-    if (!paragraphContext) return;
-    const blockParent2 = $pos.node(paragraphContext.paragraphDepth);
-    const style = calculateTabStyle(node.nodeSize, view, pos, blockParent2, paragraphContext, coordCache, domPosCache);
-    if (style) {
-      decorations.push(
-        Decoration.node(pos, pos + node.nodeSize, {
-          style
-        })
-      );
-    }
-  });
-  return decorations;
-};
-function calculateTabStyle(nodeSize2, view, pos, blockParent2, paragraphContext, coordCache = null, domPosCache = null) {
-  let extraStyles = "";
-  try {
-    const { tabStops, flattened, positionMap, startPos } = paragraphContext;
-    if (paragraphContext.indentWidth === void 0) {
-      paragraphContext.indentWidth = getIndentWidth(view, startPos, paragraphContext.indent, coordCache, domPosCache);
-    }
-    if (paragraphContext.tabHeight === void 0) {
-      paragraphContext.tabHeight = calcTabHeight(blockParent2);
-    }
-    if (paragraphContext.paragraphWidth === void 0) {
-      paragraphContext.paragraphWidth = getBlockNodeWidth(view, startPos);
-    }
-    const indentWidth = paragraphContext.indentWidth;
-    const hanging = twipsToPixels(Number(paragraphContext.indent.hanging) || 0);
-    if (hanging > 0) {
-      tabStops.unshift({ val: "start", pos: indentWidth + hanging });
-    }
-    const accumulatedTabWidth = paragraphContext.accumulatedTabWidth || 0;
-    const currentWidth = indentWidth + measureRangeWidth(view, startPos + 1, pos, coordCache, domPosCache) + accumulatedTabWidth;
-    let tabWidth;
-    if (tabStops.length) {
-      const tabStop = tabStops.find((stop) => stop.pos > currentWidth && stop.val !== "clear");
-      if (tabStop) {
-        tabWidth = Math.min(tabStop.pos, paragraphContext.paragraphWidth) - currentWidth;
-        let val = tabStop.val;
-        const aliases = { left: "start", right: "end" };
-        if (aliases[val]) val = aliases[val];
-        if (val === "center" || val === "end" || val === "right") {
-          const entryIndex = positionMap.get(pos);
-          if (entryIndex === void 0) return;
-          const nextTabIndex = findNextTabIndex(flattened, entryIndex + 1);
-          const segmentStartPos = pos + nodeSize2;
-          const segmentEndPos = nextTabIndex === -1 ? startPos + paragraphContext.paragraph.nodeSize - 1 : flattened[nextTabIndex].pos;
-          const segmentWidth = measureRangeWidth(view, segmentStartPos, segmentEndPos, coordCache, domPosCache);
-          tabWidth -= val === "center" ? segmentWidth / 2 : segmentWidth;
-        } else if (val === "decimal" || val === "num") {
-          const entryIndex = positionMap.get(pos);
-          if (entryIndex === void 0) return;
-          const breakChar = tabStop.decimalChar || ".";
-          const decimalPos = findDecimalBreakPos(flattened, entryIndex + 1, breakChar);
-          const integralWidth = decimalPos ? measureRangeWidth(view, pos + nodeSize2, decimalPos, coordCache, domPosCache) : measureRangeWidth(
-            view,
-            pos + nodeSize2,
-            startPos + paragraphContext.paragraph.nodeSize - 1,
-            coordCache,
-            domPosCache
-          );
-          tabWidth -= integralWidth;
-        }
-        if (tabStop.leader) {
-          const leaderStyles = {
-            dot: "border-bottom: 1px dotted black;",
-            heavy: "border-bottom: 2px solid black;",
-            hyphen: "border-bottom: 1px solid black;",
-            middleDot: "border-bottom: 1px dotted black; margin-bottom: 2px;",
-            underscore: "border-bottom: 1px solid black;"
-          };
-          extraStyles += leaderStyles[tabStop.leader] || "";
-        }
+function getUnderlineCssString({ type = "single", color = null, thickness = null, approximate = true } = {}) {
+  const parts = [];
+  const add = (k2, v) => {
+    if (!v) return;
+    parts.push(`${k2}: ${v}`);
+  };
+  const lower = String(type || "single").toLowerCase();
+  if (lower === "none" || lower === "0") {
+    add("text-decoration", "none");
+    return parts.join("; ");
+  }
+  add("text-decoration-line", "underline");
+  const HEAVY = thickness || "0.2em";
+  const THICK = thickness || "0.15em";
+  switch (lower) {
+    case "single":
+      break;
+    case "double":
+      add("text-decoration-style", "double");
+      break;
+    case "thick":
+      add("text-decoration-thickness", THICK);
+      break;
+    case "dotted":
+      add("text-decoration-style", "dotted");
+      break;
+    case "dash":
+    case "dashed":
+      add("text-decoration-style", "dashed");
+      break;
+    case "dotdash":
+    case "dotdotdash":
+    case "dashlong":
+    case "dashlongheavy":
+      if (approximate) {
+        add("text-decoration-style", "dashed");
+        if (lower.includes("heavy")) add("text-decoration-thickness", HEAVY);
       }
-    }
-    if (!tabWidth || tabWidth < 1) {
-      tabWidth = defaultTabDistance - currentWidth % defaultLineLength % defaultTabDistance;
-      if (tabWidth === 0) tabWidth = defaultTabDistance;
-    }
-    const tabHeight = paragraphContext.tabHeight;
-    paragraphContext.accumulatedTabWidth = accumulatedTabWidth + tabWidth;
-    return `width: ${tabWidth}px; height: ${tabHeight}; ${extraStyles}`;
-  } catch (error) {
-    console.error("tab decoration error", error);
-  }
-}
-function findParagraphContext($pos, cache, helpers2) {
-  for (let depth = $pos.depth; depth >= 0; depth--) {
-    const node = $pos.node(depth);
-    if (node?.type?.name === "paragraph") {
-      const startPos = $pos.start(depth);
-      if (!cache.has(startPos)) {
-        const paragraphContext = extractParagraphContext(node, startPos, helpers2, depth);
-        cache.set(startPos, paragraphContext);
+      break;
+    case "dottedheavy":
+      add("text-decoration-style", "dotted");
+      add("text-decoration-thickness", HEAVY);
+      break;
+    case "dashedheavy":
+      add("text-decoration-style", "dashed");
+      add("text-decoration-thickness", HEAVY);
+      break;
+    case "wavy":
+      add("text-decoration-style", "wavy");
+      break;
+    case "wavyheavy":
+      add("text-decoration-style", "wavy");
+      add("text-decoration-thickness", HEAVY);
+      break;
+    case "wavydouble":
+      if (approximate) {
+        add("text-decoration-style", "wavy");
+        add("text-decoration-thickness", HEAVY);
       }
-      return cache.get(startPos);
-    }
+      break;
   }
-  return null;
+  if (color) add("text-decoration-color", color);
+  return parts.join("; ");
 }
-function extractParagraphContext(node, startPos, helpers2, depth = 0) {
-  let tabStops = [];
-  if (Array.isArray(node.attrs?.tabStops)) {
-    tabStops = node.attrs.tabStops.map((stop) => {
-      const ref2 = stop?.tab;
-      if (!ref2) return stop || null;
-      return {
-        val: ref2.tabType || "start",
-        pos: twipsToPixels(Number(ref2.pos) || 0),
-        leader: ref2.leader
-      };
-    }).filter(Boolean);
-  } else {
-    const style = helpers2.linkedStyles.getStyleById(node.attrs?.styleId);
-    if (Array.isArray(style?.definition?.styles?.tabStops)) {
-      tabStops = style.definition.styles.tabStops;
-    }
+function collectTextStyleMarks(listItem, markType) {
+  const textStyleMarks = [];
+  const seenMarks = /* @__PURE__ */ new Set();
+  const attrs = {};
+  if (!markType) {
+    return {
+      marks: textStyleMarks,
+      attrs
+    };
   }
-  const { entries, positionMap } = flattenParagraph(node, startPos);
-  return {
-    paragraph: node,
-    paragraphDepth: depth,
-    startPos,
-    indent: node.attrs?.indent || {},
-    tabStops,
-    flattened: entries,
-    positionMap,
-    // Store position map for O(1) lookups
-    accumulatedTabWidth: 0
-  };
-}
-function flattenParagraph(paragraph, paragraphStartPos) {
-  const entries = [];
-  const positionMap = /* @__PURE__ */ new Map();
-  const walk = (node, basePos) => {
+  const collectMarks = (node) => {
     if (!node) return;
-    if (node.type?.name === "run") {
-      node.forEach((child, offset2) => {
-        const childPos = basePos + offset2 + 1;
-        walk(child, childPos);
+    const candidateMarks = Array.isArray(node.marks) ? node.marks : [];
+    if (candidateMarks.length && typeof markType.isInSet === "function" && markType.isInSet(candidateMarks)) {
+      candidateMarks.forEach((mark) => {
+        if (mark.type === markType && !seenMarks.has(mark)) {
+          seenMarks.add(mark);
+          textStyleMarks.push(mark);
+        }
       });
-      return;
     }
-    const pos = basePos - 1;
-    const index2 = entries.length;
-    entries.push({ node, pos });
-    positionMap.set(pos, index2);
+    if (!node.isText && node.childCount) {
+      node.forEach((child) => collectMarks(child));
+    }
   };
-  paragraph.forEach((child, offset2) => {
-    const childPos = paragraphStartPos + offset2 + 1;
-    walk(child, childPos);
+  listItem.forEach((childNode) => {
+    if (childNode.type?.name !== "paragraph") return;
+    if (childNode.attrs?.lineHeight !== void 0) {
+      attrs.lineHeight = childNode.attrs.lineHeight;
+    }
+    collectMarks(childNode);
   });
-  return { entries, positionMap };
+  return {
+    marks: textStyleMarks,
+    attrs
+  };
 }
-function findNextTabIndex(flattened, fromIndex) {
-  for (let i = fromIndex; i < flattened.length; i++) {
-    if (flattened[i]?.node?.type?.name === "tab") {
-      return i;
-    }
+function parseSizeFromRunProperties(listRunProperties) {
+  const val = listRunProperties?.["w:val"] || listRunProperties?.["w:sz"];
+  if (val == null) return null;
+  const numeric = Number(val);
+  if (Number.isNaN(numeric) || numeric <= 0) return null;
+  const sizeInPoints = numeric / 2;
+  return `${sizeInPoints}pt`;
+}
+function parseFontFamilyFromRunProperties(listRunProperties) {
+  const ascii = listRunProperties?.["w:ascii"];
+  const hAnsi = listRunProperties?.["w:hAnsi"];
+  const eastAsia = listRunProperties?.["w:eastAsia"];
+  return ascii || hAnsi || eastAsia || null;
+}
+const computedStylesCache = /* @__PURE__ */ new WeakMap();
+function clearComputedStyleCache(domNode) {
+  if (domNode) {
+    computedStylesCache.delete(domNode);
   }
-  return -1;
 }
-function findDecimalBreakPos(flattened, startIndex, breakChar) {
-  for (let i = startIndex; i < flattened.length; i++) {
-    const entry = flattened[i];
-    if (!entry) break;
-    if (entry.node.type?.name === "tab") break;
-    if (entry.node.type?.name === "text") {
-      const index2 = entry.node.text?.indexOf(breakChar);
-      if (index2 !== void 0 && index2 !== -1) {
-        return entry.pos + index2 + 1;
-      }
-    }
+function readNodeViewStyles(view) {
+  const fallback = { fontSize: null, fontFamily: null, lineHeight: null };
+  if (!view?.dom) return fallback;
+  const inline = {
+    fontSize: view.dom.style?.fontSize || null,
+    fontFamily: view.dom.style?.fontFamily || null,
+    lineHeight: view.dom.style?.lineHeight || null
+  };
+  if (inline.fontSize && inline.fontFamily && inline.lineHeight) return inline;
+  if (computedStylesCache.has(view.dom)) {
+    const cached = computedStylesCache.get(view.dom);
+    return {
+      fontSize: inline.fontSize || cached.fontSize,
+      fontFamily: inline.fontFamily || cached.fontFamily,
+      lineHeight: inline.lineHeight || cached.lineHeight
+    };
   }
-  return null;
-}
-function measureRangeWidth(view, from2, to, coordCache = null, domPosCache = null) {
-  if (!Number.isFinite(from2) || !Number.isFinite(to) || to <= from2) return 0;
-  try {
-    const range = document.createRange();
-    const fromRef = getCachedDomAtPos(view, from2, domPosCache);
-    const toRef = getCachedDomAtPos(view, to, domPosCache);
-    range.setStart(fromRef.node, fromRef.offset);
-    range.setEnd(toRef.node, toRef.offset);
-    const rect = range.getBoundingClientRect();
-    range.detach?.();
-    return rect.width || 0;
-  } catch {
-    const startLeft = getLeftCoord(view, from2, coordCache, domPosCache);
-    const endLeft = getLeftCoord(view, to, coordCache, domPosCache);
-    if (startLeft == null || endLeft == null) return 0;
-    return Math.max(0, endLeft - startLeft);
+  const globalWindow = typeof window !== "undefined" ? window : void 0;
+  if (globalWindow?.getComputedStyle) {
+    const computed2 = globalWindow.getComputedStyle(view.dom);
+    const computedStyles = {
+      fontSize: computed2.fontSize,
+      fontFamily: computed2.fontFamily,
+      lineHeight: computed2.lineHeight
+    };
+    computedStylesCache.set(view.dom, computedStyles);
+    return {
+      fontSize: inline.fontSize || computedStyles.fontSize,
+      fontFamily: inline.fontFamily || computedStyles.fontFamily,
+      lineHeight: inline.lineHeight || computedStyles.lineHeight
+    };
   }
+  return inline;
 }
-function getIndentWidth(view, paragraphStartPos, indentAttrs = {}, coordCache = null, domPosCache = null) {
-  const marginLeft = getLeftCoord(view, paragraphStartPos, coordCache, domPosCache);
-  const lineLeft = getLeftCoord(view, paragraphStartPos + 1, coordCache, domPosCache);
-  if (marginLeft != null && lineLeft != null) {
-    const diff = lineLeft - marginLeft;
-    if (!Number.isNaN(diff) && Math.abs(diff) > 0.5) {
-      return diff;
+function getAdjacentListItemNodeView({ nodeView, pos, direction, activeNodeViews }) {
+  if (!activeNodeViews) return null;
+  let candidate = null;
+  activeNodeViews.forEach((view) => {
+    if (view === nodeView) return;
+    let viewPos;
+    try {
+      if (typeof view.getResolvedPos === "function") {
+        viewPos = view.getResolvedPos();
+      } else if (typeof view.getPos === "function") {
+        viewPos = view.getPos();
+      }
+    } catch {
+      return;
     }
-  }
-  return calculateIndentFallback(indentAttrs);
+    if (typeof viewPos !== "number") return;
+    if (viewPos < pos) {
+      if (!candidate || viewPos > candidate.pos) candidate = { view, pos: viewPos };
+    }
+  });
+  return candidate?.view ?? null;
 }
-function getBlockNodeWidth(view, blockStartPos) {
-  const blockDom = view.nodeDOM(blockStartPos - 1);
-  if (blockDom instanceof HTMLElement) {
-    const styles = window.getComputedStyle(blockDom);
-    const width = blockDom.clientWidth + parseFloat(styles.marginLeft || "0") + parseFloat(styles.marginRight || "0") + parseFloat(styles.borderLeftWidth || "0") + parseFloat(styles.borderRightWidth || "0") + parseFloat(styles.paddingLeft || "0") + parseFloat(styles.paddingRight || "0");
-    return width;
+function findSiblingListItem({ editor, pos, direction }) {
+  if (typeof pos !== "number" || !editor?.view) return null;
+  const { state } = editor.view;
+  const $pos = state.doc.resolve(pos);
+  const parentDepth = $pos.depth - 1;
+  if (parentDepth < 0) return null;
+  const parent = $pos.node(parentDepth);
+  if (!parent) return null;
+  const indexInsideParent = $pos.index(parentDepth);
+  const siblingIndex = indexInsideParent + direction;
+  if (siblingIndex < 0 || siblingIndex >= parent.childCount) return null;
+  const sibling = parent.child(siblingIndex);
+  return sibling?.type?.name === "listItem" ? sibling : null;
+}
+function deriveFontStylesFromNode({ node, textStyleType, defaultFont, defaultSize, listRunProperties }) {
+  const { marks: allMarks, attrs } = collectTextStyleMarks(node, textStyleType);
+  const styleMarks = textStyleType ? allMarks.filter((m) => m.type === textStyleType) : [];
+  const sizeMark = styleMarks.find((m) => m.attrs?.fontSize);
+  const familyMark = styleMarks.find((m) => m.attrs?.fontFamily);
+  let fontSize = defaultSize;
+  if (sizeMark) {
+    const [value, unit = "pt"] = parseSizeUnit(sizeMark.attrs.fontSize);
+    if (!Number.isNaN(value)) {
+      fontSize = `${value}${unit}`;
+    }
+  }
+  let hasSize = Boolean(sizeMark);
+  if (!hasSize && listRunProperties) {
+    const sizeFromList = parseSizeFromRunProperties(listRunProperties);
+    if (sizeFromList) {
+      fontSize = sizeFromList;
+      hasSize = true;
+    }
+  }
+  let fontFamily = familyMark?.attrs?.fontFamily ?? defaultFont;
+  let hasFamily = Boolean(familyMark);
+  if (!hasFamily && listRunProperties) {
+    const fontFromList = parseFontFamilyFromRunProperties(listRunProperties);
+    if (fontFromList) {
+      fontFamily = fontFromList;
+      hasFamily = true;
+    }
+  }
+  let lineHeight = attrs.lineHeight;
+  const firstChild = node.firstChild;
+  const hasOnlyOnePar = node.childCount === 1 && firstChild?.type?.name === "paragraph";
+  if (hasOnlyOnePar) {
+    const par = firstChild;
+    const parFirstChild = par?.firstChild;
+    if (par?.childCount === 1 && parFirstChild?.type?.name === "fieldAnnotation") {
+      const aFontSize = parFirstChild.attrs?.fontSize;
+      const aFontFamily = parFirstChild.attrs?.fontFamily;
+      if (!sizeMark && aFontSize) fontSize = aFontSize;
+      if (!familyMark && aFontFamily) fontFamily = aFontFamily;
+    }
   }
-  return defaultLineLength;
+  return {
+    fontSize,
+    fontFamily,
+    lineHeight,
+    hasSize,
+    hasFamily
+  };
 }
-function calculateIndentFallback(indentAttrs = {}) {
-  if (!indentAttrs) return 0;
-  const left2 = twipsToPixels(Number(indentAttrs.left) || 0);
-  const firstLine = twipsToPixels(Number(indentAttrs.firstLine) || 0);
-  const hanging = twipsToPixels(Number(indentAttrs.hanging) || 0);
-  let textIndent = 0;
-  if (firstLine && hanging) {
-    textIndent = firstLine - hanging;
-  } else if (firstLine) {
-    textIndent = firstLine;
-  } else if (hanging) {
-    textIndent = -hanging;
+function getStylesFromLinkedStyles({ node, pos, editor }) {
+  const { state } = editor.view;
+  const linkedStyles = LinkedStylesPluginKey.getState(state)?.decorations;
+  const decorationsInPlace = linkedStyles?.find(pos, pos + node.nodeSize);
+  const predicates = [
+    (style2) => style2.includes("font-size") && style2.includes("font-family"),
+    (style2) => style2.includes("font-size"),
+    (style2) => style2.includes("font-family")
+  ];
+  let styleDeco;
+  for (const predicateFn of predicates) {
+    styleDeco = decorationsInPlace?.find((dec) => {
+      const style2 = dec.type?.attrs?.style || "";
+      return style2 && predicateFn(style2);
+    });
+    if (styleDeco) break;
   }
-  if (textIndent) return left2 + textIndent;
-  if (left2) return left2;
-  return 0;
+  const style = styleDeco?.type?.attrs?.style;
+  const stylesArray = style?.split(";") || [];
+  const fontSizeFromStyles = stylesArray.find((s2) => s2.includes("font-size"))?.split(":")[1]?.trim();
+  const fontFamilyFromStyles = stylesArray.find((s2) => s2.includes("font-family"))?.split(":")[1]?.trim();
+  return {
+    font: fontFamilyFromStyles,
+    size: fontSizeFromStyles
+  };
 }
-function getLeftCoord(view, pos, coordCache = null, domPosCache = null) {
-  if (!Number.isFinite(pos)) return null;
-  if (coordCache && coordCache.has(pos)) {
-    return coordCache.get(pos);
-  }
-  let result = null;
-  try {
-    result = view.coordsAtPos(pos).left;
-  } catch {
-    try {
-      const ref2 = getCachedDomAtPos(view, pos, domPosCache);
-      const range = document.createRange();
-      range.setStart(ref2.node, ref2.offset);
-      range.setEnd(ref2.node, ref2.offset);
-      const rect = range.getBoundingClientRect();
-      range.detach?.();
-      result = rect.left;
-    } catch {
-      result = null;
+function resolveListItemTypography({ node, pos, editor, nodeView, activeNodeViews }) {
+  const defaults = getStylesFromLinkedStyles({ node, pos, editor });
+  const textStyleType = getMarkType("textStyle", editor.schema);
+  const currentStyles = deriveFontStylesFromNode({
+    node,
+    textStyleType,
+    defaultFont: defaults.font,
+    defaultSize: defaults.size,
+    listRunProperties: node.attrs?.listRunProperties
+  });
+  if ((!currentStyles.hasSize || !currentStyles.hasFamily || !currentStyles.lineHeight) && editor?.view) {
+    const previousListItem = findSiblingListItem({ editor, pos, direction: -1 });
+    if (previousListItem) {
+      const previousStyles = deriveFontStylesFromNode({
+        node: previousListItem,
+        textStyleType,
+        defaultFont: defaults.font,
+        defaultSize: defaults.size,
+        listRunProperties: previousListItem.attrs?.listRunProperties
+      });
+      if (!currentStyles.hasSize && previousStyles.fontSize) currentStyles.fontSize = previousStyles.fontSize;
+      if (!currentStyles.hasFamily && previousStyles.fontFamily) currentStyles.fontFamily = previousStyles.fontFamily;
+      if (!currentStyles.lineHeight && previousStyles.lineHeight) currentStyles.lineHeight = previousStyles.lineHeight;
     }
   }
-  if (coordCache) {
-    coordCache.set(pos, result);
-  }
-  return result;
-}
-function getCachedDomAtPos(view, pos, domPosCache = null) {
-  if (domPosCache && domPosCache.has(pos)) {
-    return domPosCache.get(pos);
-  }
-  const result = view.domAtPos(pos);
-  if (domPosCache) {
-    domPosCache.set(pos, result);
+  if ((!currentStyles.fontSize || !currentStyles.fontFamily || !currentStyles.lineHeight) && nodeView) {
+    const previousView = getAdjacentListItemNodeView({
+      nodeView,
+      pos,
+      direction: -1,
+      activeNodeViews
+    });
+    if (previousView) {
+      const {
+        fontSize: prevSize,
+        fontFamily: prevFamily,
+        lineHeight: prevLineHeight
+      } = readNodeViewStyles(previousView);
+      if (!currentStyles.fontSize && prevSize) currentStyles.fontSize = prevSize;
+      if (!currentStyles.fontFamily && prevFamily) currentStyles.fontFamily = prevFamily;
+      if (!currentStyles.lineHeight && prevLineHeight) currentStyles.lineHeight = prevLineHeight;
+    }
   }
-  return result;
-}
-function calcTabHeight(blockParent2) {
-  const ptToPxRatio = 1.333;
-  const defaultFontSize = 16;
-  const defaultLineHeight = 1.1;
-  const parentTextStyleMark = blockParent2.firstChild?.marks?.find((mark) => mark.type.name === "textStyle");
-  const fontSize = parseInt(parentTextStyleMark?.attrs.fontSize) * ptToPxRatio || defaultFontSize;
-  return `${fontSize * defaultLineHeight}px`;
+  return {
+    fontSize: currentStyles.fontSize,
+    fontFamily: currentStyles.fontFamily,
+    lineHeight: currentStyles.lineHeight
+  };
 }
-class ParagraphNodeView {
-  /**
-   * @param {import('prosemirror-model').Node} node Current paragraph node.
-   * @param {import('../../core/Editor').Editor} editor Editor instance providing schema/helpers.
-   * @param {() => number} getPos Position getter provided by ProseMirror.
-   * @param {import('prosemirror-view').Decoration[]} decorations Decorations applied to this node.
-   * @param {Record<string, unknown>} extensionAttrs Extra attributes declared by the paragraph extension.
-   */
-  constructor(node, editor, getPos, decorations, extensionAttrs) {
-    __privateAdd(this, _ParagraphNodeView_instances);
+const MARKER_PADDING = 6;
+const MARKER_OFFSET_RIGHT = 4;
+const MIN_MARKER_WIDTH = 20;
+const POINT_TO_PIXEL_CONVERSION_FACTOR = 1.33;
+const DEFAULT_FONT_FAMILY = "Arial, sans-serif";
+const DEFAULT_FONT_SIZE = "10pt";
+const activeListItemNodeViews = /* @__PURE__ */ new Set();
+class ListItemNodeView {
+  constructor(node, getPos, decorations, editor) {
+    __privateAdd(this, _ListItemNodeView_instances);
+    __publicField(this, "handleNumberingClick", () => {
+    });
     this.node = node;
     this.editor = editor;
-    this.getPos = getPos;
     this.decorations = decorations;
-    this.extensionAttrs = extensionAttrs;
-    this._animationFrameRequest = null;
-    this.dom = document.createElement("p");
-    this.contentDOM = document.createElement("span");
-    this.dom.appendChild(this.contentDOM);
-    if (__privateMethod(this, _ParagraphNodeView_instances, checkIsList_fn).call(this)) {
-      __privateMethod(this, _ParagraphNodeView_instances, initList_fn).call(this, node.attrs.listRendering);
-      __privateMethod(this, _ParagraphNodeView_instances, scheduleAnimation_fn).call(this, () => {
-        if (!__privateMethod(this, _ParagraphNodeView_instances, checkIsList_fn).call(this)) {
-          return;
-        }
-        __privateMethod(this, _ParagraphNodeView_instances, updateListStyles_fn).call(this);
-      });
+    this.view = editor.view;
+    this._rawGetPos = getPos;
+    this._pendingIndentRefresh = null;
+    this.getPos = () => this.getResolvedPos();
+    __privateMethod(this, _ListItemNodeView_instances, init_fn3).call(this);
+    activeListItemNodeViews.add(this);
+  }
+  getResolvedPos() {
+    if (typeof this._rawGetPos !== "function") return null;
+    try {
+      const resolved = this._rawGetPos();
+      return typeof resolved === "number" ? resolved : null;
+    } catch {
+      return null;
     }
-    __privateMethod(this, _ParagraphNodeView_instances, updateHTMLAttributes_fn).call(this);
   }
-  /**
-   * @param {import('prosemirror-model').Node} node
-   * @param {import('prosemirror-view').Decoration[]} decorations
-   */
+  invalidateResolvedPos() {
+  }
+  refreshIndentStyling({ immediate = false } = {}) {
+    const raf = typeof globalThis !== "undefined" ? globalThis.requestAnimationFrame : void 0;
+    const shouldSchedule = !immediate && typeof raf === "function";
+    if (!shouldSchedule) {
+      this._pendingIndentRefresh = null;
+      __privateMethod(this, _ListItemNodeView_instances, applyIndentStyling_fn).call(this);
+      return;
+    }
+    if (this._pendingIndentRefresh != null) return;
+    this._pendingIndentRefresh = raf(() => {
+      this._pendingIndentRefresh = null;
+      __privateMethod(this, _ListItemNodeView_instances, applyIndentStyling_fn).call(this);
+    });
+  }
   update(node, decorations) {
-    const oldAttrs = this.node.attrs;
-    const newAttrs = node.attrs;
+    const prevNode = this.node;
     this.node = node;
     this.decorations = decorations;
-    if (JSON.stringify(oldAttrs) === JSON.stringify(newAttrs)) {
-      return true;
-    }
-    __privateMethod(this, _ParagraphNodeView_instances, updateHTMLAttributes_fn).call(this);
-    if (!__privateMethod(this, _ParagraphNodeView_instances, checkIsList_fn).call(this)) {
-      __privateMethod(this, _ParagraphNodeView_instances, removeList_fn).call(this);
-      return true;
+    this.invalidateResolvedPos();
+    const stylingAttrsChanged = !prevNode || prevNode.attrs.styleId !== node.attrs.styleId || prevNode.attrs.numId !== node.attrs.numId || prevNode.attrs.level !== node.attrs.level;
+    if (stylingAttrsChanged) {
+      clearComputedStyleCache(this.dom);
     }
-    __privateMethod(this, _ParagraphNodeView_instances, initList_fn).call(this, node.attrs.listRendering);
-    __privateMethod(this, _ParagraphNodeView_instances, scheduleAnimation_fn).call(this, () => {
-      __privateMethod(this, _ParagraphNodeView_instances, initList_fn).call(this, node.attrs.listRendering);
-      __privateMethod(this, _ParagraphNodeView_instances, updateListStyles_fn).call(this);
+    const { fontSize, fontFamily, lineHeight } = resolveListItemTypography({
+      node,
+      pos: this.getResolvedPos(),
+      editor: this.editor,
+      nodeView: this,
+      activeNodeViews: activeListItemNodeViews
     });
-    return true;
-  }
-  /**
-   * @param {MutationRecord} mutation
-   */
-  ignoreMutation(mutation) {
-    if (this.marker && (mutation.target === this.marker || this.marker.contains(mutation.target))) {
-      return true;
-    }
-    if (this.separator && (mutation.target === this.separator || this.separator.contains(mutation.target))) {
-      return true;
-    }
-    if (mutation.type === "attributes" && mutation.target === this.dom && mutation.attributeName === "style") {
-      return true;
+    this.dom.style.fontSize = fontSize;
+    this.dom.style.fontFamily = fontFamily || "inherit";
+    this.dom.style.lineHeight = lineHeight || "";
+    const attrsChanged = stylingAttrsChanged || prevNode?.attrs.indent !== node.attrs.indent;
+    if (attrsChanged) {
+      this.refreshIndentStyling();
     }
-    if (mutation.type === "childList") {
-      if (this.marker && Array.from(mutation.removedNodes).includes(this.marker)) {
-        return true;
-      }
-      if (this.marker && Array.from(mutation.addedNodes).includes(this.marker)) {
-        return true;
-      }
-      if (this.separator && Array.from(mutation.removedNodes).includes(this.separator)) {
-        return true;
-      }
-      if (this.separator && Array.from(mutation.addedNodes).includes(this.separator)) {
-        return true;
-      }
-    }
-    return false;
   }
   destroy() {
-    __privateMethod(this, _ParagraphNodeView_instances, cancelScheduledAnimation_fn).call(this);
-  }
-}
-_ParagraphNodeView_instances = new WeakSet();
-updateHTMLAttributes_fn = function() {
-  const htmlAttributes = Attribute.getAttributesToRender(this.node, this.extensionAttrs);
-  htmlAttributes.style = htmlAttributes.style || "";
-  for (const [key2, value] of Object.entries(htmlAttributes || {})) {
-    if (value == null) {
-      this.dom.removeAttribute(key2);
-      continue;
+    activeListItemNodeViews.delete(this);
+    this.numberingDOM.removeEventListener("click", this.handleNumberingClick);
+    clearComputedStyleCache(this.dom);
+    const caf = typeof globalThis !== "undefined" ? globalThis.cancelAnimationFrame : void 0;
+    if (this._pendingIndentRefresh != null && typeof caf === "function") {
+      caf(this._pendingIndentRefresh);
     }
-    this.dom.setAttribute(key2, value);
-  }
-};
-updateListStyles_fn = function() {
-  let { suffix, justification } = this.node.attrs.listRendering;
-  suffix = suffix ?? "tab";
-  __privateMethod(this, _ParagraphNodeView_instances, calculateMarkerStyle_fn).call(this, justification);
-  if (suffix === "tab") {
-    __privateMethod(this, _ParagraphNodeView_instances, calculateTabSeparatorStyle_fn).call(this, justification, this.node.attrs.indent);
-  } else {
-    this.separator.textContent = suffix === "space" ? " " : "";
+    this._pendingIndentRefresh = null;
   }
-  return true;
-};
-/**
- * @param {{ markerText: string, suffix?: string }} listRendering
- */
-initList_fn = function(listRendering) {
-  __privateMethod(this, _ParagraphNodeView_instances, createMarker_fn).call(this, listRendering.markerText);
-  __privateMethod(this, _ParagraphNodeView_instances, createSeparator_fn).call(this, listRendering.suffix);
-};
-checkIsList_fn = function() {
-  return isList(this.node);
-};
-/**
- * @param {string} markerText
- */
-createMarker_fn = function(markerText) {
-  if (!this.marker) {
-    this.marker = document.createElement("span");
-    this.dom.insertBefore(this.marker, this.contentDOM);
-  }
-  this.marker.contentEditable = "false";
-  this.marker.className = "list-marker";
-  this.marker.textContent = markerText;
-};
-/**
- * @param {'tab' | 'space' | 'nothing'} [suffix]
- */
-createSeparator_fn = function(suffix) {
-  if (suffix === "tab" || suffix == null) {
-    if (this.separator == null || this.separator.tagName?.toLowerCase() !== "span") {
-      this.separator?.parentNode?.removeChild(this.separator);
-      this.separator = document.createElement("span");
-      this.marker.after(this.separator);
-    }
-    this.separator.className = "sd-editor-tab";
-    this.separator.contentEditable = "false";
-  } else if (suffix === "space") {
-    if (this.separator == null || this.separator.nodeType !== Node.TEXT_NODE) {
-      this.separator?.parentNode?.removeChild(this.separator);
-      this.separator = document.createTextNode(" ");
-      this.marker.after(this.separator);
-    }
-    this.separator.textContent = " ";
-  } else if (suffix === "nothing") {
-    if (this.separator == null || this.separator.nodeType !== Node.TEXT_NODE) {
-      this.separator?.parentNode?.removeChild(this.separator);
-      this.separator = document.createTextNode("");
-      this.marker.after(this.separator);
-    }
-    this.separator.textContent = "";
-  }
-};
-/**
- * This is the logic behind the calculation:
- *
- * For left alignment:
- *   - The tab character extends to the next tab stop
- *
- * For right alignment:
- *   When: hanging is defined OR hanging is not defined and neither is firstLine
- *     - The tab character extends to the hanging position only and never goes beyond it.
- *
- *   When: firstLine is defined
- *       - The tab character extends to the next tab stop
- *
- * For center alignment:
- *   - The tab character extends to the next tab stop
- */
-/**
- * @param {'left' | 'right' | 'center'} justification
- * @param {{ hanging?: number, firstLine?: number } | null} indent
- */
-calculateTabSeparatorStyle_fn = function(justification, indent) {
-  const markerWidth = this.marker.getBoundingClientRect().width;
-  let tabStyle;
-  let { paragraphContext, start: start2 } = __privateMethod(this, _ParagraphNodeView_instances, getParagraphContext_fn).call(this);
-  if (justification === "right") {
-    if (indent?.hanging || !indent?.hanging && !indent?.firstLine) {
-      const hanging = indent?.hanging ? twipsToPixels(indent.hanging) : 0;
-      tabStyle = `width: ${hanging}px;`;
+}
+_ListItemNodeView_instances = new WeakSet();
+init_fn3 = function() {
+  const { attrs } = this.node;
+  const { listLevel, listNumberingType, lvlText, numId, level, customFormat } = attrs;
+  let orderMarker = "";
+  if (listLevel) {
+    if (listNumberingType !== "bullet") {
+      orderMarker = generateOrderedListIndex({
+        listLevel,
+        lvlText,
+        listNumberingType,
+        customFormat
+      });
     } else {
-      const tabNode = this.editor.schema.nodes.tab.create(null);
-      tabStyle = calculateTabStyle(tabNode.nodeSize, this.editor.view, start2, this.node, paragraphContext);
-    }
-  } else if (justification === "center") {
-    paragraphContext.accumulatedTabWidth = markerWidth / 2;
-    const tabNode = this.editor.schema.nodes.tab.create(null);
-    tabStyle = calculateTabStyle(tabNode.nodeSize, this.editor.view, start2, this.node, paragraphContext);
-    tabStyle += `margin-left: ${markerWidth / 2}px;`;
-  } else {
-    paragraphContext.accumulatedTabWidth = markerWidth;
-    const tabNode = this.editor.schema.nodes.tab.create(null);
-    tabStyle = calculateTabStyle(tabNode.nodeSize, this.editor.view, start2, this.node, paragraphContext);
-  }
-  this.separator.style.cssText = tabStyle;
-};
-/**
- * This is the logic behind the calculation:
- *  For left alignment:
- *    - The marker text STARTS at the left indent
- *
- *  For right alignment:
- *    - The marker text ENDS at the left indent
- *
- * For center alignment:
- *   - The marker text is centered around the left indent (pulled back by half its width)
- *
- * The left/center/right alignment positioning uses the left indent (+ firstLine if present) as the anchor point.
- */
-/**
- * @param {'left' | 'right' | 'center'} justification
- */
-calculateMarkerStyle_fn = function(justification) {
-  const runProperties = resolveRunProperties(
-    { docx: this.editor.converter.convertedXml, numbering: this.editor.converter.numbering },
-    this.node.attrs.paragraphProperties.runProperties || {},
-    { ...this.node.attrs.paragraphProperties, numberingProperties: this.node.attrs.numberingProperties },
-    true,
-    Boolean(this.node.attrs.paragraphProperties.numberingProperties)
-  );
-  const style = encodeCSSFromRPr(runProperties, this.editor.converter.convertedXml);
-  this.marker.style.cssText = Object.entries(style).map(([k2, v]) => `${k2}: ${v};`).join(" ");
-  let markerStyle = {
-    position: "",
-    left: "",
-    bottom: ""
-  };
-  let domStyle = {
-    position: ""
-  };
-  const calculateTop = () => {
-    let top2 = "0";
-    if (globalThis) {
-      const computedStyle = globalThis.getComputedStyle(this.dom);
-      const markerComputedStyle = globalThis.getComputedStyle(this.marker);
-      const lineHeight = parseFloat(computedStyle.lineHeight);
-      const markerLineHeight = parseFloat(markerComputedStyle.lineHeight);
-      top2 = `${lineHeight - markerLineHeight}px`;
-    }
-    return top2;
-  };
-  const rect = this.marker.getBoundingClientRect();
-  const markerWidth = rect.width;
-  if (justification === "right") {
-    markerStyle.position = "absolute";
-    markerStyle.left = `${-markerWidth}px`;
-    markerStyle.top = calculateTop();
-    domStyle.position = "relative";
-  } else if (justification === "center") {
-    markerStyle.position = "absolute";
-    markerStyle.left = `${-markerWidth / 2}px`;
-    markerStyle.top = calculateTop();
-    domStyle.position = "relative";
-  }
-  Object.entries(markerStyle).forEach(([k2, v]) => {
-    this.marker.style[k2] = v;
-  });
-  Object.entries(domStyle).forEach(([k2, v]) => {
-    this.dom.style[k2] = v;
-  });
-};
-removeList_fn = function() {
-  if (this.marker) {
-    this.dom.removeChild(this.marker);
-    this.marker = null;
-  }
-  if (this.separator) {
-    this.dom.removeChild(this.separator);
-    this.separator = null;
-  }
-  this.dom.style.position = "";
-};
-getParagraphContext_fn = function() {
-  const $pos = this.editor.state.doc.resolve(this.getPos());
-  const start2 = $pos.start($pos.depth + 1);
-  const paragraphContext = extractParagraphContext(this.node, start2, this.editor.helpers);
-  return { paragraphContext, start: start2 };
-};
-/**
- * @param {() => void} fn
- */
-scheduleAnimation_fn = function(fn2) {
-  if (typeof globalThis === "undefined") {
-    return;
+      orderMarker = docxNumberingHelpers.normalizeLvlTextChar(lvlText);
+    }
   }
-  __privateMethod(this, _ParagraphNodeView_instances, cancelScheduledAnimation_fn).call(this);
-  this._animationFrameRequest = globalThis.requestAnimationFrame(() => {
-    fn2();
-    this._animationFrameRequest = null;
+  const pos = this.getResolvedPos();
+  const { fontSize, fontFamily, lineHeight } = resolveListItemTypography({
+    node: this.node,
+    pos,
+    editor: this.editor,
+    nodeView: this,
+    activeNodeViews: activeListItemNodeViews
   });
+  this.dom = document.createElement("li");
+  this.dom.className = "sd-editor-list-item-node-view";
+  this.dom.style.fontSize = fontSize;
+  this.dom.style.fontFamily = fontFamily ? fontFamily : "inherit";
+  this.dom.style.lineHeight = lineHeight || "";
+  this.dom.setAttribute("data-marker-type", orderMarker);
+  this.dom.setAttribute("data-num-id", numId);
+  this.dom.setAttribute("data-list-level", JSON.stringify(listLevel));
+  this.dom.setAttribute("data-list-numbering-type", listNumberingType);
+  this.dom.setAttribute("data-level", level);
+  this.numberingDOM = document.createElement("span");
+  this.numberingDOM.className = "sd-editor-list-item-numbering";
+  this.numberingDOM.textContent = orderMarker;
+  this.numberingDOM.setAttribute("contenteditable", "false");
+  this.numberingDOM.addEventListener("click", this.handleNumberingClick);
+  this.contentDOM = document.createElement("div");
+  this.contentDOM.className = "sd-editor-list-item-content-dom";
+  this.dom.appendChild(this.numberingDOM);
+  this.dom.appendChild(this.contentDOM);
+  this.refreshIndentStyling({ immediate: true });
 };
-cancelScheduledAnimation_fn = function() {
-  if (typeof globalThis === "undefined" || !this._animationFrameRequest) {
-    return;
-  }
-  globalThis.cancelAnimationFrame(this._animationFrameRequest);
-  this._animationFrameRequest = null;
-};
-function NumberingManager() {
-  let countersMap = {};
-  let abstractCountersMap = {};
-  let abstractIdMap = {};
-  const startsMap = {};
-  let lastSeenMap = {};
-  let pathCache = {};
-  let cacheEnabled = false;
-  return {
-    /**
-     * Persist the base start value and optional restart limit for a given
-     * numId/level combination.
-     *
-     * @param {string | number} numId
-     * @param {number} level
-     * @param {number} startValue
-     * @param {number} [restartValue]
-     */
-    setStartSettings(numId, level, startValue, restartValue) {
-      if (!startsMap[numId]) {
-        startsMap[numId] = {};
-      }
-      if (!startsMap[numId][level]) {
-        startsMap[numId][level] = {};
-      }
-      startsMap[numId][level].start = startValue;
-      startsMap[numId][level].restart = restartValue;
-    },
-    /**
-     * Record the computed counter for a specific node position. When caching is
-     * enabled this also tracks the latest position to speed up lookups.
-     *
-     * @param {string | number} numId
-     * @param {number} level
-     * @param {number} pos
-     * @param {number} value
-     */
-    setCounter(numId, level, pos, value, abstractId) {
-      if (!countersMap[numId]) {
-        countersMap[numId] = {};
-      }
-      if (!countersMap[numId][level]) {
-        countersMap[numId][level] = {};
-      }
-      countersMap[numId][level][pos] = value;
-      abstractIdMap[numId] = abstractId;
-      if (!abstractCountersMap[abstractId]) {
-        abstractCountersMap[abstractId] = {};
-      }
-      if (!abstractCountersMap[abstractId][level]) {
-        abstractCountersMap[abstractId][level] = {};
-      }
-      abstractCountersMap[abstractId][level][pos] = value;
-      if (!cacheEnabled) {
-        return;
-      }
-      if (!lastSeenMap[numId]) {
-        lastSeenMap[numId] = {};
-      }
-      const lastSeen = lastSeenMap[numId][level];
-      if (!lastSeen || pos > lastSeen.pos) {
-        lastSeenMap[numId][level] = { pos, count: value };
-      }
-    },
-    /**
-     * Retrieve a previously stored counter for the provided position.
-     *
-     * @param {string | number} numId
-     * @param {number} level
-     * @param {number} pos
-     * @returns {number | null}
-     */
-    getCounter(numId, level, pos) {
-      if (countersMap[numId] && countersMap[numId][level] && countersMap[numId][level][pos] != null) {
-        return countersMap[numId][level][pos];
-      }
-      return null;
-    },
-    /**
-     * Calculate the counter value that should be used for the given position,
-     * respecting restart rules, ancestor usage, and cached history.
-     *
-     * @param {string | number} numId
-     * @param {number} level
-     * @param {number} pos
-     * @returns {number}
-     */
-    calculateCounter(numId, level, pos, abstractId) {
-      abstractIdMap[numId] = abstractId;
-      const restartSetting = startsMap?.[numId]?.[level]?.restart;
-      const startValue = startsMap?.[numId]?.[level]?.start ?? 1;
-      const levelData = abstractCountersMap?.[abstractId]?.[level] || {};
-      let previousPos = null;
-      let previousCount = startValue - 1;
-      if (cacheEnabled) {
-        const cachedLast = lastSeenMap?.[numId]?.[level];
-        if (cachedLast && cachedLast.pos < pos) {
-          previousPos = cachedLast.pos;
-          previousCount = cachedLast.count;
-        }
-      }
-      if (previousPos == null) {
-        const fallbackPos = Object.keys(levelData).map((p) => parseInt(p)).filter((p) => p < pos).pop();
-        if (fallbackPos != null) {
-          previousPos = fallbackPos;
-          previousCount = levelData[fallbackPos];
-        }
-      }
-      if (restartSetting === 0) {
-        return previousCount + 1;
-      }
-      if (previousPos == null) {
-        return startValue;
-      }
-      const usedLevels = [];
-      for (let lvl = 0; lvl < level; lvl++) {
-        const levelData2 = abstractCountersMap?.[abstractId]?.[lvl] || {};
-        const hasUsed = Object.keys(levelData2).map((p) => parseInt(p)).some((p) => p > previousPos && p < pos);
-        if (hasUsed) {
-          usedLevels.push(lvl);
-        }
-      }
-      if (usedLevels.length === 0) {
-        return previousCount + 1;
-      }
-      if (restartSetting == null) {
-        return startValue;
-      }
-      const shouldRestart = usedLevels.some((lvl) => lvl <= restartSetting);
-      if (shouldRestart) {
-        return startValue;
-      }
-      return previousCount + 1;
-    },
-    /**
-     * Resolve the counter values for every ancestor level preceding the given
-     * position. All numbering definitions that have the same abstract id
-     * are considered. Results are cached when cache mode is active.
-     *
-     * @param {string | number} numId
-     * @param {number} level
-     * @param {number} pos
-     * @returns {number[]}
-     */
-    getAncestorsPath(numId, level, pos) {
-      if (cacheEnabled && pathCache?.[numId]?.[level]?.[pos]) {
-        return pathCache[numId][level][pos];
-      }
-      const path = [];
-      const abstractId = abstractIdMap[numId];
-      for (let lvl = 0; lvl < level; lvl++) {
-        const startCount = startsMap?.[numId]?.[lvl]?.start ?? 1;
-        const levelData = abstractCountersMap?.[abstractId]?.[lvl] || {};
-        if (levelData == null) {
-          path.push(startCount);
-          continue;
-        }
-        const previousPos = Object.keys(levelData).map((p) => parseInt(p)).filter((p) => p < pos).pop();
-        if (previousPos == null) {
-          path.push(startCount);
-        } else {
-          path.push(levelData[previousPos]);
-        }
-      }
-      if (cacheEnabled) {
-        if (!pathCache[numId]) {
-          pathCache[numId] = {};
-        }
-        if (!pathCache[numId][level]) {
-          pathCache[numId][level] = {};
-        }
-        pathCache[numId][level][pos] = path;
-      }
-      return path;
-    },
-    /**
-     * Convenience helper that appends the current level counter on top of the
-     * ancestor path.
-     *
-     * @param {string | number} numId
-     * @param {number} level
-     * @param {number} pos
-     * @returns {number[]}
-     */
-    calculatePath(numId, level, pos) {
-      const path = this.getAncestorsPath(numId, level, pos);
-      const myCount = this.getCounter(numId, level, pos);
-      path.push(myCount);
-      return path;
-    },
-    /**
-     * Expose the internal counters map mainly for debugging and tests.
-     *
-     * @returns {Record<string, Record<string, Record<string, number>>>}
-     */
-    getCountersMap() {
-      return countersMap;
-    },
-    /**
-     * Reset cached counter/path structures. Intended for internal use only.
-     */
-    _clearCache() {
-      lastSeenMap = {};
-      pathCache = {};
-      countersMap = {};
-      abstractCountersMap = {};
-      abstractIdMap = {};
-    },
-    /**
-     * Enable cache-aware logic (used during document scans) and drop stale data.
-     */
-    enableCache() {
-      cacheEnabled = true;
-      this._clearCache();
+applyIndentStyling_fn = function() {
+  const { attrs } = this.node;
+  const { styleId, numId, level, indent: inlineIndent } = attrs;
+  const defs = getListItemStyleDefinitions({ styleId, node: this.node, numId, level, editor: this.editor });
+  const visibleIndent = getVisibleIndent(defs.stylePpr, defs.numDefPpr, inlineIndent);
+  const lvlJc = defs.numLvlJs?.attributes?.["w:val"] || "left";
+  const contentLeft = visibleIndent.left || 0;
+  const hanging = visibleIndent.hanging || 0;
+  const handlers2 = {
+    right: () => {
+      const calculatedWidth = calculateMarkerWidth(this.dom, this.numberingDOM, this.editor);
+      const minMarkerWidth = Math.max(calculatedWidth, MIN_MARKER_WIDTH);
+      const effectiveHanging = Math.max(hanging, minMarkerWidth);
+      const markerLeft = contentLeft - effectiveHanging - MARKER_OFFSET_RIGHT;
+      this.contentDOM.style.marginLeft = `${contentLeft}px`;
+      this.numberingDOM.style.left = `${markerLeft}px`;
+      this.numberingDOM.style.width = `${effectiveHanging}px`;
+      this.numberingDOM.style.textAlign = "right";
     },
-    /**
-     * Disable cache-aware logic and clear residual cache entries.
-     */
-    disableCache() {
-      cacheEnabled = false;
-      this._clearCache();
+    left: () => {
+      const calculatedWidth = calculateMarkerWidth(this.dom, this.numberingDOM, this.editor);
+      const minMarkerWidth = Math.max(calculatedWidth, MIN_MARKER_WIDTH);
+      let markerLeft = contentLeft - hanging;
+      if (markerLeft === contentLeft) {
+        markerLeft -= minMarkerWidth;
+      } else if (minMarkerWidth > hanging) {
+        const diff = minMarkerWidth - hanging;
+        markerLeft -= diff;
+      }
+      this.contentDOM.style.marginLeft = `${contentLeft}px`;
+      this.numberingDOM.style.left = `${markerLeft}px`;
+      this.numberingDOM.style.width = "";
+      this.numberingDOM.style.textAlign = "";
     }
   };
-}
-const generateOrderedListIndex = ({ listLevel, lvlText, listNumberingType, customFormat }) => {
-  const handler = listIndexMap[listNumberingType];
-  return handler ? handler(listLevel, lvlText, customFormat) : null;
-};
-const handleDecimal = (path, lvlText) => generateNumbering(path, lvlText, String);
-const handleRoman = (path, lvlText) => generateNumbering(path, lvlText, intToRoman);
-const handleLowerRoman = (path, lvlText) => handleRoman(path, lvlText).toLowerCase();
-const handleLowerAlpha = (path, lvlText) => handleAlpha(path, lvlText).toLowerCase();
-const handleAlpha = (path, lvlText) => generateNumbering(path, lvlText, (p) => intToAlpha(p));
-const handleOrdinal = (path, lvlText) => generateNumbering(path, lvlText, ordinalFormatter);
-const handleCustom = (path, lvlText, customFormat) => generateFromCustom(path, lvlText, customFormat);
-const handleJapaneseCounting = (path, lvlText) => generateNumbering(path, lvlText, intToJapaneseCounting);
-const listIndexMap = {
-  decimal: handleDecimal,
-  lowerRoman: handleLowerRoman,
-  upperRoman: handleRoman,
-  lowerLetter: handleLowerAlpha,
-  upperLetter: handleAlpha,
-  ordinal: handleOrdinal,
-  custom: handleCustom,
-  japaneseCounting: handleJapaneseCounting
-};
-const createNumbering = (values, lvlText) => {
-  return values.reduce((acc, value, index2) => {
-    return value > 9 ? acc.replace(/^0/, "").replace(`%${index2 + 1}`, value) : acc.replace(`%${index2 + 1}`, value);
-  }, lvlText);
-};
-const generateNumbering = (path, lvlText, formatter) => {
-  const formattedValues = path.map(formatter);
-  return createNumbering(formattedValues, lvlText);
-};
-const ordinalFormatter = (level) => {
-  const suffixes = ["th", "st", "nd", "rd"];
-  const value = level % 100;
-  const suffix = suffixes[(value - 20) % 10] || suffixes[value] || suffixes[0];
-  const p = level + suffix;
-  return p;
-};
-const generateFromCustom = (path, lvlText, customFormat) => {
-  if (customFormat.match(/(?:[0]+\d,\s){3}\.{3}/) == null) return generateNumbering(path, lvlText, String);
-  const match = customFormat.match(/(\d+)/);
-  if (!match) throw new Error("Invalid format string: no numeric pattern found");
-  const sample = match[1];
-  const digitCount = sample.length;
-  return generateNumbering(path, lvlText, (p) => String(p).padStart(digitCount, "0"));
-};
-const intToRoman = (num) => {
-  const romanNumeralMap = [
-    { value: 1e3, numeral: "M" },
-    { value: 900, numeral: "CM" },
-    { value: 500, numeral: "D" },
-    { value: 400, numeral: "CD" },
-    { value: 100, numeral: "C" },
-    { value: 90, numeral: "XC" },
-    { value: 50, numeral: "L" },
-    { value: 40, numeral: "XL" },
-    { value: 10, numeral: "X" },
-    { value: 9, numeral: "IX" },
-    { value: 5, numeral: "V" },
-    { value: 4, numeral: "IV" },
-    { value: 1, numeral: "I" }
-  ];
-  let result = "";
-  for (const { value, numeral } of romanNumeralMap) {
-    while (num >= value) {
-      result += numeral;
-      num -= value;
-    }
-  }
-  return result;
-};
-const intToAlpha = (num) => {
-  let result = "";
-  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  while (num > 0) {
-    let index2 = (num - 1) % 26;
-    result = alphabet[index2] + result;
-    num = Math.floor((num - 1) / 26);
-  }
-  return result;
+  const handleStyles = handlers2[lvlJc] ?? handlers2.left;
+  handleStyles();
 };
-const intToJapaneseCounting = (num) => {
-  const digits = ["", "一", "二", "三", "四", "五", "六", "七", "八", "九"];
-  const units = ["", "十", "百", "千"];
-  if (num === 0) return "零";
-  if (num < 10) return digits[num];
-  let result = "";
-  let tempNum = num;
-  let unitIndex = 0;
-  while (tempNum > 0) {
-    const digit = tempNum % 10;
-    if (digit !== 0) {
-      const digitStr = digit === 1 && unitIndex > 0 ? "" : digits[digit];
-      result = digitStr + (unitIndex > 0 ? units[unitIndex] : "") + result;
-    } else if (result && tempNum > 0) {
-      if (!result.startsWith("零") && tempNum % 100 !== 0) {
-        result = "零" + result;
-      }
+function refreshAllListItemNodeViews() {
+  activeListItemNodeViews.forEach((nodeView) => {
+    try {
+      nodeView.refreshIndentStyling({ immediate: true });
+    } catch (error) {
+      console.error("Error refreshing list item node view:", error);
+      activeListItemNodeViews.delete(nodeView);
     }
-    tempNum = Math.floor(tempNum / 10);
-    unitIndex++;
-    if (unitIndex > 3) break;
-  }
-  if (num >= 10 && num < 20) {
-    result = result.replace(/^一十/, "十");
-  }
+  });
+}
+const getVisibleIndent = (stylePpr, numDefPpr, inlineIndent) => {
+  const styleIndentTag = stylePpr?.elements?.find((el) => el.name === "w:ind") || {};
+  const styleIndent = parseIndentElement(styleIndentTag);
+  const numDefIndentTag = numDefPpr?.elements?.find((el) => el.name === "w:ind") || {};
+  const numDefIndent = parseIndentElement(numDefIndentTag);
+  const indent = combineIndents(styleIndent, numDefIndent);
+  const result = combineIndents(indent, inlineIndent);
   return result;
 };
-function createNumberingPlugin(editor) {
-  const numberingManager = NumberingManager();
-  const applyStartSettingsFromDefinitions = (definitionsMap) => {
-    Object.entries(definitionsMap || {}).forEach(([numId, levels]) => {
-      Object.entries(levels || {}).forEach(([level, def]) => {
-        const start2 = parseInt(def?.start) || 1;
-        let restart = def?.restart;
-        if (restart != null) {
-          restart = parseInt(restart);
-        }
-        numberingManager.setStartSettings(numId, parseInt(level), start2, restart);
-      });
-    });
-  };
-  const refreshStartSettings = () => {
-    const definitions = ListHelpers.getAllListDefinitions(editor);
-    applyStartSettingsFromDefinitions(definitions);
-  };
-  refreshStartSettings();
-  if (typeof editor?.on === "function") {
-    editor.on("list-definitions-change", refreshStartSettings);
-    if (typeof editor?.off === "function") {
-      const cleanupListDefinitionListener = () => {
-        editor.off("list-definitions-change", refreshStartSettings);
-        editor.off?.("destroy", cleanupListDefinitionListener);
-      };
-      editor.on("destroy", cleanupListDefinitionListener);
-    }
+function calculateMarkerWidth(dom, numberingDOM, editor, { withPadding = true } = {}) {
+  const markerText = numberingDOM.textContent || "";
+  const fontSize = dom.style.fontSize || DEFAULT_FONT_SIZE;
+  const fontValue = dom.style.fontFamily;
+  const fontFamily = fontValue && fontValue !== "inherit" ? fontValue : DEFAULT_FONT_FAMILY;
+  if (!markerText.trim()) return 0;
+  try {
+    if (editor?.options?.isHeadless) return 0;
+    if (typeof globalThis.CanvasRenderingContext2D === "undefined") return 0;
+    const canvas = document.createElement("canvas");
+    if (typeof canvas.getContext !== "function") return 0;
+    const context = canvas.getContext("2d");
+    if (!context) return 0;
+    const fontSizePx = fontSize.includes("pt") ? Number.parseFloat(fontSize) * POINT_TO_PIXEL_CONVERSION_FACTOR : Number.parseFloat(fontSize);
+    context.font = `${fontSizePx}px ${fontFamily}`;
+    const textWidth = context.measureText(markerText).width;
+    const resultWidth = withPadding ? Math.ceil(textWidth + MARKER_PADDING) : Math.ceil(textWidth);
+    return resultWidth;
+  } catch {
+    return 0;
   }
+}
+const orderedListSyncPluginKey = new PluginKey("orderedListSync");
+function orderedListSync(editor) {
+  let hasInitialized = false;
+  const docx = editor.converter.convertedXml;
   return new Plugin({
-    name: "numberingPlugin",
-    key: new PluginKey("numberingPlugin"),
-    /**
-     * Scan document changes and collect fresh numbering metadata for list
-     * paragraphs. The incoming transactions are marked to avoid reprocessing.
-     *
-     * @param {import('prosemirror-state').Transaction[]} transactions
-     * @param {import('prosemirror-state').EditorState} oldState
-     * @param {import('prosemirror-state').EditorState} newState
-     * @returns {import('prosemirror-state').Transaction | null}
-     */
+    key: orderedListSyncPluginKey,
     appendTransaction(transactions, oldState, newState) {
+      if (transactions.every((tr2) => tr2.getMeta("y-sync$"))) return null;
+      const updateNodeViews = transactions.some((tr2) => tr2.getMeta("updatedListItemNodeViews"));
+      if (updateNodeViews || !hasInitialized) {
+        refreshAllListItemNodeViews();
+      }
       const isFromPlugin = transactions.some((tr2) => tr2.getMeta("orderedListSync"));
-      if (isFromPlugin || !transactions.some((tr2) => tr2.docChanged)) {
+      const docChanged = transactions.some((tr2) => tr2.docChanged) && !oldState.doc.eq(newState.doc);
+      if (isFromPlugin || !docChanged) {
         return null;
       }
+      hasInitialized = true;
       const tr = newState.tr;
       tr.setMeta("orderedListSync", true);
-      numberingManager.enableCache();
+      const listMap = /* @__PURE__ */ new Map();
+      const listInitialized = /* @__PURE__ */ new Map();
+      const shouldProcess = transactions.some((tr2) => {
+        if (tr2.getMeta("updateListSync")) return true;
+        return tr2.steps.some((step) => {
+          const stepJSON = step.toJSON();
+          if (step.slice?.content) {
+            let hasListItem = false;
+            step.slice.content.descendants((node) => {
+              if (node.type.name === "listItem") {
+                hasListItem = true;
+                return false;
+              }
+            });
+            if (hasListItem) return true;
+          }
+          if (stepJSON && stepJSON.slice) {
+            const jsonStr = JSON.stringify(stepJSON);
+            if (jsonStr.includes('"listItem"')) return true;
+          }
+          return false;
+        });
+      });
+      if (!shouldProcess) return null;
       newState.doc.descendants((node, pos) => {
-        if (node.type.name !== "paragraph" || !node.attrs.numberingProperties) {
-          return;
+        if (node.type.name !== "listItem") return;
+        const { level: attrLvl, numId: attrNumId, styleId } = node.attrs;
+        const level = parseInt(attrLvl);
+        const numId = parseInt(attrNumId);
+        let {
+          lvlText,
+          customFormat,
+          listNumberingType,
+          start: numberingDefStart
+        } = ListHelpers.getListDefinitionDetails({ numId, level, editor });
+        const start2 = parseInt(numberingDefStart) || 1;
+        if (!listMap.has(numId)) {
+          const generatedLevels = {};
+          const initialPath = docxNumberingHelpers.generateListPath(level, numId, styleId, generatedLevels, docx);
+          listMap.set(numId, initialPath || []);
+          listInitialized.set(numId, false);
+        }
+        let currentListLevels = [...listMap.get(numId)];
+        if (!listInitialized.get(numId)) {
+          listInitialized.set(numId, true);
+          if (typeof start2 === "number") {
+            while (currentListLevels.length <= level) {
+              currentListLevels.push(0);
+            }
+            currentListLevels[level] = start2;
+            for (let i = level + 1; i < currentListLevels.length; i++) {
+              currentListLevels[i] = 0;
+            }
+          }
+        } else {
+          while (currentListLevels.length <= level) {
+            currentListLevels.push(0);
+          }
+          currentListLevels[level] = (currentListLevels[level] || 0) + 1;
+          for (let i = level + 1; i < currentListLevels.length; i++) {
+            currentListLevels[i] = 0;
+          }
         }
-        const { numId, ilvl: level = 0 } = node.attrs.numberingProperties;
-        const definitionDetails = ListHelpers.getListDefinitionDetails({ numId, level, editor });
-        if (!definitionDetails || Object.keys(definitionDetails).length === 0) {
-          tr.setNodeAttribute(pos, "listRendering", null);
-          return;
+        if (currentListLevels.length === 0) {
+          currentListLevels = [1];
         }
-        let { lvlText, customFormat, listNumberingType, suffix, justification, abstractId } = definitionDetails;
-        let markerText = "";
-        listNumberingType = listNumberingType || "decimal";
-        const count = numberingManager.calculateCounter(numId, level, pos, abstractId);
-        numberingManager.setCounter(numId, level, pos, count, abstractId);
-        const path = numberingManager.calculatePath(numId, level, pos);
-        if (listNumberingType !== "bullet") {
-          markerText = generateOrderedListIndex({
-            listLevel: path,
-            lvlText,
-            listNumberingType,
-            customFormat
-          });
-        } else {
-          markerText = docxNumberingHelpers.normalizeLvlTextChar(lvlText);
-        }
-        if (JSON.stringify(node.attrs.listRendering) !== JSON.stringify({
-          markerText,
-          suffix,
-          justification,
-          path,
-          numberingType: listNumberingType
-        })) {
-          tr.setNodeAttribute(pos, "listRendering", {
-            markerText,
-            suffix,
-            justification,
-            path,
-            numberingType: listNumberingType
-          });
+        listMap.set(numId, currentListLevels);
+        const updatedAttrs = {
+          ...node.attrs,
+          listLevel: [...currentListLevels],
+          level,
+          lvlText,
+          listNumberingType,
+          customFormat
+        };
+        const keysChanged = Object.keys(updatedAttrs).some((key2) => node.attrs[key2] !== updatedAttrs[key2]);
+        if (keysChanged) {
+          tr.setNodeMarkup(pos, void 0, updatedAttrs);
         }
-        return false;
       });
-      numberingManager.disableCache();
-      return tr.docChanged ? tr : null;
+      return tr;
     }
   });
 }
-const bulletInputRegex = /^\s*([-+*])\s$/;
-const orderedInputRegex = /^(\d+)\.\s$/;
+const ListItem = Node$1.create({
+  name: "listItem",
+  content: "paragraph* block*",
+  defining: true,
+  priority: 101,
+  // to run listItem commands first
+  addOptions() {
+    return {
+      htmlAttributes: {
+        "aria-label": "List item node"
+      },
+      bulletListTypeName: "bulletList",
+      orderedListTypeName: "orderedList"
+    };
+  },
+  parseDOM() {
+    return [{ tag: "li" }];
+  },
+  renderDOM({ htmlAttributes }) {
+    return ["li", Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+  },
+  addPmPlugins() {
+    return this.editor?.converter?.convertedXml ? [orderedListSync(this.editor)] : [];
+  },
+  /**
+   * Important: The listItem node uses a custom node view.
+   * Skip node view in headless mode for performance.
+   * @returns {import('@core/NodeView.js').NodeView|null}
+   */
+  addNodeView() {
+    if (shouldSkipNodeView(this.editor)) return null;
+    return ({ node, editor, getPos, decorations }) => {
+      return new ListItemNodeView(node, getPos, decorations, editor);
+    };
+  },
+  addAttributes() {
+    return {
+      // Virtual attribute.
+      markerType: {
+        default: null,
+        renderDOM: (attrs) => {
+          let { listLevel, listNumberingType, lvlText } = attrs;
+          let hasListLevel = !!listLevel?.length;
+          if (!hasListLevel || !lvlText) {
+            return {};
+          }
+          let orderMarker = generateOrderedListIndex({
+            listLevel,
+            lvlText,
+            listNumberingType
+          });
+          if (!orderMarker) return {};
+          return {
+            "data-marker-type": orderMarker
+          };
+        }
+      },
+      lvlText: {
+        default: null,
+        keepOnSplit: true,
+        parseDOM: (elem) => elem.getAttribute("data-lvl-text"),
+        renderDOM: (attrs) => {
+          if (!attrs.lvlText) return {};
+          return {
+            "data-lvl-text": attrs.lvlText
+          };
+        }
+      },
+      listNumberingType: {
+        default: null,
+        keepOnSplit: true,
+        parseDOM: (elem) => elem.getAttribute("data-num-fmt"),
+        renderDOM: (attrs) => {
+          if (!attrs.listNumberingType) return {};
+          return {
+            "data-num-fmt": attrs.listNumberingType
+          };
+        }
+      },
+      listLevel: {
+        default: null,
+        parseDOM: (elem) => {
+          let listLevel = elem.getAttribute("data-list-level");
+          try {
+            listLevel = JSON.parse(listLevel);
+          } catch {
+          }
+          return listLevel;
+        },
+        renderDOM: (attrs) => {
+          if (!attrs.listLevel) return {};
+          return {
+            "data-list-level": JSON.stringify(attrs.listLevel)
+          };
+        }
+      },
+      // JC = justification. Expect left, right, center
+      lvlJc: {
+        keepOnSplit: true,
+        default: null,
+        rendered: false
+      },
+      // This will contain indentation and space info.
+      // ie: w:left (left indent), w:hanging (hanging indent)
+      listParagraphProperties: {
+        keepOnSplit: true,
+        default: null,
+        rendered: false
+      },
+      // This will contain run properties for the list item
+      listRunProperties: {
+        keepOnSplit: true,
+        default: null,
+        rendered: false
+      },
+      numId: {
+        keepOnSplit: true,
+        default: null,
+        parseDOM: (elem) => elem.getAttribute("data-num-id"),
+        renderDOM: (attrs) => {
+          if (!attrs.numId) return {};
+          return {
+            "data-num-id": attrs.numId
+          };
+        }
+      },
+      numPrType: {
+        rendered: false,
+        default: "inline",
+        keepOnSplit: true
+      },
+      level: {
+        parseDOM: (elem) => {
+          return elem.getAttribute("data-level");
+        },
+        renderDOM: (attrs) => {
+          if (attrs.level === void 0 || attrs.level === null) return {};
+          return {
+            "data-level": attrs.level
+          };
+        }
+      },
+      attributes: {
+        keepOnSplit: true,
+        rendered: false
+      },
+      spacing: {
+        keepOnSplit: true,
+        default: null,
+        rendered: false
+      },
+      indent: {
+        parseDOM: (elem) => JSON.parse(elem.getAttribute("data-indent")),
+        keepOnSplit: true,
+        default: null,
+        rendered: false
+      },
+      markerStyle: {
+        default: null,
+        rendered: false,
+        keepOnSplit: true
+      },
+      styleId: {
+        rendered: false,
+        keepOnSplit: true
+      },
+      customFormat: {
+        default: null,
+        rendered: false,
+        keepOnSplit: true
+      },
+      importedFontFamily: {
+        parseDOM: (elem) => elem.getAttribute("data-font-family"),
+        renderDOM: (attrs) => {
+          if (!attrs.importedFontFamily) return {};
+          return {
+            "data-font-family": attrs.importedFontFamily
+          };
+        }
+      },
+      importedFontSize: {
+        parseDOM: (elem) => elem.getAttribute("data-font-size"),
+        renderDOM: (attrs) => {
+          if (!attrs.importedFontSize) return {};
+          return {
+            "data-font-size": attrs.importedFontSize
+          };
+        }
+      }
+    };
+  },
+  addShortcuts() {
+    return {
+      Enter: () => {
+        return this.editor.commands.splitListItem();
+      },
+      "Shift-Enter": () => {
+        return this.editor.commands.first(({ commands: commands2 }) => [
+          () => commands2.createParagraphNear(),
+          () => commands2.splitBlock()
+        ]);
+      },
+      Tab: () => {
+        return this.editor.commands.first(({ commands: commands2 }) => [() => commands2.increaseListIndent()]);
+      },
+      "Shift-Tab": () => {
+        return this.editor.commands.first(({ commands: commands2 }) => [() => commands2.decreaseListIndent()]);
+      }
+    };
+  }
+});
+const getDefaultSpacing = () => ({
+  lineSpaceAfter: 0,
+  lineSpaceBefore: 0,
+  line: 0,
+  lineRule: null
+});
 const Paragraph = OxmlNode.create({
   name: "paragraph",
   oXmlName: "w:p",
@@ -19777,26 +20739,22 @@ const Paragraph = OxmlNode.create({
         parseDOM: (element) => {
           if (element && element.closest("[data-superdoc-import]")) {
             return {
-              after: pixelsToTwips(11),
-              before: 0,
-              line: linesToTwips(1.15),
+              lineSpaceAfter: 11,
+              lineSpaceBefore: 0,
+              line: 1.15,
               lineRule: "auto"
             };
           }
           return void 0;
         },
         renderDOM: (attrs) => {
-          const { spacing, marksAttrs } = attrs;
-          if (!spacing) return { style: null };
+          const { spacing } = attrs;
+          if (!spacing) return {};
           const spacingCopy = { ...spacing };
           if (attrs.lineHeight) delete spacingCopy.line;
-          const style = getSpacingStyleString(
-            spacingCopy,
-            marksAttrs ?? [],
-            Boolean(attrs.paragraphProperties?.numberingProperties)
-          );
+          const style = getSpacingStyleString(spacingCopy);
           if (style) return { style };
-          return { style: null };
+          return {};
         }
       },
       extraAttrs: {
@@ -19824,17 +20782,17 @@ const Paragraph = OxmlNode.create({
       indent: {
         default: null,
         renderDOM: ({ indent }) => {
-          if (!indent) return { style: null };
+          if (!indent) return {};
           const { left: left2, right: right2, firstLine, hanging } = indent;
           if (indent && Object.values(indent).every((v) => v === 0)) {
-            return { style: null };
+            return {};
           }
           let style = "";
-          if (left2) style += `margin-left: ${twipsToPixels(left2)}px;`;
-          if (right2) style += `margin-right: ${twipsToPixels(right2)}px;`;
-          if (firstLine && !hanging) style += `text-indent: ${twipsToPixels(firstLine)}px;`;
-          if (firstLine && hanging) style += `text-indent: ${twipsToPixels(firstLine - hanging)}px;`;
-          if (!firstLine && hanging) style += `text-indent: ${twipsToPixels(-hanging)}px;`;
+          if (left2) style += `margin-left: ${left2}px;`;
+          if (right2) style += `margin-right: ${right2}px;`;
+          if (firstLine && !hanging) style += `text-indent: ${firstLine}px;`;
+          if (firstLine && hanging) style += `text-indent: ${firstLine - hanging}px;`;
+          if (!firstLine && hanging) style += `text-indent: ${-hanging}px;`;
           return { style };
         }
       },
@@ -19853,16 +20811,12 @@ const Paragraph = OxmlNode.create({
           sideOrder.forEach((side) => {
             const b = borders[side];
             if (!b) return;
-            if (["nil", "none", void 0, null].includes(b.val)) {
-              style += `border-${side}: none;`;
-              return;
-            }
-            const width = b.size != null ? `${eighthPointsToPixels(b.size)}px` : "1px";
+            const width = b.size != null ? `${b.size}px` : "1px";
             const cssStyle = valToCss[b.val] || "solid";
-            const color = !b.color || b.color === "auto" ? "#000000" : `#${b.color}`;
+            const color = b.color || "#000000";
             style += `border-${side}: ${width} ${cssStyle} ${color};`;
             if (b.space != null && side === "bottom") {
-              style += `padding-bottom: ${eighthPointsToPixels(b.space)}px;`;
+              style += `padding-bottom: ${b.space}px;`;
             }
           });
           return style ? { style } : {};
@@ -19876,12 +20830,7 @@ const Paragraph = OxmlNode.create({
           return null;
         }
       },
-      styleId: {
-        renderDOM: (attrs) => {
-          if (!attrs.styleId) return {};
-          return { styleid: attrs.styleId };
-        }
-      },
+      styleId: {},
       sdBlockId: {
         default: null,
         keepOnSplit: false,
@@ -19899,37 +20848,19 @@ const Paragraph = OxmlNode.create({
       paragraphProperties: { rendered: false },
       dropcap: { rendered: false },
       pageBreakSource: { rendered: false },
-      textAlign: {
-        renderDOM: ({ textAlign }) => {
-          if (!textAlign) return {};
+      justify: {
+        renderDOM: ({ justify }) => {
+          const { val: jc } = justify || {};
+          if (!jc) return {};
           let style = "";
-          if (textAlign === "left") style += "text-align: left;";
-          else if (textAlign === "right") style += "text-align: right;";
-          else if (textAlign === "center") style += "text-align: center;";
-          else if (textAlign === "both") style += "text-align: justify;";
+          if (jc === "left") style += "text-align: left;";
+          else if (jc === "right") style += "text-align: right;";
+          else if (jc === "center") style += "text-align: center;";
+          else if (jc === "both") style += "text-align: justify;";
           return { style };
         }
       },
-      tabStops: { rendered: false },
-      listRendering: {
-        keepOnSplit: false,
-        renderDOM: ({ listRendering }) => {
-          return {
-            "data-marker-type": listRendering?.markerText,
-            "data-list-level": listRendering?.path ? JSON.stringify(listRendering.path) : null,
-            "data-list-numbering-type": listRendering?.numberingType
-          };
-        }
-      },
-      numberingProperties: {
-        keepOnSplit: true,
-        renderDOM: ({ numberingProperties }) => {
-          return {
-            "data-num-id": numberingProperties?.numId,
-            "data-level": numberingProperties?.ilvl
-          };
-        }
-      }
+      tabStops: { rendered: false }
     };
   },
   parseDOM() {
@@ -19937,59 +20868,12 @@ const Paragraph = OxmlNode.create({
       {
         tag: "p",
         getAttrs: (node) => {
-          const numberingProperties = {};
-          let indent, spacing;
-          const { styleid: styleId, ...extraAttrs } = Array.from(node.attributes).reduce((acc, attr) => {
-            if (attr.name === "data-num-id") {
-              numberingProperties.numId = parseInt(attr.value);
-            } else if (attr.name === "data-level") {
-              numberingProperties.ilvl = parseInt(attr.value);
-            } else if (attr.name === "data-indent") {
-              try {
-                indent = JSON.parse(attr.value);
-                Object.keys(indent).forEach((key2) => {
-                  indent[key2] = Number(indent[key2]);
-                });
-              } catch {
-              }
-            } else if (attr.name === "data-spacing") {
-              try {
-                spacing = JSON.parse(attr.value);
-                Object.keys(spacing).forEach((key2) => {
-                  spacing[key2] = Number(spacing[key2]);
-                });
-              } catch {
-              }
-            } else {
-              acc[attr.name] = attr.value;
-            }
+          const { styleid, ...extraAttrs } = Array.from(node.attributes).reduce((acc, attr) => {
+            acc[attr.name] = attr.value;
             return acc;
           }, {});
-          if (Object.keys(numberingProperties).length > 0) {
-            const resolvedParagraphProperties = resolveParagraphProperties(
-              { docx: this.editor.converter.convertedXml, numbering: this.editor.converter.numbering },
-              { styleId, numberingProperties, indent, spacing },
-              false,
-              true
-            );
-            return {
-              paragraphProperties: {
-                numberingProperties,
-                indent,
-                spacing,
-                styleId: styleId || null
-              },
-              indent: resolvedParagraphProperties.indent,
-              spacing: resolvedParagraphProperties.spacing,
-              numberingProperties,
-              styleId: styleId || null,
-              extraAttrs
-            };
-          }
           return {
-            styleId: styleId || null,
-            indent,
-            spacing,
+            styleId: styleid || null,
             extraAttrs
           };
         }
@@ -20017,101 +20901,6 @@ const Paragraph = OxmlNode.create({
   renderDOM({ htmlAttributes }) {
     return ["p", Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
   },
-  addNodeView() {
-    if (shouldSkipNodeView(this.editor)) return null;
-    return ({ node, editor, getPos, decorations, extensionAttrs }) => {
-      return new ParagraphNodeView(node, editor, getPos, decorations, extensionAttrs);
-    };
-  },
-  addShortcuts() {
-    return {
-      "Mod-Shift-7": () => {
-        return this.editor.commands.toggleOrderedList();
-      },
-      "Mod-Shift-8": () => {
-        return this.editor.commands.toggleBulletList();
-      },
-      Enter: (params2) => {
-        return removeNumberingProperties({ checkType: "empty" })({
-          ...params2,
-          tr: this.editor.state.tr,
-          state: this.editor.state,
-          dispatch: this.editor.view.dispatch
-        });
-      },
-      "Shift-Enter": () => {
-        return this.editor.commands.first(({ commands: commands2 }) => [
-          () => commands2.createParagraphNear(),
-          splitBlock$1({
-            attrsToRemoveOverride: ["paragraphProperties.numberingProperties", "listRendering", "numberingProperties"]
-          })
-        ]);
-      },
-      Tab: () => {
-        return this.editor.commands.first(({ commands: commands2 }) => [() => commands2.increaseListIndent()]);
-      },
-      "Shift-Tab": () => {
-        return this.editor.commands.first(({ commands: commands2 }) => [() => commands2.decreaseListIndent()]);
-      }
-    };
-  },
-  addInputRules() {
-    return [
-      { regex: orderedInputRegex, type: "orderedList" },
-      { regex: bulletInputRegex, type: "bulletList" }
-    ].map(
-      ({ regex, type }) => new InputRule({
-        match: regex,
-        handler: ({ state, range }) => {
-          const parentListItem = findParentNode(isList)(state.selection);
-          if (parentListItem) {
-            return null;
-          }
-          const { tr } = state;
-          tr.delete(range.from, range.to);
-          ListHelpers.createNewList({
-            listType: type,
-            tr,
-            editor: this.editor
-          });
-        }
-      })
-    );
-  },
-  addCommands() {
-    return {
-      /**
-       * Toggle ordered list formatting
-       * @category Command
-       * @example
-       * editor.commands.toggleOrderedList()
-       * @note Converts selection to ordered list or back to paragraphs
-       */
-      toggleOrderedList: () => (params2) => {
-        return toggleList("orderedList")(params2);
-      },
-      /**
-       * Toggle a bullet list at the current selection
-       * @category Command
-       * @example
-       * // Toggle bullet list on selected text
-       * editor.commands.toggleBulletList()
-       * @note Converts selected paragraphs to list items or removes list formatting
-       */
-      toggleBulletList: () => (params2) => {
-        return toggleList("bulletList")(params2);
-      },
-      /**
-       * Restart numbering for the current list
-       * @category Command
-       * @example
-       * // Restart numbering for the current list item
-       * editor.commands.restartNumbering()
-       * @note Resets list numbering for the current list item and following items
-       */
-      restartNumbering: () => restartNumbering
-    };
-  },
   addPmPlugins() {
     const { view } = this.editor;
     const dropcapWidthCache = /* @__PURE__ */ new Map();
@@ -20185,8 +20974,7 @@ const Paragraph = OxmlNode.create({
         }
       }
     });
-    const numberingPlugin = createNumberingPlugin(this.editor);
-    return [dropcapPlugin, numberingPlugin];
+    return [dropcapPlugin];
   }
 });
 const getDropcapDecorations = (state, view, widthCache) => {
@@ -20383,6 +21171,259 @@ const CommentsMark = Mark.create({
     return [CommentMarkName, Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes)];
   }
 });
+const defaultTabDistance = 48;
+const defaultLineLength = 816;
+const getTabDecorations = (doc2, view, helpers2, from2 = 0, to = null) => {
+  const decorations = [];
+  const paragraphCache = /* @__PURE__ */ new Map();
+  const coordCache = /* @__PURE__ */ new Map();
+  const domPosCache = /* @__PURE__ */ new Map();
+  const end2 = to ?? doc2.content.size;
+  doc2.nodesBetween(from2, end2, (node, pos) => {
+    if (node.type.name !== "tab") return;
+    let extraStyles = "";
+    const $pos = doc2.resolve(pos);
+    const paragraphContext = getParagraphContext($pos, paragraphCache, helpers2);
+    if (!paragraphContext) return;
+    try {
+      const { tabStops, flattened, positionMap, startPos } = paragraphContext;
+      const entryIndex = positionMap.get(pos);
+      if (entryIndex === void 0) return;
+      if (paragraphContext.indentWidth === void 0) {
+        paragraphContext.indentWidth = getIndentWidth(view, startPos, paragraphContext.indent, coordCache, domPosCache);
+      }
+      if (paragraphContext.tabHeight === void 0) {
+        paragraphContext.tabHeight = calcTabHeight($pos);
+      }
+      const indentWidth = paragraphContext.indentWidth;
+      const accumulatedTabWidth = paragraphContext.accumulatedTabWidth || 0;
+      const currentWidth = indentWidth + measureRangeWidth(view, startPos + 1, pos, coordCache, domPosCache) + accumulatedTabWidth;
+      let tabWidth;
+      if (tabStops.length) {
+        const tabStop = tabStops.find((stop) => stop.pos > currentWidth && stop.val !== "clear");
+        if (tabStop) {
+          tabWidth = tabStop.pos - currentWidth;
+          if (tabStop.val === "center" || tabStop.val === "end" || tabStop.val === "right") {
+            const nextTabIndex = findNextTabIndex(flattened, entryIndex + 1);
+            const segmentStartPos = pos + node.nodeSize;
+            const segmentEndPos = nextTabIndex === -1 ? startPos + paragraphContext.paragraph.nodeSize - 1 : flattened[nextTabIndex].pos;
+            const segmentWidth = measureRangeWidth(view, segmentStartPos, segmentEndPos, coordCache, domPosCache);
+            tabWidth -= tabStop.val === "center" ? segmentWidth / 2 : segmentWidth;
+          } else if (tabStop.val === "decimal" || tabStop.val === "num") {
+            const breakChar = tabStop.decimalChar || ".";
+            const decimalPos = findDecimalBreakPos(flattened, entryIndex + 1, breakChar);
+            const integralWidth = decimalPos ? measureRangeWidth(view, pos + node.nodeSize, decimalPos, coordCache, domPosCache) : measureRangeWidth(
+              view,
+              pos + node.nodeSize,
+              startPos + paragraphContext.paragraph.nodeSize - 1,
+              coordCache,
+              domPosCache
+            );
+            tabWidth -= integralWidth;
+          }
+          if (tabStop.leader) {
+            const leaderStyles = {
+              dot: "border-bottom: 1px dotted black;",
+              heavy: "border-bottom: 2px solid black;",
+              hyphen: "border-bottom: 1px solid black;",
+              middleDot: "border-bottom: 1px dotted black; margin-bottom: 2px;",
+              underscore: "border-bottom: 1px solid black;"
+            };
+            extraStyles += leaderStyles[tabStop.leader] || "";
+          }
+        }
+      }
+      if (!tabWidth || tabWidth < 1) {
+        tabWidth = defaultTabDistance - currentWidth % defaultLineLength % defaultTabDistance;
+        if (tabWidth === 0) tabWidth = defaultTabDistance;
+      }
+      const tabHeight = paragraphContext.tabHeight;
+      decorations.push(
+        Decoration.node(pos, pos + node.nodeSize, {
+          style: `width: ${tabWidth}px; height: ${tabHeight};${extraStyles}`
+        })
+      );
+      paragraphContext.accumulatedTabWidth = accumulatedTabWidth + tabWidth;
+    } catch (error) {
+      console.error("tab decoration error", error);
+    }
+  });
+  return decorations;
+};
+function getParagraphContext($pos, cache, helpers2) {
+  for (let depth = $pos.depth; depth >= 0; depth--) {
+    const node = $pos.node(depth);
+    if (node?.type?.name === "paragraph") {
+      const startPos = $pos.start(depth);
+      if (!cache.has(startPos)) {
+        let tabStops = [];
+        if (Array.isArray(node.attrs?.tabStops)) {
+          tabStops = node.attrs.tabStops;
+        } else {
+          const style = helpers2.linkedStyles.getStyleById(node.attrs?.styleId);
+          if (Array.isArray(style?.definition?.styles?.tabStops)) {
+            tabStops = style.definition.styles.tabStops;
+          }
+        }
+        const { entries, positionMap } = flattenParagraph(node, startPos);
+        cache.set(startPos, {
+          paragraph: node,
+          paragraphDepth: depth,
+          startPos,
+          indent: node.attrs?.indent || {},
+          tabStops,
+          flattened: entries,
+          positionMap,
+          // Store position map for O(1) lookups
+          accumulatedTabWidth: 0
+        });
+      }
+      return cache.get(startPos);
+    }
+  }
+  return null;
+}
+function flattenParagraph(paragraph, paragraphStartPos) {
+  const entries = [];
+  const positionMap = /* @__PURE__ */ new Map();
+  const walk = (node, basePos) => {
+    if (!node) return;
+    if (node.type?.name === "run") {
+      node.forEach((child, offset2) => {
+        const childPos = basePos + offset2 + 1;
+        walk(child, childPos);
+      });
+      return;
+    }
+    const pos = basePos - 1;
+    const index2 = entries.length;
+    entries.push({ node, pos });
+    positionMap.set(pos, index2);
+  };
+  paragraph.forEach((child, offset2) => {
+    const childPos = paragraphStartPos + offset2 + 1;
+    walk(child, childPos);
+  });
+  return { entries, positionMap };
+}
+function findNextTabIndex(flattened, fromIndex) {
+  for (let i = fromIndex; i < flattened.length; i++) {
+    if (flattened[i]?.node?.type?.name === "tab") {
+      return i;
+    }
+  }
+  return -1;
+}
+function findDecimalBreakPos(flattened, startIndex, breakChar) {
+  for (let i = startIndex; i < flattened.length; i++) {
+    const entry = flattened[i];
+    if (!entry) break;
+    if (entry.node.type?.name === "tab") break;
+    if (entry.node.type?.name === "text") {
+      const index2 = entry.node.text?.indexOf(breakChar);
+      if (index2 !== void 0 && index2 !== -1) {
+        return entry.pos + index2 + 1;
+      }
+    }
+  }
+  return null;
+}
+function measureRangeWidth(view, from2, to, coordCache = null, domPosCache = null) {
+  if (!Number.isFinite(from2) || !Number.isFinite(to) || to <= from2) return 0;
+  try {
+    const range = document.createRange();
+    const fromRef = getCachedDomAtPos(view, from2, domPosCache);
+    const toRef = getCachedDomAtPos(view, to, domPosCache);
+    range.setStart(fromRef.node, fromRef.offset);
+    range.setEnd(toRef.node, toRef.offset);
+    const rect = range.getBoundingClientRect();
+    range.detach?.();
+    return rect.width || 0;
+  } catch {
+    const startLeft = getLeftCoord(view, from2, coordCache, domPosCache);
+    const endLeft = getLeftCoord(view, to, coordCache, domPosCache);
+    if (startLeft == null || endLeft == null) return 0;
+    return Math.max(0, endLeft - startLeft);
+  }
+}
+function getIndentWidth(view, paragraphStartPos, indentAttrs = {}, coordCache = null, domPosCache = null) {
+  const marginLeft = getLeftCoord(view, paragraphStartPos, coordCache, domPosCache);
+  const lineLeft = getLeftCoord(view, paragraphStartPos + 1, coordCache, domPosCache);
+  if (marginLeft != null && lineLeft != null) {
+    const diff = lineLeft - marginLeft;
+    if (!Number.isNaN(diff) && Math.abs(diff) > 0.5) {
+      return diff;
+    }
+  }
+  return calculateIndentFallback(indentAttrs);
+}
+function calculateIndentFallback(indentAttrs = {}) {
+  if (!indentAttrs) return 0;
+  const left2 = Number(indentAttrs.left) || 0;
+  const firstLine = Number(indentAttrs.firstLine) || 0;
+  const hanging = Number(indentAttrs.hanging) || 0;
+  let textIndent = 0;
+  if (firstLine && hanging) {
+    textIndent = firstLine - hanging;
+  } else if (firstLine) {
+    textIndent = firstLine;
+  } else if (hanging) {
+    textIndent = -hanging;
+  } else if (typeof indentAttrs.textIndent === "string") {
+    const match = indentAttrs.textIndent.match(/(-?\d*\.?\d+)in$/);
+    if (match) {
+      textIndent = Number(match[1]) * 96;
+    }
+  }
+  if (textIndent) return left2 + textIndent;
+  if (left2) return left2;
+  return 0;
+}
+function getLeftCoord(view, pos, coordCache = null, domPosCache = null) {
+  if (!Number.isFinite(pos)) return null;
+  if (coordCache && coordCache.has(pos)) {
+    return coordCache.get(pos);
+  }
+  let result = null;
+  try {
+    result = view.coordsAtPos(pos).left;
+  } catch {
+    try {
+      const ref2 = getCachedDomAtPos(view, pos, domPosCache);
+      const range = document.createRange();
+      range.setStart(ref2.node, ref2.offset);
+      range.setEnd(ref2.node, ref2.offset);
+      const rect = range.getBoundingClientRect();
+      range.detach?.();
+      result = rect.left;
+    } catch {
+      result = null;
+    }
+  }
+  if (coordCache) {
+    coordCache.set(pos, result);
+  }
+  return result;
+}
+function getCachedDomAtPos(view, pos, domPosCache = null) {
+  if (domPosCache && domPosCache.has(pos)) {
+    return domPosCache.get(pos);
+  }
+  const result = view.domAtPos(pos);
+  if (domPosCache) {
+    domPosCache.set(pos, result);
+  }
+  return result;
+}
+function calcTabHeight(pos) {
+  const ptToPxRatio = 1.333;
+  const defaultFontSize = 16;
+  const defaultLineHeight = 1.1;
+  const blockParent2 = pos.node(1);
+  const parentTextStyleMark = blockParent2.firstChild.marks.find((mark) => mark.type.name === "textStyle");
+  const fontSize = parseInt(parentTextStyleMark?.attrs.fontSize) * ptToPxRatio || defaultFontSize;
+  return `${fontSize * defaultLineHeight}px`;
+}
 const TabNode = Node$1.create({
   name: "tab",
   group: "inline",
@@ -24734,60 +25775,42 @@ function toHex(color) {
   };
   return `#${hex(r2)}${hex(g)}${hex(b)}${a < 1 ? hex(Math.round(a * 255)) : ""}`;
 }
-const summarizeListContent = (node, fieldsToDeleteSet) => {
-  const summary = {
-    totalFieldAnnotations: 0,
-    deletableFieldAnnotations: 0,
-    hasOtherInlineContent: false
-  };
-  if (typeof node?.descendants !== "function") {
-    return summary;
-  }
-  node.descendants((child) => {
-    if (!child) return true;
-    if (child.type?.name === "fieldAnnotation") {
-      summary.totalFieldAnnotations += 1;
-      const fieldId = child.attrs?.fieldId;
-      if (fieldId && fieldsToDeleteSet.has(fieldId)) {
-        summary.deletableFieldAnnotations += 1;
-      } else {
-        summary.hasOtherInlineContent = true;
-      }
-      return false;
-    }
-    if (child.isText) {
-      if (child.text?.trim()) {
-        summary.hasOtherInlineContent = true;
-      }
-      return false;
-    }
-    if (child.isInline || child.isAtom) {
-      summary.hasOtherInlineContent = true;
-      return false;
-    }
-    return true;
-  });
-  return summary;
-};
 const cleanUpListsWithAnnotations = (fieldsToDelete = []) => ({ dispatch, tr, state }) => {
   if (!dispatch) return true;
   if (!Array.isArray(fieldsToDelete)) fieldsToDelete = [fieldsToDelete];
-  const fieldsToDeleteSet = new Set(fieldsToDelete);
   const { doc: doc2 } = state;
   const docxAnnotations = getAllFieldAnnotations(state) || [];
   const nodesToDelete = [];
   fieldsToDelete.forEach((fieldId) => {
     const matched = docxAnnotations.find((a) => a.node.attrs.fieldId === fieldId);
     if (!matched) return;
-    const listItem = findParentNodeClosestToPos(doc2.resolve(matched.pos), isList);
+    const listItem = findParentNodeClosestToPos(doc2.resolve(matched.pos), (node2) => node2.type.name === "listItem");
     if (!listItem) return;
-    const { totalFieldAnnotations, deletableFieldAnnotations, hasOtherInlineContent } = summarizeListContent(
-      listItem.node,
-      fieldsToDeleteSet
-    );
-    if (!totalFieldAnnotations) return;
-    if (hasOtherInlineContent) return;
-    if (totalFieldAnnotations !== deletableFieldAnnotations) return;
+    let remainingNodes = 0;
+    listItem.node.descendants((node2) => {
+      if (node2.type.name === "fieldAnnotation") {
+        remainingNodes += 1;
+      }
+    });
+    let matchingNodesFound = 0;
+    let hasOtherNodes = false;
+    listItem.node.children.forEach((child) => {
+      const { type } = child;
+      if (type.name !== "paragraph" && type.name !== "fieldAnnotation") return;
+      child.children.forEach((inline) => {
+        const isFieldToDelete = fieldsToDelete.includes(inline.attrs.fieldId);
+        const isFieldType = inline.type.name === "fieldAnnotation";
+        const isMatchingField = isFieldType && isFieldToDelete;
+        if (!isFieldType && !isMatchingField) hasOtherNodes = true;
+        if (isMatchingField) matchingNodesFound += 1;
+      });
+    });
+    if (!hasOtherNodes && matchingNodesFound > 0) {
+      remainingNodes -= matchingNodesFound;
+    }
+    if (remainingNodes > 0) {
+      return;
+    }
     let { pos, node, depth } = listItem;
     let $pos = doc2.resolve(pos);
     while (depth > 0) {
@@ -30717,21 +31740,6 @@ const TextStyle = Mark.create({
           if (!hasStyles || isAnnotation) return false;
           return {};
         }
-      },
-      {
-        getAttrs: (node) => {
-          const fontFamily = node.style.fontFamily?.replace(/['"]+/g, "");
-          const fontSize = node.style.fontSize;
-          const textTransform = node.style.textTransform;
-          if (fontFamily || fontSize || textTransform) {
-            return {
-              fontFamily: fontFamily || null,
-              fontSize: fontSize || null,
-              textTransform: textTransform || null
-            };
-          }
-          return false;
-        }
       }
     ];
   },
@@ -30802,8 +31810,8 @@ const Bold = Mark.create({
       value: {
         default: null,
         renderDOM: (attrs) => {
-          if (attrs.value == null) return {};
-          if (attrs.value === "0" || !attrs.value) {
+          if (!attrs.value) return {};
+          if (attrs.value === "0") {
             return { style: "font-weight: normal" };
           }
           return {};
@@ -30880,8 +31888,8 @@ const Italic = Mark.create({
       value: {
         default: null,
         renderDOM: (attrs) => {
-          if (attrs.value == null) return {};
-          if (attrs.value === "0" || !attrs.value) return { style: "font-style: normal" };
+          if (!attrs.value) return {};
+          if (attrs.value === "0") return { style: "font-style: normal" };
           return {};
         }
       }
@@ -31100,7 +32108,7 @@ const Strike = Mark.create({
     const merged = Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
     const { value } = mark.attrs;
     const { ...rest } = merged || {};
-    if (value === "0" || value === false) {
+    if (value === "0") {
       return ["span", rest, 0];
     }
     return ["s", rest, 0];
@@ -31143,8 +32151,8 @@ const Strike = Mark.create({
       value: {
         default: null,
         renderDOM: (attrs) => {
-          if (attrs.value == null) return {};
-          if (attrs.value === "0" || !attrs.value) {
+          if (!attrs.value) return {};
+          if (attrs.value === "0") {
             return { style: "text-decoration: none" };
           }
           return {};
@@ -37515,6 +38523,7 @@ const NodeResizer = Extension.create({
 const getRichTextExtensions = () => {
   return [
     Bold,
+    BulletList,
     Color,
     Document,
     FontFamily,
@@ -37522,8 +38531,10 @@ const getRichTextExtensions = () => {
     History,
     Heading,
     Italic,
+    ListItem,
     LineHeight,
     Link,
+    OrderedList,
     Paragraph,
     Strike,
     Text,
@@ -37555,6 +38566,7 @@ const getStarterExtensions = () => {
   return [
     Bold,
     BlockNode,
+    BulletList,
     Color,
     CommentRangeStart,
     CommentRangeEnd,
@@ -37565,8 +38577,10 @@ const getStarterExtensions = () => {
     History,
     Heading,
     Italic,
+    ListItem,
     LineHeight,
     Link,
+    OrderedList,
     Paragraph,
     LineBreak,
     HardBreak,
@@ -37639,27 +38653,28 @@ export {
   _export_sfc as _,
   getQuickFormatList as a,
   generateLinkedStyleString as b,
-  getFileOpener as c,
-  checkAndProcessImage as d,
-  uploadAndInsertImage as e,
-  collectTrackedChanges as f,
+  collectTargetListItemPositions as c,
+  getFileOpener as d,
+  checkAndProcessImage as e,
+  uploadAndInsertImage as f,
   global as g,
-  undoDepth as h,
+  collectTrackedChanges as h,
   isTrackedChangeActionAllowed as i,
-  redoDepth as j,
-  collectTrackedChangesForContext as k,
-  isHeadless as l,
-  getStarterExtensions as m,
-  getRichTextExtensions as n,
-  Decoration as o,
-  Extension as p,
-  index$1 as q,
+  undoDepth as j,
+  redoDepth as k,
+  collectTrackedChangesForContext as l,
+  isHeadless as m,
+  getStarterExtensions as n,
+  getRichTextExtensions as o,
+  Decoration as p,
+  Extension as q,
   replaceSelectionWithImagePlaceholder as r,
   shouldBypassContextMenu as s,
-  index as t,
+  index$1 as t,
   useHighContrastMode as u,
-  AnnotatorHelpers as v,
-  SectionHelpers as w,
-  getAllowedImageDimensions as x,
-  yUndoPluginKey as y
+  index as v,
+  AnnotatorHelpers as w,
+  SectionHelpers as x,
+  yUndoPluginKey as y,
+  getAllowedImageDimensions as z
 };