superdoc 0.30.0 → 0.31.0-next.1

package/dist/super-editor/chunks/{editor-CNJV20ln.js → editor-B0PiO07g.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, _ListItemNodeView_instances, init_fn3, applyIndentStyling_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, _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;
 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 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 { 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-B3mE6WPB.js";
+import { D as DocxZipper } from "./docx-zipper-FgUekv4g.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,12 +8251,15 @@ const ensureMarks = (state, splittableMarks) => {
     state.tr.ensureMarks(filtered);
   }
 };
-const splitBlock$1 = ({ keepMarks = true } = {}) => (props) => {
+const splitBlock$1 = ({ keepMarks = true, attrsToRemoveOverride = [] } = {}) => (props) => {
   const { tr, state, dispatch, editor } = props;
   const { selection, doc: doc2 } = tr;
   const { $from, $to } = selection;
   const extensionAttrs = editor.extensionService.attributes;
-  const newAttrs = Attribute.getSplittedAttributes(extensionAttrs, $from.node().type.name, $from.node().attrs);
+  let newAttrs = Attribute.getSplittedAttributes(extensionAttrs, $from.node().type.name, $from.node().attrs);
+  if (attrsToRemoveOverride.length > 0) {
+    newAttrs = deleteAttributes(newAttrs, attrsToRemoveOverride);
+  }
   if (selection instanceof NodeSelection && selection.node.isBlock) {
     if (!$from.parentOffset || !canSplit(doc2, $from.pos)) return false;
     if (dispatch) {
@@ -8291,6 +8294,23 @@ const splitBlock$1 = ({ keepMarks = true } = {}) => (props) => {
   }
   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;
@@ -9111,7 +9131,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, state, commands: commands2, editor }) => {
+const insertContent = (value, options = {}) => ({ tr, commands: commands2, editor }) => {
   if (options.contentType) {
     const validTypes = ["html", "markdown", "text", "schema"];
     if (!validTypes.includes(options.contentType)) {
@@ -9122,7 +9142,7 @@ const insertContent = (value, options = {}) => ({ tr, state, commands: commands2
       const processedDoc = processContent({
         content: value,
         type: options.contentType,
-        schema: state.schema
+        editor
       });
       const jsonContent = processedDoc.toJSON();
       const ok = commands2.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, jsonContent, options);
@@ -9149,12 +9169,13 @@ const removeWhitespaces = (node) => {
   }
   return node;
 };
-function elementFromString(value) {
+function elementFromString(value, editor) {
   const wrappedValue = `<body>${value}</body>`;
-  const html = new window.DOMParser().parseFromString(wrappedValue, "text/html").body;
+  const html = htmlHandler(wrappedValue, editor);
   return removeWhitespaces(html);
 }
-function createNodeFromContent(content, schema, options) {
+function createNodeFromContent(content, editor, options) {
+  const schema = editor.schema;
   options = {
     slice: true,
     parseOptions: {},
@@ -9178,7 +9199,7 @@ function createNodeFromContent(content, schema, 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("", schema, options);
+      return createNodeFromContent("", editor, options);
     }
   }
   if (isTextContent) {
@@ -9208,9 +9229,9 @@ function createNodeFromContent(content, schema, options) {
         })
       });
       if (options.slice) {
-        DOMParser$1.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
+        DOMParser$1.fromSchema(contentCheckSchema).parseSlice(elementFromString(content, editor), options.parseOptions);
       } else {
-        DOMParser$1.fromSchema(contentCheckSchema).parse(elementFromString(content), options.parseOptions);
+        DOMParser$1.fromSchema(contentCheckSchema).parse(elementFromString(content, editor), options.parseOptions);
       }
       if (options.errorOnInvalidContent && hasInvalidContent) {
         throw new Error("[super-editor error]: Invalid HTML content", {
@@ -9220,11 +9241,11 @@ function createNodeFromContent(content, schema, options) {
     }
     const parser = DOMParser$1.fromSchema(schema);
     if (options.slice) {
-      return parser.parseSlice(elementFromString(content), options.parseOptions).content;
+      return parser.parseSlice(elementFromString(content, editor), options.parseOptions).content;
     }
-    return parser.parse(elementFromString(content), options.parseOptions);
+    return parser.parse(elementFromString(content, editor), options.parseOptions);
   }
-  return createNodeFromContent("", schema, options);
+  return createNodeFromContent("", editor, options);
 }
 function selectionToInsertionEnd(tr, startLen, bias) {
   const last = tr.steps.length - 1;
@@ -9260,7 +9281,7 @@ const insertContentAt = (position, value, options) => ({ tr, dispatch, editor })
   };
   let content;
   try {
-    content = createNodeFromContent(value, editor.schema, {
+    content = createNodeFromContent(value, editor, {
       parseOptions: {
         preserveWhitespace: "full",
         ...options.parseOptions
@@ -9347,539 +9368,112 @@ const undoInputRule = () => ({ state, dispatch }) => {
   }
   return false;
 };
-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;
-  }
-  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)
+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 {
     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)
+  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 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;
-  };
-}
-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 };
-    }
-  }
-  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;
+  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;
+      }
     }
-    return true;
-  });
-  if (found != null) {
-    tr.setSelection(TextSelection.create(tr.doc, found, found));
-  } else {
-    const fallback = Math.min(tr.doc.content.size, Math.max(1, containerPos + 1));
-    tr.setSelection(TextSelection.create(tr.doc, fallback, fallback));
   }
-}
-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 };
+  let mode = null;
+  let sharedNumberingProperties = null;
+  if (firstListNode) {
+    if (!hasNonListParagraphs) {
+      mode = "remove";
     } 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;
-    }
-    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);
+      mode = "reuse";
+      const baseNumbering = firstListNode.attrs.numberingProperties || {};
+      sharedNumberingProperties = {
+        ...baseNumbering,
+        ilvl: baseNumbering.ilvl ?? 0
+      };
     }
