@harbour-enterprises/superdoc 0.20.1 → 0.21.0-RC1

package/dist/super-editor/chunks/{converter-Dq0PLazx.js → converter-B61ZUb-V.js}

@@ -14875,25 +14875,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 = (hex) => {
+  if (!hex) return null;
+  let value = hex.replace("#", "").trim();
+  if (!value) return null;
+  value = value.toUpperCase();
+  if (value.length === 3)
+    value = value.split("").map((c) => c + c).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 hex = DOCX_HIGHLIGHT_KEYWORD_MAP.get(docxColor);
+  return hex ? `#${hex}` : 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, hex] of DOCX_HIGHLIGHT_KEYWORD_MAP.entries()) {
+    if (hex === normalized) return keyword;
+  }
+  return null;
 };
 function isValidHexColor(color) {
   if (!color || typeof color !== "string") return false;
@@ -24303,37 +24325,37 @@ const _NodeTranslator = class _NodeTranslator {
 /** @type {typeof TranslatorTypes} */
 __publicField(_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"
@@ -24343,7 +24365,7 @@ const encode$h = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$h = (params, decodedAttrs) => {
+const decode$I = (params, decodedAttrs) => {
   const { node } = params;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24360,63 +24382,120 @@ const decode$h = (params, 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 = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  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 = (params) => {
+  const attrs = params?.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 = (params, decodedAttrs = {}) => {
+const decode$C = (params, decodedAttrs = {}) => {
   const { node } = params || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24432,15 +24511,15 @@ const decode$d = (params, 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;
@@ -24615,17 +24694,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"];
@@ -24646,7 +24729,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 {};
@@ -25010,102 +25097,102 @@ const handleParagraphNode$1 = (params) => {
   }
   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 = (params, encodedAttrs = {}) => {
+const encode$D = (params, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25113,7 +25200,7 @@ const encode$5 = (params, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$5 = (params, decodedAttrs = {}) => {
+const decode$u = (params, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25121,15 +25208,15 @@ const decode$5 = (params, 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: (params) => {
@@ -25236,13 +25323,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: [
@@ -25275,8 +25362,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,
@@ -25285,7 +25372,7 @@ const translator$d = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$c = NodeTranslator.from(
+const translator$n = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridBefore",
     null,
@@ -25294,21 +25381,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 }) => {
@@ -25335,11 +25422,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 = (params) => {
+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 = (params) => {
   const { nodes } = params;
   const node = nodes[0];
   let attributes = {
@@ -25353,12 +25440,12 @@ const encode$4 = (params) => {
   };
   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 = (params) => {
+const decode$t = (params) => {
   const { tableRowProperties = {} } = params.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName, tableRowProperties);
   const newNode = {
@@ -25370,18 +25457,18 @@ const decode$4 = (params) => {
   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) => {
@@ -25391,25 +25478,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 = (params, encodedAttrs) => {
+const encode$B = (params, encodedAttrs) => {
   const { row, table } = params.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({
       ...params,
       nodes: [tPr]
     }));
@@ -25422,7 +25509,7 @@ const encode$3 = (params, encodedAttrs) => {
   let currentColumnIndex = 0;
   const content = cellNodes?.map((n) => {
     let columnWidth = gridColumnWidths?.[currentColumnIndex] || null;
-    const result = translator$2.encode({
+    const result = translator$d.encode({
       ...params,
       extraParams: {
         ...params.extraParams,
@@ -25453,7 +25540,7 @@ const _getGridColumnWidths = (tableNode) => {
   }) || [];
   return columnWidths;
 };
-const decode$3 = (params, decodedAttrs) => {
+const decode$s = (params, decodedAttrs) => {
   const { node } = params;
   const elements = translateChildNodes(params);
   if (node.attrs?.tableRowProperties) {
@@ -25465,7 +25552,7 @@ const decode$3 = (params, decodedAttrs) => {
       }
     }
     tableRowProperties["cantSplit"] = node.attrs["cantSplit"];
-    const trPr = translator$4.decode({
+    const trPr = translator$f.decode({
       ...params,
       node: { ...node, attrs: { ...node.attrs, tableRowProperties } }
     });
@@ -25477,15 +25564,15 @@ const decode$3 = (params, 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 = (params) => {
   const { nodes } = params;
   if (nodes.length === 0) {
@@ -25549,7 +25636,7 @@ function handleTableNode(node, params) {
   attrs["borders"] = borderData;
   const content = [];
   rows.forEach((row) => {
-    const result = translator$3.encode({
+    const result = translator$e.encode({
       ...params,
       nodes: [row],
       extraParams: {
@@ -25930,10 +26017,10 @@ function generateCellMargins(cellMargins) {
   if (left != null) elements.push({ name: "w:left", attributes: { "w:w": pixelsToTwips(left) } });
   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(params, encodedAttrs) {
+const validXmlAttributes$c = [];
+function encode$A(params, encodedAttrs) {
   const { node, table, row, rowBorders, styleTag, columnIndex, columnWidth } = params.extraParams;
   const schemaNode = handleTableCellNode({
     params,
@@ -25950,23 +26037,23 @@ function encode$2(params, encodedAttrs) {
   }
   return schemaNode;
 }
-function decode$2(params, decodedAttrs) {
+function decode$r(params, decodedAttrs) {
   const translated = translateTableCell(params);
   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,
@@ -25974,7 +26061,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"),
   {
@@ -25987,7 +26074,7 @@ const validXmlAttributes$1 = [
   _createAttributeHandler("r:id", "rId"),
   _createAttributeHandler("w:tgtFrame", "target")
 ];
-const encode$1 = (params, encodedAttrs) => {
+const encode$z = (params, encodedAttrs) => {
   const { nodes, docx, nodeListHandler } = params;
   const node = nodes[0];
   let href = _resolveHref(docx, encodedAttrs);
@@ -26001,7 +26088,16 @@ const encode$1 = (params, encodedAttrs) => {
     nodes: runNodes,
     path: [...params.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"];
@@ -26018,7 +26114,7 @@ const _resolveHref = (docx, encodedAttrs) => {
   }
   return href;
 };
-function decode$1(params) {
+function decode$q(params) {
   const { node } = params;
   const linkMark = node.marks.find((m2) => m2.type === "link");
   const linkAttrs = this.decodeAttributes({ ...params, node: linkMark });
@@ -26062,15 +26158,15 @@ function _addNewLinkRelationship(params, 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 {};
@@ -26081,7 +26177,7 @@ function parseTagValueJSON(json) {
   }
   try {
     return JSON.parse(trimmed);
-  } catch (err) {
+  } catch {
     return {};
   }
 }
@@ -27883,10 +27979,10 @@ function translateStructuredContent(params) {
   };
   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(params, encodedAttrs) {
+const validXmlAttributes$a = [];
+function encode$y(params) {
   const nodes = params.nodes;
   const node = nodes[0];
   const { type: sdtType, handler: handler2 } = sdtNodeTypeStrategy(node);
@@ -27896,7 +27992,7 @@ function encode(params, encodedAttrs) {
   const result = handler2(params);
   return result;
 }
-function decode(params, decodedAttrs) {
+function decode$p(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
@@ -27912,43 +28008,138 @@ function decode(params, 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,
-  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 = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  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 = (params) => {
+  const attrs = params?.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(params) {
   const { type: type2 } = params.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(params, "Start"),
     commentRangeEnd: () => translateCommentNode(params, "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
   };
@@ -28271,7 +28462,7 @@ function translateTextNode(params) {
   const isTrackedNode = node.marks?.some((m2) => trackedMarks.includes(m2.type));
   if (isTrackedNode) return translateTrackedNode(params);
   const isLinkNode = node.marks?.some((m2) => m2.type === "link");
-  if (isLinkNode) return translator$1.decode(params);
+  if (isLinkNode) return translator$c.decode(params);
   const { text, marks = [] } = node;
   return getTextNodeForExport(text, marks, params);
 }
@@ -28756,10 +28947,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;
@@ -28801,12 +29002,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;
 }
@@ -29674,82 +29874,912 @@ const trackChangeNodeHandlerEntity = {
   handlerName: "trackChangeNodeHandler",
   handler: handleTrackChangeNode
 };
-const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$1);
-const handleRunNode = (params) => {
-  const { nodes, nodeListHandler, parentStyleId, docx } = params;
-  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 = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
   const node = nodes[0];
-  const childParams = { ...params, nodes: node.elements, path: [...params.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 exists = combinedMarks.some(
-        (mark) => mark.type === runStyle.type && JSON.stringify(mark.attrs || {}) === JSON.stringify(runStyle.attrs || {})
-      );
-      if (!exists) {
-        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 = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  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 = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  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 = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  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 = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  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 = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  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 = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  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 = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  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 = (params) => {
+  const { nodes } = params;
+  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({ ...params, 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 = (params, rPrNode, translator2 = translator$1) => {
+  if (!rPrNode) return { entries: [], hadRPr: false, styleChangeMarks: [] };
+  const result = translator2.encode({ ...params, 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, [], params?.docx) || [];
+  const styleChangeMarks = handleStyleChangeMarks(rPrNode, legacyMarks) || [];
+  return { entries, hadRPr: true, styleChangeMarks };
+};
+const buildRunAttrs = (encodedAttrs = {}, hadRPr, runProps) => {
+  const base = { ...encodedAttrs || {} };
+  if (hadRPr) {
+    base.runProperties = runProps.length ? runProps : null;
+  }
+  return base;
+};
+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 map = /* @__PURE__ */ new Map();
+  markSets.filter(Boolean).forEach((marks) => {
     marks.forEach((mark) => {
-      const exists = combinedMarks.some(
-        (existing) => existing.type === mark.type && JSON.stringify(existing.attrs || {}) === JSON.stringify(mark.attrs || {})
-      );
-      if (!exists) {
-        combinedMarks.push(mark);
-      }
+      if (!mark || !mark.type) return;
+      map.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(map.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 = (params, encodedAttrs = {}) => {
+  const { nodes = [], nodeListHandler } = params || {};
+  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(params, rPrNode);
+  const { remainingProps, inlineMarks, textStyleAttrs, runStyleId } = splitRunProperties(runPropEntries, params?.docx);
+  const styleMarks = deriveStyleMarks({
+    docx: params?.docx,
+    paragraphStyleId: params?.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 = { ...params, 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 = (params, decodedAttrs = {}) => {
+  const { node } = params || {};
+  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 = { ...params, 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((style2) => style2.name === "w:style");
-  const style = styleTags.find((tag) => tag.attributes["w:styleId"] === styleId) || {};
-  if (!style) return {};
-  return parseProperties(style);
+  return translated;
 };
-const runNodeHandlerEntity = {
-  handlerName: "runNodeHandler",
-  handler: handleRunNode
+const config = {
+  xmlName: XML_NODE_NAME,
+  sdNodeOrKeyName: SD_KEY_NAME,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode,
+  decode,
+  attributes: validXmlAttributes
 };
+const translator = NodeTranslator.from(config);
+const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator);
 const handleTextNode = (params) => {
   const { nodes, insideTrackChange } = params;
   if (nodes.length === 0 || !(nodes[0].name === "w:t" || insideTrackChange && nodes[0].name === "w:delText")) {
@@ -29786,7 +30816,7 @@ const handleParagraphNode = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$h.encode(params);
+  const schemaNode = translator$s.encode(params);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -29799,7 +30829,7 @@ const handleSdtNode = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:sdt") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator.encode(params);
+  const result = translator$b.encode(params);
   if (!result) {
     return { nodes: [], consumed: 0 };
   }
@@ -29889,7 +30919,7 @@ const handler = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$j.encode(params);
+  const result = translator$v.encode(params);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -30585,7 +31615,7 @@ const handleTabNode = (params) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$i.encode(params);
+  const node = translator$t.encode(params);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
@@ -31032,6 +32062,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 _SuperConverter {
   constructor(params = null) {
     __privateAdd(this, _SuperConverter_instances);
@@ -31067,6 +32107,31 @@ const _SuperConverter = class _SuperConverter {
     this.documentId = params?.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 = _SuperConverter.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 = _SuperConverter.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.
@@ -31112,7 +32177,7 @@ const _SuperConverter = class _SuperConverter {
       return;
     }
   }
-  static updateDocumentVersion(docx = this.convertedXml, version = "0.20.0") {
+  static updateDocumentVersion(docx = this.convertedXml, version = "0.21.0-RC1") {
     const customLocation = "docProps/custom.xml";
     if (!docx[customLocation]) {
       docx[customLocation] = generateCustomXml();
@@ -31163,13 +32228,19 @@ const _SuperConverter = class _SuperConverter {
       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 fontSize = typeface ?? rPr?.elements?.find((el) => el.name === "w:sz")?.attributes["w:val"];
-        fontSizeNormal = !fontSizeNormal && fontSize ? Number(fontSize) / 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 = _SuperConverter.toCssFontFamily(typeface, this.convertedXml);
+      return { fontSizePt, kern, typeface, panose, fontFamilyCss };
     }
   }
   getDocumentFonts() {
@@ -31602,7 +32673,7 @@ function storeSuperdocVersion(docx) {
 function generateCustomXml() {
   return DEFAULT_CUSTOM_XML;
 }
-function generateSuperdocVersion(pid = 2, version = "0.20.0") {
+function generateSuperdocVersion(pid = 2, version = "0.21.0-RC1") {
   return {
     type: "element",
     name: "property",
@@ -31655,6 +32726,7 @@ export {
   objectIncludes as Z,
   AddMarkStep as _,
   Plugin as a,
+  translator$v as a$,
   twipsToLines as a0,
   pixelsToTwips as a1,
   helpers as a2,
@@ -31670,10 +32742,28 @@ export {
   readFromClipboard as aC,
   handleClipboardPaste as aD,
   getFileObject as aE,
-  translator$h as aF,
-  translator$i as aG,
-  translator$j as aH,
-  _sfc_main as aI,
+  runPropertyTranslators as aF,
+  translator$g as aG,
+  translator$h as aH,
+  translator$f as aI,
+  translator$i as aJ,
+  translator$e as aK,
+  translator$d as aL,
+  translator$j as aM,
+  translator$k as aN,
+  translator$t as aO,
+  translator$b as aP,
+  translator$1 as aQ,
+  translator as aR,
+  translator$s as aS,
+  translator$l as aT,
+  translator$c as aU,
+  translator$m as aV,
+  translator$n as aW,
+  translator$o as aX,
+  translator$p as aY,
+  translator$q as aZ,
+  translator$r as a_,
   hasSomeParentWithClass as aa,
   isActive as ab,
   unflattenListsInHtml as ac,
@@ -31701,6 +32791,7 @@ export {
   getContentTypesFromXml as ay,
   xmljs as az,
   Slice as b,
+  _sfc_main as b0,
   DOMParser$1 as c,
   Mark as d,
   dropPoint as e,