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

package/dist/super-editor/chunks/{converter-Brf9NxwA.js → converter-BJVy6JMW.js}

@@ -14886,25 +14886,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;
@@ -24301,37 +24323,37 @@ const _NodeTranslator = class _NodeTranslator {
 /** @type {typeof TranslatorTypes} */
 __publicField(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$A = (attributes) => {
+const encode$17 = (attributes) => {
   return attributes["w:type"];
 };
-const decode$A = (attrs) => {
+const decode$_ = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
-const attrConfig$i = Object.freeze({
+const attrConfig$F = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$A,
-  decode: decode$A
+  encode: encode$17,
+  decode: decode$_
 });
-const encode$z = (attributes) => {
+const encode$16 = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$z = (attrs) => {
+const decode$Z = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
-const attrConfig$h = Object.freeze({
+const attrConfig$E = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$z,
-  decode: decode$z
+  encode: encode$16,
+  decode: decode$Z
 });
-const validXmlAttributes$b = [attrConfig$i, attrConfig$h];
-const XML_NODE_NAME$h = "w:br";
+const validXmlAttributes$l = [attrConfig$F, attrConfig$E];
+const XML_NODE_NAME$t = "w:br";
 const SD_NODE_NAME$c = "lineBreak";
-const encode$y = (_2, encodedAttrs) => {
+const encode$15 = (_2, encodedAttrs) => {
   const isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -24341,7 +24363,7 @@ const encode$y = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$y = (params, decodedAttrs) => {
+const decode$Y = (params, decodedAttrs) => {
   const { node } = params;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24358,63 +24380,125 @@ const decode$y = (params, decodedAttrs) => {
   };
   return translated;
 };
-const config$f = {
-  xmlName: XML_NODE_NAME$h,
+const config$r = {
+  xmlName: XML_NODE_NAME$t,
   sdNodeOrKeyName: SD_NODE_NAME$c,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$y,
-  decode: decode$y,
-  attributes: validXmlAttributes$b
+  encode: encode$15,
+  decode: decode$Y,
+  attributes: validXmlAttributes$l
+};
+const translator$15 = NodeTranslator.from(config$r);
+const encode$14 = (attributes) => attributes?.["w:val"];
+const decode$X = (attrs) => attrs?.highlight;
+const attrConfig$D = Object.freeze({
+  xmlName: "w:val",
+  sdName: "highlight",
+  encode: encode$14,
+  decode: decode$X
+});
+const validXmlAttributes$k = [attrConfig$D];
+const XML_NODE_NAME$s = "w:highlight";
+const SD_ATTR_KEY$f = "highlight";
+const DISABLED_TOKENS = /* @__PURE__ */ new Set(["transparent", "none", "inherit"]);
+const encode$13 = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  const node = nodes?.[0];
+  const value = encodedAttrs.highlight ?? node?.attributes?.["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$s,
+    sdNodeOrKeyName: SD_ATTR_KEY$f,
+    attributes: { "w:val": value ?? null }
+  };
+};
+const decode$W = (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) return void 0;
+  if (DISABLED_TOKENS.has(normalizedValue)) {
+    return {
+      name: XML_NODE_NAME$s,
+      attributes: { "w:val": "none" }
+    };
+  }
+  const keyword = getDocxHighlightKeywordFromHex(highlightValue);
+  if (keyword) {
+    return {
+      name: XML_NODE_NAME$s,
+      attributes: { "w:val": keyword }
+    };
+  }
+  const fill = normalizeHexColor(highlightValue);
+  if (!fill) return void 0;
+  return {
+    name: "w:shd",
+    attributes: {
+      "w:color": "auto",
+      "w:val": "clear",
+      "w:fill": fill
+    }
+  };
 };
-const translator$V = NodeTranslator.from(config$f);
-const encode$x = (attributes) => {
+const config$q = {
+  xmlName: XML_NODE_NAME$s,
+  sdNodeOrKeyName: SD_ATTR_KEY$f,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$13,
+  decode: decode$W,
+  attributes: validXmlAttributes$k
+};
+const translator$14 = NodeTranslator.from(config$q);
+const encode$12 = (attributes) => {
   return attributes["w:val"];
 };
-const decode$x = (attrs) => {
+const decode$V = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
-const attrConfig$g = Object.freeze({
+const attrConfig$C = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$x,
-  decode: decode$x
+  encode: encode$12,
+  decode: decode$V
 });
-const encode$w = (attributes) => {
+const encode$11 = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$w = (attrs) => {
+const decode$U = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
-const attrConfig$f = Object.freeze({
+const attrConfig$B = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$w,
-  decode: decode$w
+  encode: encode$11,
+  decode: decode$U
 });
-const encode$v = (attributes) => {
+const encode$10 = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$v = (attrs) => {
+const decode$T = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
-const attrConfig$e = Object.freeze({
+const attrConfig$A = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$v,
-  decode: decode$v
+  encode: encode$10,
+  decode: decode$T
 });
-const validXmlAttributes$a = [attrConfig$g, attrConfig$e, attrConfig$f];
-const XML_NODE_NAME$g = "w:tab";
+const validXmlAttributes$j = [attrConfig$C, attrConfig$A, attrConfig$B];
+const XML_NODE_NAME$r = "w:tab";
 const SD_NODE_NAME$b = "tab";
-const encode$u = (_2, encodedAttrs = {}) => {
+const encode$$ = (_2, encodedAttrs = {}) => {
   const translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$u = (params, decodedAttrs = {}) => {
+const decode$S = (params, decodedAttrs = {}) => {
   const { node } = params || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24430,15 +24514,15 @@ const decode$u = (params, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$e = {
-  xmlName: XML_NODE_NAME$g,
+const config$p = {
+  xmlName: XML_NODE_NAME$r,
   sdNodeOrKeyName: SD_NODE_NAME$b,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$u,
-  decode: decode$u,
-  attributes: validXmlAttributes$a
+  encode: encode$$,
+  decode: decode$S,
+  attributes: validXmlAttributes$j
 };
-const translator$U = NodeTranslator.from(config$e);
+const translator$13 = NodeTranslator.from(config$p);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -24613,17 +24697,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"];
@@ -24644,7 +24732,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 {};
@@ -24674,27 +24766,39 @@ const getParagraphIndent = (node, docx, styleId = "") => {
     right: 0,
     firstLine: 0,
     hanging: 0,
-    textIndent: 0
+    textIndent: 0,
+    explicitLeft: false,
+    explicitRight: false,
+    explicitFirstLine: false,
+    explicitHanging: false
   };
   const { indent: pDefaultIndent = {} } = getDefaultParagraphStyle(docx, styleId);
   const pPr = node.elements?.find((el) => el.name === "w:pPr");
   const inLineIndentTag = pPr?.elements?.find((el) => el.name === "w:ind");
   const inLineIndent = inLineIndentTag?.attributes || {};
-  const leftIndent = inLineIndent?.["w:left"] || pDefaultIndent?.["w:left"];
-  const rightIndent = inLineIndent?.["w:right"] || pDefaultIndent?.["w:right"];
-  const firstLine = inLineIndent?.["w:firstLine"] || pDefaultIndent?.["w:firstLine"];
-  const hanging = inLineIndent?.["w:hanging"] || pDefaultIndent?.["w:hanging"];
+  const inlineLeft = inLineIndent?.["w:left"];
+  const inlineRight = inLineIndent?.["w:right"];
+  const inlineFirstLine = inLineIndent?.["w:firstLine"];
+  const inlineHanging = inLineIndent?.["w:hanging"];
+  const leftIndent = inlineLeft ?? pDefaultIndent?.["w:left"];
+  const rightIndent = inlineRight ?? pDefaultIndent?.["w:right"];
+  const firstLine = inlineFirstLine ?? pDefaultIndent?.["w:firstLine"];
+  const hanging = inlineHanging ?? pDefaultIndent?.["w:hanging"];
   if (leftIndent) {
     indent.left = twipsToPixels(leftIndent);
+    indent.explicitLeft = inlineLeft !== void 0;
   }
   if (rightIndent) {
     indent.right = twipsToPixels(rightIndent);
+    indent.explicitRight = inlineRight !== void 0;
   }
   if (firstLine) {
     indent.firstLine = twipsToPixels(firstLine);
+    indent.explicitFirstLine = inlineFirstLine !== void 0;
   }
   if (hanging) {
     indent.hanging = twipsToPixels(hanging);
+    indent.explicitHanging = inlineHanging !== void 0;
   }
   const textIndentValue = leftIndent - parseInt(hanging || 0) || 0;
   if (textIndentValue) {
@@ -25033,102 +25137,102 @@ const handleParagraphNode$1 = (params) => {
   }
   return schemaNode;
 };
-const encode$t = (attributes) => {
+const encode$_ = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$t = (attrs) => {
+const decode$R = (attrs) => {
   return attrs.rsidDel;
 };
-const attrConfig$d = Object.freeze({
+const attrConfig$z = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$t,
-  decode: decode$t
+  encode: encode$_,
+  decode: decode$R
 });
-const encode$s = (attributes) => {
+const encode$Z = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$s = (attrs) => {
+const decode$Q = (attrs) => {
   return attrs.rsidP;
 };
-const attrConfig$c = Object.freeze({
+const attrConfig$y = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$s,
-  decode: decode$s
+  encode: encode$Z,
+  decode: decode$Q
 });
-const encode$r = (attributes) => {
+const encode$Y = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$r = (attrs) => {
+const decode$P = (attrs) => {
   return attrs.rsidR;
 };
-const attrConfig$b = Object.freeze({
+const attrConfig$x = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$r,
-  decode: decode$r
+  encode: encode$Y,
+  decode: decode$P
 });
-const encode$q = (attributes) => {
+const encode$X = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$q = (attrs) => {
+const decode$O = (attrs) => {
   return attrs.rsidRPr;
 };
-const attrConfig$a = Object.freeze({
+const attrConfig$w = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$q,
-  decode: decode$q
+  encode: encode$X,
+  decode: decode$O
 });
-const encode$p = (attributes) => {
+const encode$W = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$p = (attrs) => {
+const decode$N = (attrs) => {
   return attrs.rsidRDefault;
 };
-const attrConfig$9 = Object.freeze({
+const attrConfig$v = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$p,
-  decode: decode$p
+  encode: encode$W,
+  decode: decode$N
 });
-const encode$o = (attributes) => {
+const encode$V = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$o = (attrs) => {
+const decode$M = (attrs) => {
   return attrs.paraId;
 };
-const attrConfig$8 = Object.freeze({
+const attrConfig$u = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$o,
-  decode: decode$o
+  encode: encode$V,
+  decode: decode$M
 });
-const encode$n = (attributes) => {
+const encode$U = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$n = (attrs) => {
+const decode$L = (attrs) => {
   return attrs.textId;
 };
-const attrConfig$7 = Object.freeze({
+const attrConfig$t = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$n,
-  decode: decode$n
+  encode: encode$U,
+  decode: decode$L
 });
-const validXmlAttributes$9 = [
-  attrConfig$8,
-  attrConfig$7,
-  attrConfig$b,
-  attrConfig$9,
-  attrConfig$c,
-  attrConfig$a,
-  attrConfig$d
+const validXmlAttributes$i = [
+  attrConfig$u,
+  attrConfig$t,
+  attrConfig$x,
+  attrConfig$v,
+  attrConfig$y,
+  attrConfig$w,
+  attrConfig$z
 ];
-const XML_NODE_NAME$f = "w:p";
+const XML_NODE_NAME$q = "w:p";
 const SD_NODE_NAME$a = "paragraph";
-const encode$m = (params, encodedAttrs = {}) => {
+const encode$T = (params, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25136,7 +25240,7 @@ const encode$m = (params, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$m = (params, decodedAttrs = {}) => {
+const decode$K = (params, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25144,167 +25248,1322 @@ const decode$m = (params, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$d = {
-  xmlName: XML_NODE_NAME$f,
+const config$o = {
+  xmlName: XML_NODE_NAME$q,
   sdNodeOrKeyName: SD_NODE_NAME$a,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$m,
-  decode: decode$m,
-  attributes: validXmlAttributes$9
+  encode: encode$T,
+  decode: decode$K,
+  attributes: validXmlAttributes$i
+};
+const translator$12 = NodeTranslator.from(config$o);
+const encode$S = (attributes) => {
+  const raw = attributes?.["w:val"];
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw === "number") return raw !== 0;
+  const val = String(raw).trim().toLowerCase();
+  if (val === "0" || val === "false" || val === "off") return false;
+  if (val === "1" || val === "true" || val === "on") return true;
+  return void 0;
 };
-const translator$T = NodeTranslator.from(config$d);
-const generateV2HandlerEntity = (handlerName, translator2) => ({
-  handlerName,
-  handler: (params) => {
-    const { nodes } = params;
-    if (nodes.length === 0 || nodes[0].name !== translator2.xmlName) {
-      return { nodes: [], consumed: 0 };
-    }
-    const result = translator2.encode(params);
-    if (!result) return { nodes: [], consumed: 0 };
-    return {
-      nodes: Array.isArray(result) ? result : [result],
-      consumed: 1
-    };
-  }
+const decode$J = (runProps) => {
+  if (runProps?.bold === false) return "0";
+  return void 0;
+};
+const attrConfig$s = Object.freeze({
+  xmlName: "w:val",
+  sdName: "bold",
+  encode: encode$S,
+  decode: decode$J
 });
-function createSingleAttrPropertyHandler(xmlName, sdName = null, attrName = "w:val", transformEncode = null, transformDecode = null) {
-  if (!sdName) sdName = xmlName.split(":")[1];
-  if (!transformEncode) transformEncode = (v2) => v2;
-  if (!transformDecode) transformDecode = (v2) => v2;
+const validXmlAttributes$h = [attrConfig$s];
+const XML_NODE_NAME$p = "w:b";
+const SD_ATTR_KEY$e = "bold";
+const encode$R = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  const node = nodes[0];
+  if (!node) return void 0;
+  const val = encodedAttrs?.[SD_ATTR_KEY$e];
+  let attributes;
+  if (val === false) attributes = { "w:val": "0" };
+  else if (val === true)
+    attributes = {};
+  else attributes = node.attributes || {};
   return {
-    xmlName,
-    sdNodeOrKeyName: sdName,
-    encode: ({ nodes }) => {
-      return transformEncode(nodes[0].attributes[attrName]) ?? void 0;
-    },
-    decode: ({ node }) => {
-      const value = node.attrs?.[sdName] != null ? transformDecode(node.attrs[sdName]) : void 0;
-      return value != null ? { name: xmlName, attributes: { [attrName]: value } } : void 0;
-    }
+    type: "attr",
+    xmlName: XML_NODE_NAME$p,
+    sdNodeOrKeyName: SD_ATTR_KEY$e,
+    attributes
   };
-}
-function createMeasurementPropertyHandler(xmlName, sdName = null) {
-  if (!sdName) sdName = xmlName.split(":")[1];
+};
+const config$n = {
+  xmlName: XML_NODE_NAME$p,
+  sdNodeOrKeyName: SD_ATTR_KEY$e,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$R,
+  attributes: validXmlAttributes$h
+};
+const translator$11 = NodeTranslator.from(config$n);
+const XML_NODE_NAME$o = "w:i";
+const SD_ATTR_KEY$d = "italic";
+const encode$Q = (params) => {
+  const { nodes } = params;
+  const node = nodes?.[0];
+  if (!node) return void 0;
   return {
-    xmlName,
-    sdNodeOrKeyName: sdName,
-    attributes: [
-      createAttributeHandler("w:w", "value", parseInteger, integerToString),
-      createAttributeHandler("w:type")
-    ],
-    encode: (_2, encodedAttrs) => {
-      return encodedAttrs["value"] != null ? encodedAttrs : void 0;
-    },
-    decode: function({ node }) {
-      const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs[sdName] || {} } });
-      return decodedAttrs["w:w"] != null ? { attributes: decodedAttrs } : void 0;
+    type: "attr",
+    xmlName: XML_NODE_NAME$o,
+    sdNodeOrKeyName: SD_ATTR_KEY$d,
+    attributes: {
+      "w:val": node.attributes?.["w:val"] ?? null
     }
   };
-}
-function createBorderPropertyHandler(xmlName, sdName = null) {
-  if (!sdName) sdName = xmlName.split(":")[1];
+};
+const config$m = {
+  xmlName: XML_NODE_NAME$o,
+  sdNodeOrKeyName: SD_ATTR_KEY$d,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$Q
+};
+const translator$10 = NodeTranslator.from(config$m);
+const encode$P = (attributes) => attributes?.["w:val"];
+const decode$I = (attrs) => attrs?.underline;
+const attrConfig$r = Object.freeze({
+  xmlName: "w:val",
+  sdName: "underline",
+  encode: encode$P,
+  decode: decode$I
+});
+const encode$O = (attributes) => attributes?.["w:color"];
+const decode$H = (attrs) => attrs?.color;
+const attrConfig$q = Object.freeze({
+  xmlName: "w:color",
+  sdName: "color",
+  encode: encode$O,
+  decode: decode$H
+});
+const encode$N = (attributes) => attributes?.["w:themeColor"];
+const decode$G = (attrs) => attrs?.themeColor;
+const attrConfig$p = Object.freeze({
+  xmlName: "w:themeColor",
+  sdName: "themeColor",
+  encode: encode$N,
+  decode: decode$G
+});
+const encode$M = (attributes) => attributes?.["w:themeTint"];
+const decode$F = (attrs) => attrs?.themeTint;
+const attrConfig$o = Object.freeze({
+  xmlName: "w:themeTint",
+  sdName: "themeTint",
+  encode: encode$M,
+  decode: decode$F
+});
+const encode$L = (attributes) => attributes?.["w:themeShade"];
+const decode$E = (attrs) => attrs?.themeShade;
+const attrConfig$n = Object.freeze({
+  xmlName: "w:themeShade",
+  sdName: "themeShade",
+  encode: encode$L,
+  decode: decode$E
+});
+const validXmlAttributes$g = [attrConfig$r, attrConfig$q, attrConfig$p, attrConfig$o, attrConfig$n];
+const XML_NODE_NAME$n = "w:u";
+const SD_ATTR_KEY$c = "underline";
+const encode$K = (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 {
-    xmlName,
-    sdNodeOrKeyName: sdName,
-    attributes: [
-      createAttributeHandler("w:val"),
-      createAttributeHandler("w:color"),
-      createAttributeHandler("w:themeColor"),
-      createAttributeHandler("w:themeTint"),
-      createAttributeHandler("w:themeShade"),
-      createAttributeHandler("w:sz", "size", parseInteger, integerToString),
-      createAttributeHandler("w:space", null, parseInteger, integerToString),
-      createAttributeHandler("w:shadow", null, parseBoolean, booleanToString),
-      createAttributeHandler("w:frame", null, parseBoolean, booleanToString)
-    ],
-    encode: (params, encodedAttrs) => {
-      return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
-    },
-    decode: function({ node }, context) {
-      const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs[sdName] || {} } });
-      return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
-    }
+    type: "attr",
+    xmlName: XML_NODE_NAME$n,
+    sdNodeOrKeyName: SD_ATTR_KEY$c,
+    attributes
   };
-}
-const createAttributeHandler = (xmlName, sdName = null, transformEncode = null, transformDecode = null) => {
-  if (!transformEncode) transformEncode = (v2) => v2;
-  if (!transformDecode) transformDecode = (v2) => v2;
-  if (!sdName) sdName = xmlName.split(":")[1];
+};
+const decode$D = (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 {
-    xmlName,
-    sdName,
-    encode: (attributes) => transformEncode(attributes[xmlName]),
-    decode: (attributes) => transformDecode(attributes[sdName])
+    name: XML_NODE_NAME$n,
+    attributes
   };
 };
-function encodeProperties(node, translatorsByXmlName, asArray = false) {
-  if (!node?.elements || node.elements.length === 0) {
-    return asArray ? [] : {};
-  }
-  const attributes = asArray ? [] : {};
-  node.elements.forEach((el) => {
-    const translator2 = translatorsByXmlName[el.name];
-    if (translator2) {
-      const encodedAttr = translator2.encode({ nodes: [el] });
-      if (encodedAttr != null) {
-        if (asArray) {
-          attributes.push({ [translator2.sdNodeOrKeyName]: encodedAttr });
-        } else {
-          attributes[translator2.sdNodeOrKeyName] = encodedAttr;
-        }
-      }
-    }
-  });
-  return attributes;
-}
-function decodeProperties(translatorsBySdName, properties) {
-  if (!properties || typeof properties !== "object") {
-    return [];
-  }
-  const elements = [];
-  Object.keys(properties).forEach((key) => {
-    const translator2 = translatorsBySdName[key];
-    if (translator2) {
-      const result = translator2.decode({ node: { attrs: { [key]: properties[key] } } });
-      if (result != null) {
-        result.name = translator2.xmlName;
-        elements.push(result);
-      }
-    }
-  });
-  return elements;
-}
-const parseBoolean = (value) => value != null ? ["1", "true"].includes(value) : void 0;
-const booleanToString = (value) => value != null ? value ? "1" : "0" : void 0;
-const parseInteger = (value) => {
-  if (value == null) return void 0;
-  const intValue = parseInt(value, 10);
-  return isNaN(intValue) ? void 0 : intValue;
+const config$l = {
+  xmlName: XML_NODE_NAME$n,
+  sdNodeOrKeyName: SD_ATTR_KEY$c,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$K,
+  decode: decode$D,
+  attributes: validXmlAttributes$g
+};
+const translator$$ = NodeTranslator.from(config$l);
+const encode$J = (attributes) => {
+  const raw = attributes?.["w:val"];
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw === "number") return raw !== 0;
+  const val = String(raw).trim().toLowerCase();
+  if (val === "0" || val === "false" || val === "off") return false;
+  if (val === "1" || val === "true" || val === "on") return true;
+  return void 0;
 };
-const integerToString = (value) => {
-  const intValue = parseInteger(value);
-  return intValue != void 0 ? String(intValue) : void 0;
+const decode$C = (attrs) => {
+  if (attrs?.strike === false) return "0";
+  return void 0;
 };
-function preProcessVerticalMergeCells(table, { editorSchema }) {
-  if (!table || !Array.isArray(table.content)) {
-    return table;
-  }
-  const rows = table.content;
-  for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
-    const row = rows[rowIndex];
-    if (!row) continue;
-    if (!Array.isArray(row.content)) {
-      row.content = [];
-    }
-    for (let cellIndex = 0; cellIndex < row.content.length; cellIndex++) {
-      const cell = row.content[cellIndex];
-      if (!cell) continue;
-      const attrs = cell.attrs || {};
-      if (!attrs.rowspan || attrs.rowspan <= 1) continue;
-      const maxRowspan = Math.min(attrs.rowspan, rows.length - rowIndex);
-      for (let offset = 1; offset < maxRowspan; offset++) {
-        const rowToChange = rows[rowIndex + offset];
+const attrConfig$m = Object.freeze({
+  xmlName: "w:val",
+  sdName: "strike",
+  encode: encode$J,
+  decode: decode$C
+});
+const validXmlAttributes$f = [attrConfig$m];
+const XML_NODE_NAME$m = "w:strike";
+const SD_ATTR_KEY$b = "strike";
+const encode$I = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  const node = nodes?.[0];
+  if (!node) return void 0;
+  const val = encodedAttrs?.[SD_ATTR_KEY$b];
+  let attributes;
+  if (val === false) attributes = { "w:val": "0" };
+  else if (val === true) attributes = {};
+  else attributes = { ...node.attributes || {} };
+  if (attributes["w:val"] === void 0 && val !== true) attributes["w:val"] = null;
+  else if (val === true && attributes["w:val"] === void 0) delete attributes["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$m,
+    sdNodeOrKeyName: SD_ATTR_KEY$b,
+    attributes
+  };
+};
+const config$k = {
+  xmlName: XML_NODE_NAME$m,
+  sdNodeOrKeyName: SD_ATTR_KEY$b,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$I,
+  attributes: validXmlAttributes$f
+};
+const translator$_ = NodeTranslator.from(config$k);
+const encode$H = (attributes) => attributes?.["w:val"];
+const decode$B = (attrs) => attrs?.color;
+const attrConfig$l = Object.freeze({
+  xmlName: "w:val",
+  sdName: "color",
+  encode: encode$H,
+  decode: decode$B
+});
+const encode$G = (attributes) => attributes?.["w:themeColor"];
+const decode$A = (attrs) => attrs?.themeColor;
+const attrConfig$k = Object.freeze({
+  xmlName: "w:themeColor",
+  sdName: "themeColor",
+  encode: encode$G,
+  decode: decode$A
+});
+const encode$F = (attributes) => attributes?.["w:themeTint"];
+const decode$z = (attrs) => attrs?.themeTint;
+const attrConfig$j = Object.freeze({
+  xmlName: "w:themeTint",
+  sdName: "themeTint",
+  encode: encode$F,
+  decode: decode$z
+});
+const encode$E = (attributes) => attributes?.["w:themeShade"];
+const decode$y = (attrs) => attrs?.themeShade;
+const attrConfig$i = Object.freeze({
+  xmlName: "w:themeShade",
+  sdName: "themeShade",
+  encode: encode$E,
+  decode: decode$y
+});
+const validXmlAttributes$e = [attrConfig$l, attrConfig$k, attrConfig$j, attrConfig$i];
+const XML_NODE_NAME$l = "w:color";
+const SD_ATTR_KEY$a = "color";
+const encode$D = (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$l,
+    sdNodeOrKeyName: SD_ATTR_KEY$a,
+    attributes
+  };
+};
+const config$j = {
+  xmlName: XML_NODE_NAME$l,
+  sdNodeOrKeyName: SD_ATTR_KEY$a,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$D,
+  attributes: validXmlAttributes$e
+};
+const translator$Z = NodeTranslator.from(config$j);
+const encode$C = (attributes) => attributes?.["w:eastAsia"];
+const decode$x = (attrs) => attrs?.eastAsia;
+const attrConfig$h = Object.freeze({
+  xmlName: "w:eastAsia",
+  sdName: "eastAsia",
+  encode: encode$C,
+  decode: decode$x
+});
+const encode$B = (attributes) => attributes?.["w:ascii"];
+const decode$w = (attrs) => attrs?.ascii;
+const attrConfig$g = Object.freeze({
+  xmlName: "w:ascii",
+  sdName: "ascii",
+  encode: encode$B,
+  decode: decode$w
+});
+const encode$A = (attributes) => attributes?.["w:hAnsi"];
+const decode$v = (attrs) => attrs?.hAnsi;
+const attrConfig$f = Object.freeze({
+  xmlName: "w:hAnsi",
+  sdName: "hAnsi",
+  encode: encode$A,
+  decode: decode$v
+});
+const encode$z = (attributes) => attributes?.["w:cs"];
+const decode$u = (attrs) => attrs?.cs;
+const attrConfig$e = Object.freeze({
+  xmlName: "w:cs",
+  sdName: "cs",
+  encode: encode$z,
+  decode: decode$u
+});
+const encode$y = (attributes) => attributes?.["w:val"];
+const decode$t = (attrs) => attrs?.value;
+const attrConfig$d = Object.freeze({
+  xmlName: "w:val",
+  sdName: "value",
+  encode: encode$y,
+  decode: decode$t
+});
+const validXmlAttributes$d = [attrConfig$h, attrConfig$g, attrConfig$f, attrConfig$e, attrConfig$d];
+const XML_NODE_NAME$k = "w:rFonts";
+const SD_ATTR_KEY$9 = "fontFamily";
+const encode$x = (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$k,
+    sdNodeOrKeyName: SD_ATTR_KEY$9,
+    attributes
+  };
+};
+const config$i = {
+  xmlName: XML_NODE_NAME$k,
+  sdNodeOrKeyName: SD_ATTR_KEY$9,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$x,
+  attributes: validXmlAttributes$d
+};
+const translator$Y = NodeTranslator.from(config$i);
+const encode$w = (attributes) => attributes?.["w:val"];
+const decode$s = (attrs) => attrs?.styleId;
+const attrConfig$c = Object.freeze({
+  xmlName: "w:val",
+  sdName: "styleId",
+  encode: encode$w,
+  decode: decode$s
+});
+const validXmlAttributes$c = [attrConfig$c];
+const XML_NODE_NAME$j = "w:rStyle";
+const SD_ATTR_KEY$8 = "styleId";
+const encode$v = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  const node = nodes?.[0];
+  const value = encodedAttrs.styleId ?? node?.attributes?.["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$j,
+    sdNodeOrKeyName: SD_ATTR_KEY$8,
+    attributes: { "w:val": value ?? null }
+  };
+};
+const config$h = {
+  xmlName: XML_NODE_NAME$j,
+  sdNodeOrKeyName: SD_ATTR_KEY$8,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$v,
+  attributes: validXmlAttributes$c
+};
+const translator$X = NodeTranslator.from(config$h);
+const encode$u = (attributes) => attributes?.["w:val"];
+const decode$r = (attrs) => attrs?.fontSize;
+const attrConfig$b = Object.freeze({
+  xmlName: "w:val",
+  sdName: "fontSize",
+  encode: encode$u,
+  decode: decode$r
+});
+const validXmlAttributes$b = [attrConfig$b];
+const XML_NODE_NAME$i = "w:sz";
+const SD_ATTR_KEY$7 = "fontSize";
+const encode$t = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  const node = nodes?.[0];
+  const value = encodedAttrs.fontSize ?? node?.attributes?.["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$i,
+    sdNodeOrKeyName: SD_ATTR_KEY$7,
+    attributes: { "w:val": value ?? null }
+  };
+};
+const config$g = {
+  xmlName: XML_NODE_NAME$i,
+  sdNodeOrKeyName: SD_ATTR_KEY$7,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$t,
+  attributes: validXmlAttributes$b
+};
+const translator$W = NodeTranslator.from(config$g);
+const encode$s = (attributes) => attributes?.["w:val"];
+const decode$q = (attrs) => attrs?.fontSizeCs;
+const attrConfig$a = Object.freeze({
+  xmlName: "w:val",
+  sdName: "fontSizeCs",
+  encode: encode$s,
+  decode: decode$q
+});
+const validXmlAttributes$a = [attrConfig$a];
+const XML_NODE_NAME$h = "w:szCs";
+const SD_ATTR_KEY$6 = "fontSizeCs";
+const encode$r = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  const node = nodes?.[0];
+  const value = encodedAttrs.fontSizeCs ?? node?.attributes?.["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$h,
+    sdNodeOrKeyName: SD_ATTR_KEY$6,
+    attributes: { "w:val": value ?? null }
+  };
+};
+const config$f = {
+  xmlName: XML_NODE_NAME$h,
+  sdNodeOrKeyName: SD_ATTR_KEY$6,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$r,
+  attributes: validXmlAttributes$a
+};
+const translator$V = NodeTranslator.from(config$f);
+const runPropertyTranslators = Object.freeze({
+  "w:b": translator$11,
+  "w:i": translator$10,
+  "w:u": translator$$,
+  "w:strike": translator$_,
+  "w:color": translator$Z,
+  "w:highlight": translator$14,
+  "w:rFonts": translator$Y,
+  "w:rStyle": translator$X,
+  "w:sz": translator$W,
+  "w:szCs": translator$V
+});
+const rawRunPropertyXmlNames = Object.freeze(["w:lang", "w:shd"]);
+const RAW_CHILD_NAME_SET = new Set(rawRunPropertyXmlNames);
+const KNOWN_CHILD_XML_NAMES = /* @__PURE__ */ new Set([...Object.keys(runPropertyTranslators), ...RAW_CHILD_NAME_SET]);
+const toRunPropertyEntry = (candidate) => {
+  if (!candidate || candidate.type !== "attr") return null;
+  const xmlName = candidate.xmlName || candidate.name;
+  if (!xmlName) return null;
+  return {
+    xmlName,
+    attributes: { ...candidate.attributes || {} }
+  };
+};
+const XML_NODE_NAME$g = "w:rPr";
+const SD_ATTR_KEY$5 = "runProperties";
+const encode$q = (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$e = {
+  xmlName: XML_NODE_NAME$g,
+  sdNodeOrKeyName: SD_ATTR_KEY$5,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$q
+};
+const translator$U = NodeTranslator.from(config$e);
+const EAST_ASIAN_CHARACTER_REGEX = /[\u1100-\u11FF\u2E80-\u2EFF\u2F00-\u2FDF\u3040-\u30FF\u3100-\u312F\u3130-\u318F\u31A0-\u31BF\u3400-\u4DBF\u4E00-\u9FFF\uA960-\uA97F\uAC00-\uD7AF\uF900-\uFAFF\uFF00-\uFFEF]/u;
+const containsEastAsianCharacters = (text) => EAST_ASIAN_CHARACTER_REGEX.test(text);
+const collectRunProperties = (params, rPrNode, translator2 = translator$U) => {
+  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 ensureInlineMarks = (marks, inlineMarks = []) => {
+  inlineMarks.forEach(({ type: type2, attrs }) => {
+    if (!type2) return;
+    if (marks.some((mark) => mark?.type === type2)) return;
+    marks.push(attrs ? { type: type2, attrs: { ...attrs } } : { type: type2 });
+  });
+};
+const ensureTextStyleMark = (marks, textStyleAttrs) => {
+  if (!textStyleAttrs) return;
+  const existingTextStyle = marks.find((mark) => mark?.type === "textStyle");
+  if (existingTextStyle) {
+    existingTextStyle.attrs = { ...existingTextStyle.attrs || {}, ...textStyleAttrs };
+    return;
+  }
+  marks.push({ type: "textStyle", attrs: { ...textStyleAttrs } });
+};
+const normalizeTextStyleAttrsForNode = (textStyleAttrs, node) => {
+  if (!textStyleAttrs || typeof textStyleAttrs !== "object") return null;
+  const normalized = { ...textStyleAttrs };
+  const eastAsiaFont = normalized.eastAsiaFontFamily;
+  if (eastAsiaFont) {
+    delete normalized.eastAsiaFontFamily;
+    const text = typeof node?.text === "string" ? node.text : null;
+    const shouldUseEastAsia = typeof text === "string" && containsEastAsianCharacters(text);
+    if (shouldUseEastAsia) {
+      normalized.fontFamily = eastAsiaFont;
+    }
+  }
+  return Object.keys(normalized).length ? normalized : null;
+};
+const applyRunMarks = (node, inlineMarks, textStyleAttrs) => {
+  if (!node || typeof node !== "object") return node;
+  const baseMarks = Array.isArray(node.marks) ? node.marks : [];
+  const marks = baseMarks.map((mark) => cloneMark$1(mark));
+  ensureInlineMarks(marks, inlineMarks);
+  if (node.type === "text") {
+    const normalizedTextStyle = normalizeTextStyleAttrsForNode(textStyleAttrs, node);
+    ensureTextStyleMark(marks, normalizedTextStyle);
+  }
+  return { ...node, marks };
+};
+const deriveStyleMarks = ({ docx, paragraphStyleId, runStyleId }) => {
+  const paragraphStyleMarks = collectStyleMarks(paragraphStyleId, docx);
+  const runStyleMarks = collectStyleMarks(runStyleId, docx);
+  const inlineMarks = mergeInlineMarkSets(paragraphStyleMarks.inlineMarks, runStyleMarks.inlineMarks);
+  const textStyleAttrs = mergeTextStyleAttrs(paragraphStyleMarks.textStyleAttrs, runStyleMarks.textStyleAttrs);
+  return { inlineMarks, textStyleAttrs };
+};
+const collectStyleMarks = (styleId, docx, seen = /* @__PURE__ */ new Set()) => {
+  if (!styleId || !docx || seen.has(styleId)) return { inlineMarks: [], textStyleAttrs: null };
+  seen.add(styleId);
+  const chain = collectStyleChain(styleId, docx, seen);
+  if (!chain.length) return { inlineMarks: [], textStyleAttrs: null };
+  const inlineMap = /* @__PURE__ */ new Map();
+  let textStyleAttrs = {};
+  chain.forEach((styleTag) => {
+    const marks = extractMarksFromStyle(styleTag, docx);
+    marks.inlineMarks.forEach((mark) => {
+      inlineMap.set(mark.type, mark.attrs ? { type: mark.type, attrs: { ...mark.attrs } } : { type: mark.type });
+    });
+    if (marks.textStyleAttrs) textStyleAttrs = { ...textStyleAttrs, ...marks.textStyleAttrs };
+  });
+  return {
+    inlineMarks: Array.from(inlineMap.values()),
+    textStyleAttrs: Object.keys(textStyleAttrs).length ? textStyleAttrs : null
+  };
+};
+const collectStyleChain = (styleId, docx, seen) => {
+  if (!styleId || !docx) return [];
+  const styleTag = findStyleTag(docx, styleId);
+  if (!styleTag || !styleTag.elements) return [];
+  const basedOn = styleTag.elements?.find((el) => el.name === "w:basedOn")?.attributes?.["w:val"];
+  let chain = [];
+  if (basedOn && !seen.has(basedOn)) {
+    seen.add(basedOn);
+    chain = collectStyleChain(basedOn, docx, seen);
+  }
+  chain.push(styleTag);
+  return chain;
+};
+const findStyleTag = (docx, styleId) => {
+  const stylesFile = docx?.["word/styles.xml"];
+  if (!stylesFile?.elements?.length) return null;
+  const candidates = [];
+  stylesFile.elements.forEach((el) => {
+    if (!el) return;
+    if (el.name === "w:styles" && Array.isArray(el.elements)) {
+      el.elements.forEach((child) => {
+        if (child?.name === "w:style") candidates.push(child);
+      });
+      return;
+    }
+    if (el.name === "w:style") {
+      candidates.push(el);
+      return;
+    }
+    if (Array.isArray(el.elements)) {
+      el.elements.forEach((child) => {
+        if (child?.name === "w:style") candidates.push(child);
+      });
+    }
+  });
+  return candidates.find((tag) => tag?.attributes?.["w:styleId"] === styleId) || null;
+};
+const extractMarksFromStyle = (styleTag, docx) => {
+  const rPr = styleTag?.elements?.find((el) => el.name === "w:rPr");
+  if (!rPr) return { inlineMarks: [], textStyleAttrs: null };
+  const marks = parseMarks(rPr, [], docx) || [];
+  const inlineMarks = [];
+  let textStyleAttrs = {};
+  marks.forEach((mark) => {
+    if (!mark) return;
+    if (mark.type === "textStyle") {
+      const attrs = mark.attrs || {};
+      if (Object.keys(attrs).length) textStyleAttrs = { ...textStyleAttrs, ...attrs };
+      return;
+    }
+    if (mark.type) inlineMarks.push(mark.attrs ? { type: mark.type, attrs: { ...mark.attrs } } : { type: mark.type });
+  });
+  return {
+    inlineMarks,
+    textStyleAttrs: Object.keys(textStyleAttrs).length ? textStyleAttrs : null
+  };
+};
+const mergeInlineMarkSets = (...markSets) => {
+  const map = /* @__PURE__ */ new Map();
+  markSets.filter(Boolean).forEach((marks) => {
+    marks.forEach((mark) => {
+      if (!mark || !mark.type) return;
+      map.set(mark.type, mark.attrs ? { type: mark.type, attrs: { ...mark.attrs } } : { type: mark.type });
+    });
+  });
+  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$1 = (mark) => {
+  if (!mark || typeof mark !== "object") return mark;
+  const cloned = { ...mark };
+  if (mark.attrs && typeof mark.attrs === "object") {
+    cloned.attrs = { ...mark.attrs };
+    if (Array.isArray(mark.attrs.runProperties)) {
+      cloned.attrs.runProperties = mark.attrs.runProperties.map((entry) => ({
+        xmlName: entry?.xmlName,
+        attributes: { ...entry?.attributes || {} }
+      }));
+    }
+  }
+  return cloned;
+};
+const normalizeBool = (value) => {
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === "0" || normalized === "false" || normalized === "off") return false;
+  if (normalized === "1" || normalized === "true" || normalized === "on") return true;
+  return true;
+};
+const createRunPropertiesElement = (entries = []) => {
+  if (!Array.isArray(entries) || !entries.length) return null;
+  const elements = entries.map((entry) => {
+    if (!entry || !entry.xmlName) return null;
+    return {
+      name: entry.xmlName,
+      attributes: { ...entry.attributes || {} }
+    };
+  }).filter(Boolean);
+  if (!elements.length) return null;
+  return {
+    name: "w:rPr",
+    elements
+  };
+};
+const cloneXmlNode = (nodeLike) => {
+  if (!nodeLike || typeof nodeLike !== "object") return nodeLike;
+  return {
+    name: nodeLike.name,
+    type: nodeLike.type,
+    attributes: nodeLike.attributes ? { ...nodeLike.attributes } : void 0,
+    elements: Array.isArray(nodeLike.elements) ? nodeLike.elements.map((el) => cloneXmlNode(el)) : void 0,
+    text: nodeLike.text
+  };
+};
+const applyRunPropertiesTemplate = (runNode, runPropertiesTemplate) => {
+  if (!runNode || !runPropertiesTemplate) return;
+  if (!Array.isArray(runNode.elements)) runNode.elements = [];
+  let runProps = runNode.elements.find((el) => el?.name === "w:rPr");
+  if (!runProps) {
+    runProps = { name: "w:rPr", elements: [] };
+    runNode.elements.unshift(runProps);
+  }
+  if (!Array.isArray(runProps.elements)) runProps.elements = [];
+  if (runPropertiesTemplate.attributes) {
+    runProps.attributes = {
+      ...runProps.attributes || {},
+      ...runPropertiesTemplate.attributes
+    };
+  }
+  const isValidRunPropName = (name) => typeof name === "string" && name.includes(":");
+  runProps.elements = runProps.elements.filter((entry) => isValidRunPropName(entry?.name));
+  const existingNames = new Set(runProps.elements.map((el) => el?.name));
+  (runPropertiesTemplate.elements || []).forEach((entry) => {
+    if (!isValidRunPropName(entry?.name) || existingNames.has(entry.name)) return;
+    runProps.elements.push(cloneXmlNode(entry));
+    existingNames.add(entry.name);
+  });
+};
+const splitRunProperties = (entries = [], docx = null) => {
+  const remainingProps = [];
+  const inlineMarks = [];
+  const textStyleAttrs = {};
+  let hasTextStyle = false;
+  let highlightColor = null;
+  let runStyleId = null;
+  entries.forEach((entry) => {
+    if (!entry || !entry.xmlName) return;
+    const attributes = entry.attributes || {};
+    switch (entry.xmlName) {
+      case "w:b": {
+        const val = normalizeBool(attributes["w:val"]);
+        inlineMarks.push(val ? { type: "bold" } : { type: "bold", attrs: { value: "0" } });
+        break;
+      }
+      case "w:i": {
+        const val = normalizeBool(attributes["w:val"]);
+        inlineMarks.push(val ? { type: "italic" } : { type: "italic", attrs: { value: "0" } });
+        break;
+      }
+      case "w:u": {
+        const rawVal = attributes["w:val"];
+        const underlineType = rawVal == null || rawVal === "" ? "single" : String(rawVal);
+        const attrs = {};
+        if (underlineType.toLowerCase() === "none" || underlineType === "0") {
+          attrs.underlineType = "none";
+        } else {
+          attrs.underlineType = underlineType;
+          const colorRaw = attributes["w:color"];
+          if (typeof colorRaw === "string" && colorRaw.toLowerCase() !== "auto") {
+            const normalizedColor = normalizeHexColor(colorRaw);
+            if (normalizedColor) attrs.underlineColor = `#${normalizedColor}`;
+          }
+        }
+        if (attributes["w:themeColor"]) attrs.underlineThemeColor = attributes["w:themeColor"];
+        if (attributes["w:themeTint"]) attrs.underlineThemeTint = attributes["w:themeTint"];
+        if (attributes["w:themeShade"]) attrs.underlineThemeShade = attributes["w:themeShade"];
+        inlineMarks.push({ type: "underline", attrs });
+        break;
+      }
+      case "w:color": {
+        const raw = attributes["w:val"];
+        if (typeof raw === "string" && raw) {
+          hasTextStyle = true;
+          textStyleAttrs.color = `#${raw.replace("#", "").toUpperCase()}`;
+        }
+        break;
+      }
+      case "w:rFonts": {
+        const asciiFamily = attributes["w:ascii"] || attributes["w:hAnsi"] || (attributes["w:eastAsia"] ? void 0 : attributes["w:val"]);
+        const eastAsiaFamily = attributes["w:eastAsia"];
+        if (asciiFamily) {
+          hasTextStyle = true;
+          textStyleAttrs.fontFamily = SuperConverter.toCssFontFamily(asciiFamily, docx);
+        }
+        if (eastAsiaFamily) {
+          hasTextStyle = true;
+          const eastAsiaCss = SuperConverter.toCssFontFamily(eastAsiaFamily, docx);
+          if (!asciiFamily || eastAsiaCss !== textStyleAttrs.fontFamily) {
+            textStyleAttrs.eastAsiaFontFamily = eastAsiaCss;
+          }
+        }
+        break;
+      }
+      case "w:sz":
+      case "w:szCs": {
+        const rawSize = Number(attributes["w:val"]);
+        if (Number.isFinite(rawSize) && rawSize > 0) {
+          hasTextStyle = true;
+          textStyleAttrs.fontSize = `${rawSize / 2}pt`;
+        }
+        break;
+      }
+      case "w:strike": {
+        const val = normalizeBool(attributes["w:val"]);
+        inlineMarks.push(val ? { type: "strike" } : { type: "strike", attrs: { value: "0" } });
+        break;
+      }
+      case "w:highlight": {
+        const color = attributes["w:val"];
+        if (typeof color === "string" && color) {
+          highlightColor = color.toLowerCase() === "none" ? "transparent" : color;
+        }
+        break;
+      }
+      case "w:shd": {
+        const fill = attributes["w:fill"];
+        const shdVal = attributes["w:val"];
+        if (fill && String(fill).toLowerCase() !== "auto") {
+          highlightColor = `#${String(fill).replace("#", "")}`;
+        } else if (typeof shdVal === "string") {
+          const normalized = shdVal.toLowerCase();
+          if (normalized === "clear" || normalized === "nil" || normalized === "none") {
+            highlightColor = "transparent";
+          }
+        }
+        break;
+      }
+      case "w:rStyle": {
+        if (typeof attributes["w:val"] === "string") runStyleId = attributes["w:val"];
+        remainingProps.push({ xmlName: entry.xmlName, attributes: { ...attributes } });
+        break;
+      }
+      default: {
+        remainingProps.push({ xmlName: entry.xmlName, attributes: { ...attributes } });
+      }
+    }
+  });
+  if (highlightColor) inlineMarks.push({ type: "highlight", attrs: { color: highlightColor } });
+  return {
+    remainingProps,
+    inlineMarks,
+    textStyleAttrs: hasTextStyle ? textStyleAttrs : null,
+    runStyleId
+  };
+};
+const cloneMark = (mark) => {
+  if (!mark) return mark;
+  return {
+    ...mark,
+    attrs: mark.attrs ? { ...mark.attrs } : void 0
+  };
+};
+const cloneNode = (node) => {
+  if (!node || typeof node !== "object") return node;
+  const cloned = { ...node };
+  if (node.marks) cloned.marks = node.marks.map((mark) => cloneMark(mark));
+  if (node.content) cloned.content = node.content.map((child) => cloneNode(child));
+  if (node.elements) cloned.elements = node.elements.map((el) => cloneNode(el));
+  if (node.attributes) cloned.attributes = { ...node.attributes };
+  return cloned;
+};
+const cloneRuns = (runs = []) => runs.map((run2) => cloneNode(run2));
+const prepareRunTrackingContext = (node = {}) => {
+  const marks = Array.isArray(node.marks) ? node.marks : [];
+  const trackingMarks = marks.filter(
+    (mark) => mark?.type === TrackInsertMarkName || mark?.type === TrackDeleteMarkName
+  );
+  if (!trackingMarks.length) {
+    return { runNode: node, trackingMarksByType: /* @__PURE__ */ new Map() };
+  }
+  const trackingMarksByType = /* @__PURE__ */ new Map();
+  trackingMarks.forEach((mark) => {
+    if (mark?.type) trackingMarksByType.set(mark.type, cloneMark(mark));
+  });
+  const preservedMarks = marks.filter((mark) => mark?.type !== TrackInsertMarkName && mark?.type !== TrackDeleteMarkName).map((mark) => cloneMark(mark));
+  const clonedContent = Array.isArray(node.content) ? node.content.map((child) => {
+    const childClone = cloneNode(child);
+    const childMarks = Array.isArray(childClone.marks) ? childClone.marks.slice() : [];
+    trackingMarks.forEach((mark) => {
+      childMarks.push(cloneMark(mark));
+    });
+    childClone.marks = childMarks;
+    return childClone;
+  }) : [];
+  return {
+    runNode: {
+      ...cloneNode(node),
+      marks: preservedMarks,
+      content: clonedContent
+    },
+    trackingMarksByType
+  };
+};
+const mapTrackingAttrs = (mark, attrMap) => {
+  const source = mark?.attrs || {};
+  const mapped = {};
+  attrMap.forEach((targetKey, sourceKey) => {
+    if (source[sourceKey] != null) mapped[targetKey] = source[sourceKey];
+  });
+  return mapped;
+};
+const renameTextElementsForDeletion = (node) => {
+  if (!node || typeof node !== "object") return;
+  if (node.name === "w:t") node.name = "w:delText";
+  if (Array.isArray(node.elements)) node.elements.forEach(renameTextElementsForDeletion);
+};
+const ensureTrackedWrapper = (runs, trackingMarksByType = /* @__PURE__ */ new Map()) => {
+  if (!Array.isArray(runs) || !runs.length) return runs;
+  const firstRun = runs[0];
+  if (firstRun?.name === "w:ins" || firstRun?.name === "w:del") {
+    return runs;
+  }
+  if (!trackingMarksByType.size) return runs;
+  if (trackingMarksByType.has(TrackInsertMarkName)) {
+    const mark = trackingMarksByType.get(TrackInsertMarkName);
+    const clonedRuns = cloneRuns(runs);
+    const wrapper = {
+      name: "w:ins",
+      attributes: mapTrackingAttrs(
+        mark,
+        /* @__PURE__ */ new Map([
+          ["id", "w:id"],
+          ["author", "w:author"],
+          ["authorEmail", "w:authorEmail"],
+          ["date", "w:date"]
+        ])
+      ),
+      elements: clonedRuns
+    };
+    return [wrapper];
+  }
+  if (trackingMarksByType.has(TrackDeleteMarkName)) {
+    const mark = trackingMarksByType.get(TrackDeleteMarkName);
+    const clonedRuns = cloneRuns(runs);
+    clonedRuns.forEach(renameTextElementsForDeletion);
+    const wrapper = {
+      name: "w:del",
+      attributes: mapTrackingAttrs(mark, /* @__PURE__ */ new Map([["id", "w:id"]])),
+      elements: clonedRuns
+    };
+    return [wrapper];
+  }
+  return runs;
+};
+const encode$p = (attributes) => {
+  return attributes["w:rsidR"];
+};
+const decode$p = (attrs) => {
+  return attrs.rsidR;
+};
+const attrConfig$9 = Object.freeze({
+  xmlName: "w:rsidR",
+  sdName: "rsidR",
+  encode: encode$p,
+  decode: decode$p
+});
+const encode$o = (attributes) => {
+  return attributes["w:rsidRPr"];
+};
+const decode$o = (attrs) => {
+  return attrs.rsidRPr;
+};
+const attrConfig$8 = Object.freeze({
+  xmlName: "w:rsidRPr",
+  sdName: "rsidRPr",
+  encode: encode$o,
+  decode: decode$o
+});
+const encode$n = (attributes) => {
+  return attributes["w:rsidDel"];
+};
+const decode$n = (attrs) => {
+  return attrs.rsidDel;
+};
+const attrConfig$7 = Object.freeze({
+  xmlName: "w:rsidDel",
+  sdName: "rsidDel",
+  encode: encode$n,
+  decode: decode$n
+});
+const validXmlAttributes$9 = [attrConfig$9, attrConfig$8, attrConfig$7];
+const XML_NODE_NAME$f = "w:r";
+const SD_KEY_NAME = "run";
+const encode$m = (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$1(mark)) : [];
+  if (styleChangeMarks?.length) {
+    runLevelMarks = [...runLevelMarks, ...styleChangeMarks.map((mark) => cloneMark$1(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$1(mark)) : [];
+    if (!runLevelMarks.length) return child;
+    return { ...child, marks: [...baseMarks, ...runLevelMarks.map((mark) => cloneMark$1(mark))] };
+  });
+  const marked = contentWithRunMarks.map((child) => applyRunMarks(child, mergedInlineMarks, mergedTextStyleAttrs));
+  const filtered = marked.filter(Boolean);
+  const runNodeResult = {
+    type: SD_KEY_NAME,
+    content: filtered
+  };
+  const attrs = cloneRunAttrs(runAttrs);
+  if (attrs && Object.keys(attrs).length) {
+    if (attrs.runProperties == null) delete attrs.runProperties;
+    if (Object.keys(attrs).length) runNodeResult.attrs = attrs;
+  }
+  if (runLevelMarks.length) {
+    runNodeResult.marks = runLevelMarks.map((mark) => cloneMark$1(mark));
+  }
+  return runNodeResult;
+};
+const decode$m = (params, decodedAttrs = {}) => {
+  const { node } = params || {};
+  if (!node) return void 0;
+  const { runNode: runNodeForExport, trackingMarksByType } = prepareRunTrackingContext(node);
+  const runAttrs = runNodeForExport.attrs || {};
+  const runProperties = Array.isArray(runAttrs.runProperties) ? runAttrs.runProperties : [];
+  const exportParams = { ...params, node: runNodeForExport };
+  if (!exportParams.editor) {
+    exportParams.editor = { extensionService: { extensions: [] } };
+  }
+  const childElements = translateChildNodes(exportParams) || [];
+  let runPropertiesElement = createRunPropertiesElement(runProperties);
+  const markElements = processOutputMarks(Array.isArray(runNodeForExport.marks) ? runNodeForExport.marks : []);
+  if (markElements.length) {
+    if (!runPropertiesElement) {
+      runPropertiesElement = generateRunProps(markElements);
+    } else {
+      if (!Array.isArray(runPropertiesElement.elements)) runPropertiesElement.elements = [];
+      const existingNames = new Set(
+        runPropertiesElement.elements.map((el) => el?.name).filter((name) => typeof name === "string")
+      );
+      markElements.forEach((element) => {
+        if (!element || !element.name || existingNames.has(element.name)) return;
+        runPropertiesElement.elements.push({ ...element, attributes: { ...element.attributes || {} } });
+        existingNames.add(element.name);
+      });
+    }
+  }
+  const runPropsTemplate = runPropertiesElement ? cloneXmlNode(runPropertiesElement) : null;
+  const applyBaseRunProps = (runNode) => applyRunPropertiesTemplate(runNode, runPropsTemplate);
+  const runs = [];
+  childElements.forEach((child) => {
+    if (!child) return;
+    if (child.name === "w:r") {
+      const clonedRun = cloneXmlNode(child);
+      applyBaseRunProps(clonedRun);
+      runs.push(clonedRun);
+      return;
+    }
+    if (child.name === "w:hyperlink") {
+      const hyperlinkClone = cloneXmlNode(child);
+      if (Array.isArray(hyperlinkClone.elements)) {
+        hyperlinkClone.elements.forEach((run2) => applyBaseRunProps(run2));
+      }
+      runs.push(hyperlinkClone);
+      return;
+    }
+    if (child.name === "w:ins" || child.name === "w:del") {
+      const trackedClone = cloneXmlNode(child);
+      if (Array.isArray(trackedClone.elements)) {
+        trackedClone.elements.forEach((element) => {
+          if (element?.name === "w:r") applyBaseRunProps(element);
+        });
+      }
+      runs.push(trackedClone);
+      return;
+    }
+    const runWrapper = { name: XML_NODE_NAME$f, elements: [] };
+    applyBaseRunProps(runWrapper);
+    if (!Array.isArray(runWrapper.elements)) runWrapper.elements = [];
+    runWrapper.elements.push(cloneXmlNode(child));
+    runs.push(runWrapper);
+  });
+  const trackedRuns = ensureTrackedWrapper(runs, trackingMarksByType);
+  if (!trackedRuns.length) {
+    const emptyRun = { name: XML_NODE_NAME$f, elements: [] };
+    applyBaseRunProps(emptyRun);
+    trackedRuns.push(emptyRun);
+  }
+  if (decodedAttrs && Object.keys(decodedAttrs).length) {
+    trackedRuns.forEach((run2) => {
+      run2.attributes = { ...run2.attributes || {}, ...decodedAttrs };
+    });
+  }
+  if (trackedRuns.length === 1) {
+    return trackedRuns[0];
+  }
+  return trackedRuns;
+};
+const config$d = {
+  xmlName: XML_NODE_NAME$f,
+  sdNodeOrKeyName: SD_KEY_NAME,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$m,
+  decode: decode$m,
+  attributes: validXmlAttributes$9
+};
+const translator$T = NodeTranslator.from(config$d);
+const generateV2HandlerEntity = (handlerName, translator2) => ({
+  handlerName,
+  handler: (params) => {
+    const { nodes } = params;
+    if (nodes.length === 0 || nodes[0].name !== translator2.xmlName) {
+      return { nodes: [], consumed: 0 };
+    }
+    const result = translator2.encode(params);
+    if (!result) return { nodes: [], consumed: 0 };
+    return {
+      nodes: Array.isArray(result) ? result : [result],
+      consumed: 1
+    };
+  }
+});
+function createSingleAttrPropertyHandler(xmlName, sdName = null, attrName = "w:val", transformEncode = null, transformDecode = null) {
+  if (!sdName) sdName = xmlName.split(":")[1];
+  if (!transformEncode) transformEncode = (v2) => v2;
+  if (!transformDecode) transformDecode = (v2) => v2;
+  return {
+    xmlName,
+    sdNodeOrKeyName: sdName,
+    encode: ({ nodes }) => {
+      return transformEncode(nodes[0].attributes[attrName]) ?? void 0;
+    },
+    decode: ({ node }) => {
+      const value = node.attrs?.[sdName] != null ? transformDecode(node.attrs[sdName]) : void 0;
+      return value != null ? { name: xmlName, attributes: { [attrName]: value } } : void 0;
+    }
+  };
+}
+function createMeasurementPropertyHandler(xmlName, sdName = null) {
+  if (!sdName) sdName = xmlName.split(":")[1];
+  return {
+    xmlName,
+    sdNodeOrKeyName: sdName,
+    attributes: [
+      createAttributeHandler("w:w", "value", parseInteger, integerToString),
+      createAttributeHandler("w:type")
+    ],
+    encode: (_2, encodedAttrs) => {
+      return encodedAttrs["value"] != null ? encodedAttrs : void 0;
+    },
+    decode: function({ node }) {
+      const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs[sdName] || {} } });
+      return decodedAttrs["w:w"] != null ? { attributes: decodedAttrs } : void 0;
+    }
+  };
+}
+function createBorderPropertyHandler(xmlName, sdName = null) {
+  if (!sdName) sdName = xmlName.split(":")[1];
+  return {
+    xmlName,
+    sdNodeOrKeyName: sdName,
+    attributes: [
+      createAttributeHandler("w:val"),
+      createAttributeHandler("w:color"),
+      createAttributeHandler("w:themeColor"),
+      createAttributeHandler("w:themeTint"),
+      createAttributeHandler("w:themeShade"),
+      createAttributeHandler("w:sz", "size", parseInteger, integerToString),
+      createAttributeHandler("w:space", null, parseInteger, integerToString),
+      createAttributeHandler("w:shadow", null, parseBoolean, booleanToString),
+      createAttributeHandler("w:frame", null, parseBoolean, booleanToString)
+    ],
+    encode: (params, encodedAttrs) => {
+      return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
+    },
+    decode: function({ node }, context) {
+      const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs[sdName] || {} } });
+      return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
+    }
+  };
+}
+const createAttributeHandler = (xmlName, sdName = null, transformEncode = null, transformDecode = null) => {
+  if (!transformEncode) transformEncode = (v2) => v2;
+  if (!transformDecode) transformDecode = (v2) => v2;
+  if (!sdName) sdName = xmlName.split(":")[1];
+  return {
+    xmlName,
+    sdName,
+    encode: (attributes) => transformEncode(attributes[xmlName]),
+    decode: (attributes) => transformDecode(attributes[sdName])
+  };
+};
+function encodeProperties(node, translatorsByXmlName, asArray = false) {
+  if (!node?.elements || node.elements.length === 0) {
+    return asArray ? [] : {};
+  }
+  const attributes = asArray ? [] : {};
+  node.elements.forEach((el) => {
+    const translator2 = translatorsByXmlName[el.name];
+    if (translator2) {
+      const encodedAttr = translator2.encode({ nodes: [el] });
+      if (encodedAttr != null) {
+        if (asArray) {
+          attributes.push({ [translator2.sdNodeOrKeyName]: encodedAttr });
+        } else {
+          attributes[translator2.sdNodeOrKeyName] = encodedAttr;
+        }
+      }
+    }
+  });
+  return attributes;
+}
+function decodeProperties(translatorsBySdName, properties) {
+  if (!properties || typeof properties !== "object") {
+    return [];
+  }
+  const elements = [];
+  Object.keys(properties).forEach((key) => {
+    const translator2 = translatorsBySdName[key];
+    if (translator2) {
+      const result = translator2.decode({ node: { attrs: { [key]: properties[key] } } });
+      if (result != null) {
+        result.name = translator2.xmlName;
+        elements.push(result);
+      }
+    }
+  });
+  return elements;
+}
+const parseBoolean = (value) => value != null ? ["1", "true"].includes(value) : void 0;
+const booleanToString = (value) => value != null ? value ? "1" : "0" : void 0;
+const parseInteger = (value) => {
+  if (value == null) return void 0;
+  const intValue = parseInt(value, 10);
+  return isNaN(intValue) ? void 0 : intValue;
+};
+const integerToString = (value) => {
+  const intValue = parseInteger(value);
+  return intValue != void 0 ? String(intValue) : void 0;
+};
+function preProcessVerticalMergeCells(table, { editorSchema }) {
+  if (!table || !Array.isArray(table.content)) {
+    return table;
+  }
+  const rows = table.content;
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+    const row = rows[rowIndex];
+    if (!row) continue;
+    if (!Array.isArray(row.content)) {
+      row.content = [];
+    }
+    for (let cellIndex = 0; cellIndex < row.content.length; cellIndex++) {
+      const cell = row.content[cellIndex];
+      if (!cell) continue;
+      const attrs = cell.attrs || {};
+      if (!attrs.rowspan || attrs.rowspan <= 1) continue;
+      const maxRowspan = Math.min(attrs.rowspan, rows.length - rowIndex);
+      for (let offset = 1; offset < maxRowspan; offset++) {
+        const rowToChange = rows[rowIndex + offset];
         if (!rowToChange) continue;
         if (!Array.isArray(rowToChange.content)) {
           rowToChange.content = [];
@@ -26524,17 +27783,52 @@ const encode$d = (params, encodedAttrs) => {
   const { nodes, docx, nodeListHandler } = params;
   const node = nodes[0];
   let href = _resolveHref(docx, encodedAttrs);
-  const linkMark = { type: "link", attrs: { ...encodedAttrs, href } };
+  const linkMark = { attrs: { ...encodedAttrs, href } };
   const runNodes = node.elements.filter((el) => el.name === "w:r");
   runNodes.forEach((runNode) => {
-    runNode.marks = [...runNode.marks || [], linkMark];
+    const existingRunMarks = Array.isArray(runNode.marks) ? runNode.marks : [];
+    const runMarksWithoutLink = existingRunMarks.filter((mark) => mark?.type !== "link");
+    runNode.marks = runMarksWithoutLink;
   });
   const updatedNode = nodeListHandler.handler({
     ...params,
     nodes: runNodes,
     path: [...params.path || [], node]
   });
-  return updatedNode;
+  const cloneMark2 = (mark) => {
+    if (!mark || typeof mark !== "object") return mark;
+    if (!mark.attrs) return { ...mark };
+    return { ...mark, attrs: { ...mark.attrs } };
+  };
+  const ensureLinkMark = (child) => {
+    if (!child || typeof child !== "object") return child;
+    if (Array.isArray(child.content)) {
+      const updatedContent = child.content.map((item) => ensureLinkMark(item));
+      if (updatedContent !== child.content) {
+        child = { ...child, content: updatedContent };
+      }
+    }
+    if (child.type === "run") {
+      const existingMarks2 = Array.isArray(child.marks) ? child.marks : [];
+      const filteredMarks = existingMarks2.filter((mark) => mark?.type !== "link").map((mark) => cloneMark2(mark));
+      if (filteredMarks.length !== existingMarks2.length) {
+        if (filteredMarks.length) child = { ...child, marks: filteredMarks };
+        else {
+          const { marks, ...rest } = child;
+          child = rest;
+        }
+      }
+      return child;
+    }
+    if (child.type !== "text") return child;
+    const existingMarks = Array.isArray(child.marks) ? child.marks.map((mark) => cloneMark2(mark)) : [];
+    const hasLink = existingMarks.some((mark) => mark?.type === "link");
+    if (hasLink) return child;
+    const linkClone = { type: "link", attrs: { ...linkMark.attrs } };
+    return { ...child, marks: [...existingMarks, linkClone] };
+  };
+  if (!Array.isArray(updatedNode)) return updatedNode;
+  return updatedNode.map((child) => ensureLinkMark(child));
 };
 const _resolveHref = (docx, encodedAttrs) => {
   const rels = docx["word/_rels/document.xml.rels"];
@@ -27416,225 +28710,79 @@ function decode$c(params) {
   return translateAnchorNode(params);
 }
 const config$5 = {
-  xmlName: XML_NODE_NAME$5,
-  sdNodeOrKeyName: SD_NODE_NAME$5,
-  type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$c,
-  decode: decode$c,
-  attributes: validXmlAttributes$5
-};
-const translator$5 = NodeTranslator.from(config$5);
-function handleInlineNode(params) {
-  const { node } = params.extraParams;
-  if (node.name !== "wp:inline") {
-    return null;
-  }
-  return handleImageNode(node, params, false);
-}
-function translateInlineNode(params) {
-  const nodeElements = translateImageNode(params);
-  return {
-    name: "wp:inline",
-    attributes: nodeElements.attributes,
-    elements: nodeElements.elements
-  };
-}
-const XML_NODE_NAME$4 = "wp:inline";
-const SD_NODE_NAME$4 = ["image"];
-const validXmlAttributes$4 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
-function encode$b(params) {
-  const { node } = params.extraParams;
-  if (!node || !node.type) {
-    return null;
-  }
-  return handleInlineNode(params);
-}
-function decode$b(params) {
-  const { node } = params;
-  if (!node || !node.type) {
-    return null;
-  }
-  return translateInlineNode(params);
-}
-const config$4 = {
-  xmlName: XML_NODE_NAME$4,
-  sdNodeOrKeyName: SD_NODE_NAME$4,
-  type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$b,
-  decode: decode$b,
-  attributes: validXmlAttributes$4
-};
-const translator$4 = NodeTranslator.from(config$4);
-const encode$a = (attributes) => {
-  return attributes["w:id"];
-};
-const decode$a = (attrs) => {
-  return attrs.id;
-};
-const attrConfig$6 = Object.freeze({
-  xmlName: "w:id",
-  sdName: "id",
-  encode: encode$a,
-  decode: decode$a
-});
-const encode$9 = (attributes) => {
-  return attributes["w:name"];
-};
-const decode$9 = (attrs) => {
-  return attrs.name;
-};
-const attrConfig$5 = Object.freeze({
-  xmlName: "w:name",
-  sdName: "name",
-  encode: encode$9,
-  decode: decode$9
-});
-const encode$8 = (attributes) => {
-  return attributes["w:colFirst"];
-};
-const decode$8 = (attrs) => {
-  return attrs.colFirst;
-};
-const attrConfig$4 = Object.freeze({
-  xmlName: "w:colFirst",
-  sdName: "colFirst",
-  encode: encode$8,
-  decode: decode$8
-});
-const encode$7 = (attributes) => {
-  return attributes["w:colLast"];
-};
-const decode$7 = (attrs) => {
-  return attrs.colLast;
-};
-const attrConfig$3 = Object.freeze({
-  xmlName: "w:colLast",
-  sdName: "colLast",
-  encode: encode$7,
-  decode: decode$7
-});
-const encode$6 = (attributes) => {
-  return attributes["w:displacedByCustomXml"];
-};
-const decode$6 = (attrs) => {
-  return attrs.displacedByCustomXml;
-};
-const attrConfig$2 = Object.freeze({
-  xmlName: "w:displacedByCustomXml",
-  sdName: "displacedByCustomXml",
-  encode: encode$6,
-  decode: decode$6
-});
-const validXmlAttributes$3 = [attrConfig$6, attrConfig$5, attrConfig$4, attrConfig$3, attrConfig$2];
-const XML_NODE_NAME$3 = "w:bookmarkStart";
-const SD_NODE_NAME$3 = "bookmarkStart";
-const encode$5 = (params, encodedAttrs = {}) => {
-  return {
-    type: "bookmarkStart",
-    attrs: encodedAttrs
-  };
-};
-const decode$5 = (params, decodedAttrs = {}) => {
-  const result = {
-    name: "w:bookmarkStart",
-    elements: []
-  };
-  if (decodedAttrs && Object.keys(decodedAttrs).length) {
-    result.attributes = decodedAttrs;
-  }
-  return result;
-};
-const config$3 = {
-  xmlName: XML_NODE_NAME$3,
-  sdNodeOrKeyName: SD_NODE_NAME$3,
-  type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$5,
-  decode: decode$5,
-  attributes: validXmlAttributes$3
-};
-const translator$3 = NodeTranslator.from(config$3);
-const encode$4 = (attributes) => {
-  return attributes["w:id"];
-};
-const decode$4 = (attrs) => {
-  return attrs.id;
-};
-const attrConfig$1 = Object.freeze({
-  xmlName: "w:id",
-  sdName: "id",
-  encode: encode$4,
-  decode: decode$4
-});
-const encode$3 = (attributes) => {
-  return attributes["w:displacedByCustomXml"];
-};
-const decode$3 = (attrs) => {
-  return attrs.displacedByCustomXml;
-};
-const attrConfig = Object.freeze({
-  xmlName: "w:displacedByCustomXml",
-  sdName: "displacedByCustomXml",
-  encode: encode$3,
-  decode: decode$3
-});
-const validXmlAttributes$2 = [attrConfig$1, attrConfig];
-const XML_NODE_NAME$2 = "w:bookmarkEnd";
-const SD_NODE_NAME$2 = "bookmarkEnd";
-const encode$2 = (params, encodedAttrs = {}) => {
-  return {
-    type: "bookmarkEnd",
-    attrs: encodedAttrs
-  };
+  xmlName: XML_NODE_NAME$5,
+  sdNodeOrKeyName: SD_NODE_NAME$5,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$c,
+  decode: decode$c,
+  attributes: validXmlAttributes$5
 };
-const decode$2 = (params, decodedAttrs = {}) => {
-  const result = {
-    name: "w:bookmarkEnd",
-    elements: []
+const translator$5 = NodeTranslator.from(config$5);
+function handleInlineNode(params) {
+  const { node } = params.extraParams;
+  if (node.name !== "wp:inline") {
+    return null;
+  }
+  return handleImageNode(node, params, false);
+}
+function translateInlineNode(params) {
+  const nodeElements = translateImageNode(params);
+  return {
+    name: "wp:inline",
+    attributes: nodeElements.attributes,
+    elements: nodeElements.elements
   };
-  if (decodedAttrs && Object.keys(decodedAttrs).length) {
-    result.attributes = decodedAttrs;
+}
+const XML_NODE_NAME$4 = "wp:inline";
+const SD_NODE_NAME$4 = ["image"];
+const validXmlAttributes$4 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
+function encode$b(params) {
+  const { node } = params.extraParams;
+  if (!node || !node.type) {
+    return null;
   }
-  return result;
-};
-const config$2 = {
-  xmlName: XML_NODE_NAME$2,
-  sdNodeOrKeyName: SD_NODE_NAME$2,
+  return handleInlineNode(params);
+}
+function decode$b(params) {
+  const { node } = params;
+  if (!node || !node.type) {
+    return null;
+  }
+  return translateInlineNode(params);
+}
+const config$4 = {
+  xmlName: XML_NODE_NAME$4,
+  sdNodeOrKeyName: SD_NODE_NAME$4,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$2,
-  decode: decode$2,
-  attributes: validXmlAttributes$2
+  encode: encode$b,
+  decode: decode$b,
+  attributes: validXmlAttributes$4
 };
-const translator$2 = NodeTranslator.from(config$2);
-const registeredHandlers = Object.freeze({
-  "w:br": translator$V,
-  "w:tab": translator$U,
-  "w:p": translator$T,
-  "wp:anchor": translator$5,
-  "wp:inline": translator$4,
-  "w:bookmarkStart": translator$3,
-  "w:bookmarkEnd": translator$2
-});
-const XML_NODE_NAME$1 = "w:drawing";
-const SD_NODE_NAME$1 = [];
-const validXmlAttributes$1 = [];
-function encode$1(params) {
+const translator$4 = NodeTranslator.from(config$4);
+const XML_NODE_NAME$3 = "w:drawing";
+const SD_NODE_NAME$3 = [];
+const validXmlAttributes$3 = [];
+function encode$a(params) {
   const nodes = params.nodes;
   const node = nodes[0];
-  const validChildTranslators = ["wp:anchor", "wp:inline"];
+  const translatorByChildName = {
+    "wp:anchor": translator$5,
+    "wp:inline": translator$4
+  };
   return node.elements.reduce((acc, child) => {
     if (acc) return acc;
-    if (!validChildTranslators.includes(child.name)) return acc;
-    const translator2 = registeredHandlers[child.name];
+    const translator2 = translatorByChildName[child.name];
+    if (!translator2) return acc;
     return translator2.encode({ ...params, extraParams: { node: child } }) || acc;
   }, null);
 }
-function decode$1(params) {
+function decode$a(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
   }
-  const handlerName = node.attrs.isAnchor ? "wp:anchor" : "wp:inline";
-  const resultNode = registeredHandlers[handlerName].decode(params);
+  const childTranslator = node.attrs.isAnchor ? translator$5 : translator$4;
+  const resultNode = childTranslator.decode(params);
   return wrapTextInRun(
     {
       name: "w:drawing",
@@ -27643,15 +28791,15 @@ function decode$1(params) {
     []
   );
 }
-const config$1 = {
-  xmlName: XML_NODE_NAME$1,
-  sdNodeOrKeyName: SD_NODE_NAME$1,
+const config$3 = {
+  xmlName: XML_NODE_NAME$3,
+  sdNodeOrKeyName: SD_NODE_NAME$3,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$1,
-  decode: decode$1,
-  attributes: validXmlAttributes$1
+  encode: encode$a,
+  decode: decode$a,
+  attributes: validXmlAttributes$3
 };
-const translator$1 = NodeTranslator.from(config$1);
+const translator$3 = NodeTranslator.from(config$3);
 class CommandService {
   /**
    * @param {import('./commands/types/index.js').CommandServiceOptions} props
@@ -28989,7 +30137,7 @@ function prepareTextAnnotation(params) {
   return getTextNodeForExport(attrs.displayLabel, [...marks, ...marksFromAttrs], params);
 }
 function prepareImageAnnotation(params, imageSize) {
-  return translator$1.decode({
+  return translator$3.decode({
     ...params,
     imageSize
   });
@@ -29226,10 +30374,10 @@ function translateStructuredContent(params) {
   };
   return result;
 }
-const XML_NODE_NAME = "w:sdt";
-const SD_NODE_NAME = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
-const validXmlAttributes = [];
-function encode(params) {
+const XML_NODE_NAME$2 = "w:sdt";
+const SD_NODE_NAME$2 = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
+const validXmlAttributes$2 = [];
+function encode$9(params) {
   const nodes = params.nodes;
   const node = nodes[0];
   const { type: sdtType, handler: handler2 } = sdtNodeTypeStrategy(node);
@@ -29239,7 +30387,7 @@ function encode(params) {
   const result = handler2(params);
   return result;
 }
-function decode(params) {
+function decode$9(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
@@ -29255,6 +30403,146 @@ function decode(params) {
   const result = decoder();
   return result;
 }
+const config$2 = {
+  xmlName: XML_NODE_NAME$2,
+  sdNodeOrKeyName: SD_NODE_NAME$2,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$9,
+  decode: decode$9,
+  attributes: validXmlAttributes$2
+};
+const translator$2 = NodeTranslator.from(config$2);
+const encode$8 = (attributes) => {
+  return attributes["w:id"];
+};
+const decode$8 = (attrs) => {
+  return attrs.id;
+};
+const attrConfig$6 = Object.freeze({
+  xmlName: "w:id",
+  sdName: "id",
+  encode: encode$8,
+  decode: decode$8
+});
+const encode$7 = (attributes) => {
+  return attributes["w:name"];
+};
+const decode$7 = (attrs) => {
+  return attrs.name;
+};
+const attrConfig$5 = Object.freeze({
+  xmlName: "w:name",
+  sdName: "name",
+  encode: encode$7,
+  decode: decode$7
+});
+const encode$6 = (attributes) => {
+  return attributes["w:colFirst"];
+};
+const decode$6 = (attrs) => {
+  return attrs.colFirst;
+};
+const attrConfig$4 = Object.freeze({
+  xmlName: "w:colFirst",
+  sdName: "colFirst",
+  encode: encode$6,
+  decode: decode$6
+});
+const encode$5 = (attributes) => {
+  return attributes["w:colLast"];
+};
+const decode$5 = (attrs) => {
+  return attrs.colLast;
+};
+const attrConfig$3 = Object.freeze({
+  xmlName: "w:colLast",
+  sdName: "colLast",
+  encode: encode$5,
+  decode: decode$5
+});
+const encode$4 = (attributes) => {
+  return attributes["w:displacedByCustomXml"];
+};
+const decode$4 = (attrs) => {
+  return attrs.displacedByCustomXml;
+};
+const attrConfig$2 = Object.freeze({
+  xmlName: "w:displacedByCustomXml",
+  sdName: "displacedByCustomXml",
+  encode: encode$4,
+  decode: decode$4
+});
+const validXmlAttributes$1 = [attrConfig$6, attrConfig$5, attrConfig$4, attrConfig$3, attrConfig$2];
+const XML_NODE_NAME$1 = "w:bookmarkStart";
+const SD_NODE_NAME$1 = "bookmarkStart";
+const encode$3 = (params, encodedAttrs = {}) => {
+  return {
+    type: "bookmarkStart",
+    attrs: encodedAttrs
+  };
+};
+const decode$3 = (params, decodedAttrs = {}) => {
+  const result = {
+    name: "w:bookmarkStart",
+    elements: []
+  };
+  if (decodedAttrs && Object.keys(decodedAttrs).length) {
+    result.attributes = decodedAttrs;
+  }
+  return result;
+};
+const config$1 = {
+  xmlName: XML_NODE_NAME$1,
+  sdNodeOrKeyName: SD_NODE_NAME$1,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$3,
+  decode: decode$3,
+  attributes: validXmlAttributes$1
+};
+const translator$1 = NodeTranslator.from(config$1);
+const encode$2 = (attributes) => {
+  return attributes["w:id"];
+};
+const decode$2 = (attrs) => {
+  return attrs.id;
+};
+const attrConfig$1 = Object.freeze({
+  xmlName: "w:id",
+  sdName: "id",
+  encode: encode$2,
+  decode: decode$2
+});
+const encode$1 = (attributes) => {
+  return attributes["w:displacedByCustomXml"];
+};
+const decode$1 = (attrs) => {
+  return attrs.displacedByCustomXml;
+};
+const attrConfig = Object.freeze({
+  xmlName: "w:displacedByCustomXml",
+  sdName: "displacedByCustomXml",
+  encode: encode$1,
+  decode: decode$1
+});
+const validXmlAttributes = [attrConfig$1, attrConfig];
+const XML_NODE_NAME = "w:bookmarkEnd";
+const SD_NODE_NAME = "bookmarkEnd";
+const encode = (params, encodedAttrs = {}) => {
+  return {
+    type: "bookmarkEnd",
+    attrs: encodedAttrs
+  };
+};
+const decode = (params, decodedAttrs = {}) => {
+  const result = {
+    name: "w:bookmarkEnd",
+    elements: []
+  };
+  if (decodedAttrs && Object.keys(decodedAttrs).length) {
+    result.attributes = decodedAttrs;
+  }
+  return result;
+};
 const config = {
   xmlName: XML_NODE_NAME,
   sdNodeOrKeyName: SD_NODE_NAME,
@@ -29264,35 +30552,44 @@ const config = {
   attributes: validXmlAttributes
 };
 const translator = NodeTranslator.from(config);
+const isLineBreakOnlyRun = (node) => {
+  if (!node) return false;
+  if (node.type === "lineBreak" || node.type === "hardBreak") return true;
+  if (node.type !== "run") return false;
+  const runContent = Array.isArray(node.content) ? node.content : [];
+  if (!runContent.length) return false;
+  return runContent.every((child) => child?.type === "lineBreak" || child?.type === "hardBreak");
+};
 function exportSchemaToJson(params) {
   const { type: type2 } = params.node || {};
   const router = {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$T,
+    paragraph: translator$12,
+    run: translator$T,
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$V,
+    lineBreak: translator$15,
     table: translator$8,
     tableRow: translator$F,
     tableCell: translator$7,
-    bookmarkStart: translator$3,
-    bookmarkEnd: translator$2,
-    fieldAnnotation: translator,
-    tab: translator$U,
-    image: translator$1,
-    hardBreak: translator$V,
+    bookmarkStart: translator$1,
+    bookmarkEnd: translator,
+    fieldAnnotation: translator$2,
+    tab: translator$13,
+    image: translator$3,
+    hardBreak: translator$15,
     commentRangeStart: () => translateCommentNode(params, "Start"),
     commentRangeEnd: () => translateCommentNode(params, "End"),
     commentReference: () => null,
     shapeContainer: translateShapeContainer,
     shapeTextbox: translateShapeTextbox,
     contentBlock: translateContentBlock,
-    structuredContent: translator,
-    structuredContentBlock: translator,
-    documentSection: translator,
+    structuredContent: translator$2,
+    structuredContentBlock: translator$2,
+    documentSection: translator$2,
     "page-number": translatePageNumberNode,
     "total-page-number": translateTotalPageNumberNode
   };
@@ -29431,21 +30728,32 @@ function generateParagraphProperties(node) {
     };
     pPrElements.push(spacingElement);
   }
-  if (indent && Object.values(indent).some((v2) => v2 !== 0)) {
-    const { left, right, firstLine, hanging } = indent;
+  const hasIndent = !!indent;
+  if (hasIndent) {
+    const { left, right, firstLine, hanging, explicitLeft, explicitRight, explicitFirstLine, explicitHanging } = indent;
     const attributes = {};
-    if (left || left === 0) attributes["w:left"] = pixelsToTwips(left);
-    if (right || right === 0) attributes["w:right"] = pixelsToTwips(right);
-    if (firstLine || firstLine === 0) attributes["w:firstLine"] = pixelsToTwips(firstLine);
-    if (hanging || hanging === 0) attributes["w:hanging"] = pixelsToTwips(hanging);
-    if (textIndent && !attributes["w:left"]) {
+    if (left !== void 0 && (left !== 0 || explicitLeft || textIndent)) {
+      attributes["w:left"] = pixelsToTwips(left);
+    }
+    if (right !== void 0 && (right !== 0 || explicitRight)) {
+      attributes["w:right"] = pixelsToTwips(right);
+    }
+    if (firstLine !== void 0 && (firstLine !== 0 || explicitFirstLine)) {
+      attributes["w:firstLine"] = pixelsToTwips(firstLine);
+    }
+    if (hanging !== void 0 && (hanging !== 0 || explicitHanging)) {
+      attributes["w:hanging"] = pixelsToTwips(hanging);
+    }
+    if (textIndent && attributes["w:left"] === void 0) {
       attributes["w:left"] = getTextIndentExportValue(textIndent);
     }
-    const indentElement = {
-      name: "w:ind",
-      attributes
-    };
-    pPrElements.push(indentElement);
+    if (Object.keys(attributes).length) {
+      const indentElement = {
+        name: "w:ind",
+        attributes
+      };
+      pPrElements.push(indentElement);
+    }
   } else if (textIndent && textIndent !== "0in") {
     const indentElement = {
       name: "w:ind",
@@ -29495,12 +30803,17 @@ function generateParagraphProperties(node) {
   if (sectPr) {
     pPrElements.push(sectPr);
   }
+  const mapTabVal = (value) => {
+    if (!value || value === "start") return "left";
+    if (value === "end") return "right";
+    return value;
+  };
   const { tabStops } = attrs;
   if (tabStops && tabStops.length > 0) {
     const tabElements = tabStops.map((tab) => {
       const posValue = tab.originalPos !== void 0 ? tab.originalPos : pixelsToTwips(tab.pos).toString();
       const tabAttributes = {
-        "w:val": tab.val || "start",
+        "w:val": mapTabVal(tab.val),
         "w:pos": posValue
       };
       if (tab.leader) {
@@ -29855,6 +31168,11 @@ const convertMultipleListItemsIntoSingleNode = (listItem) => {
       collapsedParagraph.content.push(item);
     }
   });
+  collapsedParagraph.content = collapsedParagraph.content.filter((node, index, nodes) => {
+    if (!isLineBreakOnlyRun(node)) return true;
+    const prevNode = nodes[index - 1];
+    return !(prevNode && isLineBreakOnlyRun(prevNode));
+  });
   return collapsedParagraph;
 };
 const restoreIndent = (indent) => {
@@ -29908,13 +31226,27 @@ function translateMark(mark) {
       markElement.type = "element";
       break;
     case "italic":
-      delete markElement.attributes;
-      markElement.type = "element";
-      break;
-    case "underline":
+      if (attrs?.value && attrs.value !== "1" && attrs.value !== true) {
+        markElement.attributes["w:val"] = attrs.value;
+      } else {
+        delete markElement.attributes;
+      }
       markElement.type = "element";
-      markElement.attributes["w:val"] = attrs.underlineType;
       break;
+    case "underline": {
+      const translated = translator$$.decode({
+        node: {
+          attrs: {
+            underlineType: attrs.underlineType ?? attrs.underline ?? null,
+            underlineColor: attrs.underlineColor ?? attrs.color ?? null,
+            underlineThemeColor: attrs.underlineThemeColor ?? attrs.themeColor ?? null,
+            underlineThemeTint: attrs.underlineThemeTint ?? attrs.themeTint ?? null,
+            underlineThemeShade: attrs.underlineThemeShade ?? attrs.themeShade ?? null
+          }
+        }
+      });
+      return translated || {};
+    }
     // Text style cases
     case "fontSize":
       value = attrs.fontSize;
@@ -29932,13 +31264,21 @@ function translateMark(mark) {
       markElement.name = "w:rStyle";
       markElement.attributes["w:val"] = attrs.styleId;
       break;
-    case "color":
-      let processedColor = attrs.color.replace(/^#/, "").replace(/;$/, "");
+    case "color": {
+      const rawColor = attrs.color;
+      if (!rawColor) break;
+      const normalized = String(rawColor).trim().toLowerCase();
+      if (normalized === "inherit") {
+        markElement.attributes["w:val"] = "auto";
+        break;
+      }
+      let processedColor = String(rawColor).replace(/^#/, "").replace(/;$/, "");
       if (processedColor.startsWith("rgb")) {
         processedColor = rgbToHex(processedColor);
       }
       markElement.attributes["w:val"] = processedColor;
       break;
+    }
     case "textAlign":
       markElement.attributes["w:val"] = attrs.textAlign;
       break;
@@ -29956,12 +31296,11 @@ function translateMark(mark) {
     case "lineHeight":
       markElement.attributes["w:line"] = linesToTwips(attrs.lineHeight);
       break;
-    case "highlight":
-      markElement.attributes["w:fill"] = attrs.color?.substring(1);
-      markElement.attributes["w:color"] = "auto";
-      markElement.attributes["w:val"] = "clear";
-      markElement.name = "w:shd";
-      break;
+    case "highlight": {
+      const highlightValue = attrs.color ?? attrs.highlight ?? null;
+      const translated = translator$14.decode({ node: { attrs: { highlight: highlightValue } } });
+      return translated || {};
+    }
   }
   return markElement;
 }
@@ -30092,8 +31431,8 @@ generate_xml_as_list_fn = function(data, debug = false) {
   return final;
 };
 replaceSpecialCharacters_fn = function(text) {
-  if (!text) return;
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  if (text === void 0 || text === null) return text;
+  return String(text).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 };
 generateXml_fn = function(node) {
   if (!node) return null;
@@ -30109,7 +31448,7 @@ generateXml_fn = function(node) {
   else tag += ">";
   let tags = [tag];
   if (!name && node.type === "text") {
-    return node.text;
+    return __privateMethod(this, _DocxExporter_instances, replaceSpecialCharacters_fn).call(this, node.text ?? "");
   }
   if (elements) {
     if (name === "w:instrText") {
@@ -30235,7 +31574,7 @@ const handleDrawingNode = (params) => {
   if (mainNode.name === "w:drawing") node = mainNode;
   else node = mainNode.elements.find((el) => el.name === "w:drawing");
   if (!node) return { nodes: [], consumed: 0 };
-  const schemaNode = translator$1.encode(params);
+  const schemaNode = translator$3.encode(params);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -30338,81 +31677,7 @@ const trackChangeNodeHandlerEntity = {
   handler: handleTrackChangeNode
 };
 const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$6);
-const handleRunNode = (params) => {
-  const { nodes, nodeListHandler, parentStyleId, docx } = params;
-  if (nodes.length === 0 || nodes[0].name !== "w:r") {
-    return { nodes: [], consumed: 0 };
-  }
-  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);
-      }
-    });
-    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 (runStyleId) combinedMarks.push({ type: "textStyle", attrs: { styleId: runStyleId } });
-    if (node.marks) combinedMarks.push(...node.marks);
-    const newMarks = createImportMarks(combinedMarks);
-    processedRun = processedRun.map((n) => {
-      const existingMarks = n.marks || [];
-      return {
-        ...n,
-        marks: [...newMarks, ...existingMarks]
-      };
-    });
-  }
-  return { nodes: processedRun, consumed: 1 };
-};
-const getMarksFromStyles = (docx, styleId) => {
-  const styles = docx?.["word/styles.xml"];
-  if (!styles) {
-    return {};
-  }
-  const styleTags = styles.elements[0].elements.filter((style2) => style2.name === "w:style");
-  const style = styleTags.find((tag) => tag.attributes["w:styleId"] === styleId) || {};
-  if (!style) return {};
-  return parseProperties(style);
-};
-const runNodeHandlerEntity = {
-  handlerName: "runNodeHandler",
-  handler: handleRunNode
-};
+const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$T);
 const handleTextNode = (params) => {
   const { nodes, insideTrackChange } = params;
   if (nodes.length === 0 || !(nodes[0].name === "w:t" || insideTrackChange && nodes[0].name === "w:delText")) {
@@ -30424,6 +31689,10 @@ const handleTextNode = (params) => {
   let text;
   if (elements.length === 1) {
     text = elements[0].text;
+    const xmlSpace = node.attributes?.["xml:space"] ?? elements[0]?.attributes?.["xml:space"];
+    if (xmlSpace !== "preserve" && typeof text === "string") {
+      text = text.replace(/^\s+/, "").replace(/\s+$/, "");
+    }
     text = text.replace(/\[\[sdspace\]\]/g, "");
   } else if (!elements.length && "attributes" in node && node.attributes["xml:space"] === "preserve") {
     text = " ";
@@ -30449,7 +31718,7 @@ const handleParagraphNode = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$T.encode(params);
+  const schemaNode = translator$12.encode(params);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -30462,7 +31731,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$2.encode(params);
   if (!result) {
     return { nodes: [], consumed: 0 };
   }
@@ -30552,7 +31821,7 @@ const handler = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$V.encode(params);
+  const result = translator$15.encode(params);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -30624,7 +31893,7 @@ const handleBookmarkStartNode = (params) => {
   if (isCustomMarkBookmark(nodes[0], params.editor)) {
     return handleBookmarkNode(params);
   }
-  const node = translator$3.encode(params);
+  const node = translator$1.encode(params);
   if (!node) return { nodes: [], consumed: 0 };
   return { nodes: [node], consumed: 1 };
 };
@@ -30656,7 +31925,7 @@ const handleBookmarkEndNode = (params) => {
   if (!nodes.length || nodes[0].name !== "w:bookmarkEnd") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$2.encode(params);
+  const node = translator.encode(params);
   if (!node) return { nodes: [], consumed: 0 };
   return { nodes: [node], consumed: 1 };
 };
@@ -31295,7 +32564,7 @@ const handleTabNode = (params) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$U.encode(params);
+  const node = translator$13.encode(params);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
@@ -31744,6 +33013,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);
@@ -31779,6 +33058,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.
@@ -31875,13 +33179,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() {
@@ -32367,6 +33677,7 @@ export {
   objectIncludes as Z,
   AddMarkStep as _,
   Plugin as a,
+  translator$R as a$,
   twipsToLines as a0,
   pixelsToTwips as a1,
   helpers as a2,
@@ -32377,12 +33688,33 @@ export {
   createDocFromMarkdown as a7,
   createDocFromHTML as a8,
   EditorState as a9,
-  getActiveFormatting as aA,
-  readFromClipboard as aB,
-  handleClipboardPaste as aC,
-  getFileObject as aD,
-  _sfc_main as aE,
-  registeredHandlers as aF,
+  readFromClipboard as aA,
+  handleClipboardPaste as aB,
+  getFileObject as aC,
+  runPropertyTranslators as aD,
+  translator as aE,
+  translator$1 as aF,
+  translator$4 as aG,
+  translator$5 as aH,
+  translator$H as aI,
+  translator$I as aJ,
+  translator$G as aK,
+  translator$J as aL,
+  translator$F as aM,
+  translator$7 as aN,
+  translator$K as aO,
+  translator$L as aP,
+  translator$13 as aQ,
+  translator$2 as aR,
+  translator$U as aS,
+  translator$T as aT,
+  translator$12 as aU,
+  translator$M as aV,
+  translator$6 as aW,
+  translator$N as aX,
+  translator$O as aY,
+  translator$P as aZ,
+  translator$Q as a_,
   hasSomeParentWithClass as aa,
   isActive as ab,
   unflattenListsInHtml as ac,
@@ -32396,20 +33728,23 @@ export {
   docxNumberigHelpers as ak,
   parseIndentElement as al,
   combineIndents as am,
-  StepMap as an,
-  SelectionRange as ao,
-  Transform as ap,
-  isInTable as aq,
-  generateDocxRandomId as ar,
-  insertNewRelationship as as,
-  updateDOMAttributes as at,
-  htmlHandler as au,
-  commonjsGlobal as av,
-  getDefaultExportFromCjs$1 as aw,
-  getContentTypesFromXml as ax,
-  xmljs as ay,
-  vClickOutside as az,
+  SelectionRange as an,
+  Transform as ao,
+  isInTable as ap,
+  generateDocxRandomId as aq,
+  insertNewRelationship as ar,
+  updateDOMAttributes as as,
+  htmlHandler as at,
+  commonjsGlobal as au,
+  getDefaultExportFromCjs$1 as av,
+  getContentTypesFromXml as aw,
+  xmljs as ax,
+  vClickOutside as ay,
+  getActiveFormatting as az,
   Slice as b,
+  translator$S as b0,
+  translator$15 as b1,
+  _sfc_main as b2,
   DOMParser$1 as c,
   Mark as d,
   dropPoint as e,