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

package/dist/chunks/{super-editor.es-BKurmwFy.es.js → super-editor.es-4Ig7dBJr.es.js}

@@ -14888,25 +14888,47 @@ const getContentTypesFromXml = (contentTypesXml) => {
   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;
@@ -24294,37 +24316,37 @@ const _NodeTranslator = class _NodeTranslator2 {
 };
 __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"
@@ -24334,7 +24356,7 @@ const encode$y = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$y = (params2, decodedAttrs) => {
+const decode$Y = (params2, decodedAttrs) => {
   const { node } = params2;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24351,63 +24373,125 @@ const decode$y = (params2, decodedAttrs) => {
   };
   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" };
@@ -24423,15 +24507,15 @@ const decode$u = (params2, decodedAttrs = {}) => {
   }
   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;
@@ -24606,17 +24690,21 @@ function getMarkValue(markType, attributes, docx) {
 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"];
@@ -24637,7 +24725,11 @@ function getHighLightValue(attributes) {
   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 {};
@@ -24667,27 +24759,39 @@ const getParagraphIndent = (node, docx, styleId = "") => {
     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) {
@@ -25026,102 +25130,102 @@ const handleParagraphNode$1 = (params2) => {
   }
   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) {
@@ -25129,7 +25233,7 @@ const encode$m = (params2, encodedAttrs = {}) => {
   }
   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) {
@@ -25137,9 +25241,1164 @@ const decode$m = (params2, decodedAttrs = {}) => {
   }
   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 map3 = /* @__PURE__ */ new Map();
+  markSets.filter(Boolean).forEach((marks) => {
+    marks.forEach((mark) => {
+      if (!mark || !mark.type) return;
+      map3.set(mark.type, mark.attrs ? { type: mark.type, attrs: { ...mark.attrs } } : { type: mark.type });
+    });
+  });
+  return Array.from(map3.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,
@@ -26517,17 +27776,52 @@ const encode$d = (params2, encodedAttrs) => {
   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"];
@@ -27458,176 +28752,30 @@ const config$4 = {
   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",
@@ -27636,15 +28784,15 @@ function decode$1(params2) {
     []
   );
 }
-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
@@ -28982,7 +30130,7 @@ function prepareTextAnnotation(params2) {
   return getTextNodeForExport(attrs.displayLabel, [...marks, ...marksFromAttrs], params2);
 }
 function prepareImageAnnotation(params2, imageSize) {
-  return translator$1.decode({
+  return translator$3.decode({
     ...params2,
     imageSize
   });
@@ -29219,10 +30367,10 @@ function translateStructuredContent(params2) {
   };
   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);
@@ -29232,7 +30380,7 @@ function encode$B(params2) {
   const result = handler2(params2);
   return result;
 }
-function decode(params2) {
+function decode$9(params2) {
   const { node } = params2;
   if (!node || !node.type) {
     return null;
@@ -29248,44 +30396,193 @@ function decode(params2) {
   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
   };
@@ -29424,21 +30721,32 @@ function generateParagraphProperties(node) {
     };
     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",
@@ -29488,12 +30796,17 @@ function generateParagraphProperties(node) {
   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) {
@@ -29848,6 +31161,11 @@ const convertMultipleListItemsIntoSingleNode = (listItem) => {
       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) => {
@@ -29901,13 +31219,27 @@ function translateMark(mark) {
       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;
@@ -29925,13 +31257,21 @@ function translateMark(mark) {
       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;
@@ -29949,12 +31289,11 @@ function translateMark(mark) {
     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;
 }
@@ -30085,8 +31424,8 @@ generate_xml_as_list_fn = function(data, debug = false) {
   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;
@@ -30102,7 +31441,7 @@ generateXml_fn = function(node) {
   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") {
@@ -30228,7 +31567,7 @@ const handleDrawingNode = (params2) => {
   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 };
 };
@@ -30331,81 +31670,7 @@ const trackChangeNodeHandlerEntity = {
   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")) {
@@ -30417,6 +31682,10 @@ const handleTextNode = (params2) => {
   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 = " ";
@@ -30442,7 +31711,7 @@ const handleParagraphNode = (params2) => {
   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 };
 };
@@ -30455,7 +31724,7 @@ const handleSdtNode = (params2) => {
   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 };
   }
@@ -30545,7 +31814,7 @@ const handler = (params2) => {
   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],
@@ -30617,7 +31886,7 @@ const handleBookmarkStartNode = (params2) => {
   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 };
 };
@@ -30649,7 +31918,7 @@ const handleBookmarkEndNode = (params2) => {
   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 };
 };
@@ -31288,7 +32557,7 @@ const handleTabNode = (params2) => {
   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 = {
@@ -31737,6 +33006,16 @@ const isAlternatingHeadersOddEven = (docx) => {
 };
 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);
@@ -31772,6 +33051,31 @@ const _SuperConverter = class _SuperConverter2 {
     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.
@@ -31868,13 +33172,19 @@ const _SuperConverter = class _SuperConverter2 {
       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() {
@@ -43711,6 +45021,96 @@ const toggleMark = (typeOrName, attrs = {}, options = {}) => ({ state: state2, c
   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 def = style2?.definition?.styles || {};
+      if (key2 in def) {
+        const raw = def[key2];
+        if (raw === void 0) return true;
+        const val = raw?.value ?? raw;
+        return isStyleTokenEnabled(val);
+      }
+      current = 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;
@@ -45056,11 +46456,14 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   command,
   createParagraphNear,
   decreaseListIndent,
+  defaultStyleDetector,
   deleteListItem,
   deleteSelection,
   exitCode,
   first,
+  getEffectiveStyleId,
   getParaCtx,
+  getStyleIdFromMarks,
   handleBackspaceNextToList,
   handleDeleteNextToList,
   increaseListIndent,
@@ -45069,12 +46472,14 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   insertTabChar,
   insertTabCharacter,
   insertTabNode,
+  isStyleTokenEnabled,
   joinBackward,
   joinDown,
   joinForward,
   joinUp,
   liftEmptyBlock,
   liftListItem,
+  mapMarkToStyleKey,
   nearestListAt,
   newlineInCode,
   rebuildListNodeWithNewNum,
@@ -45094,6 +46499,7 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   splitListItem,
   toggleList,
   toggleMark,
+  toggleMarkCascade,
   toggleNode,
   undoInputRule,
   unsetAllMarks,
@@ -45109,6 +46515,7 @@ const Commands = Extension.create({
 });
 const handleEnter = (editor) => {
   return editor.commands.first(({ commands: commands2 }) => [
+    () => commands2.splitRun(),
     () => commands2.newlineInCode(),
     () => commands2.createParagraphNear(),
     () => commands2.liftEmptyBlock(),
@@ -45142,6 +46549,7 @@ const Keymap = Extension.create({
   addShortcuts() {
     const baseKeymap = {
       Enter: () => handleEnter(this.editor),
+      "Shift-Enter": () => this.editor.commands.insertLineBreak(),
       "Mod-Enter": () => this.editor.commands.exitCode(),
       Backspace: () => handleBackspace(this.editor),
       "Mod-Backspace": () => handleBackspace(this.editor),
@@ -46219,7 +47627,18 @@ const updateYdocDocxData = async (editor, ydoc) => {
   ydoc = ydoc || editor.options.ydoc;
   if (!ydoc) return;
   const metaMap = ydoc.getMap("meta");
-  const docx = [...metaMap.get("docx")];
+  const docxValue = metaMap.get("docx");
+  let docx = [];
+  if (Array.isArray(docxValue)) {
+    docx = [...docxValue];
+  } else if (docxValue && typeof docxValue.toArray === "function") {
+    docx = docxValue.toArray();
+  } else if (docxValue && typeof docxValue[Symbol.iterator] === "function") {
+    docx = Array.from(docxValue);
+  }
+  if (!docx.length && Array.isArray(editor.options.content)) {
+    docx = [...editor.options.content];
+  }
   const newXml = await editor.exportDocx({ getUpdatedDocs: true });
   Object.keys(newXml).forEach((key2) => {
     const fileIndex = docx.findIndex((item) => item.name === key2);
@@ -46297,7 +47716,7 @@ const createHeaderFooterEditor = ({
   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, {
@@ -46310,7 +47729,7 @@ const createHeaderFooterEditor = ({
     left: "0",
     width: "auto",
     maxWidth: "none",
-    fontFamily: typeface,
+    fontFamily: fontFamilyCss || typeface,
     fontSize: `${fontSizeInPixles}px`,
     lineHeight: `${lineHeight2}px`
   });
@@ -47140,7 +48559,6 @@ const trackedTransaction = ({ tr, state: state2, user }) => {
         originalStep,
         originalStepIndex
       });
-      console.debug("[track-changes]: replaceStep");
     } else if (step instanceof AddMarkStep) {
       addMarkStep({
         state: state2,
@@ -47150,7 +48568,6 @@ const trackedTransaction = ({ tr, state: state2, user }) => {
         user,
         date
       });
-      console.debug("[track-changes]: addMarkStep");
     } else if (step instanceof RemoveMarkStep) {
       removeMarkStep({
         state: state2,
@@ -47160,10 +48577,8 @@ const trackedTransaction = ({ tr, state: state2, user }) => {
         user,
         date
       });
-      console.debug("[track-changes]: removeMarkStep");
     } else {
       newTr.step(step);
-      console.log("[track-changes]: otherStep");
     }
   });
   if (tr.getMeta("inputType")) {
@@ -49233,9 +50648,10 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
     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`;
@@ -49523,12 +50939,15 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
   }
   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);
@@ -50602,6 +52021,7 @@ const FormatCommands = Extension.create({
   },
   addCommands() {
     return {
+      toggleMarkCascade,
       /**
        * Clear all formatting (nodes and marks)
        * @category Command
@@ -51581,27 +53001,69 @@ const Text = Node$1.create({
     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,
-        "aria-label": "Run node"
+        keepOnSplit: true
+      },
+      rsidR: {
+        default: null,
+        rendered: false,
+        keepOnSplit: true
+      },
+      rsidRPr: {
+        default: null,
+        rendered: false,
+        keepOnSplit: true
+      },
+      rsidDel: {
+        default: null,
+        rendered: false,
+        keepOnSplit: true
       }
     };
+  },
+  addCommands() {
+    return {
+      splitRun
+    };
+  },
+  parseDOM() {
+    return [{ tag: "span[data-run]" }];
+  },
+  renderDOM({ htmlAttributes }) {
+    const base2 = Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+    return ["span", base2, 0];
   }
 });
 const inputRegex$1 = /^\s*([-+*])\s$/;
@@ -51876,6 +53338,115 @@ const OrderedList = Node$1.create({
     ];
   }
 });
+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, (p) => intToAlpha(p));
+const handleOrdinal = (path, lvlText) => generateNumbering(path, lvlText, ordinalFormatter);
+const handleCustom = (path, lvlText, customFormat) => generateFromCustom(path, lvlText, customFormat);
+const handleJapaneseCounting = (path, lvlText) => generateNumbering(path, lvlText, intToJapaneseCounting);
+const listIndexMap = {
+  decimal: handleDecimal,
+  lowerRoman: handleLowerRoman,
+  upperRoman: handleRoman,
+  lowerLetter: handleLowerAlpha,
+  upperLetter: handleAlpha,
+  ordinal: handleOrdinal,
+  custom: handleCustom,
+  japaneseCounting: handleJapaneseCounting
+};
+const createNumbering = (values, lvlText) => {
+  return values.reduce((acc, value, index2) => {
+    return value > 9 ? acc.replace(/^0/, "").replace(`%${index2 + 1}`, value) : acc.replace(`%${index2 + 1}`, value);
+  }, lvlText);
+};
+const generateNumbering = (path, lvlText, formatter) => {
+  const formattedValues = path.map(formatter);
+  return createNumbering(formattedValues, lvlText);
+};
+const ordinalFormatter = (level) => {
+  const suffixes = ["th", "st", "nd", "rd"];
+  const value = level % 100;
+  const suffix2 = suffixes[(value - 20) % 10] || suffixes[value] || suffixes[0];
+  const p = level + suffix2;
+  return p;
+};
+const generateFromCustom = (path, lvlText, customFormat) => {
+  if (customFormat !== "001, 002, 003, ...") return generateNumbering(path, lvlText, String);
+  const match = customFormat.match(/(\d+)/);
+  if (!match) throw new Error("Invalid format string: no numeric pattern found");
+  const sample = match[1];
+  const digitCount = sample.length;
+  const index2 = path.pop();
+  return String(index2).padStart(digitCount, "0");
+};
+const intToRoman = (num) => {
+  const romanNumeralMap = [
+    { value: 1e3, numeral: "M" },
+    { value: 900, numeral: "CM" },
+    { value: 500, numeral: "D" },
+    { value: 400, numeral: "CD" },
+    { value: 100, numeral: "C" },
+    { value: 90, numeral: "XC" },
+    { value: 50, numeral: "L" },
+    { value: 40, numeral: "XL" },
+    { value: 10, numeral: "X" },
+    { value: 9, numeral: "IX" },
+    { value: 5, numeral: "V" },
+    { value: 4, numeral: "IV" },
+    { value: 1, numeral: "I" }
+  ];
+  let result = "";
+  for (const { value, numeral } of romanNumeralMap) {
+    while (num >= value) {
+      result += numeral;
+      num -= value;
+    }
+  }
+  return result;
+};
+const intToAlpha = (num) => {
+  let result = "";
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  while (num > 0) {
+    let index2 = (num - 1) % 26;
+    result = alphabet[index2] + result;
+    num = Math.floor((num - 1) / 26);
+  }
+  return result;
+};
+const intToJapaneseCounting = (num) => {
+  const digits = ["", "一", "二", "三", "四", "五", "六", "七", "八", "九"];
+  const units = ["", "十", "百", "千"];
+  if (num === 0) return "零";
+  if (num < 10) return digits[num];
+  let result = "";
+  let tempNum = num;
+  let unitIndex = 0;
+  while (tempNum > 0) {
+    const digit = tempNum % 10;
+    if (digit !== 0) {
+      const digitStr = digit === 1 && unitIndex > 0 ? "" : digits[digit];
+      result = digitStr + (unitIndex > 0 ? units[unitIndex] : "") + result;
+    } else if (result && tempNum > 0) {
+      if (!result.startsWith("零") && tempNum % 100 !== 0) {
+        result = "零" + result;
+      }
+    }
+    tempNum = Math.floor(tempNum / 10);
+    unitIndex++;
+    if (unitIndex > 3) break;
+  }
+  if (num >= 10 && num < 20) {
+    result = result.replace(/^一十/, "十");
+  }
+  return result;
+};
 const CustomSelectionPluginKey = new PluginKey("CustomSelection");
 const handleClickOutside = (event, editor) => {
   const editorElem = editor?.options?.element;
@@ -52156,6 +53727,7 @@ const getMarksStyle = (attrs) => {
       case "textStyle":
         const { fontFamily: fontFamily2, fontSize: fontSize2 } = attr.attrs;
         styles += `${fontFamily2 ? `font-family: ${fontFamily2};` : ""} ${fontSize2 ? `font-size: ${fontSize2};` : ""}`;
+        break;
     }
   }
   return styles.trim();
@@ -52174,12 +53746,22 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
   const linkedDefinitionStyles = { ...linkedStyle.definition.styles };
   const basedOnDefinitionStyles = { ...basedOnStyle?.definition?.styles };
   const resultStyles = { ...linkedDefinitionStyles };
-  if (!linkedDefinitionStyles["font-size"] && basedOnDefinitionStyles["font-size"]) {
-    resultStyles["font-size"] = basedOnDefinitionStyles["font-size"];
-  }
-  if (!linkedDefinitionStyles["text-transform"] && basedOnDefinitionStyles["text-transform"]) {
-    resultStyles["text-transform"] = basedOnDefinitionStyles["text-transform"];
-  }
+  const inheritKeys = [
+    "font-size",
+    "font-family",
+    "text-transform",
+    "bold",
+    "italic",
+    "underline",
+    "strike",
+    "color",
+    "highlight"
+  ];
+  inheritKeys.forEach((k) => {
+    if (!linkedDefinitionStyles[k] && basedOnDefinitionStyles[k]) {
+      resultStyles[k] = basedOnDefinitionStyles[k];
+    }
+  });
   Object.entries(resultStyles).forEach(([k, value]) => {
     const key2 = kebabCase$1(k);
     const flattenedMarks = [];
@@ -52194,6 +53776,10 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
       }
       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 || {});
@@ -52210,10 +53796,28 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
         if (rightIndent) markValue["margin-right"] = rightIndent + "px";
         if (firstLine) markValue["text-indent"] = firstLine + "px";
       } else if (key2 === "bold" && node) {
-        const val = value?.value;
-        if (!listTypes.includes(node.type.name) && val !== "0") {
+        const boldValue = typeof value === "object" && value !== null ? value.value : value;
+        const hasInlineBoldOff = node.marks?.some((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;
@@ -52222,10 +53826,44 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
         if (!listTypes.includes(node.type.name)) {
           markValue[key2] = value;
         }
+      } else if (key2 === "font-family" && node) {
+        if (!listTypes.includes(node.type.name)) {
+          markValue[key2] = value;
+        }
       } else if (key2 === "color" && node) {
         if (!listTypes.includes(node.type.name)) {
           markValue[key2] = value;
         }
+      } else if (key2 === "highlight" && node) {
+        const hasInlineHighlight = node.marks?.some((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;
       }
@@ -52358,23 +53996,51 @@ const createLinkedStylesPlugin = (editor) => {
 };
 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);
@@ -52503,115 +54169,298 @@ const LinkedStyles = Extension.create({
     };
   }
 });
-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, (p) => intToAlpha(p));
-const handleOrdinal = (path, lvlText) => generateNumbering(path, lvlText, ordinalFormatter);
-const handleCustom = (path, lvlText, customFormat) => generateFromCustom(path, lvlText, customFormat);
-const handleJapaneseCounting = (path, lvlText) => generateNumbering(path, lvlText, intToJapaneseCounting);
-const listIndexMap = {
-  decimal: handleDecimal,
-  lowerRoman: handleLowerRoman,
-  upperRoman: handleRoman,
-  lowerLetter: handleLowerAlpha,
-  upperLetter: handleAlpha,
-  ordinal: handleOrdinal,
-  custom: handleCustom,
-  japaneseCounting: handleJapaneseCounting
-};
-const createNumbering = (values, lvlText) => {
-  return values.reduce((acc, value, index2) => {
-    return value > 9 ? acc.replace(/^0/, "").replace(`%${index2 + 1}`, value) : acc.replace(`%${index2 + 1}`, value);
-  }, lvlText);
-};
-const generateNumbering = (path, lvlText, formatter) => {
-  const formattedValues = path.map(formatter);
-  return createNumbering(formattedValues, lvlText);
-};
-const ordinalFormatter = (level) => {
-  const suffixes = ["th", "st", "nd", "rd"];
-  const value = level % 100;
-  const suffix2 = suffixes[(value - 20) % 10] || suffixes[value] || suffixes[0];
-  const p = level + suffix2;
-  return p;
-};
-const generateFromCustom = (path, lvlText, customFormat) => {
-  if (customFormat !== "001, 002, 003, ...") return generateNumbering(path, lvlText, String);
-  const match = customFormat.match(/(\d+)/);
-  if (!match) throw new Error("Invalid format string: no numeric pattern found");
-  const sample = match[1];
-  const digitCount = sample.length;
-  const index2 = path.pop();
-  return String(index2).padStart(digitCount, "0");
-};
-const intToRoman = (num) => {
-  const romanNumeralMap = [
-    { value: 1e3, numeral: "M" },
-    { value: 900, numeral: "CM" },
-    { value: 500, numeral: "D" },
-    { value: 400, numeral: "CD" },
-    { value: 100, numeral: "C" },
-    { value: 90, numeral: "XC" },
-    { value: 50, numeral: "L" },
-    { value: 40, numeral: "XL" },
-    { value: 10, numeral: "X" },
-    { value: 9, numeral: "IX" },
-    { value: 5, numeral: "V" },
-    { value: 4, numeral: "IV" },
-    { value: 1, numeral: "I" }
-  ];
-  let result = "";
-  for (const { value, numeral } of romanNumeralMap) {
-    while (num >= value) {
-      result += numeral;
-      num -= value;
+function getUnderlineCssString({ type: 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;
@@ -52629,8 +54478,8 @@ class ListItemNodeView {
     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;
@@ -52673,10 +54522,12 @@ class ListItemNodeView {
   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";
@@ -52705,10 +54556,12 @@ init_fn2 = function() {
     }
   }
   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";
@@ -52741,79 +54594,6 @@ function refreshAllListItemNodeViews() {
     }
   });
 }
-function getListItemTextStyleMarks(listItem, markType) {
-  let textStyleMarks = [];
-  let attrs = {};
-  listItem.forEach((childNode) => {
-    if (childNode.type.name !== "paragraph") return;
-    attrs.lineHeight = childNode.attrs.lineHeight;
-    childNode.forEach((textNode) => {
-      let isTextNode = textNode.type.name === "text";
-      let hasTextStyleMarks = markType.isInSet(textNode.marks);
-      if (isTextNode && hasTextStyleMarks) {
-        let marks = textNode.marks.filter((mark) => mark.type === markType);
-        textStyleMarks.push(...marks);
-      }
-    });
-  });
-  return {
-    marks: textStyleMarks,
-    attrs
-  };
-}
-function getTextStyleMarksFromLinkedStyles({ node, pos, editor }) {
-  const { font: defaultFont, size: defaultSize } = getStylesFromLinkedStyles({ node, pos, editor });
-  const textStyleType = getMarkType("textStyle", editor.schema);
-  const { marks: allMarks, attrs: allAttrs } = getListItemTextStyleMarks(node, textStyleType);
-  const styleMarks = allMarks.filter((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);
@@ -53547,6 +55327,211 @@ const CommentsMark = Mark2.create({
     return [CommentMarkName, Attribute2.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 i = fromIndex; i < flattened.length; i++) {
+    if (flattened[i]?.node?.type?.name === "tab") {
+      return i;
+    }
+  }
+  return -1;
+}
+function findDecimalBreakPos(flattened, startIndex, breakChar) {
+  for (let i = startIndex; i < flattened.length; i++) {
+    const entry = flattened[i];
+    if (!entry) break;
+    if (entry.node.type?.name === "tab") break;
+    if (entry.node.type?.name === "text") {
+      const index2 = entry.node.text?.indexOf(breakChar);
+      if (index2 !== void 0 && index2 !== -1) {
+        return entry.pos + index2 + 1;
+      }
+    }
+  }
+  return null;
+}
+function measureRangeWidth(view, from2, to) {
+  if (!Number.isFinite(from2) || !Number.isFinite(to) || to <= from2) return 0;
+  try {
+    const 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",
@@ -53584,8 +55569,7 @@ const TabNode = Node$1.create({
     };
   },
   addPmPlugins() {
-    const { view, schema } = this.editor;
-    const domSerializer = DOMSerializer.fromSchema(schema);
+    const { view } = this.editor;
     const tabPlugin = new Plugin({
       name: "tabPlugin",
       key: new PluginKey("tabPlugin"),
@@ -53595,10 +55579,7 @@ const TabNode = Node$1.create({
         },
         apply(tr, { decorations }, _oldState, newState) {
           if (!decorations) {
-            decorations = DecorationSet.create(
-              newState.doc,
-              getTabDecorations(newState.doc, StepMap.empty, view, domSerializer)
-            );
+            decorations = DecorationSet.create(newState.doc, getTabDecorations(newState.doc, view));
           }
           if (!tr.docChanged) {
             return { decorations };
@@ -53638,8 +55619,7 @@ const TabNode = Node$1.create({
           rangesToRecalculate.forEach(([start2, end2]) => {
             const oldDecorations = decorations.find(start2, end2);
             decorations = decorations.remove(oldDecorations);
-            const invertMapping = tr.mapping.invert();
-            const newDecorations = getTabDecorations(newState.doc, invertMapping, view, domSerializer, start2, end2);
+            const newDecorations = getTabDecorations(newState.doc, view, start2, end2);
             decorations = decorations.add(newState.doc, newDecorations);
           });
           return { decorations };
@@ -53654,156 +55634,6 @@ const TabNode = Node$1.create({
     return [tabPlugin];
   }
 });
-const defaultTabDistance = 48;
-const defaultLineLength = 816;
-const getTabDecorations = (doc2, invertMapping, view, domSerializer, from2 = 0, to = null) => {
-  if (!to) {
-    to = doc2.content.size;
-  }
-  const nodeWidthCache = {};
-  let decorations = [];
-  doc2.nodesBetween(from2, to, (node, pos, parent) => {
-    if (node.type.name === "tab") {
-      let extraStyles = "";
-      const $pos = doc2.resolve(pos);
-      const tabIndex = $pos.index($pos.depth);
-      const fistlineIndent = parent.attrs?.indent?.firstLine || 0;
-      const currentWidth = calcChildNodesWidth(
-        parent,
-        pos - $pos.parentOffset,
-        0,
-        tabIndex,
-        domSerializer,
-        view,
-        invertMapping,
-        nodeWidthCache
-      ) + fistlineIndent;
-      let tabWidth;
-      if ($pos.depth === 1 && parent.attrs.tabStops && parent.attrs.tabStops.length > 0) {
-        const tabStop = parent.attrs.tabStops.find((tabStop2) => tabStop2.pos > currentWidth && tabStop2.val !== "clear");
-        if (tabStop) {
-          tabWidth = tabStop.pos - currentWidth;
-          if (["end", "center"].includes(tabStop.val)) {
-            let nextTabIndex = tabIndex + 1;
-            while (nextTabIndex < parent.childCount && parent.child(nextTabIndex).type.name !== "tab") {
-              nextTabIndex++;
-            }
-            const tabSectionWidth = calcChildNodesWidth(
-              parent,
-              pos - $pos.parentOffset,
-              tabIndex,
-              nextTabIndex,
-              domSerializer,
-              view,
-              invertMapping,
-              nodeWidthCache
-            );
-            tabWidth -= tabStop.val === "end" ? tabSectionWidth : tabSectionWidth / 2;
-          } else if (["decimal", "num"].includes(tabStop.val)) {
-            const breakChar = ".";
-            let nodeIndex = tabIndex + 1;
-            let integralWidth = 0;
-            let nodePos = pos - $pos.parentOffset;
-            while (nodeIndex < parent.childCount) {
-              const node2 = parent.child(nodeIndex);
-              if (node2.type.name === "tab") {
-                break;
-              }
-              const oldPos = invertMapping.map(nodePos);
-              if (node2.type.name === "text" && node2.text.includes(breakChar)) {
-                const modifiedNode = node2.cut(0, node2.text.indexOf(breakChar));
-                integralWidth += calcNodeWidth(domSerializer, modifiedNode, view, oldPos);
-                break;
-              }
-              integralWidth += calcNodeWidth(domSerializer, node2, view, oldPos);
-              nodeWidthCache[nodePos] = integralWidth;
-              nodePos += node2.nodeSize;
-              nodeIndex += 1;
-            }
-            tabWidth -= integralWidth;
-          }
-          if (tabStop.leader) {
-            if (tabStop.leader === "dot") {
-              extraStyles += `border-bottom: 1px dotted black;`;
-            } else if (tabStop.leader === "heavy") {
-              extraStyles += `border-bottom: 2px solid black;`;
-            } else if (tabStop.leader === "hyphen") {
-              extraStyles += `border-bottom: 1px solid black;`;
-            } else if (tabStop.leader === "middleDot") {
-              extraStyles += `border-bottom: 1px dotted black; margin-bottom: 2px;`;
-            } else if (tabStop.leader === "underscore") {
-              extraStyles += `border-bottom: 1px solid black;`;
-            }
-          }
-        }
-      }
-      if (!tabWidth || tabWidth < 1) {
-        tabWidth = defaultTabDistance - currentWidth % defaultLineLength % defaultTabDistance;
-        if (tabWidth === 0) {
-          tabWidth = defaultTabDistance;
-        }
-      }
-      nodeWidthCache[pos] = tabWidth;
-      const tabHeight = calcTabHeight($pos);
-      decorations.push(
-        Decoration.node(pos, pos + node.nodeSize, {
-          style: `width: ${tabWidth}px; height: ${tabHeight};${extraStyles}`
-        })
-      );
-    }
-  });
-  return decorations;
-};
-function calcNodeWidth(domSerializer, node, view, oldPos) {
-  const oldDomNode = view.nodeDOM(oldPos);
-  const styleReference = oldDomNode ? oldDomNode.nodeName === "#text" ? oldDomNode.parentNode : oldDomNode : view.dom;
-  const temp = document.createElement("div");
-  const 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 i = 0; i < endIndex; i++) {
-    const node = parent.child(i);
-    if (i >= startIndex) {
-      if (!nodeWidthCache[pos]) {
-        nodeWidthCache[pos] = calcNodeWidth(domSerializer, node, view, invertMapping.map(pos));
-      }
-      width += nodeWidthCache[pos];
-    }
-    pos += node.nodeSize;
-  }
-  return width;
-}
-function calcTabHeight(pos) {
-  const ptToPxRatio = 1.333;
-  const defaultFontSize = 16;
-  const defaultLineHeight = 1.1;
-  const blockParent2 = pos.node(1);
-  const parentTextStyleMark = blockParent2.firstChild.marks.find((mark) => mark.type.name === "textStyle");
-  const fontSize2 = parseInt(parentTextStyleMark?.attrs.fontSize) * ptToPxRatio || defaultFontSize;
-  return `${fontSize2 * defaultLineHeight}px`;
-}
 const LineBreak = Node$1.create({
   name: "lineBreak",
   group: "inline",
@@ -59470,10 +61300,10 @@ const Image = Node$1.create({
       },
       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;
@@ -61264,6 +63094,30 @@ const TextStyle = Mark2.create({
     };
   }
 });
+function createCascadeToggleCommands({
+  markName,
+  setCommand,
+  unsetCommand,
+  toggleCommand,
+  negationAttrs,
+  isNegation,
+  extendEmptyMarkRange
+} = {}) {
+  if (!markName) throw new Error("createCascadeToggleCommands requires a markName");
+  const capitalized = markName.charAt(0).toUpperCase() + markName.slice(1);
+  const setName = setCommand ?? `set${capitalized}`;
+  const unsetName = unsetCommand ?? `unset${capitalized}`;
+  const toggleName = toggleCommand ?? `toggle${capitalized}`;
+  const cascadeOptions = {};
+  if (negationAttrs) cascadeOptions.negationAttrs = negationAttrs;
+  if (typeof isNegation === "function") cascadeOptions.isNegation = isNegation;
+  if (extendEmptyMarkRange !== void 0) cascadeOptions.extendEmptyMarkRange = extendEmptyMarkRange;
+  return {
+    [setName]: () => ({ commands: commands2 }) => commands2.setMark(markName),
+    [unsetName]: () => ({ commands: commands2 }) => commands2.unsetMark(markName),
+    [toggleName]: () => ({ commands: commands2 }) => commands2.toggleMarkCascade(markName, cascadeOptions)
+  };
+}
 const Bold = Mark2.create({
   name: "bold",
   addOptions() {
@@ -61294,9 +63148,18 @@ const Bold = Mark2.create({
     ];
   },
   renderDOM({ htmlAttributes }) {
-    return ["strong", Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+    const merged = Attribute2.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
@@ -61305,21 +63168,21 @@ const Bold = Mark2.create({
        * editor.commands.setBold()
        * @note '0' renders as normal weight
        */
-      setBold: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+      setBold,
       /**
        * Remove bold formatting
        * @category Command
        * @example
        * editor.commands.unsetBold()
        */
-      unsetBold: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+      unsetBold,
       /**
        * Toggle bold formatting
        * @category Command
        * @example
        * editor.commands.toggleBold()
        */
-      toggleBold: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+      toggleBold
     };
   },
   addShortcuts() {
@@ -61336,6 +63199,22 @@ const Italic = Mark2.create({
       htmlAttributes: {}
     };
   },
+  addAttributes() {
+    return {
+      /**
+       * @category Attribute
+       * @param {string} [value] - Italic toggle value ('0' renders as normal)
+       */
+      value: {
+        default: null,
+        renderDOM: (attrs) => {
+          if (!attrs.value) return {};
+          if (attrs.value === "0") return { style: "font-style: normal" };
+          return {};
+        }
+      }
+    };
+  },
   parseDOM() {
     return [
       { tag: "i" },
@@ -61345,9 +63224,18 @@ const Italic = Mark2.create({
     ];
   },
   renderDOM({ htmlAttributes }) {
-    return ["em", Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+    const merged = Attribute2.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
@@ -61355,21 +63243,21 @@ const Italic = Mark2.create({
        * @example
        * editor.commands.setItalic()
        */
-      setItalic: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+      setItalic,
       /**
        * Remove italic formatting
        * @category Command
        * @example
        * editor.commands.unsetItalic()
        */
-      unsetItalic: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+      unsetItalic,
       /**
        * Toggle italic formatting
        * @category Command
        * @example
        * editor.commands.toggleItalic()
        */
-      toggleItalic: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+      toggleItalic
     };
   },
   addShortcuts() {
@@ -61394,7 +63282,16 @@ const Underline = Mark2.create({
     ];
   },
   renderDOM({ htmlAttributes }) {
-    return ["u", Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+    const merged = Attribute2.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 {
@@ -61404,10 +63301,18 @@ const Underline = Mark2.create({
        */
       underlineType: {
         default: "single"
+      },
+      underlineColor: {
+        default: null
       }
     };
   },
   addCommands() {
+    const { setUnderline, unsetUnderline, toggleUnderline } = createCascadeToggleCommands({
+      markName: this.name,
+      negationAttrs: { underlineType: "none" },
+      isNegation: (attrs) => attrs?.underlineType === "none"
+    });
     return {
       /**
        * Apply underline formatting
@@ -61416,7 +63321,7 @@ const Underline = Mark2.create({
        * @example
        * setUnderline()
        */
-      setUnderline: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+      setUnderline,
       /**
        * Remove underline formatting
        * @category Command
@@ -61424,7 +63329,7 @@ const Underline = Mark2.create({
        * @example
        * unsetUnderline()
        */
-      unsetUnderline: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+      unsetUnderline,
       /**
        * Toggle underline formatting
        * @category Command
@@ -61432,7 +63337,7 @@ const Underline = Mark2.create({
        * @example
        * toggleUnderline()
        */
-      toggleUnderline: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+      toggleUnderline
     };
   },
   addShortcuts() {
@@ -61520,9 +63425,18 @@ const Strike = Mark2.create({
     ];
   },
   renderDOM({ htmlAttributes }) {
-    return ["s", Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+    const merged = Attribute2.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
@@ -61530,26 +63444,38 @@ const Strike = Mark2.create({
        * @example
        * editor.commands.setStrike()
        */
-      setStrike: () => ({ commands: commands2 }) => {
-        return commands2.setMark(this.name);
-      },
+      setStrike,
       /**
        * Remove strikethrough formatting
        * @category Command
        * @example
        * editor.commands.unsetStrike()
        */
-      unsetStrike: () => ({ commands: commands2 }) => {
-        return commands2.unsetMark(this.name);
-      },
+      unsetStrike,
       /**
        * Toggle strikethrough formatting
        * @category Command
        * @example
        * editor.commands.toggleStrike()
        */
-      toggleStrike: () => ({ commands: commands2 }) => {
-        return commands2.toggleMark(this.name);
+      toggleStrike
+    };
+  },
+  addAttributes() {
+    return {
+      /**
+       * @category Attribute
+       * @param {string} [value] - Strike toggle value ('0' renders as normal)
+       */
+      value: {
+        default: null,
+        renderDOM: (attrs) => {
+          if (!attrs.value) return {};
+          if (attrs.value === "0") {
+            return { style: "text-decoration: none" };
+          }
+          return {};
+        }
       }
     };
   },
@@ -67690,7 +69616,7 @@ const getStarterExtensions = () => {
     Paragraph,
     LineBreak,
     HardBreak,
-    RunItem,
+    Run,
     SlashMenu,
     Strike,
     TabNode,
@@ -80918,6 +82844,38 @@ const toolbarTexts = {
   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 EventEmitter2 {
   /**
    * Creates a new SuperToolbar instance
@@ -81011,10 +82969,14 @@ class SuperToolbar extends EventEmitter2 {
        * @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
@@ -81023,12 +82985,14 @@ class SuperToolbar extends EventEmitter2 {
        * @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
@@ -81345,14 +83309,16 @@ class SuperToolbar extends EventEmitter2 {
           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",
@@ -81410,7 +83376,6 @@ class SuperToolbar extends EventEmitter2 {
     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 });
     }
@@ -82973,6 +84938,36 @@ const _sfc_main = {
   }
 };
 const SuperInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__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: Attribute2,