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

package/dist/superdoc.umd.js

@@ -1385,7 +1385,7 @@
       shallowReadonlyMap
     );
   }
-  function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+  function createReactiveObject(target, isReadonly2, baseHandlers2, collectionHandlers, proxyMap) {
     if (!isObject$3(target)) {
       return target;
     }
@@ -1402,7 +1402,7 @@
     }
     const proxy = new Proxy(
       target,
-      targetType === 2 ? collectionHandlers : baseHandlers
+      targetType === 2 ? collectionHandlers : baseHandlers2
     );
     proxyMap.set(target, proxy);
     return proxy;
@@ -22630,25 +22630,47 @@
     const defaults = xmlDoc.querySelectorAll("Default");
     return Array.from(defaults).map((item) => item.getAttribute("Extension"));
   };
+  const DOCX_HIGHLIGHT_KEYWORD_MAP = /* @__PURE__ */ new Map([
+    ["yellow", "FFFF00"],
+    ["green", "00FF00"],
+    ["blue", "0000FF"],
+    ["cyan", "00FFFF"],
+    ["magenta", "FF00FF"],
+    ["red", "FF0000"],
+    ["darkYellow", "808000"],
+    ["darkGreen", "008000"],
+    ["darkBlue", "000080"],
+    ["darkCyan", "008080"],
+    ["darkMagenta", "800080"],
+    ["darkGray", "808080"],
+    ["darkRed", "800000"],
+    ["lightGray", "C0C0C0"],
+    ["black", "000000"],
+    ["white", "FFFFFF"]
+  ]);
+  const normalizeHexColor = (hex2) => {
+    if (!hex2) return null;
+    let value = hex2.replace("#", "").trim();
+    if (!value) return null;
+    value = value.toUpperCase();
+    if (value.length === 3)
+      value = value.split("").map((c2) => c2 + c2).join("");
+    if (value.length === 8) value = value.slice(0, 6);
+    return value;
+  };
   const getHexColorFromDocxSystem = (docxColor) => {
-    const colorMap = /* @__PURE__ */ new Map([
-      ["yellow", "#ffff00"],
-      ["green", "#00ff00"],
-      ["blue", "#0000FFFF"],
-      ["cyan", "#00ffff"],
-      ["magenta", "#ff00ff"],
-      ["red", "#ff0000"],
-      ["darkYellow", "#808000FF"],
-      ["darkGreen", "#008000FF"],
-      ["darkBlue", "#000080"],
-      ["darkCyan", "#008080FF"],
-      ["darkMagenta", "#800080FF"],
-      ["darkGray", "#808080FF"],
-      ["darkRed", "#800000FF"],
-      ["lightGray", "#C0C0C0FF"],
-      ["black", "#000"]
-    ]);
-    return colorMap.get(docxColor) || null;
+    const hex2 = DOCX_HIGHLIGHT_KEYWORD_MAP.get(docxColor);
+    return hex2 ? `#${hex2}` : null;
+  };
+  const getDocxHighlightKeywordFromHex = (hexColor) => {
+    if (!hexColor) return null;
+    if (DOCX_HIGHLIGHT_KEYWORD_MAP.has(hexColor)) return hexColor;
+    const normalized = normalizeHexColor(hexColor);
+    if (!normalized) return null;
+    for (const [keyword, hex2] of DOCX_HIGHLIGHT_KEYWORD_MAP.entries()) {
+      if (hex2 === normalized) return keyword;
+    }
+    return null;
   };
   function isValidHexColor(color) {
     if (!color || typeof color !== "string") return false;
@@ -32036,37 +32058,37 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   };
   __publicField$2(_NodeTranslator, "translatorTypes", TranslatorTypes);
   let NodeTranslator = _NodeTranslator;
