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

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

@@ -14888,25 +14888,47 @@ const getContentTypesFromXml = (contentTypesXml) => {
   const defaults = xmlDoc.querySelectorAll("Default");
   return Array.from(defaults).map((item) => item.getAttribute("Extension"));
 };
+const DOCX_HIGHLIGHT_KEYWORD_MAP = /* @__PURE__ */ new Map([
+  ["yellow", "FFFF00"],
+  ["green", "00FF00"],
+  ["blue", "0000FF"],
+  ["cyan", "00FFFF"],
+  ["magenta", "FF00FF"],
+  ["red", "FF0000"],
+  ["darkYellow", "808000"],
+  ["darkGreen", "008000"],
+  ["darkBlue", "000080"],
+  ["darkCyan", "008080"],
+  ["darkMagenta", "800080"],
+  ["darkGray", "808080"],
+  ["darkRed", "800000"],
+  ["lightGray", "C0C0C0"],
+  ["black", "000000"],
+  ["white", "FFFFFF"]
+]);
+const normalizeHexColor = (hex2) => {
+  if (!hex2) return null;
+  let value = hex2.replace("#", "").trim();
+  if (!value) return null;
+  value = value.toUpperCase();
+  if (value.length === 3)
+    value = value.split("").map((c2) => c2 + c2).join("");
+  if (value.length === 8) value = value.slice(0, 6);
+  return value;
+};
 const getHexColorFromDocxSystem = (docxColor) => {
-  const colorMap = /* @__PURE__ */ new Map([
-    ["yellow", "#ffff00"],
-    ["green", "#00ff00"],
-    ["blue", "#0000FFFF"],
-    ["cyan", "#00ffff"],
-    ["magenta", "#ff00ff"],
-    ["red", "#ff0000"],
-    ["darkYellow", "#808000FF"],
-    ["darkGreen", "#008000FF"],
-    ["darkBlue", "#000080"],
-    ["darkCyan", "#008080FF"],
-    ["darkMagenta", "#800080FF"],
-    ["darkGray", "#808080FF"],
-    ["darkRed", "#800000FF"],
-    ["lightGray", "#C0C0C0FF"],
-    ["black", "#000"]
-  ]);
-  return colorMap.get(docxColor) || null;
+  const hex2 = DOCX_HIGHLIGHT_KEYWORD_MAP.get(docxColor);
+  return hex2 ? `#${hex2}` : null;
+};
+const getDocxHighlightKeywordFromHex = (hexColor) => {
+  if (!hexColor) return null;
+  if (DOCX_HIGHLIGHT_KEYWORD_MAP.has(hexColor)) return hexColor;
+  const normalized = normalizeHexColor(hexColor);
+  if (!normalized) return null;
+  for (const [keyword, hex2] of DOCX_HIGHLIGHT_KEYWORD_MAP.entries()) {
+    if (hex2 === normalized) return keyword;
+  }
+  return null;
 };
 function isValidHexColor(color) {
   if (!color || typeof color !== "string") return false;
@@ -21401,7 +21423,7 @@ function L() {
   return { async: false, breaks: false, extensions: null, gfm: true, hooks: null, pedantic: false, renderer: null, silent: false, tokenizer: null, walkTokens: null };
 }
 var O = L();
-function H(l3) {
+function G(l3) {
   O = l3;
 }
 var E = { exec: () => null };
@@ -21413,7 +21435,7 @@ function h(l3, e = "") {
   return n;
 }
 var m = { codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm, outputLinkReplace: /\\([\[\]])/g, indentCodeCompensation: /^(\s+)(?:```)/, beginningSpace: /^\s+/, endingHash: /#$/, startingSpaceChar: /^ /, endingSpaceChar: / $/, nonSpaceChar: /[^ ]/, newLineCharGlobal: /\n/g, tabCharGlobal: /\t/g, multipleSpaceGlobal: /\s+/g, blankLine: /^[ \t]*$/, doubleBlankLine: /\n[ \t]*\n[ \t]*$/, blockquoteStart: /^ {0,3}>/, blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g, blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm, listReplaceTabs: /^\t+/, listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g, listIsTask: /^\[[ xX]\] /, listReplaceTask: /^\[[ xX]\] +/, anyLine: /\n.*\n/, hrefBrackets: /^<(.*)>$/, tableDelimiter: /[:|]/, tableAlignChars: /^\||\| *$/g, tableRowBlankLine: /\n[ \t]*$/, tableAlignRight: /^ *-+: *$/, tableAlignCenter: /^ *:-+: *$/, tableAlignLeft: /^ *:-+ *$/, startATag: /^<a /i, endATag: /^<\/a>/i, startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i, endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i, startAngleBracket: /^</, endAngleBracket: />$/, pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/, unicodeAlphaNumeric: /[\p{L}\p{N}]/u, escapeTest: /[&<>"']/, escapeReplace: /[&<>"']/g, escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g, unescapeTest: /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig, caret: /(^|[^\[])\^/g, percentDecode: /%25/g, findPipe: /\|/g, splitPipe: / \|/, slashPipe: /\\\|/g, carriageReturn: /\r\n|\r/g, spaceLine: /^ +$/gm, notSpaceStart: /^\S*/, endingNewline: /\n$/, listItemRegex: (l3) => new RegExp(`^( {0,3}${l3})((?:[	 ][^\\n]*)?(?:\\n|$))`), nextBulletRegex: (l3) => new RegExp(`^ {0,${Math.min(3, l3 - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`), hrRegex: (l3) => new RegExp(`^ {0,${Math.min(3, l3 - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`), fencesBeginRegex: (l3) => new RegExp(`^ {0,${Math.min(3, l3 - 1)}}(?:\`\`\`|~~~)`), headingBeginRegex: (l3) => new RegExp(`^ {0,${Math.min(3, l3 - 1)}}#`), htmlBeginRegex: (l3) => new RegExp(`^ {0,${Math.min(3, l3 - 1)}}<(?:[a-z].*>|!--)`, "i") }, xe = /^(?:[ \t]*(?:\n|$))+/, be = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/, Re = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/, C = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/, Oe = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/, j = /(?:[*+-]|\d{1,9}[.)])/, se = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/, ie$2 = h(se).replace(/bull/g, j).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex(), Te = h(se).replace(/bull/g, j).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex(), F = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/, we = /^[^\n]+/, Q = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/, ye = h(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", Q).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(), Pe = h(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, j).getRegex(), v = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul", U = /<!--(?:-?>|[\s\S]*?(?:-->|$))/, Se = h("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$))", "i").replace("comment", U).replace("tag", v).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(), oe = h(F).replace("hr", C).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", v).getRegex(), $e = h(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", oe).getRegex(), K$1 = { blockquote: $e, code: be, def: ye, fences: Re, heading: Oe, hr: C, html: Se, lheading: ie$2, list: Pe, newline: xe, paragraph: oe, table: E, text: we }, re = h("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", C).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}	)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", v).getRegex(), _e = { ...K$1, lheading: Te, table: re, paragraph: h(F).replace("hr", C).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", re).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", v).getRegex() }, Le = { ...K$1, html: h(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", U).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, heading: /^(#{1,6})(.*)(?:\n+|$)/, fences: E, lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, paragraph: h(F).replace("hr", C).replace("heading", ` *#{1,6} *[^
-]`).replace("lheading", ie$2).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() }, Me = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/, ze = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/, ae = /^( {2,}|\\)\n(?!\s*$)/, Ae = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/, D = /[\p{P}\p{S}]/u, W = /[\s\p{P}\p{S}]/u, le = /[^\s\p{P}\p{S}]/u, Ee = h(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, W).getRegex(), ue = /(?!~)[\p{P}\p{S}]/u, Ce = /(?!~)[\s\p{P}\p{S}]/u, Ie = /(?:[^\s\p{P}\p{S}]|~)/u, Be = /\[[^\[\]]*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)|`[^`]*?`|<(?! )[^<>]*?>/g, pe = /^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/, qe = h(pe, "u").replace(/punct/g, D).getRegex(), ve = h(pe, "u").replace(/punct/g, ue).getRegex(), ce = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)", De = h(ce, "gu").replace(/notPunctSpace/g, le).replace(/punctSpace/g, W).replace(/punct/g, D).getRegex(), Ze = h(ce, "gu").replace(/notPunctSpace/g, Ie).replace(/punctSpace/g, Ce).replace(/punct/g, ue).getRegex(), Ge = h("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, le).replace(/punctSpace/g, W).replace(/punct/g, D).getRegex(), He = h(/\\(punct)/, "gu").replace(/punct/g, D).getRegex(), Ne = h(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(), je = h(U).replace("(?:-->|$)", "-->").getRegex(), Fe = h("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", je).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(), q = /(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`[^`]*`|[^\[\]\\`])*?/, Qe = h(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]*(?:\n[ \t]*)?)(title))?\s*\)/).replace("label", q).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(), he$3 = h(/^!?\[(label)\]\[(ref)\]/).replace("label", q).replace("ref", Q).getRegex(), de = h(/^!?\[(ref)\](?:\[\])?/).replace("ref", Q).getRegex(), Ue = h("reflink|nolink(?!\\()", "g").replace("reflink", he$3).replace("nolink", de).getRegex(), X = { _backpedal: E, anyPunctuation: He, autolink: Ne, blockSkip: Be, br: ae, code: ze, del: E, emStrongLDelim: qe, emStrongRDelimAst: De, emStrongRDelimUnd: Ge, escape: Me, link: Qe, nolink: de, punctuation: Ee, reflink: he$3, reflinkSearch: Ue, tag: Fe, text: Ae, url: E }, Ke = { ...X, link: h(/^!?\[(label)\]\((.*?)\)/).replace("label", q).getRegex(), reflink: h(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", q).getRegex() }, N = { ...X, emStrongRDelimAst: Ze, emStrongLDelim: ve, url: h(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i").replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(), _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, del: /^(~~?)(?=[^\s~])((?:\\[\s\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/, text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/ }, We = { ...N, br: h(ae).replace("{2,}", "*").getRegex(), text: h(N.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex() }, I = { normal: K$1, gfm: _e, pedantic: Le }, M = { normal: X, gfm: N, breaks: We, pedantic: Ke };
+]`).replace("lheading", ie$2).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() }, Me = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/, ze = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/, ae = /^( {2,}|\\)\n(?!\s*$)/, Ae = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/, D = /[\p{P}\p{S}]/u, W = /[\s\p{P}\p{S}]/u, le = /[^\s\p{P}\p{S}]/u, Ee = h(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, W).getRegex(), ue = /(?!~)[\p{P}\p{S}]/u, Ce = /(?!~)[\s\p{P}\p{S}]/u, Ie = /(?:[^\s\p{P}\p{S}]|~)/u, Be = /\[[^\[\]]*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)|`[^`]*?`|<(?! )[^<>]*?>/g, pe = /^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/, qe = h(pe, "u").replace(/punct/g, D).getRegex(), ve = h(pe, "u").replace(/punct/g, ue).getRegex(), ce = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)", De = h(ce, "gu").replace(/notPunctSpace/g, le).replace(/punctSpace/g, W).replace(/punct/g, D).getRegex(), He = h(ce, "gu").replace(/notPunctSpace/g, Ie).replace(/punctSpace/g, Ce).replace(/punct/g, ue).getRegex(), Ze = h("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, le).replace(/punctSpace/g, W).replace(/punct/g, D).getRegex(), Ge = h(/\\(punct)/, "gu").replace(/punct/g, D).getRegex(), Ne = h(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(), je = h(U).replace("(?:-->|$)", "-->").getRegex(), Fe = h("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", je).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(), q = /(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`[^`]*`|[^\[\]\\`])*?/, Qe = h(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]*(?:\n[ \t]*)?)(title))?\s*\)/).replace("label", q).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(), he$3 = h(/^!?\[(label)\]\[(ref)\]/).replace("label", q).replace("ref", Q).getRegex(), de = h(/^!?\[(ref)\](?:\[\])?/).replace("ref", Q).getRegex(), Ue = h("reflink|nolink(?!\\()", "g").replace("reflink", he$3).replace("nolink", de).getRegex(), X = { _backpedal: E, anyPunctuation: Ge, autolink: Ne, blockSkip: Be, br: ae, code: ze, del: E, emStrongLDelim: qe, emStrongRDelimAst: De, emStrongRDelimUnd: Ze, escape: Me, link: Qe, nolink: de, punctuation: Ee, reflink: he$3, reflinkSearch: Ue, tag: Fe, text: Ae, url: E }, Ke = { ...X, link: h(/^!?\[(label)\]\((.*?)\)/).replace("label", q).getRegex(), reflink: h(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", q).getRegex() }, N = { ...X, emStrongRDelimAst: He, emStrongLDelim: ve, url: h(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i").replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(), _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, del: /^(~~?)(?=[^\s~])((?:\\[\s\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/, text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/ }, We = { ...N, br: h(ae).replace("{2,}", "*").getRegex(), text: h(N.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex() }, I = { normal: K$1, gfm: _e, pedantic: Le }, M = { normal: X, gfm: N, breaks: We, pedantic: Ke };
 var Xe = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }, ke = (l3) => Xe[l3];
 function w(l3, e) {
   if (e) {
@@ -21571,15 +21593,15 @@ ${c2}` : c2;
         if (!(t = s.exec(e)) || this.rules.block.hr.test(e)) break;
         p = t[0], e = e.substring(p.length);
         let f = t[2].split(`
-`, 1)[0].replace(this.rules.other.listReplaceTabs, (Z) => " ".repeat(3 * Z.length)), k = e.split(`
+`, 1)[0].replace(this.rules.other.listReplaceTabs, (H) => " ".repeat(3 * H.length)), k = e.split(`
 `, 1)[0], x = !f.trim(), g = 0;
         if (this.options.pedantic ? (g = 2, c2 = f.trimStart()) : x ? g = t[1].length + 1 : (g = t[2].search(this.rules.other.nonSpaceChar), g = g > 4 ? 1 : g, c2 = f.slice(g), g += t[1].length), x && this.rules.other.blankLine.test(k) && (p += k + `
 `, e = e.substring(k.length + 1), u = true), !u) {
-          let Z = this.rules.other.nextBulletRegex(g), ee = this.rules.other.hrRegex(g), te = this.rules.other.fencesBeginRegex(g), ne = this.rules.other.headingBeginRegex(g), me = this.rules.other.htmlBeginRegex(g);
+          let H = this.rules.other.nextBulletRegex(g), ee = this.rules.other.hrRegex(g), te = this.rules.other.fencesBeginRegex(g), ne = this.rules.other.headingBeginRegex(g), me = this.rules.other.htmlBeginRegex(g);
           for (; e; ) {
-            let G = e.split(`
+            let Z = e.split(`
 `, 1)[0], A;
-            if (k = G, this.options.pedantic ? (k = k.replace(this.rules.other.listReplaceNesting, "  "), A = k) : A = k.replace(this.rules.other.tabCharGlobal, "    "), te.test(k) || ne.test(k) || me.test(k) || Z.test(k) || ee.test(k)) break;
+            if (k = Z, this.options.pedantic ? (k = k.replace(this.rules.other.listReplaceNesting, "  "), A = k) : A = k.replace(this.rules.other.tabCharGlobal, "    "), te.test(k) || ne.test(k) || me.test(k) || H.test(k) || ee.test(k)) break;
             if (A.search(this.rules.other.nonSpaceChar) >= g || !k.trim()) c2 += `
 ` + A.slice(g);
             else {
@@ -21587,8 +21609,8 @@ ${c2}` : c2;
               c2 += `
 ` + k;
             }
-            !x && !k.trim() && (x = true), p += G + `
-`, e = e.substring(G.length + 1), f = A.slice(g);
+            !x && !k.trim() && (x = true), p += Z + `
+`, e = e.substring(Z.length + 1), f = A.slice(g);
           }
         }
         i.loose || (o ? i.loose = true : this.rules.other.doubleBlankLine.test(p) && (o = true));
@@ -21895,6 +21917,7 @@ var b = class l {
     }
     for (; (r2 = this.tokenizer.rules.inline.anyPunctuation.exec(n)) != null; ) n = n.slice(0, r2.index) + "++" + n.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
     for (; (r2 = this.tokenizer.rules.inline.blockSkip.exec(n)) != null; ) n = n.slice(0, r2.index) + "[" + "a".repeat(r2[0].length - 2) + "]" + n.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+    n = this.options.hooks?.emStrongMask?.call({ lexer: this }, n) ?? n;
     let i = false, s = "";
     for (; e; ) {
       i || (s = ""), i = false;
@@ -22089,7 +22112,7 @@ ${e}</tr>
     return "tokens" in e && e.tokens ? this.parser.parseInline(e.tokens) : "escaped" in e && e.escaped ? e.text : w(e.text);
   }
 };
-var S = class {
+var $ = class {
   strong({ text: e }) {
     return e;
   }
@@ -22123,7 +22146,7 @@ var R = class l2 {
     __publicField$2(this, "options");
     __publicField$2(this, "renderer");
     __publicField$2(this, "textRenderer");
-    this.options = e || O, this.options.renderer = this.options.renderer || new P(), this.renderer = this.options.renderer, this.renderer.options = this.options, this.renderer.parser = this, this.textRenderer = new S();
+    this.options = e || O, this.options.renderer = this.options.renderer || new P(), this.renderer = this.options.renderer, this.renderer.options = this.options, this.renderer.parser = this, this.textRenderer = new $();
   }
   static parse(e, t) {
     return new l2(t).parse(e);
@@ -22263,7 +22286,7 @@ var R = class l2 {
     return n;
   }
 };
-var $ = (_a = class {
+var S = (_a = class {
   constructor(e) {
     __publicField$2(this, "options");
     __publicField$2(this, "block");
@@ -22278,13 +22301,16 @@ var $ = (_a = class {
   processAllTokens(e) {
     return e;
   }
+  emStrongMask(e) {
+    return e;
+  }
   provideLexer() {
     return this.block ? b.lex : b.lexInline;
   }
   provideParser() {
     return this.block ? R.parse : R.parseInline;
   }
-}, __publicField$2(_a, "passThroughHooks", /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens"])), _a);
+}, __publicField$2(_a, "passThroughHooks", /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens", "emStrongMask"])), __publicField$2(_a, "passThroughHooksRespectAsync", /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens"])), _a);
 var B = class {
   constructor(...e) {
     __publicField$2(this, "defaults", L());
@@ -22293,10 +22319,10 @@ var B = class {
     __publicField$2(this, "parseInline", this.parseMarkdown(false));
     __publicField$2(this, "Parser", R);
     __publicField$2(this, "Renderer", P);
-    __publicField$2(this, "TextRenderer", S);
+    __publicField$2(this, "TextRenderer", $);
     __publicField$2(this, "Lexer", b);
     __publicField$2(this, "Tokenizer", y);
-    __publicField$2(this, "Hooks", $);
+    __publicField$2(this, "Hooks", S);
     this.use(...e);
   }
   walkTokens(e, t) {
@@ -22369,13 +22395,13 @@ var B = class {
         r2.tokenizer = i;
       }
       if (n.hooks) {
-        let i = this.defaults.hooks || new $();
+        let i = this.defaults.hooks || new S();
         for (let s in n.hooks) {
           if (!(s in i)) throw new Error(`hook '${s}' does not exist`);
           if (["options", "block"].includes(s)) continue;
           let o = s, a = n.hooks[o], u = i[o];
-          $.passThroughHooks.has(s) ? i[o] = (p) => {
-            if (this.defaults.async) return Promise.resolve(a.call(i, p)).then((f) => u.call(i, f));
+          S.passThroughHooks.has(s) ? i[o] = (p) => {
+            if (this.defaults.async && S.passThroughHooksRespectAsync.has(s)) return Promise.resolve(a.call(i, p)).then((f) => u.call(i, f));
             let c2 = a.call(i, p);
             return u.call(i, c2);
           } : i[o] = (...p) => {
@@ -22441,12 +22467,12 @@ function d(l3, e) {
   return _.parse(l3, e);
 }
 d.options = d.setOptions = function(l3) {
-  return _.setOptions(l3), d.defaults = _.defaults, H(d.defaults), d;
+  return _.setOptions(l3), d.defaults = _.defaults, G(d.defaults), d;
 };
 d.getDefaults = L;
 d.defaults = O;
 d.use = function(...l3) {
-  return _.use(...l3), d.defaults = _.defaults, H(d.defaults), d;
+  return _.use(...l3), d.defaults = _.defaults, G(d.defaults), d;
 };
 d.walkTokens = function(l3, e) {
   return _.walkTokens(l3, e);
@@ -22455,11 +22481,11 @@ d.parseInline = _.parseInline;
 d.Parser = R;
 d.parser = R.parse;
 d.Renderer = P;
-d.TextRenderer = S;
+d.TextRenderer = $;
 d.Lexer = b;
 d.lexer = b.lex;
 d.Tokenizer = y;
-d.Hooks = $;
+d.Hooks = S;
 d.parse = d;
 d.options;
 d.setOptions;
@@ -24290,37 +24316,37 @@ const _NodeTranslator = class _NodeTranslator2 {
 };
 __publicField$2(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$A = (attributes) => {
+const encode$17 = (attributes) => {
   return attributes["w:type"];
 };
-const decode$A = (attrs) => {
+const decode$_ = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
-const attrConfig$i = Object.freeze({
+const attrConfig$F = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$A,
-  decode: decode$A
+  encode: encode$17,
+  decode: decode$_
 });
-const encode$z = (attributes) => {
+const encode$16 = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$z = (attrs) => {
+const decode$Z = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
-const attrConfig$h = Object.freeze({
+const attrConfig$E = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$z,
-  decode: decode$z
+  encode: encode$16,
+  decode: decode$Z
 });
-const validXmlAttributes$b = [attrConfig$i, attrConfig$h];
-const XML_NODE_NAME$h = "w:br";
+const validXmlAttributes$l = [attrConfig$F, attrConfig$E];
+const XML_NODE_NAME$t = "w:br";
 const SD_NODE_NAME$c = "lineBreak";
-const encode$y = (_2, encodedAttrs) => {
+const encode$15 = (_2, encodedAttrs) => {
   const isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -24330,7 +24356,7 @@ const encode$y = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$y = (params2, decodedAttrs) => {
+const decode$Y = (params2, decodedAttrs) => {
   const { node } = params2;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24347,63 +24373,125 @@ const decode$y = (params2, decodedAttrs) => {
   };
   return translated;
 };
-const config$f = {
-  xmlName: XML_NODE_NAME$h,
+const config$r = {
+  xmlName: XML_NODE_NAME$t,
   sdNodeOrKeyName: SD_NODE_NAME$c,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$y,
-  decode: decode$y,
-  attributes: validXmlAttributes$b
+  encode: encode$15,
+  decode: decode$Y,
+  attributes: validXmlAttributes$l
+};
+const translator$15 = NodeTranslator.from(config$r);
+const encode$14 = (attributes) => attributes?.["w:val"];
+const decode$X = (attrs) => attrs?.highlight;
+const attrConfig$D = Object.freeze({
+  xmlName: "w:val",
+  sdName: "highlight",
+  encode: encode$14,
+  decode: decode$X
+});
+const validXmlAttributes$k = [attrConfig$D];
+const XML_NODE_NAME$s = "w:highlight";
+const SD_ATTR_KEY$f = "highlight";
+const DISABLED_TOKENS = /* @__PURE__ */ new Set(["transparent", "none", "inherit"]);
+const encode$13 = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  const value = encodedAttrs.highlight ?? node?.attributes?.["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$s,
+    sdNodeOrKeyName: SD_ATTR_KEY$f,
+    attributes: { "w:val": value ?? null }
+  };
+};
+const decode$W = (params2) => {
+  const attrs = params2?.node?.attrs || {};
+  const highlightValue = attrs.highlight ?? attrs.color ?? null;
+  if (!highlightValue) return void 0;
+  const normalizedValue = String(highlightValue).trim().toLowerCase();
+  if (!normalizedValue) return void 0;
+  if (DISABLED_TOKENS.has(normalizedValue)) {
+    return {
+      name: XML_NODE_NAME$s,
+      attributes: { "w:val": "none" }
+    };
+  }
+  const keyword = getDocxHighlightKeywordFromHex(highlightValue);
+  if (keyword) {
+    return {
+      name: XML_NODE_NAME$s,
+      attributes: { "w:val": keyword }
+    };
+  }
+  const fill = normalizeHexColor(highlightValue);
+  if (!fill) return void 0;
+  return {
+    name: "w:shd",
+    attributes: {
+      "w:color": "auto",
+      "w:val": "clear",
+      "w:fill": fill
+    }
+  };
 };
-const translator$V = NodeTranslator.from(config$f);
-const encode$x = (attributes) => {
+const config$q = {
+  xmlName: XML_NODE_NAME$s,
+  sdNodeOrKeyName: SD_ATTR_KEY$f,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$13,
+  decode: decode$W,
+  attributes: validXmlAttributes$k
+};
+const translator$14 = NodeTranslator.from(config$q);
+const encode$12 = (attributes) => {
   return attributes["w:val"];
 };
-const decode$x = (attrs) => {
+const decode$V = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
-const attrConfig$g = Object.freeze({
+const attrConfig$C = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$x,
-  decode: decode$x
+  encode: encode$12,
+  decode: decode$V
 });
-const encode$w = (attributes) => {
+const encode$11 = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$w = (attrs) => {
+const decode$U = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
-const attrConfig$f = Object.freeze({
+const attrConfig$B = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$w,
-  decode: decode$w
+  encode: encode$11,
+  decode: decode$U
 });
-const encode$v = (attributes) => {
+const encode$10 = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$v = (attrs) => {
+const decode$T = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
-const attrConfig$e = Object.freeze({
+const attrConfig$A = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$v,
-  decode: decode$v
+  encode: encode$10,
+  decode: decode$T
 });
-const validXmlAttributes$a = [attrConfig$g, attrConfig$e, attrConfig$f];
-const XML_NODE_NAME$g = "w:tab";
+const validXmlAttributes$j = [attrConfig$C, attrConfig$A, attrConfig$B];
+const XML_NODE_NAME$r = "w:tab";
 const SD_NODE_NAME$b = "tab";
-const encode$u = (_2, encodedAttrs = {}) => {
+const encode$$ = (_2, encodedAttrs = {}) => {
   const translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$u = (params2, decodedAttrs = {}) => {
+const decode$S = (params2, decodedAttrs = {}) => {
   const { node } = params2 || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24419,15 +24507,15 @@ const decode$u = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$e = {
-  xmlName: XML_NODE_NAME$g,
+const config$p = {
+  xmlName: XML_NODE_NAME$r,
   sdNodeOrKeyName: SD_NODE_NAME$b,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$u,
-  decode: decode$u,
-  attributes: validXmlAttributes$a
+  encode: encode$$,
+  decode: decode$S,
+  attributes: validXmlAttributes$j
 };
-const translator$U = NodeTranslator.from(config$e);
+const translator$13 = NodeTranslator.from(config$p);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -24602,17 +24690,21 @@ function getMarkValue(markType, attributes, docx) {
 function getFontFamilyValue(attributes, docx) {
   const ascii = attributes["w:ascii"];
   const themeAscii = attributes["w:asciiTheme"];
-  if (!docx || !themeAscii) return ascii;
-  const theme = docx["word/theme/theme1.xml"];
-  if (!theme) return ascii;
-  const { elements: topElements } = theme;
-  const { elements } = topElements[0];
-  const themeElements = elements.find((el) => el.name === "a:themeElements");
-  const fontScheme = themeElements.elements.find((el) => el.name === "a:fontScheme");
-  const majorFont = fontScheme.elements.find((el) => el.name === "a:majorFont");
-  const latin = majorFont.elements.find((el) => el.name === "a:latin");
-  const typeface = latin.attributes["typeface"];
-  return typeface;
+  let resolved = ascii;
+  if (docx && themeAscii) {
+    const theme = docx["word/theme/theme1.xml"];
+    if (theme?.elements?.length) {
+      const { elements: topElements } = theme;
+      const { elements } = topElements[0] || {};
+      const themeElements = elements?.find((el) => el.name === "a:themeElements");
+      const fontScheme = themeElements?.elements?.find((el) => el.name === "a:fontScheme");
+      const majorFont = fontScheme?.elements?.find((el) => el.name === "a:majorFont");
+      const latin = majorFont?.elements?.find((el) => el.name === "a:latin");
+      resolved = latin?.attributes?.typeface || resolved;
+    }
+  }
+  if (!resolved) return null;
+  return SuperConverter.toCssFontFamily(resolved, docx);
 }
 function getIndentValue(attributes) {
   let value = attributes["w:left"];
@@ -24633,7 +24725,11 @@ function getHighLightValue(attributes) {
   return getHexColorFromDocxSystem(attributes?.["w:val"]) || null;
 }
 function getStrikeValue(attributes) {
-  return attributes?.["w:val"] === "1" ? attributes["w:val"] : null;
+  const raw = attributes?.["w:val"];
+  if (raw === void 0 || raw === null) return "1";
+  const value = String(raw).trim().toLowerCase();
+  if (value === "1" || value === "true" || value === "on") return "1";
+  return null;
 }
 const parseParagraphBorders = (pBdr) => {
   if (!pBdr || !pBdr.elements) return {};
@@ -24663,27 +24759,39 @@ const getParagraphIndent = (node, docx, styleId = "") => {
     right: 0,
     firstLine: 0,
     hanging: 0,
-    textIndent: 0
+    textIndent: 0,
+    explicitLeft: false,
+    explicitRight: false,
+    explicitFirstLine: false,
+    explicitHanging: false
   };
   const { indent: pDefaultIndent = {} } = getDefaultParagraphStyle(docx, styleId);
   const pPr = node.elements?.find((el) => el.name === "w:pPr");
   const inLineIndentTag = pPr?.elements?.find((el) => el.name === "w:ind");
   const inLineIndent = inLineIndentTag?.attributes || {};
-  const leftIndent = inLineIndent?.["w:left"] || pDefaultIndent?.["w:left"];
-  const rightIndent = inLineIndent?.["w:right"] || pDefaultIndent?.["w:right"];
-  const firstLine = inLineIndent?.["w:firstLine"] || pDefaultIndent?.["w:firstLine"];
-  const hanging = inLineIndent?.["w:hanging"] || pDefaultIndent?.["w:hanging"];
+  const inlineLeft = inLineIndent?.["w:left"];
+  const inlineRight = inLineIndent?.["w:right"];
+  const inlineFirstLine = inLineIndent?.["w:firstLine"];
+  const inlineHanging = inLineIndent?.["w:hanging"];
+  const leftIndent = inlineLeft ?? pDefaultIndent?.["w:left"];
+  const rightIndent = inlineRight ?? pDefaultIndent?.["w:right"];
+  const firstLine = inlineFirstLine ?? pDefaultIndent?.["w:firstLine"];
+  const hanging = inlineHanging ?? pDefaultIndent?.["w:hanging"];
   if (leftIndent) {
     indent.left = twipsToPixels(leftIndent);
+    indent.explicitLeft = inlineLeft !== void 0;
   }
   if (rightIndent) {
     indent.right = twipsToPixels(rightIndent);
+    indent.explicitRight = inlineRight !== void 0;
   }
   if (firstLine) {
     indent.firstLine = twipsToPixels(firstLine);
+    indent.explicitFirstLine = inlineFirstLine !== void 0;
   }
   if (hanging) {
     indent.hanging = twipsToPixels(hanging);
+    indent.explicitHanging = inlineHanging !== void 0;
   }
   const textIndentValue = leftIndent - parseInt(hanging || 0) || 0;
   if (textIndentValue) {
@@ -25022,102 +25130,102 @@ const handleParagraphNode$1 = (params2) => {
   }
   return schemaNode;
 };
-const encode$t = (attributes) => {
+const encode$_ = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$t = (attrs) => {
+const decode$R = (attrs) => {
   return attrs.rsidDel;
 };
-const attrConfig$d = Object.freeze({
+const attrConfig$z = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$t,
-  decode: decode$t
+  encode: encode$_,
+  decode: decode$R
 });
-const encode$s = (attributes) => {
+const encode$Z = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$s = (attrs) => {
+const decode$Q = (attrs) => {
   return attrs.rsidP;
 };
-const attrConfig$c = Object.freeze({
+const attrConfig$y = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$s,
-  decode: decode$s
+  encode: encode$Z,
+  decode: decode$Q
 });
-const encode$r = (attributes) => {
+const encode$Y = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$r = (attrs) => {
+const decode$P = (attrs) => {
   return attrs.rsidR;
 };
-const attrConfig$b = Object.freeze({
+const attrConfig$x = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$r,
-  decode: decode$r
+  encode: encode$Y,
+  decode: decode$P
 });
-const encode$q = (attributes) => {
+const encode$X = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$q = (attrs) => {
+const decode$O = (attrs) => {
   return attrs.rsidRPr;
 };
-const attrConfig$a = Object.freeze({
+const attrConfig$w = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$q,
-  decode: decode$q
+  encode: encode$X,
+  decode: decode$O
 });
-const encode$p = (attributes) => {
+const encode$W = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$p = (attrs) => {
+const decode$N = (attrs) => {
   return attrs.rsidRDefault;
 };
-const attrConfig$9 = Object.freeze({
+const attrConfig$v = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$p,
-  decode: decode$p
+  encode: encode$W,
+  decode: decode$N
 });
-const encode$o = (attributes) => {
+const encode$V = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$o = (attrs) => {
+const decode$M = (attrs) => {
   return attrs.paraId;
 };
-const attrConfig$8 = Object.freeze({
+const attrConfig$u = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$o,
-  decode: decode$o
+  encode: encode$V,
+  decode: decode$M
 });
-const encode$n = (attributes) => {
+const encode$U = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$n = (attrs) => {
+const decode$L = (attrs) => {
   return attrs.textId;
 };
-const attrConfig$7 = Object.freeze({
+const attrConfig$t = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$n,
-  decode: decode$n
+  encode: encode$U,
+  decode: decode$L
 });
-const validXmlAttributes$9 = [
-  attrConfig$8,
-  attrConfig$7,
-  attrConfig$b,
-  attrConfig$9,
-  attrConfig$c,
-  attrConfig$a,
-  attrConfig$d
+const validXmlAttributes$i = [
+  attrConfig$u,
+  attrConfig$t,
+  attrConfig$x,
+  attrConfig$v,
+  attrConfig$y,
+  attrConfig$w,
+  attrConfig$z
 ];
-const XML_NODE_NAME$f = "w:p";
+const XML_NODE_NAME$q = "w:p";
 const SD_NODE_NAME$a = "paragraph";
-const encode$m = (params2, encodedAttrs = {}) => {
+const encode$T = (params2, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params2);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25125,7 +25233,7 @@ const encode$m = (params2, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$m = (params2, decodedAttrs = {}) => {
+const decode$K = (params2, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params2);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25133,9 +25241,1164 @@ const decode$m = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
+const config$o = {
+  xmlName: XML_NODE_NAME$q,
+  sdNodeOrKeyName: SD_NODE_NAME$a,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$T,
+  decode: decode$K,
+  attributes: validXmlAttributes$i
+};
+const translator$12 = NodeTranslator.from(config$o);
+const encode$S = (attributes) => {
+  const raw = attributes?.["w:val"];
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw === "number") return raw !== 0;
+  const val = String(raw).trim().toLowerCase();
+  if (val === "0" || val === "false" || val === "off") return false;
+  if (val === "1" || val === "true" || val === "on") return true;
+  return void 0;
+};
+const decode$J = (runProps) => {
+  if (runProps?.bold === false) return "0";
+  return void 0;
+};
+const attrConfig$s = Object.freeze({
+  xmlName: "w:val",
+  sdName: "bold",
+  encode: encode$S,
+  decode: decode$J
+});
+const validXmlAttributes$h = [attrConfig$s];
+const XML_NODE_NAME$p = "w:b";
+const SD_ATTR_KEY$e = "bold";
+const encode$R = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes[0];
+  if (!node) return void 0;
+  const val = encodedAttrs?.[SD_ATTR_KEY$e];
+  let attributes;
+  if (val === false) attributes = { "w:val": "0" };
+  else if (val === true)
+    attributes = {};
+  else attributes = node.attributes || {};
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$p,
+    sdNodeOrKeyName: SD_ATTR_KEY$e,
+    attributes
+  };
+};
+const config$n = {
+  xmlName: XML_NODE_NAME$p,
+  sdNodeOrKeyName: SD_ATTR_KEY$e,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$R,
+  attributes: validXmlAttributes$h
+};
+const translator$11 = NodeTranslator.from(config$n);
+const XML_NODE_NAME$o = "w:i";
+const SD_ATTR_KEY$d = "italic";
+const encode$Q = (params2) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  if (!node) return void 0;
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$o,
+    sdNodeOrKeyName: SD_ATTR_KEY$d,
+    attributes: {
+      "w:val": node.attributes?.["w:val"] ?? null
+    }
+  };
+};
+const config$m = {
+  xmlName: XML_NODE_NAME$o,
+  sdNodeOrKeyName: SD_ATTR_KEY$d,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$Q
+};
+const translator$10 = NodeTranslator.from(config$m);
+const encode$P = (attributes) => attributes?.["w:val"];
+const decode$I = (attrs) => attrs?.underline;
+const attrConfig$r = Object.freeze({
+  xmlName: "w:val",
+  sdName: "underline",
+  encode: encode$P,
+  decode: decode$I
+});
+const encode$O = (attributes) => attributes?.["w:color"];
+const decode$H = (attrs) => attrs?.color;
+const attrConfig$q = Object.freeze({
+  xmlName: "w:color",
+  sdName: "color",
+  encode: encode$O,
+  decode: decode$H
+});
+const encode$N = (attributes) => attributes?.["w:themeColor"];
+const decode$G = (attrs) => attrs?.themeColor;
+const attrConfig$p = Object.freeze({
+  xmlName: "w:themeColor",
+  sdName: "themeColor",
+  encode: encode$N,
+  decode: decode$G
+});
+const encode$M = (attributes) => attributes?.["w:themeTint"];
+const decode$F = (attrs) => attrs?.themeTint;
+const attrConfig$o = Object.freeze({
+  xmlName: "w:themeTint",
+  sdName: "themeTint",
+  encode: encode$M,
+  decode: decode$F
+});
+const encode$L = (attributes) => attributes?.["w:themeShade"];
+const decode$E = (attrs) => attrs?.themeShade;
+const attrConfig$n = Object.freeze({
+  xmlName: "w:themeShade",
+  sdName: "themeShade",
+  encode: encode$L,
+  decode: decode$E
+});
+const validXmlAttributes$g = [attrConfig$r, attrConfig$q, attrConfig$p, attrConfig$o, attrConfig$n];
+const XML_NODE_NAME$n = "w:u";
+const SD_ATTR_KEY$c = "underline";
+const encode$K = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  const sourceAttrs = node?.attributes || {};
+  const underlineType = encodedAttrs.underline ?? sourceAttrs["w:val"];
+  const color = encodedAttrs.color ?? sourceAttrs["w:color"];
+  const themeColor = encodedAttrs.themeColor ?? sourceAttrs["w:themeColor"];
+  const themeTint = encodedAttrs.themeTint ?? sourceAttrs["w:themeTint"];
+  const themeShade = encodedAttrs.themeShade ?? sourceAttrs["w:themeShade"];
+  const attributes = { "w:val": underlineType ?? null };
+  if (color !== void 0 && color !== null) attributes["w:color"] = color;
+  if (themeColor !== void 0 && themeColor !== null) attributes["w:themeColor"] = themeColor;
+  if (themeTint !== void 0 && themeTint !== null) attributes["w:themeTint"] = themeTint;
+  if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$n,
+    sdNodeOrKeyName: SD_ATTR_KEY$c,
+    attributes
+  };
+};
+const decode$D = (params2) => {
+  const attrs = params2?.node?.attrs || {};
+  const underlineType = attrs.underlineType ?? attrs.underline ?? null;
+  const color = attrs.underlineColor ?? attrs.color ?? null;
+  const themeColor = attrs.underlineThemeColor ?? attrs.themeColor ?? null;
+  const themeTint = attrs.underlineThemeTint ?? attrs.themeTint ?? null;
+  const themeShade = attrs.underlineThemeShade ?? attrs.themeShade ?? null;
+  if (!underlineType && !color && !themeColor && !themeTint && !themeShade) return void 0;
+  const attributes = {};
+  if (underlineType) attributes["w:val"] = underlineType;
+  if (color) {
+    const normalized = normalizeHexColor(color);
+    if (normalized) attributes["w:color"] = normalized;
+  }
+  if (themeColor) attributes["w:themeColor"] = themeColor;
+  if (themeTint) attributes["w:themeTint"] = themeTint;
+  if (themeShade) attributes["w:themeShade"] = themeShade;
+  return {
+    name: XML_NODE_NAME$n,
+    attributes
+  };
+};
+const config$l = {
+  xmlName: XML_NODE_NAME$n,
+  sdNodeOrKeyName: SD_ATTR_KEY$c,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$K,
+  decode: decode$D,
+  attributes: validXmlAttributes$g
+};
+const translator$$ = NodeTranslator.from(config$l);
+const encode$J = (attributes) => {
+  const raw = attributes?.["w:val"];
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw === "number") return raw !== 0;
+  const val = String(raw).trim().toLowerCase();
+  if (val === "0" || val === "false" || val === "off") return false;
+  if (val === "1" || val === "true" || val === "on") return true;
+  return void 0;
+};
+const decode$C = (attrs) => {
+  if (attrs?.strike === false) return "0";
+  return void 0;
+};
+const attrConfig$m = Object.freeze({
+  xmlName: "w:val",
+  sdName: "strike",
+  encode: encode$J,
+  decode: decode$C
+});
+const validXmlAttributes$f = [attrConfig$m];
+const XML_NODE_NAME$m = "w:strike";
+const SD_ATTR_KEY$b = "strike";
+const encode$I = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  if (!node) return void 0;
+  const val = encodedAttrs?.[SD_ATTR_KEY$b];
+  let attributes;
+  if (val === false) attributes = { "w:val": "0" };
+  else if (val === true) attributes = {};
+  else attributes = { ...node.attributes || {} };
+  if (attributes["w:val"] === void 0 && val !== true) attributes["w:val"] = null;
+  else if (val === true && attributes["w:val"] === void 0) delete attributes["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$m,
+    sdNodeOrKeyName: SD_ATTR_KEY$b,
+    attributes
+  };
+};
+const config$k = {
+  xmlName: XML_NODE_NAME$m,
+  sdNodeOrKeyName: SD_ATTR_KEY$b,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$I,
+  attributes: validXmlAttributes$f
+};
+const translator$_ = NodeTranslator.from(config$k);
+const encode$H = (attributes) => attributes?.["w:val"];
+const decode$B = (attrs) => attrs?.color;
+const attrConfig$l = Object.freeze({
+  xmlName: "w:val",
+  sdName: "color",
+  encode: encode$H,
+  decode: decode$B
+});
+const encode$G = (attributes) => attributes?.["w:themeColor"];
+const decode$A = (attrs) => attrs?.themeColor;
+const attrConfig$k = Object.freeze({
+  xmlName: "w:themeColor",
+  sdName: "themeColor",
+  encode: encode$G,
+  decode: decode$A
+});
+const encode$F = (attributes) => attributes?.["w:themeTint"];
+const decode$z = (attrs) => attrs?.themeTint;
+const attrConfig$j = Object.freeze({
+  xmlName: "w:themeTint",
+  sdName: "themeTint",
+  encode: encode$F,
+  decode: decode$z
+});
+const encode$E = (attributes) => attributes?.["w:themeShade"];
+const decode$y = (attrs) => attrs?.themeShade;
+const attrConfig$i = Object.freeze({
+  xmlName: "w:themeShade",
+  sdName: "themeShade",
+  encode: encode$E,
+  decode: decode$y
+});
+const validXmlAttributes$e = [attrConfig$l, attrConfig$k, attrConfig$j, attrConfig$i];
+const XML_NODE_NAME$l = "w:color";
+const SD_ATTR_KEY$a = "color";
+const encode$D = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  const sourceAttrs = node?.attributes || {};
+  const value = encodedAttrs.color ?? sourceAttrs["w:val"];
+  const themeColor = encodedAttrs.themeColor ?? sourceAttrs["w:themeColor"];
+  const themeTint = encodedAttrs.themeTint ?? sourceAttrs["w:themeTint"];
+  const themeShade = encodedAttrs.themeShade ?? sourceAttrs["w:themeShade"];
+  const attributes = {};
+  attributes["w:val"] = value ?? null;
+  if (themeColor !== void 0 && themeColor !== null) attributes["w:themeColor"] = themeColor;
+  if (themeTint !== void 0 && themeTint !== null) attributes["w:themeTint"] = themeTint;
+  if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$l,
+    sdNodeOrKeyName: SD_ATTR_KEY$a,
+    attributes
+  };
+};
+const config$j = {
+  xmlName: XML_NODE_NAME$l,
+  sdNodeOrKeyName: SD_ATTR_KEY$a,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$D,
+  attributes: validXmlAttributes$e
+};
+const translator$Z = NodeTranslator.from(config$j);
+const encode$C = (attributes) => attributes?.["w:eastAsia"];
+const decode$x = (attrs) => attrs?.eastAsia;
+const attrConfig$h = Object.freeze({
+  xmlName: "w:eastAsia",
+  sdName: "eastAsia",
+  encode: encode$C,
+  decode: decode$x
+});
+const encode$B = (attributes) => attributes?.["w:ascii"];
+const decode$w = (attrs) => attrs?.ascii;
+const attrConfig$g = Object.freeze({
+  xmlName: "w:ascii",
+  sdName: "ascii",
+  encode: encode$B,
+  decode: decode$w
+});
+const encode$A = (attributes) => attributes?.["w:hAnsi"];
+const decode$v = (attrs) => attrs?.hAnsi;
+const attrConfig$f = Object.freeze({
+  xmlName: "w:hAnsi",
+  sdName: "hAnsi",
+  encode: encode$A,
+  decode: decode$v
+});
+const encode$z = (attributes) => attributes?.["w:cs"];
+const decode$u = (attrs) => attrs?.cs;
+const attrConfig$e = Object.freeze({
+  xmlName: "w:cs",
+  sdName: "cs",
+  encode: encode$z,
+  decode: decode$u
+});
+const encode$y = (attributes) => attributes?.["w:val"];
+const decode$t = (attrs) => attrs?.value;
+const attrConfig$d = Object.freeze({
+  xmlName: "w:val",
+  sdName: "value",
+  encode: encode$y,
+  decode: decode$t
+});
+const validXmlAttributes$d = [attrConfig$h, attrConfig$g, attrConfig$f, attrConfig$e, attrConfig$d];
+const XML_NODE_NAME$k = "w:rFonts";
+const SD_ATTR_KEY$9 = "fontFamily";
+const encode$x = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  const sourceAttrs = node?.attributes || {};
+  const attributes = {};
+  const setAttr = (xmlName, sdName) => {
+    if (encodedAttrs[sdName] !== void 0 && encodedAttrs[sdName] !== null) {
+      attributes[xmlName] = encodedAttrs[sdName];
+    } else if (sourceAttrs[xmlName] !== void 0) {
+      attributes[xmlName] = sourceAttrs[xmlName];
+    }
+  };
+  setAttr("w:eastAsia", "eastAsia");
+  setAttr("w:ascii", "ascii");
+  setAttr("w:hAnsi", "hAnsi");
+  setAttr("w:cs", "cs");
+  setAttr("w:val", "value");
+  Object.keys(sourceAttrs).forEach((key2) => {
+    if (attributes[key2] === void 0) attributes[key2] = sourceAttrs[key2];
+  });
+  if (attributes["w:val"] === void 0 && attributes["w:eastAsia"]) {
+    attributes["w:val"] = attributes["w:eastAsia"];
+  }
+  if (attributes["w:val"] === void 0) delete attributes["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$k,
+    sdNodeOrKeyName: SD_ATTR_KEY$9,
+    attributes
+  };
+};
+const config$i = {
+  xmlName: XML_NODE_NAME$k,
+  sdNodeOrKeyName: SD_ATTR_KEY$9,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$x,
+  attributes: validXmlAttributes$d
+};
+const translator$Y = NodeTranslator.from(config$i);
+const encode$w = (attributes) => attributes?.["w:val"];
+const decode$s = (attrs) => attrs?.styleId;
+const attrConfig$c = Object.freeze({
+  xmlName: "w:val",
+  sdName: "styleId",
+  encode: encode$w,
+  decode: decode$s
+});
+const validXmlAttributes$c = [attrConfig$c];
+const XML_NODE_NAME$j = "w:rStyle";
+const SD_ATTR_KEY$8 = "styleId";
+const encode$v = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  const value = encodedAttrs.styleId ?? node?.attributes?.["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$j,
+    sdNodeOrKeyName: SD_ATTR_KEY$8,
+    attributes: { "w:val": value ?? null }
+  };
+};
+const config$h = {
+  xmlName: XML_NODE_NAME$j,
+  sdNodeOrKeyName: SD_ATTR_KEY$8,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$v,
+  attributes: validXmlAttributes$c
+};
+const translator$X = NodeTranslator.from(config$h);
+const encode$u = (attributes) => attributes?.["w:val"];
+const decode$r = (attrs) => attrs?.fontSize;
+const attrConfig$b = Object.freeze({
+  xmlName: "w:val",
+  sdName: "fontSize",
+  encode: encode$u,
+  decode: decode$r
+});
+const validXmlAttributes$b = [attrConfig$b];
+const XML_NODE_NAME$i = "w:sz";
+const SD_ATTR_KEY$7 = "fontSize";
+const encode$t = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  const value = encodedAttrs.fontSize ?? node?.attributes?.["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$i,
+    sdNodeOrKeyName: SD_ATTR_KEY$7,
+    attributes: { "w:val": value ?? null }
+  };
+};
+const config$g = {
+  xmlName: XML_NODE_NAME$i,
+  sdNodeOrKeyName: SD_ATTR_KEY$7,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$t,
+  attributes: validXmlAttributes$b
+};
+const translator$W = NodeTranslator.from(config$g);
+const encode$s = (attributes) => attributes?.["w:val"];
+const decode$q = (attrs) => attrs?.fontSizeCs;
+const attrConfig$a = Object.freeze({
+  xmlName: "w:val",
+  sdName: "fontSizeCs",
+  encode: encode$s,
+  decode: decode$q
+});
+const validXmlAttributes$a = [attrConfig$a];
+const XML_NODE_NAME$h = "w:szCs";
+const SD_ATTR_KEY$6 = "fontSizeCs";
+const encode$r = (params2, encodedAttrs = {}) => {
+  const { nodes } = params2;
+  const node = nodes?.[0];
+  const value = encodedAttrs.fontSizeCs ?? node?.attributes?.["w:val"];
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$h,
+    sdNodeOrKeyName: SD_ATTR_KEY$6,
+    attributes: { "w:val": value ?? null }
+  };
+};
+const config$f = {
+  xmlName: XML_NODE_NAME$h,
+  sdNodeOrKeyName: SD_ATTR_KEY$6,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$r,
+  attributes: validXmlAttributes$a
+};
+const translator$V = NodeTranslator.from(config$f);
+const runPropertyTranslators = Object.freeze({
+  "w:b": translator$11,
+  "w:i": translator$10,
+  "w:u": translator$$,
+  "w:strike": translator$_,
+  "w:color": translator$Z,
+  "w:highlight": translator$14,
+  "w:rFonts": translator$Y,
+  "w:rStyle": translator$X,
+  "w:sz": translator$W,
+  "w:szCs": translator$V
+});
+const rawRunPropertyXmlNames = Object.freeze(["w:lang", "w:shd"]);
+const RAW_CHILD_NAME_SET = new Set(rawRunPropertyXmlNames);
+const KNOWN_CHILD_XML_NAMES = /* @__PURE__ */ new Set([...Object.keys(runPropertyTranslators), ...RAW_CHILD_NAME_SET]);
+const toRunPropertyEntry = (candidate) => {
+  if (!candidate || candidate.type !== "attr") return null;
+  const xmlName = candidate.xmlName || candidate.name;
+  if (!xmlName) return null;
+  return {
+    xmlName,
+    attributes: { ...candidate.attributes || {} }
+  };
+};
+const XML_NODE_NAME$g = "w:rPr";
+const SD_ATTR_KEY$5 = "runProperties";
+const encode$q = (params2) => {
+  const { nodes } = params2;
+  const node = nodes?.[0] || {};
+  const contents = Array.isArray(node.elements) ? node.elements : [];
+  const runPropsArray = contents.reduce(
+    (acc, child) => {
+      if (!child || typeof child !== "object") return acc;
+      const xmlName = child.name;
+      if (!KNOWN_CHILD_XML_NAMES.has(xmlName)) return acc;
+      const translator2 = runPropertyTranslators[xmlName];
+      let entry = null;
+      if (translator2) {
+        const encoded = translator2.encode({ ...params2, nodes: [child] }) || null;
+        entry = toRunPropertyEntry(encoded);
+      } else if (RAW_CHILD_NAME_SET.has(xmlName)) {
+        entry = toRunPropertyEntry({
+          type: "attr",
+          xmlName,
+          attributes: { ...child.attributes || {} }
+        });
+      }
+      if (entry) acc.push(entry);
+      return acc;
+    },
+    /** @type {{ xmlName: string, attributes: Record<string, any> }[]} */
+    []
+  );
+  return {
+    type: "attr",
+    xmlName: "w:rPr",
+    sdNodeOrKeyName: "runProperties",
+    attributes: runPropsArray
+  };
+};
+const config$e = {
+  xmlName: XML_NODE_NAME$g,
+  sdNodeOrKeyName: SD_ATTR_KEY$5,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$q
+};
+const translator$U = NodeTranslator.from(config$e);
+const EAST_ASIAN_CHARACTER_REGEX = /[\u1100-\u11FF\u2E80-\u2EFF\u2F00-\u2FDF\u3040-\u30FF\u3100-\u312F\u3130-\u318F\u31A0-\u31BF\u3400-\u4DBF\u4E00-\u9FFF\uA960-\uA97F\uAC00-\uD7AF\uF900-\uFAFF\uFF00-\uFFEF]/u;
+const containsEastAsianCharacters = (text) => EAST_ASIAN_CHARACTER_REGEX.test(text);
+const collectRunProperties = (params2, rPrNode, translator2 = translator$U) => {
+  if (!rPrNode) return { entries: [], hadRPr: false, styleChangeMarks: [] };
+  const result = translator2.encode({ ...params2, nodes: [rPrNode] }) || {};
+  let entries = [];
+  if (Array.isArray(result.attributes) && result.attributes.length) {
+    entries = result.attributes.map((attr) => ({
+      xmlName: attr?.xmlName,
+      attributes: { ...attr?.attributes || {} }
+    }));
+  } else if (Array.isArray(rPrNode.elements) && rPrNode.elements.length) {
+    entries = rPrNode.elements.filter((el) => el && typeof el === "object").map((el) => ({
+      xmlName: el.name,
+      attributes: { ...el.attributes || {} }
+    }));
+  }
+  const legacyMarks = parseMarks(rPrNode, [], params2?.docx) || [];
+  const styleChangeMarks = handleStyleChangeMarks(rPrNode, legacyMarks) || [];
+  return { entries, hadRPr: true, styleChangeMarks };
+};
+const buildRunAttrs = (encodedAttrs = {}, hadRPr, runProps) => {
+  const base2 = { ...encodedAttrs || {} };
+  if (hadRPr) {
+    base2.runProperties = runProps.length ? runProps : null;
+  }
+  return base2;
+};
+const ensureInlineMarks = (marks, inlineMarks = []) => {
+  inlineMarks.forEach(({ type: type2, attrs }) => {
+    if (!type2) return;
+    if (marks.some((mark) => mark?.type === type2)) return;
+    marks.push(attrs ? { type: type2, attrs: { ...attrs } } : { type: type2 });
+  });
+};
+const ensureTextStyleMark = (marks, textStyleAttrs) => {
+  if (!textStyleAttrs) return;
+  const existingTextStyle = marks.find((mark) => mark?.type === "textStyle");
+  if (existingTextStyle) {
+    existingTextStyle.attrs = { ...existingTextStyle.attrs || {}, ...textStyleAttrs };
+    return;
+  }
+  marks.push({ type: "textStyle", attrs: { ...textStyleAttrs } });
+};
+const normalizeTextStyleAttrsForNode = (textStyleAttrs, node) => {
+  if (!textStyleAttrs || typeof textStyleAttrs !== "object") return null;
+  const normalized = { ...textStyleAttrs };
+  const eastAsiaFont = normalized.eastAsiaFontFamily;
+  if (eastAsiaFont) {
+    delete normalized.eastAsiaFontFamily;
+    const text = typeof node?.text === "string" ? node.text : null;
+    const shouldUseEastAsia = typeof text === "string" && containsEastAsianCharacters(text);
+    if (shouldUseEastAsia) {
+      normalized.fontFamily = eastAsiaFont;
+    }
+  }
+  return Object.keys(normalized).length ? normalized : null;
+};
+const applyRunMarks = (node, inlineMarks, textStyleAttrs) => {
+  if (!node || typeof node !== "object") return node;
+  const baseMarks = Array.isArray(node.marks) ? node.marks : [];
+  const marks = baseMarks.map((mark) => cloneMark$1(mark));
+  ensureInlineMarks(marks, inlineMarks);
+  if (node.type === "text") {
+    const normalizedTextStyle = normalizeTextStyleAttrsForNode(textStyleAttrs, node);
+    ensureTextStyleMark(marks, normalizedTextStyle);
+  }
+  return { ...node, marks };
+};
+const deriveStyleMarks = ({ docx, paragraphStyleId, runStyleId }) => {
+  const paragraphStyleMarks = collectStyleMarks(paragraphStyleId, docx);
+  const runStyleMarks = collectStyleMarks(runStyleId, docx);
+  const inlineMarks = mergeInlineMarkSets(paragraphStyleMarks.inlineMarks, runStyleMarks.inlineMarks);
+  const textStyleAttrs = mergeTextStyleAttrs(paragraphStyleMarks.textStyleAttrs, runStyleMarks.textStyleAttrs);
+  return { inlineMarks, textStyleAttrs };
+};
+const collectStyleMarks = (styleId, docx, seen = /* @__PURE__ */ new Set()) => {
+  if (!styleId || !docx || seen.has(styleId)) return { inlineMarks: [], textStyleAttrs: null };
+  seen.add(styleId);
+  const chain = collectStyleChain(styleId, docx, seen);
+  if (!chain.length) return { inlineMarks: [], textStyleAttrs: null };
+  const inlineMap = /* @__PURE__ */ new Map();
+  let textStyleAttrs = {};
+  chain.forEach((styleTag) => {
+    const marks = extractMarksFromStyle(styleTag, docx);
+    marks.inlineMarks.forEach((mark) => {
+      inlineMap.set(mark.type, mark.attrs ? { type: mark.type, attrs: { ...mark.attrs } } : { type: mark.type });
+    });
+    if (marks.textStyleAttrs) textStyleAttrs = { ...textStyleAttrs, ...marks.textStyleAttrs };
+  });
+  return {
+    inlineMarks: Array.from(inlineMap.values()),
+    textStyleAttrs: Object.keys(textStyleAttrs).length ? textStyleAttrs : null
+  };
+};
+const collectStyleChain = (styleId, docx, seen) => {
+  if (!styleId || !docx) return [];
+  const styleTag = findStyleTag(docx, styleId);
+  if (!styleTag || !styleTag.elements) return [];
+  const basedOn = styleTag.elements?.find((el) => el.name === "w:basedOn")?.attributes?.["w:val"];
+  let chain = [];
+  if (basedOn && !seen.has(basedOn)) {
+    seen.add(basedOn);
+    chain = collectStyleChain(basedOn, docx, seen);
+  }
+  chain.push(styleTag);
+  return chain;
+};
+const findStyleTag = (docx, styleId) => {
+  const stylesFile = docx?.["word/styles.xml"];
+  if (!stylesFile?.elements?.length) return null;
+  const candidates = [];
+  stylesFile.elements.forEach((el) => {
+    if (!el) return;
+    if (el.name === "w:styles" && Array.isArray(el.elements)) {
+      el.elements.forEach((child) => {
+        if (child?.name === "w:style") candidates.push(child);
+      });
+      return;
+    }
+    if (el.name === "w:style") {
+      candidates.push(el);
+      return;
+    }
+    if (Array.isArray(el.elements)) {
+      el.elements.forEach((child) => {
+        if (child?.name === "w:style") candidates.push(child);
+      });
+    }
+  });
+  return candidates.find((tag) => tag?.attributes?.["w:styleId"] === styleId) || null;
+};
+const extractMarksFromStyle = (styleTag, docx) => {
+  const rPr = styleTag?.elements?.find((el) => el.name === "w:rPr");
+  if (!rPr) return { inlineMarks: [], textStyleAttrs: null };
+  const marks = parseMarks(rPr, [], docx) || [];
+  const inlineMarks = [];
+  let textStyleAttrs = {};
+  marks.forEach((mark) => {
+    if (!mark) return;
+    if (mark.type === "textStyle") {
+      const attrs = mark.attrs || {};
+      if (Object.keys(attrs).length) textStyleAttrs = { ...textStyleAttrs, ...attrs };
+      return;
+    }
+    if (mark.type) inlineMarks.push(mark.attrs ? { type: mark.type, attrs: { ...mark.attrs } } : { type: mark.type });
+  });
+  return {
+    inlineMarks,
+    textStyleAttrs: Object.keys(textStyleAttrs).length ? textStyleAttrs : null
+  };
+};
+const mergeInlineMarkSets = (...markSets) => {
+  const map3 = /* @__PURE__ */ new Map();
+  markSets.filter(Boolean).forEach((marks) => {
+    marks.forEach((mark) => {
+      if (!mark || !mark.type) return;
+      map3.set(mark.type, mark.attrs ? { type: mark.type, attrs: { ...mark.attrs } } : { type: mark.type });
+    });
+  });
+  return Array.from(map3.values());
+};
+const mergeTextStyleAttrs = (...attrsList) => {
+  const merged = attrsList.filter((attrs) => attrs && Object.keys(attrs).length).reduce((acc, attrs) => ({ ...acc, ...attrs }), {});
+  return Object.keys(merged).length ? merged : null;
+};
+const cloneRunAttrs = (attrs) => {
+  const clone = { ...attrs };
+  if (Array.isArray(attrs?.runProperties)) {
+    clone.runProperties = attrs.runProperties.map((entry) => ({
+      xmlName: entry?.xmlName,
+      attributes: { ...entry?.attributes || {} }
+    }));
+  }
+  return clone;
+};
+const cloneMark$1 = (mark) => {
+  if (!mark || typeof mark !== "object") return mark;
+  const cloned = { ...mark };
+  if (mark.attrs && typeof mark.attrs === "object") {
+    cloned.attrs = { ...mark.attrs };
+    if (Array.isArray(mark.attrs.runProperties)) {
+      cloned.attrs.runProperties = mark.attrs.runProperties.map((entry) => ({
+        xmlName: entry?.xmlName,
+        attributes: { ...entry?.attributes || {} }
+      }));
+    }
+  }
+  return cloned;
+};
+const normalizeBool = (value) => {
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === "0" || normalized === "false" || normalized === "off") return false;
+  if (normalized === "1" || normalized === "true" || normalized === "on") return true;
+  return true;
+};
+const createRunPropertiesElement = (entries = []) => {
+  if (!Array.isArray(entries) || !entries.length) return null;
+  const elements = entries.map((entry) => {
+    if (!entry || !entry.xmlName) return null;
+    return {
+      name: entry.xmlName,
+      attributes: { ...entry.attributes || {} }
+    };
+  }).filter(Boolean);
+  if (!elements.length) return null;
+  return {
+    name: "w:rPr",
+    elements
+  };
+};
+const cloneXmlNode = (nodeLike) => {
+  if (!nodeLike || typeof nodeLike !== "object") return nodeLike;
+  return {
+    name: nodeLike.name,
+    type: nodeLike.type,
+    attributes: nodeLike.attributes ? { ...nodeLike.attributes } : void 0,
+    elements: Array.isArray(nodeLike.elements) ? nodeLike.elements.map((el) => cloneXmlNode(el)) : void 0,
+    text: nodeLike.text
+  };
+};
+const applyRunPropertiesTemplate = (runNode, runPropertiesTemplate) => {
+  if (!runNode || !runPropertiesTemplate) return;
+  if (!Array.isArray(runNode.elements)) runNode.elements = [];
+  let runProps = runNode.elements.find((el) => el?.name === "w:rPr");
+  if (!runProps) {
+    runProps = { name: "w:rPr", elements: [] };
+    runNode.elements.unshift(runProps);
+  }
+  if (!Array.isArray(runProps.elements)) runProps.elements = [];
+  if (runPropertiesTemplate.attributes) {
+    runProps.attributes = {
+      ...runProps.attributes || {},
+      ...runPropertiesTemplate.attributes
+    };
+  }
+  const isValidRunPropName = (name) => typeof name === "string" && name.includes(":");
+  runProps.elements = runProps.elements.filter((entry) => isValidRunPropName(entry?.name));
+  const existingNames = new Set(runProps.elements.map((el) => el?.name));
+  (runPropertiesTemplate.elements || []).forEach((entry) => {
+    if (!isValidRunPropName(entry?.name) || existingNames.has(entry.name)) return;
+    runProps.elements.push(cloneXmlNode(entry));
+    existingNames.add(entry.name);
+  });
+};
+const splitRunProperties = (entries = [], docx = null) => {
+  const remainingProps = [];
+  const inlineMarks = [];
+  const textStyleAttrs = {};
+  let hasTextStyle = false;
+  let highlightColor = null;
+  let runStyleId = null;
+  entries.forEach((entry) => {
+    if (!entry || !entry.xmlName) return;
+    const attributes = entry.attributes || {};
+    switch (entry.xmlName) {
+      case "w:b": {
+        const val = normalizeBool(attributes["w:val"]);
+        inlineMarks.push(val ? { type: "bold" } : { type: "bold", attrs: { value: "0" } });
+        break;
+      }
+      case "w:i": {
+        const val = normalizeBool(attributes["w:val"]);
+        inlineMarks.push(val ? { type: "italic" } : { type: "italic", attrs: { value: "0" } });
+        break;
+      }
+      case "w:u": {
+        const rawVal = attributes["w:val"];
+        const underlineType = rawVal == null || rawVal === "" ? "single" : String(rawVal);
+        const attrs = {};
+        if (underlineType.toLowerCase() === "none" || underlineType === "0") {
+          attrs.underlineType = "none";
+        } else {
+          attrs.underlineType = underlineType;
+          const colorRaw = attributes["w:color"];
+          if (typeof colorRaw === "string" && colorRaw.toLowerCase() !== "auto") {
+            const normalizedColor = normalizeHexColor(colorRaw);
+            if (normalizedColor) attrs.underlineColor = `#${normalizedColor}`;
+          }
+        }
+        if (attributes["w:themeColor"]) attrs.underlineThemeColor = attributes["w:themeColor"];
+        if (attributes["w:themeTint"]) attrs.underlineThemeTint = attributes["w:themeTint"];
+        if (attributes["w:themeShade"]) attrs.underlineThemeShade = attributes["w:themeShade"];
+        inlineMarks.push({ type: "underline", attrs });
+        break;
+      }
+      case "w:color": {
+        const raw = attributes["w:val"];
+        if (typeof raw === "string" && raw) {
+          hasTextStyle = true;
+          textStyleAttrs.color = `#${raw.replace("#", "").toUpperCase()}`;
+        }
+        break;
+      }
+      case "w:rFonts": {
+        const asciiFamily = attributes["w:ascii"] || attributes["w:hAnsi"] || (attributes["w:eastAsia"] ? void 0 : attributes["w:val"]);
+        const eastAsiaFamily = attributes["w:eastAsia"];
+        if (asciiFamily) {
+          hasTextStyle = true;
+          textStyleAttrs.fontFamily = SuperConverter.toCssFontFamily(asciiFamily, docx);
+        }
+        if (eastAsiaFamily) {
+          hasTextStyle = true;
+          const eastAsiaCss = SuperConverter.toCssFontFamily(eastAsiaFamily, docx);
+          if (!asciiFamily || eastAsiaCss !== textStyleAttrs.fontFamily) {
+            textStyleAttrs.eastAsiaFontFamily = eastAsiaCss;
+          }
+        }
+        break;
+      }
+      case "w:sz":
+      case "w:szCs": {
+        const rawSize = Number(attributes["w:val"]);
+        if (Number.isFinite(rawSize) && rawSize > 0) {
+          hasTextStyle = true;
+          textStyleAttrs.fontSize = `${rawSize / 2}pt`;
+        }
+        break;
+      }
+      case "w:strike": {
+        const val = normalizeBool(attributes["w:val"]);
+        inlineMarks.push(val ? { type: "strike" } : { type: "strike", attrs: { value: "0" } });
+        break;
+      }
+      case "w:highlight": {
+        const color = attributes["w:val"];
+        if (typeof color === "string" && color) {
+          highlightColor = color.toLowerCase() === "none" ? "transparent" : color;
+        }
+        break;
+      }
+      case "w:shd": {
+        const fill = attributes["w:fill"];
+        const shdVal = attributes["w:val"];
+        if (fill && String(fill).toLowerCase() !== "auto") {
+          highlightColor = `#${String(fill).replace("#", "")}`;
+        } else if (typeof shdVal === "string") {
+          const normalized = shdVal.toLowerCase();
+          if (normalized === "clear" || normalized === "nil" || normalized === "none") {
+            highlightColor = "transparent";
+          }
+        }
+        break;
+      }
+      case "w:rStyle": {
+        if (typeof attributes["w:val"] === "string") runStyleId = attributes["w:val"];
+        remainingProps.push({ xmlName: entry.xmlName, attributes: { ...attributes } });
+        break;
+      }
+      default: {
+        remainingProps.push({ xmlName: entry.xmlName, attributes: { ...attributes } });
+      }
+    }
+  });
+  if (highlightColor) inlineMarks.push({ type: "highlight", attrs: { color: highlightColor } });
+  return {
+    remainingProps,
+    inlineMarks,
+    textStyleAttrs: hasTextStyle ? textStyleAttrs : null,
+    runStyleId
+  };
+};
+const cloneMark = (mark) => {
+  if (!mark) return mark;
+  return {
+    ...mark,
+    attrs: mark.attrs ? { ...mark.attrs } : void 0
+  };
+};
+const cloneNode = (node) => {
+  if (!node || typeof node !== "object") return node;
+  const cloned = { ...node };
+  if (node.marks) cloned.marks = node.marks.map((mark) => cloneMark(mark));
+  if (node.content) cloned.content = node.content.map((child) => cloneNode(child));
+  if (node.elements) cloned.elements = node.elements.map((el) => cloneNode(el));
+  if (node.attributes) cloned.attributes = { ...node.attributes };
+  return cloned;
+};
+const cloneRuns = (runs = []) => runs.map((run2) => cloneNode(run2));
+const prepareRunTrackingContext = (node = {}) => {
+  const marks = Array.isArray(node.marks) ? node.marks : [];
+  const trackingMarks = marks.filter(
+    (mark) => mark?.type === TrackInsertMarkName || mark?.type === TrackDeleteMarkName
+  );
+  if (!trackingMarks.length) {
+    return { runNode: node, trackingMarksByType: /* @__PURE__ */ new Map() };
+  }
+  const trackingMarksByType = /* @__PURE__ */ new Map();
+  trackingMarks.forEach((mark) => {
+    if (mark?.type) trackingMarksByType.set(mark.type, cloneMark(mark));
+  });
+  const preservedMarks = marks.filter((mark) => mark?.type !== TrackInsertMarkName && mark?.type !== TrackDeleteMarkName).map((mark) => cloneMark(mark));
+  const clonedContent = Array.isArray(node.content) ? node.content.map((child) => {
+    const childClone = cloneNode(child);
+    const childMarks = Array.isArray(childClone.marks) ? childClone.marks.slice() : [];
+    trackingMarks.forEach((mark) => {
+      childMarks.push(cloneMark(mark));
+    });
+    childClone.marks = childMarks;
+    return childClone;
+  }) : [];
+  return {
+    runNode: {
+      ...cloneNode(node),
+      marks: preservedMarks,
+      content: clonedContent
+    },
+    trackingMarksByType
+  };
+};
+const mapTrackingAttrs = (mark, attrMap) => {
+  const source = mark?.attrs || {};
+  const mapped = {};
+  attrMap.forEach((targetKey, sourceKey) => {
+    if (source[sourceKey] != null) mapped[targetKey] = source[sourceKey];
+  });
+  return mapped;
+};
+const renameTextElementsForDeletion = (node) => {
+  if (!node || typeof node !== "object") return;
+  if (node.name === "w:t") node.name = "w:delText";
+  if (Array.isArray(node.elements)) node.elements.forEach(renameTextElementsForDeletion);
+};
+const ensureTrackedWrapper = (runs, trackingMarksByType = /* @__PURE__ */ new Map()) => {
+  if (!Array.isArray(runs) || !runs.length) return runs;
+  const firstRun = runs[0];
+  if (firstRun?.name === "w:ins" || firstRun?.name === "w:del") {
+    return runs;
+  }
+  if (!trackingMarksByType.size) return runs;
+  if (trackingMarksByType.has(TrackInsertMarkName)) {
+    const mark = trackingMarksByType.get(TrackInsertMarkName);
+    const clonedRuns = cloneRuns(runs);
+    const wrapper = {
+      name: "w:ins",
+      attributes: mapTrackingAttrs(
+        mark,
+        /* @__PURE__ */ new Map([
+          ["id", "w:id"],
+          ["author", "w:author"],
+          ["authorEmail", "w:authorEmail"],
+          ["date", "w:date"]
+        ])
+      ),
+      elements: clonedRuns
+    };
+    return [wrapper];
+  }
+  if (trackingMarksByType.has(TrackDeleteMarkName)) {
+    const mark = trackingMarksByType.get(TrackDeleteMarkName);
+    const clonedRuns = cloneRuns(runs);
+    clonedRuns.forEach(renameTextElementsForDeletion);
+    const wrapper = {
+      name: "w:del",
+      attributes: mapTrackingAttrs(mark, /* @__PURE__ */ new Map([["id", "w:id"]])),
+      elements: clonedRuns
+    };
+    return [wrapper];
+  }
+  return runs;
+};
+const encode$p = (attributes) => {
+  return attributes["w:rsidR"];
+};
+const decode$p = (attrs) => {
+  return attrs.rsidR;
+};
+const attrConfig$9 = Object.freeze({
+  xmlName: "w:rsidR",
+  sdName: "rsidR",
+  encode: encode$p,
+  decode: decode$p
+});
+const encode$o = (attributes) => {
+  return attributes["w:rsidRPr"];
+};
+const decode$o = (attrs) => {
+  return attrs.rsidRPr;
+};
+const attrConfig$8 = Object.freeze({
+  xmlName: "w:rsidRPr",
+  sdName: "rsidRPr",
+  encode: encode$o,
+  decode: decode$o
+});
+const encode$n = (attributes) => {
+  return attributes["w:rsidDel"];
+};
+const decode$n = (attrs) => {
+  return attrs.rsidDel;
+};
+const attrConfig$7 = Object.freeze({
+  xmlName: "w:rsidDel",
+  sdName: "rsidDel",
+  encode: encode$n,
+  decode: decode$n
+});
+const validXmlAttributes$9 = [attrConfig$9, attrConfig$8, attrConfig$7];
+const XML_NODE_NAME$f = "w:r";
+const SD_KEY_NAME = "run";
+const encode$m = (params2, encodedAttrs = {}) => {
+  const { nodes = [], nodeListHandler } = params2 || {};
+  const runNode = nodes[0];
+  if (!runNode) return void 0;
+  const elements = Array.isArray(runNode.elements) ? runNode.elements : [];
+  const rPrNode = elements.find((child) => child?.name === "w:rPr");
+  const contentElements = rPrNode ? elements.filter((el) => el !== rPrNode) : elements;
+  const { entries: runPropEntries, hadRPr, styleChangeMarks } = collectRunProperties(params2, rPrNode);
+  const { remainingProps, inlineMarks, textStyleAttrs, runStyleId } = splitRunProperties(runPropEntries, params2?.docx);
+  const styleMarks = deriveStyleMarks({
+    docx: params2?.docx,
+    paragraphStyleId: params2?.parentStyleId,
+    runStyleId
+  });
+  const mergedInlineMarks = mergeInlineMarkSets(styleMarks.inlineMarks, inlineMarks);
+  let mergedTextStyleAttrs = mergeTextStyleAttrs(styleMarks.textStyleAttrs, textStyleAttrs);
+  if (runStyleId) {
+    mergedTextStyleAttrs = mergedTextStyleAttrs ? { ...mergedTextStyleAttrs, styleId: runStyleId } : { styleId: runStyleId };
+  }
+  const runAttrs = buildRunAttrs(encodedAttrs, hadRPr, remainingProps);
+  let runLevelMarks = Array.isArray(runNode.marks) ? runNode.marks.map((mark) => cloneMark$1(mark)) : [];
+  if (styleChangeMarks?.length) {
+    runLevelMarks = [...runLevelMarks, ...styleChangeMarks.map((mark) => cloneMark$1(mark))];
+  }
+  const childParams = { ...params2, nodes: contentElements };
+  const content = nodeListHandler?.handler(childParams) || [];
+  const contentWithRunMarks = content.map((child) => {
+    if (!child || typeof child !== "object") return child;
+    const baseMarks = Array.isArray(child.marks) ? child.marks.map((mark) => cloneMark$1(mark)) : [];
+    if (!runLevelMarks.length) return child;
+    return { ...child, marks: [...baseMarks, ...runLevelMarks.map((mark) => cloneMark$1(mark))] };
+  });
+  const marked = contentWithRunMarks.map((child) => applyRunMarks(child, mergedInlineMarks, mergedTextStyleAttrs));
+  const filtered = marked.filter(Boolean);
+  const runNodeResult = {
+    type: SD_KEY_NAME,
+    content: filtered
+  };
+  const attrs = cloneRunAttrs(runAttrs);
+  if (attrs && Object.keys(attrs).length) {
+    if (attrs.runProperties == null) delete attrs.runProperties;
+    if (Object.keys(attrs).length) runNodeResult.attrs = attrs;
+  }
+  if (runLevelMarks.length) {
+    runNodeResult.marks = runLevelMarks.map((mark) => cloneMark$1(mark));
+  }
+  return runNodeResult;
+};
+const decode$m = (params2, decodedAttrs = {}) => {
+  const { node } = params2 || {};
+  if (!node) return void 0;
+  const { runNode: runNodeForExport, trackingMarksByType } = prepareRunTrackingContext(node);
+  const runAttrs = runNodeForExport.attrs || {};
+  const runProperties = Array.isArray(runAttrs.runProperties) ? runAttrs.runProperties : [];
+  const exportParams = { ...params2, node: runNodeForExport };
+  if (!exportParams.editor) {
+    exportParams.editor = { extensionService: { extensions: [] } };
+  }
+  const childElements = translateChildNodes(exportParams) || [];
+  let runPropertiesElement = createRunPropertiesElement(runProperties);
+  const markElements = processOutputMarks(Array.isArray(runNodeForExport.marks) ? runNodeForExport.marks : []);
+  if (markElements.length) {
+    if (!runPropertiesElement) {
+      runPropertiesElement = generateRunProps(markElements);
+    } else {
+      if (!Array.isArray(runPropertiesElement.elements)) runPropertiesElement.elements = [];
+      const existingNames = new Set(
+        runPropertiesElement.elements.map((el) => el?.name).filter((name) => typeof name === "string")
+      );
+      markElements.forEach((element) => {
+        if (!element || !element.name || existingNames.has(element.name)) return;
+        runPropertiesElement.elements.push({ ...element, attributes: { ...element.attributes || {} } });
+        existingNames.add(element.name);
+      });
+    }
+  }
+  const runPropsTemplate = runPropertiesElement ? cloneXmlNode(runPropertiesElement) : null;
+  const applyBaseRunProps = (runNode) => applyRunPropertiesTemplate(runNode, runPropsTemplate);
+  const runs = [];
+  childElements.forEach((child) => {
+    if (!child) return;
+    if (child.name === "w:r") {
+      const clonedRun = cloneXmlNode(child);
+      applyBaseRunProps(clonedRun);
+      runs.push(clonedRun);
+      return;
+    }
+    if (child.name === "w:hyperlink") {
+      const hyperlinkClone = cloneXmlNode(child);
+      if (Array.isArray(hyperlinkClone.elements)) {
+        hyperlinkClone.elements.forEach((run2) => applyBaseRunProps(run2));
+      }
+      runs.push(hyperlinkClone);
+      return;
+    }
+    if (child.name === "w:ins" || child.name === "w:del") {
+      const trackedClone = cloneXmlNode(child);
+      if (Array.isArray(trackedClone.elements)) {
+        trackedClone.elements.forEach((element) => {
+          if (element?.name === "w:r") applyBaseRunProps(element);
+        });
+      }
+      runs.push(trackedClone);
+      return;
+    }
+    const runWrapper = { name: XML_NODE_NAME$f, elements: [] };
+    applyBaseRunProps(runWrapper);
+    if (!Array.isArray(runWrapper.elements)) runWrapper.elements = [];
+    runWrapper.elements.push(cloneXmlNode(child));
+    runs.push(runWrapper);
+  });
+  const trackedRuns = ensureTrackedWrapper(runs, trackingMarksByType);
+  if (!trackedRuns.length) {
+    const emptyRun = { name: XML_NODE_NAME$f, elements: [] };
+    applyBaseRunProps(emptyRun);
+    trackedRuns.push(emptyRun);
+  }
+  if (decodedAttrs && Object.keys(decodedAttrs).length) {
+    trackedRuns.forEach((run2) => {
+      run2.attributes = { ...run2.attributes || {}, ...decodedAttrs };
+    });
+  }
+  if (trackedRuns.length === 1) {
+    return trackedRuns[0];
+  }
+  return trackedRuns;
+};
 const config$d = {
   xmlName: XML_NODE_NAME$f,
-  sdNodeOrKeyName: SD_NODE_NAME$a,
+  sdNodeOrKeyName: SD_KEY_NAME,
   type: NodeTranslator.translatorTypes.NODE,
   encode: encode$m,
   decode: decode$m,
@@ -26513,17 +27776,52 @@ const encode$d = (params2, encodedAttrs) => {
   const { nodes, docx, nodeListHandler } = params2;
   const node = nodes[0];
   let href = _resolveHref(docx, encodedAttrs);
-  const linkMark = { type: "link", attrs: { ...encodedAttrs, href } };
+  const linkMark = { attrs: { ...encodedAttrs, href } };
   const runNodes = node.elements.filter((el) => el.name === "w:r");
   runNodes.forEach((runNode) => {
-    runNode.marks = [...runNode.marks || [], linkMark];
+    const existingRunMarks = Array.isArray(runNode.marks) ? runNode.marks : [];
+    const runMarksWithoutLink = existingRunMarks.filter((mark) => mark?.type !== "link");
+    runNode.marks = runMarksWithoutLink;
   });
   const updatedNode = nodeListHandler.handler({
     ...params2,
     nodes: runNodes,
     path: [...params2.path || [], node]
   });
-  return updatedNode;
+  const cloneMark2 = (mark) => {
+    if (!mark || typeof mark !== "object") return mark;
+    if (!mark.attrs) return { ...mark };
+    return { ...mark, attrs: { ...mark.attrs } };
+  };
+  const ensureLinkMark = (child) => {
+    if (!child || typeof child !== "object") return child;
+    if (Array.isArray(child.content)) {
+      const updatedContent = child.content.map((item) => ensureLinkMark(item));
+      if (updatedContent !== child.content) {
+        child = { ...child, content: updatedContent };
+      }
+    }
+    if (child.type === "run") {
+      const existingMarks2 = Array.isArray(child.marks) ? child.marks : [];
+      const filteredMarks = existingMarks2.filter((mark) => mark?.type !== "link").map((mark) => cloneMark2(mark));
+      if (filteredMarks.length !== existingMarks2.length) {
+        if (filteredMarks.length) child = { ...child, marks: filteredMarks };
+        else {
+          const { marks, ...rest } = child;
+          child = rest;
+        }
+      }
+      return child;
+    }
+    if (child.type !== "text") return child;
+    const existingMarks = Array.isArray(child.marks) ? child.marks.map((mark) => cloneMark2(mark)) : [];
+    const hasLink = existingMarks.some((mark) => mark?.type === "link");
+    if (hasLink) return child;
+    const linkClone = { type: "link", attrs: { ...linkMark.attrs } };
+    return { ...child, marks: [...existingMarks, linkClone] };
+  };
+  if (!Array.isArray(updatedNode)) return updatedNode;
+  return updatedNode.map((child) => ensureLinkMark(child));
 };
 const _resolveHref = (docx, encodedAttrs) => {
   const rels = docx["word/_rels/document.xml.rels"];
@@ -27454,176 +28752,30 @@ const config$4 = {
   attributes: validXmlAttributes$4
 };
 const translator$4 = NodeTranslator.from(config$4);
-const encode$a = (attributes) => {
-  return attributes["w:id"];
-};
-const decode$a = (attrs) => {
-  return attrs.id;
-};
-const attrConfig$6 = Object.freeze({
-  xmlName: "w:id",
-  sdName: "id",
-  encode: encode$a,
-  decode: decode$a
-});
-const encode$9 = (attributes) => {
-  return attributes["w:name"];
-};
-const decode$9 = (attrs) => {
-  return attrs.name;
-};
-const attrConfig$5 = Object.freeze({
-  xmlName: "w:name",
-  sdName: "name",
-  encode: encode$9,
-  decode: decode$9
-});
-const encode$8 = (attributes) => {
-  return attributes["w:colFirst"];
-};
-const decode$8 = (attrs) => {
-  return attrs.colFirst;
-};
-const attrConfig$4 = Object.freeze({
-  xmlName: "w:colFirst",
-  sdName: "colFirst",
-  encode: encode$8,
-  decode: decode$8
-});
-const encode$7 = (attributes) => {
-  return attributes["w:colLast"];
-};
-const decode$7 = (attrs) => {
-  return attrs.colLast;
-};
-const attrConfig$3 = Object.freeze({
-  xmlName: "w:colLast",
-  sdName: "colLast",
-  encode: encode$7,
-  decode: decode$7
-});
-const encode$6 = (attributes) => {
-  return attributes["w:displacedByCustomXml"];
-};
-const decode$6 = (attrs) => {
-  return attrs.displacedByCustomXml;
-};
-const attrConfig$2 = Object.freeze({
-  xmlName: "w:displacedByCustomXml",
-  sdName: "displacedByCustomXml",
-  encode: encode$6,
-  decode: decode$6
-});
-const validXmlAttributes$3 = [attrConfig$6, attrConfig$5, attrConfig$4, attrConfig$3, attrConfig$2];
-const XML_NODE_NAME$3 = "w:bookmarkStart";
-const SD_NODE_NAME$3 = "bookmarkStart";
-const encode$5 = (params2, encodedAttrs = {}) => {
-  return {
-    type: "bookmarkStart",
-    attrs: encodedAttrs
-  };
-};
-const decode$5 = (params2, decodedAttrs = {}) => {
-  const result = {
-    name: "w:bookmarkStart",
-    elements: []
-  };
-  if (decodedAttrs && Object.keys(decodedAttrs).length) {
-    result.attributes = decodedAttrs;
-  }
-  return result;
-};
-const config$3 = {
-  xmlName: XML_NODE_NAME$3,
-  sdNodeOrKeyName: SD_NODE_NAME$3,
-  type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$5,
-  decode: decode$5,
-  attributes: validXmlAttributes$3
-};
-const translator$3 = NodeTranslator.from(config$3);
-const encode$4 = (attributes) => {
-  return attributes["w:id"];
-};
-const decode$4 = (attrs) => {
-  return attrs.id;
-};
-const attrConfig$1 = Object.freeze({
-  xmlName: "w:id",
-  sdName: "id",
-  encode: encode$4,
-  decode: decode$4
-});
-const encode$3 = (attributes) => {
-  return attributes["w:displacedByCustomXml"];
-};
-const decode$3 = (attrs) => {
-  return attrs.displacedByCustomXml;
-};
-const attrConfig = Object.freeze({
-  xmlName: "w:displacedByCustomXml",
-  sdName: "displacedByCustomXml",
-  encode: encode$3,
-  decode: decode$3
-});
-const validXmlAttributes$2 = [attrConfig$1, attrConfig];
-const XML_NODE_NAME$2 = "w:bookmarkEnd";
-const SD_NODE_NAME$2 = "bookmarkEnd";
-const encode$2 = (params2, encodedAttrs = {}) => {
-  return {
-    type: "bookmarkEnd",
-    attrs: encodedAttrs
-  };
-};
-const decode$2 = (params2, decodedAttrs = {}) => {
-  const result = {
-    name: "w:bookmarkEnd",
-    elements: []
-  };
-  if (decodedAttrs && Object.keys(decodedAttrs).length) {
-    result.attributes = decodedAttrs;
-  }
-  return result;
-};
-const config$2 = {
-  xmlName: XML_NODE_NAME$2,
-  sdNodeOrKeyName: SD_NODE_NAME$2,
-  type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$2,
-  decode: decode$2,
-  attributes: validXmlAttributes$2
-};
-const translator$2 = NodeTranslator.from(config$2);
-const registeredHandlers = Object.freeze({
-  "w:br": translator$V,
-  "w:tab": translator$U,
-  "w:p": translator$T,
-  "wp:anchor": translator$5,
-  "wp:inline": translator$4,
-  "w:bookmarkStart": translator$3,
-  "w:bookmarkEnd": translator$2
-});
-const XML_NODE_NAME$1 = "w:drawing";
-const SD_NODE_NAME$1 = [];
-const validXmlAttributes$1 = [];
-function encode$1(params2) {
+const XML_NODE_NAME$3 = "w:drawing";
+const SD_NODE_NAME$3 = [];
+const validXmlAttributes$3 = [];
+function encode$a(params2) {
   const nodes = params2.nodes;
   const node = nodes[0];
-  const validChildTranslators = ["wp:anchor", "wp:inline"];
+  const translatorByChildName = {
+    "wp:anchor": translator$5,
+    "wp:inline": translator$4
+  };
   return node.elements.reduce((acc, child) => {
     if (acc) return acc;
-    if (!validChildTranslators.includes(child.name)) return acc;
-    const translator2 = registeredHandlers[child.name];
+    const translator2 = translatorByChildName[child.name];
+    if (!translator2) return acc;
     return translator2.encode({ ...params2, extraParams: { node: child } }) || acc;
   }, null);
 }
-function decode$1(params2) {
+function decode$a(params2) {
   const { node } = params2;
   if (!node || !node.type) {
     return null;
   }
-  const handlerName = node.attrs.isAnchor ? "wp:anchor" : "wp:inline";
-  const resultNode = registeredHandlers[handlerName].decode(params2);
+  const childTranslator = node.attrs.isAnchor ? translator$5 : translator$4;
+  const resultNode = childTranslator.decode(params2);
   return wrapTextInRun(
     {
       name: "w:drawing",
@@ -27632,15 +28784,15 @@ function decode$1(params2) {
     []
   );
 }
-const config$1 = {
-  xmlName: XML_NODE_NAME$1,
-  sdNodeOrKeyName: SD_NODE_NAME$1,
+const config$3 = {
+  xmlName: XML_NODE_NAME$3,
+  sdNodeOrKeyName: SD_NODE_NAME$3,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$1,
-  decode: decode$1,
-  attributes: validXmlAttributes$1
+  encode: encode$a,
+  decode: decode$a,
+  attributes: validXmlAttributes$3
 };
-const translator$1 = NodeTranslator.from(config$1);
+const translator$3 = NodeTranslator.from(config$3);
 class CommandService {
   /**
    * @param {import('./commands/types/index.js').CommandServiceOptions} props
@@ -28978,7 +30130,7 @@ function prepareTextAnnotation(params2) {
   return getTextNodeForExport(attrs.displayLabel, [...marks, ...marksFromAttrs], params2);
 }
 function prepareImageAnnotation(params2, imageSize) {
-  return translator$1.decode({
+  return translator$3.decode({
     ...params2,
     imageSize
   });
@@ -29215,10 +30367,10 @@ function translateStructuredContent(params2) {
   };
   return result;
 }
-const XML_NODE_NAME = "w:sdt";
-const SD_NODE_NAME = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
-const validXmlAttributes = [];
-function encode$B(params2) {
+const XML_NODE_NAME$2 = "w:sdt";
+const SD_NODE_NAME$2 = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
+const validXmlAttributes$2 = [];
+function encode$9(params2) {
   const nodes = params2.nodes;
   const node = nodes[0];
   const { type: sdtType, handler: handler2 } = sdtNodeTypeStrategy(node);
@@ -29228,7 +30380,7 @@ function encode$B(params2) {
   const result = handler2(params2);
   return result;
 }
-function decode(params2) {
+function decode$9(params2) {
   const { node } = params2;
   if (!node || !node.type) {
     return null;
@@ -29244,44 +30396,193 @@ function decode(params2) {
   const result = decoder();
   return result;
 }
+const config$2 = {
+  xmlName: XML_NODE_NAME$2,
+  sdNodeOrKeyName: SD_NODE_NAME$2,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$9,
+  decode: decode$9,
+  attributes: validXmlAttributes$2
+};
+const translator$2 = NodeTranslator.from(config$2);
+const encode$8 = (attributes) => {
+  return attributes["w:id"];
+};
+const decode$8 = (attrs) => {
+  return attrs.id;
+};
+const attrConfig$6 = Object.freeze({
+  xmlName: "w:id",
+  sdName: "id",
+  encode: encode$8,
+  decode: decode$8
+});
+const encode$7 = (attributes) => {
+  return attributes["w:name"];
+};
+const decode$7 = (attrs) => {
+  return attrs.name;
+};
+const attrConfig$5 = Object.freeze({
+  xmlName: "w:name",
+  sdName: "name",
+  encode: encode$7,
+  decode: decode$7
+});
+const encode$6 = (attributes) => {
+  return attributes["w:colFirst"];
+};
+const decode$6 = (attrs) => {
+  return attrs.colFirst;
+};
+const attrConfig$4 = Object.freeze({
+  xmlName: "w:colFirst",
+  sdName: "colFirst",
+  encode: encode$6,
+  decode: decode$6
+});
+const encode$5 = (attributes) => {
+  return attributes["w:colLast"];
+};
+const decode$5 = (attrs) => {
+  return attrs.colLast;
+};
+const attrConfig$3 = Object.freeze({
+  xmlName: "w:colLast",
+  sdName: "colLast",
+  encode: encode$5,
+  decode: decode$5
+});
+const encode$4 = (attributes) => {
+  return attributes["w:displacedByCustomXml"];
+};
+const decode$4 = (attrs) => {
+  return attrs.displacedByCustomXml;
+};
+const attrConfig$2 = Object.freeze({
+  xmlName: "w:displacedByCustomXml",
+  sdName: "displacedByCustomXml",
+  encode: encode$4,
+  decode: decode$4
+});
+const validXmlAttributes$1 = [attrConfig$6, attrConfig$5, attrConfig$4, attrConfig$3, attrConfig$2];
+const XML_NODE_NAME$1 = "w:bookmarkStart";
+const SD_NODE_NAME$1 = "bookmarkStart";
+const encode$3 = (params2, encodedAttrs = {}) => {
+  return {
+    type: "bookmarkStart",
+    attrs: encodedAttrs
+  };
+};
+const decode$3 = (params2, decodedAttrs = {}) => {
+  const result = {
+    name: "w:bookmarkStart",
+    elements: []
+  };
+  if (decodedAttrs && Object.keys(decodedAttrs).length) {
+    result.attributes = decodedAttrs;
+  }
+  return result;
+};
+const config$1 = {
+  xmlName: XML_NODE_NAME$1,
+  sdNodeOrKeyName: SD_NODE_NAME$1,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$3,
+  decode: decode$3,
+  attributes: validXmlAttributes$1
+};
+const translator$1 = NodeTranslator.from(config$1);
+const encode$2 = (attributes) => {
+  return attributes["w:id"];
+};
+const decode$2 = (attrs) => {
+  return attrs.id;
+};
+const attrConfig$1 = Object.freeze({
+  xmlName: "w:id",
+  sdName: "id",
+  encode: encode$2,
+  decode: decode$2
+});
+const encode$1 = (attributes) => {
+  return attributes["w:displacedByCustomXml"];
+};
+const decode$1 = (attrs) => {
+  return attrs.displacedByCustomXml;
+};
+const attrConfig = Object.freeze({
+  xmlName: "w:displacedByCustomXml",
+  sdName: "displacedByCustomXml",
+  encode: encode$1,
+  decode: decode$1
+});
+const validXmlAttributes = [attrConfig$1, attrConfig];
+const XML_NODE_NAME = "w:bookmarkEnd";
+const SD_NODE_NAME = "bookmarkEnd";
+const encode$18 = (params2, encodedAttrs = {}) => {
+  return {
+    type: "bookmarkEnd",
+    attrs: encodedAttrs
+  };
+};
+const decode = (params2, decodedAttrs = {}) => {
+  const result = {
+    name: "w:bookmarkEnd",
+    elements: []
+  };
+  if (decodedAttrs && Object.keys(decodedAttrs).length) {
+    result.attributes = decodedAttrs;
+  }
+  return result;
+};
 const config = {
   xmlName: XML_NODE_NAME,
   sdNodeOrKeyName: SD_NODE_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$B,
+  encode: encode$18,
   decode,
   attributes: validXmlAttributes
 };
 const translator = NodeTranslator.from(config);
+const isLineBreakOnlyRun = (node) => {
+  if (!node) return false;
+  if (node.type === "lineBreak" || node.type === "hardBreak") return true;
+  if (node.type !== "run") return false;
+  const runContent = Array.isArray(node.content) ? node.content : [];
+  if (!runContent.length) return false;
+  return runContent.every((child) => child?.type === "lineBreak" || child?.type === "hardBreak");
+};
 function exportSchemaToJson(params2) {
   const { type: type2 } = params2.node || {};
   const router = {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$T,
+    paragraph: translator$12,
+    run: translator$T,
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$V,
+    lineBreak: translator$15,
     table: translator$8,
     tableRow: translator$F,
     tableCell: translator$7,
-    bookmarkStart: translator$3,
-    bookmarkEnd: translator$2,
-    fieldAnnotation: translator,
-    tab: translator$U,
-    image: translator$1,
-    hardBreak: translator$V,
+    bookmarkStart: translator$1,
+    bookmarkEnd: translator,
+    fieldAnnotation: translator$2,
+    tab: translator$13,
+    image: translator$3,
+    hardBreak: translator$15,
     commentRangeStart: () => translateCommentNode(params2, "Start"),
     commentRangeEnd: () => translateCommentNode(params2, "End"),
     commentReference: () => null,
     shapeContainer: translateShapeContainer,
     shapeTextbox: translateShapeTextbox,
     contentBlock: translateContentBlock,
-    structuredContent: translator,
-    structuredContentBlock: translator,
-    documentSection: translator,
+    structuredContent: translator$2,
+    structuredContentBlock: translator$2,
+    documentSection: translator$2,
     "page-number": translatePageNumberNode,
     "total-page-number": translateTotalPageNumberNode
   };
@@ -29420,21 +30721,32 @@ function generateParagraphProperties(node) {
     };
     pPrElements.push(spacingElement);
   }
-  if (indent && Object.values(indent).some((v2) => v2 !== 0)) {
-    const { left: left2, right: right2, firstLine, hanging } = indent;
+  const hasIndent = !!indent;
+  if (hasIndent) {
+    const { left: left2, right: right2, firstLine, hanging, explicitLeft, explicitRight, explicitFirstLine, explicitHanging } = indent;
     const attributes = {};
-    if (left2 || left2 === 0) attributes["w:left"] = pixelsToTwips(left2);
-    if (right2 || right2 === 0) attributes["w:right"] = pixelsToTwips(right2);
-    if (firstLine || firstLine === 0) attributes["w:firstLine"] = pixelsToTwips(firstLine);
-    if (hanging || hanging === 0) attributes["w:hanging"] = pixelsToTwips(hanging);
-    if (textIndent && !attributes["w:left"]) {
+    if (left2 !== void 0 && (left2 !== 0 || explicitLeft || textIndent)) {
+      attributes["w:left"] = pixelsToTwips(left2);
+    }
+    if (right2 !== void 0 && (right2 !== 0 || explicitRight)) {
+      attributes["w:right"] = pixelsToTwips(right2);
+    }
+    if (firstLine !== void 0 && (firstLine !== 0 || explicitFirstLine)) {
+      attributes["w:firstLine"] = pixelsToTwips(firstLine);
+    }
+    if (hanging !== void 0 && (hanging !== 0 || explicitHanging)) {
+      attributes["w:hanging"] = pixelsToTwips(hanging);
+    }
+    if (textIndent && attributes["w:left"] === void 0) {
       attributes["w:left"] = getTextIndentExportValue(textIndent);
     }
-    const indentElement = {
-      name: "w:ind",
-      attributes
-    };
-    pPrElements.push(indentElement);
+    if (Object.keys(attributes).length) {
+      const indentElement = {
+        name: "w:ind",
+        attributes
+      };
+      pPrElements.push(indentElement);
+    }
   } else if (textIndent && textIndent !== "0in") {
     const indentElement = {
       name: "w:ind",
@@ -29484,12 +30796,17 @@ function generateParagraphProperties(node) {
   if (sectPr) {
     pPrElements.push(sectPr);
   }
+  const mapTabVal = (value) => {
+    if (!value || value === "start") return "left";
+    if (value === "end") return "right";
+    return value;
+  };
   const { tabStops } = attrs;
   if (tabStops && tabStops.length > 0) {
     const tabElements = tabStops.map((tab) => {
       const posValue = tab.originalPos !== void 0 ? tab.originalPos : pixelsToTwips(tab.pos).toString();
       const tabAttributes = {
-        "w:val": tab.val || "start",
+        "w:val": mapTabVal(tab.val),
         "w:pos": posValue
       };
       if (tab.leader) {
@@ -29844,6 +31161,11 @@ const convertMultipleListItemsIntoSingleNode = (listItem) => {
       collapsedParagraph.content.push(item);
     }
   });
+  collapsedParagraph.content = collapsedParagraph.content.filter((node, index2, nodes) => {
+    if (!isLineBreakOnlyRun(node)) return true;
+    const prevNode = nodes[index2 - 1];
+    return !(prevNode && isLineBreakOnlyRun(prevNode));
+  });
   return collapsedParagraph;
 };
 const restoreIndent = (indent) => {
@@ -29897,13 +31219,27 @@ function translateMark(mark) {
       markElement.type = "element";
       break;
     case "italic":
-      delete markElement.attributes;
-      markElement.type = "element";
-      break;
-    case "underline":
+      if (attrs?.value && attrs.value !== "1" && attrs.value !== true) {
+        markElement.attributes["w:val"] = attrs.value;
+      } else {
+        delete markElement.attributes;
+      }
       markElement.type = "element";
-      markElement.attributes["w:val"] = attrs.underlineType;
       break;
+    case "underline": {
+      const translated = translator$$.decode({
+        node: {
+          attrs: {
+            underlineType: attrs.underlineType ?? attrs.underline ?? null,
+            underlineColor: attrs.underlineColor ?? attrs.color ?? null,
+            underlineThemeColor: attrs.underlineThemeColor ?? attrs.themeColor ?? null,
+            underlineThemeTint: attrs.underlineThemeTint ?? attrs.themeTint ?? null,
+            underlineThemeShade: attrs.underlineThemeShade ?? attrs.themeShade ?? null
+          }
+        }
+      });
+      return translated || {};
+    }
     // Text style cases
     case "fontSize":
       value = attrs.fontSize;
@@ -29921,13 +31257,21 @@ function translateMark(mark) {
       markElement.name = "w:rStyle";
       markElement.attributes["w:val"] = attrs.styleId;
       break;
-    case "color":
-      let processedColor = attrs.color.replace(/^#/, "").replace(/;$/, "");
+    case "color": {
+      const rawColor = attrs.color;
+      if (!rawColor) break;
+      const normalized = String(rawColor).trim().toLowerCase();
+      if (normalized === "inherit") {
+        markElement.attributes["w:val"] = "auto";
+        break;
+      }
+      let processedColor = String(rawColor).replace(/^#/, "").replace(/;$/, "");
       if (processedColor.startsWith("rgb")) {
         processedColor = rgbToHex(processedColor);
       }
       markElement.attributes["w:val"] = processedColor;
       break;
+    }
     case "textAlign":
       markElement.attributes["w:val"] = attrs.textAlign;
       break;
@@ -29945,12 +31289,11 @@ function translateMark(mark) {
     case "lineHeight":
       markElement.attributes["w:line"] = linesToTwips(attrs.lineHeight);
       break;
-    case "highlight":
-      markElement.attributes["w:fill"] = attrs.color?.substring(1);
-      markElement.attributes["w:color"] = "auto";
-      markElement.attributes["w:val"] = "clear";
-      markElement.name = "w:shd";
-      break;
+    case "highlight": {
+      const highlightValue = attrs.color ?? attrs.highlight ?? null;
+      const translated = translator$14.decode({ node: { attrs: { highlight: highlightValue } } });
+      return translated || {};
+    }
   }
   return markElement;
 }
@@ -30081,8 +31424,8 @@ generate_xml_as_list_fn = function(data, debug = false) {
   return final;
 };
 replaceSpecialCharacters_fn = function(text) {
-  if (!text) return;
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  if (text === void 0 || text === null) return text;
+  return String(text).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 };
 generateXml_fn = function(node) {
   if (!node) return null;
@@ -30098,7 +31441,7 @@ generateXml_fn = function(node) {
   else tag += ">";
   let tags = [tag];
   if (!name && node.type === "text") {
-    return node.text;
+    return __privateMethod$2(this, _DocxExporter_instances, replaceSpecialCharacters_fn).call(this, node.text ?? "");
   }
   if (elements) {
     if (name === "w:instrText") {
@@ -30224,7 +31567,7 @@ const handleDrawingNode = (params2) => {
   if (mainNode.name === "w:drawing") node = mainNode;
   else node = mainNode.elements.find((el) => el.name === "w:drawing");
   if (!node) return { nodes: [], consumed: 0 };
-  const schemaNode = translator$1.encode(params2);
+  const schemaNode = translator$3.encode(params2);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -30327,81 +31670,7 @@ const trackChangeNodeHandlerEntity = {
   handler: handleTrackChangeNode
 };
 const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$6);
-const handleRunNode = (params2) => {
-  const { nodes, nodeListHandler, parentStyleId, docx } = params2;
-  if (nodes.length === 0 || nodes[0].name !== "w:r") {
-    return { nodes: [], consumed: 0 };
-  }
-  const node = nodes[0];
-  const childParams = { ...params2, nodes: node.elements, path: [...params2.path || [], node] };
-  let processedRun = nodeListHandler.handler(childParams)?.filter((n) => n) || [];
-  const hasRunProperties = node.elements?.some((el) => el.name === "w:rPr");
-  const defaultNodeStyles = getMarksFromStyles(docx, parentStyleId);
-  if (hasRunProperties) {
-    const { marks = [] } = parseProperties(node);
-    let runStyleAttributes = [];
-    const runStyleElement = node.elements?.find((el) => el.name === "w:rPr")?.elements?.find((el) => el.name === "w:rStyle");
-    let runStyleId;
-    if (runStyleElement && runStyleElement.attributes?.["w:val"] && docx) {
-      runStyleId = runStyleElement.attributes["w:val"];
-      const runStyleDefinition = getMarksFromStyles(docx, runStyleId);
-      if (runStyleDefinition.marks && runStyleDefinition.marks.length > 0) {
-        runStyleAttributes = runStyleDefinition.marks;
-      }
-    }
-    let paragraphStyleAttributes = [];
-    if (defaultNodeStyles.marks) {
-      paragraphStyleAttributes = defaultNodeStyles.marks.filter((mark) => {
-        if (["bold"].includes(mark.type) && marks.find((m2) => m2.type === "bold")?.attrs?.value === "0") {
-          return false;
-        }
-        return true;
-      });
-    }
-    const combinedMarks = [...paragraphStyleAttributes];
-    runStyleAttributes.forEach((runStyle) => {
-      const exists2 = combinedMarks.some(
-        (mark) => mark.type === runStyle.type && JSON.stringify(mark.attrs || {}) === JSON.stringify(runStyle.attrs || {})
-      );
-      if (!exists2) {
-        combinedMarks.push(runStyle);
-      }
-    });
-    marks.forEach((mark) => {
-      const exists2 = combinedMarks.some(
-        (existing) => existing.type === mark.type && JSON.stringify(existing.attrs || {}) === JSON.stringify(mark.attrs || {})
-      );
-      if (!exists2) {
-        combinedMarks.push(mark);
-      }
-    });
-    if (runStyleId) combinedMarks.push({ type: "textStyle", attrs: { styleId: runStyleId } });
-    if (node.marks) combinedMarks.push(...node.marks);
-    const newMarks = createImportMarks(combinedMarks);
-    processedRun = processedRun.map((n) => {
-      const existingMarks = n.marks || [];
-      return {
-        ...n,
-        marks: [...newMarks, ...existingMarks]
-      };
-    });
-  }
-  return { nodes: processedRun, consumed: 1 };
-};
-const getMarksFromStyles = (docx, styleId) => {
-  const styles = docx?.["word/styles.xml"];
-  if (!styles) {
-    return {};
-  }
-  const styleTags = styles.elements[0].elements.filter((style22) => style22.name === "w:style");
-  const style2 = styleTags.find((tag) => tag.attributes["w:styleId"] === styleId) || {};
-  if (!style2) return {};
-  return parseProperties(style2);
-};
-const runNodeHandlerEntity = {
-  handlerName: "runNodeHandler",
-  handler: handleRunNode
-};
+const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$T);
 const handleTextNode = (params2) => {
   const { nodes, insideTrackChange } = params2;
   if (nodes.length === 0 || !(nodes[0].name === "w:t" || insideTrackChange && nodes[0].name === "w:delText")) {
@@ -30413,6 +31682,10 @@ const handleTextNode = (params2) => {
   let text;
   if (elements.length === 1) {
     text = elements[0].text;
+    const xmlSpace = node.attributes?.["xml:space"] ?? elements[0]?.attributes?.["xml:space"];
+    if (xmlSpace !== "preserve" && typeof text === "string") {
+      text = text.replace(/^\s+/, "").replace(/\s+$/, "");
+    }
     text = text.replace(/\[\[sdspace\]\]/g, "");
   } else if (!elements.length && "attributes" in node && node.attributes["xml:space"] === "preserve") {
     text = " ";
@@ -30438,7 +31711,7 @@ const handleParagraphNode = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$T.encode(params2);
+  const schemaNode = translator$12.encode(params2);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -30451,7 +31724,7 @@ const handleSdtNode = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:sdt") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator.encode(params2);
+  const result = translator$2.encode(params2);
   if (!result) {
     return { nodes: [], consumed: 0 };
   }
@@ -30541,7 +31814,7 @@ const handler = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$V.encode(params2);
+  const result = translator$15.encode(params2);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -30613,7 +31886,7 @@ const handleBookmarkStartNode = (params2) => {
   if (isCustomMarkBookmark(nodes[0], params2.editor)) {
     return handleBookmarkNode(params2);
   }
-  const node = translator$3.encode(params2);
+  const node = translator$1.encode(params2);
   if (!node) return { nodes: [], consumed: 0 };
   return { nodes: [node], consumed: 1 };
 };
@@ -30645,7 +31918,7 @@ const handleBookmarkEndNode = (params2) => {
   if (!nodes.length || nodes[0].name !== "w:bookmarkEnd") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$2.encode(params2);
+  const node = translator.encode(params2);
   if (!node) return { nodes: [], consumed: 0 };
   return { nodes: [node], consumed: 1 };
 };
@@ -31284,7 +32557,7 @@ const handleTabNode = (params2) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$U.encode(params2);
+  const node = translator$13.encode(params2);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
@@ -31733,6 +33006,16 @@ const isAlternatingHeadersOddEven = (docx) => {
 };
 const HYPERLINK_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
 const HEADER_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header";
+const FONT_FAMILY_FALLBACKS = Object.freeze({
+  swiss: "Arial, sans-serif",
+  roman: "Times New Roman, serif",
+  modern: "Courier New, monospace",
+  script: "cursive",
+  decorative: "fantasy",
+  system: "system-ui",
+  auto: "sans-serif"
+});
+const DEFAULT_GENERIC_FALLBACK = "sans-serif";
 const _SuperConverter = class _SuperConverter2 {
   constructor(params2 = null) {
     __privateAdd$2(this, _SuperConverter_instances);
@@ -31768,6 +33051,31 @@ const _SuperConverter = class _SuperConverter2 {
     this.documentId = params2?.documentId || null;
     if (this.docx.length || this.xml) this.parseFromXml();
   }
+  static getFontTableEntry(docx, fontName) {
+    if (!docx || !fontName) return null;
+    const fontTable = docx["word/fontTable.xml"];
+    if (!fontTable?.elements?.length) return null;
+    const fontsNode = fontTable.elements.find((el) => el.name === "w:fonts");
+    if (!fontsNode?.elements?.length) return null;
+    return fontsNode.elements.find((el) => el?.attributes?.["w:name"] === fontName) || null;
+  }
+  static getFallbackFromFontTable(docx, fontName) {
+    const fontEntry = _SuperConverter2.getFontTableEntry(docx, fontName);
+    const family = fontEntry?.elements?.find((child) => child.name === "w:family")?.attributes?.["w:val"];
+    if (!family) return null;
+    const mapped = FONT_FAMILY_FALLBACKS[family.toLowerCase()];
+    return mapped || DEFAULT_GENERIC_FALLBACK;
+  }
+  static toCssFontFamily(fontName, docx) {
+    if (!fontName) return fontName;
+    if (fontName.includes(",")) return fontName;
+    const fallback = _SuperConverter2.getFallbackFromFontTable(docx, fontName) || DEFAULT_GENERIC_FALLBACK;
+    const normalizedFallbackParts = fallback.split(",").map((part) => part.trim().toLowerCase()).filter(Boolean);
+    if (normalizedFallbackParts.includes(fontName.trim().toLowerCase())) {
+      return fallback;
+    }
+    return `${fontName}, ${fallback}`;
+  }
   /**
    * Get the DocxHelpers object that contains utility functions for working with docx files.
    * @returns {import('./docx-helpers/docx-helpers.js').DocxHelpers} The DocxHelpers object.
@@ -31813,7 +33121,7 @@ const _SuperConverter = class _SuperConverter2 {
       return;
     }
   }
-  static updateDocumentVersion(docx = this.convertedXml, version2 = "0.20.0") {
+  static updateDocumentVersion(docx = this.convertedXml, version2 = "0.20.0-next.13") {
     const customLocation = "docProps/custom.xml";
     if (!docx[customLocation]) {
       docx[customLocation] = generateCustomXml();
@@ -31864,13 +33172,19 @@ const _SuperConverter = class _SuperConverter2 {
       if (rPrDefaults) {
         const rPr = rPrDefaults.elements?.find((el) => el.name === "w:rPr");
         const fonts = rPr?.elements?.find((el) => el.name === "w:rFonts");
-        typeface = fonts?.attributes["w:ascii"];
-        const fontSize2 = typeface ?? rPr?.elements?.find((el) => el.name === "w:sz")?.attributes["w:val"];
-        fontSizeNormal = !fontSizeNormal && fontSize2 ? Number(fontSize2) / 2 : null;
+        if (fonts?.attributes?.["w:ascii"]) {
+          typeface = fonts.attributes["w:ascii"];
+        }
+        const fontSizeRaw = rPr?.elements?.find((el) => el.name === "w:sz")?.attributes?.["w:val"];
+        if (!fontSizeNormal && fontSizeRaw) {
+          fontSizeNormal = Number(fontSizeRaw) / 2;
+        }
       }
-      const fontSizePt = fontSizeNormal || Number(rElements.find((el) => el.name === "w:sz")?.attributes["w:val"]) / 2 || 10;
+      const fallbackSz = Number(rElements.find((el) => el.name === "w:sz")?.attributes?.["w:val"]);
+      const fontSizePt = fontSizeNormal ?? (Number.isFinite(fallbackSz) ? fallbackSz / 2 : void 0) ?? 10;
       const kern = rElements.find((el) => el.name === "w:kern")?.attributes["w:val"];
-      return { fontSizePt, kern, typeface, panose };
+      const fontFamilyCss = _SuperConverter2.toCssFontFamily(typeface, this.convertedXml);
+      return { fontSizePt, kern, typeface, panose, fontFamilyCss };
     }
   }
   getDocumentFonts() {
@@ -32300,7 +33614,7 @@ function storeSuperdocVersion(docx) {
 function generateCustomXml() {
   return DEFAULT_CUSTOM_XML;
 }
-function generateSuperdocVersion(pid = 2, version2 = "0.20.0") {
+function generateSuperdocVersion(pid = 2, version2 = "0.20.0-next.13") {
   return {
     type: "element",
     name: "property",
@@ -33771,15 +35085,15 @@ function requireJszip_min() {
         function M2(e2, t2, r22, n2, i2) {
           this.good_length = e2, this.max_lazy = t2, this.nice_length = r22, this.max_chain = n2, this.func = i2;
         }
-        function H2() {
+        function H() {
           this.strm = null, this.status = 0, this.pending_buf = null, this.pending_buf_size = 0, this.pending_out = 0, this.pending = 0, this.wrap = 0, this.gzhead = null, this.gzindex = 0, this.method = v2, this.last_flush = -1, this.w_size = 0, this.w_bits = 0, this.w_mask = 0, this.window = null, this.window_size = 0, this.prev = null, this.head = null, this.ins_h = 0, this.hash_size = 0, this.hash_bits = 0, this.hash_mask = 0, this.hash_shift = 0, this.block_start = 0, this.match_length = 0, this.prev_match = 0, this.match_available = 0, this.strstart = 0, this.match_start = 0, this.lookahead = 0, this.prev_length = 0, this.max_chain_length = 0, this.max_lazy_match = 0, this.level = 0, this.strategy = 0, this.good_match = 0, this.nice_match = 0, this.dyn_ltree = new c2.Buf16(2 * w2), this.dyn_dtree = new c2.Buf16(2 * (2 * a + 1)), this.bl_tree = new c2.Buf16(2 * (2 * o + 1)), D2(this.dyn_ltree), D2(this.dyn_dtree), D2(this.bl_tree), this.l_desc = null, this.d_desc = null, this.bl_desc = null, this.bl_count = new c2.Buf16(k + 1), this.heap = new c2.Buf16(2 * s + 1), D2(this.heap), this.heap_len = 0, this.heap_max = 0, this.depth = new c2.Buf16(2 * s + 1), D2(this.depth), this.l_buf = 0, this.lit_bufsize = 0, this.last_lit = 0, this.d_buf = 0, this.opt_len = 0, this.static_len = 0, this.matches = 0, this.insert = 0, this.bi_buf = 0, this.bi_valid = 0;
         }
-        function G(e2) {
+        function G2(e2) {
           var t2;
           return e2 && e2.state ? (e2.total_in = e2.total_out = 0, e2.data_type = i, (t2 = e2.state).pending = 0, t2.pending_out = 0, t2.wrap < 0 && (t2.wrap = -t2.wrap), t2.status = t2.wrap ? C2 : E2, e2.adler = 2 === t2.wrap ? 0 : 1, t2.last_flush = l3, u._tr_init(t2), m2) : R2(e2, _2);
         }
         function K2(e2) {
-          var t2 = G(e2);
+          var t2 = G2(e2);
           return t2 === m2 && (function(e3) {
             e3.window_size = 2 * e3.w_size, D2(e3.head), e3.max_lazy_match = h2[e3.level].max_lazy, e3.good_match = h2[e3.level].good_length, e3.nice_match = h2[e3.level].nice_length, e3.max_chain_length = h2[e3.level].max_chain, e3.strstart = 0, e3.block_start = 0, e3.lookahead = 0, e3.insert = 0, e3.match_length = e3.prev_length = x - 1, e3.match_available = 0, e3.ins_h = 0;
           })(e2.state), t2;
@@ -33789,7 +35103,7 @@ function requireJszip_min() {
           var a2 = 1;
           if (t2 === g && (t2 = 6), n2 < 0 ? (a2 = 0, n2 = -n2) : 15 < n2 && (a2 = 2, n2 -= 16), i2 < 1 || y2 < i2 || r22 !== v2 || n2 < 8 || 15 < n2 || t2 < 0 || 9 < t2 || s2 < 0 || b2 < s2) return R2(e2, _2);
           8 === n2 && (n2 = 9);
-          var o2 = new H2();
+          var o2 = new H();
           return (e2.state = o2).strm = e2, o2.wrap = a2, o2.gzhead = null, o2.w_bits = n2, o2.w_size = 1 << o2.w_bits, o2.w_mask = o2.w_size - 1, o2.hash_bits = i2 + 7, o2.hash_size = 1 << o2.hash_bits, o2.hash_mask = o2.hash_size - 1, o2.hash_shift = ~~((o2.hash_bits + x - 1) / x), o2.window = new c2.Buf8(2 * o2.w_size), o2.head = new c2.Buf16(o2.hash_size), o2.prev = new c2.Buf16(o2.w_size), o2.lit_bufsize = 1 << i2 + 6, o2.pending_buf_size = 4 * o2.lit_bufsize, o2.pending_buf = new c2.Buf8(o2.pending_buf_size), o2.d_buf = 1 * o2.lit_bufsize, o2.l_buf = 3 * o2.lit_bufsize, o2.level = t2, o2.strategy = s2, o2.method = r22, K2(e2);
         }
         h2 = [new M2(0, 0, 0, 0, function(e2, t2) {
@@ -33807,7 +35121,7 @@ function requireJszip_min() {
           return e2.insert = 0, t2 === f ? (N2(e2, true), 0 === e2.strm.avail_out ? O2 : B2) : (e2.strstart > e2.block_start && (N2(e2, false), e2.strm.avail_out), A);
         }), new M2(4, 4, 8, 4, Z), new M2(4, 5, 16, 8, Z), new M2(4, 6, 32, 32, Z), new M2(4, 4, 16, 16, W2), new M2(8, 16, 32, 32, W2), new M2(8, 16, 128, 128, W2), new M2(8, 32, 128, 256, W2), new M2(32, 128, 258, 1024, W2), new M2(32, 258, 258, 4096, W2)], r2.deflateInit = function(e2, t2) {
           return Y2(e2, t2, v2, 15, 8, 0);
-        }, r2.deflateInit2 = Y2, r2.deflateReset = K2, r2.deflateResetKeep = G, r2.deflateSetHeader = function(e2, t2) {
+        }, r2.deflateInit2 = Y2, r2.deflateReset = K2, r2.deflateResetKeep = G2, r2.deflateSetHeader = function(e2, t2) {
           return e2 && e2.state ? 2 !== e2.state.wrap ? _2 : (e2.state.gzhead = t2, m2) : _2;
         }, r2.deflate = function(e2, t2) {
           var r22, n2, i2, s2;
@@ -34463,12 +35777,12 @@ function requireJszip_min() {
         function M2(e2) {
           8 < e2.bi_valid ? U2(e2, e2.bi_buf) : 0 < e2.bi_valid && (e2.pending_buf[e2.pending++] = e2.bi_buf), e2.bi_buf = 0, e2.bi_valid = 0;
         }
-        function H2(e2, t2, r22, n2) {
+        function H(e2, t2, r22, n2) {
           var i2 = 2 * t2, s2 = 2 * r22;
           return e2[i2] < e2[s2] || e2[i2] === e2[s2] && n2[t2] <= n2[r22];
         }
-        function G(e2, t2, r22) {
-          for (var n2 = e2.heap[r22], i2 = r22 << 1; i2 <= e2.heap_len && (i2 < e2.heap_len && H2(t2, e2.heap[i2 + 1], e2.heap[i2], e2.depth) && i2++, !H2(t2, n2, e2.heap[i2], e2.depth)); ) e2.heap[r22] = e2.heap[i2], r22 = i2, i2 <<= 1;
+        function G2(e2, t2, r22) {
+          for (var n2 = e2.heap[r22], i2 = r22 << 1; i2 <= e2.heap_len && (i2 < e2.heap_len && H(t2, e2.heap[i2 + 1], e2.heap[i2], e2.depth) && i2++, !H(t2, n2, e2.heap[i2], e2.depth)); ) e2.heap[r22] = e2.heap[i2], r22 = i2, i2 <<= 1;
           e2.heap[r22] = n2;
         }
         function K2(e2, t2, r22) {
@@ -34480,8 +35794,8 @@ function requireJszip_min() {
           var r22, n2, i2, s2 = t2.dyn_tree, a2 = t2.stat_desc.static_tree, o2 = t2.stat_desc.has_stree, h22 = t2.stat_desc.elems, u2 = -1;
           for (e2.heap_len = 0, e2.heap_max = _2, r22 = 0; r22 < h22; r22++) 0 !== s2[2 * r22] ? (e2.heap[++e2.heap_len] = u2 = r22, e2.depth[r22] = 0) : s2[2 * r22 + 1] = 0;
           for (; e2.heap_len < 2; ) s2[2 * (i2 = e2.heap[++e2.heap_len] = u2 < 2 ? ++u2 : 0)] = 1, e2.depth[i2] = 0, e2.opt_len--, o2 && (e2.static_len -= a2[2 * i2 + 1]);
-          for (t2.max_code = u2, r22 = e2.heap_len >> 1; 1 <= r22; r22--) G(e2, s2, r22);
-          for (i2 = h22; r22 = e2.heap[1], e2.heap[1] = e2.heap[e2.heap_len--], G(e2, s2, 1), n2 = e2.heap[1], e2.heap[--e2.heap_max] = r22, e2.heap[--e2.heap_max] = n2, s2[2 * i2] = s2[2 * r22] + s2[2 * n2], e2.depth[i2] = (e2.depth[r22] >= e2.depth[n2] ? e2.depth[r22] : e2.depth[n2]) + 1, s2[2 * r22 + 1] = s2[2 * n2 + 1] = i2, e2.heap[1] = i2++, G(e2, s2, 1), 2 <= e2.heap_len; ) ;
+          for (t2.max_code = u2, r22 = e2.heap_len >> 1; 1 <= r22; r22--) G2(e2, s2, r22);
+          for (i2 = h22; r22 = e2.heap[1], e2.heap[1] = e2.heap[e2.heap_len--], G2(e2, s2, 1), n2 = e2.heap[1], e2.heap[--e2.heap_max] = r22, e2.heap[--e2.heap_max] = n2, s2[2 * i2] = s2[2 * r22] + s2[2 * n2], e2.depth[i2] = (e2.depth[r22] >= e2.depth[n2] ? e2.depth[r22] : e2.depth[n2]) + 1, s2[2 * r22 + 1] = s2[2 * n2 + 1] = i2, e2.heap[1] = i2++, G2(e2, s2, 1), 2 <= e2.heap_len; ) ;
           e2.heap[--e2.heap_max] = e2.heap[1], (function(e3, t3) {
             var r3, n3, i3, s3, a3, o3, h3 = t3.dyn_tree, u3 = t3.max_code, l22 = t3.stat_desc.static_tree, f2 = t3.stat_desc.has_stree, c22 = t3.stat_desc.extra_bits, d22 = t3.stat_desc.extra_base, p2 = t3.stat_desc.max_length, m22 = 0;
             for (s3 = 0; s3 <= g; s3++) e3.bl_count[s3] = 0;
@@ -41043,19 +42357,19 @@ class Hasher {
     this._W = new Uint32Array(buf, 64, 64);
   }
   _updateHash() {
-    const H2 = this._H;
+    const H = this._H;
     const W2 = this._W;
     for (let t = 16; t < 64; t++) {
       W2[t] = sigma1to256(W2[t - 2]) + W2[t - 7] + sigma0to256(W2[t - 15]) + W2[t - 16];
     }
-    let a = H2[0];
-    let b2 = H2[1];
-    let c2 = H2[2];
-    let d2 = H2[3];
-    let e = H2[4];
-    let f = H2[5];
-    let g = H2[6];
-    let h2 = H2[7];
+    let a = H[0];
+    let b2 = H[1];
+    let c2 = H[2];
+    let d2 = H[3];
+    let e = H[4];
+    let f = H[5];
+    let g = H[6];
+    let h2 = H[7];
     for (let tt = 0, T1, T2; tt < 64; tt++) {
       T1 = h2 + sum1to256(e) + (e & f ^ ~e & g) + K[tt] + W2[tt] >>> 0;
       T2 = sum0to256(a) + (a & b2 ^ a & c2 ^ b2 & c2) >>> 0;
@@ -41068,14 +42382,14 @@ class Hasher {
       b2 = a;
       a = T1 + T2 >>> 0;
     }
-    H2[0] += a;
-    H2[1] += b2;
-    H2[2] += c2;
-    H2[3] += d2;
-    H2[4] += e;
-    H2[5] += f;
-    H2[6] += g;
-    H2[7] += h2;
+    H[0] += a;
+    H[1] += b2;
+    H[2] += c2;
+    H[3] += d2;
+    H[4] += e;
+    H[5] += f;
+    H[6] += g;
+    H[7] += h2;
   }
   /**
    * Returns a 32-byte hash.
@@ -43707,6 +45021,96 @@ const toggleMark = (typeOrName, attrs = {}, options = {}) => ({ state: state2, c
   if (isActive2) return commands2.unsetMark(type2, { extendEmptyMarkRange });
   return commands2.setMark(type2, attrs);
 };
+const toggleMarkCascade = (markName, options = {}) => ({ state: state2, chain, editor }) => {
+  const {
+    negationAttrs = { value: "0" },
+    isNegation = (attrs) => attrs?.value === "0",
+    styleDetector = defaultStyleDetector,
+    extendEmptyMarkRange = true
+  } = options;
+  const selectionMarks = getMarksFromSelection(state2) || [];
+  const inlineMarks = selectionMarks.filter((m2) => m2.type?.name === markName);
+  const hasNegation = inlineMarks.some((m2) => isNegation(m2.attrs || {}));
+  const hasInline = inlineMarks.some((m2) => !isNegation(m2.attrs || {}));
+  const styleOn = styleDetector({ state: state2, selectionMarks, markName, editor });
+  const cmdChain = chain();
+  if (hasNegation) return cmdChain.unsetMark(markName, { extendEmptyMarkRange }).run();
+  if (hasInline && styleOn) {
+    return cmdChain.unsetMark(markName, { extendEmptyMarkRange }).setMark(markName, negationAttrs, { extendEmptyMarkRange }).run();
+  }
+  if (hasInline) return cmdChain.unsetMark(markName, { extendEmptyMarkRange }).run();
+  if (styleOn) return cmdChain.setMark(markName, negationAttrs, { extendEmptyMarkRange }).run();
+  return cmdChain.setMark(markName, {}, { extendEmptyMarkRange }).run();
+};
+function defaultStyleDetector({ state: state2, selectionMarks, markName, editor }) {
+  try {
+    const styleId = getEffectiveStyleId(state2, selectionMarks);
+    if (!styleId || !editor?.converter?.linkedStyles) return false;
+    const styles = editor.converter.linkedStyles;
+    const seen = /* @__PURE__ */ new Set();
+    let current = styleId;
+    const key2 = mapMarkToStyleKey(markName);
+    while (current && !seen.has(current)) {
+      seen.add(current);
+      const style2 = styles.find((s) => s.id === current);
+      const def = style2?.definition?.styles || {};
+      if (key2 in def) {
+        const raw = def[key2];
+        if (raw === void 0) return true;
+        const val = raw?.value ?? raw;
+        return isStyleTokenEnabled(val);
+      }
+      current = style2?.definition?.attrs?.basedOn || null;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function getEffectiveStyleId(state2, selectionMarks) {
+  const sidFromMarks = getStyleIdFromMarks(selectionMarks);
+  if (sidFromMarks) return sidFromMarks;
+  const $from = state2.selection.$from;
+  const before = $from.nodeBefore;
+  const after = $from.nodeAfter;
+  if (before && before.marks) {
+    const sid = getStyleIdFromMarks(before.marks);
+    if (sid) return sid;
+  }
+  if (after && after.marks) {
+    const sid = getStyleIdFromMarks(after.marks);
+    if (sid) return sid;
+  }
+  const ts = selectionMarks.find((m2) => m2.type?.name === "textStyle" && m2.attrs?.styleId);
+  if (ts) return ts.attrs.styleId;
+  const pos = state2.selection.$from.pos;
+  const $pos = state2.doc.resolve(pos);
+  for (let d2 = $pos.depth; d2 >= 0; d2--) {
+    const n = $pos.node(d2);
+    if (n?.type?.name === "paragraph") return n.attrs?.styleId || null;
+  }
+  return null;
+}
+function getStyleIdFromMarks(marks) {
+  if (!Array.isArray(marks)) return null;
+  const textStyleMark = marks.find((m2) => m2.type?.name === "textStyle" && m2.attrs?.styleId);
+  if (textStyleMark) return textStyleMark.attrs.styleId;
+  return null;
+}
+function mapMarkToStyleKey(markName) {
+  if (markName === "textStyle" || markName === "color") return "color";
+  return markName;
+}
+function isStyleTokenEnabled(val) {
+  if (val === false || val === 0) return false;
+  if (typeof val === "string") {
+    const normalized = val.trim().toLowerCase();
+    if (!normalized) return false;
+    if (["0", "false", "none", "inherit", "transparent"].includes(normalized)) return false;
+    return true;
+  }
+  return !!val;
+}
 const clearNodes = () => ({ state: state2, tr, dispatch }) => {
   const { selection } = tr;
   const { ranges } = selection;
@@ -45052,11 +46456,14 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   command,
   createParagraphNear,
   decreaseListIndent,
+  defaultStyleDetector,
   deleteListItem,
   deleteSelection,
   exitCode,
   first,
+  getEffectiveStyleId,
   getParaCtx,
+  getStyleIdFromMarks,
   handleBackspaceNextToList,
   handleDeleteNextToList,
   increaseListIndent,
@@ -45065,12 +46472,14 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   insertTabChar,
   insertTabCharacter,
   insertTabNode,
+  isStyleTokenEnabled,
   joinBackward,
   joinDown,
   joinForward,
   joinUp,
   liftEmptyBlock,
   liftListItem,
+  mapMarkToStyleKey,
   nearestListAt,
   newlineInCode,
   rebuildListNodeWithNewNum,
@@ -45090,6 +46499,7 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   splitListItem,
   toggleList,
   toggleMark,
+  toggleMarkCascade,
   toggleNode,
   undoInputRule,
   unsetAllMarks,
@@ -45105,6 +46515,7 @@ const Commands = Extension.create({
 });
 const handleEnter = (editor) => {
   return editor.commands.first(({ commands: commands2 }) => [
+    () => commands2.splitRun(),
     () => commands2.newlineInCode(),
     () => commands2.createParagraphNear(),
     () => commands2.liftEmptyBlock(),
@@ -45138,6 +46549,7 @@ const Keymap = Extension.create({
   addShortcuts() {
     const baseKeymap = {
       Enter: () => handleEnter(this.editor),
+      "Shift-Enter": () => this.editor.commands.insertLineBreak(),
       "Mod-Enter": () => this.editor.commands.exitCode(),
       Backspace: () => handleBackspace(this.editor),
       "Mod-Backspace": () => handleBackspace(this.editor),
@@ -46215,7 +47627,18 @@ const updateYdocDocxData = async (editor, ydoc) => {
   ydoc = ydoc || editor.options.ydoc;
   if (!ydoc) return;
   const metaMap = ydoc.getMap("meta");
-  const docx = [...metaMap.get("docx")];
+  const docxValue = metaMap.get("docx");
+  let docx = [];
+  if (Array.isArray(docxValue)) {
+    docx = [...docxValue];
+  } else if (docxValue && typeof docxValue.toArray === "function") {
+    docx = docxValue.toArray();
+  } else if (docxValue && typeof docxValue[Symbol.iterator] === "function") {
+    docx = Array.from(docxValue);
+  }
+  if (!docx.length && Array.isArray(editor.options.content)) {
+    docx = [...editor.options.content];
+  }
   const newXml = await editor.exportDocx({ getUpdatedDocs: true });
   Object.keys(newXml).forEach((key2) => {
     const fileIndex = docx.findIndex((item) => item.name === key2);
@@ -46293,7 +47716,7 @@ const createHeaderFooterEditor = ({
   currentPageNumber
 }) => {
   const parentStyles = editor.converter.getDocumentDefaultStyles();
-  const { fontSizePt, typeface } = parentStyles;
+  const { fontSizePt, typeface, fontFamilyCss } = parentStyles;
   const fontSizeInPixles = fontSizePt * 1.3333;
   const lineHeight2 = fontSizeInPixles * 1.2;
   Object.assign(editorContainer.style, {
@@ -46306,7 +47729,7 @@ const createHeaderFooterEditor = ({
     left: "0",
     width: "auto",
     maxWidth: "none",
-    fontFamily: typeface,
+    fontFamily: fontFamilyCss || typeface,
     fontSize: `${fontSizeInPixles}px`,
     lineHeight: `${lineHeight2}px`
   });
@@ -47136,7 +48559,6 @@ const trackedTransaction = ({ tr, state: state2, user }) => {
         originalStep,
         originalStepIndex
       });
-      console.debug("[track-changes]: replaceStep");
     } else if (step instanceof AddMarkStep) {
       addMarkStep({
         state: state2,
@@ -47146,7 +48568,6 @@ const trackedTransaction = ({ tr, state: state2, user }) => {
         user,
         date
       });
-      console.debug("[track-changes]: addMarkStep");
     } else if (step instanceof RemoveMarkStep) {
       removeMarkStep({
         state: state2,
@@ -47156,10 +48577,8 @@ const trackedTransaction = ({ tr, state: state2, user }) => {
         user,
         date
       });
-      console.debug("[track-changes]: removeMarkStep");
     } else {
       newTr.step(step);
-      console.log("[track-changes]: otherStep");
     }
   });
   if (tr.getMeta("inputType")) {
@@ -49229,9 +50648,10 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
     element.style.isolation = "isolate";
     proseMirror.style.outline = "none";
     proseMirror.style.border = "none";
-    const { typeface, fontSizePt } = this.converter.getDocumentDefaultStyles() ?? {};
-    if (typeface) {
-      element.style.fontFamily = typeface;
+    const { typeface, fontSizePt, fontFamilyCss } = this.converter.getDocumentDefaultStyles() ?? {};
+    const resolvedFontFamily = fontFamilyCss || typeface;
+    if (resolvedFontFamily) {
+      element.style.fontFamily = resolvedFontFamily;
     }
     if (fontSizePt) {
       element.style.fontSize = `${fontSizePt}pt`;
@@ -49519,12 +50939,15 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
   }
   destroyHeaderFooterEditors() {
     try {
-      const editors = [...this.converter.headerEditors, ...this.converter.footerEditors];
+      const headerEditors = this.converter?.headerEditors ?? [];
+      const footerEditors = this.converter?.footerEditors ?? [];
+      if (!headerEditors.length && !footerEditors.length) return;
+      const editors = [...headerEditors, ...footerEditors].filter(Boolean);
       for (let editorData of editors) {
-        editorData.editor.destroy();
+        editorData?.editor?.destroy?.();
       }
-      this.converter.headerEditors.length = 0;
-      this.converter.footerEditors.length = 0;
+      if (headerEditors.length) headerEditors.length = 0;
+      if (footerEditors.length) footerEditors.length = 0;
     } catch (error) {
       this.emit("exception", { error, editor: this });
       console.error(error);
@@ -49547,7 +50970,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
    * @returns {Object | void} Migration results
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "0.20.0");
+    console.debug("[checkVersionMigrations] Current editor version", "0.20.0-next.13");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -50598,6 +52021,7 @@ const FormatCommands = Extension.create({
   },
   addCommands() {
     return {
+      toggleMarkCascade,
       /**
        * Clear all formatting (nodes and marks)
        * @category Command
@@ -51577,27 +53001,69 @@ const Text = Node$1.create({
     return {};
   }
 });
-const RunItem = Node$1.create({
+const splitRun = () => (props) => {
+  const { state: state2, view, tr } = props;
+  const { $from, empty: empty2 } = state2.selection;
+  if (!empty2) return false;
+  if ($from.parent.type.name !== "run") return false;
+  const handled = splitBlock(state2, (transaction) => {
+    view.dispatch(transaction);
+  });
+  if (handled) {
+    tr.setMeta("preventDispatch", true);
+  }
+  return handled;
+};
+const Run = OxmlNode.create({
   name: "run",
+  oXmlName: "w:r",
   group: "inline",
-  content: "text*",
   inline: true,
+  content: "inline*",
+  selectable: false,
+  childToAttributes: ["runProperties"],
   addOptions() {
-    return {};
-  },
-  parseDOM() {
-    return [{ tag: "run" }];
-  },
-  renderDOM() {
-    return ["run", 0];
+    return {
+      htmlAttributes: {
+        "data-run": "1"
+      }
+    };
   },
   addAttributes() {
     return {
-      attributes: {
+      runProperties: {
+        default: null,
         rendered: false,
-        "aria-label": "Run node"
+        keepOnSplit: true
+      },
+      rsidR: {
+        default: null,
+        rendered: false,
+        keepOnSplit: true
+      },
+      rsidRPr: {
+        default: null,
+        rendered: false,
+        keepOnSplit: true
+      },
+      rsidDel: {
+        default: null,
+        rendered: false,
+        keepOnSplit: true
       }
     };
+  },
+  addCommands() {
+    return {
+      splitRun
+    };
+  },
+  parseDOM() {
+    return [{ tag: "span[data-run]" }];
+  },
+  renderDOM({ htmlAttributes }) {
+    const base2 = Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+    return ["span", base2, 0];
   }
 });
 const inputRegex$1 = /^\s*([-+*])\s$/;
@@ -51872,6 +53338,115 @@ const OrderedList = Node$1.create({
     ];
   }
 });
+const generateOrderedListIndex = ({ listLevel, lvlText, listNumberingType, customFormat }) => {
+  const handler2 = listIndexMap[listNumberingType];
+  return handler2 ? handler2(listLevel, lvlText, customFormat) : null;
+};
+const handleDecimal = (path, lvlText) => generateNumbering(path, lvlText, String);
+const handleRoman = (path, lvlText) => generateNumbering(path, lvlText, intToRoman);
+const handleLowerRoman = (path, lvlText) => handleRoman(path, lvlText).toLowerCase();
+const handleLowerAlpha = (path, lvlText) => handleAlpha(path, lvlText).toLowerCase();
+const handleAlpha = (path, lvlText) => generateNumbering(path, lvlText, (p) => intToAlpha(p));
+const handleOrdinal = (path, lvlText) => generateNumbering(path, lvlText, ordinalFormatter);
+const handleCustom = (path, lvlText, customFormat) => generateFromCustom(path, lvlText, customFormat);
+const handleJapaneseCounting = (path, lvlText) => generateNumbering(path, lvlText, intToJapaneseCounting);
+const listIndexMap = {
+  decimal: handleDecimal,
+  lowerRoman: handleLowerRoman,
+  upperRoman: handleRoman,
+  lowerLetter: handleLowerAlpha,
+  upperLetter: handleAlpha,
+  ordinal: handleOrdinal,
+  custom: handleCustom,
+  japaneseCounting: handleJapaneseCounting
+};
+const createNumbering = (values, lvlText) => {
+  return values.reduce((acc, value, index2) => {
+    return value > 9 ? acc.replace(/^0/, "").replace(`%${index2 + 1}`, value) : acc.replace(`%${index2 + 1}`, value);
+  }, lvlText);
+};
+const generateNumbering = (path, lvlText, formatter) => {
+  const formattedValues = path.map(formatter);
+  return createNumbering(formattedValues, lvlText);
+};
+const ordinalFormatter = (level) => {
+  const suffixes = ["th", "st", "nd", "rd"];
+  const value = level % 100;
+  const suffix2 = suffixes[(value - 20) % 10] || suffixes[value] || suffixes[0];
+  const p = level + suffix2;
+  return p;
+};
+const generateFromCustom = (path, lvlText, customFormat) => {
+  if (customFormat !== "001, 002, 003, ...") return generateNumbering(path, lvlText, String);
+  const match = customFormat.match(/(\d+)/);
+  if (!match) throw new Error("Invalid format string: no numeric pattern found");
+  const sample = match[1];
+  const digitCount = sample.length;
+  const index2 = path.pop();
+  return String(index2).padStart(digitCount, "0");
+};
+const intToRoman = (num) => {
+  const romanNumeralMap = [
+    { value: 1e3, numeral: "M" },
+    { value: 900, numeral: "CM" },
+    { value: 500, numeral: "D" },
+    { value: 400, numeral: "CD" },
+    { value: 100, numeral: "C" },
+    { value: 90, numeral: "XC" },
+    { value: 50, numeral: "L" },
+    { value: 40, numeral: "XL" },
+    { value: 10, numeral: "X" },
+    { value: 9, numeral: "IX" },
+    { value: 5, numeral: "V" },
+    { value: 4, numeral: "IV" },
+    { value: 1, numeral: "I" }
+  ];
+  let result = "";
+  for (const { value, numeral } of romanNumeralMap) {
+    while (num >= value) {
+      result += numeral;
+      num -= value;
+    }
+  }
+  return result;
+};
+const intToAlpha = (num) => {
+  let result = "";
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  while (num > 0) {
+    let index2 = (num - 1) % 26;
+    result = alphabet[index2] + result;
+    num = Math.floor((num - 1) / 26);
+  }
+  return result;
+};
+const intToJapaneseCounting = (num) => {
+  const digits = ["", "一", "二", "三", "四", "五", "六", "七", "八", "九"];
+  const units = ["", "十", "百", "千"];
+  if (num === 0) return "零";
+  if (num < 10) return digits[num];
+  let result = "";
+  let tempNum = num;
+  let unitIndex = 0;
+  while (tempNum > 0) {
+    const digit = tempNum % 10;
+    if (digit !== 0) {
+      const digitStr = digit === 1 && unitIndex > 0 ? "" : digits[digit];
+      result = digitStr + (unitIndex > 0 ? units[unitIndex] : "") + result;
+    } else if (result && tempNum > 0) {
+      if (!result.startsWith("零") && tempNum % 100 !== 0) {
+        result = "零" + result;
+      }
+    }
+    tempNum = Math.floor(tempNum / 10);
+    unitIndex++;
+    if (unitIndex > 3) break;
+  }
+  if (num >= 10 && num < 20) {
+    result = result.replace(/^一十/, "十");
+  }
+  return result;
+};
 const CustomSelectionPluginKey = new PluginKey("CustomSelection");
 const handleClickOutside = (event, editor) => {
   const editorElem = editor?.options?.element;
@@ -52152,6 +53727,7 @@ const getMarksStyle = (attrs) => {
       case "textStyle":
         const { fontFamily: fontFamily2, fontSize: fontSize2 } = attr.attrs;
         styles += `${fontFamily2 ? `font-family: ${fontFamily2};` : ""} ${fontSize2 ? `font-size: ${fontSize2};` : ""}`;
+        break;
     }
   }
   return styles.trim();
@@ -52170,12 +53746,22 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
   const linkedDefinitionStyles = { ...linkedStyle.definition.styles };
   const basedOnDefinitionStyles = { ...basedOnStyle?.definition?.styles };
   const resultStyles = { ...linkedDefinitionStyles };
-  if (!linkedDefinitionStyles["font-size"] && basedOnDefinitionStyles["font-size"]) {
-    resultStyles["font-size"] = basedOnDefinitionStyles["font-size"];
-  }
-  if (!linkedDefinitionStyles["text-transform"] && basedOnDefinitionStyles["text-transform"]) {
-    resultStyles["text-transform"] = basedOnDefinitionStyles["text-transform"];
-  }
+  const inheritKeys = [
+    "font-size",
+    "font-family",
+    "text-transform",
+    "bold",
+    "italic",
+    "underline",
+    "strike",
+    "color",
+    "highlight"
+  ];
+  inheritKeys.forEach((k) => {
+    if (!linkedDefinitionStyles[k] && basedOnDefinitionStyles[k]) {
+      resultStyles[k] = basedOnDefinitionStyles[k];
+    }
+  });
   Object.entries(resultStyles).forEach(([k, value]) => {
     const key2 = kebabCase$1(k);
     const flattenedMarks = [];
@@ -52190,6 +53776,10 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
       }
       flattenedMarks.push({ key: n.type.name, value: n.attrs[key2] });
     });
+    const underlineNone = node?.marks?.some((m2) => m2.type?.name === "underline" && m2.attrs?.underlineType === "none");
+    if (underlineNone) {
+      markValue["text-decoration"] = "none";
+    }
     const mark = flattenedMarks.find((n) => n.key === key2);
     const hasParentIndent = Object.keys(parent?.attrs?.indent || {});
     const hasParentSpacing = Object.keys(parent?.attrs?.spacing || {});
@@ -52206,10 +53796,28 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
         if (rightIndent) markValue["margin-right"] = rightIndent + "px";
         if (firstLine) markValue["text-indent"] = firstLine + "px";
       } else if (key2 === "bold" && node) {
-        const val = value?.value;
-        if (!listTypes.includes(node.type.name) && val !== "0") {
+        const boldValue = typeof value === "object" && value !== null ? value.value : value;
+        const hasInlineBoldOff = node.marks?.some((m2) => m2.type?.name === "bold" && m2.attrs?.value === "0");
+        const hasInlineBoldOn = node.marks?.some((m2) => m2.type?.name === "bold" && m2.attrs?.value !== "0");
+        if (!listTypes.includes(node.type.name) && !hasInlineBoldOff && !hasInlineBoldOn && boldValue !== "0" && boldValue !== false) {
           markValue["font-weight"] = "bold";
         }
+      } else if (key2 === "italic" && node) {
+        const italicValue = typeof value === "object" && value !== null ? value.value : value;
+        const hasInlineItalicOff = node.marks?.some((m2) => m2.type?.name === "italic" && m2.attrs?.value === "0");
+        const hasInlineItalicOn = node.marks?.some((m2) => m2.type?.name === "italic" && m2.attrs?.value !== "0");
+        if (!listTypes.includes(node.type.name) && !hasInlineItalicOff && !hasInlineItalicOn && italicValue !== "0" && italicValue !== false) {
+          markValue["font-style"] = "italic";
+        }
+      } else if (key2 === "strike" && node) {
+        const strikeValue = typeof value === "object" && value !== null ? value.value : value;
+        const hasInlineStrikeOff = node.marks?.some((m2) => m2.type?.name === "strike" && m2.attrs?.value === "0");
+        const hasInlineStrikeOn = node.marks?.some(
+          (m2) => m2.type?.name === "strike" && (m2.attrs?.value === void 0 || m2.attrs?.value !== "0")
+        );
+        if (!listTypes.includes(node.type.name) && !hasInlineStrikeOff && !hasInlineStrikeOn && strikeValue !== "0" && strikeValue !== false) {
+          markValue["text-decoration"] = "line-through";
+        }
       } else if (key2 === "text-transform" && node) {
         if (!listTypes.includes(node.type.name)) {
           markValue[key2] = value;
@@ -52218,10 +53826,44 @@ const generateLinkedStyleString = (linkedStyle, basedOnStyle, node, parent, incl
         if (!listTypes.includes(node.type.name)) {
           markValue[key2] = value;
         }
+      } else if (key2 === "font-family" && node) {
+        if (!listTypes.includes(node.type.name)) {
+          markValue[key2] = value;
+        }
       } else if (key2 === "color" && node) {
         if (!listTypes.includes(node.type.name)) {
           markValue[key2] = value;
         }
+      } else if (key2 === "highlight" && node) {
+        const hasInlineHighlight = node.marks?.some((m2) => m2.type?.name === "highlight");
+        if (!listTypes.includes(node.type.name) && !hasInlineHighlight) {
+          const color = typeof value === "string" ? value : value?.color;
+          if (color) markValue["background-color"] = color;
+        }
+      } else if (key2 === "underline" && node) {
+        const styleValRaw = value?.value ?? value ?? "";
+        const styleVal = styleValRaw.toString().toLowerCase();
+        const hasInlineUnderlineOff = node.marks?.some(
+          (m2) => m2.type?.name === "underline" && m2.attrs?.underlineType === "none"
+        );
+        const hasInlineUnderlineOn = node.marks?.some(
+          (m2) => m2.type?.name === "underline" && m2.attrs?.underlineType && m2.attrs.underlineType !== "none"
+        );
+        if (!listTypes.includes(node.type.name) && !hasInlineUnderlineOff && !hasInlineUnderlineOn) {
+          if (styleVal && styleVal !== "none" && styleVal !== "0") {
+            const colorVal = value && typeof value === "object" ? value.color || value.underlineColor || null : null;
+            const css = getUnderlineCssString({ type: styleVal, color: colorVal });
+            css.split(";").forEach((decl) => {
+              const d2 = decl.trim();
+              if (!d2) return;
+              const idx = d2.indexOf(":");
+              if (idx === -1) return;
+              const k2 = d2.slice(0, idx).trim();
+              const v2 = d2.slice(idx + 1).trim();
+              markValue[k2] = v2;
+            });
+          }
+        }
       } else if (typeof value === "string") {
         markValue[key2] = value;
       }
@@ -52354,23 +53996,51 @@ const createLinkedStylesPlugin = (editor) => {
 };
 const generateDecorations = (state2, styles) => {
   const decorations = [];
-  let lastStyleId = null;
   const doc2 = state2?.doc;
+  const getParagraphStyleId = (pos) => {
+    const $pos = state2.doc.resolve(pos);
+    for (let d2 = $pos.depth; d2 >= 0; d2--) {
+      const n = $pos.node(d2);
+      if (n?.type?.name === "paragraph") return n.attrs?.styleId || null;
+    }
+    return null;
+  };
   doc2.descendants((node, pos) => {
     const { name } = node.type;
-    if (node?.attrs?.styleId) lastStyleId = node.attrs.styleId;
-    if (name === "paragraph" && !node.attrs?.styleId) lastStyleId = null;
-    if (name !== "text" && name !== "listItem" && name !== "orderedList") return;
+    if (name !== "text") return;
+    const paragraphStyleId = getParagraphStyleId(pos);
+    let runStyleId = null;
+    let inlineTextStyleId = null;
     for (const mark of node.marks) {
-      if (mark.type.name === "textStyle" && mark.attrs.styleId) {
-        lastStyleId = mark.attrs.styleId;
-      }
-    }
-    const { linkedStyle, basedOnStyle } = getLinkedStyle(lastStyleId, styles);
-    if (!linkedStyle) return;
+      if (mark.type.name === "run") {
+        const rp = mark.attrs?.runProperties;
+        if (rp && typeof rp === "object" && !Array.isArray(rp) && rp.styleId) runStyleId = rp.styleId;
+        else if (Array.isArray(rp)) {
+          const ent = rp.find((e) => e?.xmlName === "w:rStyle");
+          const sid = ent?.attributes?.["w:val"];
+          if (sid) runStyleId = sid;
+        }
+      } else if (mark.type.name === "textStyle" && mark.attrs?.styleId) {
+        inlineTextStyleId = mark.attrs.styleId;
+      }
+    }
+    const buildStyleMap = (sid) => {
+      if (!sid) return {};
+      const { linkedStyle, basedOnStyle: basedOnStyle2 } = getLinkedStyle(sid, styles);
+      if (!linkedStyle) return {};
+      const base2 = { ...basedOnStyle2?.definition?.styles || {} };
+      return { ...base2, ...linkedStyle.definition?.styles || {} };
+    };
+    const pMap = buildStyleMap(paragraphStyleId);
+    const tMap = buildStyleMap(inlineTextStyleId);
+    const rMap = buildStyleMap(runStyleId);
+    const finalStyles = { ...pMap, ...tMap, ...rMap };
+    if (Object.keys(finalStyles).length === 0) return;
+    const mergedLinkedStyle = { definition: { styles: finalStyles, attrs: {} } };
+    const basedOnStyle = null;
     const $pos = state2.doc.resolve(pos);
     const parent = $pos.parent;
-    const styleString = generateLinkedStyleString(linkedStyle, basedOnStyle, node, parent);
+    const styleString = generateLinkedStyleString(mergedLinkedStyle, basedOnStyle, node, parent);
     if (!styleString) return;
     const decoration = Decoration.inline(pos, pos + node.nodeSize, { style: styleString });
     decorations.push(decoration);
@@ -52499,115 +54169,298 @@ const LinkedStyles = Extension.create({
     };
   }
 });
-const generateOrderedListIndex = ({ listLevel, lvlText, listNumberingType, customFormat }) => {
-  const handler2 = listIndexMap[listNumberingType];
-  return handler2 ? handler2(listLevel, lvlText, customFormat) : null;
-};
-const handleDecimal = (path, lvlText) => generateNumbering(path, lvlText, String);
-const handleRoman = (path, lvlText) => generateNumbering(path, lvlText, intToRoman);
-const handleLowerRoman = (path, lvlText) => handleRoman(path, lvlText).toLowerCase();
-const handleLowerAlpha = (path, lvlText) => handleAlpha(path, lvlText).toLowerCase();
-const handleAlpha = (path, lvlText) => generateNumbering(path, lvlText, (p) => intToAlpha(p));
-const handleOrdinal = (path, lvlText) => generateNumbering(path, lvlText, ordinalFormatter);
-const handleCustom = (path, lvlText, customFormat) => generateFromCustom(path, lvlText, customFormat);
-const handleJapaneseCounting = (path, lvlText) => generateNumbering(path, lvlText, intToJapaneseCounting);
-const listIndexMap = {
-  decimal: handleDecimal,
-  lowerRoman: handleLowerRoman,
-  upperRoman: handleRoman,
-  lowerLetter: handleLowerAlpha,
-  upperLetter: handleAlpha,
-  ordinal: handleOrdinal,
-  custom: handleCustom,
-  japaneseCounting: handleJapaneseCounting
-};
-const createNumbering = (values, lvlText) => {
-  return values.reduce((acc, value, index2) => {
-    return value > 9 ? acc.replace(/^0/, "").replace(`%${index2 + 1}`, value) : acc.replace(`%${index2 + 1}`, value);
-  }, lvlText);
-};
-const generateNumbering = (path, lvlText, formatter) => {
-  const formattedValues = path.map(formatter);
-  return createNumbering(formattedValues, lvlText);
-};
-const ordinalFormatter = (level) => {
-  const suffixes = ["th", "st", "nd", "rd"];
-  const value = level % 100;
-  const suffix2 = suffixes[(value - 20) % 10] || suffixes[value] || suffixes[0];
-  const p = level + suffix2;
-  return p;
-};
-const generateFromCustom = (path, lvlText, customFormat) => {
-  if (customFormat !== "001, 002, 003, ...") return generateNumbering(path, lvlText, String);
-  const match = customFormat.match(/(\d+)/);
-  if (!match) throw new Error("Invalid format string: no numeric pattern found");
-  const sample = match[1];
-  const digitCount = sample.length;
-  const index2 = path.pop();
-  return String(index2).padStart(digitCount, "0");
-};
-const intToRoman = (num) => {
-  const romanNumeralMap = [
-    { value: 1e3, numeral: "M" },
-    { value: 900, numeral: "CM" },
-    { value: 500, numeral: "D" },
-    { value: 400, numeral: "CD" },
-    { value: 100, numeral: "C" },
-    { value: 90, numeral: "XC" },
-    { value: 50, numeral: "L" },
-    { value: 40, numeral: "XL" },
-    { value: 10, numeral: "X" },
-    { value: 9, numeral: "IX" },
-    { value: 5, numeral: "V" },
-    { value: 4, numeral: "IV" },
-    { value: 1, numeral: "I" }
-  ];
-  let result = "";
-  for (const { value, numeral } of romanNumeralMap) {
-    while (num >= value) {
-      result += numeral;
-      num -= value;
+function getUnderlineCssString({ type: type2 = "single", color = null, thickness = null, approximate = true } = {}) {
+  const parts = [];
+  const add = (k, v2) => {
+    if (!v2) return;
+    parts.push(`${k}: ${v2}`);
+  };
+  const lower = String(type2 || "single").toLowerCase();
+  if (lower === "none" || lower === "0") {
+    add("text-decoration", "none");
+    return parts.join("; ");
+  }
+  add("text-decoration-line", "underline");
+  const HEAVY = thickness || "0.2em";
+  const THICK = thickness || "0.15em";
+  switch (lower) {
+    case "single":
+      break;
+    case "double":
+      add("text-decoration-style", "double");
+      break;
+    case "thick":
+      add("text-decoration-thickness", THICK);
+      break;
+    case "dotted":
+      add("text-decoration-style", "dotted");
+      break;
+    case "dash":
+    case "dashed":
+      add("text-decoration-style", "dashed");
+      break;
+    case "dotdash":
+    case "dotdotdash":
+    case "dashlong":
+    case "dashlongheavy":
+      if (approximate) {
+        add("text-decoration-style", "dashed");
+        if (lower.includes("heavy")) add("text-decoration-thickness", HEAVY);
+      }
+      break;
+    case "dottedheavy":
+      add("text-decoration-style", "dotted");
+      add("text-decoration-thickness", HEAVY);
+      break;
+    case "dashedheavy":
+      add("text-decoration-style", "dashed");
+      add("text-decoration-thickness", HEAVY);
+      break;
+    case "wavy":
+      add("text-decoration-style", "wavy");
+      break;
+    case "wavyheavy":
+      add("text-decoration-style", "wavy");
+      add("text-decoration-thickness", HEAVY);
+      break;
+    case "wavydouble":
+      if (approximate) {
+        add("text-decoration-style", "wavy");
+        add("text-decoration-thickness", HEAVY);
+      }
+      break;
+  }
+  if (color) add("text-decoration-color", color);
+  return parts.join("; ");
+}
+function collectTextStyleMarks(listItem, markType) {
+  const textStyleMarks = [];
+  const seenMarks = /* @__PURE__ */ new Set();
+  const attrs = {};
+  if (!markType) {
+    return {
+      marks: textStyleMarks,
+      attrs
+    };
+  }
+  const collectMarks = (node) => {
+    if (!node) return;
+    const candidateMarks = Array.isArray(node.marks) ? node.marks : [];
+    if (candidateMarks.length && typeof markType.isInSet === "function" && markType.isInSet(candidateMarks)) {
+      candidateMarks.forEach((mark) => {
+        if (mark.type === markType && !seenMarks.has(mark)) {
+          seenMarks.add(mark);
+          textStyleMarks.push(mark);
+        }
+      });
+    }
+    if (!node.isText && node.childCount) {
+      node.forEach((child) => collectMarks(child));
+    }
+  };
+  listItem.forEach((childNode) => {
+    if (childNode.type?.name !== "paragraph") return;
+    if (childNode.attrs?.lineHeight !== void 0) {
+      attrs.lineHeight = childNode.attrs.lineHeight;
     }
+    collectMarks(childNode);
+  });
+  return {
+    marks: textStyleMarks,
+    attrs
+  };
+}
+function parseSizeFromRunProperties(listRunProperties) {
+  const val = listRunProperties?.["w:val"] || listRunProperties?.["w:sz"];
+  if (val == null) return null;
+  const numeric = Number(val);
+  if (Number.isNaN(numeric) || numeric <= 0) return null;
+  const sizeInPoints = numeric / 2;
+  return `${sizeInPoints}pt`;
+}
+function parseFontFamilyFromRunProperties(listRunProperties) {
+  const ascii = listRunProperties?.["w:ascii"];
+  const hAnsi = listRunProperties?.["w:hAnsi"];
+  const eastAsia = listRunProperties?.["w:eastAsia"];
+  return ascii || hAnsi || eastAsia || null;
+}
+function readNodeViewStyles(view) {
+  const fallback = { fontSize: null, fontFamily: null, lineHeight: null };
+  if (!view?.dom) return fallback;
+  const inline = {
+    fontSize: view.dom.style?.fontSize || null,
+    fontFamily: view.dom.style?.fontFamily || null,
+    lineHeight: view.dom.style?.lineHeight || null
+  };
+  if (inline.fontSize && inline.fontFamily && inline.lineHeight) return inline;
+  const globalWindow = typeof window !== "undefined" ? window : void 0;
+  if (globalWindow?.getComputedStyle) {
+    const computed2 = globalWindow.getComputedStyle(view.dom);
+    return {
+      fontSize: inline.fontSize || computed2.fontSize,
+      fontFamily: inline.fontFamily || computed2.fontFamily,
+      lineHeight: inline.lineHeight || computed2.lineHeight
+    };
   }
-  return result;
-};
-const intToAlpha = (num) => {
-  let result = "";
-  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  while (num > 0) {
-    let index2 = (num - 1) % 26;
-    result = alphabet[index2] + result;
-    num = Math.floor((num - 1) / 26);
+  return inline;
+}
+function getAdjacentListItemNodeView({ nodeView, pos, direction, activeNodeViews }) {
+  if (!activeNodeViews) return null;
+  let candidate = null;
+  activeNodeViews.forEach((view) => {
+    if (view === nodeView) return;
+    let viewPos;
+    try {
+      viewPos = view.getPos();
+    } catch {
+      return;
+    }
+    if (typeof viewPos !== "number") return;
+    if (viewPos < pos) {
+      if (!candidate || viewPos > candidate.pos) candidate = { view, pos: viewPos };
+    }
+  });
+  return candidate?.view ?? null;
+}
+function findSiblingListItem({ editor, pos, direction }) {
+  if (typeof pos !== "number" || !editor?.view) return null;
+  const { state: state2 } = editor.view;
+  const $pos = state2.doc.resolve(pos);
+  const parentDepth = $pos.depth - 1;
+  if (parentDepth < 0) return null;
+  const parent = $pos.node(parentDepth);
+  if (!parent) return null;
+  const indexInsideParent = $pos.index(parentDepth);
+  const siblingIndex = indexInsideParent + direction;
+  if (siblingIndex < 0 || siblingIndex >= parent.childCount) return null;
+  const sibling = parent.child(siblingIndex);
+  return sibling?.type?.name === "listItem" ? sibling : null;
+}
+function deriveFontStylesFromNode({ node, textStyleType, defaultFont, defaultSize, listRunProperties }) {
+  const { marks: allMarks, attrs } = collectTextStyleMarks(node, textStyleType);
+  const styleMarks = textStyleType ? allMarks.filter((m2) => m2.type === textStyleType) : [];
+  const sizeMark = styleMarks.find((m2) => m2.attrs?.fontSize);
+  const familyMark = styleMarks.find((m2) => m2.attrs?.fontFamily);
+  let fontSize2 = defaultSize;
+  if (sizeMark) {
+    const [value, unit = "pt"] = parseSizeUnit(sizeMark.attrs.fontSize);
+    if (!Number.isNaN(value)) {
+      fontSize2 = `${value}${unit}`;
+    }
   }
-  return result;
-};
-const intToJapaneseCounting = (num) => {
-  const digits = ["", "一", "二", "三", "四", "五", "六", "七", "八", "九"];
-  const units = ["", "十", "百", "千"];
-  if (num === 0) return "零";
-  if (num < 10) return digits[num];
-  let result = "";
-  let tempNum = num;
-  let unitIndex = 0;
-  while (tempNum > 0) {
-    const digit = tempNum % 10;
-    if (digit !== 0) {
-      const digitStr = digit === 1 && unitIndex > 0 ? "" : digits[digit];
-      result = digitStr + (unitIndex > 0 ? units[unitIndex] : "") + result;
-    } else if (result && tempNum > 0) {
-      if (!result.startsWith("零") && tempNum % 100 !== 0) {
-        result = "零" + result;
-      }
+  let hasSize = Boolean(sizeMark);
+  if (!hasSize && listRunProperties) {
+    const sizeFromList = parseSizeFromRunProperties(listRunProperties);
+    if (sizeFromList) {
+      fontSize2 = sizeFromList;
+      hasSize = true;
     }
-    tempNum = Math.floor(tempNum / 10);
-    unitIndex++;
-    if (unitIndex > 3) break;
   }
-  if (num >= 10 && num < 20) {
-    result = result.replace(/^一十/, "十");
+  let fontFamily2 = familyMark?.attrs?.fontFamily ?? defaultFont;
+  let hasFamily = Boolean(familyMark);
+  if (!hasFamily && listRunProperties) {
+    const fontFromList = parseFontFamilyFromRunProperties(listRunProperties);
+    if (fontFromList) {
+      fontFamily2 = fontFromList;
+      hasFamily = true;
+    }
   }
-  return result;
-};
+  let lineHeight2 = attrs.lineHeight;
+  const firstChild = node.firstChild;
+  const hasOnlyOnePar = node.childCount === 1 && firstChild?.type?.name === "paragraph";
+  if (hasOnlyOnePar) {
+    const par = firstChild;
+    const parFirstChild = par?.firstChild;
+    if (par?.childCount === 1 && parFirstChild?.type?.name === "fieldAnnotation") {
+      const aFontSize = parFirstChild.attrs?.fontSize;
+      const aFontFamily = parFirstChild.attrs?.fontFamily;
+      if (!sizeMark && aFontSize) fontSize2 = aFontSize;
+      if (!familyMark && aFontFamily) fontFamily2 = aFontFamily;
+    }
+  }
+  return {
+    fontSize: fontSize2,
+    fontFamily: fontFamily2,
+    lineHeight: lineHeight2,
+    hasSize,
+    hasFamily
+  };
+}
+function getStylesFromLinkedStyles({ node, pos, editor }) {
+  const { state: state2 } = editor.view;
+  const linkedStyles = LinkedStylesPluginKey.getState(state2)?.decorations;
+  const decorationsInPlace = linkedStyles?.find(pos, pos + node.nodeSize);
+  const predicates = [
+    (style22) => style22.includes("font-size") && style22.includes("font-family"),
+    (style22) => style22.includes("font-size"),
+    (style22) => style22.includes("font-family")
+  ];
+  let styleDeco;
+  for (const predicateFn of predicates) {
+    styleDeco = decorationsInPlace?.find((dec) => {
+      const style22 = dec.type?.attrs?.style || "";
+      return style22 && predicateFn(style22);
+    });
+    if (styleDeco) break;
+  }
+  const style2 = styleDeco?.type?.attrs?.style;
+  const stylesArray = style2?.split(";") || [];
+  const fontSizeFromStyles = stylesArray.find((s) => s.includes("font-size"))?.split(":")[1]?.trim();
+  const fontFamilyFromStyles = stylesArray.find((s) => s.includes("font-family"))?.split(":")[1]?.trim();
+  return {
+    font: fontFamilyFromStyles,
+    size: fontSizeFromStyles
+  };
+}
+function resolveListItemTypography({ node, pos, editor, nodeView, activeNodeViews }) {
+  const defaults = getStylesFromLinkedStyles({ node, pos, editor });
+  const textStyleType = getMarkType("textStyle", editor.schema);
+  const currentStyles = deriveFontStylesFromNode({
+    node,
+    textStyleType,
+    defaultFont: defaults.font,
+    defaultSize: defaults.size,
+    listRunProperties: node.attrs?.listRunProperties
+  });
+  if ((!currentStyles.hasSize || !currentStyles.hasFamily || !currentStyles.lineHeight) && editor?.view) {
+    const previousListItem = findSiblingListItem({ editor, pos, direction: -1 });
+    if (previousListItem) {
+      const previousStyles = deriveFontStylesFromNode({
+        node: previousListItem,
+        textStyleType,
+        defaultFont: defaults.font,
+        defaultSize: defaults.size,
+        listRunProperties: previousListItem.attrs?.listRunProperties
+      });
+      if (!currentStyles.hasSize && previousStyles.fontSize) currentStyles.fontSize = previousStyles.fontSize;
+      if (!currentStyles.hasFamily && previousStyles.fontFamily) currentStyles.fontFamily = previousStyles.fontFamily;
+      if (!currentStyles.lineHeight && previousStyles.lineHeight) currentStyles.lineHeight = previousStyles.lineHeight;
+    }
+  }
+  if ((!currentStyles.fontSize || !currentStyles.fontFamily || !currentStyles.lineHeight) && nodeView) {
+    const previousView = getAdjacentListItemNodeView({
+      nodeView,
+      pos,
+      direction: -1,
+      activeNodeViews
+    });
+    if (previousView) {
+      const {
+        fontSize: prevSize,
+        fontFamily: prevFamily,
+        lineHeight: prevLineHeight
+      } = readNodeViewStyles(previousView);
+      if (!currentStyles.fontSize && prevSize) currentStyles.fontSize = prevSize;
+      if (!currentStyles.fontFamily && prevFamily) currentStyles.fontFamily = prevFamily;
+      if (!currentStyles.lineHeight && prevLineHeight) currentStyles.lineHeight = prevLineHeight;
+    }
+  }
+  return {
+    fontSize: currentStyles.fontSize,
+    fontFamily: currentStyles.fontFamily,
+    lineHeight: currentStyles.lineHeight
+  };
+}
 const MARKER_PADDING = 6;
 const MARKER_OFFSET_RIGHT = 4;
 const MIN_MARKER_WIDTH = 20;
@@ -52625,8 +54478,8 @@ class ListItemNodeView {
     this.decorations = decorations;
     this.view = editor.view;
     this.getPos = getPos;
-    activeListItemNodeViews.add(this);
     __privateMethod$1(this, _ListItemNodeView_instances, init_fn2).call(this);
+    activeListItemNodeViews.add(this);
   }
   refreshIndentStyling() {
     const { attrs } = this.node;
@@ -52669,10 +54522,12 @@ class ListItemNodeView {
   update(node, decorations) {
     this.node = node;
     this.decorations = decorations;
-    const { fontSize: fontSize2, fontFamily: fontFamily2, lineHeight: lineHeight2 } = getTextStyleMarksFromLinkedStyles({
+    const { fontSize: fontSize2, fontFamily: fontFamily2, lineHeight: lineHeight2 } = resolveListItemTypography({
       node,
       pos: this.getPos(),
-      editor: this.editor
+      editor: this.editor,
+      nodeView: this,
+      activeNodeViews: activeListItemNodeViews
     });
     this.dom.style.fontSize = fontSize2;
     this.dom.style.fontFamily = fontFamily2 || "inherit";
@@ -52701,10 +54556,12 @@ init_fn2 = function() {
     }
   }
   const pos = this.getPos();
-  const { fontSize: fontSize2, fontFamily: fontFamily2, lineHeight: lineHeight2 } = getTextStyleMarksFromLinkedStyles({
+  const { fontSize: fontSize2, fontFamily: fontFamily2, lineHeight: lineHeight2 } = resolveListItemTypography({
     node: this.node,
     pos,
-    editor: this.editor
+    editor: this.editor,
+    nodeView: this,
+    activeNodeViews: activeListItemNodeViews
   });
   this.dom = document.createElement("li");
   this.dom.className = "sd-editor-list-item-node-view";
@@ -52737,79 +54594,6 @@ function refreshAllListItemNodeViews() {
     }
   });
 }
-function getListItemTextStyleMarks(listItem, markType) {
-  let textStyleMarks = [];
-  let attrs = {};
-  listItem.forEach((childNode) => {
-    if (childNode.type.name !== "paragraph") return;
-    attrs.lineHeight = childNode.attrs.lineHeight;
-    childNode.forEach((textNode) => {
-      let isTextNode = textNode.type.name === "text";
-      let hasTextStyleMarks = markType.isInSet(textNode.marks);
-      if (isTextNode && hasTextStyleMarks) {
-        let marks = textNode.marks.filter((mark) => mark.type === markType);
-        textStyleMarks.push(...marks);
-      }
-    });
-  });
-  return {
-    marks: textStyleMarks,
-    attrs
-  };
-}
-function getTextStyleMarksFromLinkedStyles({ node, pos, editor }) {
-  const { font: defaultFont, size: defaultSize } = getStylesFromLinkedStyles({ node, pos, editor });
-  const textStyleType = getMarkType("textStyle", editor.schema);
-  const { marks: allMarks, attrs: allAttrs } = getListItemTextStyleMarks(node, textStyleType);
-  const styleMarks = allMarks.filter((m2) => m2.type === textStyleType);
-  const sizeMark = styleMarks.find((m2) => m2.attrs.fontSize);
-  const familyMark = styleMarks.find((m2) => m2.attrs.fontFamily);
-  const lineHeight2 = allAttrs.lineHeight;
-  let fontSize2 = sizeMark ? (() => {
-    const [value, unit = "pt"] = parseSizeUnit(sizeMark.attrs.fontSize);
-    return Number.isNaN(value) ? defaultSize : `${value}${unit}`;
-  })() : defaultSize;
-  let fontFamily2 = familyMark?.attrs.fontFamily ?? defaultFont;
-  const firstChild = node.firstChild;
-  const hasOnlyOnePar = node.childCount === 1 && firstChild?.type.name === "paragraph";
-  if (hasOnlyOnePar) {
-    const par = firstChild;
-    const parFirstChild = par?.firstChild;
-    if (par?.childCount === 1 && parFirstChild?.type.name === "fieldAnnotation") {
-      const aFontSize = parFirstChild.attrs.fontSize;
-      const aFontFamily = parFirstChild.attrs.fontFamily;
-      if (!sizeMark && aFontSize) fontSize2 = aFontSize;
-      if (!familyMark && aFontFamily) fontFamily2 = aFontFamily;
-    }
-  }
-  return { fontSize: fontSize2, fontFamily: fontFamily2, lineHeight: lineHeight2 };
-}
-const getStylesFromLinkedStyles = ({ node, pos, editor }) => {
-  const { state: state2 } = editor.view;
-  const linkedStyles = LinkedStylesPluginKey.getState(state2)?.decorations;
-  const decorationsInPlace = linkedStyles?.find(pos, pos + node.nodeSize);
-  const predicates = [
-    (style22) => style22.includes("font-size") && style22.includes("font-family"),
-    (style22) => style22.includes("font-size"),
-    (style22) => style22.includes("font-family")
-  ];
-  let styleDeco;
-  for (const predicateFn of predicates) {
-    styleDeco = decorationsInPlace?.find((dec) => {
-      const style22 = dec.type.attrs?.style || "";
-      return style22 && predicateFn(style22);
-    });
-    if (styleDeco) break;
-  }
-  const style2 = styleDeco?.type.attrs?.style;
-  const stylesArray = style2?.split(";") || [];
-  const fontSizeFromStyles = stylesArray.find((s) => s.includes("font-size"))?.split(":")[1].trim();
-  const fontFamilyFromStyles = stylesArray.find((s) => s.includes("font-family"))?.split(":")[1].trim();
-  return {
-    font: fontFamilyFromStyles,
-    size: fontSizeFromStyles
-  };
-};
 const getVisibleIndent = (stylePpr, numDefPpr, inlineIndent) => {
   const styleIndentTag = stylePpr?.elements?.find((el) => el.name === "w:ind") || {};
   const styleIndent = parseIndentElement(styleIndentTag);
@@ -53543,6 +55327,211 @@ const CommentsMark = Mark2.create({
     return [CommentMarkName, Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes)];
   }
 });
+const defaultTabDistance = 48;
+const defaultLineLength = 816;
+const getTabDecorations = (doc2, view, from2 = 0, to = null) => {
+  const decorations = [];
+  const paragraphCache = /* @__PURE__ */ new Map();
+  const end2 = to ?? doc2.content.size;
+  doc2.nodesBetween(from2, end2, (node, pos) => {
+    if (node.type.name !== "tab") return;
+    let extraStyles = "";
+    const $pos = doc2.resolve(pos);
+    const paragraphContext = getParagraphContext($pos, paragraphCache);
+    if (!paragraphContext) return;
+    try {
+      const { tabStops, flattened, startPos } = paragraphContext;
+      const entryIndex = flattened.findIndex((entry) => entry.pos === pos);
+      if (entryIndex === -1) return;
+      const indentWidth = getIndentWidth(view, startPos, paragraphContext.indent);
+      const accumulatedTabWidth = paragraphContext.accumulatedTabWidth || 0;
+      const currentWidth = indentWidth + measureRangeWidth(view, startPos + 1, pos) + accumulatedTabWidth;
+      let tabWidth;
+      if (tabStops.length) {
+        const tabStop = tabStops.find((stop) => stop.pos > currentWidth && stop.val !== "clear");
+        if (tabStop) {
+          tabWidth = tabStop.pos - currentWidth;
+          if (tabStop.val === "center" || tabStop.val === "end" || tabStop.val === "right") {
+            const nextTabIndex = findNextTabIndex(flattened, entryIndex + 1);
+            const segmentStartPos = pos + node.nodeSize;
+            const segmentEndPos = nextTabIndex === -1 ? startPos + paragraphContext.paragraph.nodeSize - 1 : flattened[nextTabIndex].pos;
+            const segmentWidth = measureRangeWidth(view, segmentStartPos, segmentEndPos);
+            tabWidth -= tabStop.val === "center" ? segmentWidth / 2 : segmentWidth;
+          } else if (tabStop.val === "decimal" || tabStop.val === "num") {
+            const breakChar = tabStop.decimalChar || ".";
+            const decimalPos = findDecimalBreakPos(flattened, entryIndex + 1, breakChar);
+            const integralWidth = decimalPos ? measureRangeWidth(view, pos + node.nodeSize, decimalPos) : measureRangeWidth(view, pos + node.nodeSize, startPos + paragraphContext.paragraph.nodeSize - 1);
+            tabWidth -= integralWidth;
+          }
+          if (tabStop.leader) {
+            const leaderStyles = {
+              dot: "border-bottom: 1px dotted black;",
+              heavy: "border-bottom: 2px solid black;",
+              hyphen: "border-bottom: 1px solid black;",
+              middleDot: "border-bottom: 1px dotted black; margin-bottom: 2px;",
+              underscore: "border-bottom: 1px solid black;"
+            };
+            extraStyles += leaderStyles[tabStop.leader] || "";
+          }
+        }
+      }
+      if (!tabWidth || tabWidth < 1) {
+        tabWidth = defaultTabDistance - currentWidth % defaultLineLength % defaultTabDistance;
+        if (tabWidth === 0) tabWidth = defaultTabDistance;
+      }
+      const tabHeight = calcTabHeight($pos);
+      decorations.push(
+        Decoration.node(pos, pos + node.nodeSize, {
+          style: `width: ${tabWidth}px; height: ${tabHeight};${extraStyles}`
+        })
+      );
+      paragraphContext.accumulatedTabWidth = accumulatedTabWidth + tabWidth;
+    } catch (error) {
+      console.error("tab decoration error", error);
+    }
+  });
+  return decorations;
+};
+function getParagraphContext($pos, cache2) {
+  for (let depth = $pos.depth; depth >= 0; depth--) {
+    const node = $pos.node(depth);
+    if (node?.type?.name === "paragraph") {
+      const startPos = $pos.start(depth);
+      if (!cache2.has(startPos)) {
+        cache2.set(startPos, {
+          paragraph: node,
+          paragraphDepth: depth,
+          startPos,
+          indent: node.attrs?.indent || {},
+          tabStops: Array.isArray(node.attrs?.tabStops) ? node.attrs.tabStops : [],
+          flattened: flattenParagraph(node, startPos),
+          accumulatedTabWidth: 0
+        });
+      }
+      return cache2.get(startPos);
+    }
+  }
+  return null;
+}
+function flattenParagraph(paragraph, paragraphStartPos) {
+  const entries = [];
+  const walk = (node, basePos) => {
+    if (!node) return;
+    if (node.type?.name === "run") {
+      node.forEach((child, offset2) => {
+        const childPos = basePos + offset2 + 1;
+        walk(child, childPos);
+      });
+      return;
+    }
+    entries.push({ node, pos: basePos - 1 });
+  };
+  paragraph.forEach((child, offset2) => {
+    const childPos = paragraphStartPos + offset2 + 1;
+    walk(child, childPos);
+  });
+  return entries;
+}
+function findNextTabIndex(flattened, fromIndex) {
+  for (let i = fromIndex; i < flattened.length; i++) {
+    if (flattened[i]?.node?.type?.name === "tab") {
+      return i;
+    }
+  }
+  return -1;
+}
+function findDecimalBreakPos(flattened, startIndex, breakChar) {
+  for (let i = startIndex; i < flattened.length; i++) {
+    const entry = flattened[i];
+    if (!entry) break;
+    if (entry.node.type?.name === "tab") break;
+    if (entry.node.type?.name === "text") {
+      const index2 = entry.node.text?.indexOf(breakChar);
+      if (index2 !== void 0 && index2 !== -1) {
+        return entry.pos + index2 + 1;
+      }
+    }
+  }
+  return null;
+}
+function measureRangeWidth(view, from2, to) {
+  if (!Number.isFinite(from2) || !Number.isFinite(to) || to <= from2) return 0;
+  try {
+    const range2 = document.createRange();
+    const fromRef = view.domAtPos(from2);
+    const toRef2 = view.domAtPos(to);
+    range2.setStart(fromRef.node, fromRef.offset);
+    range2.setEnd(toRef2.node, toRef2.offset);
+    const rect = range2.getBoundingClientRect();
+    range2.detach?.();
+    return rect.width || 0;
+  } catch {
+    const startLeft = getLeftCoord(view, from2);
+    const endLeft = getLeftCoord(view, to);
+    if (startLeft == null || endLeft == null) return 0;
+    return Math.max(0, endLeft - startLeft);
+  }
+}
+function getIndentWidth(view, paragraphStartPos, indentAttrs = {}) {
+  const marginLeft = getLeftCoord(view, paragraphStartPos);
+  const lineLeft = getLeftCoord(view, paragraphStartPos + 1);
+  if (marginLeft != null && lineLeft != null) {
+    const diff = lineLeft - marginLeft;
+    if (!Number.isNaN(diff) && Math.abs(diff) > 0.5) {
+      return diff;
+    }
+  }
+  return calculateIndentFallback(indentAttrs);
+}
+function calculateIndentFallback(indentAttrs = {}) {
+  if (!indentAttrs) return 0;
+  const left2 = Number(indentAttrs.left) || 0;
+  const firstLine = Number(indentAttrs.firstLine) || 0;
+  const hanging = Number(indentAttrs.hanging) || 0;
+  let textIndent = 0;
+  if (firstLine && hanging) {
+    textIndent = firstLine - hanging;
+  } else if (firstLine) {
+    textIndent = firstLine;
+  } else if (hanging) {
+    textIndent = -hanging;
+  } else if (typeof indentAttrs.textIndent === "string") {
+    const match = indentAttrs.textIndent.match(/(-?\d*\.?\d+)in$/);
+    if (match) {
+      textIndent = Number(match[1]) * 96;
+    }
+  }
+  if (textIndent) return left2 + textIndent;
+  if (left2) return left2;
+  return 0;
+}
+function getLeftCoord(view, pos) {
+  if (!Number.isFinite(pos)) return null;
+  try {
+    return view.coordsAtPos(pos).left;
+  } catch {
+    try {
+      const ref2 = view.domAtPos(pos);
+      const range2 = document.createRange();
+      range2.setStart(ref2.node, ref2.offset);
+      range2.setEnd(ref2.node, ref2.offset);
+      const rect = range2.getBoundingClientRect();
+      range2.detach?.();
+      return rect.left;
+    } catch {
+      return null;
+    }
+  }
+}
+function calcTabHeight(pos) {
+  const ptToPxRatio = 1.333;
+  const defaultFontSize = 16;
+  const defaultLineHeight = 1.1;
+  const blockParent2 = pos.node(1);
+  const parentTextStyleMark = blockParent2.firstChild.marks.find((mark) => mark.type.name === "textStyle");
+  const fontSize2 = parseInt(parentTextStyleMark?.attrs.fontSize) * ptToPxRatio || defaultFontSize;
+  return `${fontSize2 * defaultLineHeight}px`;
+}
 const TabNode = Node$1.create({
   name: "tab",
   group: "inline",
@@ -53580,8 +55569,7 @@ const TabNode = Node$1.create({
     };
   },
   addPmPlugins() {
-    const { view, schema } = this.editor;
-    const domSerializer = DOMSerializer.fromSchema(schema);
+    const { view } = this.editor;
     const tabPlugin = new Plugin({
       name: "tabPlugin",
       key: new PluginKey("tabPlugin"),
@@ -53591,10 +55579,7 @@ const TabNode = Node$1.create({
         },
         apply(tr, { decorations }, _oldState, newState) {
           if (!decorations) {
-            decorations = DecorationSet.create(
-              newState.doc,
-              getTabDecorations(newState.doc, StepMap.empty, view, domSerializer)
-            );
+            decorations = DecorationSet.create(newState.doc, getTabDecorations(newState.doc, view));
           }
           if (!tr.docChanged) {
             return { decorations };
@@ -53634,8 +55619,7 @@ const TabNode = Node$1.create({
           rangesToRecalculate.forEach(([start2, end2]) => {
             const oldDecorations = decorations.find(start2, end2);
             decorations = decorations.remove(oldDecorations);
-            const invertMapping = tr.mapping.invert();
-            const newDecorations = getTabDecorations(newState.doc, invertMapping, view, domSerializer, start2, end2);
+            const newDecorations = getTabDecorations(newState.doc, view, start2, end2);
             decorations = decorations.add(newState.doc, newDecorations);
           });
           return { decorations };
@@ -53650,156 +55634,6 @@ const TabNode = Node$1.create({
     return [tabPlugin];
   }
 });
-const defaultTabDistance = 48;
-const defaultLineLength = 816;
-const getTabDecorations = (doc2, invertMapping, view, domSerializer, from2 = 0, to = null) => {
-  if (!to) {
-    to = doc2.content.size;
-  }
-  const nodeWidthCache = {};
-  let decorations = [];
-  doc2.nodesBetween(from2, to, (node, pos, parent) => {
-    if (node.type.name === "tab") {
-      let extraStyles = "";
-      const $pos = doc2.resolve(pos);
-      const tabIndex = $pos.index($pos.depth);
-      const fistlineIndent = parent.attrs?.indent?.firstLine || 0;
-      const currentWidth = calcChildNodesWidth(
-        parent,
-        pos - $pos.parentOffset,
-        0,
-        tabIndex,
-        domSerializer,
-        view,
-        invertMapping,
-        nodeWidthCache
-      ) + fistlineIndent;
-      let tabWidth;
-      if ($pos.depth === 1 && parent.attrs.tabStops && parent.attrs.tabStops.length > 0) {
-        const tabStop = parent.attrs.tabStops.find((tabStop2) => tabStop2.pos > currentWidth && tabStop2.val !== "clear");
-        if (tabStop) {
-          tabWidth = tabStop.pos - currentWidth;
-          if (["end", "center"].includes(tabStop.val)) {
-            let nextTabIndex = tabIndex + 1;
-            while (nextTabIndex < parent.childCount && parent.child(nextTabIndex).type.name !== "tab") {
-              nextTabIndex++;
-            }
-            const tabSectionWidth = calcChildNodesWidth(
-              parent,
-              pos - $pos.parentOffset,
-              tabIndex,
-              nextTabIndex,
-              domSerializer,
-              view,
-              invertMapping,
-              nodeWidthCache
-            );
-            tabWidth -= tabStop.val === "end" ? tabSectionWidth : tabSectionWidth / 2;
-          } else if (["decimal", "num"].includes(tabStop.val)) {
-            const breakChar = ".";
-            let nodeIndex = tabIndex + 1;
-            let integralWidth = 0;
-            let nodePos = pos - $pos.parentOffset;
-            while (nodeIndex < parent.childCount) {
-              const node2 = parent.child(nodeIndex);
-              if (node2.type.name === "tab") {
-                break;
-              }
-              const oldPos = invertMapping.map(nodePos);
-              if (node2.type.name === "text" && node2.text.includes(breakChar)) {
-                const modifiedNode = node2.cut(0, node2.text.indexOf(breakChar));
-                integralWidth += calcNodeWidth(domSerializer, modifiedNode, view, oldPos);
-                break;
-              }
-              integralWidth += calcNodeWidth(domSerializer, node2, view, oldPos);
-              nodeWidthCache[nodePos] = integralWidth;
-              nodePos += node2.nodeSize;
-              nodeIndex += 1;
-            }
-            tabWidth -= integralWidth;
-          }
-          if (tabStop.leader) {
-            if (tabStop.leader === "dot") {
-              extraStyles += `border-bottom: 1px dotted black;`;
-            } else if (tabStop.leader === "heavy") {
-              extraStyles += `border-bottom: 2px solid black;`;
-            } else if (tabStop.leader === "hyphen") {
-              extraStyles += `border-bottom: 1px solid black;`;
-            } else if (tabStop.leader === "middleDot") {
-              extraStyles += `border-bottom: 1px dotted black; margin-bottom: 2px;`;
-            } else if (tabStop.leader === "underscore") {
-              extraStyles += `border-bottom: 1px solid black;`;
-            }
-          }
-        }
-      }
-      if (!tabWidth || tabWidth < 1) {
-        tabWidth = defaultTabDistance - currentWidth % defaultLineLength % defaultTabDistance;
-        if (tabWidth === 0) {
-          tabWidth = defaultTabDistance;
-        }
-      }
-      nodeWidthCache[pos] = tabWidth;
-      const tabHeight = calcTabHeight($pos);
-      decorations.push(
-        Decoration.node(pos, pos + node.nodeSize, {
-          style: `width: ${tabWidth}px; height: ${tabHeight};${extraStyles}`
-        })
-      );
-    }
-  });
-  return decorations;
-};
-function calcNodeWidth(domSerializer, node, view, oldPos) {
-  const oldDomNode = view.nodeDOM(oldPos);
-  const styleReference = oldDomNode ? oldDomNode.nodeName === "#text" ? oldDomNode.parentNode : oldDomNode : view.dom;
-  const temp = document.createElement("div");
-  const style2 = window.getComputedStyle(styleReference);
-  temp.style.cssText = `
-        position: absolute;
-        top: -9999px;
-        left: -9999px;
-        white-space: nowrap;
-        font-family: ${style2.fontFamily};
-        font-size: ${style2.fontSize};
-        font-weight: ${style2.fontWeight};
-        font-style: ${style2.fontStyle};
-        letter-spacing: ${style2.letterSpacing};
-        word-spacing: ${style2.wordSpacing};
-        text-transform: ${style2.textTransform};
-        display: inline-block;
-    `;
-  const domNode = domSerializer.serializeNode(node);
-  temp.appendChild(domNode);
-  document.body.appendChild(temp);
-  const width = temp.offsetWidth;
-  document.body.removeChild(temp);
-  return width;
-}
-function calcChildNodesWidth(parent, parentPos, startIndex, endIndex, domSerializer, view, invertMapping, nodeWidthCache) {
-  let pos = parentPos;
-  let width = 0;
-  for (let i = 0; i < endIndex; i++) {
-    const node = parent.child(i);
-    if (i >= startIndex) {
-      if (!nodeWidthCache[pos]) {
-        nodeWidthCache[pos] = calcNodeWidth(domSerializer, node, view, invertMapping.map(pos));
-      }
-      width += nodeWidthCache[pos];
-    }
-    pos += node.nodeSize;
-  }
-  return width;
-}
-function calcTabHeight(pos) {
-  const ptToPxRatio = 1.333;
-  const defaultFontSize = 16;
-  const defaultLineHeight = 1.1;
-  const blockParent2 = pos.node(1);
-  const parentTextStyleMark = blockParent2.firstChild.marks.find((mark) => mark.type.name === "textStyle");
-  const fontSize2 = parseInt(parentTextStyleMark?.attrs.fontSize) * ptToPxRatio || defaultFontSize;
-  return `${fontSize2 * defaultLineHeight}px`;
-}
 const LineBreak = Node$1.create({
   name: "lineBreak",
   group: "inline",
@@ -59466,10 +61300,10 @@ const Image = Node$1.create({
       },
       padding: {
         default: {},
-        renderDOM: ({ size: size2 = {}, padding, marginOffset, transformData }) => {
+        renderDOM: ({ size: size2 = {}, padding, marginOffset, transformData = {} }) => {
           let { left: left2 = 0, top: top2 = 0, bottom: bottom2 = 0, right: right2 = 0 } = padding ?? {};
-          const { rotation } = transformData ?? {};
-          const { height, width } = size2 ?? {};
+          const { rotation } = transformData;
+          const { height, width } = size2;
           if (rotation && height && width) {
             const { horizontal, vertical } = getRotationMargins(width, height, rotation);
             left2 += horizontal;
@@ -61260,6 +63094,30 @@ const TextStyle = Mark2.create({
     };
   }
 });
+function createCascadeToggleCommands({
+  markName,
+  setCommand,
+  unsetCommand,
+  toggleCommand,
+  negationAttrs,
+  isNegation,
+  extendEmptyMarkRange
+} = {}) {
+  if (!markName) throw new Error("createCascadeToggleCommands requires a markName");
+  const capitalized = markName.charAt(0).toUpperCase() + markName.slice(1);
+  const setName = setCommand ?? `set${capitalized}`;
+  const unsetName = unsetCommand ?? `unset${capitalized}`;
+  const toggleName = toggleCommand ?? `toggle${capitalized}`;
+  const cascadeOptions = {};
+  if (negationAttrs) cascadeOptions.negationAttrs = negationAttrs;
+  if (typeof isNegation === "function") cascadeOptions.isNegation = isNegation;
+  if (extendEmptyMarkRange !== void 0) cascadeOptions.extendEmptyMarkRange = extendEmptyMarkRange;
+  return {
+    [setName]: () => ({ commands: commands2 }) => commands2.setMark(markName),
+    [unsetName]: () => ({ commands: commands2 }) => commands2.unsetMark(markName),
+    [toggleName]: () => ({ commands: commands2 }) => commands2.toggleMarkCascade(markName, cascadeOptions)
+  };
+}
 const Bold = Mark2.create({
   name: "bold",
   addOptions() {
@@ -61290,9 +63148,18 @@ const Bold = Mark2.create({
     ];
   },
   renderDOM({ htmlAttributes }) {
-    return ["strong", Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+    const merged = Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+    const { value, ...rest } = merged || {};
+    if (value === "0") {
+      return ["span", rest, 0];
+    }
+    return ["strong", rest, 0];
   },
   addCommands() {
+    const { setBold, unsetBold, toggleBold } = createCascadeToggleCommands({
+      markName: this.name,
+      negationAttrs: { value: "0" }
+    });
     return {
       /**
        * Apply bold formatting
@@ -61301,21 +63168,21 @@ const Bold = Mark2.create({
        * editor.commands.setBold()
        * @note '0' renders as normal weight
        */
-      setBold: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+      setBold,
       /**
        * Remove bold formatting
        * @category Command
        * @example
        * editor.commands.unsetBold()
        */
-      unsetBold: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+      unsetBold,
       /**
        * Toggle bold formatting
        * @category Command
        * @example
        * editor.commands.toggleBold()
        */
-      toggleBold: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+      toggleBold
     };
   },
   addShortcuts() {
@@ -61332,6 +63199,22 @@ const Italic = Mark2.create({
       htmlAttributes: {}
     };
   },
+  addAttributes() {
+    return {
+      /**
+       * @category Attribute
+       * @param {string} [value] - Italic toggle value ('0' renders as normal)
+       */
+      value: {
+        default: null,
+        renderDOM: (attrs) => {
+          if (!attrs.value) return {};
+          if (attrs.value === "0") return { style: "font-style: normal" };
+          return {};
+        }
+      }
+    };
+  },
   parseDOM() {
     return [
       { tag: "i" },
@@ -61341,9 +63224,18 @@ const Italic = Mark2.create({
     ];
   },
   renderDOM({ htmlAttributes }) {
-    return ["em", Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+    const merged = Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+    const { value, ...rest } = merged || {};
+    if (value === "0") {
+      return ["span", rest, 0];
+    }
+    return ["em", rest, 0];
   },
   addCommands() {
+    const { setItalic, unsetItalic, toggleItalic } = createCascadeToggleCommands({
+      markName: this.name,
+      negationAttrs: { value: "0" }
+    });
     return {
       /**
        * Apply italic formatting
@@ -61351,21 +63243,21 @@ const Italic = Mark2.create({
        * @example
        * editor.commands.setItalic()
        */
-      setItalic: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+      setItalic,
       /**
        * Remove italic formatting
        * @category Command
        * @example
        * editor.commands.unsetItalic()
        */
-      unsetItalic: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+      unsetItalic,
       /**
        * Toggle italic formatting
        * @category Command
        * @example
        * editor.commands.toggleItalic()
        */
-      toggleItalic: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+      toggleItalic
     };
   },
   addShortcuts() {
@@ -61390,7 +63282,16 @@ const Underline = Mark2.create({
     ];
   },
   renderDOM({ htmlAttributes }) {
-    return ["u", Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+    const merged = Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+    const type2 = merged?.underlineType;
+    const color = merged?.underlineColor;
+    const css = getUnderlineCssString({ type: type2, color });
+    const { style: style2, ...rest } = merged || {};
+    const styleString = [style2, css].filter(Boolean).join("; ");
+    if (type2 === "none") {
+      return ["span", { ...rest, ...styleString ? { style: styleString } : {} }, 0];
+    }
+    return ["u", { ...rest, ...styleString ? { style: styleString } : {} }, 0];
   },
   addAttributes() {
     return {
@@ -61400,10 +63301,18 @@ const Underline = Mark2.create({
        */
       underlineType: {
         default: "single"
+      },
+      underlineColor: {
+        default: null
       }
     };
   },
   addCommands() {
+    const { setUnderline, unsetUnderline, toggleUnderline } = createCascadeToggleCommands({
+      markName: this.name,
+      negationAttrs: { underlineType: "none" },
+      isNegation: (attrs) => attrs?.underlineType === "none"
+    });
     return {
       /**
        * Apply underline formatting
@@ -61412,7 +63321,7 @@ const Underline = Mark2.create({
        * @example
        * setUnderline()
        */
-      setUnderline: () => ({ commands: commands2 }) => commands2.setMark(this.name),
+      setUnderline,
       /**
        * Remove underline formatting
        * @category Command
@@ -61420,7 +63329,7 @@ const Underline = Mark2.create({
        * @example
        * unsetUnderline()
        */
-      unsetUnderline: () => ({ commands: commands2 }) => commands2.unsetMark(this.name),
+      unsetUnderline,
       /**
        * Toggle underline formatting
        * @category Command
@@ -61428,7 +63337,7 @@ const Underline = Mark2.create({
        * @example
        * toggleUnderline()
        */
-      toggleUnderline: () => ({ commands: commands2 }) => commands2.toggleMark(this.name)
+      toggleUnderline
     };
   },
   addShortcuts() {
@@ -61516,9 +63425,18 @@ const Strike = Mark2.create({
     ];
   },
   renderDOM({ htmlAttributes }) {
-    return ["s", Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes), 0];
+    const merged = Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
+    const { value, ...rest } = merged || {};
+    if (value === "0") {
+      return ["span", rest, 0];
+    }
+    return ["s", rest, 0];
   },
   addCommands() {
+    const { setStrike, unsetStrike, toggleStrike } = createCascadeToggleCommands({
+      markName: this.name,
+      negationAttrs: { value: "0" }
+    });
     return {
       /**
        * Apply strikethrough formatting
@@ -61526,26 +63444,38 @@ const Strike = Mark2.create({
        * @example
        * editor.commands.setStrike()
        */
-      setStrike: () => ({ commands: commands2 }) => {
-        return commands2.setMark(this.name);
-      },
+      setStrike,
       /**
        * Remove strikethrough formatting
        * @category Command
        * @example
        * editor.commands.unsetStrike()
        */
-      unsetStrike: () => ({ commands: commands2 }) => {
-        return commands2.unsetMark(this.name);
-      },
+      unsetStrike,
       /**
        * Toggle strikethrough formatting
        * @category Command
        * @example
        * editor.commands.toggleStrike()
        */
-      toggleStrike: () => ({ commands: commands2 }) => {
-        return commands2.toggleMark(this.name);
+      toggleStrike
+    };
+  },
+  addAttributes() {
+    return {
+      /**
+       * @category Attribute
+       * @param {string} [value] - Strike toggle value ('0' renders as normal)
+       */
+      value: {
+        default: null,
+        renderDOM: (attrs) => {
+          if (!attrs.value) return {};
+          if (attrs.value === "0") {
+            return { style: "text-decoration: none" };
+          }
+          return {};
+        }
       }
     };
   },
@@ -67686,7 +69616,7 @@ const getStarterExtensions = () => {
     Paragraph,
     LineBreak,
     HardBreak,
-    RunItem,
+    Run,
     SlashMenu,
     Strike,
     TabNode,
@@ -80914,6 +82844,38 @@ const toolbarTexts = {
   documentViewingModeDescription: "View clean version of document only",
   linkedStyles: "Linked styles"
 };
+const isOffValue = (value) => {
+  if (value == null) return false;
+  const normalized = String(value).toLowerCase();
+  return normalized === "0" || normalized === "false" || normalized === "off";
+};
+const negationChecks = {
+  bold: (attrs = {}) => isOffValue(attrs.value),
+  italic: (attrs = {}) => isOffValue(attrs.value),
+  strike: (attrs = {}) => isOffValue(attrs.value),
+  underline: (attrs = {}) => {
+    const type2 = attrs.underlineType ?? attrs.value;
+    if (type2 == null) return false;
+    const normalized = String(type2).toLowerCase();
+    return normalized === "none" || isOffValue(normalized);
+  },
+  color: (attrs = {}) => {
+    const value = attrs.color;
+    if (value == null) return true;
+    return String(value).toLowerCase() === "inherit";
+  },
+  highlight: (attrs = {}) => {
+    const value = attrs.color;
+    if (value == null) return true;
+    const normalized = String(value).toLowerCase();
+    return normalized === "transparent" || normalized === "none";
+  }
+};
+const isNegatedMark = (name, attrs = {}) => {
+  const checker = negationChecks[name];
+  if (typeof checker !== "function") return false;
+  return Boolean(checker(attrs));
+};
 class SuperToolbar extends EventEmitter2 {
   /**
    * Creates a new SuperToolbar instance
@@ -81007,10 +82969,14 @@ class SuperToolbar extends EventEmitter2 {
        * @param {string} params.argument - The color to set
        * @returns {void}
        */
-      setColor: ({ item, argument }) => {
-        __privateMethod(this, _SuperToolbar_instances, runCommandWithArgumentOnly_fn).call(this, { item, argument }, () => {
-          this.activeEditor?.commands.setFieldAnnotationsTextColor(argument, true);
-        });
+      setColor: ({ argument }) => {
+        if (!argument || !this.activeEditor) return;
+        const isNone = argument === "none";
+        const value = isNone ? "inherit" : argument;
+        if (this.activeEditor?.commands?.setColor) this.activeEditor.commands.setColor(value);
+        const argValue = isNone ? null : argument;
+        this.activeEditor?.commands.setFieldAnnotationsTextColor(argValue, true);
+        this.updateToolbarState();
       },
       /**
        * Sets the highlight color for text
@@ -81019,12 +82985,14 @@ class SuperToolbar extends EventEmitter2 {
        * @param {string} params.argument - The highlight color to set
        * @returns {void}
        */
-      setHighlight: ({ item, argument }) => {
-        __privateMethod(this, _SuperToolbar_instances, runCommandWithArgumentOnly_fn).call(this, { item, argument, noArgumentCallback: true }, () => {
-          let arg = argument !== "none" ? argument : null;
-          this.activeEditor?.commands.setFieldAnnotationsTextHighlight(arg, true);
-          this.activeEditor?.commands.setCellBackground(arg);
-        });
+      setHighlight: ({ argument }) => {
+        if (!argument || !this.activeEditor) return;
+        const inlineColor = argument !== "none" ? argument : "transparent";
+        if (this.activeEditor?.commands?.setHighlight) this.activeEditor.commands.setHighlight(inlineColor);
+        const argValue = argument !== "none" ? argument : null;
+        this.activeEditor?.commands.setFieldAnnotationsTextHighlight(argValue, true);
+        this.activeEditor?.commands.setCellBackground(argValue);
+        this.updateToolbarState();
       },
       /**
        * Toggles the ruler visibility
@@ -81341,14 +83309,16 @@ class SuperToolbar extends EventEmitter2 {
           return item.activate();
         }
       }
-      const activeMark = marks.find((mark) => mark.name === item.name.value);
+      const rawActiveMark = marks.find((mark) => mark.name === item.name.value);
+      const markNegated = rawActiveMark ? isNegatedMark(rawActiveMark.name, rawActiveMark.attrs) : false;
+      const activeMark = markNegated ? null : rawActiveMark;
       if (activeMark) {
         item.activate(activeMark.attrs);
       } else {
         item.deactivate();
       }
       const styleIdMark = marks.find((mark) => mark.name === "styleId");
-      if (!activeMark && styleIdMark?.attrs.styleId) {
+      if (!activeMark && !markNegated && styleIdMark?.attrs.styleId) {
         const markToStyleMap = {
           fontSize: "font-size",
           fontFamily: "font-family",
@@ -81406,7 +83376,6 @@ class SuperToolbar extends EventEmitter2 {
     if (!command2) {
       return;
     }
-    this.log("(emmitCommand) Command:", command2, "\n	item:", item, "\n	argument:", argument, "\n	option:", option);
     if (command2 in __privateGet(this, _interceptedCommands)) {
       return __privateGet(this, _interceptedCommands)[command2]({ item, argument });
     }
@@ -82969,6 +84938,36 @@ const _sfc_main = {
   }
 };
 const SuperInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4d5cff52"]]);
+const baseHandlers = {
+  ...runPropertyTranslators,
+  "w:br": translator$15,
+  "w:cantSplit": translator$S,
+  "w:cnfStyle": translator$R,
+  "w:divId": translator$Q,
+  "w:gridAfter": translator$P,
+  "w:gridBefore": translator$O,
+  "w:hidden": translator$N,
+  "w:hyperlink": translator$6,
+  "w:jc": translator$M,
+  "w:p": translator$12,
+  "w:r": translator$T,
+  "w:rPr": translator$U,
+  "w:sdt": translator$2,
+  "w:tab": translator$13,
+  "w:tblCellSpacing": translator$L,
+  "w:tblHeader": translator$K,
+  "w:tc": translator$7,
+  "w:tr": translator$F,
+  "w:trHeight": translator$J,
+  "w:trPr": translator$G,
+  "w:wAfter": translator$I,
+  "w:wBefore": translator$H,
+  "wp:anchor": translator$5,
+  "wp:inline": translator$4,
+  "w:bookmarkStart": translator$1,
+  "w:bookmarkEnd": translator
+};
+const registeredHandlers = Object.freeze(baseHandlers);
 const Extensions = {
   Node: Node$1,
   Attribute: Attribute2,