-    setMappedSelectionSpan(tr, spanFromBefore, spanToBefore);
-    if (dispatch) dispatch(tr);
-    return true;
+  } else {
+    mode = "create";
+    const numId = ListHelpers.getNewListId(editor);
+    ListHelpers.generateNewListDefinition({ numId: Number(numId), listType, editor });
+    sharedNumberingProperties = {
+      numId: Number(numId),
+      ilvl: 0
+    };
   }
-  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;
+  for (const { node, pos } of paragraphsInSelection) {
+    if (mode === "remove") {
+      updateNumberingProperties(null, node, pos, editor, tr);
+      continue;
     }
+    if (mode === "reuse" && predicate(node)) {
+      continue;
+    }
+    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 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 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;
-    }
+const increaseListIndent = () => ({ editor, tr, dispatch }) => {
+  const handled = changeListLevel(1, editor, tr);
+  if (handled && dispatch) {
+    dispatch(tr);
   }
-  return null;
+  return handled;
 };
-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 });
-    }
-  });
-  if (!candidates.length && typeof fallbackPos === "number") {
-    return [fallbackPos];
+const decreaseListIndent = () => ({ editor, tr, dispatch }) => {
+  const handled = changeListLevel(-1, editor, tr);
+  if (handled && dispatch) {
+    dispatch(tr);
   }
-  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]);
+  return handled;
 };
-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
-      });
+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();
     }
-    tr.setNodeMarkup(mappedPos, null, {
-      ...attrs,
-      level: newLevel,
-      numId
-    });
-  });
-  return Object.values(parentListsMap).length ? !Object.values(parentListsMap).every((pos) => !pos) : true;
+    return outdented;
+  } else {
+    updateNumberingProperties(null, paragraph, pos, editor, tr);
+  }
+  if (dispatch) dispatch(tr);
+  return true;
 };
 function isVisuallyEmptyParagraph(node) {
   if (!node || node.type.name !== "paragraph") return false;
@@ -9896,7 +9490,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") {
+    if (n.isInline && n.isLeaf && n.type?.name !== "hardBreak" && n.type?.name !== "run") {
       hasInlineLeaf = true;
       return false;
     }
@@ -9905,468 +9499,6 @@ 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(
@@ -10420,23 +9552,18 @@ const getSelectionMarks = () => ({ state, tr }) => {
 };
 const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  atVisualParaEnd,
+  changeListLevel,
   clearNodes,
-  collectIntersectingTopLists,
   command,
   createParagraphNear,
   decreaseListIndent,
   defaultStyleDetector,
-  deleteListItem,
   deleteSelection,
   exitCode,
   first,
   getEffectiveStyleId,
-  getParaCtx,
   getSelectionMarks,
   getStyleIdFromMarks,
-  handleBackspaceNextToList,
-  handleDeleteNextToList,
   increaseListIndent,
   insertContent,
   insertContentAt,
@@ -10449,11 +9576,9 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   joinForward,
   joinUp,
   liftEmptyBlock,
-  liftListItem,
   mapMarkToStyleKey,
-  nearestListAt,
   newlineInCode,
-  rebuildListNodeWithNewNum,
+  removeNumberingProperties,
   resetAttributes,
   restoreSelection,
   selectAll,
@@ -10461,14 +9586,11 @@ 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,
@@ -10477,7 +9599,7 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   unsetAllMarks,
   unsetMark,
   updateAttributes,
-  wrapInList
+  updateNumberingProperties
 }, Symbol.toStringTag, { value: "Module" }));
 const Commands = Extension.create({
   name: "commands",
@@ -10502,8 +9624,7 @@ const handleBackspace = (editor) => {
       return false;
     },
     () => commands2.deleteSelection(),
-    () => commands2.handleBackspaceNextToList(),
-    () => commands2.deleteListItem(),
+    () => commands2.removeNumberingProperties(),
     () => commands2.joinBackward(),
     () => commands2.selectNodeBackward()
   ]);