-  const encode$A = (attributes) => {
+  const encode$17 = (attributes) => {
     return attributes["w:type"];
   };
-  const decode$A = (attrs) => {
+  const decode$_ = (attrs) => {
     const { lineBreakType } = attrs;
     return lineBreakType;
   };
-  const attrConfig$i = Object.freeze({
+  const attrConfig$F = Object.freeze({
     xmlName: "w:type",
     sdName: "lineBreakType",
-    encode: encode$A,
-    decode: decode$A
+    encode: encode$17,
+    decode: decode$_
   });
-  const encode$z = (attributes) => {
+  const encode$16 = (attributes) => {
     const xmlAttrValue = attributes["w:clear"];
     return xmlAttrValue;
   };
-  const decode$z = (attrs) => {
+  const decode$Z = (attrs) => {
     const { clear } = attrs;
     return clear;
   };
-  const attrConfig$h = Object.freeze({
+  const attrConfig$E = Object.freeze({
     xmlName: "w:clear",
     sdName: "clear",
-    encode: encode$z,
-    decode: decode$z
+    encode: encode$16,
+    decode: decode$Z
   });
-  const validXmlAttributes$b = [attrConfig$i, attrConfig$h];
-  const XML_NODE_NAME$h = "w:br";
+  const validXmlAttributes$l = [attrConfig$F, attrConfig$E];
+  const XML_NODE_NAME$t = "w:br";
   const SD_NODE_NAME$c = "lineBreak";
-  const encode$y = (_2, encodedAttrs) => {
+  const encode$15 = (_2, encodedAttrs) => {
     const isPageBreak = encodedAttrs?.lineBreakType === "page";
     const translated = {
       type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -32076,7 +32098,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return translated;
   };
-  const decode$y = (params2, decodedAttrs) => {
+  const decode$Y = (params2, decodedAttrs) => {
     const { node } = params2;
     if (!node) return;
     const wBreak = { name: "w:br" };
@@ -32093,63 +32115,125 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     };
     return translated;
   };
-  const config$f = {
-    xmlName: XML_NODE_NAME$h,
+  const config$r = {
+    xmlName: XML_NODE_NAME$t,
     sdNodeOrKeyName: SD_NODE_NAME$c,
     type: NodeTranslator.translatorTypes.NODE,
-    encode: encode$y,
-    decode: decode$y,
-    attributes: validXmlAttributes$b
+    encode: encode$15,
+    decode: decode$Y,
+    attributes: validXmlAttributes$l
+  };
+  const translator$15 = NodeTranslator.from(config$r);
+  const encode$14 = (attributes) => attributes?.["w:val"];
+  const decode$X = (attrs) => attrs?.highlight;
+  const attrConfig$D = Object.freeze({
+    xmlName: "w:val",
+    sdName: "highlight",
+    encode: encode$14,
+    decode: decode$X
+  });
+  const validXmlAttributes$k = [attrConfig$D];
+  const XML_NODE_NAME$s = "w:highlight";
+  const SD_ATTR_KEY$f = "highlight";
+  const DISABLED_TOKENS = /* @__PURE__ */ new Set(["transparent", "none", "inherit"]);
+  const encode$13 = (params2, encodedAttrs = {}) => {
+    const { nodes } = params2;
+    const node = nodes?.[0];
+    const value = encodedAttrs.highlight ?? node?.attributes?.["w:val"];
+    return {
+      type: "attr",
+      xmlName: XML_NODE_NAME$s,
+      sdNodeOrKeyName: SD_ATTR_KEY$f,
+      attributes: { "w:val": value ?? null }
+    };
+  };
+  const decode$W = (params2) => {
+    const attrs = params2?.node?.attrs || {};
+    const highlightValue = attrs.highlight ?? attrs.color ?? null;
+    if (!highlightValue) return void 0;
+    const normalizedValue = String(highlightValue).trim().toLowerCase();
+    if (!normalizedValue) return void 0;
+    if (DISABLED_TOKENS.has(normalizedValue)) {
+      return {
+        name: XML_NODE_NAME$s,
+        attributes: { "w:val": "none" }
+      };
+    }
+    const keyword = getDocxHighlightKeywordFromHex(highlightValue);
+    if (keyword) {
+      return {
+        name: XML_NODE_NAME$s,
+        attributes: { "w:val": keyword }
+      };
+    }
+    const fill = normalizeHexColor(highlightValue);
+    if (!fill) return void 0;
+    return {
+      name: "w:shd",
+      attributes: {
+        "w:color": "auto",
+        "w:val": "clear",
+        "w:fill": fill
+      }
+    };
   };
-  const translator$V = NodeTranslator.from(config$f);
-  const encode$x = (attributes) => {
+  const config$q = {
+    xmlName: XML_NODE_NAME$s,
+    sdNodeOrKeyName: SD_ATTR_KEY$f,
+    type: NodeTranslator.translatorTypes.ATTRIBUTE,
+    encode: encode$13,
+    decode: decode$W,
+    attributes: validXmlAttributes$k
+  };
+  const translator$14 = NodeTranslator.from(config$q);
+  const encode$12 = (attributes) => {
     return attributes["w:val"];
   };
-  const decode$x = (attrs) => {
+  const decode$V = (attrs) => {
     const { tabSize } = attrs || {};
     return tabSize;
   };
-  const attrConfig$g = Object.freeze({
+  const attrConfig$C = Object.freeze({
     xmlName: "w:val",
     sdName: "tabSize",
-    encode: encode$x,
-    decode: decode$x
+    encode: encode$12,
+    decode: decode$V
   });
-  const encode$w = (attributes) => {
+  const encode$11 = (attributes) => {
     return attributes["w:leader"];
   };
-  const decode$w = (attrs) => {
+  const decode$U = (attrs) => {
     const { leader } = attrs || {};
     return leader;
   };
-  const attrConfig$f = Object.freeze({
+  const attrConfig$B = Object.freeze({
     xmlName: "w:leader",
     sdName: "leader",
-    encode: encode$w,
-    decode: decode$w
+    encode: encode$11,
+    decode: decode$U
   });
-  const encode$v = (attributes) => {
+  const encode$10 = (attributes) => {
     return attributes["w:pos"];
   };
-  const decode$v = (attrs) => {
+  const decode$T = (attrs) => {
     const { pos } = attrs || {};
     return pos;
   };
-  const attrConfig$e = Object.freeze({
+  const attrConfig$A = Object.freeze({
     xmlName: "w:pos",
     sdName: "pos",
-    encode: encode$v,
-    decode: decode$v
+    encode: encode$10,
+    decode: decode$T
   });
-  const validXmlAttributes$a = [attrConfig$g, attrConfig$e, attrConfig$f];
-  const XML_NODE_NAME$g = "w:tab";
+  const validXmlAttributes$j = [attrConfig$C, attrConfig$A, attrConfig$B];
+  const XML_NODE_NAME$r = "w:tab";
   const SD_NODE_NAME$b = "tab";
-  const encode$u = (_2, encodedAttrs = {}) => {
+  const encode$$ = (_2, encodedAttrs = {}) => {
     const translated = { type: "tab" };
     if (encodedAttrs) translated.attrs = { ...encodedAttrs };
     return translated;
   };
-  const decode$u = (params2, decodedAttrs = {}) => {
+  const decode$S = (params2, decodedAttrs = {}) => {
     const { node } = params2 || {};
     if (!node) return;
     const wTab = { name: "w:tab" };
@@ -32165,15 +32249,15 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return translated;
   };
-  const config$e = {
-    xmlName: XML_NODE_NAME$g,
+  const config$p = {
+    xmlName: XML_NODE_NAME$r,
     sdNodeOrKeyName: SD_NODE_NAME$b,
     type: NodeTranslator.translatorTypes.NODE,
-    encode: encode$u,
-    decode: decode$u,
-    attributes: validXmlAttributes$a
+    encode: encode$$,
+    decode: decode$S,
+    attributes: validXmlAttributes$j
   };
-  const translator$U = NodeTranslator.from(config$e);
+  const translator$13 = NodeTranslator.from(config$p);
   const mergeTextNodes = (nodes) => {
     if (!nodes || !Array.isArray(nodes)) {
       return nodes;
@@ -32348,17 +32432,21 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   function getFontFamilyValue(attributes, docx) {
     const ascii = attributes["w:ascii"];
     const themeAscii = attributes["w:asciiTheme"];
-    if (!docx || !themeAscii) return ascii;
-    const theme = docx["word/theme/theme1.xml"];
-    if (!theme) return ascii;
-    const { elements: topElements } = theme;
-    const { elements } = topElements[0];
-    const themeElements = elements.find((el) => el.name === "a:themeElements");
-    const fontScheme = themeElements.elements.find((el) => el.name === "a:fontScheme");
-    const majorFont = fontScheme.elements.find((el) => el.name === "a:majorFont");
-    const latin = majorFont.elements.find((el) => el.name === "a:latin");
-    const typeface = latin.attributes["typeface"];
-    return typeface;
+    let resolved = ascii;
+    if (docx && themeAscii) {
+      const theme = docx["word/theme/theme1.xml"];
+      if (theme?.elements?.length) {
+        const { elements: topElements } = theme;
+        const { elements } = topElements[0] || {};
+        const themeElements = elements?.find((el) => el.name === "a:themeElements");
+        const fontScheme = themeElements?.elements?.find((el) => el.name === "a:fontScheme");
+        const majorFont = fontScheme?.elements?.find((el) => el.name === "a:majorFont");
+        const latin = majorFont?.elements?.find((el) => el.name === "a:latin");
+        resolved = latin?.attributes?.typeface || resolved;
+      }
+    }
+    if (!resolved) return null;
+    return SuperConverter.toCssFontFamily(resolved, docx);
   }
   function getIndentValue(attributes) {
     let value = attributes["w:left"];
@@ -32379,7 +32467,11 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     return getHexColorFromDocxSystem(attributes?.["w:val"]) || null;
   }
   function getStrikeValue(attributes) {
-    return attributes?.["w:val"] === "1" ? attributes["w:val"] : null;
+    const raw = attributes?.["w:val"];
+    if (raw === void 0 || raw === null) return "1";
+    const value = String(raw).trim().toLowerCase();
+    if (value === "1" || value === "true" || value === "on") return "1";
+    return null;
   }
   const parseParagraphBorders = (pBdr) => {
     if (!pBdr || !pBdr.elements) return {};
@@ -32409,27 +32501,39 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       right: 0,
       firstLine: 0,
       hanging: 0,
-      textIndent: 0
+      textIndent: 0,
+      explicitLeft: false,
+      explicitRight: false,
+      explicitFirstLine: false,
+      explicitHanging: false
     };
     const { indent: pDefaultIndent = {} } = getDefaultParagraphStyle(docx, styleId);
     const pPr = node.elements?.find((el) => el.name === "w:pPr");
     const inLineIndentTag = pPr?.elements?.find((el) => el.name === "w:ind");
     const inLineIndent = inLineIndentTag?.attributes || {};
-    const leftIndent = inLineIndent?.["w:left"] || pDefaultIndent?.["w:left"];
-    const rightIndent = inLineIndent?.["w:right"] || pDefaultIndent?.["w:right"];
-    const firstLine = inLineIndent?.["w:firstLine"] || pDefaultIndent?.["w:firstLine"];
-    const hanging = inLineIndent?.["w:hanging"] || pDefaultIndent?.["w:hanging"];
+    const inlineLeft = inLineIndent?.["w:left"];
+    const inlineRight = inLineIndent?.["w:right"];
+    const inlineFirstLine = inLineIndent?.["w:firstLine"];
+    const inlineHanging = inLineIndent?.["w:hanging"];
+    const leftIndent = inlineLeft ?? pDefaultIndent?.["w:left"];
+    const rightIndent = inlineRight ?? pDefaultIndent?.["w:right"];
+    const firstLine = inlineFirstLine ?? pDefaultIndent?.["w:firstLine"];
+    const hanging = inlineHanging ?? pDefaultIndent?.["w:hanging"];
     if (leftIndent) {
       indent.left = twipsToPixels(leftIndent);
+      indent.explicitLeft = inlineLeft !== void 0;
     }
     if (rightIndent) {
       indent.right = twipsToPixels(rightIndent);
+      indent.explicitRight = inlineRight !== void 0;
     }
     if (firstLine) {
       indent.firstLine = twipsToPixels(firstLine);
+      indent.explicitFirstLine = inlineFirstLine !== void 0;
     }
     if (hanging) {
       indent.hanging = twipsToPixels(hanging);
+      indent.explicitHanging = inlineHanging !== void 0;
     }
     const textIndentValue = leftIndent - parseInt(hanging || 0) || 0;
     if (textIndentValue) {
@@ -32768,102 +32872,102 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return schemaNode;
   };
-  const encode$t = (attributes) => {
+  const encode$_ = (attributes) => {
     return attributes["w:rsidDel"];
   };
-  const decode$t = (attrs) => {
+  const decode$R = (attrs) => {
     return attrs.rsidDel;
   };
-  const attrConfig$d = Object.freeze({
+  const attrConfig$z = Object.freeze({
     xmlName: "w:rsidDel",
     sdName: "rsidDel",
-    encode: encode$t,
-    decode: decode$t
+    encode: encode$_,
+    decode: decode$R
   });
-  const encode$s = (attributes) => {
+  const encode$Z = (attributes) => {
     return attributes["w:rsidP"];
   };
-  const decode$s = (attrs) => {
+  const decode$Q = (attrs) => {
     return attrs.rsidP;
   };
-  const attrConfig$c = Object.freeze({
+  const attrConfig$y = Object.freeze({
     xmlName: "w:rsidP",
     sdName: "rsidP",
-    encode: encode$s,
-    decode: decode$s
+    encode: encode$Z,
+    decode: decode$Q
   });
-  const encode$r = (attributes) => {
+  const encode$Y = (attributes) => {
     return attributes["w:rsidR"];
   };
-  const decode$r = (attrs) => {
+  const decode$P = (attrs) => {
     return attrs.rsidR;
   };
-  const attrConfig$b = Object.freeze({
+  const attrConfig$x = Object.freeze({
     xmlName: "w:rsidR",
     sdName: "rsidR",
-    encode: encode$r,
-    decode: decode$r
+    encode: encode$Y,
+    decode: decode$P
   });
-  const encode$q = (attributes) => {
+  const encode$X = (attributes) => {
     return attributes["w:rsidRPr"];
   };
-  const decode$q = (attrs) => {
+  const decode$O = (attrs) => {
     return attrs.rsidRPr;
   };
-  const attrConfig$a = Object.freeze({
+  const attrConfig$w = Object.freeze({
     xmlName: "w:rsidRPr",
     sdName: "rsidRPr",
-    encode: encode$q,
-    decode: decode$q
+    encode: encode$X,
+    decode: decode$O
   });
-  const encode$p = (attributes) => {
+  const encode$W = (attributes) => {
     return attributes["w:rsidRDefault"];
   };
-  const decode$p = (attrs) => {
+  const decode$N = (attrs) => {
     return attrs.rsidRDefault;
   };
-  const attrConfig$9 = Object.freeze({
+  const attrConfig$v = Object.freeze({
     xmlName: "w:rsidRDefault",
     sdName: "rsidRDefault",
-    encode: encode$p,
-    decode: decode$p
+    encode: encode$W,
+    decode: decode$N
   });
-  const encode$o = (attributes) => {
+  const encode$V = (attributes) => {
     return attributes["w14:paraId"];
   };
-  const decode$o = (attrs) => {
+  const decode$M = (attrs) => {
     return attrs.paraId;
   };
-  const attrConfig$8 = Object.freeze({
+  const attrConfig$u = Object.freeze({
     xmlName: "w14:paraId",
     sdName: "paraId",
-    encode: encode$o,
-    decode: decode$o
+    encode: encode$V,
+    decode: decode$M
   });
-  const encode$n = (attributes) => {
+  const encode$U = (attributes) => {
     return attributes["w14:textId"];
   };
-  const decode$n = (attrs) => {
+  const decode$L = (attrs) => {
     return attrs.textId;
   };
-  const attrConfig$7 = Object.freeze({
+  const attrConfig$t = Object.freeze({
     xmlName: "w14:textId",
     sdName: "textId",
-    encode: encode$n,
-    decode: decode$n
+    encode: encode$U,
+    decode: decode$L
   });
-  const validXmlAttributes$9 = [
-    attrConfig$8,
-    attrConfig$7,
-    attrConfig$b,
-    attrConfig$9,
-    attrConfig$c,
-    attrConfig$a,
-    attrConfig$d
+  const validXmlAttributes$i = [
+    attrConfig$u,
+    attrConfig$t,
+    attrConfig$x,
+    attrConfig$v,
+    attrConfig$y,
+    attrConfig$w,
+    attrConfig$z
   ];
-  const XML_NODE_NAME$f = "w:p";
+  const XML_NODE_NAME$q = "w:p";
   const SD_NODE_NAME$a = "paragraph";
-  const encode$m = (params2, encodedAttrs = {}) => {
+  const encode$T = (params2, encodedAttrs = {}) => {
     const node = handleParagraphNode$1(params2);
     if (!node) return void 0;
     if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -32871,7 +32975,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return node;
   };
-  const decode$m = (params2, decodedAttrs = {}) => {
+  const decode$K = (params2, decodedAttrs = {}) => {
     const translated = translateParagraphNode(params2);
     if (!translated) return void 0;
     if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -32879,9 +32983,1164 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return translated;
   };
+  const config$o = {
+    xmlName: XML_NODE_NAME$q,
+    sdNodeOrKeyName: SD_NODE_NAME$a,
+    type: NodeTranslator.translatorTypes.NODE,
+    encode: encode$T,
+    decode: decode$K,
+    attributes: validXmlAttributes$i
+  };
+  const translator$12 = NodeTranslator.from(config$o);
+  const encode$S = (attributes) => {
+    const raw = attributes?.["w:val"];
+    if (raw === void 0 || raw === null) return void 0;
+    if (typeof raw === "boolean") return raw;
+    if (typeof raw === "number") return raw !== 0;
+    const val = String(raw).trim().toLowerCase();
+    if (val === "0" || val === "false" || val === "off") return false;
+    if (val === "1" || val === "true" || val === "on") return true;
+    return void 0;
+  };
+  const decode$J = (runProps) => {
+    if (runProps?.bold === false) return "0";
+    return void 0;
+  };
+  const attrConfig$s = Object.freeze({
+    xmlName: "w:val",
+    sdName: "bold",
+    encode: encode$S,
+    decode: decode$J
+  });
+  const validXmlAttributes$h = [attrConfig$s];
+  const XML_NODE_NAME$p = "w:b";
+  const SD_ATTR_KEY$e = "bold";
+  const encode$R = (params2, encodedAttrs = {}) => {
+    const { nodes } = params2;
+    const node = nodes[0];
+    if (!node) return void 0;
+    const val = encodedAttrs?.[SD_ATTR_KEY$e];
+    let attributes;
+    if (val === false) attributes = { "w:val": "0" };
+    else if (val === true)
+      attributes = {};
+    else attributes = node.attributes || {};
+    return {
+      type: "attr",
+      xmlName: XML_NODE_NAME$p,
+      sdNodeOrKeyName: SD_ATTR_KEY$e,
+      attributes
+    };
+  };
+  const config$n = {
+    xmlName: XML_NODE_NAME$p,
+    sdNodeOrKeyName: SD_ATTR_KEY$e,
+    type: NodeTranslator.translatorTypes.ATTRIBUTE,
+    encode: encode$R,
+    attributes: validXmlAttributes$h
+  };
+  const translator$11 = NodeTranslator.from(config$n);
+  const XML_NODE_NAME$o = "w:i";
+  const SD_ATTR_KEY$d = "italic";
+  const encode$Q = (params2) => {
+    const { nodes } = params2;
+    const node = nodes?.[0];
+    if (!node) return void 0;
+    return {
+      type: "attr",
+      xmlName: XML_NODE_NAME$o,
+      sdNodeOrKeyName: SD_ATTR_KEY$d,
+      attributes: {
+        "w:val": node.attributes?.["w:val"] ?? null
+      }
+    };
+  };
+  const config$m = {
+    xmlName: XML_NODE_NAME$o,
+    sdNodeOrKeyName: SD_ATTR_KEY$d,
+    type: NodeTranslator.translatorTypes.ATTRIBUTE,
+    encode: encode$Q
+  };
+  const translator$10 = NodeTranslator.from(config$m);
+  const encode$P = (attributes) => attributes?.["w:val"];
+  const decode$I = (attrs) => attrs?.underline;
+  const attrConfig$r = Object.freeze({
+    xmlName: "w:val",
+    sdName: "underline",
+    encode: encode$P,
+    decode: decode$I
+  });
+  const encode$O = (attributes) => attributes?.["w:color"];
+  const decode$H = (attrs) => attrs?.color;
+  const attrConfig$q = Object.freeze({
+    xmlName: "w:color",
+    sdName: "color",
+    encode: encode$O,
+    decode: decode$H
+  });
+  const encode$N = (attributes) => attributes?.["w:themeColor"];
+  const decode$G = (attrs) => attrs?.themeColor;
+  const attrConfig$p = Object.freeze({
+    xmlName: "w:themeColor",
+    sdName: "themeColor",
+    encode: encode$N,
+    decode: decode$G
+  });
+  const encode$M = (attributes) => attributes?.["w:themeTint"];
+  const decode$F = (attrs) => attrs?.themeTint;
+  const attrConfig$o = Object.freeze({
+    xmlName: "w:themeTint",
+    sdName: "themeTint",
+    encode: encode$M,
+    decode: decode$F
+  });
+  const encode$L = (attributes) => attributes?.["w:themeShade"];
+  const decode$E = (attrs) => attrs?.themeShade;
+  const attrConfig$n = Object.freeze({
+    xmlName: "w:themeShade",
+    sdName: "themeShade",
+    encode: encode$L,
+    decode: decode$E
+  });
+  const validXmlAttributes$g = [attrConfig$r, attrConfig$q, attrConfig$p, attrConfig$o, attrConfig$n];
+  const XML_NODE_NAME$n = "w:u";
+  const SD_ATTR_KEY$c = "underline";
+  const encode$K = (params2, encodedAttrs = {}) => {
+    const { nodes } = params2;
+    const node = nodes?.[0];
+    const sourceAttrs = node?.attributes || {};
+    const underlineType = encodedAttrs.underline ?? sourceAttrs["w:val"];
+    const color = encodedAttrs.color ?? sourceAttrs["w:color"];
+    const themeColor = encodedAttrs.themeColor ?? sourceAttrs["w:themeColor"];
+    const themeTint = encodedAttrs.themeTint ?? sourceAttrs["w:themeTint"];
+    const themeShade = encodedAttrs.themeShade ?? sourceAttrs["w:themeShade"];
+    const attributes = { "w:val": underlineType ?? null };
+    if (color !== void 0 && color !== null) attributes["w:color"] = color;
+    if (themeColor !== void 0 && themeColor !== null) attributes["w:themeColor"] = themeColor;
+    if (themeTint !== void 0 && themeTint !== null) attributes["w:themeTint"] = themeTint;
+    if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
+    return {
+      type: "attr",
+      xmlName: XML_NODE_NAME$n,
+      sdNodeOrKeyName: SD_ATTR_KEY$c,
+      attributes
+    };
+  };
+  const decode$D = (params2) => {
+    const attrs = params2?.node?.attrs || {};
+    const underlineType = attrs.underlineType ?? attrs.underline ?? null;
+    const color = attrs.underlineColor ?? attrs.color ?? null;
+    const themeColor = attrs.underlineThemeColor ?? attrs.themeColor ?? null;
+    const themeTint = attrs.underlineThemeTint ?? attrs.themeTint ?? null;
+    const themeShade = attrs.underlineThemeShade ?? attrs.themeShade ?? null;
+    if (!underlineType && !color && !themeColor && !themeTint && !themeShade) return void 0;
+    const attributes = {};
+    if (underlineType) attributes["w:val"] = underlineType;
+    if (color) {
+      const normalized = normalizeHexColor(color);
+      if (normalized) attributes["w:color"] = normalized;
+    }
+    if (themeColor) attributes["w:themeColor"] = themeColor;
+    if (themeTint) attributes["w:themeTint"] = themeTint;
+    if (themeShade) attributes["w:themeShade"] = themeShade;
+    return {
+      name: XML_NODE_NAME$n,
+      attributes
+    };
+  };
+  const config$l = {
+    xmlName: XML_NODE_NAME$n,
+    sdNodeOrKeyName: SD_ATTR_KEY$c,
+    type: NodeTranslator.translatorTypes.ATTRIBUTE,
+    encode: encode$K,
+    decode: decode$D,
+    attributes: validXmlAttributes$g
+  };
+  const translator$$ = NodeTranslator.from(config$l);
+  const encode$J = (attributes) => {
+    const raw = attributes?.["w:val"];
+    if (raw === void 0 || raw === null) return void 0;
+    if (typeof raw === "boolean") return raw;
+    if (typeof raw === "number") return raw !== 0;
+    const val = String(raw).trim().toLowerCase();
+    if (val === "0" || val === "false" || val === "off") return false;
+    if (val === "1" || val === "true" || val === "on") return true;
+    return void 0;
+  };
+  const decode$C = (attrs) => {
+    if (attrs?.strike === false) return "0";
+    return void 0;
+  };
+  const attrConfig$m = Object.freeze({
+    xmlName: "w:val",
+    sdName: "strike",
+    encode: encode$J,
+    decode: decode$C
+  });
+  const validXmlAttributes$f = [attrConfig$m];
+  const XML_NODE_NAME$m = "w:strike";
+  const SD_ATTR_KEY$b = "strike";
+  const encode$I = (params2, encodedAttrs = {}) => {
+    const { nodes } = params2;
+    const node = nodes?.[0];
+    if (!node) return void 0;
+    const val = encodedAttrs?.[SD_ATTR_KEY$b];
+    let attributes;
+    if (val === false) attributes = { "w:val": "0" };
+    else if (val === true) attributes = {};
+    else attributes = { ...node.attributes || {} };
+    if (attributes["w:val"] === void 0 && val !== true) attributes["w:val"] = null;
+    else if (val === true && attributes["w:val"] === void 0) delete attributes["w:val"];
+    return {
+      type: "attr",
+      xmlName: XML_NODE_NAME$m,
+      sdNodeOrKeyName: SD_ATTR_KEY$b,
+      attributes
+    };
+  };
+  const config$k = {
+    xmlName: XML_NODE_NAME$m,
+    sdNodeOrKeyName: SD_ATTR_KEY$b,
+    type: NodeTranslator.translatorTypes.ATTRIBUTE,
+    encode: encode$I,
+    attributes: validXmlAttributes$f
+  };
+  const translator$_ = NodeTranslator.from(config$k);
+  const encode$H = (attributes) => attributes?.["w:val"];
+  const decode$B = (attrs) => attrs?.color;
+  const attrConfig$l = Object.freeze({
+    xmlName: "w:val",
+    sdName: "color",
+    encode: encode$H,
+    decode: decode$B
+  });
+  const encode$G = (attributes) => attributes?.["w:themeColor"];
+  const decode$A = (attrs) => attrs?.themeColor;
+  const attrConfig$k = Object.freeze({
+    xmlName: "w:themeColor",
+    sdName: "themeColor",
+    encode: encode$G,
+    decode: decode$A
+  });
+  const encode$F = (attributes) => attributes?.["w:themeTint"];
+  const decode$z = (attrs) => attrs?.themeTint;
+  const attrConfig$j = Object.freeze({
+    xmlName: "w:themeTint",
+    sdName: "themeTint",
+    encode: encode$F,
+    decode: decode$z
+  });
+  const encode$E = (attributes) => attributes?.["w:themeShade"];
+  const decode$y = (attrs) => attrs?.themeShade;
+  const attrConfig$i = Object.freeze({
+    xmlName: "w:themeShade",
+    sdName: "themeShade",
+    encode: encode$E,
+    decode: decode$y
+  });
+  const validXmlAttributes$e = [attrConfig$l, attrConfig$k, attrConfig$j, attrConfig$i];
+  const XML_NODE_NAME$l = "w:color";
+  const SD_ATTR_KEY$a = "color";
+  const encode$D = (params2, encodedAttrs = {}) => {
+    const { nodes } = params2;
+    const node = nodes?.[0];
+    const sourceAttrs = node?.attributes || {};
+    const value = encodedAttrs.color ?? sourceAttrs["w:val"];
+    const themeColor = encodedAttrs.themeColor ?? sourceAttrs["w:themeColor"];
+    const themeTint = encodedAttrs.themeTint ?? sourceAttrs["w:themeTint"];
+    const themeShade = encodedAttrs.themeShade ?? sourceAttrs["w:themeShade"];
+    const attributes = {};
+    attributes["w:val"] = value ?? null;
+    if (themeColor !== void 0 && themeColor !== null) attributes["w:themeColor"] = themeColor;
+    if (themeTint !== void 0 && themeTint !== null) attributes["w:themeTint"] = themeTint;
+    if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
+    return {
+      type: "attr",
+      xmlName: XML_NODE_NAME$l,
+      sdNodeOrKeyName: SD_ATTR_KEY$a,
+      attributes
+    };
+  };
+  const config$j = {
+    xmlName: XML_NODE_NAME$l,
+    sdNodeOrKeyName: SD_ATTR_KEY$a,
+    type: NodeTranslator.translatorTypes.ATTRIBUTE,
+    encode: encode$D,
+    attributes: validXmlAttributes$e
+  };
+  const translator$Z = NodeTranslator.from(config$j);
+  const encode$C = (attributes) => attributes?.["w:eastAsia"];
+  const decode$x = (attrs) => attrs?.eastAsia;
+  const attrConfig$h = Object.freeze({
+    xmlName: "w:eastAsia",
+    sdName: "eastAsia",
+    encode: encode$C,
+    decode: decode$x
+  });
+  const encode$B = (attributes) => attributes?.["w:ascii"];
+  const decode$w = (attrs) => attrs?.ascii;
+  const attrConfig$g = Object.freeze({
+    xmlName: "w:ascii",
+    sdName: "ascii",
+    encode: encode$B,
+    decode: decode$w
+  });
+  const encode$A = (attributes) => attributes?.["w:hAnsi"];
+  const decode$v = (attrs) => attrs?.hAnsi;
+  const attrConfig$f = Object.freeze({
+    xmlName: "w:hAnsi",
+    sdName: "hAnsi",
+    encode: encode$A,
+    decode: decode$v
+  });
+  const encode$z = (attributes) => attributes?.["w:cs"];
+  const decode$u = (attrs) => attrs?.cs;
+  const attrConfig$e = Object.freeze({
+    xmlName: "w:cs",
+    sdName: "cs",
+    encode: encode$z,
+    decode: decode$u
+  });
+  const encode$y = (attributes) => attributes?.["w:val"];
+  const decode$t = (attrs) => attrs?.value;
+  const attrConfig$d = Object.freeze({
+    xmlName: "w:val",
+    sdName: "value",
+    encode: encode$y,
+    decode: decode$t
+  });
+  const validXmlAttributes$d = [attrConfig$h, attrConfig$g, attrConfig$f, attrConfig$e, attrConfig$d];
+  const XML_NODE_NAME$k = "w:rFonts";
+  const SD_ATTR_KEY$9 = "fontFamily";
+  const encode$x = (params2, encodedAttrs = {}) => {
+    const { nodes } = params2;
+    const node = nodes?.[0];
+    const sourceAttrs = node?.attributes || {};
+    const attributes = {};
+    const setAttr = (xmlName, sdName) => {
+      if (encodedAttrs[sdName] !== void 0 && encodedAttrs[sdName] !== null) {
+        attributes[xmlName] = encodedAttrs[sdName];
+      } else if (sourceAttrs[xmlName] !== void 0) {
+        attributes[xmlName] = sourceAttrs[xmlName];
+      }
+    };
+    setAttr("w:eastAsia", "eastAsia");
+    setAttr("w:ascii", "ascii");
+    setAttr("w:hAnsi", "hAnsi");
+    setAttr("w:cs", "cs");
+    setAttr("w:val", "value");
+    Object.keys(sourceAttrs).forEach((key2) => {
+      if (attributes[key2] === void 0) attributes[key2] = sourceAttrs[key2];
+    });
+    if (attributes["w:val"] === void 0 && attributes["w:eastAsia"]) {
+      attributes["w:val"] = attributes["w:eastAsia"];
+    }
+    if (attributes["w:val"] === void 0) delete attributes["w:val"];
+    return {
+      type: "attr",
+      xmlName: XML_NODE_NAME$k,
+      sdNodeOrKeyName: SD_ATTR_KEY$9,
+      attributes
+    };
+  };
+  const config$i = {
+    xmlName: XML_NODE_NAME$k,
+    sdNodeOrKeyName: SD_ATTR_KEY$9,
+    type: NodeTranslator.translatorTypes.ATTRIBUTE,
+    encode: encode$x,
+    attributes: validXmlAttributes$d
+  };
+  const translator$Y = NodeTranslator.from(config$i);
+  const encode$w = (attributes) => attributes?.["w:val"];
+  const decode$s = (attrs) => attrs?.styleId;
+  const attrConfig$c = Object.freeze({
+    xmlName: "w:val",
+    sdName: "styleId",
+    encode: encode$w,
+    decode: decode$s
+  });
+  const validXmlAttributes$c = [attrConfig$c];
+  const XML_NODE_NAME$j = "w:rStyle";
+  const SD_ATTR_KEY$8 = "styleId";
+  const encode$v = (params2, encodedAttrs = {}) => {
+    const { nodes } = params2;
+    const node = nodes?.[0];
+    const value = encodedAttrs.styleId ?? node?.attributes?.["w:val"];
+    return {
+      type: "attr",
+      xmlName: XML_NODE_NAME$j,
+      sdNodeOrKeyName: SD_ATTR_KEY$8,
+      attributes: { "w:val": value ?? null }
+    };
+  };
+  const config$h = {
+    xmlName: XML_NODE_NAME$j,
+    sdNodeOrKeyName: SD_ATTR_KEY$8,
+    type: NodeTranslator.translatorTypes.ATTRIBUTE,
+    encode: encode$v,
+    attributes: validXmlAttributes$c
+  };
+  const translator$X = NodeTranslator.from(config$h);
+  const encode$u = (attributes) => attributes?.["w:val"];
+  const decode$r = (attrs) => attrs?.fontSize;
+  const attrConfig$b = Object.freeze({
+    xmlName: "w:val",
+    sdName: "fontSize",
+    encode: encode$u,
+    decode: decode$r
+  });
+  const validXmlAttributes$b = [attrConfig$b];
+  const XML_NODE_NAME$i = "w:sz";
+  const SD_ATTR_KEY$7 = "fontSize";
+  const encode$t = (params2, encodedAttrs = {}) => {
+    const { nodes } = params2;
+    const node = nodes?.[0];
+    const value = encodedAttrs.fontSize ?? node?.attributes?.["w:val"];
+    return {
+      type: "attr",
+      xmlName: XML_NODE_NAME$i,
+      sdNodeOrKeyName: SD_ATTR_KEY$7,
+      attributes: { "w:val": value ?? null }
+    };
+  };
+  const config$g = {
+    xmlName: XML_NODE_NAME$i,
+    sdNodeOrKeyName: SD_ATTR_KEY$7,
+    type: NodeTranslator.translatorTypes.ATTRIBUTE,
+    encode: encode$t,
+    attributes: validXmlAttributes$b
+  };
+  const translator$W = NodeTranslator.from(config$g);
+  const encode$s = (attributes) => attributes?.["w:val"];
+  const decode$q = (attrs) => attrs?.fontSizeCs;
+  const attrConfig$a = Object.freeze({
+    xmlName: "w:val",
+    sdName: "fontSizeCs",
+    encode: encode$s,
+    decode: decode$q
+  });
+  const validXmlAttributes$a = [attrConfig$a];
+  const XML_NODE_NAME$h = "w:szCs";
+  const SD_ATTR_KEY$6 = "fontSizeCs";
+  const encode$r = (params2, encodedAttrs = {}) => {
+    const { nodes } = params2;
+    const node = nodes?.[0];
+    const value = encodedAttrs.fontSizeCs ?? node?.attributes?.["w:val"];
+    return {
+      type: "attr",
+      xmlName: XML_NODE_NAME$h,
+      sdNodeOrKeyName: SD_ATTR_KEY$6,
+      attributes: { "w:val": value ?? null }
+    };
+  };
+  const config$f = {
+    xmlName: XML_NODE_NAME$h,
+    sdNodeOrKeyName: SD_ATTR_KEY$6,
+    type: NodeTranslator.translatorTypes.ATTRIBUTE,
+    encode: encode$r,
+    attributes: validXmlAttributes$a
+  };
+  const translator$V = NodeTranslator.from(config$f);
+  const runPropertyTranslators = Object.freeze({
+    "w:b": translator$11,
+    "w:i": translator$10,
+    "w:u": translator$$,
+    "w:strike": translator$_,
+    "w:color": translator$Z,
+    "w:highlight": translator$14,
+    "w:rFonts": translator$Y,
+    "w:rStyle": translator$X,
+    "w:sz": translator$W,
+    "w:szCs": translator$V
+  });
+  const rawRunPropertyXmlNames = Object.freeze(["w:lang", "w:shd"]);
+  const RAW_CHILD_NAME_SET = new Set(rawRunPropertyXmlNames);
+  const KNOWN_CHILD_XML_NAMES = /* @__PURE__ */ new Set([...Object.keys(runPropertyTranslators), ...RAW_CHILD_NAME_SET]);
+  const toRunPropertyEntry = (candidate) => {
+    if (!candidate || candidate.type !== "attr") return null;
+    const xmlName = candidate.xmlName || candidate.name;
+    if (!xmlName) return null;
+    return {
+      xmlName,
+      attributes: { ...candidate.attributes || {} }
+    };
+  };
+  const XML_NODE_NAME$g = "w:rPr";
+  const SD_ATTR_KEY$5 = "runProperties";
+  const encode$q = (params2) => {
+    const { nodes } = params2;
+    const node = nodes?.[0] || {};
+    const contents = Array.isArray(node.elements) ? node.elements : [];
+    const runPropsArray = contents.reduce(
+      (acc, child) => {
+        if (!child || typeof child !== "object") return acc;
+        const xmlName = child.name;
+        if (!KNOWN_CHILD_XML_NAMES.has(xmlName)) return acc;
+        const translator2 = runPropertyTranslators[xmlName];
+        let entry = null;
+        if (translator2) {
+          const encoded = translator2.encode({ ...params2, nodes: [child] }) || null;
+          entry = toRunPropertyEntry(encoded);
+        } else if (RAW_CHILD_NAME_SET.has(xmlName)) {
+          entry = toRunPropertyEntry({
+            type: "attr",
+            xmlName,
+            attributes: { ...child.attributes || {} }
+          });
+        }
+        if (entry) acc.push(entry);
+        return acc;
+      },
+      /** @type {{ xmlName: string, attributes: Record<string, any> }[]} */
+      []
+    );
+    return {
+      type: "attr",
+      xmlName: "w:rPr",
+      sdNodeOrKeyName: "runProperties",
+      attributes: runPropsArray
+    };
+  };
+  const config$e = {
+    xmlName: XML_NODE_NAME$g,
+    sdNodeOrKeyName: SD_ATTR_KEY$5,
+    type: NodeTranslator.translatorTypes.ATTRIBUTE,
+    encode: encode$q
+  };
+  const translator$U = NodeTranslator.from(config$e);
+  const EAST_ASIAN_CHARACTER_REGEX = /[\u1100-\u11FF\u2E80-\u2EFF\u2F00-\u2FDF\u3040-\u30FF\u3100-\u312F\u3130-\u318F\u31A0-\u31BF\u3400-\u4DBF\u4E00-\u9FFF\uA960-\uA97F\uAC00-\uD7AF\uF900-\uFAFF\uFF00-\uFFEF]/u;
+  const containsEastAsianCharacters = (text) => EAST_ASIAN_CHARACTER_REGEX.test(text);
+  const collectRunProperties = (params2, rPrNode, translator2 = translator$U) => {
+    if (!rPrNode) return { entries: [], hadRPr: false, styleChangeMarks: [] };
+    const result = translator2.encode({ ...params2, nodes: [rPrNode] }) || {};
+    let entries = [];
+    if (Array.isArray(result.attributes) && result.attributes.length) {
+      entries = result.attributes.map((attr) => ({
+        xmlName: attr?.xmlName,
+        attributes: { ...attr?.attributes || {} }
+      }));
+    } else if (Array.isArray(rPrNode.elements) && rPrNode.elements.length) {
+      entries = rPrNode.elements.filter((el) => el && typeof el === "object").map((el) => ({
+        xmlName: el.name,
+        attributes: { ...el.attributes || {} }
+      }));
+    }
+    const legacyMarks = parseMarks(rPrNode, [], params2?.docx) || [];
+    const styleChangeMarks = handleStyleChangeMarks(rPrNode, legacyMarks) || [];
+    return { entries, hadRPr: true, styleChangeMarks };
+  };
+  const buildRunAttrs = (encodedAttrs = {}, hadRPr, runProps) => {
+    const base2 = { ...encodedAttrs || {} };
+    if (hadRPr) {
+      base2.runProperties = runProps.length ? runProps : null;
+    }
+    return base2;
+  };
+  const ensureInlineMarks = (marks, inlineMarks = []) => {
+    inlineMarks.forEach(({ type: type2, attrs }) => {
+      if (!type2) return;
+      if (marks.some((mark) => mark?.type === type2)) return;
+      marks.push(attrs ? { type: type2, attrs: { ...attrs } } : { type: type2 });
+    });
+  };
+  const ensureTextStyleMark = (marks, textStyleAttrs) => {
+    if (!textStyleAttrs) return;
+    const existingTextStyle = marks.find((mark) => mark?.type === "textStyle");
+    if (existingTextStyle) {
+      existingTextStyle.attrs = { ...existingTextStyle.attrs || {}, ...textStyleAttrs };
+      return;
+    }
+    marks.push({ type: "textStyle", attrs: { ...textStyleAttrs } });
+  };
+  const normalizeTextStyleAttrsForNode = (textStyleAttrs, node) => {
+    if (!textStyleAttrs || typeof textStyleAttrs !== "object") return null;
+    const normalized = { ...textStyleAttrs };
+    const eastAsiaFont = normalized.eastAsiaFontFamily;
+    if (eastAsiaFont) {
+      delete normalized.eastAsiaFontFamily;
+      const text = typeof node?.text === "string" ? node.text : null;
+      const shouldUseEastAsia = typeof text === "string" && containsEastAsianCharacters(text);
+      if (shouldUseEastAsia) {
+        normalized.fontFamily = eastAsiaFont;
+      }
+    }
+    return Object.keys(normalized).length ? normalized : null;
+  };
+  const applyRunMarks = (node, inlineMarks, textStyleAttrs) => {
+    if (!node || typeof node !== "object") return node;
+    const baseMarks = Array.isArray(node.marks) ? node.marks : [];
+    const marks = baseMarks.map((mark) => cloneMark$1(mark));
+    ensureInlineMarks(marks, inlineMarks);
+    if (node.type === "text") {
+      const normalizedTextStyle = normalizeTextStyleAttrsForNode(textStyleAttrs, node);
+      ensureTextStyleMark(marks, normalizedTextStyle);
+    }
+    return { ...node, marks };
+  };
+  const deriveStyleMarks = ({ docx, paragraphStyleId, runStyleId }) => {
+    const paragraphStyleMarks = collectStyleMarks(paragraphStyleId, docx);
+    const runStyleMarks = collectStyleMarks(runStyleId, docx);
+    const inlineMarks = mergeInlineMarkSets(paragraphStyleMarks.inlineMarks, runStyleMarks.inlineMarks);
+    const textStyleAttrs = mergeTextStyleAttrs(paragraphStyleMarks.textStyleAttrs, runStyleMarks.textStyleAttrs);
+    return { inlineMarks, textStyleAttrs };
+  };
+  const collectStyleMarks = (styleId, docx, seen = /* @__PURE__ */ new Set()) => {
+    if (!styleId || !docx || seen.has(styleId)) return { inlineMarks: [], textStyleAttrs: null };
+    seen.add(styleId);
+    const chain = collectStyleChain(styleId, docx, seen);
+    if (!chain.length) return { inlineMarks: [], textStyleAttrs: null };
+    const inlineMap = /* @__PURE__ */ new Map();
+    let textStyleAttrs = {};
+    chain.forEach((styleTag) => {
+      const marks = extractMarksFromStyle(styleTag, docx);
+      marks.inlineMarks.forEach((mark) => {
+        inlineMap.set(mark.type, mark.attrs ? { type: mark.type, attrs: { ...mark.attrs } } : { type: mark.type });
+      });
+      if (marks.textStyleAttrs) textStyleAttrs = { ...textStyleAttrs, ...marks.textStyleAttrs };
+    });
+    return {
+      inlineMarks: Array.from(inlineMap.values()),
+      textStyleAttrs: Object.keys(textStyleAttrs).length ? textStyleAttrs : null
+    };
+  };
+  const collectStyleChain = (styleId, docx, seen) => {
+    if (!styleId || !docx) return [];
+    const styleTag = findStyleTag(docx, styleId);
+    if (!styleTag || !styleTag.elements) return [];
+    const basedOn = styleTag.elements?.find((el) => el.name === "w:basedOn")?.attributes?.["w:val"];
+    let chain = [];
+    if (basedOn && !seen.has(basedOn)) {
+      seen.add(basedOn);
+      chain = collectStyleChain(basedOn, docx, seen);
+    }
+    chain.push(styleTag);
+    return chain;
+  };
+  const findStyleTag = (docx, styleId) => {
+    const stylesFile = docx?.["word/styles.xml"];
+    if (!stylesFile?.elements?.length) return null;
+    const candidates = [];
+    stylesFile.elements.forEach((el) => {
+      if (!el) return;
+      if (el.name === "w:styles" && Array.isArray(el.elements)) {
+        el.elements.forEach((child) => {
+          if (child?.name === "w:style") candidates.push(child);
+        });
+        return;
+      }
+      if (el.name === "w:style") {
+        candidates.push(el);
+        return;
+      }
+      if (Array.isArray(el.elements)) {
+        el.elements.forEach((child) => {
+          if (child?.name === "w:style") candidates.push(child);
+        });
+      }
+    });
+    return candidates.find((tag) => tag?.attributes?.["w:styleId"] === styleId) || null;
+  };
+  const extractMarksFromStyle = (styleTag, docx) => {
+    const rPr = styleTag?.elements?.find((el) => el.name === "w:rPr");
+    if (!rPr) return { inlineMarks: [], textStyleAttrs: null };
+    const marks = parseMarks(rPr, [], docx) || [];
+    const inlineMarks = [];
+    let textStyleAttrs = {};
+    marks.forEach((mark) => {
+      if (!mark) return;
+      if (mark.type === "textStyle") {
+        const attrs = mark.attrs || {};
+        if (Object.keys(attrs).length) textStyleAttrs = { ...textStyleAttrs, ...attrs };
+        return;
+      }
+      if (mark.type) inlineMarks.push(mark.attrs ? { type: mark.type, attrs: { ...mark.attrs } } : { type: mark.type });
+    });
+    return {
+      inlineMarks,
+      textStyleAttrs: Object.keys(textStyleAttrs).length ? textStyleAttrs : null
+    };
+  };
+  const mergeInlineMarkSets = (...markSets) => {
+    const map2 = /* @__PURE__ */ new Map();
+    markSets.filter(Boolean).forEach((marks) => {
+      marks.forEach((mark) => {
+        if (!mark || !mark.type) return;
+        map2.set(mark.type, mark.attrs ? { type: mark.type, attrs: { ...mark.attrs } } : { type: mark.type });
+      });
+    });
+    return Array.from(map2.values());
+  };
+  const mergeTextStyleAttrs = (...attrsList) => {
+    const merged = attrsList.filter((attrs) => attrs && Object.keys(attrs).length).reduce((acc, attrs) => ({ ...acc, ...attrs }), {});
+    return Object.keys(merged).length ? merged : null;
+  };
+  const cloneRunAttrs = (attrs) => {
+    const clone = { ...attrs };
+    if (Array.isArray(attrs?.runProperties)) {
+      clone.runProperties = attrs.runProperties.map((entry) => ({
+        xmlName: entry?.xmlName,
+        attributes: { ...entry?.attributes || {} }
+      }));
+    }
+    return clone;
+  };
+  const cloneMark$1 = (mark) => {
+    if (!mark || typeof mark !== "object") return mark;
+    const cloned = { ...mark };
+    if (mark.attrs && typeof mark.attrs === "object") {
+      cloned.attrs = { ...mark.attrs };
+      if (Array.isArray(mark.attrs.runProperties)) {
+        cloned.attrs.runProperties = mark.attrs.runProperties.map((entry) => ({
+          xmlName: entry?.xmlName,
+          attributes: { ...entry?.attributes || {} }
+        }));
+      }
+    }
+    return cloned;
+  };
+  const normalizeBool = (value) => {
+    if (value === void 0 || value === null) return true;
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return value !== 0;
+    const normalized = String(value).trim().toLowerCase();
+    if (normalized === "0" || normalized === "false" || normalized === "off") return false;
+    if (normalized === "1" || normalized === "true" || normalized === "on") return true;
+    return true;
+  };
+  const createRunPropertiesElement = (entries = []) => {
+    if (!Array.isArray(entries) || !entries.length) return null;
+    const elements = entries.map((entry) => {
+      if (!entry || !entry.xmlName) return null;
+      return {
+        name: entry.xmlName,
+        attributes: { ...entry.attributes || {} }
+      };
+    }).filter(Boolean);
+    if (!elements.length) return null;
+    return {
+      name: "w:rPr",
+      elements
+    };
+  };
+  const cloneXmlNode = (nodeLike) => {
+    if (!nodeLike || typeof nodeLike !== "object") return nodeLike;
+    return {
+      name: nodeLike.name,
+      type: nodeLike.type,
+      attributes: nodeLike.attributes ? { ...nodeLike.attributes } : void 0,
+      elements: Array.isArray(nodeLike.elements) ? nodeLike.elements.map((el) => cloneXmlNode(el)) : void 0,
+      text: nodeLike.text
+    };
+  };
+  const applyRunPropertiesTemplate = (runNode, runPropertiesTemplate) => {
+    if (!runNode || !runPropertiesTemplate) return;
+    if (!Array.isArray(runNode.elements)) runNode.elements = [];
+    let runProps = runNode.elements.find((el) => el?.name === "w:rPr");
+    if (!runProps) {
+      runProps = { name: "w:rPr", elements: [] };
+      runNode.elements.unshift(runProps);
+    }
+    if (!Array.isArray(runProps.elements)) runProps.elements = [];
+    if (runPropertiesTemplate.attributes) {
+      runProps.attributes = {
+        ...runProps.attributes || {},
+        ...runPropertiesTemplate.attributes
+      };
+    }
+    const isValidRunPropName = (name) => typeof name === "string" && name.includes(":");
+    runProps.elements = runProps.elements.filter((entry) => isValidRunPropName(entry?.name));
+    const existingNames = new Set(runProps.elements.map((el) => el?.name));
+    (runPropertiesTemplate.elements || []).forEach((entry) => {
+      if (!isValidRunPropName(entry?.name) || existingNames.has(entry.name)) return;
+      runProps.elements.push(cloneXmlNode(entry));
+      existingNames.add(entry.name);
+    });
+  };
+  const splitRunProperties = (entries = [], docx = null) => {
+    const remainingProps = [];
+    const inlineMarks = [];
+    const textStyleAttrs = {};
+    let hasTextStyle = false;
+    let highlightColor = null;
+    let runStyleId = null;
+    entries.forEach((entry) => {
+      if (!entry || !entry.xmlName) return;
+      const attributes = entry.attributes || {};
+      switch (entry.xmlName) {
+        case "w:b": {
+          const val = normalizeBool(attributes["w:val"]);
+          inlineMarks.push(val ? { type: "bold" } : { type: "bold", attrs: { value: "0" } });
+          break;
+        }
+        case "w:i": {
+          const val = normalizeBool(attributes["w:val"]);
+          inlineMarks.push(val ? { type: "italic" } : { type: "italic", attrs: { value: "0" } });
+          break;
+        }
+        case "w:u": {
+          const rawVal = attributes["w:val"];
+          const underlineType = rawVal == null || rawVal === "" ? "single" : String(rawVal);
+          const attrs = {};
+          if (underlineType.toLowerCase() === "none" || underlineType === "0") {
+            attrs.underlineType = "none";
+          } else {
+            attrs.underlineType = underlineType;
+            const colorRaw = attributes["w:color"];
+            if (typeof colorRaw === "string" && colorRaw.toLowerCase() !== "auto") {
+              const normalizedColor = normalizeHexColor(colorRaw);
+              if (normalizedColor) attrs.underlineColor = `#${normalizedColor}`;
+            }
+          }
+          if (attributes["w:themeColor"]) attrs.underlineThemeColor = attributes["w:themeColor"];
+          if (attributes["w:themeTint"]) attrs.underlineThemeTint = attributes["w:themeTint"];
+          if (attributes["w:themeShade"]) attrs.underlineThemeShade = attributes["w:themeShade"];
+          inlineMarks.push({ type: "underline", attrs });
+          break;
+        }
+        case "w:color": {
+          const raw = attributes["w:val"];
+          if (typeof raw === "string" && raw) {
+            hasTextStyle = true;
+            textStyleAttrs.color = `#${raw.replace("#", "").toUpperCase()}`;
+          }
+          break;
+        }
+        case "w:rFonts": {
+          const asciiFamily = attributes["w:ascii"] || attributes["w:hAnsi"] || (attributes["w:eastAsia"] ? void 0 : attributes["w:val"]);
+          const eastAsiaFamily = attributes["w:eastAsia"];
+          if (asciiFamily) {
+            hasTextStyle = true;
+            textStyleAttrs.fontFamily = SuperConverter.toCssFontFamily(asciiFamily, docx);
+          }
+          if (eastAsiaFamily) {
+            hasTextStyle = true;
+            const eastAsiaCss = SuperConverter.toCssFontFamily(eastAsiaFamily, docx);
+            if (!asciiFamily || eastAsiaCss !== textStyleAttrs.fontFamily) {
+              textStyleAttrs.eastAsiaFontFamily = eastAsiaCss;
+            }
+          }
+          break;
+        }
+        case "w:sz":
+        case "w:szCs": {
+          const rawSize = Number(attributes["w:val"]);
+          if (Number.isFinite(rawSize) && rawSize > 0) {
+            hasTextStyle = true;
+            textStyleAttrs.fontSize = `${rawSize / 2}pt`;
+          }
+          break;
+        }
+        case "w:strike": {
+          const val = normalizeBool(attributes["w:val"]);
+          inlineMarks.push(val ? { type: "strike" } : { type: "strike", attrs: { value: "0" } });
+          break;
+        }
+        case "w:highlight": {
+          const color = attributes["w:val"];
+          if (typeof color === "string" && color) {
+            highlightColor = color.toLowerCase() === "none" ? "transparent" : color;
+          }
+          break;
+        }
+        case "w:shd": {
+          const fill = attributes["w:fill"];
+          const shdVal = attributes["w:val"];
+          if (fill && String(fill).toLowerCase() !== "auto") {
+            highlightColor = `#${String(fill).replace("#", "")}`;
+          } else if (typeof shdVal === "string") {
+            const normalized = shdVal.toLowerCase();
+            if (normalized === "clear" || normalized === "nil" || normalized === "none") {
+              highlightColor = "transparent";
+            }
+          }
+          break;
+        }
+        case "w:rStyle": {
+          if (typeof attributes["w:val"] === "string") runStyleId = attributes["w:val"];
+          remainingProps.push({ xmlName: entry.xmlName, attributes: { ...attributes } });
+          break;
+        }
+        default: {
+          remainingProps.push({ xmlName: entry.xmlName, attributes: { ...attributes } });
+        }
+      }
+    });
+    if (highlightColor) inlineMarks.push({ type: "highlight", attrs: { color: highlightColor } });
+    return {
+      remainingProps,
+      inlineMarks,
+      textStyleAttrs: hasTextStyle ? textStyleAttrs : null,
+      runStyleId
+    };
+  };
+  const cloneMark = (mark) => {
+    if (!mark) return mark;
+    return {
+      ...mark,
+      attrs: mark.attrs ? { ...mark.attrs } : void 0
+    };
+  };
+  const cloneNode = (node) => {
+    if (!node || typeof node !== "object") return node;
+    const cloned = { ...node };
+    if (node.marks) cloned.marks = node.marks.map((mark) => cloneMark(mark));
+    if (node.content) cloned.content = node.content.map((child) => cloneNode(child));
+    if (node.elements) cloned.elements = node.elements.map((el) => cloneNode(el));
+    if (node.attributes) cloned.attributes = { ...node.attributes };
+    return cloned;
+  };
+  const cloneRuns = (runs = []) => runs.map((run2) => cloneNode(run2));
+  const prepareRunTrackingContext = (node = {}) => {
+    const marks = Array.isArray(node.marks) ? node.marks : [];
+    const trackingMarks = marks.filter(
+      (mark) => mark?.type === TrackInsertMarkName || mark?.type === TrackDeleteMarkName
+    );
+    if (!trackingMarks.length) {
+      return { runNode: node, trackingMarksByType: /* @__PURE__ */ new Map() };
+    }
+    const trackingMarksByType = /* @__PURE__ */ new Map();
+    trackingMarks.forEach((mark) => {
+      if (mark?.type) trackingMarksByType.set(mark.type, cloneMark(mark));
+    });
+    const preservedMarks = marks.filter((mark) => mark?.type !== TrackInsertMarkName && mark?.type !== TrackDeleteMarkName).map((mark) => cloneMark(mark));
+    const clonedContent = Array.isArray(node.content) ? node.content.map((child) => {
+      const childClone = cloneNode(child);
+      const childMarks = Array.isArray(childClone.marks) ? childClone.marks.slice() : [];
+      trackingMarks.forEach((mark) => {
+        childMarks.push(cloneMark(mark));
+      });
+      childClone.marks = childMarks;
+      return childClone;
+    }) : [];
+    return {
+      runNode: {
+        ...cloneNode(node),
+        marks: preservedMarks,
+        content: clonedContent
+      },
+      trackingMarksByType
+    };
+  };
+  const mapTrackingAttrs = (mark, attrMap) => {
+    const source = mark?.attrs || {};
+    const mapped = {};
+    attrMap.forEach((targetKey, sourceKey) => {
+      if (source[sourceKey] != null) mapped[targetKey] = source[sourceKey];
+    });
+    return mapped;
+  };
+  const renameTextElementsForDeletion = (node) => {
+    if (!node || typeof node !== "object") return;
+    if (node.name === "w:t") node.name = "w:delText";
+    if (Array.isArray(node.elements)) node.elements.forEach(renameTextElementsForDeletion);
+  };
+  const ensureTrackedWrapper = (runs, trackingMarksByType = /* @__PURE__ */ new Map()) => {
+    if (!Array.isArray(runs) || !runs.length) return runs;
+    const firstRun = runs[0];
+    if (firstRun?.name === "w:ins" || firstRun?.name === "w:del") {
+      return runs;
+    }
+    if (!trackingMarksByType.size) return runs;
+    if (trackingMarksByType.has(TrackInsertMarkName)) {
+      const mark = trackingMarksByType.get(TrackInsertMarkName);
+      const clonedRuns = cloneRuns(runs);
+      const wrapper = {
+        name: "w:ins",
+        attributes: mapTrackingAttrs(
+          mark,
+          /* @__PURE__ */ new Map([
+            ["id", "w:id"],
+            ["author", "w:author"],
+            ["authorEmail", "w:authorEmail"],
+            ["date", "w:date"]
+          ])
+        ),
+        elements: clonedRuns
+      };
+      return [wrapper];
+    }
+    if (trackingMarksByType.has(TrackDeleteMarkName)) {
+      const mark = trackingMarksByType.get(TrackDeleteMarkName);
+      const clonedRuns = cloneRuns(runs);
+      clonedRuns.forEach(renameTextElementsForDeletion);
+      const wrapper = {
+        name: "w:del",
+        attributes: mapTrackingAttrs(mark, /* @__PURE__ */ new Map([["id", "w:id"]])),
+        elements: clonedRuns
+      };
+      return [wrapper];
+    }
+    return runs;
+  };
+  const encode$p = (attributes) => {
+    return attributes["w:rsidR"];
+  };
+  const decode$p = (attrs) => {
+    return attrs.rsidR;
+  };
+  const attrConfig$9 = Object.freeze({
+    xmlName: "w:rsidR",
+    sdName: "rsidR",
+    encode: encode$p,
+    decode: decode$p
+  });
+  const encode$o = (attributes) => {
+    return attributes["w:rsidRPr"];
+  };
+  const decode$o = (attrs) => {
+    return attrs.rsidRPr;
+  };
+  const attrConfig$8 = Object.freeze({
+    xmlName: "w:rsidRPr",
+    sdName: "rsidRPr",
+    encode: encode$o,
+    decode: decode$o
+  });
+  const encode$n = (attributes) => {
+    return attributes["w:rsidDel"];
+  };
+  const decode$n = (attrs) => {
+    return attrs.rsidDel;
+  };
+  const attrConfig$7 = Object.freeze({
+    xmlName: "w:rsidDel",
+    sdName: "rsidDel",
+    encode: encode$n,
+    decode: decode$n
+  });
+  const validXmlAttributes$9 = [attrConfig$9, attrConfig$8, attrConfig$7];
+  const XML_NODE_NAME$f = "w:r";
+  const SD_KEY_NAME = "run";
+  const encode$m = (params2, encodedAttrs = {}) => {
+    const { nodes = [], nodeListHandler } = params2 || {};
+    const runNode = nodes[0];
+    if (!runNode) return void 0;
+    const elements = Array.isArray(runNode.elements) ? runNode.elements : [];
+    const rPrNode = elements.find((child) => child?.name === "w:rPr");
+    const contentElements = rPrNode ? elements.filter((el) => el !== rPrNode) : elements;
+    const { entries: runPropEntries, hadRPr, styleChangeMarks } = collectRunProperties(params2, rPrNode);
+    const { remainingProps, inlineMarks, textStyleAttrs, runStyleId } = splitRunProperties(runPropEntries, params2?.docx);
+    const styleMarks = deriveStyleMarks({
+      docx: params2?.docx,
+      paragraphStyleId: params2?.parentStyleId,
+      runStyleId
+    });
+    const mergedInlineMarks = mergeInlineMarkSets(styleMarks.inlineMarks, inlineMarks);
+    let mergedTextStyleAttrs = mergeTextStyleAttrs(styleMarks.textStyleAttrs, textStyleAttrs);
+    if (runStyleId) {
+      mergedTextStyleAttrs = mergedTextStyleAttrs ? { ...mergedTextStyleAttrs, styleId: runStyleId } : { styleId: runStyleId };
+    }
+    const runAttrs = buildRunAttrs(encodedAttrs, hadRPr, remainingProps);
+    let runLevelMarks = Array.isArray(runNode.marks) ? runNode.marks.map((mark) => cloneMark$1(mark)) : [];
+    if (styleChangeMarks?.length) {
+      runLevelMarks = [...runLevelMarks, ...styleChangeMarks.map((mark) => cloneMark$1(mark))];
+    }
+    const childParams = { ...params2, nodes: contentElements };
+    const content = nodeListHandler?.handler(childParams) || [];
+    const contentWithRunMarks = content.map((child) => {
+      if (!child || typeof child !== "object") return child;
+      const baseMarks = Array.isArray(child.marks) ? child.marks.map((mark) => cloneMark$1(mark)) : [];
+      if (!runLevelMarks.length) return child;
+      return { ...child, marks: [...baseMarks, ...runLevelMarks.map((mark) => cloneMark$1(mark))] };
+    });
+    const marked = contentWithRunMarks.map((child) => applyRunMarks(child, mergedInlineMarks, mergedTextStyleAttrs));
+    const filtered = marked.filter(Boolean);
+    const runNodeResult = {
+      type: SD_KEY_NAME,
+      content: filtered
+    };
+    const attrs = cloneRunAttrs(runAttrs);
+    if (attrs && Object.keys(attrs).length) {
+      if (attrs.runProperties == null) delete attrs.runProperties;
+      if (Object.keys(attrs).length) runNodeResult.attrs = attrs;
+    }
+    if (runLevelMarks.length) {
+      runNodeResult.marks = runLevelMarks.map((mark) => cloneMark$1(mark));
+    }
+    return runNodeResult;
+  };
+  const decode$m = (params2, decodedAttrs = {}) => {
+    const { node } = params2 || {};
+    if (!node) return void 0;
+    const { runNode: runNodeForExport, trackingMarksByType } = prepareRunTrackingContext(node);
+    const runAttrs = runNodeForExport.attrs || {};
+    const runProperties = Array.isArray(runAttrs.runProperties) ? runAttrs.runProperties : [];
+    const exportParams = { ...params2, node: runNodeForExport };
+    if (!exportParams.editor) {
+      exportParams.editor = { extensionService: { extensions: [] } };
+    }
+    const childElements = translateChildNodes(exportParams) || [];
+    let runPropertiesElement = createRunPropertiesElement(runProperties);
+    const markElements = processOutputMarks(Array.isArray(runNodeForExport.marks) ? runNodeForExport.marks : []);
+    if (markElements.length) {
+      if (!runPropertiesElement) {
+        runPropertiesElement = generateRunProps(markElements);
+      } else {
+        if (!Array.isArray(runPropertiesElement.elements)) runPropertiesElement.elements = [];
+        const existingNames = new Set(
+          runPropertiesElement.elements.map((el) => el?.name).filter((name) => typeof name === "string")
+        );
+        markElements.forEach((element) => {
+          if (!element || !element.name || existingNames.has(element.name)) return;
+          runPropertiesElement.elements.push({ ...element, attributes: { ...element.attributes || {} } });
+          existingNames.add(element.name);
+        });
+      }
+    }
+    const runPropsTemplate = runPropertiesElement ? cloneXmlNode(runPropertiesElement) : null;
+    const applyBaseRunProps = (runNode) => applyRunPropertiesTemplate(runNode, runPropsTemplate);
+    const runs = [];
+    childElements.forEach((child) => {
+      if (!child) return;
+      if (child.name === "w:r") {
+        const clonedRun = cloneXmlNode(child);
+        applyBaseRunProps(clonedRun);
+        runs.push(clonedRun);
+        return;
+      }
+      if (child.name === "w:hyperlink") {
+        const hyperlinkClone = cloneXmlNode(child);
+        if (Array.isArray(hyperlinkClone.elements)) {
+          hyperlinkClone.elements.forEach((run2) => applyBaseRunProps(run2));
+        }
+        runs.push(hyperlinkClone);
+        return;
+      }
+      if (child.name === "w:ins" || child.name === "w:del") {
+        const trackedClone = cloneXmlNode(child);
+        if (Array.isArray(trackedClone.elements)) {
+          trackedClone.elements.forEach((element) => {
+            if (element?.name === "w:r") applyBaseRunProps(element);
+          });
+        }
+        runs.push(trackedClone);
+        return;
+      }
+      const runWrapper = { name: XML_NODE_NAME$f, elements: [] };
+      applyBaseRunProps(runWrapper);
+      if (!Array.isArray(runWrapper.elements)) runWrapper.elements = [];
+      runWrapper.elements.push(cloneXmlNode(child));
+      runs.push(runWrapper);
+    });
+    const trackedRuns = ensureTrackedWrapper(runs, trackingMarksByType);
+    if (!trackedRuns.length) {
+      const emptyRun = { name: XML_NODE_NAME$f, elements: [] };
+      applyBaseRunProps(emptyRun);
+      trackedRuns.push(emptyRun);
+    }
+    if (decodedAttrs && Object.keys(decodedAttrs).length) {
+      trackedRuns.forEach((run2) => {
+        run2.attributes = { ...run2.attributes || {}, ...decodedAttrs };
+      });
+    }
+    if (trackedRuns.length === 1) {
+      return trackedRuns[0];
+    }
+    return trackedRuns;
+  };
   const config$d = {
     xmlName: XML_NODE_NAME$f,
-    sdNodeOrKeyName: SD_NODE_NAME$a,
+    sdNodeOrKeyName: SD_KEY_NAME,
     type: NodeTranslator.translatorTypes.NODE,
     encode: encode$m,
     decode: decode$m,
@@ -34259,17 +35518,52 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const { nodes, docx, nodeListHandler } = params2;
     const node = nodes[0];
     let href = _resolveHref(docx, encodedAttrs);
-    const linkMark = { type: "link", attrs: { ...encodedAttrs, href } };
+    const linkMark = { attrs: { ...encodedAttrs, href } };
     const runNodes = node.elements.filter((el) => el.name === "w:r");
     runNodes.forEach((runNode) => {
-      runNode.marks = [...runNode.marks || [], linkMark];
+      const existingRunMarks = Array.isArray(runNode.marks) ? runNode.marks : [];
+      const runMarksWithoutLink = existingRunMarks.filter((mark) => mark?.type !== "link");
+      runNode.marks = runMarksWithoutLink;
     });
     const updatedNode = nodeListHandler.handler({
       ...params2,
       nodes: runNodes,
       path: [...params2.path || [], node]
     });
-    return updatedNode;
+    const cloneMark2 = (mark) => {
+      if (!mark || typeof mark !== "object") return mark;
+      if (!mark.attrs) return { ...mark };
+      return { ...mark, attrs: { ...mark.attrs } };
+    };
+    const ensureLinkMark = (child) => {
+      if (!child || typeof child !== "object") return child;
+      if (Array.isArray(child.content)) {
+        const updatedContent = child.content.map((item) => ensureLinkMark(item));
+        if (updatedContent !== child.content) {
+          child = { ...child, content: updatedContent };
+        }
+      }
+      if (child.type === "run") {
+        const existingMarks2 = Array.isArray(child.marks) ? child.marks : [];
+        const filteredMarks = existingMarks2.filter((mark) => mark?.type !== "link").map((mark) => cloneMark2(mark));
+        if (filteredMarks.length !== existingMarks2.length) {
+          if (filteredMarks.length) child = { ...child, marks: filteredMarks };
+          else {
+            const { marks, ...rest } = child;
+            child = rest;
+          }
+        }
+        return child;
+      }
+      if (child.type !== "text") return child;
+      const existingMarks = Array.isArray(child.marks) ? child.marks.map((mark) => cloneMark2(mark)) : [];
+      const hasLink = existingMarks.some((mark) => mark?.type === "link");
+      if (hasLink) return child;
+      const linkClone = { type: "link", attrs: { ...linkMark.attrs } };
+      return { ...child, marks: [...existingMarks, linkClone] };
+    };
+    if (!Array.isArray(updatedNode)) return updatedNode;
+    return updatedNode.map((child) => ensureLinkMark(child));
   };
   const _resolveHref = (docx, encodedAttrs) => {
     const rels = docx["word/_rels/document.xml.rels"];
@@ -35200,176 +36494,30 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     attributes: validXmlAttributes$4
   };
   const translator$4 = NodeTranslator.from(config$4);
-  const encode$a = (attributes) => {
-    return attributes["w:id"];
-  };
-  const decode$a = (attrs) => {
-    return attrs.id;
-  };
-  const attrConfig$6 = Object.freeze({
-    xmlName: "w:id",
-    sdName: "id",
-    encode: encode$a,
-    decode: decode$a
-  });
-  const encode$9 = (attributes) => {
-    return attributes["w:name"];
-  };
-  const decode$9 = (attrs) => {
-    return attrs.name;
-  };
-  const attrConfig$5 = Object.freeze({
-    xmlName: "w:name",
-    sdName: "name",
-    encode: encode$9,
-    decode: decode$9
-  });
-  const encode$8 = (attributes) => {
-    return attributes["w:colFirst"];
-  };
-  const decode$8 = (attrs) => {
-    return attrs.colFirst;
-  };
-  const attrConfig$4 = Object.freeze({
-    xmlName: "w:colFirst",
-    sdName: "colFirst",
-    encode: encode$8,
-    decode: decode$8
-  });
-  const encode$7 = (attributes) => {
-    return attributes["w:colLast"];
-  };
-  const decode$7 = (attrs) => {
-    return attrs.colLast;
-  };
-  const attrConfig$3 = Object.freeze({
-    xmlName: "w:colLast",
-    sdName: "colLast",
-    encode: encode$7,
-    decode: decode$7
-  });
-  const encode$6 = (attributes) => {
-    return attributes["w:displacedByCustomXml"];
-  };
-  const decode$6 = (attrs) => {
-    return attrs.displacedByCustomXml;
-  };
-  const attrConfig$2 = Object.freeze({
-    xmlName: "w:displacedByCustomXml",
-    sdName: "displacedByCustomXml",
-    encode: encode$6,
-    decode: decode$6
-  });
-  const validXmlAttributes$3 = [attrConfig$6, attrConfig$5, attrConfig$4, attrConfig$3, attrConfig$2];
-  const XML_NODE_NAME$3 = "w:bookmarkStart";
-  const SD_NODE_NAME$3 = "bookmarkStart";
-  const encode$5 = (params2, encodedAttrs = {}) => {
-    return {
-      type: "bookmarkStart",
-      attrs: encodedAttrs
-    };
-  };
-  const decode$5 = (params2, decodedAttrs = {}) => {
-    const result = {
-      name: "w:bookmarkStart",
-      elements: []
-    };
-    if (decodedAttrs && Object.keys(decodedAttrs).length) {
-      result.attributes = decodedAttrs;
-    }
-    return result;
-  };
-  const config$3 = {
-    xmlName: XML_NODE_NAME$3,
-    sdNodeOrKeyName: SD_NODE_NAME$3,
-    type: NodeTranslator.translatorTypes.NODE,
-    encode: encode$5,
-    decode: decode$5,
-    attributes: validXmlAttributes$3
-  };
-  const translator$3 = NodeTranslator.from(config$3);
-  const encode$4 = (attributes) => {
-    return attributes["w:id"];
-  };
-  const decode$4 = (attrs) => {
-    return attrs.id;
-  };
-  const attrConfig$1 = Object.freeze({
-    xmlName: "w:id",
-    sdName: "id",
-    encode: encode$4,
-    decode: decode$4
-  });
-  const encode$3 = (attributes) => {
-    return attributes["w:displacedByCustomXml"];
-  };
-  const decode$3 = (attrs) => {
-    return attrs.displacedByCustomXml;
-  };
-  const attrConfig = Object.freeze({
-    xmlName: "w:displacedByCustomXml",
-    sdName: "displacedByCustomXml",
-    encode: encode$3,
-    decode: decode$3
-  });
-  const validXmlAttributes$2 = [attrConfig$1, attrConfig];
-  const XML_NODE_NAME$2 = "w:bookmarkEnd";
-  const SD_NODE_NAME$2 = "bookmarkEnd";
-  const encode$2 = (params2, encodedAttrs = {}) => {
-    return {
-      type: "bookmarkEnd",
-      attrs: encodedAttrs
-    };
-  };
-  const decode$2 = (params2, decodedAttrs = {}) => {
-    const result = {
-      name: "w:bookmarkEnd",
-      elements: []
-    };
-    if (decodedAttrs && Object.keys(decodedAttrs).length) {
-      result.attributes = decodedAttrs;
-    }
-    return result;
-  };
-  const config$2 = {
-    xmlName: XML_NODE_NAME$2,
-    sdNodeOrKeyName: SD_NODE_NAME$2,
-    type: NodeTranslator.translatorTypes.NODE,
-    encode: encode$2,
-    decode: decode$2,
-    attributes: validXmlAttributes$2
-  };
-  const translator$2 = NodeTranslator.from(config$2);
-  const registeredHandlers = Object.freeze({
-    "w:br": translator$V,
-    "w:tab": translator$U,
-    "w:p": translator$T,
-    "wp:anchor": translator$5,
-    "wp:inline": translator$4,
-    "w:bookmarkStart": translator$3,
-    "w:bookmarkEnd": translator$2
-  });
-  const XML_NODE_NAME$1 = "w:drawing";
-  const SD_NODE_NAME$1 = [];
-  const validXmlAttributes$1 = [];
-  function encode$1(params2) {
+  const XML_NODE_NAME$3 = "w:drawing";
+  const SD_NODE_NAME$3 = [];
+  const validXmlAttributes$3 = [];
+  function encode$a(params2) {
     const nodes = params2.nodes;
     const node = nodes[0];
-    const validChildTranslators = ["wp:anchor", "wp:inline"];
+    const translatorByChildName = {
+      "wp:anchor": translator$5,
+      "wp:inline": translator$4
+    };
     return node.elements.reduce((acc, child) => {
       if (acc) return acc;
-      if (!validChildTranslators.includes(child.name)) return acc;
-      const translator2 = registeredHandlers[child.name];
+      const translator2 = translatorByChildName[child.name];
+      if (!translator2) return acc;
       return translator2.encode({ ...params2, extraParams: { node: child } }) || acc;
     }, null);
   }
-  function decode$1(params2) {
+  function decode$a(params2) {
     const { node } = params2;
     if (!node || !node.type) {
       return null;
     }
-    const handlerName = node.attrs.isAnchor ? "wp:anchor" : "wp:inline";
-    const resultNode = registeredHandlers[handlerName].decode(params2);
+    const childTranslator = node.attrs.isAnchor ? translator$5 : translator$4;
+    const resultNode = childTranslator.decode(params2);
     return wrapTextInRun(
       {
         name: "w:drawing",
@@ -35378,15 +36526,15 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       []
     );
   }
-  const config$1 = {
-    xmlName: XML_NODE_NAME$1,
-    sdNodeOrKeyName: SD_NODE_NAME$1,
+  const config$3 = {
+    xmlName: XML_NODE_NAME$3,
+    sdNodeOrKeyName: SD_NODE_NAME$3,
     type: NodeTranslator.translatorTypes.NODE,
-    encode: encode$1,
-    decode: decode$1,
-    attributes: validXmlAttributes$1
+    encode: encode$a,
+    decode: decode$a,
+    attributes: validXmlAttributes$3
   };
-  const translator$1 = NodeTranslator.from(config$1);
+  const translator$3 = NodeTranslator.from(config$3);
   class CommandService {
     /**
      * @param {import('./commands/types/index.js').CommandServiceOptions} props
@@ -36724,7 +37872,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     return getTextNodeForExport(attrs.displayLabel, [...marks, ...marksFromAttrs], params2);
   }
   function prepareImageAnnotation(params2, imageSize) {
-    return translator$1.decode({
+    return translator$3.decode({
       ...params2,
       imageSize
     });
@@ -36961,10 +38109,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     };
     return result;
   }
-  const XML_NODE_NAME = "w:sdt";
-  const SD_NODE_NAME = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
-  const validXmlAttributes = [];
-  function encode$B(params2) {
+  const XML_NODE_NAME$2 = "w:sdt";
+  const SD_NODE_NAME$2 = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
+  const validXmlAttributes$2 = [];
+  function encode$9(params2) {
     const nodes = params2.nodes;
     const node = nodes[0];
     const { type: sdtType, handler: handler2 } = sdtNodeTypeStrategy(node);
@@ -36974,7 +38122,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const result = handler2(params2);
     return result;
   }
-  function decode(params2) {
+  function decode$9(params2) {
     const { node } = params2;
     if (!node || !node.type) {
       return null;
@@ -36990,44 +38138,193 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const result = decoder();
     return result;
   }
+  const config$2 = {
+    xmlName: XML_NODE_NAME$2,
+    sdNodeOrKeyName: SD_NODE_NAME$2,
+    type: NodeTranslator.translatorTypes.NODE,
+    encode: encode$9,
+    decode: decode$9,
+    attributes: validXmlAttributes$2
+  };
+  const translator$2 = NodeTranslator.from(config$2);
+  const encode$8 = (attributes) => {
+    return attributes["w:id"];
+  };
+  const decode$8 = (attrs) => {
+    return attrs.id;
+  };
+  const attrConfig$6 = Object.freeze({
+    xmlName: "w:id",
+    sdName: "id",
+    encode: encode$8,
+    decode: decode$8
+  });
+  const encode$7 = (attributes) => {
+    return attributes["w:name"];
+  };
+  const decode$7 = (attrs) => {
+    return attrs.name;
+  };
+  const attrConfig$5 = Object.freeze({
+    xmlName: "w:name",
+    sdName: "name",
+    encode: encode$7,
+    decode: decode$7
+  });
+  const encode$6 = (attributes) => {
+    return attributes["w:colFirst"];
+  };
+  const decode$6 = (attrs) => {
+    return attrs.colFirst;
+  };
+  const attrConfig$4 = Object.freeze({
+    xmlName: "w:colFirst",
+    sdName: "colFirst",
+    encode: encode$6,
+    decode: decode$6
+  });
+  const encode$5 = (attributes) => {
+    return attributes["w:colLast"];
+  };
+  const decode$5 = (attrs) => {
+    return attrs.colLast;
+  };
+  const attrConfig$3 = Object.freeze({
+    xmlName: "w:colLast",
+    sdName: "colLast",
+    encode: encode$5,
+    decode: decode$5
+  });
+  const encode$4 = (attributes) => {
+    return attributes["w:displacedByCustomXml"];
+  };
+  const decode$4 = (attrs) => {
+    return attrs.displacedByCustomXml;
+  };
+  const attrConfig$2 = Object.freeze({
+    xmlName: "w:displacedByCustomXml",
+    sdName: "displacedByCustomXml",
+    encode: encode$4,
+    decode: decode$4
+  });
+  const validXmlAttributes$1 = [attrConfig$6, attrConfig$5, attrConfig$4, attrConfig$3, attrConfig$2];
+  const XML_NODE_NAME$1 = "w:bookmarkStart";
+  const SD_NODE_NAME$1 = "bookmarkStart";
+  const encode$3 = (params2, encodedAttrs = {}) => {
+    return {
+      type: "bookmarkStart",
+      attrs: encodedAttrs
+    };
+  };
+  const decode$3 = (params2, decodedAttrs = {}) => {
+    const result = {
+      name: "w:bookmarkStart",
+      elements: []
+    };
+    if (decodedAttrs && Object.keys(decodedAttrs).length) {
+      result.attributes = decodedAttrs;
+    }
+    return result;
+  };
+  const config$1 = {
+    xmlName: XML_NODE_NAME$1,
+    sdNodeOrKeyName: SD_NODE_NAME$1,
+    type: NodeTranslator.translatorTypes.NODE,
+    encode: encode$3,
+    decode: decode$3,
+    attributes: validXmlAttributes$1
+  };
+  const translator$1 = NodeTranslator.from(config$1);
+  const encode$2 = (attributes) => {
+    return attributes["w:id"];
+  };
+  const decode$2 = (attrs) => {
+    return attrs.id;
+  };
+  const attrConfig$1 = Object.freeze({
+    xmlName: "w:id",
+    sdName: "id",
+    encode: encode$2,
+    decode: decode$2
+  });
+  const encode$1 = (attributes) => {
+    return attributes["w:displacedByCustomXml"];
+  };
+  const decode$1 = (attrs) => {
+    return attrs.displacedByCustomXml;
+  };
+  const attrConfig = Object.freeze({
+    xmlName: "w:displacedByCustomXml",
+    sdName: "displacedByCustomXml",
+    encode: encode$1,
+    decode: decode$1
+  });
+  const validXmlAttributes = [attrConfig$1, attrConfig];
+  const XML_NODE_NAME = "w:bookmarkEnd";
+  const SD_NODE_NAME = "bookmarkEnd";
+  const encode$18 = (params2, encodedAttrs = {}) => {
+    return {
+      type: "bookmarkEnd",
+      attrs: encodedAttrs
+    };
+  };
+  const decode = (params2, decodedAttrs = {}) => {
+    const result = {
+      name: "w:bookmarkEnd",
+      elements: []
+    };
+    if (decodedAttrs && Object.keys(decodedAttrs).length) {
+      result.attributes = decodedAttrs;
+    }
+    return result;
+  };
   const config = {
     xmlName: XML_NODE_NAME,
     sdNodeOrKeyName: SD_NODE_NAME,
     type: NodeTranslator.translatorTypes.NODE,
-    encode: encode$B,
+    encode: encode$18,
     decode,
     attributes: validXmlAttributes
   };
   const translator = NodeTranslator.from(config);
+  const isLineBreakOnlyRun = (node) => {
+    if (!node) return false;
+    if (node.type === "lineBreak" || node.type === "hardBreak") return true;
+    if (node.type !== "run") return false;
+    const runContent = Array.isArray(node.content) ? node.content : [];
+    if (!runContent.length) return false;
+    return runContent.every((child) => child?.type === "lineBreak" || child?.type === "hardBreak");
+  };
   function exportSchemaToJson(params2) {
     const { type: type2 } = params2.node || {};
     const router = {
       doc: translateDocumentNode,
       body: translateBodyNode,
       heading: translateHeadingNode,
-      paragraph: translator$T,
+      paragraph: translator$12,
+      run: translator$T,
       text: translateTextNode,
       bulletList: translateList,
       orderedList: translateList,
-      lineBreak: translator$V,
+      lineBreak: translator$15,
       table: translator$8,
       tableRow: translator$F,
       tableCell: translator$7,
-      bookmarkStart: translator$3,
-      bookmarkEnd: translator$2,
-      fieldAnnotation: translator,
-      tab: translator$U,
-      image: translator$1,
-      hardBreak: translator$V,
+      bookmarkStart: translator$1,
+      bookmarkEnd: translator,
+      fieldAnnotation: translator$2,
+      tab: translator$13,
+      image: translator$3,
+      hardBreak: translator$15,
       commentRangeStart: () => translateCommentNode(params2, "Start"),
       commentRangeEnd: () => translateCommentNode(params2, "End"),
       commentReference: () => null,
       shapeContainer: translateShapeContainer,
       shapeTextbox: translateShapeTextbox,
       contentBlock: translateContentBlock,
-      structuredContent: translator,
-      structuredContentBlock: translator,
-      documentSection: translator,
+      structuredContent: translator$2,
+      structuredContentBlock: translator$2,
+      documentSection: translator$2,
       "page-number": translatePageNumberNode,
       "total-page-number": translateTotalPageNumberNode
     };
@@ -37166,21 +38463,32 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       };
       pPrElements.push(spacingElement);
     }
-    if (indent && Object.values(indent).some((v2) => v2 !== 0)) {
-      const { left: left2, right: right2, firstLine, hanging } = indent;
+    const hasIndent = !!indent;
+    if (hasIndent) {
+      const { left: left2, right: right2, firstLine, hanging, explicitLeft, explicitRight, explicitFirstLine, explicitHanging } = indent;
       const attributes = {};
-      if (left2 || left2 === 0) attributes["w:left"] = pixelsToTwips(left2);
-      if (right2 || right2 === 0) attributes["w:right"] = pixelsToTwips(right2);
-      if (firstLine || firstLine === 0) attributes["w:firstLine"] = pixelsToTwips(firstLine);
-      if (hanging || hanging === 0) attributes["w:hanging"] = pixelsToTwips(hanging);
-      if (textIndent && !attributes["w:left"]) {
+      if (left2 !== void 0 && (left2 !== 0 || explicitLeft || textIndent)) {
+        attributes["w:left"] = pixelsToTwips(left2);
+      }
+      if (right2 !== void 0 && (right2 !== 0 || explicitRight)) {
+        attributes["w:right"] = pixelsToTwips(right2);
+      }
+      if (firstLine !== void 0 && (firstLine !== 0 || explicitFirstLine)) {
+        attributes["w:firstLine"] = pixelsToTwips(firstLine);
+      }
+      if (hanging !== void 0 && (hanging !== 0 || explicitHanging)) {
+        attributes["w:hanging"] = pixelsToTwips(hanging);
+      }
+      if (textIndent && attributes["w:left"] === void 0) {
         attributes["w:left"] = getTextIndentExportValue(textIndent);
       }
-      const indentElement = {
-        name: "w:ind",
-        attributes
-      };
-      pPrElements.push(indentElement);
+      if (Object.keys(attributes).length) {
+        const indentElement = {
+          name: "w:ind",
+          attributes
+        };
+        pPrElements.push(indentElement);
+      }
     } else if (textIndent && textIndent !== "0in") {
       const indentElement = {
         name: "w:ind",
@@ -37230,12 +38538,17 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (sectPr) {
       pPrElements.push(sectPr);
     }
+    const mapTabVal = (value) => {
+      if (!value || value === "start") return "left";
+      if (value === "end") return "right";
+      return value;
+    };
     const { tabStops } = attrs;
     if (tabStops && tabStops.length > 0) {
       const tabElements = tabStops.map((tab) => {
         const posValue = tab.originalPos !== void 0 ? tab.originalPos : pixelsToTwips(tab.pos).toString();
         const tabAttributes = {
-          "w:val": tab.val || "start",
+          "w:val": mapTabVal(tab.val),
           "w:pos": posValue
         };
         if (tab.leader) {
@@ -37590,6 +38903,11 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         collapsedParagraph.content.push(item);
       }
     });
+    collapsedParagraph.content = collapsedParagraph.content.filter((node, index2, nodes) => {
+      if (!isLineBreakOnlyRun(node)) return true;
+      const prevNode = nodes[index2 - 1];
+      return !(prevNode && isLineBreakOnlyRun(prevNode));
+    });
     return collapsedParagraph;
   };
   const restoreIndent = (indent) => {
@@ -37643,13 +38961,27 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         markElement.type = "element";
         break;
       case "italic":
-        delete markElement.attributes;
-        markElement.type = "element";
-        break;
-      case "underline":
+        if (attrs?.value && attrs.value !== "1" && attrs.value !== true) {
+          markElement.attributes["w:val"] = attrs.value;
+        } else {
+          delete markElement.attributes;
+        }
         markElement.type = "element";
-        markElement.attributes["w:val"] = attrs.underlineType;
         break;
+      case "underline": {
+        const translated = translator$$.decode({
+          node: {
+            attrs: {
+              underlineType: attrs.underlineType ?? attrs.underline ?? null,
+              underlineColor: attrs.underlineColor ?? attrs.color ?? null,
+              underlineThemeColor: attrs.underlineThemeColor ?? attrs.themeColor ?? null,
+              underlineThemeTint: attrs.underlineThemeTint ?? attrs.themeTint ?? null,
+              underlineThemeShade: attrs.underlineThemeShade ?? attrs.themeShade ?? null
+            }
+          }
+        });
+        return translated || {};
+      }
       // Text style cases
       case "fontSize":
         value = attrs.fontSize;
@@ -37667,13 +38999,21 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         markElement.name = "w:rStyle";
         markElement.attributes["w:val"] = attrs.styleId;
         break;
-      case "color":
-        let processedColor = attrs.color.replace(/^#/, "").replace(/;$/, "");
+      case "color": {
+        const rawColor = attrs.color;
+        if (!rawColor) break;
+        const normalized = String(rawColor).trim().toLowerCase();
+        if (normalized === "inherit") {
+          markElement.attributes["w:val"] = "auto";
+          break;
+        }
+        let processedColor = String(rawColor).replace(/^#/, "").replace(/;$/, "");
         if (processedColor.startsWith("rgb")) {
           processedColor = rgbToHex(processedColor);
         }
         markElement.attributes["w:val"] = processedColor;
         break;
+      }
       case "textAlign":
         markElement.attributes["w:val"] = attrs.textAlign;
         break;
@@ -37691,12 +39031,11 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       case "lineHeight":
         markElement.attributes["w:line"] = linesToTwips(attrs.lineHeight);
         break;
-      case "highlight":
-        markElement.attributes["w:fill"] = attrs.color?.substring(1);
-        markElement.attributes["w:color"] = "auto";
-        markElement.attributes["w:val"] = "clear";
-        markElement.name = "w:shd";
-        break;
+      case "highlight": {
+        const highlightValue = attrs.color ?? attrs.highlight ?? null;
+        const translated = translator$14.decode({ node: { attrs: { highlight: highlightValue } } });
+        return translated || {};
+      }
     }
     return markElement;
   }
@@ -37827,8 +39166,8 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     return final;
   };
   replaceSpecialCharacters_fn = function(text) {
-    if (!text) return;
-    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+    if (text === void 0 || text === null) return text;
+    return String(text).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
   };
   generateXml_fn = function(node) {
     if (!node) return null;
@@ -37844,7 +39183,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     else tag += ">";
     let tags = [tag];
     if (!name && node.type === "text") {
-      return node.text;
+      return __privateMethod$2(this, _DocxExporter_instances, replaceSpecialCharacters_fn).call(this, node.text ?? "");
     }
     if (elements) {
       if (name === "w:instrText") {
@@ -37970,7 +39309,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (mainNode.name === "w:drawing") node = mainNode;
     else node = mainNode.elements.find((el) => el.name === "w:drawing");
     if (!node) return { nodes: [], consumed: 0 };
-    const schemaNode = translator$1.encode(params2);
+    const schemaNode = translator$3.encode(params2);
     const newNodes = schemaNode ? [schemaNode] : [];
     return { nodes: newNodes, consumed: 1 };
   };
@@ -38073,81 +39412,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     handler: handleTrackChangeNode
   };
   const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$6);
-  const handleRunNode = (params2) => {
-    const { nodes, nodeListHandler, parentStyleId, docx } = params2;
-    if (nodes.length === 0 || nodes[0].name !== "w:r") {
-      return { nodes: [], consumed: 0 };
-    }
-    const node = nodes[0];
-    const childParams = { ...params2, nodes: node.elements, path: [...params2.path || [], node] };
-    let processedRun = nodeListHandler.handler(childParams)?.filter((n) => n) || [];
-    const hasRunProperties = node.elements?.some((el) => el.name === "w:rPr");
-    const defaultNodeStyles = getMarksFromStyles(docx, parentStyleId);
-    if (hasRunProperties) {
-      const { marks = [] } = parseProperties(node);
-      let runStyleAttributes = [];
-      const runStyleElement = node.elements?.find((el) => el.name === "w:rPr")?.elements?.find((el) => el.name === "w:rStyle");
-      let runStyleId;
-      if (runStyleElement && runStyleElement.attributes?.["w:val"] && docx) {
-        runStyleId = runStyleElement.attributes["w:val"];
-        const runStyleDefinition = getMarksFromStyles(docx, runStyleId);
-        if (runStyleDefinition.marks && runStyleDefinition.marks.length > 0) {
-          runStyleAttributes = runStyleDefinition.marks;
-        }
-      }
-      let paragraphStyleAttributes = [];
-      if (defaultNodeStyles.marks) {
-        paragraphStyleAttributes = defaultNodeStyles.marks.filter((mark) => {
-          if (["bold"].includes(mark.type) && marks.find((m2) => m2.type === "bold")?.attrs?.value === "0") {
-            return false;
-          }
-          return true;
-        });
-      }
-      const combinedMarks = [...paragraphStyleAttributes];
-      runStyleAttributes.forEach((runStyle) => {
-        const exists2 = combinedMarks.some(
-          (mark) => mark.type === runStyle.type && JSON.stringify(mark.attrs || {}) === JSON.stringify(runStyle.attrs || {})
-        );
-        if (!exists2) {
-          combinedMarks.push(runStyle);
-        }
-      });
-      marks.forEach((mark) => {
-        const exists2 = combinedMarks.some(
-          (existing) => existing.type === mark.type && JSON.stringify(existing.attrs || {}) === JSON.stringify(mark.attrs || {})
-        );
-        if (!exists2) {
-          combinedMarks.push(mark);
-        }
-      });
-      if (runStyleId) combinedMarks.push({ type: "textStyle", attrs: { styleId: runStyleId } });
-      if (node.marks) combinedMarks.push(...node.marks);
-      const newMarks = createImportMarks(combinedMarks);
-      processedRun = processedRun.map((n) => {
-        const existingMarks = n.marks || [];
-        return {
-          ...n,
-          marks: [...newMarks, ...existingMarks]
-        };
-      });
-    }
-    return { nodes: processedRun, consumed: 1 };
-  };
-  const getMarksFromStyles = (docx, styleId) => {
-    const styles = docx?.["word/styles.xml"];
-    if (!styles) {
-      return {};
-    }
-    const styleTags = styles.elements[0].elements.filter((style22) => style22.name === "w:style");
-    const style2 = styleTags.find((tag) => tag.attributes["w:styleId"] === styleId) || {};
-    if (!style2) return {};
-    return parseProperties(style2);
-  };
-  const runNodeHandlerEntity = {
-    handlerName: "runNodeHandler",
-    handler: handleRunNode
-  };
+  const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$T);
   const handleTextNode = (params2) => {
     const { nodes, insideTrackChange } = params2;
     if (nodes.length === 0 || !(nodes[0].name === "w:t" || insideTrackChange && nodes[0].name === "w:delText")) {
@@ -38159,6 +39424,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     let text;
     if (elements.length === 1) {
       text = elements[0].text;
+      const xmlSpace = node.attributes?.["xml:space"] ?? elements[0]?.attributes?.["xml:space"];
+      if (xmlSpace !== "preserve" && typeof text === "string") {
+        text = text.replace(/^\s+/, "").replace(/\s+$/, "");
+      }
       text = text.replace(/\[\[sdspace\]\]/g, "");
     } else if (!elements.length && "attributes" in node && node.attributes["xml:space"] === "preserve") {
       text = " ";
@@ -38184,7 +39453,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (nodes.length === 0 || nodes[0].name !== "w:p") {
       return { nodes: [], consumed: 0 };
     }
-    const schemaNode = translator$T.encode(params2);
+    const schemaNode = translator$12.encode(params2);
     const newNodes = schemaNode ? [schemaNode] : [];
     return { nodes: newNodes, consumed: 1 };
   };
@@ -38197,7 +39466,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (nodes.length === 0 || nodes[0].name !== "w:sdt") {
       return { nodes: [], consumed: 0 };
     }
-    const result = translator.encode(params2);
+    const result = translator$2.encode(params2);
     if (!result) {
       return { nodes: [], consumed: 0 };
     }
@@ -38287,7 +39556,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (nodes.length === 0 || nodes[0].name !== "w:br") {
       return { nodes: [], consumed: 0 };
     }
-    const result = translator$V.encode(params2);
+    const result = translator$15.encode(params2);
     if (!result) return { nodes: [], consumed: 0 };
     return {
       nodes: [result],
@@ -38359,7 +39628,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (isCustomMarkBookmark(nodes[0], params2.editor)) {
       return handleBookmarkNode(params2);
     }
-    const node = translator$3.encode(params2);
+    const node = translator$1.encode(params2);
     if (!node) return { nodes: [], consumed: 0 };
     return { nodes: [node], consumed: 1 };
   };
@@ -38391,7 +39660,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (!nodes.length || nodes[0].name !== "w:bookmarkEnd") {
       return { nodes: [], consumed: 0 };
     }
-    const node = translator$2.encode(params2);
+    const node = translator.encode(params2);
     if (!node) return { nodes: [], consumed: 0 };
     return { nodes: [node], consumed: 1 };
   };
@@ -39003,7 +40272,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (!nodes.length || nodes[0].name !== "w:tab") {
       return { nodes: [], consumed: 0 };
     }
-    const node = translator$U.encode(params2);
+    const node = translator$13.encode(params2);
     return { nodes: [node], consumed: 1 };
   };
   const tabNodeEntityHandler = {
@@ -39452,6 +40721,16 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   };
   const HYPERLINK_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
   const HEADER_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header";
+  const FONT_FAMILY_FALLBACKS = Object.freeze({
+    swiss: "Arial, sans-serif",
+    roman: "Times New Roman, serif",
+    modern: "Courier New, monospace",
+    script: "cursive",
+    decorative: "fantasy",
+    system: "system-ui",
+    auto: "sans-serif"
+  });
+  const DEFAULT_GENERIC_FALLBACK = "sans-serif";
   const _SuperConverter = class _SuperConverter2 {
     constructor(params2 = null) {
       __privateAdd$2(this, _SuperConverter_instances);
@@ -39487,6 +40766,31 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       this.documentId = params2?.documentId || null;
       if (this.docx.length || this.xml) this.parseFromXml();
     }
+    static getFontTableEntry(docx, fontName) {
+      if (!docx || !fontName) return null;
+      const fontTable = docx["word/fontTable.xml"];
+      if (!fontTable?.elements?.length) return null;
+      const fontsNode = fontTable.elements.find((el) => el.name === "w:fonts");
+      if (!fontsNode?.elements?.length) return null;
+      return fontsNode.elements.find((el) => el?.attributes?.["w:name"] === fontName) || null;
+    }
+    static getFallbackFromFontTable(docx, fontName) {
+      const fontEntry = _SuperConverter2.getFontTableEntry(docx, fontName);
+      const family = fontEntry?.elements?.find((child) => child.name === "w:family")?.attributes?.["w:val"];
+      if (!family) return null;
+      const mapped = FONT_FAMILY_FALLBACKS[family.toLowerCase()];
+      return mapped || DEFAULT_GENERIC_FALLBACK;
+    }
+    static toCssFontFamily(fontName, docx) {
+      if (!fontName) return fontName;
+      if (fontName.includes(",")) return fontName;
+      const fallback = _SuperConverter2.getFallbackFromFontTable(docx, fontName) || DEFAULT_GENERIC_FALLBACK;
+      const normalizedFallbackParts = fallback.split(",").map((part) => part.trim().toLowerCase()).filter(Boolean);
+      if (normalizedFallbackParts.includes(fontName.trim().toLowerCase())) {
+        return fallback;
+      }
+      return `${fontName}, ${fallback}`;
+    }
     /**
      * Get the DocxHelpers object that contains utility functions for working with docx files.
      * @returns {import('./docx-helpers/docx-helpers.js').DocxHelpers} The DocxHelpers object.
@@ -39583,13 +40887,19 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         if (rPrDefaults) {
           const rPr = rPrDefaults.elements?.find((el) => el.name === "w:rPr");
           const fonts = rPr?.elements?.find((el) => el.name === "w:rFonts");
-          typeface = fonts?.attributes["w:ascii"];
-          const fontSize2 = typeface ?? rPr?.elements?.find((el) => el.name === "w:sz")?.attributes["w:val"];
-          fontSizeNormal = !fontSizeNormal && fontSize2 ? Number(fontSize2) / 2 : null;
+          if (fonts?.attributes?.["w:ascii"]) {
+            typeface = fonts.attributes["w:ascii"];
+          }
+          const fontSizeRaw = rPr?.elements?.find((el) => el.name === "w:sz")?.attributes?.["w:val"];
+          if (!fontSizeNormal && fontSizeRaw) {
+            fontSizeNormal = Number(fontSizeRaw) / 2;
+          }
         }
-        const fontSizePt = fontSizeNormal || Number(rElements.find((el) => el.name === "w:sz")?.attributes["w:val"]) / 2 || 10;
+        const fallbackSz = Number(rElements.find((el) => el.name === "w:sz")?.attributes?.["w:val"]);
+        const fontSizePt = fontSizeNormal ?? (Number.isFinite(fallbackSz) ? fallbackSz / 2 : void 0) ?? 10;
         const kern = rElements.find((el) => el.name === "w:kern")?.attributes["w:val"];
-        return { fontSizePt, kern, typeface, panose };
+        const fontFamilyCss = _SuperConverter2.toCssFontFamily(typeface, this.convertedXml);
+        return { fontSizePt, kern, typeface, panose, fontFamilyCss };
       }
     }
     getDocumentFonts() {
@@ -51426,6 +52736,96 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (isActive2) return commands2.unsetMark(type2, { extendEmptyMarkRange });
     return commands2.setMark(type2, attrs);
   };
+  const toggleMarkCascade = (markName, options = {}) => ({ state: state2, chain, editor }) => {
+    const {
+      negationAttrs = { value: "0" },
+      isNegation = (attrs) => attrs?.value === "0",
+      styleDetector = defaultStyleDetector,
+      extendEmptyMarkRange = true
+    } = options;
+    const selectionMarks = getMarksFromSelection(state2) || [];
+    const inlineMarks = selectionMarks.filter((m2) => m2.type?.name === markName);
+    const hasNegation = inlineMarks.some((m2) => isNegation(m2.attrs || {}));
+    const hasInline = inlineMarks.some((m2) => !isNegation(m2.attrs || {}));
+    const styleOn = styleDetector({ state: state2, 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: state2, selectionMarks, markName, editor }) {
+    try {
+      const styleId = getEffectiveStyleId(state2, 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 style2 = styles.find((s) => s.id === current);
+        const def2 = style2?.definition?.styles || {};
+        if (key2 in def2) {
+          const raw = def2[key2];
+          if (raw === void 0) return true;
+          const val = raw?.value ?? raw;
+          return isStyleTokenEnabled(val);
+        }
+        current = style2?.definition?.attrs?.basedOn || null;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  function getEffectiveStyleId(state2, selectionMarks) {
+    const sidFromMarks = getStyleIdFromMarks(selectionMarks);
+    if (sidFromMarks) return sidFromMarks;
+    const $from = state2.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((m2) => m2.type?.name === "textStyle" && m2.attrs?.styleId);
+    if (ts) return ts.attrs.styleId;
+    const pos = state2.selection.$from.pos;
+    const $pos = state2.doc.resolve(pos);
+    for (let d2 = $pos.depth; d2 >= 0; d2--) {
+      const n = $pos.node(d2);
+      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((m2) => m2.type?.name === "textStyle" && m2.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: state2, tr, dispatch }) => {
     const { selection } = tr;
     const { ranges } = selection;
@@ -52771,11 +54171,14 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     command,
     createParagraphNear,
     decreaseListIndent,
+    defaultStyleDetector,
     deleteListItem,
     deleteSelection,
     exitCode,
     first,
+    getEffectiveStyleId,
     getParaCtx,
+    getStyleIdFromMarks,
     handleBackspaceNextToList,
     handleDeleteNextToList,
     increaseListIndent,
@@ -52784,12 +54187,14 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     insertTabChar,
     insertTabCharacter,
     insertTabNode,
+    isStyleTokenEnabled,
     joinBackward,
     joinDown,
     joinForward,
     joinUp,
     liftEmptyBlock,
     liftListItem,
+    mapMarkToStyleKey,
     nearestListAt,
     newlineInCode,
     rebuildListNodeWithNewNum,
@@ -52809,6 +54214,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     splitListItem,
     toggleList,
     toggleMark,
+    toggleMarkCascade,
     toggleNode,
     undoInputRule,
     unsetAllMarks,
@@ -52824,6 +54230,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   });
   const handleEnter = (editor) => {
     return editor.commands.first(({ commands: commands2 }) => [
+      () => commands2.splitRun(),
       () => commands2.newlineInCode(),
       () => commands2.createParagraphNear(),
       () => commands2.liftEmptyBlock(),
@@ -52857,6 +54264,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     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),
@@ -53934,7 +55342,18 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     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);
@@ -54012,7 +55431,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     currentPageNumber
   }) => {
     const parentStyles = editor.converter.getDocumentDefaultStyles();
-    const { fontSizePt, typeface } = parentStyles;
+    const { fontSizePt, typeface, fontFamilyCss } = parentStyles;
     const fontSizeInPixles = fontSizePt * 1.3333;
     const lineHeight2 = fontSizeInPixles * 1.2;
     Object.assign(editorContainer.style, {
@@ -54025,7 +55444,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       left: "0",
       width: "auto",
       maxWidth: "none",
-      fontFamily: typeface,
+      fontFamily: fontFamilyCss || typeface,
       fontSize: `${fontSizeInPixles}px`,
       lineHeight: `${lineHeight2}px`
     });
@@ -54855,7 +56274,6 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           originalStep,
           originalStepIndex
         });
-        console.debug("[track-changes]: replaceStep");
       } else if (step instanceof AddMarkStep) {
         addMarkStep({
           state: state2,
@@ -54865,7 +56283,6 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           user,
           date
         });
-        console.debug("[track-changes]: addMarkStep");
       } else if (step instanceof RemoveMarkStep) {
         removeMarkStep({
           state: state2,
@@ -54875,10 +56292,8 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           user,
           date
         });
-        console.debug("[track-changes]: removeMarkStep");
       } else {
         newTr.step(step);
-        console.log("[track-changes]: otherStep");
       }
     });
     if (tr.getMeta("inputType")) {
@@ -56948,9 +58363,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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`;
@@ -57238,12 +58654,15 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     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);
@@ -58317,6 +59736,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     },
     addCommands() {
       return {
+        toggleMarkCascade,
         /**
          * Clear all formatting (nodes and marks)
          * @category Command
@@ -59296,27 +60716,69 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       return {};
     }
   });
-  const RunItem = Node$1.create({
+  const splitRun = () => (props) => {
+    const { state: state2, view, tr } = props;
+    const { $from, empty: empty2 } = state2.selection;
+    if (!empty2) return false;
+    if ($from.parent.type.name !== "run") return false;
+    const handled = splitBlock(state2, (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$/;
@@ -59591,6 +61053,115 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       ];
     }
   });
+  const generateOrderedListIndex = ({ listLevel, lvlText, listNumberingType, customFormat }) => {
+    const handler2 = listIndexMap[listNumberingType];
+    return handler2 ? handler2(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, (p2) => intToAlpha(p2));
+  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 suffix2 = suffixes[(value - 20) % 10] || suffixes[value] || suffixes[0];
+    const p2 = level + suffix2;
+    return p2;
+  };
+  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;
@@ -59871,6 +61442,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         case "textStyle":
           const { fontFamily: fontFamily2, fontSize: fontSize2 } = attr.attrs;
           styles += `${fontFamily2 ? `font-family: ${fontFamily2};` : ""} ${fontSize2 ? `font-size: ${fontSize2};` : ""}`;
+          break;
       }
     }
     return styles.trim();
@@ -59889,12 +61461,22 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     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$2(k);
       const flattenedMarks = [];
@@ -59909,6 +61491,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         }
         flattenedMarks.push({ key: n.type.name, value: n.attrs[key2] });
       });
+      const underlineNone = node?.marks?.some((m2) => m2.type?.name === "underline" && m2.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 || {});
@@ -59925,10 +61511,28 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           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((m2) => m2.type?.name === "bold" && m2.attrs?.value === "0");
+          const hasInlineBoldOn = node.marks?.some((m2) => m2.type?.name === "bold" && m2.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((m2) => m2.type?.name === "italic" && m2.attrs?.value === "0");
+          const hasInlineItalicOn = node.marks?.some((m2) => m2.type?.name === "italic" && m2.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((m2) => m2.type?.name === "strike" && m2.attrs?.value === "0");
+          const hasInlineStrikeOn = node.marks?.some(
+            (m2) => m2.type?.name === "strike" && (m2.attrs?.value === void 0 || m2.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;
@@ -59937,10 +61541,44 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           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((m2) => m2.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(
+            (m2) => m2.type?.name === "underline" && m2.attrs?.underlineType === "none"
+          );
+          const hasInlineUnderlineOn = node.marks?.some(
+            (m2) => m2.type?.name === "underline" && m2.attrs?.underlineType && m2.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 d2 = decl.trim();
+                if (!d2) return;
+                const idx = d2.indexOf(":");
+                if (idx === -1) return;
+                const k2 = d2.slice(0, idx).trim();
+                const v2 = d2.slice(idx + 1).trim();
+                markValue[k2] = v2;
+              });
+            }
+          }
         } else if (typeof value === "string") {
           markValue[key2] = value;
         }
@@ -60073,23 +61711,51 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   };
   const generateDecorations = (state2, styles) => {
     const decorations = [];
-    let lastStyleId = null;
     const doc2 = state2?.doc;
+    const getParagraphStyleId = (pos) => {
+      const $pos = state2.doc.resolve(pos);
+      for (let d2 = $pos.depth; d2 >= 0; d2--) {
+        const n = $pos.node(d2);
+        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 = state2.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);
@@ -60218,115 +61884,298 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       };
     }
   });
-  const generateOrderedListIndex = ({ listLevel, lvlText, listNumberingType, customFormat }) => {
-    const handler2 = listIndexMap[listNumberingType];
-    return handler2 ? handler2(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, (p2) => intToAlpha(p2));
-  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 suffix2 = suffixes[(value - 20) % 10] || suffixes[value] || suffixes[0];
-    const p2 = level + suffix2;
-    return p2;
-  };
-  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: type2 = "single", color = null, thickness = null, approximate = true } = {}) {
+    const parts = [];
+    const add = (k, v2) => {
+      if (!v2) return;
+      parts.push(`${k}: ${v2}`);
+    };
+    const lower = String(type2 || "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: state2 } = editor.view;
+    const $pos = state2.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((m2) => m2.type === textStyleType) : [];
+    const sizeMark = styleMarks.find((m2) => m2.attrs?.fontSize);
+    const familyMark = styleMarks.find((m2) => m2.attrs?.fontFamily);
+    let fontSize2 = defaultSize;
+    if (sizeMark) {
+      const [value, unit = "pt"] = parseSizeUnit(sizeMark.attrs.fontSize);
+      if (!Number.isNaN(value)) {
+        fontSize2 = `${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) {
+        fontSize2 = sizeFromList;
+        hasSize = true;
       }
-      tempNum = Math.floor(tempNum / 10);
-      unitIndex++;
-      if (unitIndex > 3) break;
     }
-    if (num >= 10 && num < 20) {
-      result = result.replace(/^一十/, "十");
+    let fontFamily2 = familyMark?.attrs?.fontFamily ?? defaultFont;
+    let hasFamily = Boolean(familyMark);
+    if (!hasFamily && listRunProperties) {
+      const fontFromList = parseFontFamilyFromRunProperties(listRunProperties);
+      if (fontFromList) {
+        fontFamily2 = fontFromList;
+        hasFamily = true;
+      }
     }
-    return result;
-  };
+    let lineHeight2 = 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) fontSize2 = aFontSize;
+        if (!familyMark && aFontFamily) fontFamily2 = aFontFamily;
+      }
+    }
+    return {
+      fontSize: fontSize2,
+      fontFamily: fontFamily2,
+      lineHeight: lineHeight2,
+      hasSize,
+      hasFamily
+    };
+  }
+  function getStylesFromLinkedStyles({ node, pos, editor }) {
+    const { state: state2 } = editor.view;
+    const linkedStyles = LinkedStylesPluginKey.getState(state2)?.decorations;
+    const decorationsInPlace = linkedStyles?.find(pos, pos + node.nodeSize);
+    const predicates = [
+      (style22) => style22.includes("font-size") && style22.includes("font-family"),
+      (style22) => style22.includes("font-size"),
+      (style22) => style22.includes("font-family")
+    ];
+    let styleDeco;
+    for (const predicateFn of predicates) {
+      styleDeco = decorationsInPlace?.find((dec) => {
+        const style22 = dec.type?.attrs?.style || "";
+        return style22 && predicateFn(style22);
+      });
+      if (styleDeco) break;
+    }
+    const style2 = styleDeco?.type?.attrs?.style;
+    const stylesArray = style2?.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;
@@ -60344,8 +62193,8 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       this.decorations = decorations;
       this.view = editor.view;
       this.getPos = getPos;
-      activeListItemNodeViews.add(this);
       __privateMethod$1(this, _ListItemNodeView_instances, init_fn2).call(this);
+      activeListItemNodeViews.add(this);
     }
     refreshIndentStyling() {
       const { attrs } = this.node;
@@ -60388,10 +62237,12 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     update(node, decorations) {
       this.node = node;
       this.decorations = decorations;
-      const { fontSize: fontSize2, fontFamily: fontFamily2, lineHeight: lineHeight2 } = getTextStyleMarksFromLinkedStyles({
+      const { fontSize: fontSize2, fontFamily: fontFamily2, lineHeight: lineHeight2 } = resolveListItemTypography({
         node,
         pos: this.getPos(),
-        editor: this.editor
+        editor: this.editor,
+        nodeView: this,
+        activeNodeViews: activeListItemNodeViews
       });
       this.dom.style.fontSize = fontSize2;
       this.dom.style.fontFamily = fontFamily2 || "inherit";
@@ -60420,10 +62271,12 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       }
     }
     const pos = this.getPos();
-    const { fontSize: fontSize2, fontFamily: fontFamily2, lineHeight: lineHeight2 } = getTextStyleMarksFromLinkedStyles({
+    const { fontSize: fontSize2, fontFamily: fontFamily2, lineHeight: lineHeight2 } = 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";
@@ -60456,79 +62309,6 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       }
     });
   }
-  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((m2) => m2.type === textStyleType);
-    const sizeMark = styleMarks.find((m2) => m2.attrs.fontSize);
-    const familyMark = styleMarks.find((m2) => m2.attrs.fontFamily);
-    const lineHeight2 = allAttrs.lineHeight;
-    let fontSize2 = sizeMark ? (() => {
-      const [value, unit = "pt"] = parseSizeUnit(sizeMark.attrs.fontSize);
-      return Number.isNaN(value) ? defaultSize : `${value}${unit}`;
-    })() : defaultSize;
-    let fontFamily2 = 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) fontSize2 = aFontSize;
-        if (!familyMark && aFontFamily) fontFamily2 = aFontFamily;
-      }
-    }
-    return { fontSize: fontSize2, fontFamily: fontFamily2, lineHeight: lineHeight2 };
-  }
-  const getStylesFromLinkedStyles = ({ node, pos, editor }) => {
-    const { state: state2 } = editor.view;
-    const linkedStyles = LinkedStylesPluginKey.getState(state2)?.decorations;
-    const decorationsInPlace = linkedStyles?.find(pos, pos + node.nodeSize);
-    const predicates = [
-      (style22) => style22.includes("font-size") && style22.includes("font-family"),
-      (style22) => style22.includes("font-size"),
-      (style22) => style22.includes("font-family")
-    ];
-    let styleDeco;
-    for (const predicateFn of predicates) {
-      styleDeco = decorationsInPlace?.find((dec) => {
-        const style22 = dec.type.attrs?.style || "";
-        return style22 && predicateFn(style22);
-      });
-      if (styleDeco) break;
-    }
-    const style2 = styleDeco?.type.attrs?.style;
-    const stylesArray = style2?.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);
@@ -61262,6 +63042,211 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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, cache2) {
+    for (let depth = $pos.depth; depth >= 0; depth--) {
+      const node = $pos.node(depth);
+      if (node?.type?.name === "paragraph") {
+        const startPos = $pos.start(depth);
+        if (!cache2.has(startPos)) {
+          cache2.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 cache2.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 i2 = fromIndex; i2 < flattened.length; i2++) {
+      if (flattened[i2]?.node?.type?.name === "tab") {
+        return i2;
+      }
+    }
+    return -1;
+  }
+  function findDecimalBreakPos(flattened, startIndex, breakChar) {
+    for (let i2 = startIndex; i2 < flattened.length; i2++) {
+      const entry = flattened[i2];
+      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 range2 = document.createRange();
+      const fromRef = view.domAtPos(from2);
+      const toRef2 = view.domAtPos(to);
+      range2.setStart(fromRef.node, fromRef.offset);
+      range2.setEnd(toRef2.node, toRef2.offset);
+      const rect = range2.getBoundingClientRect();
+      range2.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 range2 = document.createRange();
+        range2.setStart(ref2.node, ref2.offset);
+        range2.setEnd(ref2.node, ref2.offset);
+        const rect = range2.getBoundingClientRect();
+        range2.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 fontSize2 = parseInt(parentTextStyleMark?.attrs.fontSize) * ptToPxRatio || defaultFontSize;
+    return `${fontSize2 * defaultLineHeight}px`;
+  }
   const TabNode = Node$1.create({
     name: "tab",
     group: "inline",
@@ -61299,8 +63284,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       };
     },
     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"),
@@ -61310,10 +63294,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           },
           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 };
@@ -61353,8 +63334,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
             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 };
@@ -61369,156 +63349,6 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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 style2 = window.getComputedStyle(styleReference);
-    temp.style.cssText = `
-        position: absolute;
-        top: -9999px;
-        left: -9999px;
-        white-space: nowrap;
-        font-family: ${style2.fontFamily};
-        font-size: ${style2.fontSize};
-        font-weight: ${style2.fontWeight};
-        font-style: ${style2.fontStyle};
-        letter-spacing: ${style2.letterSpacing};
-        word-spacing: ${style2.wordSpacing};
-        text-transform: ${style2.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 i2 = 0; i2 < endIndex; i2++) {
-      const node = parent.child(i2);
-      if (i2 >= 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 fontSize2 = parseInt(parentTextStyleMark?.attrs.fontSize) * ptToPxRatio || defaultFontSize;
-    return `${fontSize2 * defaultLineHeight}px`;
-  }
   const LineBreak = Node$1.create({
     name: "lineBreak",
     group: "inline",
@@ -67185,10 +69015,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         },
         padding: {
           default: {},
-          renderDOM: ({ size: size2 = {}, padding, marginOffset, transformData }) => {
+          renderDOM: ({ size: size2 = {}, padding, marginOffset, transformData = {} }) => {
             let { left: left2 = 0, top: top2 = 0, bottom: bottom2 = 0, right: right2 = 0 } = padding ?? {};
-            const { rotation } = transformData ?? {};
-            const { height, width } = size2 ?? {};
+            const { rotation } = transformData;
+            const { height, width } = size2;
             if (rotation && height && width) {
               const { horizontal, vertical } = getRotationMargins(width, height, rotation);
               left2 += horizontal;
@@ -68979,6 +70809,30 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       };
     }
   });
+  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() {
@@ -69009,9 +70863,18 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       ];
     },
     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
@@ -69020,21 +70883,21 @@ Please report this to https://github.com/markedjs/marked.`, e) {
          * 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() {
@@ -69051,6 +70914,22 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         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" },
@@ -69060,9 +70939,18 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       ];
     },
     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
@@ -69070,21 +70958,21 @@ Please report this to https://github.com/markedjs/marked.`, e) {
          * @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() {
@@ -69109,7 +70997,16 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       ];
     },
     renderDOM({ htmlAttributes }) {
-      return ["u", Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+      const merged = Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+      const type2 = merged?.underlineType;
+      const color = merged?.underlineColor;
+      const css = getUnderlineCssString({ type: type2, color });
+      const { style: style2, ...rest } = merged || {};
+      const styleString = [style2, css].filter(Boolean).join("; ");
+      if (type2 === "none") {
+        return ["span", { ...rest, ...styleString ? { style: styleString } : {} }, 0];
+      }
+      return ["u", { ...rest, ...styleString ? { style: styleString } : {} }, 0];
     },
     addAttributes() {
       return {
@@ -69119,10 +71016,18 @@ Please report this to https://github.com/markedjs/marked.`, e) {
          */
         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
@@ -69131,7 +71036,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
          * @example
          * setUnderline()
          */
-        setUnderline: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+        setUnderline,
         /**
          * Remove underline formatting
          * @category Command
@@ -69139,7 +71044,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
          * @example
          * unsetUnderline()
          */
-        unsetUnderline: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+        unsetUnderline,
         /**
          * Toggle underline formatting
          * @category Command
@@ -69147,7 +71052,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
          * @example
          * toggleUnderline()
          */
-        toggleUnderline: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+        toggleUnderline
       };
     },
     addShortcuts() {
@@ -69235,9 +71140,18 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       ];
     },
     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
@@ -69245,26 +71159,38 @@ Please report this to https://github.com/markedjs/marked.`, e) {
          * @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 {};
+          }
         }
       };
     },
@@ -75405,7 +77331,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       Paragraph,
       LineBreak,
       HardBreak,
-      RunItem,
+      Run,
       SlashMenu,
       Strike,
       TabNode,
@@ -88633,6 +90559,38 @@ ${style2}
     documentViewingModeDescription: "View clean version of document only",
     linkedStyles: "Linked styles"
   };
+  const isOffValue = (value) => {
+    if (value == null) return false;
+    const normalized = String(value).toLowerCase();
+    return normalized === "0" || normalized === "false" || normalized === "off";
+  };
+  const negationChecks = {
+    bold: (attrs = {}) => isOffValue(attrs.value),
+    italic: (attrs = {}) => isOffValue(attrs.value),
+    strike: (attrs = {}) => isOffValue(attrs.value),
+    underline: (attrs = {}) => {
+      const type2 = attrs.underlineType ?? attrs.value;
+      if (type2 == null) return false;
+      const normalized = String(type2).toLowerCase();
+      return normalized === "none" || isOffValue(normalized);
+    },
+    color: (attrs = {}) => {
+      const value = attrs.color;
+      if (value == null) return true;
+      return String(value).toLowerCase() === "inherit";
+    },
+    highlight: (attrs = {}) => {
+      const value = attrs.color;
+      if (value == null) return true;
+      const normalized = String(value).toLowerCase();
+      return normalized === "transparent" || normalized === "none";
+    }
+  };
+  const isNegatedMark = (name, attrs = {}) => {
+    const checker = negationChecks[name];
+    if (typeof checker !== "function") return false;
+    return Boolean(checker(attrs));
+  };
   class SuperToolbar extends EventEmitter$1 {
     /**
      * Creates a new SuperToolbar instance
@@ -88726,10 +90684,14 @@ ${style2}
          * @param {string} params.argument - The color to set
          * @returns {void}
          */
-        setColor: ({ item, argument }) => {
-          __privateMethod(this, _SuperToolbar_instances, runCommandWithArgumentOnly_fn).call(this, { item, argument }, () => {
-            this.activeEditor?.commands.setFieldAnnotationsTextColor(argument, true);
-          });
+        setColor: ({ argument }) => {
+          if (!argument || !this.activeEditor) return;
+          const isNone = argument === "none";
+          const value = isNone ? "inherit" : argument;
+          if (this.activeEditor?.commands?.setColor) this.activeEditor.commands.setColor(value);
+          const argValue = isNone ? null : argument;
+          this.activeEditor?.commands.setFieldAnnotationsTextColor(argValue, true);
+          this.updateToolbarState();
         },
         /**
          * Sets the highlight color for text
@@ -88738,12 +90700,14 @@ ${style2}
          * @param {string} params.argument - The highlight color to set
          * @returns {void}
          */
-        setHighlight: ({ item, argument }) => {
-          __privateMethod(this, _SuperToolbar_instances, runCommandWithArgumentOnly_fn).call(this, { item, argument, noArgumentCallback: true }, () => {
-            let arg = argument !== "none" ? argument : null;
-            this.activeEditor?.commands.setFieldAnnotationsTextHighlight(arg, true);
-            this.activeEditor?.commands.setCellBackground(arg);
-          });
+        setHighlight: ({ argument }) => {
+          if (!argument || !this.activeEditor) return;
+          const inlineColor = argument !== "none" ? argument : "transparent";
+          if (this.activeEditor?.commands?.setHighlight) this.activeEditor.commands.setHighlight(inlineColor);
+          const argValue = argument !== "none" ? argument : null;
+          this.activeEditor?.commands.setFieldAnnotationsTextHighlight(argValue, true);
+          this.activeEditor?.commands.setCellBackground(argValue);
+          this.updateToolbarState();
         },
         /**
          * Toggles the ruler visibility
@@ -89060,14 +91024,16 @@ ${style2}
             return item.activate();
           }
         }
-        const activeMark = marks.find((mark) => mark.name === item.name.value);
+        const rawActiveMark = marks.find((mark) => mark.name === item.name.value);
+        const markNegated = rawActiveMark ? isNegatedMark(rawActiveMark.name, rawActiveMark.attrs) : false;
+        const activeMark = markNegated ? null : rawActiveMark;
         if (activeMark) {
           item.activate(activeMark.attrs);
         } else {
           item.deactivate();
         }
         const styleIdMark = marks.find((mark) => mark.name === "styleId");
-        if (!activeMark && styleIdMark?.attrs.styleId) {
+        if (!activeMark && !markNegated && styleIdMark?.attrs.styleId) {
           const markToStyleMap = {
             fontSize: "font-size",
             fontFamily: "font-family",
@@ -89125,7 +91091,6 @@ ${style2}
       if (!command2) {
         return;
       }
-      this.log("(emmitCommand) Command:", command2, "\n	item:", item, "\n	argument:", argument, "\n	option:", option);
       if (command2 in __privateGet(this, _interceptedCommands)) {
         return __privateGet(this, _interceptedCommands)[command2]({ item, argument });
       }
@@ -90688,6 +92653,36 @@ ${style2}
     }
   };
   const SuperInput = /* @__PURE__ */ _export_sfc$1(_sfc_main$i, [["__scopeId", "data-v-4d5cff52"]]);
+  const baseHandlers = {
+    ...runPropertyTranslators,
+    "w:br": translator$15,
+    "w:cantSplit": translator$S,
+    "w:cnfStyle": translator$R,
+    "w:divId": translator$Q,
+    "w:gridAfter": translator$P,
+    "w:gridBefore": translator$O,
+    "w:hidden": translator$N,
+    "w:hyperlink": translator$6,
+    "w:jc": translator$M,
+    "w:p": translator$12,
+    "w:r": translator$T,
+    "w:rPr": translator$U,
+    "w:sdt": translator$2,
+    "w:tab": translator$13,
+    "w:tblCellSpacing": translator$L,
+    "w:tblHeader": translator$K,
+    "w:tc": translator$7,
+    "w:tr": translator$F,
+    "w:trHeight": translator$J,
+    "w:trPr": translator$G,
+    "w:wAfter": translator$I,
+    "w:wBefore": translator$H,
+    "wp:anchor": translator$5,
+    "wp:inline": translator$4,
+    "w:bookmarkStart": translator$1,
+    "w:bookmarkEnd": translator
+  };
+  const registeredHandlers = Object.freeze(baseHandlers);
   const Extensions = {
     Node: Node$1,
     Attribute,
@@ -94076,7 +96071,6 @@ ${reason}`);
       }
       debounceTimers[commentId] = setTimeout(() => {
         if (superdoc2) {
-          if (__IS_DEBUG__) console.debug("[debounceEmit] tracked change update emitting...", event);
           superdoc2.emit("comments-update", event);
         }
         delete debounceTimers[commentId];
@@ -94084,7 +96078,6 @@ ${reason}`);
     };
     const showAddComment = (superdoc2) => {
       const event = { type: COMMENT_EVENTS.PENDING };
-      if (__IS_DEBUG__) console.debug("[showAddComment] emitting...", event);
       superdoc2.emit("comments-update", event);
       const selection = { ...superdocStore.activeSelection };
       selection.selectionBounds = { ...selection.selectionBounds };
@@ -94185,7 +96178,6 @@ ${reason}`);
       }
       const event = { type: COMMENT_EVENTS.ADD, comment: newComment.getValues() };
       syncCommentsToClients(superdoc2, event);
-      if (__IS_DEBUG__) console.debug("[addComment] emitting...", event);
       superdoc2.emit("comments-update", event);
     };
     const deleteComment = ({ commentId: commentIdToDelete, superdoc: superdoc2 }) => {
@@ -94202,7 +96194,6 @@ ${reason}`);
         comment: comment.getValues(),
         changes: [{ key: "deleted", commentId, fileId }]
       };
-      if (__IS_DEBUG__) console.debug("[deleteComment] emitting...", event);
       superdoc2.emit("comments-update", event);
       syncCommentsToClients(superdoc2, event);
     };
@@ -94211,7 +96202,6 @@ ${reason}`);
     };
     const processLoadedDocxComments = async ({ superdoc: superdoc2, editor, comments, documentId }) => {
       const document2 = superdocStore.getDocument(documentId);
-      if (__IS_DEBUG__) console.debug("[processLoadedDocxComments] processing comments...", comments);
       comments.forEach((comment) => {
         const htmlContent = getHTmlFromComment(comment.textJson);
         if (!htmlContent && !comment.trackedChange) {
@@ -94313,13 +96303,41 @@ ${reason}`);
       });
       return comments;
     });
+    const normalizeCommentForEditor = (node) => {
+      if (!node || typeof node !== "object") return node;
+      const cloneMarks = (marks) => Array.isArray(marks) ? marks.filter(Boolean).map((mark) => ({
+        ...mark,
+        attrs: mark?.attrs ? { ...mark.attrs } : void 0
+      })) : void 0;
+      const cloneAttrs = (attrs) => attrs && typeof attrs === "object" ? { ...attrs } : void 0;
+      if (!Array.isArray(node.content)) {
+        return {
+          type: node.type,
+          ...node.text !== void 0 ? { text: node.text } : {},
+          ...node.attrs ? { attrs: cloneAttrs(node.attrs) } : {},
+          ...node.marks ? { marks: cloneMarks(node.marks) } : {}
+        };
+      }
+      const normalizedChildren = node.content.map((child) => normalizeCommentForEditor(child)).flat().filter(Boolean);
+      if (node.type === "run") {
+        return normalizedChildren;
+      }
+      return {
+        type: node.type,
+        ...node.attrs ? { attrs: cloneAttrs(node.attrs) } : {},
+        ...node.marks ? { marks: cloneMarks(node.marks) } : {},
+        content: normalizedChildren
+      };
+    };
     const getHTmlFromComment = (commentTextJson) => {
       if (!commentTextJson.content?.length) return;
       try {
+        const normalizedContent = normalizeCommentForEditor(commentTextJson);
+        const schemaContent = Array.isArray(normalizedContent) ? normalizedContent[0] : normalizedContent;
         const editor = new Editor({
           mode: "text",
           isHeadless: true,
-          content: commentTextJson,
+          content: schemaContent,
           loadFromSchema: true,
           extensions: getRichTextExtensions()
         });