@harbour-enterprises/superdoc 0.20.0-next.13 → 0.20.0-next.15

package/dist/super-editor/chunks/{editor-B97u3IuY.js → editor-BUCOmU2Y.js}

@@ -12,9 +12,9 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 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, registerPluginByNameIfNotExists_fn, createExtensionService_fn, createCommandService_fn, createConverter_fn, initMedia_fn, initFonts_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, _ListItemNodeView_instances, init_fn2, _FieldAnnotationView_instances, createAnnotation_fn, _AutoPageNumberNodeView_instances, renderDom_fn, scheduleUpdateNodeStyle_fn, _DocumentSectionView_instances, init_fn3, addToolTip_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 InputRule, ah as kebabCase, ai as findParentNodeClosestToPos, aj as getListItemStyleDefinitions, ak as docxNumberigHelpers, al as parseIndentElement, am as combineIndents, an as StepMap, ao as SelectionRange, ap as Transform, aq as isInTable$1, ar as generateDocxRandomId, as as insertNewRelationship, at as updateDOMAttributes, au as htmlHandler } from "./converter-CTJIyTAA.js";
+import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, B as Buffer2, f as callOrGet, g as getExtensionConfigField, h as getMarkType, i as getMarksFromSelection, j as getNodeType, k as getSchemaTypeNameByName, l as Schema$1, m as cleanSchemaItem, n as canSplit, o as defaultBlockAt$1, q as liftTarget, r as canJoin, s as joinPoint, t as replaceStep$1, R as ReplaceAroundStep$1, u as isTextSelection, v as getMarkRange, w as isMarkActive, x as isNodeActive, y as deleteProps, z as processContent, C as ReplaceStep, E as NodeRange, G as findWrapping, L as ListHelpers, H as findParentNode, I as isMacOS, J as isIOS, K as getSchemaTypeByName, O as inputRulesPlugin, Q as TrackDeleteMarkName, U as TrackInsertMarkName, V as v4, W as TrackFormatMarkName, X as comments_module_events, Y as findMark, Z as objectIncludes, _ as AddMarkStep, $ as RemoveMarkStep, a0 as twipsToLines, a1 as pixelsToTwips, a2 as helpers, a3 as posToDOMRect, a4 as CommandService, a5 as SuperConverter, a6 as createDocument, a7 as createDocFromMarkdown, a8 as createDocFromHTML, a9 as EditorState, aa as hasSomeParentWithClass, ab as isActive, ac as unflattenListsInHtml, ad as parseSizeUnit, ae as minMax, af as getLineHeightValueString, ag as InputRule, ah as kebabCase, ai as findParentNodeClosestToPos, aj as getListItemStyleDefinitions, ak as docxNumberigHelpers, al as parseIndentElement, am as combineIndents, an as SelectionRange, ao as Transform, ap as isInTable$1, aq as generateDocxRandomId, ar as insertNewRelationship, as as updateDOMAttributes, at as htmlHandler } from "./converter-BJVy6JMW.js";
 import { ref, computed, createElementBlock, openBlock, withModifiers, Fragment as Fragment$1, renderList, normalizeClass, createCommentVNode, toDisplayString, createElementVNode, createApp } from "vue";
-import { D as DocxZipper } from "./docx-zipper-BwicJKh2.js";
+import { D as DocxZipper } from "./docx-zipper-DWDJGX0b.js";
 var GOOD_LEAF_SIZE = 200;
 var RopeSequence = function RopeSequence2() {
 };