@@ -10511,7 +9632,6 @@ const handleBackspace = (editor) => {
 const handleDelete = (editor) => {
   return editor.commands.first(({ commands: commands2 }) => [
     () => commands2.deleteSelection(),
-    () => commands2.handleDeleteNextToList(),
     () => commands2.joinForward(),
     () => commands2.selectNodeForward()
   ]);
@@ -11028,7 +10148,8 @@ const _ExtensionService = class _ExtensionService {
           getPos,
           decorations,
           htmlAttributes,
-          extension
+          extension,
+          extensionAttrs
         });
       };
       return [extension.name, nodeview];
@@ -15081,7 +14202,7 @@ const _Editor = class _Editor extends EventEmitter {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      import("./index-D04RPnYX.js"),
+      import("./index-0zP7LFOd.js"),
       import("./index-DRCvimau.js"),
       import("./index-C_x_N6Uh.js"),
       import("./index-D_sWOSiG.js"),
@@ -15299,7 +14420,7 @@ const _Editor = class _Editor extends EventEmitter {
    * @returns {Object | void} Migration results
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "0.30.0");
+    console.debug("[checkVersionMigrations] Current editor version", "0.31.0-next.1");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -15404,7 +14525,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.schema);
+    const htmlNode = createDocFromHTML(html, this);
     tr.replaceWith(start2, end2, htmlNode);
     dispatch(tr);
   }
@@ -15779,14 +14900,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.schema, { isImport: true });
-        } else if (this.options.html) doc2 = createDocFromHTML(this.options.html, this.schema, { isImport: true });
+          doc2 = createDocFromMarkdown(this.options.markdown, this, { isImport: true });
+        } else if (this.options.html) doc2 = createDocFromHTML(this.options.html, this, { 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.schema);
+      else if (content) doc2 = createDocFromHTML(content, this);
       else doc2 = this.schema.topNodeType.createAndFill();
     }
   } catch (err) {
@@ -18628,7 +17749,7 @@ const splitRun = () => (props) => {
   const { $from, empty: empty2 } = state.selection;
   if (!empty2) return false;
   if ($from.parent.type.name !== "run") return false;
-  const handled = splitBlock(state, (transaction) => {
+  const handled = splitBlockPatch(state, (transaction) => {
     view.dispatch(transaction);
   });
   if (handled) {
@@ -18636,6 +17757,48 @@ 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",
@@ -18688,387 +17851,6 @@ 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;
 };
@@ -19357,20 +18139,53 @@ const getLinkedStyle = (styleId, styles = []) => {
   return { linkedStyle, basedOnStyle };
 };
 const getSpacingStyle = (spacing) => {
-  const { lineSpaceBefore, lineSpaceAfter, line, lineRule } = spacing;
+  const { lineSpaceBefore, lineSpaceAfter, line, lineRule, beforeAutoSpacing, afterAutoSpacing } = 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 {
-    "margin-top": lineSpaceBefore + "px",
-    "margin-bottom": lineSpaceAfter + "px",
+    ...result,
     ...lineHeightStyles
   };
 };
-const getSpacingStyleString = (spacing) => {
-  const { lineSpaceBefore, lineSpaceAfter, line } = spacing;
+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;
+    }
+  }
   return `
-    ${lineSpaceBefore ? `margin-top: ${lineSpaceBefore}px;` : ""}
-    ${lineSpaceAfter ? `margin-bottom: ${lineSpaceAfter}px;` : ""}
+    ${before ? `margin-top: ${before}px;` : ""}
+    ${after ? `margin-bottom: ${after}px;` : ""}
     ${line ? getLineHeightValueString(line, "") : ""}
   `.trim();
 };
@@ -19868,850 +18683,1073 @@ const LinkedStyles = Extension.create({
     };
   }
 });
