@harbour-enterprises/superdoc 0.20.2 → 0.21.0-RC1

package/dist/chunks/{super-editor.es-Dzt_HBkR.cjs → super-editor.es-XC168Mlw.cjs}

@@ -14894,25 +14894,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;
@@ -24193,18 +24215,6 @@ const baseNumbering = {
     }
   ]
 };
-const sanitizeDocxMediaName = (value, fallback = "image") => {
-  if (!value) return fallback;
-  const sanitized = value.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return sanitized || fallback;
-};
-const getFallbackImageNameFromDataUri = (src = "", fallback = "image") => {
-  if (!src || typeof src !== "string") return fallback;
-  const [prefix2] = src.split(";");
-  const [, maybeType] = prefix2.split("/");
-  const extension = maybeType?.toLowerCase();
-  return extension ? `${fallback}.${extension}` : fallback;
-};
 const TranslatorTypes = Object.freeze({
   NODE: "node",
   ATTRIBUTE: "attribute"
@@ -24325,37 +24335,37 @@ const _NodeTranslator = class _NodeTranslator2 {
 };
 __publicField$2(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$j = (attributes) => {
+const encode$T = (attributes) => {
   return attributes["w:type"];
 };
-const decode$j = (attrs) => {
+const decode$K = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
-const attrConfig$b = Object.freeze({
+const attrConfig$z = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$j,
-  decode: decode$j
+  encode: encode$T,
+  decode: decode$K
 });
-const encode$i = (attributes) => {
+const encode$S = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$i = (attrs) => {
+const decode$J = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
-const attrConfig$a = Object.freeze({
+const attrConfig$y = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$i,
-  decode: decode$i
+  encode: encode$S,
+  decode: decode$J
 });
-const validXmlAttributes$6 = [attrConfig$b, attrConfig$a];
-const XML_NODE_NAME$7 = "w:br";
+const validXmlAttributes$h = [attrConfig$z, attrConfig$y];
+const XML_NODE_NAME$j = "w:br";
 const SD_NODE_NAME$6 = "lineBreak";
-const encode$h = (_2, encodedAttrs) => {
+const encode$R = (_2, encodedAttrs) => {
   const isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -24365,7 +24375,7 @@ const encode$h = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$h = (params2, decodedAttrs) => {
+const decode$I = (params2, decodedAttrs) => {
   const { node } = params2;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24382,63 +24392,120 @@ const decode$h = (params2, decodedAttrs) => {
   };
   return translated;
 };
-const config$7 = {
-  xmlName: XML_NODE_NAME$7,
+const config$j = {
+  xmlName: XML_NODE_NAME$j,
   sdNodeOrKeyName: SD_NODE_NAME$6,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$h,
-  decode: decode$h,
-  attributes: validXmlAttributes$6
+  encode: encode$R,
+  decode: decode$I,
+  attributes: validXmlAttributes$h
+};
+const translator$v = NodeTranslator.from(config$j);
+const encode$Q = (attributes) => attributes?.["w:val"];
+const decode$H = (attrs) => attrs?.highlight;
+const attrConfig$x = Object.freeze({
+  xmlName: "w:val",
+  sdName: "highlight",
+  encode: encode$Q,
+  decode: decode$H
+});
+const validXmlAttributes$g = [attrConfig$x];
+const XML_NODE_NAME$i = "w:highlight";
+const SD_ATTR_KEY$b = "highlight";
+const encode$P = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  const value = encodedAttrs.highlight ?? node?.attributes?.["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$i,
+    sdNodeOrKeyName: SD_ATTR_KEY$b,
+    attributes: { "w:val": value ?? null }
+  };
+};
+const decode$G = (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 || normalizedValue === "transparent" || normalizedValue === "none") {
+    return void 0;
+  }
+  const keyword = getDocxHighlightKeywordFromHex(highlightValue);
+  if (keyword) {
+    return {
+      name: XML_NODE_NAME$i,
+      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 config$i = {
+  xmlName: XML_NODE_NAME$i,
+  sdNodeOrKeyName: SD_ATTR_KEY$b,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$P,
+  decode: decode$G,
+  attributes: validXmlAttributes$g
 };
-const translator$j = NodeTranslator.from(config$7);
-const encode$g = (attributes) => {
+const translator$u = NodeTranslator.from(config$i);
+const encode$O = (attributes) => {
   return attributes["w:val"];
 };
-const decode$g = (attrs) => {
+const decode$F = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
-const attrConfig$9 = Object.freeze({
+const attrConfig$w = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$g,
-  decode: decode$g
+  encode: encode$O,
+  decode: decode$F
 });
-const encode$f = (attributes) => {
+const encode$N = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$f = (attrs) => {
+const decode$E = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
-const attrConfig$8 = Object.freeze({
+const attrConfig$v = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$f,
-  decode: decode$f
+  encode: encode$N,
+  decode: decode$E
 });
-const encode$e = (attributes) => {
+const encode$M = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$e = (attrs) => {
+const decode$D = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
-const attrConfig$7 = Object.freeze({
+const attrConfig$u = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$e,
-  decode: decode$e
+  encode: encode$M,
+  decode: decode$D
 });
-const validXmlAttributes$5 = [attrConfig$9, attrConfig$7, attrConfig$8];
-const XML_NODE_NAME$6 = "w:tab";
+const validXmlAttributes$f = [attrConfig$w, attrConfig$u, attrConfig$v];
+const XML_NODE_NAME$h = "w:tab";
 const SD_NODE_NAME$5 = "tab";
-const encode$d = (_2, encodedAttrs = {}) => {
+const encode$L = (_2, encodedAttrs = {}) => {
   const translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$d = (params2, decodedAttrs = {}) => {
+const decode$C = (params2, decodedAttrs = {}) => {
   const { node } = params2 || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24454,15 +24521,15 @@ const decode$d = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$6 = {
-  xmlName: XML_NODE_NAME$6,
+const config$h = {
+  xmlName: XML_NODE_NAME$h,
   sdNodeOrKeyName: SD_NODE_NAME$5,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$d,
-  decode: decode$d,
-  attributes: validXmlAttributes$5
+  encode: encode$L,
+  decode: decode$C,
+  attributes: validXmlAttributes$f
 };
-const translator$i = NodeTranslator.from(config$6);
+const translator$t = NodeTranslator.from(config$h);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -24637,17 +24704,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"];
@@ -24668,7 +24739,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 {};
@@ -25032,102 +25107,102 @@ const handleParagraphNode$1 = (params2) => {
   }
   return schemaNode;
 };
-const encode$c = (attributes) => {
+const encode$K = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$c = (attrs) => {
+const decode$B = (attrs) => {
   return attrs.rsidDel;
 };
-const attrConfig$6 = Object.freeze({
+const attrConfig$t = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$c,
-  decode: decode$c
+  encode: encode$K,
+  decode: decode$B
 });
-const encode$b = (attributes) => {
+const encode$J = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$b = (attrs) => {
+const decode$A = (attrs) => {
   return attrs.rsidP;
 };
-const attrConfig$5 = Object.freeze({
+const attrConfig$s = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$b,
-  decode: decode$b
+  encode: encode$J,
+  decode: decode$A
 });
-const encode$a = (attributes) => {
+const encode$I = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$a = (attrs) => {
+const decode$z = (attrs) => {
   return attrs.rsidR;
 };
-const attrConfig$4 = Object.freeze({
+const attrConfig$r = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$a,
-  decode: decode$a
+  encode: encode$I,
+  decode: decode$z
 });
-const encode$9 = (attributes) => {
+const encode$H = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$9 = (attrs) => {
+const decode$y = (attrs) => {
   return attrs.rsidRPr;
 };
-const attrConfig$3 = Object.freeze({
+const attrConfig$q = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$9,
-  decode: decode$9
+  encode: encode$H,
+  decode: decode$y
 });
-const encode$8 = (attributes) => {
+const encode$G = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$8 = (attrs) => {
+const decode$x = (attrs) => {
   return attrs.rsidRDefault;
 };
-const attrConfig$2 = Object.freeze({
+const attrConfig$p = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$8,
-  decode: decode$8
+  encode: encode$G,
+  decode: decode$x
 });
-const encode$7 = (attributes) => {
+const encode$F = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$7 = (attrs) => {
+const decode$w = (attrs) => {
   return attrs.paraId;
 };
-const attrConfig$1 = Object.freeze({
+const attrConfig$o = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$7,
-  decode: decode$7
+  encode: encode$F,
+  decode: decode$w
 });
-const encode$6 = (attributes) => {
+const encode$E = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$6 = (attrs) => {
+const decode$v = (attrs) => {
   return attrs.textId;
 };
-const attrConfig = Object.freeze({
+const attrConfig$n = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$6,
-  decode: decode$6
+  encode: encode$E,
+  decode: decode$v
 });
-const validXmlAttributes$4 = [
-  attrConfig$1,
-  attrConfig,
-  attrConfig$4,
-  attrConfig$2,
-  attrConfig$5,
-  attrConfig$3,
-  attrConfig$6
+const validXmlAttributes$e = [
+  attrConfig$o,
+  attrConfig$n,
+  attrConfig$r,
+  attrConfig$p,
+  attrConfig$s,
+  attrConfig$q,
+  attrConfig$t
 ];
-const XML_NODE_NAME$5 = "w:p";
+const XML_NODE_NAME$g = "w:p";
 const SD_NODE_NAME$4 = "paragraph";
-const encode$5 = (params2, encodedAttrs = {}) => {
+const encode$D = (params2, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params2);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25135,7 +25210,7 @@ const encode$5 = (params2, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$5 = (params2, decodedAttrs = {}) => {
+const decode$u = (params2, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params2);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25143,15 +25218,15 @@ const decode$5 = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$5 = {
-  xmlName: XML_NODE_NAME$5,
+const config$g = {
+  xmlName: XML_NODE_NAME$g,
   sdNodeOrKeyName: SD_NODE_NAME$4,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$5,
-  decode: decode$5,
-  attributes: validXmlAttributes$4
+  encode: encode$D,
+  decode: decode$u,
+  attributes: validXmlAttributes$e
 };
-const translator$h = NodeTranslator.from(config$5);
+const translator$s = NodeTranslator.from(config$g);
 const generateV2HandlerEntity = (handlerName, translator2) => ({
   handlerName,
   handler: (params2) => {
@@ -25258,13 +25333,13 @@ const integerToString = (value) => {
   const intValue = parseInteger(value);
   return intValue != void 0 ? String(intValue) : void 0;
 };
-const translator$g = NodeTranslator.from({
+const translator$r = NodeTranslator.from({
   xmlName: "w:cantSplit",
   sdNodeOrKeyName: "cantSplit",
   encode: ({ nodes }) => ["1", "true"].includes(nodes[0].attributes?.["w:val"] ?? "1"),
   decode: ({ node }) => node.attrs?.cantSplit ? {} : void 0
 });
-const translator$f = NodeTranslator.from({
+const translator$q = NodeTranslator.from({
   xmlName: "w:cnfStyle",
   sdNodeOrKeyName: "cnfStyle",
   attributes: [
@@ -25297,8 +25372,8 @@ const translator$f = NodeTranslator.from({
     return Object.keys(cnfStyleAttrs).length > 0 ? cnfStyleAttrs : void 0;
   }
 });
-const translator$e = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
-const translator$d = NodeTranslator.from(
+const translator$p = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
+const translator$o = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridAfter",
     null,
@@ -25307,7 +25382,7 @@ const translator$d = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$c = NodeTranslator.from(
+const translator$n = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridBefore",
     null,
@@ -25316,21 +25391,21 @@ const translator$c = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$b = NodeTranslator.from({
+const translator$m = NodeTranslator.from({
   xmlName: "w:hidden",
   sdNodeOrKeyName: "hidden",
   encode: ({ nodes }) => parseBoolean(nodes[0].attributes?.["w:val"] ?? "1"),
   decode: ({ node }) => node.attrs.hidden ? {} : void 0
 });
-const translator$a = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc"));
-const translator$9 = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "cellSpacing"));
-const translator$8 = NodeTranslator.from({
+const translator$l = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc"));
+const translator$k = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "cellSpacing"));
+const translator$j = NodeTranslator.from({
   xmlName: "w:tblHeader",
   sdNodeOrKeyName: "repeatHeader",
   encode: ({ nodes }) => parseBoolean(nodes[0].attributes?.["w:val"] ?? "1"),
   decode: ({ node }) => node.attrs.repeatHeader ? {} : void 0
 });
-const translator$7 = NodeTranslator.from({
+const translator$i = NodeTranslator.from({
   xmlName: "w:trHeight",
   sdNodeOrKeyName: "rowHeight",
   encode: ({ nodes }) => {
@@ -25357,11 +25432,11 @@ const translator$7 = NodeTranslator.from({
     return Object.keys(heightAttrs).length > 0 ? heightAttrs : void 0;
   }
 });
-const translator$6 = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
-const translator$5 = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
-const XML_NODE_NAME$4 = "w:trPr";
-const SD_ATTR_KEY = "tableRowProperties";
-const encode$4 = (params2) => {
+const translator$h = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
+const translator$g = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
+const XML_NODE_NAME$f = "w:trPr";
+const SD_ATTR_KEY$a = "tableRowProperties";
+const encode$C = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
   let attributes = {
@@ -25375,12 +25450,12 @@ const encode$4 = (params2) => {
   };
   return {
     type: NodeTranslator.translatorTypes.ATTRIBUTE,
-    xmlName: XML_NODE_NAME$4,
-    sdNodeOrKeyName: SD_ATTR_KEY,
+    xmlName: XML_NODE_NAME$f,
+    sdNodeOrKeyName: SD_ATTR_KEY$a,
     attributes
   };
 };
-const decode$4 = (params2) => {
+const decode$t = (params2) => {
   const { tableRowProperties = {} } = params2.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName, tableRowProperties);
   const newNode = {
@@ -25392,18 +25467,18 @@ const decode$4 = (params2) => {
   return newNode;
 };
 const propertyTranslators = [
-  translator$g,
-  translator$f,
-  translator$e,
-  translator$d,
-  translator$c,
-  translator$b,
-  translator$a,
-  translator$9,
-  translator$8,
-  translator$7,
-  translator$6,
-  translator$5
+  translator$r,
+  translator$q,
+  translator$p,
+  translator$o,
+  translator$n,
+  translator$m,
+  translator$l,
+  translator$k,
+  translator$j,
+  translator$i,
+  translator$h,
+  translator$g
 ];
 const propertyTranslatorsByXmlName = {};
 propertyTranslators.forEach((translator2) => {
@@ -25413,25 +25488,25 @@ const propertyTranslatorsBySdName = {};
 propertyTranslators.forEach((translator2) => {
   propertyTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
 });
-const config$4 = {
-  xmlName: XML_NODE_NAME$4,
-  sdNodeOrKeyName: SD_ATTR_KEY,
+const config$f = {
+  xmlName: XML_NODE_NAME$f,
+  sdNodeOrKeyName: SD_ATTR_KEY$a,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$4,
-  decode: decode$4
+  encode: encode$C,
+  decode: decode$t
 };
-const translator$4 = NodeTranslator.from(config$4);
-const XML_NODE_NAME$3 = "w:tr";
+const translator$f = NodeTranslator.from(config$f);
+const XML_NODE_NAME$e = "w:tr";
 const SD_NODE_NAME$3 = "tableRow";
-const validXmlAttributes$3 = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
+const validXmlAttributes$d = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
   (xmlName) => createAttributeHandler(xmlName)
 );
-const encode$3 = (params2, encodedAttrs) => {
+const encode$B = (params2, encodedAttrs) => {
   const { row, table } = params2.extraParams;
   let tableRowProperties = {};
   const tPr = row.elements.find((el) => el.name === "w:trPr");
   if (tPr) {
-    ({ attributes: tableRowProperties } = translator$4.encode({
+    ({ attributes: tableRowProperties } = translator$f.encode({
       ...params2,
       nodes: [tPr]
     }));
@@ -25444,7 +25519,7 @@ const encode$3 = (params2, encodedAttrs) => {
   let currentColumnIndex = 0;
   const content = cellNodes?.map((n) => {
     let columnWidth = gridColumnWidths?.[currentColumnIndex] || null;
-    const result = translator$2.encode({
+    const result = translator$d.encode({
       ...params2,
       extraParams: {
         ...params2.extraParams,
@@ -25475,7 +25550,7 @@ const _getGridColumnWidths = (tableNode) => {
   }) || [];
   return columnWidths;
 };
-const decode$3 = (params2, decodedAttrs) => {
+const decode$s = (params2, decodedAttrs) => {
   const { node } = params2;
   const elements = translateChildNodes(params2);
   if (node.attrs?.tableRowProperties) {
@@ -25487,7 +25562,7 @@ const decode$3 = (params2, decodedAttrs) => {
       }
     }
     tableRowProperties["cantSplit"] = node.attrs["cantSplit"];
-    const trPr = translator$4.decode({
+    const trPr = translator$f.decode({
       ...params2,
       node: { ...node, attrs: { ...node.attrs, tableRowProperties } }
     });
@@ -25499,15 +25574,15 @@ const decode$3 = (params2, decodedAttrs) => {
     elements
   };
 };
-const config$3 = {
-  xmlName: XML_NODE_NAME$3,
+const config$e = {
+  xmlName: XML_NODE_NAME$e,
   sdNodeOrKeyName: SD_NODE_NAME$3,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$3,
-  decode: decode$3,
-  attributes: validXmlAttributes$3
+  encode: encode$B,
+  decode: decode$s,
+  attributes: validXmlAttributes$d
 };
-const translator$3 = NodeTranslator.from(config$3);
+const translator$e = NodeTranslator.from(config$e);
 const handleAllTableNodes = (params2) => {
   const { nodes } = params2;
   if (nodes.length === 0) {
@@ -25571,7 +25646,7 @@ function handleTableNode(node, params2) {
   attrs["borders"] = borderData;
   const content = [];
   rows.forEach((row) => {
-    const result = translator$3.encode({
+    const result = translator$e.encode({
       ...params2,
       nodes: [row],
       extraParams: {
@@ -25952,10 +26027,10 @@ function generateCellMargins(cellMargins) {
   if (left2 != null) elements.push({ name: "w:left", attributes: { "w:w": pixelsToTwips(left2) } });
   return elements;
 }
-const XML_NODE_NAME$2 = "w:tc";
+const XML_NODE_NAME$d = "w:tc";
 const SD_NODE_NAME$2 = "tableCell";
-const validXmlAttributes$2 = [];
-function encode$2(params2, encodedAttrs) {
+const validXmlAttributes$c = [];
+function encode$A(params2, encodedAttrs) {
   const { node, table, row, rowBorders, styleTag, columnIndex, columnWidth } = params2.extraParams;
   const schemaNode = handleTableCellNode({
     params: params2,
@@ -25972,23 +26047,23 @@ function encode$2(params2, encodedAttrs) {
   }
   return schemaNode;
 }
-function decode$2(params2, decodedAttrs) {
+function decode$r(params2, decodedAttrs) {
   const translated = translateTableCell(params2);
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
     translated.attributes = { ...translated.attributes || {}, ...decodedAttrs };
   }
   return translated;
 }
-const config$2 = {
-  xmlName: XML_NODE_NAME$2,
+const config$d = {
+  xmlName: XML_NODE_NAME$d,
   sdNodeOrKeyName: SD_NODE_NAME$2,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$2,
-  decode: decode$2,
-  attributes: validXmlAttributes$2
+  encode: encode$A,
+  decode: decode$r,
+  attributes: validXmlAttributes$c
 };
-const translator$2 = NodeTranslator.from(config$2);
-const XML_NODE_NAME$1 = "w:hyperlink";
+const translator$d = NodeTranslator.from(config$d);
+const XML_NODE_NAME$c = "w:hyperlink";
 const SD_NODE_NAME$1 = "link";
 const _createAttributeHandler = (xmlName, sdName) => ({
   xmlName,
@@ -25996,7 +26071,7 @@ const _createAttributeHandler = (xmlName, sdName) => ({
   encode: (attributes) => attributes[xmlName],
   decode: (attributes) => attributes[sdName]
 });
-const validXmlAttributes$1 = [
+const validXmlAttributes$b = [
   _createAttributeHandler("w:anchor", "anchor"),
   _createAttributeHandler("w:docLocation", "docLocation"),
   {
@@ -26009,7 +26084,7 @@ const validXmlAttributes$1 = [
   _createAttributeHandler("r:id", "rId"),
   _createAttributeHandler("w:tgtFrame", "target")
 ];
-const encode$1 = (params2, encodedAttrs) => {
+const encode$z = (params2, encodedAttrs) => {
   const { nodes, docx, nodeListHandler } = params2;
   const node = nodes[0];
   let href = _resolveHref(docx, encodedAttrs);
@@ -26023,7 +26098,16 @@ const encode$1 = (params2, encodedAttrs) => {
     nodes: runNodes,
     path: [...params2.path || [], node]
   });
-  return updatedNode;
+  const ensureLinkMark = (child) => {
+    if (!child || typeof child !== "object") return child;
+    const existingMarks = Array.isArray(child.marks) ? child.marks : [];
+    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"];
@@ -26040,7 +26124,7 @@ const _resolveHref = (docx, encodedAttrs) => {
   }
   return href;
 };
-function decode$1(params2) {
+function decode$q(params2) {
   const { node } = params2;
   const linkMark = node.marks.find((m2) => m2.type === "link");
   const linkAttrs = this.decodeAttributes({ ...params2, node: linkMark });
@@ -26084,15 +26168,15 @@ function _addNewLinkRelationship(params2, link, rId) {
   });
   return rId;
 }
-const config$1 = {
-  xmlName: XML_NODE_NAME$1,
+const config$c = {
+  xmlName: XML_NODE_NAME$c,
   sdNodeOrKeyName: SD_NODE_NAME$1,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$1,
-  decode: decode$1,
-  attributes: validXmlAttributes$1
+  encode: encode$z,
+  decode: decode$q,
+  attributes: validXmlAttributes$b
 };
-const translator$1 = NodeTranslator.from(config$1);
+const translator$c = NodeTranslator.from(config$c);
 function parseTagValueJSON(json) {
   if (typeof json !== "string") {
     return {};
@@ -26103,7 +26187,7 @@ function parseTagValueJSON(json) {
   }
   try {
     return JSON.parse(trimmed);
-  } catch (err) {
+  } catch {
     return {};
   }
 }
@@ -27905,10 +27989,10 @@ function translateStructuredContent(params2) {
   };
   return result;
 }
-const XML_NODE_NAME = "w:sdt";
+const XML_NODE_NAME$b = "w:sdt";
 const SD_NODE_NAME = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
-const validXmlAttributes = [];
-function encode$k(params2, encodedAttrs) {
+const validXmlAttributes$a = [];
+function encode$y(params2) {
   const nodes = params2.nodes;
   const node = nodes[0];
   const { type: sdtType, handler: handler2 } = sdtNodeTypeStrategy(node);
@@ -27918,7 +28002,7 @@ function encode$k(params2, encodedAttrs) {
   const result = handler2(params2);
   return result;
 }
-function decode(params2, decodedAttrs) {
+function decode$p(params2) {
   const { node } = params2;
   if (!node || !node.type) {
     return null;
@@ -27934,43 +28018,138 @@ function decode(params2, decodedAttrs) {
   const result = decoder();
   return result;
 }
-const config = {
-  xmlName: XML_NODE_NAME,
+const config$b = {
+  xmlName: XML_NODE_NAME$b,
   sdNodeOrKeyName: SD_NODE_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$k,
-  decode,
-  attributes: validXmlAttributes
+  encode: encode$y,
+  decode: decode$p,
+  attributes: validXmlAttributes$a
+};
+const translator$b = NodeTranslator.from(config$b);
+const encode$x = (attributes) => attributes?.["w:val"];
+const decode$o = (attrs) => attrs?.underline;
+const attrConfig$m = Object.freeze({
+  xmlName: "w:val",
+  sdName: "underline",
+  encode: encode$x,
+  decode: decode$o
+});
+const encode$w = (attributes) => attributes?.["w:color"];
+const decode$n = (attrs) => attrs?.color;
+const attrConfig$l = Object.freeze({
+  xmlName: "w:color",
+  sdName: "color",
+  encode: encode$w,
+  decode: decode$n
+});
+const encode$v = (attributes) => attributes?.["w:themeColor"];
+const decode$m = (attrs) => attrs?.themeColor;
+const attrConfig$k = Object.freeze({
+  xmlName: "w:themeColor",
+  sdName: "themeColor",
+  encode: encode$v,
+  decode: decode$m
+});
+const encode$u = (attributes) => attributes?.["w:themeTint"];
+const decode$l = (attrs) => attrs?.themeTint;
+const attrConfig$j = Object.freeze({
+  xmlName: "w:themeTint",
+  sdName: "themeTint",
+  encode: encode$u,
+  decode: decode$l
+});
+const encode$t = (attributes) => attributes?.["w:themeShade"];
+const decode$k = (attrs) => attrs?.themeShade;
+const attrConfig$i = Object.freeze({
+  xmlName: "w:themeShade",
+  sdName: "themeShade",
+  encode: encode$t,
+  decode: decode$k
+});
+const validXmlAttributes$9 = [attrConfig$m, attrConfig$l, attrConfig$k, attrConfig$j, attrConfig$i];
+const XML_NODE_NAME$a = "w:u";
+const SD_ATTR_KEY$9 = "underline";
+const encode$s = (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$a,
+    sdNodeOrKeyName: SD_ATTR_KEY$9,
+    attributes
+  };
 };
-const translator = NodeTranslator.from(config);
+const decode$j = (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$a,
+    attributes
+  };
+};
+const config$a = {
+  xmlName: XML_NODE_NAME$a,
+  sdNodeOrKeyName: SD_ATTR_KEY$9,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$s,
+  decode: decode$j,
+  attributes: validXmlAttributes$9
+};
+const translator$a = NodeTranslator.from(config$a);
 function exportSchemaToJson(params2) {
   const { type: type2 } = params2.node || {};
   const router = {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$h,
+    paragraph: translator$s,
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$j,
+    lineBreak: translator$v,
     table: translateTable,
-    tableRow: translator$3,
-    tableCell: translator$2,
+    tableRow: translator$e,
+    tableCell: translator$d,
     bookmarkStart: translateBookmarkStart,
-    fieldAnnotation: translator,
-    tab: translator$i,
+    fieldAnnotation: translator$b,
+    tab: translator$t,
     image: translateImageNode,
-    hardBreak: translator$j,
+    hardBreak: translator$v,
     commentRangeStart: () => translateCommentNode(params2, "Start"),
     commentRangeEnd: () => translateCommentNode(params2, "End"),
     commentReference: () => null,
     shapeContainer: translateShapeContainer,
     shapeTextbox: translateShapeTextbox,
     contentBlock: translateContentBlock,
-    structuredContent: translator,
-    structuredContentBlock: translator,
-    documentSection: translator,
+    structuredContent: translator$b,
+    structuredContentBlock: translator$b,
+    documentSection: translator$b,
     "page-number": translatePageNumberNode,
     "total-page-number": translateTotalPageNumberNode
   };
@@ -28293,7 +28472,7 @@ function translateTextNode(params2) {
   const isTrackedNode = node.marks?.some((m2) => trackedMarks.includes(m2.type));
   if (isTrackedNode) return translateTrackedNode(params2);
   const isLinkNode = node.marks?.some((m2) => m2.type === "link");
-  if (isLinkNode) return translator$1.decode(params2);
+  if (isLinkNode) return translator$c.decode(params2);
   const { text, marks = [] } = node;
   return getTextNodeForExport(text, marks, params2);
 }
@@ -28778,10 +28957,20 @@ function translateMark(mark) {
       delete markElement.attributes;
       markElement.type = "element";
       break;
-    case "underline":
-      markElement.type = "element";
-      markElement.attributes["w:val"] = attrs.underlineType;
-      break;
+    case "underline": {
+      const translated = translator$a.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;
@@ -28823,12 +29012,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$u.decode({ node: { attrs: { highlight: highlightValue } } });
+      return translated || {};
+    }
   }
   return markElement;
 }
@@ -28865,17 +29053,7 @@ function translateImageNode(params2, imageSize) {
   let imageId = attrs.rId;
   const src = attrs.src || attrs.imageSrc;
   const { originalWidth, originalHeight } = getPngDimensions(src);
-  let imageName;
-  if (params2.node.type === "image") {
-    if (src?.startsWith("data:")) {
-      imageName = getFallbackImageNameFromDataUri(src);
-    } else {
-      imageName = src?.split("/").pop();
-    }
-  } else {
-    imageName = attrs.fieldId;
-  }
-  imageName = sanitizeDocxMediaName(imageName);
+  const imageName = params2.node.type === "image" ? src.split("/").pop() : attrs.fieldId?.replace("-", "_");
   let size2 = attrs.size ? {
     w: pixelsToEmu(attrs.size.width),
     h: pixelsToEmu(attrs.size.height)
@@ -28905,12 +29083,9 @@ function translateImageNode(params2, imageSize) {
     if (!type2) {
       return prepareTextAnnotation(params2);
     }
-    const sanitizedHash = sanitizeDocxMediaName(attrs.hash, generateDocxRandomId(4));
-    const fileName = `${imageName}_${sanitizedHash}.${type2}`;
-    const relationshipTarget = `media/${fileName}`;
-    const packagePath = `word/${relationshipTarget}`;
-    imageId = addNewImageRelationship(params2, relationshipTarget);
-    params2.media[packagePath] = src;
+    const imageUrl = `media/${imageName}_${attrs.hash}.${type2}`;
+    imageId = addNewImageRelationship(params2, imageUrl);
+    params2.media[`${imageName}_${attrs.hash}.${type2}`] = src;
   }
   let inlineAttrs = attrs.originalPadding || {
     distT: 0,
@@ -29709,82 +29884,912 @@ const trackChangeNodeHandlerEntity = {
   handlerName: "trackChangeNodeHandler",
   handler: handleTrackChangeNode
 };
-const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$1);
-const handleRunNode = (params2) => {
-  const { nodes, nodeListHandler, parentStyleId, docx } = params2;
-  if (nodes.length === 0 || nodes[0].name !== "w:r") {
-    return { nodes: [], consumed: 0 };
-  }
+const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$c);
+const encode$r = (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$i = (runProps) => {
+  if (runProps?.bold === false) return "0";
+  return void 0;
+};
+const attrConfig$h = Object.freeze({
+  xmlName: "w:val",
+  sdName: "bold",
+  encode: encode$r,
+  decode: decode$i
+});
+const validXmlAttributes$8 = [attrConfig$h];
+const XML_NODE_NAME$9 = "w:b";
+const SD_ATTR_KEY$8 = "bold";
+const encode$q = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
   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);
+  if (!node) return void 0;
+  const val = encodedAttrs?.[SD_ATTR_KEY$8];
+  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$9,
+    sdNodeOrKeyName: SD_ATTR_KEY$8,
+    attributes
+  };
+};
+const config$9 = {
+  xmlName: XML_NODE_NAME$9,
+  sdNodeOrKeyName: SD_ATTR_KEY$8,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$q,
+  attributes: validXmlAttributes$8
+};
+const translator$9 = NodeTranslator.from(config$9);
+const encode$p = (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$h = (attrs) => {
+  if (attrs?.italic === false) return "0";
+  return void 0;
+};
+const attrConfig$g = Object.freeze({
+  xmlName: "w:val",
+  sdName: "italic",
+  encode: encode$p,
+  decode: decode$h
+});
+const validXmlAttributes$7 = [attrConfig$g];
+const XML_NODE_NAME$8 = "w:i";
+const SD_ATTR_KEY$7 = "italic";
+const encode$o = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  if (!node) return void 0;
+  const val = encodedAttrs?.[SD_ATTR_KEY$7];
+  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$8,
+    sdNodeOrKeyName: SD_ATTR_KEY$7,
+    attributes
+  };
+};
+const config$8 = {
+  xmlName: XML_NODE_NAME$8,
+  sdNodeOrKeyName: SD_ATTR_KEY$7,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$o,
+  attributes: validXmlAttributes$7
+};
+const translator$8 = NodeTranslator.from(config$8);
+const encode$n = (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$g = (attrs) => {
+  if (attrs?.strike === false) return "0";
+  return void 0;
+};
+const attrConfig$f = Object.freeze({
+  xmlName: "w:val",
+  sdName: "strike",
+  encode: encode$n,
+  decode: decode$g
+});
+const validXmlAttributes$6 = [attrConfig$f];
+const XML_NODE_NAME$7 = "w:strike";
+const SD_ATTR_KEY$6 = "strike";
+const encode$m = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  if (!node) return void 0;
+  const val = encodedAttrs?.[SD_ATTR_KEY$6];
+  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$7,
+    sdNodeOrKeyName: SD_ATTR_KEY$6,
+    attributes
+  };
+};
+const config$7 = {
+  xmlName: XML_NODE_NAME$7,
+  sdNodeOrKeyName: SD_ATTR_KEY$6,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$m,
+  attributes: validXmlAttributes$6
+};
+const translator$7 = NodeTranslator.from(config$7);
+const encode$l = (attributes) => attributes?.["w:val"];
+const decode$f = (attrs) => attrs?.color;
+const attrConfig$e = Object.freeze({
+  xmlName: "w:val",
+  sdName: "color",
+  encode: encode$l,
+  decode: decode$f
+});
+const encode$k = (attributes) => attributes?.["w:themeColor"];
+const decode$e = (attrs) => attrs?.themeColor;
+const attrConfig$d = Object.freeze({
+  xmlName: "w:themeColor",
+  sdName: "themeColor",
+  encode: encode$k,
+  decode: decode$e
+});
+const encode$j = (attributes) => attributes?.["w:themeTint"];
+const decode$d = (attrs) => attrs?.themeTint;
+const attrConfig$c = Object.freeze({
+  xmlName: "w:themeTint",
+  sdName: "themeTint",
+  encode: encode$j,
+  decode: decode$d
+});
+const encode$i = (attributes) => attributes?.["w:themeShade"];
+const decode$c = (attrs) => attrs?.themeShade;
+const attrConfig$b = Object.freeze({
+  xmlName: "w:themeShade",
+  sdName: "themeShade",
+  encode: encode$i,
+  decode: decode$c
+});
+const validXmlAttributes$5 = [attrConfig$e, attrConfig$d, attrConfig$c, attrConfig$b];
+const XML_NODE_NAME$6 = "w:color";
+const SD_ATTR_KEY$5 = "color";
+const encode$h = (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$6,
+    sdNodeOrKeyName: SD_ATTR_KEY$5,
+    attributes
+  };
+};
+const config$6 = {
+  xmlName: XML_NODE_NAME$6,
+  sdNodeOrKeyName: SD_ATTR_KEY$5,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$h,
+  attributes: validXmlAttributes$5
+};
+const translator$6 = NodeTranslator.from(config$6);
+const encode$g = (attributes) => attributes?.["w:eastAsia"];
+const decode$b = (attrs) => attrs?.eastAsia;
+const attrConfig$a = Object.freeze({
+  xmlName: "w:eastAsia",
+  sdName: "eastAsia",
+  encode: encode$g,
+  decode: decode$b
+});
+const encode$f = (attributes) => attributes?.["w:ascii"];
+const decode$a = (attrs) => attrs?.ascii;
+const attrConfig$9 = Object.freeze({
+  xmlName: "w:ascii",
+  sdName: "ascii",
+  encode: encode$f,
+  decode: decode$a
+});
+const encode$e = (attributes) => attributes?.["w:hAnsi"];
+const decode$9 = (attrs) => attrs?.hAnsi;
+const attrConfig$8 = Object.freeze({
+  xmlName: "w:hAnsi",
+  sdName: "hAnsi",
+  encode: encode$e,
+  decode: decode$9
+});
+const encode$d = (attributes) => attributes?.["w:cs"];
+const decode$8 = (attrs) => attrs?.cs;
+const attrConfig$7 = Object.freeze({
+  xmlName: "w:cs",
+  sdName: "cs",
+  encode: encode$d,
+  decode: decode$8
+});
+const encode$c = (attributes) => attributes?.["w:val"];
+const decode$7 = (attrs) => attrs?.value;
+const attrConfig$6 = Object.freeze({
+  xmlName: "w:val",
+  sdName: "value",
+  encode: encode$c,
+  decode: decode$7
+});
+const validXmlAttributes$4 = [attrConfig$a, attrConfig$9, attrConfig$8, attrConfig$7, attrConfig$6];
+const XML_NODE_NAME$5 = "w:rFonts";
+const SD_ATTR_KEY$4 = "fontFamily";
+const encode$b = (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((key) => {
+    if (attributes[key] === void 0) attributes[key] = sourceAttrs[key];
+  });
+  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$5,
+    sdNodeOrKeyName: SD_ATTR_KEY$4,
+    attributes
+  };
+};
+const config$5 = {
+  xmlName: XML_NODE_NAME$5,
+  sdNodeOrKeyName: SD_ATTR_KEY$4,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$b,
+  attributes: validXmlAttributes$4
+};
+const translator$5 = NodeTranslator.from(config$5);
+const encode$a = (attributes) => attributes?.["w:val"];
+const decode$6 = (attrs) => attrs?.styleId;
+const attrConfig$5 = Object.freeze({
+  xmlName: "w:val",
+  sdName: "styleId",
+  encode: encode$a,
+  decode: decode$6
+});
+const validXmlAttributes$3 = [attrConfig$5];
+const XML_NODE_NAME$4 = "w:rStyle";
+const SD_ATTR_KEY$3 = "styleId";
+const encode$9 = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  const value = encodedAttrs.styleId ?? node?.attributes?.["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$4,
+    sdNodeOrKeyName: SD_ATTR_KEY$3,
+    attributes: { "w:val": value ?? null }
+  };
+};
+const config$4 = {
+  xmlName: XML_NODE_NAME$4,
+  sdNodeOrKeyName: SD_ATTR_KEY$3,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$9,
+  attributes: validXmlAttributes$3
+};
+const translator$4 = NodeTranslator.from(config$4);
+const encode$8 = (attributes) => attributes?.["w:val"];
+const decode$5 = (attrs) => attrs?.fontSize;
+const attrConfig$4 = Object.freeze({
+  xmlName: "w:val",
+  sdName: "fontSize",
+  encode: encode$8,
+  decode: decode$5
+});
+const validXmlAttributes$2 = [attrConfig$4];
+const XML_NODE_NAME$3 = "w:sz";
+const SD_ATTR_KEY$2 = "fontSize";
+const encode$7 = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  const value = encodedAttrs.fontSize ?? node?.attributes?.["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$3,
+    sdNodeOrKeyName: SD_ATTR_KEY$2,
+    attributes: { "w:val": value ?? null }
+  };
+};
+const config$3 = {
+  xmlName: XML_NODE_NAME$3,
+  sdNodeOrKeyName: SD_ATTR_KEY$2,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$7,
+  attributes: validXmlAttributes$2
+};
+const translator$3 = NodeTranslator.from(config$3);
+const encode$6 = (attributes) => attributes?.["w:val"];
+const decode$4 = (attrs) => attrs?.fontSizeCs;
+const attrConfig$3 = Object.freeze({
+  xmlName: "w:val",
+  sdName: "fontSizeCs",
+  encode: encode$6,
+  decode: decode$4
+});
+const validXmlAttributes$1 = [attrConfig$3];
+const XML_NODE_NAME$2 = "w:szCs";
+const SD_ATTR_KEY$1 = "fontSizeCs";
+const encode$5 = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  const value = encodedAttrs.fontSizeCs ?? node?.attributes?.["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$2,
+    sdNodeOrKeyName: SD_ATTR_KEY$1,
+    attributes: { "w:val": value ?? null }
+  };
+};
+const config$2 = {
+  xmlName: XML_NODE_NAME$2,
+  sdNodeOrKeyName: SD_ATTR_KEY$1,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$5,
+  attributes: validXmlAttributes$1
+};
+const translator$2 = NodeTranslator.from(config$2);
+const runPropertyTranslators = Object.freeze({
+  "w:b": translator$9,
+  "w:i": translator$8,
+  "w:u": translator$a,
+  "w:strike": translator$7,
+  "w:color": translator$6,
+  "w:highlight": translator$u,
+  "w:rFonts": translator$5,
+  "w:rStyle": translator$4,
+  "w:sz": translator$3,
+  "w:szCs": translator$2
+});
+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$1 = "w:rPr";
+const SD_ATTR_KEY = "runProperties";
+const encode$4 = (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$1 = {
+  xmlName: XML_NODE_NAME$1,
+  sdNodeOrKeyName: SD_ATTR_KEY,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$4
+};
+const translator$1 = NodeTranslator.from(config$1);
+const collectRunProperties = (params2, rPrNode, translator2 = translator$1) => {
+  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 ensureRunMark = (marks, runAttrs) => {
+  if (!runAttrs) return;
+  const runMark = createRunMark(runAttrs);
+  const runMarkIndex = marks.findIndex((mark) => mark?.type === "run");
+  if (runMarkIndex >= 0) {
+    const existing = marks[runMarkIndex];
+    if (runMark.attrs) {
+      marks[runMarkIndex] = { ...existing, attrs: mergeRunAttrs(existing?.attrs, runMark.attrs) };
+    }
+    return;
+  }
+  marks.push(runMark);
+};
+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 applyRunMarks = (node, runAttrs, inlineMarks, textStyleAttrs) => {
+  if (!node || typeof node !== "object") return node;
+  const baseMarks = Array.isArray(node.marks) ? node.marks : [];
+  const marks = baseMarks.map((mark) => cloneMark(mark));
+  ensureRunMark(marks, runAttrs);
+  ensureInlineMarks(marks, inlineMarks);
+  if (node.type === "text") {
+    ensureTextStyleMark(marks, textStyleAttrs);
+  }
+  return { ...node, marks };
+};
+const createRunMark = (attrs = {}) => {
+  const hasAttrs = attrs && Object.keys(attrs).length > 0;
+  return hasAttrs ? { type: "run", attrs: cloneRunAttrs(attrs) } : { type: "run" };
+};
+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) => {
-      const exists2 = combinedMarks.some(
-        (existing) => existing.type === mark.type && JSON.stringify(existing.attrs || {}) === JSON.stringify(mark.attrs || {})
-      );
-      if (!exists2) {
-        combinedMarks.push(mark);
-      }
+      if (!mark || !mark.type) return;
+      map3.set(mark.type, mark.attrs ? { type: mark.type, attrs: { ...mark.attrs } } : { type: mark.type });
     });
-    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 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 = (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 mergeRunAttrs = (existing = {}, incoming = {}) => {
+  const merged = { ...existing, ...cloneRunAttrs(incoming) };
+  if (Array.isArray(existing?.runProperties) && Array.isArray(incoming?.runProperties)) {
+    const seen = /* @__PURE__ */ new Set();
+    const combined = [...existing.runProperties, ...incoming.runProperties];
+    merged.runProperties = combined.filter((entry) => {
+      const key = entry?.xmlName;
+      if (!key || seen.has(key)) return false;
+      seen.add(key);
+      return true;
     });
   }
-  return { nodes: processedRun, consumed: 1 };
+  return merged;
 };
-const getMarksFromStyles = (docx, styleId) => {
-  const styles = docx?.["word/styles.xml"];
-  if (!styles) {
-    return {};
+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 resolveRunElement = (node) => {
+  if (!node) return null;
+  if (node.name === "w:r") return node;
+  return (node.elements || []).find((el) => el.name === "w:r") || null;
+};
+const ensureRunPropertiesContainer = (runElement) => {
+  if (!Array.isArray(runElement.elements)) runElement.elements = [];
+  let rPr = runElement.elements.find((el) => el.name === "w:rPr");
+  if (!rPr) {
+    rPr = { name: "w:rPr", elements: [] };
+    runElement.elements.unshift(rPr);
+  }
+  if (!Array.isArray(rPr.elements)) rPr.elements = [];
+  return rPr;
+};
+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 family = attributes["w:ascii"] || attributes["w:eastAsia"] || attributes["w:hAnsi"] || attributes["w:val"];
+        if (family) {
+          hasTextStyle = true;
+          textStyleAttrs.fontFamily = SuperConverter.toCssFontFamily(family, docx);
+        }
+        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 encode$3 = (attributes) => {
+  return attributes["w:rsidR"];
+};
+const decode$3 = (attrs) => {
+  return attrs.rsidR;
+};
+const attrConfig$2 = Object.freeze({
+  xmlName: "w:rsidR",
+  sdName: "rsidR",
+  encode: encode$3,
+  decode: decode$3
+});
+const encode$2 = (attributes) => {
+  return attributes["w:rsidRPr"];
+};
+const decode$2 = (attrs) => {
+  return attrs.rsidRPr;
+};
+const attrConfig$1 = Object.freeze({
+  xmlName: "w:rsidRPr",
+  sdName: "rsidRPr",
+  encode: encode$2,
+  decode: decode$2
+});
+const encode$1 = (attributes) => {
+  return attributes["w:rsidDel"];
+};
+const decode$1 = (attrs) => {
+  return attrs.rsidDel;
+};
+const attrConfig = Object.freeze({
+  xmlName: "w:rsidDel",
+  sdName: "rsidDel",
+  encode: encode$1,
+  decode: decode$1
+});
+const validXmlAttributes = [attrConfig$2, attrConfig$1, attrConfig];
+const XML_NODE_NAME = "w:r";
+const SD_KEY_NAME = "run";
+const encode$U = (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(mark)) : [];
+  if (styleChangeMarks?.length) {
+    runLevelMarks = [...runLevelMarks, ...styleChangeMarks.map((mark) => cloneMark(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(mark)) : [];
+    if (!runLevelMarks.length) return child;
+    return { ...child, marks: [...baseMarks, ...runLevelMarks.map((mark) => cloneMark(mark))] };
+  });
+  const marked = contentWithRunMarks.map(
+    (child) => applyRunMarks(child, runAttrs, mergedInlineMarks, mergedTextStyleAttrs)
+  );
+  const filtered = marked.filter(Boolean);
+  if (!filtered.length) return [];
+  if (filtered.length === 1) return filtered[0];
+  return filtered;
+};
+const decode = (params2, decodedAttrs = {}) => {
+  const { node } = params2 || {};
+  if (!node) return void 0;
+  const marks = Array.isArray(node.marks) ? node.marks : [];
+  const runMarkIndex = marks.findIndex((mark) => mark?.type === SD_KEY_NAME);
+  const runMark = runMarkIndex >= 0 ? marks[runMarkIndex] : void 0;
+  const strippedMarks = marks.filter((_2, idx) => idx !== runMarkIndex);
+  const exportNode = { ...node, marks: strippedMarks };
+  const exportParams = { ...params2, node: exportNode };
+  if (!exportParams.editor) {
+    exportParams.editor = { extensionService: { extensions: [] } };
+  }
+  const translated = exportSchemaToJson(exportParams);
+  if (!translated) return void 0;
+  const runElement = resolveRunElement(translated);
+  if (!runElement) return translated;
+  runElement.attributes = { ...runElement.attributes || {}, ...decodedAttrs };
+  const runProperties = Array.isArray(runMark?.attrs?.runProperties) ? runMark.attrs.runProperties : null;
+  if (runProperties && runProperties.length) {
+    const rPr = ensureRunPropertiesContainer(runElement);
+    const existingNames = new Set((rPr.elements || []).map((el) => el.name));
+    runProperties.forEach((entry) => {
+      if (!entry || !entry.xmlName || entry.xmlName === "w:b") return;
+      if (existingNames.has(entry.xmlName)) return;
+      rPr.elements.push({ name: entry.xmlName, attributes: { ...entry.attributes || {} } });
+      existingNames.add(entry.xmlName);
+    });
   }
-  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);
+  return translated;
 };
-const runNodeHandlerEntity = {
-  handlerName: "runNodeHandler",
-  handler: handleRunNode
+const config = {
+  xmlName: XML_NODE_NAME,
+  sdNodeOrKeyName: SD_KEY_NAME,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$U,
+  decode,
+  attributes: validXmlAttributes
 };
+const translator = NodeTranslator.from(config);
+const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator);
 const handleTextNode = (params2) => {
   const { nodes, insideTrackChange } = params2;
   if (nodes.length === 0 || !(nodes[0].name === "w:t" || insideTrackChange && nodes[0].name === "w:delText")) {
@@ -29821,7 +30826,7 @@ const handleParagraphNode = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$h.encode(params2);
+  const schemaNode = translator$s.encode(params2);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -29834,7 +30839,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$b.encode(params2);
   if (!result) {
     return { nodes: [], consumed: 0 };
   }
@@ -29924,7 +30929,7 @@ const handler = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$j.encode(params2);
+  const result = translator$v.encode(params2);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -30620,7 +31625,7 @@ const handleTabNode = (params2) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$i.encode(params2);
+  const node = translator$t.encode(params2);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
@@ -31067,6 +32072,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);
@@ -31102,6 +32117,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.
@@ -31147,7 +32187,7 @@ const _SuperConverter = class _SuperConverter2 {
       return;
     }
   }
-  static updateDocumentVersion(docx = this.convertedXml, version2 = "0.20.1") {
+  static updateDocumentVersion(docx = this.convertedXml, version2 = "0.21.0-RC1") {
     const customLocation = "docProps/custom.xml";
     if (!docx[customLocation]) {
       docx[customLocation] = generateCustomXml();
@@ -31198,13 +32238,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() {
@@ -31634,7 +32680,7 @@ function storeSuperdocVersion(docx) {
 function generateCustomXml() {
   return DEFAULT_CUSTOM_XML;
 }
-function generateSuperdocVersion(pid = 2, version2 = "0.20.1") {
+function generateSuperdocVersion(pid = 2, version2 = "0.21.0-RC1") {
   return {
     type: "element",
     name: "property",
@@ -34043,7 +35089,7 @@ class DocxZipper {
         const u8 = await zipEntry.async("uint8array");
         const content = ensureXmlString(u8);
         this.files.push({ name, content });
-      } else if (name.startsWith("word/media") && name !== "word/media/" || zipEntry.name.startsWith("media") && zipEntry.name !== "media/" || name.startsWith("media") && name !== "media/") {
+      } else if (name.startsWith("word/media") && name !== "word/media/" || name.startsWith("media") && name !== "media/") {
         if (isNode2) {
           const buffer2 = await zipEntry.async("nodebuffer");
           const fileBase64 = buffer2.toString("base64");
@@ -43048,6 +44094,95 @@ 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 key = mapMarkToStyleKey(markName);
+    while (current && !seen.has(current)) {
+      seen.add(current);
+      const style2 = styles.find((s) => s.id === current);
+      const def = style2?.definition?.styles || {};
+      if (key in def) {
+        const raw = def[key];
+        if (raw === void 0) return true;
+        const val = raw?.value ?? raw;
+        if (val === "0" || val === false) return false;
+        return !!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) {
+  const run2 = marks.find((m2) => m2.type?.name === "run");
+  const runProperties = run2?.attrs?.runProperties;
+  if (!runProperties) return null;
+  if (runProperties && typeof runProperties === "object" && !Array.isArray(runProperties) && runProperties.styleId) {
+    return runProperties.styleId;
+  }
+  if (Array.isArray(runProperties)) {
+    const rStyleEntry = runProperties.find((e) => e?.xmlName === "w:rStyle");
+    const sid = rStyleEntry?.attributes?.["w:val"];
+    if (sid) return sid;
+  }
+  return null;
+}
+function mapMarkToStyleKey(markName) {
+  if (markName === "textStyle" || markName === "color") return "color";
+  return markName;
+}
 const clearNodes = () => ({ state: state2, tr, dispatch }) => {
   const { selection } = tr;
   const { ranges } = selection;
@@ -44393,11 +45528,14 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   command,
   createParagraphNear,
   decreaseListIndent,
+  defaultStyleDetector,
   deleteListItem,
   deleteSelection,
   exitCode,
   first,
+  getEffectiveStyleId,
   getParaCtx,
+  getStyleIdFromMarks,
   handleBackspaceNextToList,
   handleDeleteNextToList,
   increaseListIndent,
@@ -44412,6 +45550,7 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   joinUp,
   liftEmptyBlock,
   liftListItem,
+  mapMarkToStyleKey,
   nearestListAt,
   newlineInCode,
   rebuildListNodeWithNewNum,
@@ -44431,6 +45570,7 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   splitListItem,
   toggleList,
   toggleMark,
+  toggleMarkCascade,
   toggleNode,
   undoInputRule,
   unsetAllMarks,
@@ -45634,7 +46774,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, {
@@ -45647,7 +46787,7 @@ const createHeaderFooterEditor = ({
     left: "0",
     width: "auto",
     maxWidth: "none",
-    fontFamily: typeface,
+    fontFamily: fontFamilyCss || typeface,
     fontSize: `${fontSizeInPixles}px`,
     lineHeight: `${lineHeight2}px`
   });
@@ -46477,7 +47617,6 @@ const trackedTransaction = ({ tr, state: state2, user }) => {
         originalStep,
         originalStepIndex
       });
-      console.debug("[track-changes]: replaceStep");
     } else if (step instanceof AddMarkStep) {
       addMarkStep({
         state: state2,
@@ -46487,7 +47626,6 @@ const trackedTransaction = ({ tr, state: state2, user }) => {
         user,
         date
       });
-      console.debug("[track-changes]: addMarkStep");
     } else if (step instanceof RemoveMarkStep) {
       removeMarkStep({
         state: state2,
@@ -46497,10 +47635,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")) {
@@ -48570,9 +49706,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`;
@@ -48886,7 +50023,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
    * @returns {Object | void} Migration results
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "0.20.1");
+    console.debug("[checkVersionMigrations] Current editor version", "0.21.0-RC1");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -49995,6 +51132,7 @@ const FormatCommands = Extension.create({
   },
   addCommands() {
     return {
+      toggleMarkCascade,
       /**
        * Clear all formatting (nodes and marks)
        * @category Command
@@ -50979,24 +52117,32 @@ const Text = Node$1.create({
   group: "inline",
   inline: true
 });
-const RunItem = Node$1.create({
+const Run = Mark2.create({
   name: "run",
-  group: "inline",
-  content: "text*",
-  inline: true,
-  parseDOM() {
-    return [{ tag: "run" }];
-  },
-  renderDOM() {
-    return ["run", 0];
+  inclusive: false,
+  addOptions() {
+    return {
+      htmlAttributes: {}
+    };
   },
   addAttributes() {
     return {
-      attributes: {
-        rendered: false,
-        "aria-label": "Run node"
+      runProperties: {
+        default: null,
+        rendered: false
       }
     };
+  },
+  parseDOM() {
+    return [
+      {
+        tag: "span[data-run]"
+      }
+    ];
+  },
+  renderDOM({ htmlAttributes }) {
+    const base2 = Attribute2.mergeAttributes({ "data-run": "1" }, this.options.htmlAttributes, htmlAttributes);
+    return ["span", base2, 0];
   }
 });
 const inputRegex$1 = /^\s*([-+*])\s$/;
@@ -51560,6 +52706,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();
@@ -51578,12 +52725,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 key = kebabCase$1(k);
     const flattenedMarks = [];
@@ -51598,6 +52755,10 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
       }
       flattenedMarks.push({ key: n.type.name, value: n.attrs[key] });
     });
+    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 === key);
     const hasParentIndent = Object.keys(parent?.attrs?.indent || {});
     const hasParentSpacing = Object.keys(parent?.attrs?.spacing || {});
@@ -51614,10 +52775,28 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
         if (rightIndent) markValue["margin-right"] = rightIndent + "px";
         if (firstLine) markValue["text-indent"] = firstLine + "px";
       } else if (key === "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 (key === "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 (key === "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 (key === "text-transform" && node) {
         if (!listTypes.includes(node.type.name)) {
           markValue[key] = value;
@@ -51626,10 +52805,44 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
         if (!listTypes.includes(node.type.name)) {
           markValue[key] = value;
         }
+      } else if (key === "font-family" && node) {
+        if (!listTypes.includes(node.type.name)) {
+          markValue[key] = value;
+        }
       } else if (key === "color" && node) {
         if (!listTypes.includes(node.type.name)) {
           markValue[key] = value;
         }
+      } else if (key === "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 (key === "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[key] = value;
       }
@@ -51762,23 +52975,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);
@@ -51913,6 +53154,70 @@ const LinkedStyles = Extension.create({
     };
   }
 });
+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("; ");
+}
 const generateOrderedListIndex = ({ listLevel, lvlText, listNumberingType, customFormat }) => {
   const handler2 = listIndexMap[listNumberingType];
   return handler2 ? handler2(listLevel, lvlText, customFormat) : null;
@@ -60198,6 +61503,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() {
@@ -60232,9 +61561,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
@@ -60244,7 +61582,7 @@ const Bold = Mark2.create({
        * setBold()
        * @note '0' renders as normal weight
        */
-      setBold: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+      setBold,
       /**
        * Remove bold formatting
        * @category Command
@@ -60252,7 +61590,7 @@ const Bold = Mark2.create({
        * @example
        * unsetBold()
        */
-      unsetBold: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+      unsetBold,
       /**
        * Toggle bold formatting
        * @category Command
@@ -60260,7 +61598,7 @@ const Bold = Mark2.create({
        * @example
        * toggleBold()
        */
-      toggleBold: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+      toggleBold
     };
   },
   addShortcuts() {
@@ -60277,6 +61615,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" },
@@ -60286,9 +61640,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
@@ -60297,7 +61660,7 @@ const Italic = Mark2.create({
        * @example
        * setItalic()
        */
-      setItalic: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+      setItalic,
       /**
        * Remove italic formatting
        * @category Command
@@ -60305,7 +61668,7 @@ const Italic = Mark2.create({
        * @example
        * unsetItalic()
        */
-      unsetItalic: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+      unsetItalic,
       /**
        * Toggle italic formatting
        * @category Command
@@ -60313,7 +61676,7 @@ const Italic = Mark2.create({
        * @example
        * toggleItalic()
        */
-      toggleItalic: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+      toggleItalic
     };
   },
   addShortcuts() {
@@ -60338,7 +61701,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 {
@@ -60348,10 +61720,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
@@ -60360,7 +61740,7 @@ const Underline = Mark2.create({
        * @example
        * setUnderline()
        */
-      setUnderline: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+      setUnderline,
       /**
        * Remove underline formatting
        * @category Command
@@ -60368,7 +61748,7 @@ const Underline = Mark2.create({
        * @example
        * unsetUnderline()
        */
-      unsetUnderline: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+      unsetUnderline,
       /**
        * Toggle underline formatting
        * @category Command
@@ -60376,7 +61756,7 @@ const Underline = Mark2.create({
        * @example
        * toggleUnderline()
        */
-      toggleUnderline: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+      toggleUnderline
     };
   },
   addShortcuts() {
@@ -60471,9 +61851,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
@@ -60482,9 +61871,7 @@ const Strike = Mark2.create({
        * @example
        * setStrike()
        */
-      setStrike: () => ({ commands: commands2 }) => {
-        return commands2.setMark(this.name);
-      },
+      setStrike,
       /**
        * Remove strikethrough formatting
        * @category Command
@@ -60492,9 +61879,7 @@ const Strike = Mark2.create({
        * @example
        * unsetStrike()
        */
-      unsetStrike: () => ({ commands: commands2 }) => {
-        return commands2.unsetMark(this.name);
-      },
+      unsetStrike,
       /**
        * Toggle strikethrough formatting
        * @category Command
@@ -60502,8 +61887,24 @@ const Strike = Mark2.create({
        * @example
        * 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 {};
+        }
       }
     };
   },
@@ -66658,7 +68059,7 @@ const getStarterExtensions = () => {
     Paragraph,
     LineBreak,
     HardBreak,
-    RunItem,
+    Run,
     SlashMenu,
     Strike,
     TabNode,
@@ -69189,7 +70590,7 @@ function resolveTo(selector) {
   if (typeof selector === "string") {
     return document.querySelector(selector);
   }
-  return selector() || null;
+  return selector();
 }
 const LazyTeleport = vue.defineComponent({
   name: "LazyTeleport",
@@ -69277,11 +70678,8 @@ const oppositeAlignCssPositionProps = {
 };
 const keepOffsetDirection = {
   top: true,
-  // top++
   bottom: false,
-  // top--
   left: true,
-  // left++
   right: false
   // left--
 };
@@ -70398,6 +71796,7 @@ function isFocusable(element) {
       return !!element.href && element.rel !== "ignore";
     case "INPUT":
       return element.type !== "hidden" && element.type !== "file";
+    case "BUTTON":
     case "SELECT":
     case "TEXTAREA":
       return true;
@@ -70416,8 +71815,8 @@ const FocusTrap = vue.defineComponent({
       default: true
     },
     onEsc: Function,
-    initialFocusTo: [String, Function],
-    finalFocusTo: [String, Function],
+    initialFocusTo: String,
+    finalFocusTo: String,
     returnFocusOnDeactivated: {
       type: Boolean,
       default: true
@@ -72515,7 +73914,6 @@ function self$6(vars) {
   });
 }
 const scrollbarLight = {
-  name: "Scrollbar",
   common: derived,
   self: self$6
 };
@@ -74031,14 +75429,11 @@ function self$5(vars) {
     boxShadow: boxShadow2
   });
 }
-const popoverLight = createTheme({
+const popoverLight = {
   name: "Popover",
   common: derived,
-  peers: {
-    Scrollbar: scrollbarLight
-  },
   self: self$5
-});
+};
 const oppositePlacement = {
   top: "bottom",
   bottom: "top",
@@ -74258,11 +75653,9 @@ const NPopoverBody = vue.defineComponent({
     const {
       namespaceRef,
       mergedClsPrefixRef,
-      inlineThemeDisabled,
-      mergedRtlRef
+      inlineThemeDisabled
     } = useConfig(props);
     const themeRef = useTheme("Popover", "-popover", style$3, popoverLight, props, mergedClsPrefixRef);
-    const rtlEnabledRef = useRtl("Popover", mergedRtlRef, mergedClsPrefixRef);
     const followerRef = vue.ref(null);
     const NPopover2 = vue.inject("NPopover");
     const bodyRef = vue.ref(null);
@@ -74460,8 +75853,6 @@ const NPopoverBody = vue.defineComponent({
             style: props.contentStyle
           }, slots);
           const maybeScrollableBody = props.scrollable ? vue.h(XScrollbar, {
-            themeOverrides: themeRef.value.peerOverrides.Scrollbar,
-            theme: themeRef.value.peers.Scrollbar,
             contentClass: hasHeaderOrFooter ? void 0 : `${mergedClsPrefix}-popover__content ${(_b = props.contentClass) !== null && _b !== void 0 ? _b : ""}`,
             contentStyle: hasHeaderOrFooter ? void 0 : props.contentStyle
           }, {
@@ -74477,7 +75868,7 @@ const NPopoverBody = vue.defineComponent({
           return [maybeScrollableBody, arrow2];
         };
         contentNode = vue.h("div", vue.mergeProps({
-          class: [`${mergedClsPrefix}-popover`, `${mergedClsPrefix}-popover-shared`, (rtlEnabledRef === null || rtlEnabledRef === void 0 ? void 0 : rtlEnabledRef.value) && `${mergedClsPrefix}-popover--rtl`, themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass.value, extraClass.map((v2) => `${mergedClsPrefix}-${v2}`), {
+          class: [`${mergedClsPrefix}-popover`, `${mergedClsPrefix}-popover-shared`, themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass.value, extraClass.map((v2) => `${mergedClsPrefix}-${v2}`), {
             [`${mergedClsPrefix}-popover--scrollable`]: props.scrollable,
             [`${mergedClsPrefix}-popover--show-header-or-footer`]: hasHeaderOrFooter,
             [`${mergedClsPrefix}-popover--raw`]: props.raw,
@@ -74501,7 +75892,7 @@ const NPopoverBody = vue.defineComponent({
           // The popover class and overlap class must exists, they will be used
           // to place the body & transition animation.
           // Shadow class exists for reuse box-shadow.
-          [`${mergedClsPrefix}-popover-shared`, (rtlEnabledRef === null || rtlEnabledRef === void 0 ? void 0 : rtlEnabledRef.value) && `${mergedClsPrefix}-popover--rtl`, themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass.value, props.overlap && `${mergedClsPrefix}-popover-shared--overlap`, props.showArrow && `${mergedClsPrefix}-popover-shared--show-arrow`, props.arrowPointToCenter && `${mergedClsPrefix}-popover-shared--center-arrow`],
+          [`${mergedClsPrefix}-popover-shared`, themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass.value, props.overlap && `${mergedClsPrefix}-popover-shared--overlap`, props.showArrow && `${mergedClsPrefix}-popover-shared--show-arrow`, props.arrowPointToCenter && `${mergedClsPrefix}-popover-shared--center-arrow`],
           bodyRef,
           styleRef.value,
           handleMouseEnter,
@@ -79978,10 +81369,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
@@ -79990,12 +81385,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
@@ -80362,7 +81759,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 });
     }
@@ -81925,11 +83321,32 @@ const _sfc_main = {
   }
 };
 const SuperInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4d5cff52"]]);
-const registeredHandlers = Object.freeze({
-  "w:br": translator$j,
-  "w:tab": translator$i,
-  "w:p": translator$h
-});
+const baseHandlers = {
+  ...runPropertyTranslators,
+  "w:br": translator$v,
+  "w:cantSplit": translator$r,
+  "w:cnfStyle": translator$q,
+  "w:divId": translator$p,
+  "w:gridAfter": translator$o,
+  "w:gridBefore": translator$n,
+  "w:hidden": translator$m,
+  "w:hyperlink": translator$c,
+  "w:jc": translator$l,
+  "w:p": translator$s,
+  "w:r": translator,
+  "w:rPr": translator$1,
+  "w:sdt": translator$b,
+  "w:tab": translator$t,
+  "w:tblCellSpacing": translator$k,
+  "w:tblHeader": translator$j,
+  "w:tc": translator$d,
+  "w:tr": translator$e,
+  "w:trHeight": translator$i,
+  "w:trPr": translator$f,
+  "w:wAfter": translator$h,
+  "w:wBefore": translator$g
+};
+const registeredHandlers = Object.freeze(baseHandlers);
 const Extensions = {
   Node: Node$1,
   Attribute: Attribute2,