@@ -8849,6 +8849,96 @@ const toggleMark = (typeOrName, attrs = {}, options = {}) => ({ state, commands:
   if (isActive2) return commands2.unsetMark(type, { extendEmptyMarkRange });
   return commands2.setMark(type, attrs);
 };
+const toggleMarkCascade = (markName, options = {}) => ({ state, chain, editor }) => {
+  const {
+    negationAttrs = { value: "0" },
+    isNegation = (attrs) => attrs?.value === "0",
+    styleDetector = defaultStyleDetector,
+    extendEmptyMarkRange = true
+  } = options;
+  const selectionMarks = getMarksFromSelection(state) || [];
+  const inlineMarks = selectionMarks.filter((m) => m.type?.name === markName);
+  const hasNegation = inlineMarks.some((m) => isNegation(m.attrs || {}));
+  const hasInline = inlineMarks.some((m) => !isNegation(m.attrs || {}));
+  const styleOn = styleDetector({ state, selectionMarks, markName, editor });
+  const cmdChain = chain();
+  if (hasNegation) return cmdChain.unsetMark(markName, { extendEmptyMarkRange }).run();
+  if (hasInline && styleOn) {
+    return cmdChain.unsetMark(markName, { extendEmptyMarkRange }).setMark(markName, negationAttrs, { extendEmptyMarkRange }).run();
+  }
+  if (hasInline) return cmdChain.unsetMark(markName, { extendEmptyMarkRange }).run();
+  if (styleOn) return cmdChain.setMark(markName, negationAttrs, { extendEmptyMarkRange }).run();
+  return cmdChain.setMark(markName, {}, { extendEmptyMarkRange }).run();
+};
+function defaultStyleDetector({ state, selectionMarks, markName, editor }) {
+  try {
+    const styleId = getEffectiveStyleId(state, selectionMarks);
+    if (!styleId || !editor?.converter?.linkedStyles) return false;
+    const styles = editor.converter.linkedStyles;
+    const seen = /* @__PURE__ */ new Set();
+    let current = styleId;
+    const key2 = mapMarkToStyleKey(markName);
+    while (current && !seen.has(current)) {
+      seen.add(current);
+      const style = styles.find((s) => s.id === current);
+      const def = style?.definition?.styles || {};
+      if (key2 in def) {
+        const raw = def[key2];
+        if (raw === void 0) return true;
+        const val = raw?.value ?? raw;
+        return isStyleTokenEnabled(val);
+      }
+      current = style?.definition?.attrs?.basedOn || null;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function getEffectiveStyleId(state, selectionMarks) {
+  const sidFromMarks = getStyleIdFromMarks(selectionMarks);
+  if (sidFromMarks) return sidFromMarks;
+  const $from = state.selection.$from;
+  const before = $from.nodeBefore;
+  const after = $from.nodeAfter;
+  if (before && before.marks) {
+    const sid = getStyleIdFromMarks(before.marks);
+    if (sid) return sid;
+  }
+  if (after && after.marks) {
+    const sid = getStyleIdFromMarks(after.marks);
+    if (sid) return sid;
+  }
+  const ts = selectionMarks.find((m) => m.type?.name === "textStyle" && m.attrs?.styleId);
+  if (ts) return ts.attrs.styleId;
+  const pos = state.selection.$from.pos;
+  const $pos = state.doc.resolve(pos);
+  for (let d = $pos.depth; d >= 0; d--) {
+    const n = $pos.node(d);
+    if (n?.type?.name === "paragraph") return n.attrs?.styleId || null;
+  }
+  return null;
+}
+function getStyleIdFromMarks(marks) {
+  if (!Array.isArray(marks)) return null;
+  const textStyleMark = marks.find((m) => m.type?.name === "textStyle" && m.attrs?.styleId);
+  if (textStyleMark) return textStyleMark.attrs.styleId;
+  return null;
+}
+function mapMarkToStyleKey(markName) {
+  if (markName === "textStyle" || markName === "color") return "color";
+  return markName;
+}
+function isStyleTokenEnabled(val) {
+  if (val === false || val === 0) return false;
+  if (typeof val === "string") {
+    const normalized = val.trim().toLowerCase();
+    if (!normalized) return false;
+    if (["0", "false", "none", "inherit", "transparent"].includes(normalized)) return false;
+    return true;
+  }
+  return !!val;
+}
 const clearNodes = () => ({ state, tr, dispatch }) => {
   const { selection } = tr;
   const { ranges } = selection;
@@ -10194,11 +10284,14 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   command,
   createParagraphNear,
   decreaseListIndent,
+  defaultStyleDetector,
   deleteListItem,
   deleteSelection,
   exitCode,
   first,
+  getEffectiveStyleId,
   getParaCtx,
+  getStyleIdFromMarks,
   handleBackspaceNextToList,
   handleDeleteNextToList,
   increaseListIndent,
@@ -10207,12 +10300,14 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   insertTabChar,
   insertTabCharacter,
   insertTabNode,
+  isStyleTokenEnabled,
   joinBackward,
   joinDown,
   joinForward,
   joinUp,
   liftEmptyBlock,
   liftListItem,
+  mapMarkToStyleKey,
   nearestListAt,
   newlineInCode,
   rebuildListNodeWithNewNum,
@@ -10232,6 +10327,7 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   splitListItem,
   toggleList,
   toggleMark,
+  toggleMarkCascade,
   toggleNode,
   undoInputRule,
   unsetAllMarks,
@@ -10247,6 +10343,7 @@ const Commands = Extension.create({
 });
 const handleEnter = (editor) => {
   return editor.commands.first(({ commands: commands2 }) => [
+    () => commands2.splitRun(),
     () => commands2.newlineInCode(),
     () => commands2.createParagraphNear(),
     () => commands2.liftEmptyBlock(),
@@ -10280,6 +10377,7 @@ const Keymap = Extension.create({
   addShortcuts() {
     const baseKeymap = {
       Enter: () => handleEnter(this.editor),
+      "Shift-Enter": () => this.editor.commands.insertLineBreak(),
       "Mod-Enter": () => this.editor.commands.exitCode(),
       Backspace: () => handleBackspace(this.editor),
       "Mod-Backspace": () => handleBackspace(this.editor),
@@ -11366,7 +11464,18 @@ const updateYdocDocxData = async (editor, ydoc) => {
   ydoc = ydoc || editor.options.ydoc;
   if (!ydoc) return;
   const metaMap = ydoc.getMap("meta");
-  const docx = [...metaMap.get("docx")];
+  const docxValue = metaMap.get("docx");
+  let docx = [];
+  if (Array.isArray(docxValue)) {
+    docx = [...docxValue];
+  } else if (docxValue && typeof docxValue.toArray === "function") {
+    docx = docxValue.toArray();
+  } else if (docxValue && typeof docxValue[Symbol.iterator] === "function") {
+    docx = Array.from(docxValue);
+  }
+  if (!docx.length && Array.isArray(editor.options.content)) {
+    docx = [...editor.options.content];
+  }
   const newXml = await editor.exportDocx({ getUpdatedDocs: true });
   Object.keys(newXml).forEach((key2) => {
     const fileIndex = docx.findIndex((item) => item.name === key2);
@@ -11444,7 +11553,7 @@ const createHeaderFooterEditor = ({
   currentPageNumber
 }) => {
   const parentStyles = editor.converter.getDocumentDefaultStyles();
-  const { fontSizePt, typeface } = parentStyles;
+  const { fontSizePt, typeface, fontFamilyCss } = parentStyles;
   const fontSizeInPixles = fontSizePt * 1.3333;
   const lineHeight = fontSizeInPixles * 1.2;
   Object.assign(editorContainer.style, {
@@ -11457,7 +11566,7 @@ const createHeaderFooterEditor = ({
     left: "0",
     width: "auto",
     maxWidth: "none",
-    fontFamily: typeface,
+    fontFamily: fontFamilyCss || typeface,
     fontSize: `${fontSizeInPixles}px`,
     lineHeight: `${lineHeight}px`
   });
@@ -12287,7 +12396,6 @@ const trackedTransaction = ({ tr, state, user }) => {
         originalStep,
         originalStepIndex
       });
-      console.debug("[track-changes]: replaceStep");
     } else if (step instanceof AddMarkStep) {
       addMarkStep({
         state,
@@ -12297,7 +12405,6 @@ const trackedTransaction = ({ tr, state, user }) => {
         user,
         date
       });
-      console.debug("[track-changes]: addMarkStep");
     } else if (step instanceof RemoveMarkStep) {
       removeMarkStep({
         state,
@@ -12307,10 +12414,8 @@ const trackedTransaction = ({ tr, state, user }) => {
         user,
         date
       });
-      console.debug("[track-changes]: removeMarkStep");
     } else {
       newTr.step(step);
-      console.log("[track-changes]: otherStep");
     }
   });
   if (tr.getMeta("inputType")) {
@@ -14423,9 +14528,10 @@ const _Editor = class _Editor extends EventEmitter {
     element.style.isolation = "isolate";
     proseMirror.style.outline = "none";
     proseMirror.style.border = "none";
-    const { typeface, fontSizePt } = this.converter.getDocumentDefaultStyles() ?? {};
-    if (typeface) {
-      element.style.fontFamily = typeface;
+    const { typeface, fontSizePt, fontFamilyCss } = this.converter.getDocumentDefaultStyles() ?? {};
+    const resolvedFontFamily = fontFamilyCss || typeface;
+    if (resolvedFontFamily) {
+      element.style.fontFamily = resolvedFontFamily;
     }
     if (fontSizePt) {
       element.style.fontSize = `${fontSizePt}pt`;
@@ -14713,12 +14819,15 @@ const _Editor = class _Editor extends EventEmitter {
   }
   destroyHeaderFooterEditors() {
     try {
-      const editors = [...this.converter.headerEditors, ...this.converter.footerEditors];
+      const headerEditors = this.converter?.headerEditors ?? [];
+      const footerEditors = this.converter?.footerEditors ?? [];
+      if (!headerEditors.length && !footerEditors.length) return;
+      const editors = [...headerEditors, ...footerEditors].filter(Boolean);
       for (let editorData of editors) {
-        editorData.editor.destroy();
+        editorData?.editor?.destroy?.();
       }
-      this.converter.headerEditors.length = 0;
-      this.converter.footerEditors.length = 0;
+      if (headerEditors.length) headerEditors.length = 0;
+      if (footerEditors.length) footerEditors.length = 0;
     } catch (error) {
       this.emit("exception", { error, editor: this });
       console.error(error);
@@ -14741,7 +14850,7 @@ const _Editor = class _Editor extends EventEmitter {
    * @returns {Object | void} Migration results
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "0.20.0");
+    console.debug("[checkVersionMigrations] Current editor version", "0.20.0-next.13");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -15909,6 +16018,7 @@ const FormatCommands = Extension.create({
   },
   addCommands() {
     return {
+      toggleMarkCascade,
       /**
        * Clear all formatting (nodes and marks)
        * @category Command
@@ -16888,27 +16998,69 @@ const Text = Node$1.create({
     return {};
   }
 });
-const RunItem = Node$1.create({
+const splitRun = () => (props) => {
+  const { state, view, tr } = props;
+  const { $from, empty: empty2 } = state.selection;
+  if (!empty2) return false;
+  if ($from.parent.type.name !== "run") return false;
+  const handled = splitBlock(state, (transaction) => {
+    view.dispatch(transaction);
+  });
+  if (handled) {
+    tr.setMeta("preventDispatch", true);
+  }
+  return handled;
+};
+const Run = OxmlNode.create({
   name: "run",
+  oXmlName: "w:r",
   group: "inline",
-  content: "text*",
   inline: true,
+  content: "inline*",
+  selectable: false,
+  childToAttributes: ["runProperties"],
   addOptions() {
-    return {};
-  },
-  parseDOM() {
-    return [{ tag: "run" }];
-  },
-  renderDOM() {
-    return ["run", 0];
+    return {
+      htmlAttributes: {
+        "data-run": "1"
+      }
+    };
   },
   addAttributes() {
     return {
-      attributes: {
+      runProperties: {
+        default: null,
+        rendered: false,
+        keepOnSplit: true
+      },
+      rsidR: {
+        default: null,
+        rendered: false,
+        keepOnSplit: true
+      },
+      rsidRPr: {
+        default: null,
         rendered: false,
-        "aria-label": "Run node"
+        keepOnSplit: true
+      },
+      rsidDel: {
+        default: null,
+        rendered: false,
+        keepOnSplit: true
       }
     };
+  },
+  addCommands() {
+    return {
+      splitRun
+    };
+  },
+  parseDOM() {
+    return [{ tag: "span[data-run]" }];
+  },
+  renderDOM({ htmlAttributes }) {
+    const base2 = Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+    return ["span", base2, 0];
   }
 });
 const inputRegex$1 = /^\s*([-+*])\s$/;
@@ -17183,6 +17335,115 @@ const OrderedList = Node$1.create({
     ];
   }
 });
+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 CustomSelectionPluginKey = new PluginKey("CustomSelection");
 const handleClickOutside = (event, editor) => {
   const editorElem = editor?.options?.element;
@@ -17463,6 +17724,7 @@ const getMarksStyle = (attrs) => {
       case "textStyle":
         const { fontFamily, fontSize } = attr.attrs;
         styles += `${fontFamily ? `font-family: ${fontFamily};` : ""} ${fontSize ? `font-size: ${fontSize};` : ""}`;
+        break;
     }
   }
   return styles.trim();
@@ -17481,12 +17743,22 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
   const linkedDefinitionStyles = { ...linkedStyle.definition.styles };
   const basedOnDefinitionStyles = { ...basedOnStyle?.definition?.styles };
   const resultStyles = { ...linkedDefinitionStyles };
-  if (!linkedDefinitionStyles["font-size"] && basedOnDefinitionStyles["font-size"]) {
-    resultStyles["font-size"] = basedOnDefinitionStyles["font-size"];
-  }
-  if (!linkedDefinitionStyles["text-transform"] && basedOnDefinitionStyles["text-transform"]) {
-    resultStyles["text-transform"] = basedOnDefinitionStyles["text-transform"];
-  }
+  const inheritKeys = [
+    "font-size",
+    "font-family",
+    "text-transform",
+    "bold",
+    "italic",
+    "underline",
+    "strike",
+    "color",
+    "highlight"
+  ];
+  inheritKeys.forEach((k) => {
+    if (!linkedDefinitionStyles[k] && basedOnDefinitionStyles[k]) {
+      resultStyles[k] = basedOnDefinitionStyles[k];
+    }
+  });
   Object.entries(resultStyles).forEach(([k, value]) => {
     const key2 = kebabCase(k);
     const flattenedMarks = [];
@@ -17501,6 +17773,10 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
       }
       flattenedMarks.push({ key: n.type.name, value: n.attrs[key2] });
     });
+    const underlineNone = node?.marks?.some((m) => m.type?.name === "underline" && m.attrs?.underlineType === "none");
+    if (underlineNone) {
+      markValue["text-decoration"] = "none";
+    }
     const mark = flattenedMarks.find((n) => n.key === key2);
     const hasParentIndent = Object.keys(parent?.attrs?.indent || {});
     const hasParentSpacing = Object.keys(parent?.attrs?.spacing || {});
@@ -17517,10 +17793,28 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
         if (rightIndent) markValue["margin-right"] = rightIndent + "px";
         if (firstLine) markValue["text-indent"] = firstLine + "px";
       } else if (key2 === "bold" && node) {
-        const val = value?.value;
-        if (!listTypes.includes(node.type.name) && val !== "0") {
+        const boldValue = typeof value === "object" && value !== null ? value.value : value;
+        const hasInlineBoldOff = node.marks?.some((m) => m.type?.name === "bold" && m.attrs?.value === "0");
+        const hasInlineBoldOn = node.marks?.some((m) => m.type?.name === "bold" && m.attrs?.value !== "0");
+        if (!listTypes.includes(node.type.name) && !hasInlineBoldOff && !hasInlineBoldOn && boldValue !== "0" && boldValue !== false) {
           markValue["font-weight"] = "bold";
         }
+      } else if (key2 === "italic" && node) {
+        const italicValue = typeof value === "object" && value !== null ? value.value : value;
+        const hasInlineItalicOff = node.marks?.some((m) => m.type?.name === "italic" && m.attrs?.value === "0");
+        const hasInlineItalicOn = node.marks?.some((m) => m.type?.name === "italic" && m.attrs?.value !== "0");
+        if (!listTypes.includes(node.type.name) && !hasInlineItalicOff && !hasInlineItalicOn && italicValue !== "0" && italicValue !== false) {
+          markValue["font-style"] = "italic";
+        }
+      } else if (key2 === "strike" && node) {
+        const strikeValue = typeof value === "object" && value !== null ? value.value : value;
+        const hasInlineStrikeOff = node.marks?.some((m) => m.type?.name === "strike" && m.attrs?.value === "0");
+        const hasInlineStrikeOn = node.marks?.some(
+          (m) => m.type?.name === "strike" && (m.attrs?.value === void 0 || m.attrs?.value !== "0")
+        );
+        if (!listTypes.includes(node.type.name) && !hasInlineStrikeOff && !hasInlineStrikeOn && strikeValue !== "0" && strikeValue !== false) {
+          markValue["text-decoration"] = "line-through";
+        }
       } else if (key2 === "text-transform" && node) {
         if (!listTypes.includes(node.type.name)) {
           markValue[key2] = value;
@@ -17529,10 +17823,44 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
         if (!listTypes.includes(node.type.name)) {
           markValue[key2] = value;
         }
+      } else if (key2 === "font-family" && node) {
+        if (!listTypes.includes(node.type.name)) {
+          markValue[key2] = value;
+        }
       } else if (key2 === "color" && node) {
         if (!listTypes.includes(node.type.name)) {
           markValue[key2] = value;
         }
+      } else if (key2 === "highlight" && node) {
+        const hasInlineHighlight = node.marks?.some((m) => m.type?.name === "highlight");
+        if (!listTypes.includes(node.type.name) && !hasInlineHighlight) {
+          const color = typeof value === "string" ? value : value?.color;
+          if (color) markValue["background-color"] = color;
+        }
+      } else if (key2 === "underline" && node) {
+        const styleValRaw = value?.value ?? value ?? "";
+        const styleVal = styleValRaw.toString().toLowerCase();
+        const hasInlineUnderlineOff = node.marks?.some(
+          (m) => m.type?.name === "underline" && m.attrs?.underlineType === "none"
+        );
+        const hasInlineUnderlineOn = node.marks?.some(
+          (m) => m.type?.name === "underline" && m.attrs?.underlineType && m.attrs.underlineType !== "none"
+        );
+        if (!listTypes.includes(node.type.name) && !hasInlineUnderlineOff && !hasInlineUnderlineOn) {
+          if (styleVal && styleVal !== "none" && styleVal !== "0") {
+            const colorVal = value && typeof value === "object" ? value.color || value.underlineColor || null : null;
+            const css = getUnderlineCssString({ type: styleVal, color: colorVal });
+            css.split(";").forEach((decl) => {
+              const d = decl.trim();
+              if (!d) return;
+              const idx = d.indexOf(":");
+              if (idx === -1) return;
+              const k2 = d.slice(0, idx).trim();
+              const v = d.slice(idx + 1).trim();
+              markValue[k2] = v;
+            });
+          }
+        }
       } else if (typeof value === "string") {
         markValue[key2] = value;
       }
@@ -17665,23 +17993,51 @@ const createLinkedStylesPlugin = (editor) => {
 };
 const generateDecorations = (state, styles) => {
   const decorations = [];
-  let lastStyleId = null;
   const doc2 = state?.doc;
+  const getParagraphStyleId = (pos) => {
+    const $pos = state.doc.resolve(pos);
+    for (let d = $pos.depth; d >= 0; d--) {
+      const n = $pos.node(d);
+      if (n?.type?.name === "paragraph") return n.attrs?.styleId || null;
+    }
+    return null;
+  };
   doc2.descendants((node, pos) => {
     const { name } = node.type;
-    if (node?.attrs?.styleId) lastStyleId = node.attrs.styleId;
-    if (name === "paragraph" && !node.attrs?.styleId) lastStyleId = null;
-    if (name !== "text" && name !== "listItem" && name !== "orderedList") return;
+    if (name !== "text") return;
+    const paragraphStyleId = getParagraphStyleId(pos);
+    let runStyleId = null;
+    let inlineTextStyleId = null;
     for (const mark of node.marks) {
-      if (mark.type.name === "textStyle" && mark.attrs.styleId) {
-        lastStyleId = mark.attrs.styleId;
-      }
-    }
-    const { linkedStyle, basedOnStyle } = getLinkedStyle(lastStyleId, styles);
-    if (!linkedStyle) return;
+      if (mark.type.name === "run") {
+        const rp = mark.attrs?.runProperties;
+        if (rp && typeof rp === "object" && !Array.isArray(rp) && rp.styleId) runStyleId = rp.styleId;
+        else if (Array.isArray(rp)) {
+          const ent = rp.find((e) => e?.xmlName === "w:rStyle");
+          const sid = ent?.attributes?.["w:val"];
+          if (sid) runStyleId = sid;
+        }
+      } else if (mark.type.name === "textStyle" && mark.attrs?.styleId) {
+        inlineTextStyleId = mark.attrs.styleId;
+      }
+    }
+    const buildStyleMap = (sid) => {
+      if (!sid) return {};
+      const { linkedStyle, basedOnStyle: basedOnStyle2 } = getLinkedStyle(sid, styles);
+      if (!linkedStyle) return {};
+      const base2 = { ...basedOnStyle2?.definition?.styles || {} };
+      return { ...base2, ...linkedStyle.definition?.styles || {} };
+    };
+    const pMap = buildStyleMap(paragraphStyleId);
+    const tMap = buildStyleMap(inlineTextStyleId);
+    const rMap = buildStyleMap(runStyleId);
+    const finalStyles = { ...pMap, ...tMap, ...rMap };
+    if (Object.keys(finalStyles).length === 0) return;
+    const mergedLinkedStyle = { definition: { styles: finalStyles, attrs: {} } };
+    const basedOnStyle = null;
     const $pos = state.doc.resolve(pos);
     const parent = $pos.parent;
-    const styleString = generateLinkedStyleString(linkedStyle, basedOnStyle, node, parent);
+    const styleString = generateLinkedStyleString(mergedLinkedStyle, basedOnStyle, node, parent);
     if (!styleString) return;
     const decoration = Decoration.inline(pos, pos + node.nodeSize, { style: styleString });
     decorations.push(decoration);
@@ -17810,115 +18166,298 @@ const LinkedStyles = Extension.create({
     };
   }
 });
-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;
+function getUnderlineCssString({ type = "single", color = null, thickness = null, approximate = true } = {}) {
+  const parts = [];
+  const add = (k, v) => {
+    if (!v) return;
+    parts.push(`${k}: ${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);
+      }
+      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);
+      }
+      break;
+  }
+  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
+    };
+  }
+  const collectMarks = (node) => {
+    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.isText && node.childCount) {
+      node.forEach((child) => collectMarks(child));
+    }
+  };
+  listItem.forEach((childNode) => {
+    if (childNode.type?.name !== "paragraph") return;
+    if (childNode.attrs?.lineHeight !== void 0) {
+      attrs.lineHeight = childNode.attrs.lineHeight;
     }
+    collectMarks(childNode);
+  });
+  return {
+    marks: textStyleMarks,
+    attrs
+  };
+}
+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;
+}
+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;
+  const globalWindow = typeof window !== "undefined" ? window : void 0;
+  if (globalWindow?.getComputedStyle) {
+    const computed2 = globalWindow.getComputedStyle(view.dom);
+    return {
+      fontSize: inline.fontSize || computed2.fontSize,
+      fontFamily: inline.fontFamily || computed2.fontFamily,
+      lineHeight: inline.lineHeight || computed2.lineHeight
+    };
   }
-  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 inline;
+}
+function getAdjacentListItemNodeView({ nodeView, pos, direction, activeNodeViews }) {
+  if (!activeNodeViews) return null;
+  let candidate = null;
+  activeNodeViews.forEach((view) => {
+    if (view === nodeView) return;
+    let viewPos;
+    try {
+      viewPos = view.getPos();
+    } catch {
+      return;
+    }
+    if (typeof viewPos !== "number") return;
+    if (viewPos < pos) {
+      if (!candidate || viewPos > candidate.pos) candidate = { view, pos: viewPos };
+    }
+  });
+  return candidate?.view ?? null;
+}
+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}`;
+    }
   }
-  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;
-      }
+  let hasSize = Boolean(sizeMark);
+  if (!hasSize && listRunProperties) {
+    const sizeFromList = parseSizeFromRunProperties(listRunProperties);
+    if (sizeFromList) {
+      fontSize = sizeFromList;
+      hasSize = true;
     }
-    tempNum = Math.floor(tempNum / 10);
-    unitIndex++;
-    if (unitIndex > 3) break;
   }
-  if (num >= 10 && num < 20) {
-    result = result.replace(/^一十/, "十");
+  let fontFamily = familyMark?.attrs?.fontFamily ?? defaultFont;
+  let hasFamily = Boolean(familyMark);
+  if (!hasFamily && listRunProperties) {
+    const fontFromList = parseFontFamilyFromRunProperties(listRunProperties);
+    if (fontFromList) {
+      fontFamily = fontFromList;
+      hasFamily = true;
+    }
   }
-  return result;
-};
+  let lineHeight = attrs.lineHeight;
+  const firstChild = node.firstChild;
+  const hasOnlyOnePar = node.childCount === 1 && firstChild?.type?.name === "paragraph";
+  if (hasOnlyOnePar) {
+    const par = firstChild;
+    const parFirstChild = par?.firstChild;
+    if (par?.childCount === 1 && parFirstChild?.type?.name === "fieldAnnotation") {
+      const aFontSize = parFirstChild.attrs?.fontSize;
+      const aFontFamily = parFirstChild.attrs?.fontFamily;
+      if (!sizeMark && aFontSize) fontSize = aFontSize;
+      if (!familyMark && aFontFamily) fontFamily = aFontFamily;
+    }
+  }
+  return {
+    fontSize,
+    fontFamily,
+    lineHeight,
+    hasSize,
+    hasFamily
+  };
+}
+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;
+  }
+  const style = styleDeco?.type?.attrs?.style;
+  const stylesArray = style?.split(";") || [];
+  const fontSizeFromStyles = stylesArray.find((s) => s.includes("font-size"))?.split(":")[1]?.trim();
+  const fontFamilyFromStyles = stylesArray.find((s) => s.includes("font-family"))?.split(":")[1]?.trim();
+  return {
+    font: fontFamilyFromStyles,
+    size: fontSizeFromStyles
+  };
+}
+function resolveListItemTypography({ node, pos, editor, nodeView, activeNodeViews }) {
+  const defaults = getStylesFromLinkedStyles({ node, pos, editor });
+  const textStyleType = getMarkType("textStyle", editor.schema);
+  const currentStyles = deriveFontStylesFromNode({
+    node,
+    textStyleType,
+    defaultFont: defaults.font,
+    defaultSize: defaults.size,
+    listRunProperties: node.attrs?.listRunProperties
+  });
+  if ((!currentStyles.hasSize || !currentStyles.hasFamily || !currentStyles.lineHeight) && editor?.view) {
+    const previousListItem = findSiblingListItem({ editor, pos, direction: -1 });
+    if (previousListItem) {
+      const previousStyles = deriveFontStylesFromNode({
+        node: previousListItem,
+        textStyleType,
+        defaultFont: defaults.font,
+        defaultSize: defaults.size,
+        listRunProperties: previousListItem.attrs?.listRunProperties
+      });
+      if (!currentStyles.hasSize && previousStyles.fontSize) currentStyles.fontSize = previousStyles.fontSize;
+      if (!currentStyles.hasFamily && previousStyles.fontFamily) currentStyles.fontFamily = previousStyles.fontFamily;
+      if (!currentStyles.lineHeight && previousStyles.lineHeight) currentStyles.lineHeight = previousStyles.lineHeight;
+    }
+  }
+  if ((!currentStyles.fontSize || !currentStyles.fontFamily || !currentStyles.lineHeight) && nodeView) {
+    const previousView = getAdjacentListItemNodeView({
+      nodeView,
+      pos,
+      direction: -1,
+      activeNodeViews
+    });
+    if (previousView) {
+      const {
+        fontSize: prevSize,
+        fontFamily: prevFamily,
+        lineHeight: prevLineHeight
+      } = readNodeViewStyles(previousView);
+      if (!currentStyles.fontSize && prevSize) currentStyles.fontSize = prevSize;
+      if (!currentStyles.fontFamily && prevFamily) currentStyles.fontFamily = prevFamily;
+      if (!currentStyles.lineHeight && prevLineHeight) currentStyles.lineHeight = prevLineHeight;
+    }
+  }
+  return {
+    fontSize: currentStyles.fontSize,
+    fontFamily: currentStyles.fontFamily,
+    lineHeight: currentStyles.lineHeight
+  };
+}
 const MARKER_PADDING = 6;
 const MARKER_OFFSET_RIGHT = 4;
 const MIN_MARKER_WIDTH = 20;
@@ -17936,8 +18475,8 @@ class ListItemNodeView {
     this.decorations = decorations;
     this.view = editor.view;
     this.getPos = getPos;
-    activeListItemNodeViews.add(this);
     __privateMethod(this, _ListItemNodeView_instances, init_fn2).call(this);
+    activeListItemNodeViews.add(this);
   }
   refreshIndentStyling() {
     const { attrs } = this.node;
@@ -17980,10 +18519,12 @@ class ListItemNodeView {
   update(node, decorations) {
     this.node = node;
     this.decorations = decorations;
-    const { fontSize, fontFamily, lineHeight } = getTextStyleMarksFromLinkedStyles({
+    const { fontSize, fontFamily, lineHeight } = resolveListItemTypography({
       node,
       pos: this.getPos(),
-      editor: this.editor
+      editor: this.editor,
+      nodeView: this,
+      activeNodeViews: activeListItemNodeViews
     });
     this.dom.style.fontSize = fontSize;
     this.dom.style.fontFamily = fontFamily || "inherit";
@@ -18012,10 +18553,12 @@ init_fn2 = function() {
     }
   }
   const pos = this.getPos();
-  const { fontSize, fontFamily, lineHeight } = getTextStyleMarksFromLinkedStyles({
+  const { fontSize, fontFamily, lineHeight } = resolveListItemTypography({
     node: this.node,
     pos,
-    editor: this.editor
+    editor: this.editor,
+    nodeView: this,
+    activeNodeViews: activeListItemNodeViews
   });
   this.dom = document.createElement("li");
   this.dom.className = "sd-editor-list-item-node-view";
@@ -18048,79 +18591,6 @@ function refreshAllListItemNodeViews() {
     }
   });
 }
-function getListItemTextStyleMarks(listItem, markType) {
-  let textStyleMarks = [];
-  let attrs = {};
-  listItem.forEach((childNode) => {
-    if (childNode.type.name !== "paragraph") return;
-    attrs.lineHeight = childNode.attrs.lineHeight;
-    childNode.forEach((textNode) => {
-      let isTextNode = textNode.type.name === "text";
-      let hasTextStyleMarks = markType.isInSet(textNode.marks);
-      if (isTextNode && hasTextStyleMarks) {
-        let marks = textNode.marks.filter((mark) => mark.type === markType);
-        textStyleMarks.push(...marks);
-      }
-    });
-  });
-  return {
-    marks: textStyleMarks,
-    attrs
-  };
-}
-function getTextStyleMarksFromLinkedStyles({ node, pos, editor }) {
-  const { font: defaultFont, size: defaultSize } = getStylesFromLinkedStyles({ node, pos, editor });
-  const textStyleType = getMarkType("textStyle", editor.schema);
-  const { marks: allMarks, attrs: allAttrs } = getListItemTextStyleMarks(node, textStyleType);
-  const styleMarks = allMarks.filter((m) => m.type === textStyleType);
-  const sizeMark = styleMarks.find((m) => m.attrs.fontSize);
-  const familyMark = styleMarks.find((m) => m.attrs.fontFamily);
-  const lineHeight = allAttrs.lineHeight;
-  let fontSize = sizeMark ? (() => {
-    const [value, unit = "pt"] = parseSizeUnit(sizeMark.attrs.fontSize);
-    return Number.isNaN(value) ? defaultSize : `${value}${unit}`;
-  })() : defaultSize;
-  let fontFamily = familyMark?.attrs.fontFamily ?? defaultFont;
-  const firstChild = node.firstChild;
-  const hasOnlyOnePar = node.childCount === 1 && firstChild?.type.name === "paragraph";
-  if (hasOnlyOnePar) {
-    const par = firstChild;
-    const parFirstChild = par?.firstChild;
-    if (par?.childCount === 1 && parFirstChild?.type.name === "fieldAnnotation") {
-      const aFontSize = parFirstChild.attrs.fontSize;
-      const aFontFamily = parFirstChild.attrs.fontFamily;
-      if (!sizeMark && aFontSize) fontSize = aFontSize;
-      if (!familyMark && aFontFamily) fontFamily = aFontFamily;
-    }
-  }
-  return { fontSize, fontFamily, lineHeight };
-}
-const 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;
-  }
-  const style = styleDeco?.type.attrs?.style;
-  const stylesArray = style?.split(";") || [];
-  const fontSizeFromStyles = stylesArray.find((s) => s.includes("font-size"))?.split(":")[1].trim();
-  const fontFamilyFromStyles = stylesArray.find((s) => s.includes("font-family"))?.split(":")[1].trim();
-  return {
-    font: fontFamilyFromStyles,
-    size: fontSizeFromStyles
-  };
-};
 const getVisibleIndent = (stylePpr, numDefPpr, inlineIndent) => {
   const styleIndentTag = stylePpr?.elements?.find((el) => el.name === "w:ind") || {};
   const styleIndent = parseIndentElement(styleIndentTag);
@@ -18854,6 +19324,211 @@ const CommentsMark = Mark.create({
     return [CommentMarkName, Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes)];
   }
 });
+const defaultTabDistance = 48;
+const defaultLineLength = 816;
+const getTabDecorations = (doc2, view, from2 = 0, to = null) => {
+  const decorations = [];
+  const paragraphCache = /* @__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);
+    if (!paragraphContext) return;
+    try {
+      const { tabStops, flattened, startPos } = paragraphContext;
+      const entryIndex = flattened.findIndex((entry) => entry.pos === pos);
+      if (entryIndex === -1) return;
+      const indentWidth = getIndentWidth(view, startPos, paragraphContext.indent);
+      const accumulatedTabWidth = paragraphContext.accumulatedTabWidth || 0;
+      const currentWidth = indentWidth + measureRangeWidth(view, startPos + 1, pos) + 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);
+            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) : measureRangeWidth(view, pos + node.nodeSize, startPos + paragraphContext.paragraph.nodeSize - 1);
+            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 = calcTabHeight($pos);
+      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) {
+  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)) {
+        cache.set(startPos, {
+          paragraph: node,
+          paragraphDepth: depth,
+          startPos,
+          indent: node.attrs?.indent || {},
+          tabStops: Array.isArray(node.attrs?.tabStops) ? node.attrs.tabStops : [],
+          flattened: flattenParagraph(node, startPos),
+          accumulatedTabWidth: 0
+        });
+      }
+      return cache.get(startPos);
+    }
+  }
+  return null;
+}
+function flattenParagraph(paragraph, paragraphStartPos) {
+  const entries = [];
+  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;
+    }
+    entries.push({ node, pos: basePos - 1 });
+  };
+  paragraph.forEach((child, offset2) => {
+    const childPos = paragraphStartPos + offset2 + 1;
+    walk(child, childPos);
+  });
+  return entries;
+}
+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) {
+  if (!Number.isFinite(from2) || !Number.isFinite(to) || to <= from2) return 0;
+  try {
+    const range = document.createRange();
+    const fromRef = view.domAtPos(from2);
+    const toRef = view.domAtPos(to);
+    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);
+    const endLeft = getLeftCoord(view, to);
+    if (startLeft == null || endLeft == null) return 0;
+    return Math.max(0, endLeft - startLeft);
+  }
+}
+function getIndentWidth(view, paragraphStartPos, indentAttrs = {}) {
+  const marginLeft = getLeftCoord(view, paragraphStartPos);
+  const lineLeft = getLeftCoord(view, paragraphStartPos + 1);
+  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) {
+  if (!Number.isFinite(pos)) return null;
+  try {
+    return view.coordsAtPos(pos).left;
+  } catch {
+    try {
+      const ref2 = view.domAtPos(pos);
+      const range = document.createRange();
+      range.setStart(ref2.node, ref2.offset);
+      range.setEnd(ref2.node, ref2.offset);
+      const rect = range.getBoundingClientRect();
+      range.detach?.();
+      return rect.left;
+    } catch {
+      return null;
+    }
+  }
+}
+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",
@@ -18891,8 +19566,7 @@ const TabNode = Node$1.create({
     };
   },
   addPmPlugins() {
-    const { view, schema } = this.editor;
-    const domSerializer = DOMSerializer.fromSchema(schema);
+    const { view } = this.editor;
     const tabPlugin = new Plugin({
       name: "tabPlugin",
       key: new PluginKey("tabPlugin"),
@@ -18902,10 +19576,7 @@ const TabNode = Node$1.create({
         },
         apply(tr, { decorations }, _oldState, newState) {
           if (!decorations) {
-            decorations = DecorationSet.create(
-              newState.doc,
-              getTabDecorations(newState.doc, StepMap.empty, view, domSerializer)
-            );
+            decorations = DecorationSet.create(newState.doc, getTabDecorations(newState.doc, view));
           }
           if (!tr.docChanged) {
             return { decorations };
@@ -18945,8 +19616,7 @@ const TabNode = Node$1.create({
           rangesToRecalculate.forEach(([start2, end2]) => {
             const oldDecorations = decorations.find(start2, end2);
             decorations = decorations.remove(oldDecorations);
-            const invertMapping = tr.mapping.invert();
-            const newDecorations = getTabDecorations(newState.doc, invertMapping, view, domSerializer, start2, end2);
+            const newDecorations = getTabDecorations(newState.doc, view, start2, end2);
             decorations = decorations.add(newState.doc, newDecorations);
           });
           return { decorations };
@@ -18961,156 +19631,6 @@ const TabNode = Node$1.create({
     return [tabPlugin];
   }
 });
-const defaultTabDistance = 48;
-const defaultLineLength = 816;
-const getTabDecorations = (doc2, invertMapping, view, domSerializer, from2 = 0, to = null) => {
-  if (!to) {
-    to = doc2.content.size;
-  }
-  const nodeWidthCache = {};
-  let decorations = [];
-  doc2.nodesBetween(from2, to, (node, pos, parent) => {
-    if (node.type.name === "tab") {
-      let extraStyles = "";
-      const $pos = doc2.resolve(pos);
-      const tabIndex = $pos.index($pos.depth);
-      const fistlineIndent = parent.attrs?.indent?.firstLine || 0;
-      const currentWidth = calcChildNodesWidth(
-        parent,
-        pos - $pos.parentOffset,
-        0,
-        tabIndex,
-        domSerializer,
-        view,
-        invertMapping,
-        nodeWidthCache
-      ) + fistlineIndent;
-      let tabWidth;
-      if ($pos.depth === 1 && parent.attrs.tabStops && parent.attrs.tabStops.length > 0) {
-        const tabStop = parent.attrs.tabStops.find((tabStop2) => tabStop2.pos > currentWidth && tabStop2.val !== "clear");
-        if (tabStop) {
-          tabWidth = tabStop.pos - currentWidth;
-          if (["end", "center"].includes(tabStop.val)) {
-            let nextTabIndex = tabIndex + 1;
-            while (nextTabIndex < parent.childCount && parent.child(nextTabIndex).type.name !== "tab") {
-              nextTabIndex++;
-            }
-            const tabSectionWidth = calcChildNodesWidth(
-              parent,
-              pos - $pos.parentOffset,
-              tabIndex,
-              nextTabIndex,
-              domSerializer,
-              view,
-              invertMapping,
-              nodeWidthCache
-            );
-            tabWidth -= tabStop.val === "end" ? tabSectionWidth : tabSectionWidth / 2;
-          } else if (["decimal", "num"].includes(tabStop.val)) {
-            const breakChar = ".";
-            let nodeIndex = tabIndex + 1;
-            let integralWidth = 0;
-            let nodePos = pos - $pos.parentOffset;
-            while (nodeIndex < parent.childCount) {
-              const node2 = parent.child(nodeIndex);
-              if (node2.type.name === "tab") {
-                break;
-              }
-              const oldPos = invertMapping.map(nodePos);
-              if (node2.type.name === "text" && node2.text.includes(breakChar)) {
-                const modifiedNode = node2.cut(0, node2.text.indexOf(breakChar));
-                integralWidth += calcNodeWidth(domSerializer, modifiedNode, view, oldPos);
-                break;
-              }
-              integralWidth += calcNodeWidth(domSerializer, node2, view, oldPos);
-              nodeWidthCache[nodePos] = integralWidth;
-              nodePos += node2.nodeSize;
-              nodeIndex += 1;
-            }
-            tabWidth -= integralWidth;
-          }
-          if (tabStop.leader) {
-            if (tabStop.leader === "dot") {
-              extraStyles += `border-bottom: 1px dotted black;`;
-            } else if (tabStop.leader === "heavy") {
-              extraStyles += `border-bottom: 2px solid black;`;
-            } else if (tabStop.leader === "hyphen") {
-              extraStyles += `border-bottom: 1px solid black;`;
-            } else if (tabStop.leader === "middleDot") {
-              extraStyles += `border-bottom: 1px dotted black; margin-bottom: 2px;`;
-            } else if (tabStop.leader === "underscore") {
-              extraStyles += `border-bottom: 1px solid black;`;
-            }
-          }
-        }
-      }
-      if (!tabWidth || tabWidth < 1) {
-        tabWidth = defaultTabDistance - currentWidth % defaultLineLength % defaultTabDistance;
-        if (tabWidth === 0) {
-          tabWidth = defaultTabDistance;
-        }
-      }
-      nodeWidthCache[pos] = tabWidth;
-      const tabHeight = calcTabHeight($pos);
-      decorations.push(
-        Decoration.node(pos, pos + node.nodeSize, {
-          style: `width: ${tabWidth}px; height: ${tabHeight};${extraStyles}`
-        })
-      );
-    }
-  });
-  return decorations;
-};
-function calcNodeWidth(domSerializer, node, view, oldPos) {
-  const oldDomNode = view.nodeDOM(oldPos);
-  const styleReference = oldDomNode ? oldDomNode.nodeName === "#text" ? oldDomNode.parentNode : oldDomNode : view.dom;
-  const temp = document.createElement("div");
-  const style = window.getComputedStyle(styleReference);
-  temp.style.cssText = `
-        position: absolute;
-        top: -9999px;
-        left: -9999px;
-        white-space: nowrap;
-        font-family: ${style.fontFamily};
-        font-size: ${style.fontSize};
-        font-weight: ${style.fontWeight};
-        font-style: ${style.fontStyle};
-        letter-spacing: ${style.letterSpacing};
-        word-spacing: ${style.wordSpacing};
-        text-transform: ${style.textTransform};
-        display: inline-block;
-    `;
-  const domNode = domSerializer.serializeNode(node);
-  temp.appendChild(domNode);
-  document.body.appendChild(temp);
-  const width = temp.offsetWidth;
-  document.body.removeChild(temp);
-  return width;
-}
-function calcChildNodesWidth(parent, parentPos, startIndex, endIndex, domSerializer, view, invertMapping, nodeWidthCache) {
-  let pos = parentPos;
-  let width = 0;
-  for (let i = 0; i < endIndex; i++) {
-    const node = parent.child(i);
-    if (i >= startIndex) {
-      if (!nodeWidthCache[pos]) {
-        nodeWidthCache[pos] = calcNodeWidth(domSerializer, node, view, invertMapping.map(pos));
-      }
-      width += nodeWidthCache[pos];
-    }
-    pos += node.nodeSize;
-  }
-  return width;
-}
-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 LineBreak = Node$1.create({
   name: "lineBreak",
   group: "inline",
@@ -24777,10 +25297,10 @@ const Image = Node$1.create({
       },
       padding: {
         default: {},
-        renderDOM: ({ size = {}, padding, marginOffset, transformData }) => {
+        renderDOM: ({ size = {}, padding, marginOffset, transformData = {} }) => {
           let { left: left2 = 0, top: top2 = 0, bottom: bottom2 = 0, right: right2 = 0 } = padding ?? {};
-          const { rotation } = transformData ?? {};
-          const { height, width } = size ?? {};
+          const { rotation } = transformData;
+          const { height, width } = size;
           if (rotation && height && width) {
             const { horizontal, vertical } = getRotationMargins(width, height, rotation);
             left2 += horizontal;
@@ -26571,6 +27091,30 @@ const TextStyle = Mark.create({
     };
   }
 });
+function createCascadeToggleCommands({
+  markName,
+  setCommand,
+  unsetCommand,
+  toggleCommand,
+  negationAttrs,
+  isNegation,
+  extendEmptyMarkRange
+} = {}) {
+  if (!markName) throw new Error("createCascadeToggleCommands requires a markName");
+  const capitalized = markName.charAt(0).toUpperCase() + markName.slice(1);
+  const setName = setCommand ?? `set${capitalized}`;
+  const unsetName = unsetCommand ?? `unset${capitalized}`;
+  const toggleName = toggleCommand ?? `toggle${capitalized}`;
+  const cascadeOptions = {};
+  if (negationAttrs) cascadeOptions.negationAttrs = negationAttrs;
+  if (typeof isNegation === "function") cascadeOptions.isNegation = isNegation;
+  if (extendEmptyMarkRange !== void 0) cascadeOptions.extendEmptyMarkRange = extendEmptyMarkRange;
+  return {
+    [setName]: () => ({ commands: commands2 }) => commands2.setMark(markName),
+    [unsetName]: () => ({ commands: commands2 }) => commands2.unsetMark(markName),
+    [toggleName]: () => ({ commands: commands2 }) => commands2.toggleMarkCascade(markName, cascadeOptions)
+  };
+}
 const Bold = Mark.create({
   name: "bold",
   addOptions() {
@@ -26601,9 +27145,18 @@ const Bold = Mark.create({
     ];
   },
   renderDOM({ htmlAttributes }) {
-    return ["strong", Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+    const merged = Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+    const { value, ...rest } = merged || {};
+    if (value === "0") {
+      return ["span", rest, 0];
+    }
+    return ["strong", rest, 0];
   },
   addCommands() {
+    const { setBold, unsetBold, toggleBold } = createCascadeToggleCommands({
+      markName: this.name,
+      negationAttrs: { value: "0" }
+    });
     return {
       /**
        * Apply bold formatting
@@ -26612,21 +27165,21 @@ const Bold = Mark.create({
        * editor.commands.setBold()
        * @note '0' renders as normal weight
        */
-      setBold: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+      setBold,
       /**
        * Remove bold formatting
        * @category Command
        * @example
        * editor.commands.unsetBold()
        */
-      unsetBold: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+      unsetBold,
       /**
        * Toggle bold formatting
        * @category Command
        * @example
        * editor.commands.toggleBold()
        */
-      toggleBold: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+      toggleBold
     };
   },
   addShortcuts() {
@@ -26643,6 +27196,22 @@ const Italic = Mark.create({
       htmlAttributes: {}
     };
   },
+  addAttributes() {
+    return {
+      /**
+       * @category Attribute
+       * @param {string} [value] - Italic toggle value ('0' renders as normal)
+       */
+      value: {
+        default: null,
+        renderDOM: (attrs) => {
+          if (!attrs.value) return {};
+          if (attrs.value === "0") return { style: "font-style: normal" };
+          return {};
+        }
+      }
+    };
+  },
   parseDOM() {
     return [
       { tag: "i" },
@@ -26652,9 +27221,18 @@ const Italic = Mark.create({
     ];
   },
   renderDOM({ htmlAttributes }) {
-    return ["em", Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+    const merged = Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+    const { value, ...rest } = merged || {};
+    if (value === "0") {
+      return ["span", rest, 0];
+    }
+    return ["em", rest, 0];
   },
   addCommands() {
+    const { setItalic, unsetItalic, toggleItalic } = createCascadeToggleCommands({
+      markName: this.name,
+      negationAttrs: { value: "0" }
+    });
     return {
       /**
        * Apply italic formatting
@@ -26662,21 +27240,21 @@ const Italic = Mark.create({
        * @example
        * editor.commands.setItalic()
        */
-      setItalic: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+      setItalic,
       /**
        * Remove italic formatting
        * @category Command
        * @example
        * editor.commands.unsetItalic()
        */
-      unsetItalic: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+      unsetItalic,
       /**
        * Toggle italic formatting
        * @category Command
        * @example
        * editor.commands.toggleItalic()
        */
-      toggleItalic: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+      toggleItalic
     };
   },
   addShortcuts() {
@@ -26701,7 +27279,16 @@ const Underline = Mark.create({
     ];
   },
   renderDOM({ htmlAttributes }) {
-    return ["u", Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+    const merged = Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+    const type = merged?.underlineType;
+    const color = merged?.underlineColor;
+    const css = getUnderlineCssString({ type, color });
+    const { style, ...rest } = merged || {};
+    const styleString = [style, css].filter(Boolean).join("; ");
+    if (type === "none") {
+      return ["span", { ...rest, ...styleString ? { style: styleString } : {} }, 0];
+    }
+    return ["u", { ...rest, ...styleString ? { style: styleString } : {} }, 0];
   },
   addAttributes() {
     return {
@@ -26711,10 +27298,18 @@ const Underline = Mark.create({
        */
       underlineType: {
         default: "single"
+      },
+      underlineColor: {
+        default: null
       }
     };
   },
   addCommands() {
+    const { setUnderline, unsetUnderline, toggleUnderline } = createCascadeToggleCommands({
+      markName: this.name,
+      negationAttrs: { underlineType: "none" },
+      isNegation: (attrs) => attrs?.underlineType === "none"
+    });
     return {
       /**
        * Apply underline formatting
@@ -26723,7 +27318,7 @@ const Underline = Mark.create({
        * @example
        * setUnderline()
        */
-      setUnderline: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+      setUnderline,
       /**
        * Remove underline formatting
        * @category Command
@@ -26731,7 +27326,7 @@ const Underline = Mark.create({
        * @example
        * unsetUnderline()
        */
-      unsetUnderline: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+      unsetUnderline,
       /**
        * Toggle underline formatting
        * @category Command
@@ -26739,7 +27334,7 @@ const Underline = Mark.create({
        * @example
        * toggleUnderline()
        */
-      toggleUnderline: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+      toggleUnderline
     };
   },
   addShortcuts() {
@@ -26827,9 +27422,18 @@ const Strike = Mark.create({
     ];
   },
   renderDOM({ htmlAttributes }) {
-    return ["s", Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+    const merged = Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+    const { value, ...rest } = merged || {};
+    if (value === "0") {
+      return ["span", rest, 0];
+    }
+    return ["s", rest, 0];
   },
   addCommands() {
+    const { setStrike, unsetStrike, toggleStrike } = createCascadeToggleCommands({
+      markName: this.name,
+      negationAttrs: { value: "0" }
+    });
     return {
       /**
        * Apply strikethrough formatting
@@ -26837,26 +27441,38 @@ const Strike = Mark.create({
        * @example
        * editor.commands.setStrike()
        */
-      setStrike: () => ({ commands: commands2 }) => {
-        return commands2.setMark(this.name);
-      },
+      setStrike,
       /**
        * Remove strikethrough formatting
        * @category Command
        * @example
        * editor.commands.unsetStrike()
        */
-      unsetStrike: () => ({ commands: commands2 }) => {
-        return commands2.unsetMark(this.name);
-      },
+      unsetStrike,
       /**
        * Toggle strikethrough formatting
        * @category Command
        * @example
        * editor.commands.toggleStrike()
        */
-      toggleStrike: () => ({ commands: commands2 }) => {
-        return commands2.toggleMark(this.name);
+      toggleStrike
+    };
+  },
+  addAttributes() {
+    return {
+      /**
+       * @category Attribute
+       * @param {string} [value] - Strike toggle value ('0' renders as normal)
+       */
+      value: {
+        default: null,
+        renderDOM: (attrs) => {
+          if (!attrs.value) return {};
+          if (attrs.value === "0") {
+            return { style: "text-decoration: none" };
+          }
+          return {};
+        }
       }
     };
   },
@@ -32997,7 +33613,7 @@ const getStarterExtensions = () => {
     Paragraph,
     LineBreak,
     HardBreak,
-    RunItem,
+    Run,
     SlashMenu,
     Strike,
     TabNode,