-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);
+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;
       }
-      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 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] || "";
+        }
       }
-      break;
+    }
+    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);
   }
-  if (color) add("text-decoration-color", color);
-  return parts.join("; ");
 }
-function collectTextStyleMarks(listItem, markType) {
-  const textStyleMarks = [];
-  const seenMarks = /* @__PURE__ */ new Set();
-  const attrs = {};
-  if (!markType) {
-    return {
-      marks: textStyleMarks,
-      attrs
-    };
+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);
+      }
+      return cache.get(startPos);
+    }
   }
-  const collectMarks = (node) => {
+  return null;
+}
+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;
+    }
+  }
+  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) => {
     if (!node) return;
-    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);
-        }
+    if (node.type?.name === "run") {
+      node.forEach((child, offset2) => {
+        const childPos = basePos + offset2 + 1;
+        walk(child, childPos);
       });
+      return;
     }
-    if (!node.isText && node.childCount) {
-      node.forEach((child) => collectMarks(child));
-    }
+    const pos = basePos - 1;
+    const index2 = entries.length;
+    entries.push({ node, pos });
+    positionMap.set(pos, index2);
   };
-  listItem.forEach((childNode) => {
-    if (childNode.type?.name !== "paragraph") return;
-    if (childNode.attrs?.lineHeight !== void 0) {
-      attrs.lineHeight = childNode.attrs.lineHeight;
-    }
-    collectMarks(childNode);
+  paragraph.forEach((child, offset2) => {
+    const childPos = paragraphStartPos + offset2 + 1;
+    walk(child, childPos);
   });
-  return {
-    marks: textStyleMarks,
-    attrs
-  };
+  return { entries, positionMap };
 }
-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);
+function findNextTabIndex(flattened, fromIndex) {
+  for (let i = fromIndex; i < flattened.length; i++) {
+    if (flattened[i]?.node?.type?.name === "tab") {
+      return i;
+    }
   }
+  return -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
-    };
+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;
+      }
+    }
   }
-  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 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);
   }
-  return inline;
 }
-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;
-    }
-    if (typeof viewPos !== "number") return;
-    if (viewPos < pos) {
-      if (!candidate || viewPos > candidate.pos) candidate = { view, pos: viewPos };
+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 candidate?.view ?? null;
+  }
+  return calculateIndentFallback(indentAttrs);
 }
-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;
-    }
+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;
   }
-  return {
-    fontSize,
-    fontFamily,
-    lineHeight,
-    hasSize,
-    hasFamily
-  };
+  return defaultLineLength;
 }
-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;
+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;
   }
-  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
-  };
+  if (textIndent) return left2 + textIndent;
+  if (left2) return left2;
+  return 0;
 }
-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;
-    }
+function getLeftCoord(view, pos, coordCache = null, domPosCache = null) {
+  if (!Number.isFinite(pos)) return null;
+  if (coordCache && coordCache.has(pos)) {
+    return coordCache.get(pos);
   }
-  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;
+  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;
     }
   }
-  return {
-    fontSize: currentStyles.fontSize,
-    fontFamily: currentStyles.fontFamily,
-    lineHeight: currentStyles.lineHeight
-  };
+  if (coordCache) {
+    coordCache.set(pos, result);
+  }
+  return result;
 }
-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", () => {
-    });
+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(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`;
+}
+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);
     this.node = node;
     this.editor = editor;
+    this.getPos = getPos;
     this.decorations = decorations;
-    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;
-    }
-  }
-  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;
+    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);
+      });
     }
-    if (this._pendingIndentRefresh != null) return;
-    this._pendingIndentRefresh = raf(() => {
-      this._pendingIndentRefresh = null;
-      __privateMethod(this, _ListItemNodeView_instances, applyIndentStyling_fn).call(this);
-    });
+    __privateMethod(this, _ParagraphNodeView_instances, updateHTMLAttributes_fn).call(this);
   }
+  /**
+   * @param {import('prosemirror-model').Node} node
+   * @param {import('prosemirror-view').Decoration[]} decorations
+   */
   update(node, decorations) {
-    const prevNode = this.node;
+    const oldAttrs = this.node.attrs;
+    const newAttrs = node.attrs;
     this.node = node;
     this.decorations = decorations;
-    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);
+    if (JSON.stringify(oldAttrs) === JSON.stringify(newAttrs)) {
+      return true;
     }
-    const { fontSize, fontFamily, lineHeight } = resolveListItemTypography({
-      node,
-      pos: this.getResolvedPos(),
-      editor: this.editor,
-      nodeView: this,
-      activeNodeViews: activeListItemNodeViews
+    __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;
+    }
+    __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);
     });
-    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();
+    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;
     }
+    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() {
-    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._pendingIndentRefresh = null;
+    __privateMethod(this, _ParagraphNodeView_instances, cancelScheduledAnimation_fn).call(this);
   }
 }
-_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 {
-      orderMarker = docxNumberingHelpers.normalizeLvlTextChar(lvlText);
+_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;
     }
+    this.dom.setAttribute(key2, value);
   }
-  const pos = this.getResolvedPos();
-  const { fontSize, fontFamily, lineHeight } = resolveListItemTypography({
-    node: this.node,
-    pos,
-    editor: this.editor,
-    nodeView: this,
-    activeNodeViews: activeListItemNodeViews
+};
+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" ? " " : "";
+  }
+  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;`;
+    } 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;
   });
-  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 });
 };
-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";
+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;
+  }
+  __privateMethod(this, _ParagraphNodeView_instances, cancelScheduledAnimation_fn).call(this);
+  this._animationFrameRequest = globalThis.requestAnimationFrame(() => {
+    fn2();
+    this._animationFrameRequest = null;
+  });
+};
+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;
     },
-    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 = "";
+    /**
+     * 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();
+    },
+    /**
+     * Disable cache-aware logic and clear residual cache entries.
+     */
+    disableCache() {
+      cacheEnabled = false;
+      this._clearCache();
     }
   };
-  const handleStyles = handlers2[lvlJc] ?? handlers2.left;
-  handleStyles();
+}
+const generateOrderedListIndex = ({ listLevel, lvlText, listNumberingType, customFormat }) => {
+  const handler = listIndexMap[listNumberingType];
+  return handler ? handler(listLevel, lvlText, customFormat) : null;
 };
-function refreshAllListItemNodeViews() {
-  activeListItemNodeViews.forEach((nodeView) => {
-    try {
-      nodeView.refreshIndentStyling({ immediate: true });
-    } catch (error) {
-      console.error("Error refreshing list item node view:", error);
-      activeListItemNodeViews.delete(nodeView);
+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;
     }
-  });
-}
-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 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 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;
+};
+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);
+    }
   }
-}
-const orderedListSyncPluginKey = new PluginKey("orderedListSync");
-function orderedListSync(editor) {
-  let hasInitialized = false;
-  const docx = editor.converter.convertedXml;
   return new Plugin({
-    key: orderedListSyncPluginKey,
+    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}
+     */
     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"));
-      const docChanged = transactions.some((tr2) => tr2.docChanged) && !oldState.doc.eq(newState.doc);
-      if (isFromPlugin || !docChanged) {
+      if (isFromPlugin || !transactions.some((tr2) => tr2.docChanged)) {
         return null;
       }
-      hasInitialized = true;
       const tr = newState.tr;
       tr.setMeta("orderedListSync", true);
-      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;
+      numberingManager.enableCache();
       newState.doc.descendants((node, pos) => {
-        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;
-          }
+        if (node.type.name !== "paragraph" || !node.attrs.numberingProperties) {
+          return;
         }
-        if (currentListLevels.length === 0) {
-          currentListLevels = [1];
+        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;
         }
-        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);
+        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
+          });
         }
+        return false;
       });
-      return tr;
+      numberingManager.disableCache();
+      return tr.docChanged ? tr : null;
     }
   });
 }
-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 bulletInputRegex = /^\s*([-+*])\s$/;
+const orderedInputRegex = /^(\d+)\.\s$/;
 const Paragraph = OxmlNode.create({
   name: "paragraph",
   oXmlName: "w:p",
@@ -20739,22 +19777,26 @@ const Paragraph = OxmlNode.create({
         parseDOM: (element) => {
           if (element && element.closest("[data-superdoc-import]")) {
             return {
-              lineSpaceAfter: 11,
-              lineSpaceBefore: 0,
-              line: 1.15,
+              after: pixelsToTwips(11),
+              before: 0,
+              line: linesToTwips(1.15),
               lineRule: "auto"
             };
           }
           return void 0;
         },
         renderDOM: (attrs) => {
-          const { spacing } = attrs;
-          if (!spacing) return {};
+          const { spacing, marksAttrs } = attrs;
+          if (!spacing) return { style: null };
           const spacingCopy = { ...spacing };
           if (attrs.lineHeight) delete spacingCopy.line;
-          const style = getSpacingStyleString(spacingCopy);
+          const style = getSpacingStyleString(
+            spacingCopy,
+            marksAttrs ?? [],
+            Boolean(attrs.paragraphProperties?.numberingProperties)
+          );
           if (style) return { style };
-          return {};
+          return { style: null };
         }
       },
       extraAttrs: {
@@ -20782,17 +19824,17 @@ const Paragraph = OxmlNode.create({
       indent: {
         default: null,
         renderDOM: ({ indent }) => {
-          if (!indent) return {};
+          if (!indent) return { style: null };
           const { left: left2, right: right2, firstLine, hanging } = indent;
           if (indent && Object.values(indent).every((v) => v === 0)) {
-            return {};
+            return { style: null };
           }
           let style = "";
-          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;`;
+          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;`;
           return { style };
         }
       },
@@ -20811,12 +19853,16 @@ const Paragraph = OxmlNode.create({
           sideOrder.forEach((side) => {
             const b = borders[side];
             if (!b) return;
-            const width = b.size != null ? `${b.size}px` : "1px";
+            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 cssStyle = valToCss[b.val] || "solid";
-            const color = b.color || "#000000";
+            const color = !b.color || b.color === "auto" ? "#000000" : `#${b.color}`;
             style += `border-${side}: ${width} ${cssStyle} ${color};`;
             if (b.space != null && side === "bottom") {
-              style += `padding-bottom: ${b.space}px;`;
+              style += `padding-bottom: ${eighthPointsToPixels(b.space)}px;`;
             }
           });
           return style ? { style } : {};
@@ -20830,7 +19876,12 @@ const Paragraph = OxmlNode.create({
           return null;
         }
       },
-      styleId: {},
+      styleId: {
+        renderDOM: (attrs) => {
+          if (!attrs.styleId) return {};
+          return { styleid: attrs.styleId };
+        }
+      },
       sdBlockId: {
         default: null,
         keepOnSplit: false,
@@ -20848,19 +19899,37 @@ const Paragraph = OxmlNode.create({
       paragraphProperties: { rendered: false },
       dropcap: { rendered: false },
       pageBreakSource: { rendered: false },
-      justify: {
-        renderDOM: ({ justify }) => {
-          const { val: jc } = justify || {};
-          if (!jc) return {};
+      textAlign: {
+        renderDOM: ({ textAlign }) => {
+          if (!textAlign) return {};
           let style = "";
-          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;";
+          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;";
           return { style };
         }
       },
-      tabStops: { rendered: false }
+      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
+          };
+        }
+      }
     };
   },
   parseDOM() {
@@ -20868,12 +19937,59 @@ const Paragraph = OxmlNode.create({
       {
         tag: "p",
         getAttrs: (node) => {
-          const { styleid, ...extraAttrs } = Array.from(node.attributes).reduce((acc, attr) => {
-            acc[attr.name] = attr.value;
+          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;
+            }
             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,
+            styleId: styleId || null,
+            indent,
+            spacing,
             extraAttrs
           };
         }
@@ -20901,6 +20017,101 @@ 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();
@@ -20974,7 +20185,8 @@ const Paragraph = OxmlNode.create({
         }
       }
     });
-    return [dropcapPlugin];
+    const numberingPlugin = createNumberingPlugin(this.editor);
+    return [dropcapPlugin, numberingPlugin];
   }
 });
 const getDropcapDecorations = (state, view, widthCache) => {
@@ -21171,259 +20383,6 @@ 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",
@@ -25775,42 +24734,60 @@ 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), (node2) => node2.type.name === "listItem");
+    const listItem = findParentNodeClosestToPos(doc2.resolve(matched.pos), isList);
     if (!listItem) 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;
-    }
+    const { totalFieldAnnotations, deletableFieldAnnotations, hasOtherInlineContent } = summarizeListContent(
+      listItem.node,
+      fieldsToDeleteSet
+    );
+    if (!totalFieldAnnotations) return;
+    if (hasOtherInlineContent) return;
+    if (totalFieldAnnotations !== deletableFieldAnnotations) return;
     let { pos, node, depth } = listItem;
     let $pos = doc2.resolve(pos);
     while (depth > 0) {
@@ -31740,6 +30717,21 @@ 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;
+        }
       }
     ];
   },
@@ -31810,8 +30802,8 @@ const Bold = Mark.create({
       value: {
         default: null,
         renderDOM: (attrs) => {
-          if (!attrs.value) return {};
-          if (attrs.value === "0") {
+          if (attrs.value == null) return {};
+          if (attrs.value === "0" || !attrs.value) {
             return { style: "font-weight: normal" };
           }
           return {};
@@ -31888,8 +30880,8 @@ const Italic = Mark.create({
       value: {
         default: null,
         renderDOM: (attrs) => {
-          if (!attrs.value) return {};
-          if (attrs.value === "0") return { style: "font-style: normal" };
+          if (attrs.value == null) return {};
+          if (attrs.value === "0" || !attrs.value) return { style: "font-style: normal" };
           return {};
         }
       }
@@ -32108,7 +31100,7 @@ const Strike = Mark.create({
     const merged = Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
     const { value } = mark.attrs;
     const { ...rest } = merged || {};
-    if (value === "0") {
+    if (value === "0" || value === false) {
       return ["span", rest, 0];
     }
     return ["s", rest, 0];
@@ -32151,8 +31143,8 @@ const Strike = Mark.create({
       value: {
         default: null,
         renderDOM: (attrs) => {
-          if (!attrs.value) return {};
-          if (attrs.value === "0") {
+          if (attrs.value == null) return {};
+          if (attrs.value === "0" || !attrs.value) {
             return { style: "text-decoration: none" };
           }
           return {};
@@ -38523,7 +37515,6 @@ const NodeResizer = Extension.create({
 const getRichTextExtensions = () => {
   return [
     Bold,
-    BulletList,
     Color,
     Document,
     FontFamily,
@@ -38531,10 +37522,8 @@ const getRichTextExtensions = () => {
     History,
     Heading,
     Italic,
-    ListItem,
     LineHeight,
     Link,
-    OrderedList,
     Paragraph,
     Strike,
     Text,
@@ -38566,7 +37555,6 @@ const getStarterExtensions = () => {
   return [
     Bold,
     BlockNode,
-    BulletList,
     Color,
     CommentRangeStart,
     CommentRangeEnd,
@@ -38577,10 +37565,8 @@ const getStarterExtensions = () => {
     History,
     Heading,
     Italic,
-    ListItem,
     LineHeight,
     Link,
-    OrderedList,
     Paragraph,
     LineBreak,
     HardBreak,
@@ -38653,28 +37639,27 @@ export {
   _export_sfc as _,
   getQuickFormatList as a,
   generateLinkedStyleString as b,
-  collectTargetListItemPositions as c,
-  getFileOpener as d,
-  checkAndProcessImage as e,
-  uploadAndInsertImage as f,
+  getFileOpener as c,
+  checkAndProcessImage as d,
+  uploadAndInsertImage as e,
+  collectTrackedChanges as f,
   global as g,
-  collectTrackedChanges as h,
+  undoDepth as h,
   isTrackedChangeActionAllowed as i,
-  undoDepth as j,
-  redoDepth as k,
-  collectTrackedChangesForContext as l,
-  isHeadless as m,
-  getStarterExtensions as n,
-  getRichTextExtensions as o,
-  Decoration as p,
-  Extension as q,
+  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,
   replaceSelectionWithImagePlaceholder as r,
   shouldBypassContextMenu as s,
-  index$1 as t,
+  index as t,
   useHighContrastMode as u,
-  index as v,
-  AnnotatorHelpers as w,
-  SectionHelpers as x,
-  yUndoPluginKey as y,
-  getAllowedImageDimensions as z
+  AnnotatorHelpers as v,
+  SectionHelpers as w,
+  getAllowedImageDimensions as x,
+  yUndoPluginKey as y
 };