@harbour-enterprises/superdoc 0.24.0-next.3 → 0.24.0-next.5

package/dist/super-editor/chunks/{converter-BueCftlx.js → converter-D-9mYZ83.js}

@@ -15074,6 +15074,7 @@ async function readFromClipboard(state2) {
   }
   return content;
 }
+const PIXELS_PER_INCH = 96;
 function inchesToTwips(inches) {
   if (inches == null) return;
   if (typeof inches === "string") inches = parseFloat(inches);
@@ -15096,12 +15097,12 @@ function pixelsToTwips(pixels) {
 }
 function inchesToPixels(inches) {
   if (inches == null) return;
-  const pixels = inches * 96;
+  const pixels = inches * PIXELS_PER_INCH;
   return Math.round(pixels * 1e3) / 1e3;
 }
 function pixelsToInches(pixels) {
   if (pixels == null) return;
-  const inches = Number(pixels) / 96;
+  const inches = Number(pixels) / PIXELS_PER_INCH;
   return inches;
 }
 function twipsToLines(twips) {
@@ -15119,7 +15120,7 @@ function halfPointToPoints(halfPoints) {
 function emuToPixels(emu) {
   if (emu == null) return;
   if (typeof emu === "string") emu = parseFloat(emu);
-  const pixels = emu * 96 / 914400;
+  const pixels = emu * PIXELS_PER_INCH / 914400;
   return Math.round(pixels);
 }
 function pixelsToEmu(px) {
@@ -15127,9 +15128,9 @@ function pixelsToEmu(px) {
   if (typeof px === "string") px = parseFloat(px);
   return Math.round(px * 9525);
 }
-function eigthPointsToPixels(eigthPoints) {
-  if (eigthPoints == null) return;
-  const points = parseFloat(eigthPoints) / 8;
+function eighthPointsToPixels(eighthPoints) {
+  if (eighthPoints == null) return;
+  const points = parseFloat(eighthPoints) / 8;
   const pixels = points * 1.3333;
   return pixels;
 }
@@ -15155,12 +15156,12 @@ function degreesToRot(degrees) {
 }
 function pixelsToPolygonUnits(pixels) {
   if (pixels == null) return;
-  const pu = pixels * 96;
+  const pu = pixels * PIXELS_PER_INCH;
   return Math.round(pu);
 }
 function polygonUnitsToPixels(pu) {
   if (pu == null) return;
-  const pixels = Number(pu) / 96;
+  const pixels = Number(pu) / PIXELS_PER_INCH;
   return Math.round(pixels * 1e3) / 1e3;
 }
 function polygonToObj(polygonNode) {
@@ -24542,37 +24543,37 @@ const _NodeTranslator = class _NodeTranslator {
 /** @type {typeof TranslatorTypes} */
 __publicField(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$1e = (attributes) => {
+const encode$1b = (attributes) => {
   return attributes["w:type"];
 };
-const decode$16 = (attrs) => {
+const decode$13 = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
 const attrConfig$G = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$1e,
-  decode: decode$16
+  encode: encode$1b,
+  decode: decode$13
 });
-const encode$1d = (attributes) => {
+const encode$1a = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$15 = (attrs) => {
+const decode$12 = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
 const attrConfig$F = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$1d,
-  decode: decode$15
+  encode: encode$1a,
+  decode: decode$12
 });
 const validXmlAttributes$p = [attrConfig$G, attrConfig$F];
-const XML_NODE_NAME$B = "w:br";
+const XML_NODE_NAME$y = "w:br";
 const SD_NODE_NAME$h = "lineBreak";
-const encode$1c = (_2, encodedAttrs) => {
+const encode$19 = (_2, encodedAttrs) => {
   const isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -24582,7 +24583,7 @@ const encode$1c = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$14 = (params, decodedAttrs) => {
+const decode$11 = (params, decodedAttrs) => {
   const { node } = params;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24599,39 +24600,39 @@ const decode$14 = (params, decodedAttrs) => {
   };
   return translated;
 };
-const config$y = {
-  xmlName: XML_NODE_NAME$B,
+const config$x = {
+  xmlName: XML_NODE_NAME$y,
   sdNodeOrKeyName: SD_NODE_NAME$h,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$1c,
-  decode: decode$14,
+  encode: encode$19,
+  decode: decode$11,
   attributes: validXmlAttributes$p
 };
-const translator$1c = NodeTranslator.from(config$y);
-const encode$1b = (attributes) => attributes?.["w:val"];
-const decode$13 = (attrs) => attrs?.highlight;
+const translator$1r = NodeTranslator.from(config$x);
+const encode$18 = (attributes) => attributes?.["w:val"];
+const decode$10 = (attrs) => attrs?.highlight;
 const attrConfig$E = Object.freeze({
   xmlName: "w:val",
   sdName: "highlight",
-  encode: encode$1b,
-  decode: decode$13
+  encode: encode$18,
+  decode: decode$10
 });
 const validXmlAttributes$o = [attrConfig$E];
-const XML_NODE_NAME$A = "w:highlight";
-const SD_ATTR_KEY$i = "highlight";
+const XML_NODE_NAME$x = "w:highlight";
+const SD_ATTR_KEY$f = "highlight";
 const DISABLED_TOKENS = /* @__PURE__ */ new Set(["transparent", "none", "inherit"]);
-const encode$1a = (params, encodedAttrs = {}) => {
+const encode$17 = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const value = encodedAttrs.highlight ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$A,
-    sdNodeOrKeyName: SD_ATTR_KEY$i,
+    xmlName: XML_NODE_NAME$x,
+    sdNodeOrKeyName: SD_ATTR_KEY$f,
     attributes: { "w:val": value ?? null }
   };
 };
-const decode$12 = (params) => {
+const decode$$ = (params) => {
   const attrs = params?.node?.attrs || {};
   const highlightValue = attrs.highlight ?? attrs.color ?? null;
   if (!highlightValue) return void 0;
@@ -24639,14 +24640,14 @@ const decode$12 = (params) => {
   if (!normalizedValue) return void 0;
   if (DISABLED_TOKENS.has(normalizedValue)) {
     return {
-      name: XML_NODE_NAME$A,
+      name: XML_NODE_NAME$x,
       attributes: { "w:val": "none" }
     };
   }
   const keyword = getDocxHighlightKeywordFromHex(highlightValue);
   if (keyword) {
     return {
-      name: XML_NODE_NAME$A,
+      name: XML_NODE_NAME$x,
       attributes: { "w:val": keyword }
     };
   }
@@ -24661,63 +24662,63 @@ const decode$12 = (params) => {
     }
   };
 };
-const config$x = {
-  xmlName: XML_NODE_NAME$A,
-  sdNodeOrKeyName: SD_ATTR_KEY$i,
+const config$w = {
+  xmlName: XML_NODE_NAME$x,
+  sdNodeOrKeyName: SD_ATTR_KEY$f,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$1a,
-  decode: decode$12,
+  encode: encode$17,
+  decode: decode$$,
   attributes: validXmlAttributes$o
 };
-const translator$1b = NodeTranslator.from(config$x);
-const encode$19 = (attributes) => {
+const translator$1q = NodeTranslator.from(config$w);
+const encode$16 = (attributes) => {
   return attributes["w:val"];
 };
-const decode$11 = (attrs) => {
+const decode$_ = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
 const attrConfig$D = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$19,
-  decode: decode$11
+  encode: encode$16,
+  decode: decode$_
 });
-const encode$18 = (attributes) => {
+const encode$15 = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$10 = (attrs) => {
+const decode$Z = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
 const attrConfig$C = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$18,
-  decode: decode$10
+  encode: encode$15,
+  decode: decode$Z
 });
-const encode$17 = (attributes) => {
+const encode$14 = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$$ = (attrs) => {
+const decode$Y = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
 const attrConfig$B = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$17,
-  decode: decode$$
+  encode: encode$14,
+  decode: decode$Y
 });
 const validXmlAttributes$n = [attrConfig$D, attrConfig$B, attrConfig$C];
-const XML_NODE_NAME$z = "w:tab";
+const XML_NODE_NAME$w = "w:tab";
 const SD_NODE_NAME$g = "tab";
-const encode$16 = (_2, encodedAttrs = {}) => {
+const encode$13 = (_2, encodedAttrs = {}) => {
   const translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$_ = (params, decodedAttrs = {}) => {
+const decode$X = (params, decodedAttrs = {}) => {
   const { node } = params || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24733,15 +24734,15 @@ const decode$_ = (params, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$w = {
-  xmlName: XML_NODE_NAME$z,
+const config$v = {
+  xmlName: XML_NODE_NAME$w,
   sdNodeOrKeyName: SD_NODE_NAME$g,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$16,
-  decode: decode$_,
+  encode: encode$13,
+  decode: decode$X,
   attributes: validXmlAttributes$n
 };
-const translator$1a = NodeTranslator.from(config$w);
+const translator$1p = NodeTranslator.from(config$v);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -24967,9 +24968,9 @@ const parseParagraphBorders = (pBdr) => {
     const { attributes: a } = el;
     if (a["w:val"] === "nil" || a["w:val"] === void 0) return;
     let sizePx;
-    if (a["w:sz"] !== void 0) sizePx = eigthPointsToPixels(a["w:sz"]);
+    if (a["w:sz"] !== void 0) sizePx = eighthPointsToPixels(a["w:sz"]);
     let spacePx;
-    if (a["w:space"] !== void 0) spacePx = eigthPointsToPixels(a["w:space"]);
+    if (a["w:space"] !== void 0) spacePx = eighthPointsToPixels(a["w:space"]);
     result[side] = {
       val: a["w:val"],
       size: sizePx,
@@ -25259,89 +25260,89 @@ const handleParagraphNode$1 = (params) => {
   }
   return schemaNode;
 };
-const encode$15 = (attributes) => {
+const encode$12 = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$Z = (attrs) => {
+const decode$W = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$A = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$15,
-  decode: decode$Z
+  encode: encode$12,
+  decode: decode$W
 });
-const encode$14 = (attributes) => {
+const encode$11 = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$Y = (attrs) => {
+const decode$V = (attrs) => {
   return attrs.rsidP;
 };
 const attrConfig$z = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$14,
-  decode: decode$Y
+  encode: encode$11,
+  decode: decode$V
 });
-const encode$13 = (attributes) => {
+const encode$10 = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$X = (attrs) => {
+const decode$U = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$y = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$13,
-  decode: decode$X
+  encode: encode$10,
+  decode: decode$U
 });
-const encode$12 = (attributes) => {
+const encode$$ = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$W = (attrs) => {
+const decode$T = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$x = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$12,
-  decode: decode$W
+  encode: encode$$,
+  decode: decode$T
 });
-const encode$11 = (attributes) => {
+const encode$_ = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$V = (attrs) => {
+const decode$S = (attrs) => {
   return attrs.rsidRDefault;
 };
 const attrConfig$w = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$11,
-  decode: decode$V
+  encode: encode$_,
+  decode: decode$S
 });
-const encode$10 = (attributes) => {
+const encode$Z = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$U = (attrs) => {
+const decode$R = (attrs) => {
   return attrs.paraId;
 };
 const attrConfig$v = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$10,
-  decode: decode$U
+  encode: encode$Z,
+  decode: decode$R
 });
-const encode$$ = (attributes) => {
+const encode$Y = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$T = (attrs) => {
+const decode$Q = (attrs) => {
   return attrs.textId;
 };
 const attrConfig$u = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$$,
-  decode: decode$T
+  encode: encode$Y,
+  decode: decode$Q
 });
 const validXmlAttributes$m = [
   attrConfig$v,
@@ -25352,9 +25353,9 @@ const validXmlAttributes$m = [
   attrConfig$x,
   attrConfig$A
 ];
-const XML_NODE_NAME$y = "w:p";
+const XML_NODE_NAME$v = "w:p";
 const SD_NODE_NAME$f = "paragraph";
-const encode$_ = (params, encodedAttrs = {}) => {
+const encode$X = (params, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25362,7 +25363,7 @@ const encode$_ = (params, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$S = (params, decodedAttrs = {}) => {
+const decode$P = (params, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25370,16 +25371,16 @@ const decode$S = (params, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$v = {
-  xmlName: XML_NODE_NAME$y,
+const config$u = {
+  xmlName: XML_NODE_NAME$v,
   sdNodeOrKeyName: SD_NODE_NAME$f,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$_,
-  decode: decode$S,
+  encode: encode$X,
+  decode: decode$P,
   attributes: validXmlAttributes$m
 };
-const translator$19 = NodeTranslator.from(config$v);
-const encode$Z = (attributes) => {
+const translator$1o = NodeTranslator.from(config$u);
+const encode$W = (attributes) => {
   const raw = attributes?.["w:val"];
   if (raw === void 0 || raw === null) return void 0;
   if (typeof raw === "boolean") return raw;
@@ -25389,24 +25390,24 @@ const encode$Z = (attributes) => {
   if (val === "1" || val === "true" || val === "on") return true;
   return void 0;
 };
-const decode$R = (runProps) => {
+const decode$O = (runProps) => {
   if (runProps?.bold === false) return "0";
   return void 0;
 };
 const attrConfig$t = Object.freeze({
   xmlName: "w:val",
   sdName: "bold",
-  encode: encode$Z,
-  decode: decode$R
+  encode: encode$W,
+  decode: decode$O
 });
 const validXmlAttributes$l = [attrConfig$t];
-const XML_NODE_NAME$x = "w:b";
-const SD_ATTR_KEY$h = "bold";
-const encode$Y = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$u = "w:b";
+const SD_ATTR_KEY$e = "bold";
+const encode$V = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes[0];
   if (!node) return void 0;
-  const val = encodedAttrs?.[SD_ATTR_KEY$h];
+  const val = encodedAttrs?.[SD_ATTR_KEY$e];
   let attributes;
   if (val === false) attributes = { "w:val": "0" };
   else if (val === true)
@@ -25414,85 +25415,85 @@ const encode$Y = (params, encodedAttrs = {}) => {
   else attributes = node.attributes || {};
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$x,
-    sdNodeOrKeyName: SD_ATTR_KEY$h,
+    xmlName: XML_NODE_NAME$u,
+    sdNodeOrKeyName: SD_ATTR_KEY$e,
     attributes
   };
 };
-const config$u = {
-  xmlName: XML_NODE_NAME$x,
-  sdNodeOrKeyName: SD_ATTR_KEY$h,
+const config$t = {
+  xmlName: XML_NODE_NAME$u,
+  sdNodeOrKeyName: SD_ATTR_KEY$e,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$Y,
+  encode: encode$V,
   attributes: validXmlAttributes$l
 };
-const translator$18 = NodeTranslator.from(config$u);
-const XML_NODE_NAME$w = "w:i";
-const SD_ATTR_KEY$g = "italic";
-const encode$X = (params) => {
+const translator$1n = NodeTranslator.from(config$t);
+const XML_NODE_NAME$t = "w:i";
+const SD_ATTR_KEY$d = "italic";
+const encode$U = (params) => {
   const { nodes } = params;
   const node = nodes?.[0];
   if (!node) return void 0;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$w,
-    sdNodeOrKeyName: SD_ATTR_KEY$g,
+    xmlName: XML_NODE_NAME$t,
+    sdNodeOrKeyName: SD_ATTR_KEY$d,
     attributes: {
       "w:val": node.attributes?.["w:val"] ?? null
     }
   };
 };
-const config$t = {
-  xmlName: XML_NODE_NAME$w,
-  sdNodeOrKeyName: SD_ATTR_KEY$g,
+const config$s = {
+  xmlName: XML_NODE_NAME$t,
+  sdNodeOrKeyName: SD_ATTR_KEY$d,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$X
+  encode: encode$U
 };
-const translator$17 = NodeTranslator.from(config$t);
-const encode$W = (attributes) => attributes?.["w:val"];
-const decode$Q = (attrs) => attrs?.underline;
+const translator$1m = NodeTranslator.from(config$s);
+const encode$T = (attributes) => attributes?.["w:val"];
+const decode$N = (attrs) => attrs?.underline;
 const attrConfig$s = Object.freeze({
   xmlName: "w:val",
   sdName: "underline",
-  encode: encode$W,
-  decode: decode$Q
+  encode: encode$T,
+  decode: decode$N
 });
-const encode$V = (attributes) => attributes?.["w:color"];
-const decode$P = (attrs) => attrs?.color;
+const encode$S = (attributes) => attributes?.["w:color"];
+const decode$M = (attrs) => attrs?.color;
 const attrConfig$r = Object.freeze({
   xmlName: "w:color",
   sdName: "color",
-  encode: encode$V,
-  decode: decode$P
+  encode: encode$S,
+  decode: decode$M
 });
-const encode$U = (attributes) => attributes?.["w:themeColor"];
-const decode$O = (attrs) => attrs?.themeColor;
+const encode$R = (attributes) => attributes?.["w:themeColor"];
+const decode$L = (attrs) => attrs?.themeColor;
 const attrConfig$q = Object.freeze({
   xmlName: "w:themeColor",
   sdName: "themeColor",
-  encode: encode$U,
-  decode: decode$O
+  encode: encode$R,
+  decode: decode$L
 });
-const encode$T = (attributes) => attributes?.["w:themeTint"];
-const decode$N = (attrs) => attrs?.themeTint;
+const encode$Q = (attributes) => attributes?.["w:themeTint"];
+const decode$K = (attrs) => attrs?.themeTint;
 const attrConfig$p = Object.freeze({
   xmlName: "w:themeTint",
   sdName: "themeTint",
-  encode: encode$T,
-  decode: decode$N
+  encode: encode$Q,
+  decode: decode$K
 });
-const encode$S = (attributes) => attributes?.["w:themeShade"];
-const decode$M = (attrs) => attrs?.themeShade;
+const encode$P = (attributes) => attributes?.["w:themeShade"];
+const decode$J = (attrs) => attrs?.themeShade;
 const attrConfig$o = Object.freeze({
   xmlName: "w:themeShade",
   sdName: "themeShade",
-  encode: encode$S,
-  decode: decode$M
+  encode: encode$P,
+  decode: decode$J
 });
 const validXmlAttributes$k = [attrConfig$s, attrConfig$r, attrConfig$q, attrConfig$p, attrConfig$o];
-const XML_NODE_NAME$v = "w:u";
-const SD_ATTR_KEY$f = "underline";
-const encode$R = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$s = "w:u";
+const SD_ATTR_KEY$c = "underline";
+const encode$O = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25508,12 +25509,12 @@ const encode$R = (params, encodedAttrs = {}) => {
   if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$v,
-    sdNodeOrKeyName: SD_ATTR_KEY$f,
+    xmlName: XML_NODE_NAME$s,
+    sdNodeOrKeyName: SD_ATTR_KEY$c,
     attributes
   };
 };
-const decode$L = (params) => {
+const decode$I = (params) => {
   const attrs = params?.node?.attrs || {};
   const underlineType = attrs.underlineType ?? attrs.underline ?? null;
   const color = attrs.underlineColor ?? attrs.color ?? null;
@@ -25531,20 +25532,20 @@ const decode$L = (params) => {
   if (themeTint) attributes["w:themeTint"] = themeTint;
   if (themeShade) attributes["w:themeShade"] = themeShade;
   return {
-    name: XML_NODE_NAME$v,
+    name: XML_NODE_NAME$s,
     attributes
   };
 };
-const config$s = {
-  xmlName: XML_NODE_NAME$v,
-  sdNodeOrKeyName: SD_ATTR_KEY$f,
+const config$r = {
+  xmlName: XML_NODE_NAME$s,
+  sdNodeOrKeyName: SD_ATTR_KEY$c,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$R,
-  decode: decode$L,
+  encode: encode$O,
+  decode: decode$I,
   attributes: validXmlAttributes$k
 };
-const translator$16 = NodeTranslator.from(config$s);
-const encode$Q = (attributes) => {
+const translator$1l = NodeTranslator.from(config$r);
+const encode$N = (attributes) => {
   const raw = attributes?.["w:val"];
   if (raw === void 0 || raw === null) return void 0;
   if (typeof raw === "boolean") return raw;
@@ -25554,24 +25555,24 @@ const encode$Q = (attributes) => {
   if (val === "1" || val === "true" || val === "on") return true;
   return void 0;
 };
-const decode$K = (attrs) => {
+const decode$H = (attrs) => {
   if (attrs?.strike === false) return "0";
   return void 0;
 };
 const attrConfig$n = Object.freeze({
   xmlName: "w:val",
   sdName: "strike",
-  encode: encode$Q,
-  decode: decode$K
+  encode: encode$N,
+  decode: decode$H
 });
 const validXmlAttributes$j = [attrConfig$n];
-const XML_NODE_NAME$u = "w:strike";
-const SD_ATTR_KEY$e = "strike";
-const encode$P = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$r = "w:strike";
+const SD_ATTR_KEY$b = "strike";
+const encode$M = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   if (!node) return void 0;
-  const val = encodedAttrs?.[SD_ATTR_KEY$e];
+  const val = encodedAttrs?.[SD_ATTR_KEY$b];
   let attributes;
   if (val === false) attributes = { "w:val": "0" };
   else if (val === true) attributes = {};
@@ -25580,55 +25581,55 @@ const encode$P = (params, encodedAttrs = {}) => {
   else if (val === true && attributes["w:val"] === void 0) delete attributes["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$u,
-    sdNodeOrKeyName: SD_ATTR_KEY$e,
+    xmlName: XML_NODE_NAME$r,
+    sdNodeOrKeyName: SD_ATTR_KEY$b,
     attributes
   };
 };
-const config$r = {
-  xmlName: XML_NODE_NAME$u,
-  sdNodeOrKeyName: SD_ATTR_KEY$e,
+const config$q = {
+  xmlName: XML_NODE_NAME$r,
+  sdNodeOrKeyName: SD_ATTR_KEY$b,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$P,
+  encode: encode$M,
   attributes: validXmlAttributes$j
 };
-const translator$15 = NodeTranslator.from(config$r);
-const encode$O = (attributes) => attributes?.["w:val"];
-const decode$J = (attrs) => attrs?.color;
+const translator$1k = NodeTranslator.from(config$q);
+const encode$L = (attributes) => attributes?.["w:val"];
+const decode$G = (attrs) => attrs?.color;
 const attrConfig$m = Object.freeze({
   xmlName: "w:val",
   sdName: "color",
-  encode: encode$O,
-  decode: decode$J
+  encode: encode$L,
+  decode: decode$G
 });
-const encode$N = (attributes) => attributes?.["w:themeColor"];
-const decode$I = (attrs) => attrs?.themeColor;
+const encode$K = (attributes) => attributes?.["w:themeColor"];
+const decode$F = (attrs) => attrs?.themeColor;
 const attrConfig$l = Object.freeze({
   xmlName: "w:themeColor",
   sdName: "themeColor",
-  encode: encode$N,
-  decode: decode$I
+  encode: encode$K,
+  decode: decode$F
 });
-const encode$M = (attributes) => attributes?.["w:themeTint"];
-const decode$H = (attrs) => attrs?.themeTint;
+const encode$J = (attributes) => attributes?.["w:themeTint"];
+const decode$E = (attrs) => attrs?.themeTint;
 const attrConfig$k = Object.freeze({
   xmlName: "w:themeTint",
   sdName: "themeTint",
-  encode: encode$M,
-  decode: decode$H
+  encode: encode$J,
+  decode: decode$E
 });
-const encode$L = (attributes) => attributes?.["w:themeShade"];
-const decode$G = (attrs) => attrs?.themeShade;
+const encode$I = (attributes) => attributes?.["w:themeShade"];
+const decode$D = (attrs) => attrs?.themeShade;
 const attrConfig$j = Object.freeze({
   xmlName: "w:themeShade",
   sdName: "themeShade",
-  encode: encode$L,
-  decode: decode$G
+  encode: encode$I,
+  decode: decode$D
 });
 const validXmlAttributes$i = [attrConfig$m, attrConfig$l, attrConfig$k, attrConfig$j];
-const XML_NODE_NAME$t = "w:color";
-const SD_ATTR_KEY$d = "color";
-const encode$K = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$q = "w:color";
+const SD_ATTR_KEY$a = "color";
+const encode$H = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25643,63 +25644,63 @@ const encode$K = (params, encodedAttrs = {}) => {
   if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$t,
-    sdNodeOrKeyName: SD_ATTR_KEY$d,
+    xmlName: XML_NODE_NAME$q,
+    sdNodeOrKeyName: SD_ATTR_KEY$a,
     attributes
   };
 };
-const config$q = {
-  xmlName: XML_NODE_NAME$t,
-  sdNodeOrKeyName: SD_ATTR_KEY$d,
+const config$p = {
+  xmlName: XML_NODE_NAME$q,
+  sdNodeOrKeyName: SD_ATTR_KEY$a,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$K,
+  encode: encode$H,
   attributes: validXmlAttributes$i
 };
-const translator$14 = NodeTranslator.from(config$q);
-const encode$J = (attributes) => attributes?.["w:eastAsia"];
-const decode$F = (attrs) => attrs?.eastAsia;
+const translator$1j = NodeTranslator.from(config$p);
+const encode$G = (attributes) => attributes?.["w:eastAsia"];
+const decode$C = (attrs) => attrs?.eastAsia;
 const attrConfig$i = Object.freeze({
   xmlName: "w:eastAsia",
   sdName: "eastAsia",
-  encode: encode$J,
-  decode: decode$F
+  encode: encode$G,
+  decode: decode$C
 });
-const encode$I = (attributes) => attributes?.["w:ascii"];
-const decode$E = (attrs) => attrs?.ascii;
+const encode$F = (attributes) => attributes?.["w:ascii"];
+const decode$B = (attrs) => attrs?.ascii;
 const attrConfig$h = Object.freeze({
   xmlName: "w:ascii",
   sdName: "ascii",
-  encode: encode$I,
-  decode: decode$E
+  encode: encode$F,
+  decode: decode$B
 });
-const encode$H = (attributes) => attributes?.["w:hAnsi"];
-const decode$D = (attrs) => attrs?.hAnsi;
+const encode$E = (attributes) => attributes?.["w:hAnsi"];
+const decode$A = (attrs) => attrs?.hAnsi;
 const attrConfig$g = Object.freeze({
   xmlName: "w:hAnsi",
   sdName: "hAnsi",
-  encode: encode$H,
-  decode: decode$D
+  encode: encode$E,
+  decode: decode$A
 });
-const encode$G = (attributes) => attributes?.["w:cs"];
-const decode$C = (attrs) => attrs?.cs;
+const encode$D = (attributes) => attributes?.["w:cs"];
+const decode$z = (attrs) => attrs?.cs;
 const attrConfig$f = Object.freeze({
   xmlName: "w:cs",
   sdName: "cs",
-  encode: encode$G,
-  decode: decode$C
+  encode: encode$D,
+  decode: decode$z
 });
-const encode$F = (attributes) => attributes?.["w:val"];
-const decode$B = (attrs) => attrs?.value;
+const encode$C = (attributes) => attributes?.["w:val"];
+const decode$y = (attrs) => attrs?.value;
 const attrConfig$e = Object.freeze({
   xmlName: "w:val",
   sdName: "value",
-  encode: encode$F,
-  decode: decode$B
+  encode: encode$C,
+  decode: decode$y
 });
 const validXmlAttributes$h = [attrConfig$i, attrConfig$h, attrConfig$g, attrConfig$f, attrConfig$e];
-const XML_NODE_NAME$s = "w:rFonts";
-const SD_ATTR_KEY$c = "fontFamily";
-const encode$E = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$p = "w:rFonts";
+const SD_ATTR_KEY$9 = "fontFamily";
+const encode$B = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25723,111 +25724,119 @@ const encode$E = (params, encodedAttrs = {}) => {
     attributes["w:val"] = attributes["w:eastAsia"];
   }
   if (attributes["w:val"] === void 0) delete attributes["w:val"];
+  if (params.inlineDocumentFonts) {
+    const font = attributes["w:ascii"];
+    if (font) {
+      if (!params.inlineDocumentFonts.includes(font)) {
+        params.inlineDocumentFonts.push(font);
+      }
+    }
+  }
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$s,
-    sdNodeOrKeyName: SD_ATTR_KEY$c,
+    xmlName: XML_NODE_NAME$p,
+    sdNodeOrKeyName: SD_ATTR_KEY$9,
     attributes
   };
 };
-const config$p = {
-  xmlName: XML_NODE_NAME$s,
-  sdNodeOrKeyName: SD_ATTR_KEY$c,
+const config$o = {
+  xmlName: XML_NODE_NAME$p,
+  sdNodeOrKeyName: SD_ATTR_KEY$9,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$E,
+  encode: encode$B,
   attributes: validXmlAttributes$h
 };
-const translator$13 = NodeTranslator.from(config$p);
-const encode$D = (attributes) => attributes?.["w:val"];
-const decode$A = (attrs) => attrs?.styleId;
+const translator$1i = NodeTranslator.from(config$o);
+const encode$A = (attributes) => attributes?.["w:val"];
+const decode$x = (attrs) => attrs?.styleId;
 const attrConfig$d = Object.freeze({
   xmlName: "w:val",
   sdName: "styleId",
-  encode: encode$D,
-  decode: decode$A
+  encode: encode$A,
+  decode: decode$x
 });
 const validXmlAttributes$g = [attrConfig$d];
-const XML_NODE_NAME$r = "w:rStyle";
-const SD_ATTR_KEY$b = "styleId";
-const encode$C = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$o = "w:rStyle";
+const SD_ATTR_KEY$8 = "styleId";
+const encode$z = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const value = encodedAttrs.styleId ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$r,
-    sdNodeOrKeyName: SD_ATTR_KEY$b,
+    xmlName: XML_NODE_NAME$o,
+    sdNodeOrKeyName: SD_ATTR_KEY$8,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$o = {
-  xmlName: XML_NODE_NAME$r,
-  sdNodeOrKeyName: SD_ATTR_KEY$b,
+const config$n = {
+  xmlName: XML_NODE_NAME$o,
+  sdNodeOrKeyName: SD_ATTR_KEY$8,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$C,
+  encode: encode$z,
   attributes: validXmlAttributes$g
 };
-const translator$12 = NodeTranslator.from(config$o);
-const encode$B = (attributes) => attributes?.["w:val"];
-const decode$z = (attrs) => attrs?.fontSize;
+const translator$1h = NodeTranslator.from(config$n);
+const encode$y = (attributes) => attributes?.["w:val"];
+const decode$w = (attrs) => attrs?.fontSize;
 const attrConfig$c = Object.freeze({
   xmlName: "w:val",
   sdName: "fontSize",
-  encode: encode$B,
-  decode: decode$z
+  encode: encode$y,
+  decode: decode$w
 });
 const validXmlAttributes$f = [attrConfig$c];
-const XML_NODE_NAME$q = "w:sz";
-const SD_ATTR_KEY$a = "fontSize";
-const encode$A = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$n = "w:sz";
+const SD_ATTR_KEY$7 = "fontSize";
+const encode$x = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const value = encodedAttrs.fontSize ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$q,
-    sdNodeOrKeyName: SD_ATTR_KEY$a,
+    xmlName: XML_NODE_NAME$n,
+    sdNodeOrKeyName: SD_ATTR_KEY$7,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$n = {
-  xmlName: XML_NODE_NAME$q,
-  sdNodeOrKeyName: SD_ATTR_KEY$a,
+const config$m = {
+  xmlName: XML_NODE_NAME$n,
+  sdNodeOrKeyName: SD_ATTR_KEY$7,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$A,
+  encode: encode$x,
   attributes: validXmlAttributes$f
 };
-const translator$11 = NodeTranslator.from(config$n);
-const encode$z = (attributes) => attributes?.["w:val"];
-const decode$y = (attrs) => attrs?.fontSizeCs;
+const translator$1g = NodeTranslator.from(config$m);
+const encode$w = (attributes) => attributes?.["w:val"];
+const decode$v = (attrs) => attrs?.fontSizeCs;
 const attrConfig$b = Object.freeze({
   xmlName: "w:val",
   sdName: "fontSizeCs",
-  encode: encode$z,
-  decode: decode$y
+  encode: encode$w,
+  decode: decode$v
 });
 const validXmlAttributes$e = [attrConfig$b];
-const XML_NODE_NAME$p = "w:szCs";
-const SD_ATTR_KEY$9 = "fontSizeCs";
-const encode$y = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$m = "w:szCs";
+const SD_ATTR_KEY$6 = "fontSizeCs";
+const encode$v = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const value = encodedAttrs.fontSizeCs ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$p,
-    sdNodeOrKeyName: SD_ATTR_KEY$9,
+    xmlName: XML_NODE_NAME$m,
+    sdNodeOrKeyName: SD_ATTR_KEY$6,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$m = {
-  xmlName: XML_NODE_NAME$p,
-  sdNodeOrKeyName: SD_ATTR_KEY$9,
+const config$l = {
+  xmlName: XML_NODE_NAME$m,
+  sdNodeOrKeyName: SD_ATTR_KEY$6,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$y,
+  encode: encode$v,
   attributes: validXmlAttributes$e
 };
-const translator$10 = NodeTranslator.from(config$m);
+const translator$1f = NodeTranslator.from(config$l);
 const generateV2HandlerEntity = (handlerName, translator2) => ({
   handlerName,
   handler: (params) => {
@@ -25851,7 +25860,7 @@ function createSingleAttrPropertyHandler(xmlName, sdName = null, attrName = "w:v
     xmlName,
     sdNodeOrKeyName: sdName,
     encode: ({ nodes }) => {
-      return transformEncode(nodes[0].attributes[attrName]) ?? void 0;
+      return transformEncode(nodes[0]?.attributes?.[attrName]) ?? void 0;
     },
     decode: ({ node }) => {
       const value = node.attrs?.[sdName] != null ? transformDecode(node.attrs[sdName]) : void 0;
@@ -25883,8 +25892,32 @@ function createBorderPropertyHandler(xmlName, sdName = null) {
     xmlName,
     sdNodeOrKeyName: sdName,
     attributes: [
-      createAttributeHandler("w:val"),
-      createAttributeHandler("w:color"),
+      createAttributeHandler(
+        "w:val",
+        "val",
+        (v2) => v2 === "nil" ? "none" : v2,
+        (v2) => v2 === "none" ? "nil" : v2
+      ),
+      createAttributeHandler(
+        "w:color",
+        "color",
+        (v2) => {
+          if (v2 === "auto") {
+            return null;
+          } else if (v2) {
+            return `#${v2}`;
+          } else {
+            return void 0;
+          }
+        },
+        (v2) => {
+          if (v2) {
+            return v2.replace("#", "");
+          } else {
+            return void 0;
+          }
+        }
+      ),
       createAttributeHandler("w:themeColor"),
       createAttributeHandler("w:themeTint"),
       createAttributeHandler("w:themeShade"),
@@ -25950,6 +25983,37 @@ function decodeProperties(translatorsBySdName, properties) {
   });
   return elements;
 }
+function createNestedPropertiesTranslator(xmlName, sdName, propertyTranslators2, defaultEncodedAttrs = {}) {
+  const propertyTranslatorsByXmlName = {};
+  const propertyTranslatorsBySdName = {};
+  propertyTranslators2.forEach((translator2) => {
+    propertyTranslatorsByXmlName[translator2.xmlName] = translator2;
+    propertyTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
+  });
+  return {
+    xmlName,
+    sdNodeOrKeyName: sdName,
+    type: NodeTranslator.translatorTypes.NODE,
+    attributes: [],
+    encode: (params) => {
+      const { nodes } = params;
+      const node = nodes[0];
+      const attributes = { ...defaultEncodedAttrs, ...encodeProperties(node, propertyTranslatorsByXmlName) };
+      return Object.keys(attributes).length > 0 ? attributes : void 0;
+    },
+    decode: (params) => {
+      const currentValue = params.node.attrs?.[sdName];
+      const elements = decodeProperties(propertyTranslatorsBySdName, currentValue);
+      const newNode = {
+        name: xmlName,
+        type: "element",
+        attributes: {},
+        elements
+      };
+      return newNode;
+    }
+  };
+}
 const parseBoolean = (value) => value != null ? ["1", "true"].includes(value) : void 0;
 const booleanToString = (value) => value != null ? value ? "1" : "0" : void 0;
 const parseInteger = (value) => {
@@ -25961,9 +26025,9 @@ const integerToString = (value) => {
   const intValue = parseInteger(value);
   return intValue != void 0 ? String(intValue) : void 0;
 };
-const XML_NODE_NAME$o = "w:caps";
-const SD_ATTR_KEY$8 = "textTransform";
-const encode$x = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$l = "w:caps";
+const SD_ATTR_KEY$5 = "textTransform";
+const encode$u = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes[0];
   if (!node) return void 0;
@@ -25975,31 +26039,31 @@ const encode$x = (params, encodedAttrs = {}) => {
   }
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$o,
-    sdNodeOrKeyName: SD_ATTR_KEY$8,
-    attributes: { [SD_ATTR_KEY$8]: result }
+    xmlName: XML_NODE_NAME$l,
+    sdNodeOrKeyName: SD_ATTR_KEY$5,
+    attributes: { [SD_ATTR_KEY$5]: result }
   };
 };
-const config$l = {
-  xmlName: XML_NODE_NAME$o,
-  sdNodeOrKeyName: SD_ATTR_KEY$8,
+const config$k = {
+  xmlName: XML_NODE_NAME$l,
+  sdNodeOrKeyName: SD_ATTR_KEY$5,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$x,
+  encode: encode$u,
   attributes: [createAttributeHandler("w:val")]
 };
-const translator$$ = NodeTranslator.from(config$l);
+const translator$1e = NodeTranslator.from(config$k);
 const runPropertyTranslators = Object.freeze({
-  "w:b": translator$18,
-  "w:i": translator$17,
-  "w:u": translator$16,
-  "w:strike": translator$15,
-  "w:color": translator$14,
-  "w:highlight": translator$1b,
-  "w:rFonts": translator$13,
-  "w:rStyle": translator$12,
-  "w:sz": translator$11,
-  "w:szCs": translator$10,
-  "w:caps": translator$$
+  "w:b": translator$1n,
+  "w:i": translator$1m,
+  "w:u": translator$1l,
+  "w:strike": translator$1k,
+  "w:color": translator$1j,
+  "w:highlight": translator$1q,
+  "w:rFonts": translator$1i,
+  "w:rStyle": translator$1h,
+  "w:sz": translator$1g,
+  "w:szCs": translator$1f,
+  "w:caps": translator$1e
 });
 const rawRunPropertyXmlNames = Object.freeze(["w:lang", "w:shd"]);
 const RAW_CHILD_NAME_SET = new Set(rawRunPropertyXmlNames);
@@ -26013,9 +26077,9 @@ const toRunPropertyEntry = (candidate) => {
     attributes: { ...candidate.attributes || {} }
   };
 };
-const XML_NODE_NAME$n = "w:rPr";
-const SD_ATTR_KEY$7 = "runProperties";
-const encode$w = (params) => {
+const XML_NODE_NAME$k = "w:rPr";
+const SD_ATTR_KEY$4 = "runProperties";
+const encode$t = (params) => {
   const { nodes } = params;
   const node = nodes?.[0] || {};
   const contents = Array.isArray(node.elements) ? node.elements : [];
@@ -26049,16 +26113,16 @@ const encode$w = (params) => {
     attributes: runPropsArray
   };
 };
-const config$k = {
-  xmlName: XML_NODE_NAME$n,
-  sdNodeOrKeyName: SD_ATTR_KEY$7,
+const config$j = {
+  xmlName: XML_NODE_NAME$k,
+  sdNodeOrKeyName: SD_ATTR_KEY$4,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$w
+  encode: encode$t
 };
-const translator$_ = NodeTranslator.from(config$k);
+const translator$1d = NodeTranslator.from(config$j);
 const EAST_ASIAN_CHARACTER_REGEX = /[\u1100-\u11FF\u2E80-\u2EFF\u2F00-\u2FDF\u3040-\u30FF\u3100-\u312F\u3130-\u318F\u31A0-\u31BF\u3400-\u4DBF\u4E00-\u9FFF\uA960-\uA97F\uAC00-\uD7AF\uF900-\uFAFF\uFF00-\uFFEF]/u;
 const containsEastAsianCharacters = (text) => EAST_ASIAN_CHARACTER_REGEX.test(text);
-const collectRunProperties = (params, rPrNode, translator2 = translator$_) => {
+const collectRunProperties = (params, rPrNode, translator2 = translator$1d) => {
   if (!rPrNode) return { entries: [], hadRPr: false, styleChangeMarks: [] };
   const result = translator2.encode({ ...params, nodes: [rPrNode] }) || {};
   let entries = [];
@@ -26531,7 +26595,7 @@ const ensureTrackedWrapper = (runs, trackingMarksByType = /* @__PURE__ */ new Ma
   }
   return runs;
 };
-const XML_NODE_NAME$m = "w:hyperlink";
+const XML_NODE_NAME$j = "w:hyperlink";
 const SD_NODE_NAME$e = "link";
 const _createAttributeHandler = (xmlName, sdName) => ({
   xmlName,
@@ -26552,7 +26616,7 @@ const validXmlAttributes$d = [
   _createAttributeHandler("r:id", "rId"),
   _createAttributeHandler("w:tgtFrame", "target")
 ];
-const encode$v = (params, encodedAttrs) => {
+const encode$s = (params, encodedAttrs) => {
   const { nodes, docx, nodeListHandler } = params;
   const node = nodes[0];
   let href = _resolveHref(docx, encodedAttrs);
@@ -26586,7 +26650,7 @@ const _resolveHref = (docx, encodedAttrs) => {
   }
   return href;
 };
-function decode$x(params) {
+function decode$u(params) {
   const { hyperlinkGroup = [params.node] } = params.extraParams || {};
   const node = hyperlinkGroup[0];
   const linkMark = node.marks.find((m2) => m2.type === "link");
@@ -26635,55 +26699,55 @@ function _addNewLinkRelationship(params, link) {
   });
   return id;
 }
-const config$j = {
-  xmlName: XML_NODE_NAME$m,
+const config$i = {
+  xmlName: XML_NODE_NAME$j,
   sdNodeOrKeyName: SD_NODE_NAME$e,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$v,
-  decode: decode$x,
+  encode: encode$s,
+  decode: decode$u,
   attributes: validXmlAttributes$d
 };
-const translator$Z = NodeTranslator.from(config$j);
-const encode$u = (attributes) => {
+const translator$1c = NodeTranslator.from(config$i);
+const encode$r = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$w = (attrs) => {
+const decode$t = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$a = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$u,
-  decode: decode$w
+  encode: encode$r,
+  decode: decode$t
 });
-const encode$t = (attributes) => {
+const encode$q = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$v = (attrs) => {
+const decode$s = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$9 = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$t,
-  decode: decode$v
+  encode: encode$q,
+  decode: decode$s
 });
-const encode$s = (attributes) => {
+const encode$p = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$u = (attrs) => {
+const decode$r = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$8 = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$s,
-  decode: decode$u
+  encode: encode$p,
+  decode: decode$r
 });
 const validXmlAttributes$c = [attrConfig$a, attrConfig$9, attrConfig$8];
-const XML_NODE_NAME$l = "w:r";
+const XML_NODE_NAME$i = "w:r";
 const SD_KEY_NAME = "run";
-const encode$r = (params, encodedAttrs = {}) => {
+const encode$o = (params, encodedAttrs = {}) => {
   const { nodes = [], nodeListHandler } = params || {};
   const runNode = nodes[0];
   if (!runNode) return void 0;
@@ -26731,7 +26795,7 @@ const encode$r = (params, encodedAttrs = {}) => {
   }
   return runNodeResult;
 };
-const decode$t = (params, decodedAttrs = {}) => {
+const decode$q = (params, decodedAttrs = {}) => {
   const { node } = params || {};
   if (!node) return void 0;
   const isLinkNode = node.marks?.some((m2) => m2.type === "link");
@@ -26740,7 +26804,7 @@ const decode$t = (params, decodedAttrs = {}) => {
       ...params.extraParams,
       linkProcessed: true
     };
-    return translator$Z.decode({ ...params, extraParams });
+    return translator$1c.decode({ ...params, extraParams });
   }
   const { runNode: runNodeForExport, trackingMarksByType } = prepareRunTrackingContext(node);
   const runAttrs = runNodeForExport.attrs || {};
@@ -26796,7 +26860,7 @@ const decode$t = (params, decodedAttrs = {}) => {
       runs.push(trackedClone);
       return;
     }
-    const runWrapper = { name: XML_NODE_NAME$l, elements: [] };
+    const runWrapper = { name: XML_NODE_NAME$i, elements: [] };
     applyBaseRunProps(runWrapper);
     if (!Array.isArray(runWrapper.elements)) runWrapper.elements = [];
     runWrapper.elements.push(cloneXmlNode(child));
@@ -26804,7 +26868,7 @@ const decode$t = (params, decodedAttrs = {}) => {
   });
   const trackedRuns = ensureTrackedWrapper(runs, trackingMarksByType);
   if (!trackedRuns.length) {
-    const emptyRun = { name: XML_NODE_NAME$l, elements: [] };
+    const emptyRun = { name: XML_NODE_NAME$i, elements: [] };
     applyBaseRunProps(emptyRun);
     trackedRuns.push(emptyRun);
   }
@@ -26818,15 +26882,15 @@ const decode$t = (params, decodedAttrs = {}) => {
   }
   return trackedRuns;
 };
-const config$i = {
-  xmlName: XML_NODE_NAME$l,
+const config$h = {
+  xmlName: XML_NODE_NAME$i,
   sdNodeOrKeyName: SD_KEY_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$r,
-  decode: decode$t,
+  encode: encode$o,
+  decode: decode$q,
   attributes: validXmlAttributes$c
 };
-const translator$Y = NodeTranslator.from(config$i);
+const translator$1b = NodeTranslator.from(config$h);
 function preProcessVerticalMergeCells(table, { editorSchema }) {
   if (!table || !Array.isArray(table.content)) {
     return table;
@@ -26867,13 +26931,13 @@ function preProcessVerticalMergeCells(table, { editorSchema }) {
   }
   return table;
 }
-const translator$X = NodeTranslator.from({
+const translator$1a = NodeTranslator.from({
   xmlName: "w:cantSplit",
   sdNodeOrKeyName: "cantSplit",
   encode: ({ nodes }) => ["1", "true"].includes(nodes[0].attributes?.["w:val"] ?? "1"),
   decode: ({ node }) => node.attrs?.cantSplit ? { attributes: {} } : void 0
 });
-const translator$W = NodeTranslator.from({
+const translator$19 = NodeTranslator.from({
   xmlName: "w:cnfStyle",
   sdNodeOrKeyName: "cnfStyle",
   attributes: [
@@ -26899,8 +26963,8 @@ const translator$W = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$V = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
-const translator$U = NodeTranslator.from(
+const translator$18 = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
+const translator$17 = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridAfter",
     null,
@@ -26909,7 +26973,7 @@ const translator$U = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$T = NodeTranslator.from(
+const translator$16 = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridBefore",
     null,
@@ -26918,21 +26982,21 @@ const translator$T = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$S = NodeTranslator.from({
+const translator$15 = NodeTranslator.from({
   xmlName: "w:hidden",
   sdNodeOrKeyName: "hidden",
   encode: ({ nodes }) => parseBoolean(nodes[0].attributes?.["w:val"] ?? "1"),
   decode: ({ node }) => node.attrs.hidden ? { attributes: {} } : void 0
 });
-const translator$R = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc", "justification"));
-const translator$Q = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
-const translator$P = NodeTranslator.from({
+const translator$14 = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc", "justification"));
+const translator$13 = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
+const translator$12 = NodeTranslator.from({
   xmlName: "w:tblHeader",
   sdNodeOrKeyName: "repeatHeader",
   encode: ({ nodes }) => parseBoolean(nodes[0].attributes?.["w:val"] ?? "1"),
   decode: ({ node }) => node.attrs.repeatHeader ? { attributes: {} } : void 0
 });
-const translator$O = NodeTranslator.from({
+const translator$11 = NodeTranslator.from({
   xmlName: "w:trHeight",
   sdNodeOrKeyName: "rowHeight",
   encode: ({ nodes }) => {
@@ -26959,108 +27023,164 @@ const translator$O = NodeTranslator.from({
     return Object.keys(heightAttrs).length > 0 ? { attributes: heightAttrs } : void 0;
   }
 });
-const translator$N = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
-const translator$M = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
-const XML_NODE_NAME$k = "w:trPr";
-const SD_ATTR_KEY$6 = "tableRowProperties";
-const encode$q = (params) => {
-  const { nodes } = params;
-  const node = nodes[0];
-  let attributes = {
+const translator$10 = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
+const translator$$ = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
+const propertyTranslators$6 = [
+  translator$1a,
+  translator$19,
+  translator$18,
+  translator$17,
+  translator$16,
+  translator$15,
+  translator$14,
+  translator$13,
+  translator$12,
+  translator$11,
+  translator$10,
+  translator$$
+];
+const translator$_ = NodeTranslator.from(
+  createNestedPropertiesTranslator("w:trPr", "tableRowProperties", propertyTranslators$6, {
     cantSplit: false,
     hidden: false,
     repeatHeader: false
-  };
-  attributes = {
-    ...attributes,
-    ...encodeProperties(node, propertyTranslatorsByXmlName$2)
-  };
+  })
+);
+const createPlaceholderCell = (gridWidth, reason) => {
+  const safeWidth = Number.isFinite(gridWidth) ? gridWidth : 0;
+  const noBorder = { val: "none", size: 0 };
   return {
-    type: NodeTranslator.translatorTypes.ATTRIBUTE,
-    xmlName: XML_NODE_NAME$k,
-    sdNodeOrKeyName: SD_ATTR_KEY$6,
-    attributes
-  };
-};
-const decode$s = (params) => {
-  const { tableRowProperties = {} } = params.node.attrs || {};
-  const elements = decodeProperties(propertyTranslatorsBySdName$2, tableRowProperties);
-  const newNode = {
-    name: "w:trPr",
-    type: "element",
-    attributes: {},
-    elements
-  };
-  return newNode;
+    type: "tableCell",
+    attrs: {
+      colspan: 1,
+      rowspan: 1,
+      colwidth: [safeWidth],
+      __placeholder: reason,
+      borders: {
+        top: { ...noBorder },
+        right: { ...noBorder },
+        bottom: { ...noBorder },
+        left: { ...noBorder }
+      }
+    },
+    content: [{ type: "paragraph", content: [] }]
+  };
+};
+const advancePastRowSpans = (pendingRowSpans, startIndex, totalColumns) => {
+  let index2 = startIndex;
+  while (index2 < totalColumns && pendingRowSpans[index2] > 0) {
+    pendingRowSpans[index2] -= 1;
+    index2 += 1;
+  }
+  return index2;
+};
+const fillPlaceholderColumns = ({
+  content,
+  pendingRowSpans,
+  currentIndex,
+  targetIndex,
+  totalColumns,
+  gridColumnWidths,
+  reason
+}) => {
+  let index2 = currentIndex;
+  while (index2 < targetIndex && index2 < totalColumns) {
+    if (pendingRowSpans[index2] > 0) {
+      pendingRowSpans[index2] -= 1;
+      index2 += 1;
+      continue;
+    }
+    const width = Array.isArray(gridColumnWidths) ? gridColumnWidths[index2] ?? 0 : 0;
+    content.push(createPlaceholderCell(width, reason));
+    index2 += 1;
+  }
+  return index2;
 };
-const propertyTranslators$3 = [
-  translator$X,
-  translator$W,
-  translator$V,
-  translator$U,
-  translator$T,
-  translator$S,
-  translator$R,
-  translator$Q,
-  translator$P,
-  translator$O,
-  translator$N,
-  translator$M
-];
-const propertyTranslatorsByXmlName$2 = {};
-propertyTranslators$3.forEach((translator2) => {
-  propertyTranslatorsByXmlName$2[translator2.xmlName] = translator2;
-});
-const propertyTranslatorsBySdName$2 = {};
-propertyTranslators$3.forEach((translator2) => {
-  propertyTranslatorsBySdName$2[translator2.sdNodeOrKeyName] = translator2;
-});
-const config$h = {
-  xmlName: XML_NODE_NAME$k,
-  sdNodeOrKeyName: SD_ATTR_KEY$6,
-  type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$q,
-  decode: decode$s
+const isPlaceholderCell = (cell) => {
+  if (!cell) return false;
+  if (cell.attrs?.__placeholder) return true;
+  const widths = cell.attrs?.colwidth;
+  if (Array.isArray(widths) && widths.length > 0) {
+    const hasMeaningfulWidth = widths.some(
+      (value) => typeof value === "number" && Number.isFinite(value) && Math.abs(value) > 1
+    );
+    if (!hasMeaningfulWidth) return true;
+  }
+  return false;
 };
-const translator$L = NodeTranslator.from(config$h);
-const XML_NODE_NAME$j = "w:tr";
+const XML_NODE_NAME$h = "w:tr";
 const SD_NODE_NAME$d = "tableRow";
 const validXmlAttributes$b = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
   (xmlName) => createAttributeHandler(xmlName)
 );
-const encode$p = (params, encodedAttrs) => {
+const encode$n = (params, encodedAttrs) => {
   const { row } = params.extraParams;
   let tableRowProperties = {};
   const tPr = row.elements.find((el) => el.name === "w:trPr");
   if (tPr) {
-    ({ attributes: tableRowProperties } = translator$L.encode({
+    tableRowProperties = translator$_.encode({
       ...params,
       nodes: [tPr]
-    }));
+    });
   }
+  const gridBeforeRaw = tableRowProperties?.["gridBefore"];
+  const safeGridBefore = typeof gridBeforeRaw === "number" && Number.isFinite(gridBeforeRaw) && gridBeforeRaw > 0 ? gridBeforeRaw : 0;
   encodedAttrs["tableRowProperties"] = Object.freeze(tableRowProperties);
   encodedAttrs["rowHeight"] = twipsToPixels(tableRowProperties["rowHeight"]?.value);
   encodedAttrs["cantSplit"] = tableRowProperties["cantSplit"];
-  const { columnWidths: gridColumnWidths } = params.extraParams;
+  const { columnWidths: gridColumnWidths, activeRowSpans = [] } = params.extraParams;
+  const totalColumns = Array.isArray(gridColumnWidths) ? gridColumnWidths.length : 0;
+  const pendingRowSpans = Array.isArray(activeRowSpans) ? activeRowSpans.slice() : [];
+  while (pendingRowSpans.length < totalColumns) pendingRowSpans.push(0);
   const cellNodes = row.elements.filter((el) => el.name === "w:tc");
+  const content = [];
   let currentColumnIndex = 0;
-  const content = cellNodes?.map((n) => {
-    let columnWidth = gridColumnWidths?.[currentColumnIndex] || null;
+  const fillUntil = (target, reason) => {
+    currentColumnIndex = fillPlaceholderColumns({
+      content,
+      pendingRowSpans,
+      currentIndex: currentColumnIndex,
+      targetIndex: target,
+      totalColumns,
+      gridColumnWidths,
+      reason
+    });
+  };
+  const skipOccupiedColumns = () => {
+    currentColumnIndex = advancePastRowSpans(pendingRowSpans, currentColumnIndex, totalColumns);
+  };
+  fillUntil(safeGridBefore, "gridBefore");
+  skipOccupiedColumns();
+  cellNodes?.forEach((node) => {
+    skipOccupiedColumns();
+    const startColumn = currentColumnIndex;
+    const columnWidth = gridColumnWidths?.[startColumn] || null;
     const result = translator$c.encode({
       ...params,
       extraParams: {
         ...params.extraParams,
-        node: n,
-        columnIndex: currentColumnIndex,
+        node,
+        columnIndex: startColumn,
         columnWidth
       }
     });
-    const tcPr = n.elements?.find((el) => el.name === "w:tcPr");
-    const colspanTag = tcPr?.elements?.find((el) => el.name === "w:gridSpan");
-    const colspan = parseInt(colspanTag?.attributes["w:val"] || 1, 10);
-    currentColumnIndex += colspan;
-    return result;
-  }) || [];
+    if (result) {
+      content.push(result);
+      const colspan = Math.max(1, result.attrs?.colspan || 1);
+      const rowspan = Math.max(1, result.attrs?.rowspan || 1);
+      if (rowspan > 1) {
+        for (let offset = 0; offset < colspan; offset += 1) {
+          const target = startColumn + offset;
+          if (target < pendingRowSpans.length) {
+            pendingRowSpans[target] = Math.max(pendingRowSpans[target], rowspan - 1);
+          }
+        }
+      }
+      currentColumnIndex = startColumn + colspan;
+    }
+  });
+  skipOccupiedColumns();
+  fillUntil(totalColumns, "gridAfter");
   const newNode = {
     type: "tableRow",
     content,
@@ -27068,11 +27188,39 @@ const encode$p = (params, encodedAttrs) => {
   };
   return newNode;
 };
-const decode$r = (params, decodedAttrs) => {
+const decode$p = (params, decodedAttrs) => {
   const { node } = params;
-  const elements = translateChildNodes(params);
+  const cells = node.content || [];
+  let leadingPlaceholders = 0;
+  while (leadingPlaceholders < cells.length && isPlaceholderCell(cells[leadingPlaceholders])) {
+    leadingPlaceholders += 1;
+  }
+  let trailingPlaceholders = 0;
+  while (trailingPlaceholders < cells.length - leadingPlaceholders && isPlaceholderCell(cells[cells.length - 1 - trailingPlaceholders])) {
+    trailingPlaceholders += 1;
+  }
+  const trimmedSlice = cells.slice(leadingPlaceholders, cells.length - trailingPlaceholders);
+  const sanitizedCells = trimmedSlice.map((cell) => {
+    if (cell?.attrs && "__placeholder" in cell.attrs) {
+      const { __placeholder, ...rest } = cell.attrs;
+      return { ...cell, attrs: rest };
+    }
+    return cell;
+  });
+  const trimmedContent = sanitizedCells.filter((_2, index2) => !isPlaceholderCell(trimmedSlice[index2]));
+  const translateParams = {
+    ...params,
+    node: { ...node, content: trimmedContent }
+  };
+  const elements = translateChildNodes(translateParams);
   if (node.attrs?.tableRowProperties) {
     const tableRowProperties = { ...node.attrs.tableRowProperties };
+    if (leadingPlaceholders > 0) {
+      tableRowProperties.gridBefore = leadingPlaceholders;
+    }
+    if (trailingPlaceholders > 0) {
+      tableRowProperties.gridAfter = trailingPlaceholders;
+    }
     if (node.attrs.rowHeight != null) {
       const rowHeightPixels = twipsToPixels(node.attrs.tableRowProperties["rowHeight"]?.value);
       if (rowHeightPixels !== node.attrs.rowHeight) {
@@ -27080,7 +27228,7 @@ const decode$r = (params, decodedAttrs) => {
       }
     }
     tableRowProperties["cantSplit"] = node.attrs["cantSplit"];
-    const trPr = translator$L.decode({
+    const trPr = translator$_.decode({
       ...params,
       node: { ...node, attrs: { ...node.attrs, tableRowProperties } }
     });
@@ -27093,21 +27241,21 @@ const decode$r = (params, decodedAttrs) => {
   };
 };
 const config$g = {
-  xmlName: XML_NODE_NAME$j,
+  xmlName: XML_NODE_NAME$h,
   sdNodeOrKeyName: SD_NODE_NAME$d,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$p,
-  decode: decode$r,
+  encode: encode$n,
+  decode: decode$p,
   attributes: validXmlAttributes$b
 };
-const translator$K = NodeTranslator.from(config$g);
-const translator$J = NodeTranslator.from({
+const translator$Z = NodeTranslator.from(config$g);
+const translator$Y = NodeTranslator.from({
   xmlName: "w:bidiVisual",
   sdNodeOrKeyName: "rightToLeft",
   encode: ({ nodes }) => parseBoolean(nodes[0].attributes?.["w:val"] ?? "1"),
   decode: ({ node }) => node.attrs.rightToLeft ? { attributes: {} } : void 0
 });
-const translator$I = NodeTranslator.from({
+const translator$X = NodeTranslator.from({
   xmlName: "w:shd",
   sdNodeOrKeyName: "shading",
   attributes: [
@@ -27129,11 +27277,11 @@ const translator$I = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$H = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblCaption", "caption"));
-const translator$G = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblDescription", "description"));
-const translator$F = NodeTranslator.from(createMeasurementPropertyHandler("w:tblInd", "tableIndent"));
-const translator$E = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblLayout", "tableLayout", "w:type"));
-const translator$D = NodeTranslator.from({
+const translator$W = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblCaption", "caption"));
+const translator$V = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblDescription", "description"));
+const translator$U = NodeTranslator.from(createMeasurementPropertyHandler("w:tblInd", "tableIndent"));
+const translator$T = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblLayout", "tableLayout", "w:type"));
+const translator$S = NodeTranslator.from({
   xmlName: "w:tblLook",
   sdNodeOrKeyName: "tblLook",
   attributes: ["w:firstColumn", "w:firstRow", "w:lastColumn", "w:lastRow", "w:noHBand", "w:noVBand"].map((attr) => createAttributeHandler(attr, null, parseBoolean, booleanToString)).concat([createAttributeHandler("w:val")]),
@@ -27145,16 +27293,16 @@ const translator$D = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$C = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblOverlap", "overlap"));
-const translator$B = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblStyle", "tableStyleId"));
-const translator$A = NodeTranslator.from(
+const translator$R = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblOverlap", "overlap"));
+const translator$Q = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblStyle", "tableStyleId"));
+const translator$P = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:tblStyleColBandSize", "tableStyleColBandSize")
 );
-const translator$z = NodeTranslator.from(
+const translator$O = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:tblStyleRowBandSize", "tableStyleRowBandSize")
 );
-const translator$y = NodeTranslator.from(createMeasurementPropertyHandler("w:tblW", "tableWidth"));
-const translator$x = NodeTranslator.from({
+const translator$N = NodeTranslator.from(createMeasurementPropertyHandler("w:tblW", "tableWidth"));
+const translator$M = NodeTranslator.from({
   xmlName: "w:tblpPr",
   sdNodeOrKeyName: "floatingTableProperties",
   attributes: ["w:leftFromText", "w:rightFromText", "w:topFromText", "w:bottomFromText", "w:tblpX", "w:tblpY"].map((attr) => createAttributeHandler(attr, null, parseInteger, integerToString)).concat(["w:horzAnchor", "w:vertAnchor", "w:tblpXSpec", "w:tblpYSpec"].map((attr) => createAttributeHandler(attr))),
@@ -27166,160 +27314,67 @@ const translator$x = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$w = NodeTranslator.from(createBorderPropertyHandler("w:bottom"));
-const translator$v = NodeTranslator.from(createMeasurementPropertyHandler("w:bottom", "marginBottom"));
-const translator$u = NodeTranslator.from(createBorderPropertyHandler("w:end"));
-const translator$t = NodeTranslator.from(createMeasurementPropertyHandler("w:end", "marginEnd"));
-const translator$s = NodeTranslator.from(createBorderPropertyHandler("w:insideH"));
-const translator$r = NodeTranslator.from(createBorderPropertyHandler("w:insideV"));
-const translator$q = NodeTranslator.from(createBorderPropertyHandler("w:left"));
-const translator$p = NodeTranslator.from(createMeasurementPropertyHandler("w:left", "marginLeft"));
-const translator$o = NodeTranslator.from(createBorderPropertyHandler("w:right"));
-const translator$n = NodeTranslator.from(createMeasurementPropertyHandler("w:right", "marginRight"));
-const translator$m = NodeTranslator.from(createBorderPropertyHandler("w:start"));
-const translator$l = NodeTranslator.from(createMeasurementPropertyHandler("w:start", "marginStart"));
-const translator$k = NodeTranslator.from(createBorderPropertyHandler("w:top"));
-const translator$j = NodeTranslator.from(createMeasurementPropertyHandler("w:top", "marginTop"));
-const XML_NODE_NAME$i = "w:tblBorders";
-const SD_ATTR_KEY$5 = "borders";
-const encode$o = (params) => {
-  const { nodes } = params;
-  const node = nodes[0];
-  const attributes = encodeProperties(node, tblBordersTranslatorsByXmlName);
-  return Object.keys(attributes).length > 0 ? attributes : void 0;
-};
-const decode$q = (params) => {
-  const { borders = {} } = params.node.attrs || {};
-  const elements = decodeProperties(tblBordersTranslatorsBySdName, borders);
-  const newNode = {
-    name: "w:tblBorders",
-    type: "element",
-    attributes: {},
-    elements
-  };
-  return newNode;
-};
-const propertyTranslators$2 = [
-  translator$w,
-  translator$u,
-  translator$s,
-  translator$r,
-  translator$q,
-  translator$o,
-  translator$m,
-  translator$k
-];
-const tblBordersTranslatorsByXmlName = {};
-const tblBordersTranslatorsBySdName = {};
-propertyTranslators$2.forEach((translator2) => {
-  tblBordersTranslatorsByXmlName[translator2.xmlName] = translator2;
-  tblBordersTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
-});
-const translator$i = NodeTranslator.from({
-  xmlName: XML_NODE_NAME$i,
-  sdNodeOrKeyName: SD_ATTR_KEY$5,
-  type: NodeTranslator.translatorTypes.NODE,
-  attributes: [],
-  encode: encode$o,
-  decode: decode$q
-});
-const XML_NODE_NAME$h = "w:tblCellMar";
-const SD_ATTR_KEY$4 = "cellMargins";
-const encode$n = (params) => {
-  const { nodes } = params;
-  const node = nodes[0];
-  const attributes = encodeProperties(node, propertyTranslatorsByXmlName$1);
-  return Object.keys(attributes).length > 0 ? attributes : void 0;
-};
-const decode$p = (params) => {
-  const { cellMargins = {} } = params.node.attrs || {};
-  const elements = decodeProperties(propertyTranslatorsBySdName$1, cellMargins);
-  const newNode = {
-    name: XML_NODE_NAME$h,
-    type: "element",
-    attributes: {},
-    elements
-  };
-  return newNode;
-};
-const propertyTranslators$1 = [
-  translator$v,
-  translator$t,
-  translator$p,
-  translator$n,
-  translator$l,
-  translator$j
-];
-const propertyTranslatorsByXmlName$1 = {};
-const propertyTranslatorsBySdName$1 = {};
-propertyTranslators$1.forEach((translator2) => {
-  propertyTranslatorsByXmlName$1[translator2.xmlName] = translator2;
-  propertyTranslatorsBySdName$1[translator2.sdNodeOrKeyName] = translator2;
-});
-const translator$h = NodeTranslator.from({
-  xmlName: XML_NODE_NAME$h,
-  sdNodeOrKeyName: SD_ATTR_KEY$4,
-  type: NodeTranslator.translatorTypes.NODE,
-  attributes: [],
-  encode: encode$n,
-  decode: decode$p
-});
-const XML_NODE_NAME$g = "w:tblPr";
-const SD_ATTR_KEY$3 = "tableProperties";
-const encode$m = (params) => {
-  const { nodes } = params;
-  const node = nodes[0];
-  const attributes = encodeProperties(node, propertyTranslatorsByXmlName);
-  return {
-    xmlName: XML_NODE_NAME$g,
-    sdNodeOrKeyName: SD_ATTR_KEY$3,
-    attributes
-  };
-};
-const decode$o = (params) => {
-  const { tableProperties = {} } = params.node.attrs || {};
-  const elements = decodeProperties(propertyTranslatorsBySdName, tableProperties);
-  const newNode = {
-    name: "w:tblPr",
-    type: "element",
-    attributes: {},
-    elements
-  };
-  return newNode;
-};
-const propertyTranslators = [
+const translator$L = NodeTranslator.from(createBorderPropertyHandler("w:bottom"));
+const translator$K = NodeTranslator.from(createMeasurementPropertyHandler("w:bottom", "marginBottom"));
+const translator$J = NodeTranslator.from(createBorderPropertyHandler("w:end"));
+const translator$I = NodeTranslator.from(createMeasurementPropertyHandler("w:end", "marginEnd"));
+const translator$H = NodeTranslator.from(createBorderPropertyHandler("w:insideH"));
+const translator$G = NodeTranslator.from(createBorderPropertyHandler("w:insideV"));
+const translator$F = NodeTranslator.from(createBorderPropertyHandler("w:left"));
+const translator$E = NodeTranslator.from(createMeasurementPropertyHandler("w:left", "marginLeft"));
+const translator$D = NodeTranslator.from(createBorderPropertyHandler("w:right"));
+const translator$C = NodeTranslator.from(createMeasurementPropertyHandler("w:right", "marginRight"));
+const translator$B = NodeTranslator.from(createBorderPropertyHandler("w:start"));
+const translator$A = NodeTranslator.from(createMeasurementPropertyHandler("w:start", "marginStart"));
+const translator$z = NodeTranslator.from(createBorderPropertyHandler("w:top"));
+const translator$y = NodeTranslator.from(createMeasurementPropertyHandler("w:top", "marginTop"));
+const propertyTranslators$5 = [
+  translator$L,
   translator$J,
-  translator$R,
-  translator$I,
   translator$H,
-  translator$Q,
   translator$G,
   translator$F,
-  translator$E,
   translator$D,
-  translator$C,
   translator$B,
+  translator$z
+];
+const translator$x = NodeTranslator.from(
+  createNestedPropertiesTranslator("w:tblBorders", "borders", propertyTranslators$5)
+);
+const propertyTranslators$4 = [
+  translator$K,
+  translator$I,
+  translator$E,
+  translator$C,
   translator$A,
-  translator$z,
-  translator$y,
+  translator$y
+];
+const translator$w = NodeTranslator.from(
+  createNestedPropertiesTranslator("w:tblCellMar", "cellMargins", propertyTranslators$4)
+);
+const propertyTranslators$3 = [
+  translator$Y,
+  translator$14,
+  translator$X,
+  translator$W,
+  translator$13,
+  translator$V,
+  translator$U,
+  translator$T,
+  translator$S,
+  translator$R,
+  translator$Q,
+  translator$P,
+  translator$O,
+  translator$N,
+  translator$M,
   translator$x,
-  translator$i,
-  translator$h
+  translator$w
 ];
-const propertyTranslatorsByXmlName = {};
-const propertyTranslatorsBySdName = {};
-propertyTranslators.forEach((translator2) => {
-  propertyTranslatorsByXmlName[translator2.xmlName] = translator2;
-  propertyTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
-});
-const config$f = {
-  xmlName: XML_NODE_NAME$g,
-  sdNodeOrKeyName: SD_ATTR_KEY$3,
-  encode: encode$m,
-  decode: decode$o
-};
-const translator$g = NodeTranslator.from(config$f);
-const translator$f = NodeTranslator.from(
+const translator$v = NodeTranslator.from(
+  createNestedPropertiesTranslator("w:tblPr", "tableProperties", propertyTranslators$3)
+);
+const translator$u = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:gridCol", "col", "w:w", parseInteger, integerToString)
 );
 const DEFAULT_COLUMN_WIDTH_PX = 100;
@@ -27369,20 +27424,20 @@ const resolveFallbackColumnWidthTwips = (params, totalColumns, cellMinWidthTwips
   }
   return Math.max(fallbackWidthTwips, cellMinWidthTwips);
 };
-const XML_NODE_NAME$f = "w:tblGrid";
-const SD_ATTR_KEY$2 = "grid";
+const XML_NODE_NAME$g = "w:tblGrid";
+const SD_ATTR_KEY$3 = "grid";
 const cellMinWidth = pixelsToTwips(10);
-const encode$l = (params) => {
+const encode$m = (params) => {
   const { nodes } = params;
   const node = nodes[0];
-  const attributes = encodeProperties(node, { [translator$f.xmlName]: translator$f }, true);
+  const attributes = encodeProperties(node, { [translator$u.xmlName]: translator$u }, true);
   return {
-    xmlName: XML_NODE_NAME$f,
-    sdNodeOrKeyName: SD_ATTR_KEY$2,
+    xmlName: XML_NODE_NAME$g,
+    sdNodeOrKeyName: SD_ATTR_KEY$3,
     attributes
   };
 };
-const decode$n = (params) => {
+const decode$o = (params) => {
   const { grid: rawGrid } = params.node.attrs || {};
   const grid = Array.isArray(rawGrid) ? rawGrid : [];
   const { firstRow = {} } = params.extraParams || {};
@@ -27395,17 +27450,21 @@ const decode$n = (params) => {
   const fallbackColumnWidthTwips = resolveFallbackColumnWidthTwips(params, totalColumns, cellMinWidth);
   const elements = [];
   let columnIndex = 0;
-  const pushColumn = (widthTwips) => {
+  const pushColumn = (widthTwips, { enforceMinimum = false } = {}) => {
     let numericWidth = typeof widthTwips === "string" ? parseInt(widthTwips, 10) : widthTwips;
+    let shouldEnforceMinimum = enforceMinimum;
     if (numericWidth == null || Number.isNaN(numericWidth) || numericWidth <= 0) {
       numericWidth = fallbackColumnWidthTwips;
+      shouldEnforceMinimum = true;
     }
-    numericWidth = Math.max(numericWidth, cellMinWidth);
-    const decoded = translator$f.decode({
+    const roundedWidth = Math.round(numericWidth);
+    const minimumWidth = shouldEnforceMinimum ? cellMinWidth : 1;
+    const safeWidth = Math.max(roundedWidth, minimumWidth);
+    const decoded = translator$u.decode({
       node: { type: (
         /** @type {string} */
-        translator$f.sdNodeOrKeyName
-      ), attrs: { col: numericWidth } }
+        translator$u.sdNodeOrKeyName
+      ), attrs: { col: safeWidth } }
     });
     if (decoded) elements.push(decoded);
   };
@@ -27413,13 +27472,17 @@ const decode$n = (params) => {
     const { colspan = 1, colwidth } = cell?.attrs || {};
     const spanCount = Math.max(1, colspan);
     for (let span = 0; span < spanCount; span++) {
-      const cellWidthPixels = Array.isArray(colwidth) ? colwidth[span] : void 0;
+      const rawWidth = Array.isArray(colwidth) ? colwidth[span] : void 0;
+      const cellWidthPixels = typeof rawWidth === "number" && Number.isFinite(rawWidth) ? rawWidth : Number(rawWidth);
+      const hasCellWidth = Number.isFinite(cellWidthPixels) && cellWidthPixels > 0;
       const colGridAttrs = grid?.[columnIndex] || {};
       const gridWidthTwips = normalizeTwipWidth(colGridAttrs.col);
       const gridWidthPixels = gridWidthTwips != null ? twipsToPixels(gridWidthTwips) : null;
       let cellWidthTwips;
-      if (cellWidthPixels != null) {
-        if (gridWidthTwips != null && gridWidthPixels === cellWidthPixels) {
+      let enforceMinimum = false;
+      if (hasCellWidth) {
+        const tolerance = 0.5;
+        if (gridWidthTwips != null && gridWidthPixels != null && Math.abs(gridWidthPixels - cellWidthPixels) <= tolerance) {
           cellWidthTwips = gridWidthTwips;
         } else {
           cellWidthTwips = pixelsToTwips(cellWidthPixels);
@@ -27428,8 +27491,9 @@ const decode$n = (params) => {
         cellWidthTwips = gridWidthTwips;
       } else {
         cellWidthTwips = fallbackColumnWidthTwips;
+        enforceMinimum = true;
       }
-      pushColumn(cellWidthTwips);
+      pushColumn(cellWidthTwips, { enforceMinimum });
       columnIndex++;
     }
   });
@@ -27439,19 +27503,19 @@ const decode$n = (params) => {
     columnIndex++;
   }
   const newNode = {
-    name: XML_NODE_NAME$f,
+    name: XML_NODE_NAME$g,
     attributes: {},
     elements
   };
   return newNode;
 };
-const config$e = {
-  xmlName: XML_NODE_NAME$f,
-  sdNodeOrKeyName: SD_ATTR_KEY$2,
-  encode: encode$l,
-  decode: decode$n
+const config$f = {
+  xmlName: XML_NODE_NAME$g,
+  sdNodeOrKeyName: SD_ATTR_KEY$3,
+  encode: encode$m,
+  decode: decode$o
 };
-const translator$e = NodeTranslator.from(config$e);
+const translator$t = NodeTranslator.from(config$f);
 const DEFAULT_PAGE_WIDTH_TWIPS = 12240;
 const DEFAULT_PAGE_MARGIN_TWIPS = 1440;
 const DEFAULT_CONTENT_WIDTH_TWIPS = DEFAULT_PAGE_WIDTH_TWIPS - 2 * DEFAULT_PAGE_MARGIN_TWIPS;
@@ -27514,19 +27578,19 @@ const buildFallbackGridForTable = ({ params, rows, tableWidth, tableWidthMeasure
     columnWidths: Array(columnCount).fill(fallbackColumnWidthPx)
   };
 };
-const XML_NODE_NAME$e = "w:tbl";
+const XML_NODE_NAME$f = "w:tbl";
 const SD_NODE_NAME$c = "table";
-const encode$k = (params, encodedAttrs) => {
+const encode$l = (params, encodedAttrs) => {
   const { nodes } = params;
   const node = nodes[0];
   const tblPr = node.elements.find((el) => el.name === "w:tblPr");
   if (tblPr) {
-    const encodedProperties = translator$g.encode({ ...params, nodes: [tblPr] });
-    encodedAttrs["tableProperties"] = encodedProperties?.attributes || {};
+    const encodedProperties = translator$v.encode({ ...params, nodes: [tblPr] });
+    encodedAttrs["tableProperties"] = encodedProperties || {};
   }
   const tblGrid = node.elements.find((el) => el.name === "w:tblGrid");
   if (tblGrid) {
-    encodedAttrs["grid"] = translator$e.encode({ ...params, nodes: [tblGrid] }).attributes;
+    encodedAttrs["grid"] = translator$t.encode({ ...params, nodes: [tblGrid] }).attributes;
   }
   [
     "tableStyleId",
@@ -27592,8 +27656,10 @@ const encode$k = (params, encodedAttrs) => {
     }
   }
   const content = [];
-  rows.forEach((row) => {
-    const result = translator$K.encode({
+  const totalColumns = columnWidths.length;
+  const activeRowSpans = totalColumns > 0 ? new Array(totalColumns).fill(0) : [];
+  rows.forEach((row, rowIndex) => {
+    const result = translator$Z.encode({
       ...params,
       nodes: [row],
       extraParams: {
@@ -27601,10 +27667,45 @@ const encode$k = (params, encodedAttrs) => {
         table: node,
         rowBorders: borderRowData,
         styleTag: tblStyleTag,
-        columnWidths
+        columnWidths,
+        activeRowSpans: activeRowSpans.slice(),
+        rowIndex
       }
     });
-    if (result) content.push(result);
+    if (result) {
+      content.push(result);
+      if (totalColumns > 0) {
+        const activeRowSpansForCurrentRow = activeRowSpans.slice();
+        for (let col = 0; col < totalColumns; col++) {
+          if (activeRowSpans[col] > 0) {
+            activeRowSpans[col] -= 1;
+          }
+        }
+        let columnIndex = 0;
+        const advanceColumnIndex = () => {
+          while (columnIndex < totalColumns && activeRowSpansForCurrentRow[columnIndex] > 0) {
+            columnIndex += 1;
+          }
+        };
+        advanceColumnIndex();
+        result.content?.forEach((cell) => {
+          advanceColumnIndex();
+          const colspan = Math.max(1, cell.attrs?.colspan || 1);
+          const rowspan = Math.max(1, cell.attrs?.rowspan || 1);
+          if (rowspan > 1) {
+            for (let offset = 0; offset < colspan && columnIndex + offset < totalColumns; offset++) {
+              const targetIndex = columnIndex + offset;
+              const remainingRows = rowspan - 1;
+              if (remainingRows > 0 && remainingRows > activeRowSpans[targetIndex]) {
+                activeRowSpans[targetIndex] = remainingRows;
+              }
+            }
+          }
+          columnIndex += colspan;
+          advanceColumnIndex();
+        });
+      }
+    }
   });
   return {
     type: "table",
@@ -27612,13 +27713,13 @@ const encode$k = (params, encodedAttrs) => {
     attrs: encodedAttrs
   };
 };
-const decode$m = (params, decodedAttrs) => {
+const decode$n = (params, decodedAttrs) => {
   params.node = preProcessVerticalMergeCells(params.node, params);
   const { node } = params;
   const elements = translateChildNodes(params);
   const firstRow = node.content?.find((n) => n.type === "tableRow");
   const properties = node.attrs.grid;
-  const element = translator$e.decode({
+  const element = translator$t.decode({
     ...params,
     node: { ...node, attrs: { ...node.attrs, grid: properties } },
     extraParams: {
@@ -27628,7 +27729,7 @@ const decode$m = (params, decodedAttrs) => {
   if (element) elements.unshift(element);
   if (node.attrs?.tableProperties) {
     const properties2 = { ...node.attrs.tableProperties };
-    const element2 = translator$g.decode({
+    const element2 = translator$v.decode({
       ...params,
       node: { ...node, attrs: { ...node.attrs, tableProperties: properties2 } }
     });
@@ -27648,7 +27749,7 @@ function _processTableBorders(rawBorders) {
     const color = attributes.color;
     const size = attributes.size;
     if (color && color !== "auto") attrs["color"] = color.startsWith("#") ? color : `#${color}`;
-    if (size && size !== "auto") attrs["size"] = eigthPointsToPixels(size);
+    if (size && size !== "auto") attrs["size"] = eighthPointsToPixels(size);
     const rowBorderNames = ["insideH", "insideV"];
     if (rowBorderNames.includes(name)) rowBorders[name] = attrs;
     borders[name] = attrs;
@@ -27694,7 +27795,7 @@ function _getReferencedTableStyles(tableStyleReference, params) {
     if (baseTblPr && baseTblPr.elements) {
       tblPr.elements.push(...baseTblPr.elements);
     }
-    const tableProperties = translator$g.encode({ ...params, nodes: [tblPr] }).attributes;
+    const tableProperties = translator$v.encode({ ...params, nodes: [tblPr] });
     const { borders, rowBorders } = _processTableBorders(tableProperties.borders || {});
     if (borders) stylesToReturn.borders = borders;
     if (rowBorders) stylesToReturn.rowBorders = rowBorders;
@@ -27711,16 +27812,16 @@ function _getReferencedTableStyles(tableStyleReference, params) {
   }
   return stylesToReturn;
 }
-const config$d = {
-  xmlName: XML_NODE_NAME$e,
+const config$e = {
+  xmlName: XML_NODE_NAME$f,
   sdNodeOrKeyName: SD_NODE_NAME$c,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$k,
-  decode: decode$m,
+  encode: encode$l,
+  decode: decode$n,
   attributes: []
 };
-const translator$d = NodeTranslator.from(config$d);
-const tableNodeHandlerEntity = generateV2HandlerEntity("tableNodeHandler", translator$d);
+const translator$s = NodeTranslator.from(config$e);
+const tableNodeHandlerEntity = generateV2HandlerEntity("tableNodeHandler", translator$s);
 function getReferencedTableStyles(tblStyleTag, docx) {
   if (!tblStyleTag) return null;
   const stylesToReturn = {};
@@ -27791,7 +27892,7 @@ function processTableBorders(borderElements) {
     const color = attributes["w:color"];
     const size = attributes["w:sz"];
     if (color && color !== "auto") attrs["color"] = color.startsWith("#") ? color : `#${color}`;
-    if (size && size !== "auto") attrs["size"] = eigthPointsToPixels(size);
+    if (size && size !== "auto") attrs["size"] = eighthPointsToPixels(size);
     const rowBorderNames = ["insideH", "insideV"];
     if (rowBorderNames.includes(borderName)) rowBorders[borderName] = attrs;
     borders[borderName] = attrs;
@@ -27801,6 +27902,125 @@ function processTableBorders(borderElements) {
     rowBorders
   };
 }
+const translator$r = NodeTranslator.from(createMeasurementPropertyHandler("w:tcW", "cellWidth"));
+const translator$q = NodeTranslator.from(
+  createSingleAttrPropertyHandler(
+    "w:gridSpan",
+    null,
+    "w:val",
+    (v2) => parseInteger(v2) ?? void 0,
+    (v2) => integerToString(v2)
+  )
+);
+const translator$p = NodeTranslator.from(createSingleAttrPropertyHandler("w:vMerge"));
+const translator$o = NodeTranslator.from(createBorderPropertyHandler("w:tl2br"));
+const translator$n = NodeTranslator.from(createBorderPropertyHandler("w:tr2bl"));
+const propertyTranslators$2 = [
+  translator$z,
+  translator$B,
+  translator$F,
+  translator$L,
+  translator$J,
+  translator$D,
+  translator$H,
+  translator$G,
+  translator$o,
+  translator$n
+];
+const translator$m = NodeTranslator.from(
+  createNestedPropertiesTranslator("w:tcBorders", "borders", propertyTranslators$2)
+);
+const translator$l = NodeTranslator.from(
+  createSingleAttrPropertyHandler(
+    "w:noWrap",
+    null,
+    "w:val",
+    (v2) => parseBoolean(v2 ?? "true"),
+    (v2) => booleanToString(v2)
+  )
+);
+const propertyTranslators$1 = [
+  translator$K,
+  translator$I,
+  translator$E,
+  translator$C,
+  translator$A,
+  translator$y
+];
+const translator$k = NodeTranslator.from(
+  createNestedPropertiesTranslator("w:tcMar", "cellMargins", propertyTranslators$1)
+);
+const translator$j = NodeTranslator.from(createSingleAttrPropertyHandler("w:textDirection"));
+const translator$i = NodeTranslator.from(
+  createSingleAttrPropertyHandler(
+    "w:tcFitText",
+    null,
+    "w:val",
+    (v2) => parseBoolean(v2 ?? "true"),
+    (v2) => booleanToString(v2)
+  )
+);
+const translator$h = NodeTranslator.from(createSingleAttrPropertyHandler("w:vAlign"));
+const translator$g = NodeTranslator.from(
+  createSingleAttrPropertyHandler(
+    "w:hideMark",
+    null,
+    "w:val",
+    (v2) => parseBoolean(v2 ?? "true"),
+    (v2) => booleanToString(v2)
+  )
+);
+const translator$f = NodeTranslator.from(createSingleAttrPropertyHandler("w:header"));
+const XML_NODE_NAME$e = "w:headers";
+const SD_ATTR_KEY$2 = "headers";
+const encode$k = (params) => {
+  const { nodes } = params;
+  const node = nodes[0];
+  const attributes = encodeProperties(node, { [translator$f.xmlName]: translator$f }, true);
+  return {
+    xmlName: XML_NODE_NAME$e,
+    sdNodeOrKeyName: SD_ATTR_KEY$2,
+    attributes
+  };
+};
+const decode$m = (params) => {
+  const { headers = [] } = params.node.attrs || {};
+  const newNode = {
+    name: XML_NODE_NAME$e,
+    attributes: {},
+    elements: headers.map(
+      (header) => translator$f.decode({
+        node: { type: "header", attrs: header }
+      })
+    )
+  };
+  return newNode;
+};
+const config$d = {
+  xmlName: XML_NODE_NAME$e,
+  sdNodeOrKeyName: SD_ATTR_KEY$2,
+  encode: encode$k,
+  decode: decode$m
+};
+const translator$e = NodeTranslator.from(config$d);
+const propertyTranslators = [
+  translator$19,
+  translator$r,
+  translator$q,
+  translator$p,
+  translator$m,
+  translator$X,
+  translator$l,
+  translator$k,
+  translator$j,
+  translator$i,
+  translator$h,
+  translator$g,
+  translator$e
+];
+const translator$d = NodeTranslator.from(
+  createNestedPropertiesTranslator("w:tcPr", "tableCellProperties", propertyTranslators)
+);
 function handleTableCellNode({
   params,
   node,
@@ -27813,8 +28033,10 @@ function handleTableCellNode({
   allColumnWidths = []
 }) {
   const { docx, nodeListHandler } = params;
+  const attributes = {};
   const tcPr = node.elements.find((el) => el.name === "w:tcPr");
-  const borders = tcPr?.elements?.find((el) => el.name === "w:tcBorders");
+  const tableCellProperties = tcPr ? translator$d.encode({ ...params, nodes: [tcPr] }) ?? {} : {};
+  attributes["tableCellProperties"] = tableCellProperties;
   if (rowBorders?.insideH) {
     rowBorders["bottom"] = rowBorders.insideH;
     delete rowBorders.insideH;
@@ -27823,33 +28045,20 @@ function handleTableCellNode({
     rowBorders["right"] = rowBorders.insideV;
     delete rowBorders?.insideV;
   }
-  const inlineBorders = processInlineCellBorders(borders, rowBorders);
-  const gridColumnWidths = allColumnWidths;
-  const tcWidth = tcPr?.elements?.find((el) => el.name === "w:tcW");
-  let width = tcWidth ? twipsToPixels(tcWidth.attributes["w:w"]) : null;
-  const widthType = tcWidth?.attributes["w:type"];
+  if (rowBorders) attributes["borders"] = { ...rowBorders };
+  const inlineBorders = processInlineCellBorders(tableCellProperties.borders, rowBorders);
+  if (inlineBorders) attributes["borders"] = Object.assign(attributes["borders"] || {}, inlineBorders);
+  const colspan = tableCellProperties.gridSpan;
+  if (colspan && !isNaN(parseInt(colspan, 10))) attributes["colspan"] = parseInt(colspan, 10);
+  let width = tableCellProperties.cellWidth?.value ? twipsToPixels(tableCellProperties.cellWidth?.value) : null;
+  const widthType = tableCellProperties.cellWidth?.type;
+  if (widthType) attributes["widthType"] = widthType;
   if (!width && columnWidth) width = columnWidth;
-  const vMerge = getTableCellMergeTag(node);
-  const { attributes: vMergeAttrs } = vMerge || {};
-  const backgroundColor = tcPr?.elements?.find((el) => el.name === "w:shd");
-  const background = {
-    color: backgroundColor?.attributes["w:fill"]
-  };
-  const colspanTag = tcPr?.elements?.find((el) => el.name === "w:gridSpan");
-  const colspan = colspanTag?.attributes["w:val"];
-  const marginTag = tcPr?.elements?.find((el) => el.name === "w:tcMar");
-  const verticalAlignTag = tcPr?.elements?.find((el) => el.name === "w:vAlign");
-  const verticalAlign = verticalAlignTag?.attributes["w:val"] || "top";
-  const attributes = {};
-  const referencedStyles = getReferencedTableStyles(styleTag, docx) || {};
-  attributes.cellMargins = getTableCellMargins(marginTag, referencedStyles);
-  const { fontSize, fonts = {} } = referencedStyles;
-  const fontFamily = fonts["ascii"];
   if (width) {
     attributes["colwidth"] = [width];
     attributes["widthUnit"] = "px";
-    const defaultColWidths = gridColumnWidths;
-    const hasDefaultColWidths = gridColumnWidths && gridColumnWidths.length > 0;
+    const defaultColWidths = allColumnWidths;
+    const hasDefaultColWidths = allColumnWidths && allColumnWidths.length > 0;
     const colspanNum = parseInt(colspan || 1, 10);
     if (colspanNum && colspanNum > 1 && hasDefaultColWidths) {
       let colwidth = [];
@@ -27867,15 +28076,19 @@ function handleTableCellNode({
       }
     }
   }
-  if (widthType) attributes["widthType"] = widthType;
-  if (colspan) attributes["colspan"] = parseInt(colspan, 10);
-  if (background) attributes["background"] = background;
-  attributes["verticalAlign"] = verticalAlign;
+  const background = {
+    color: tableCellProperties.shading?.fill
+  };
+  if (background.color) attributes["background"] = background;
+  const verticalAlign = tableCellProperties.vAlign;
+  if (verticalAlign) attributes["verticalAlign"] = verticalAlign;
+  const referencedStyles = getReferencedTableStyles(styleTag, docx) || { fontSize: null, fonts: {}, cellMargins: {} };
+  attributes.cellMargins = getTableCellMargins(tableCellProperties.cellMargins, referencedStyles);
+  const { fontSize, fonts = {} } = referencedStyles;
+  const fontFamily = fonts["ascii"];
   if (fontSize) attributes["fontSize"] = fontSize;
-  if (fontFamily) attributes["fontFamily"] = fontFamily["ascii"];
-  if (rowBorders) attributes["borders"] = { ...rowBorders };
-  if (inlineBorders) attributes["borders"] = Object.assign(attributes["borders"] || {}, inlineBorders);
-  if (vMergeAttrs && vMergeAttrs["w:val"] === "restart") {
+  if (fontFamily) attributes["fontFamily"] = fontFamily;
+  if (tableCellProperties.vMerge === "restart") {
     const rows = table.elements.filter((el) => el.name === "w:tr");
     const currentRowIndex = rows.findIndex((r) => r === row);
     const remainingRows = rows.slice(currentRowIndex + 1);
@@ -27886,9 +28099,8 @@ function handleTableCellNode({
       const firstCell = remainingRow.elements.findIndex((el) => el.name === "w:tc");
       const cellAtIndex = remainingRow.elements[firstCell + cellIndex];
       if (!cellAtIndex) break;
-      const vMerge2 = getTableCellMergeTag(cellAtIndex);
-      const { attributes: currentCellMergeAttrs } = vMerge2 || {};
-      if (!vMerge2 && !currentCellMergeAttrs || currentCellMergeAttrs && currentCellMergeAttrs["w:val"] === "restart") {
+      const vMerge = getTableCellVMerge(cellAtIndex);
+      if (!vMerge || vMerge === "restart") {
         break;
       }
       rowspan++;
@@ -27908,69 +28120,52 @@ function handleTableCellNode({
 }
 const processInlineCellBorders = (borders, rowBorders) => {
   if (!borders) return null;
-  const processedBorders = {};
-  const inlineBorderBottom = processBorder(borders, "bottom", rowBorders);
-  if (inlineBorderBottom) processedBorders["bottom"] = inlineBorderBottom;
-  const inlineBorderTop = processBorder(borders, "top", rowBorders);
-  if (inlineBorderTop) processedBorders["top"] = inlineBorderTop;
-  const inlineBorderLeft = processBorder(borders, "left", rowBorders);
-  if (inlineBorderLeft) processedBorders["left"] = inlineBorderLeft;
-  const inlineBorderRight = processBorder(borders, "right", rowBorders);
-  if (inlineBorderRight) processedBorders["right"] = inlineBorderRight;
-  return processedBorders;
-};
-const processBorder = (borders, direction, rowBorders = {}) => {
-  const borderAttrs = borders?.elements?.find((el) => el.name === `w:${direction}`)?.attributes;
-  if (borderAttrs && borderAttrs["w:val"] !== "nil") {
-    const border = {};
-    const color = borderAttrs["w:color"];
-    if (color) border["color"] = color === "auto" ? "#000000" : `#${color}`;
-    const size = borderAttrs["w:sz"];
-    if (size) border["size"] = eigthPointsToPixels(size);
-    return border;
-  }
-  if (borderAttrs && borderAttrs["w:val"] === "nil") {
-    const border = Object.assign({}, rowBorders[direction] || {});
-    if (!Object.keys(border)) return null;
-    border["val"] = "none";
-    return border;
-  }
-  return null;
+  return ["bottom", "top", "left", "right"].reduce((acc, direction) => {
+    const borderAttrs = borders[direction];
+    const rowBorderAttrs = rowBorders[direction];
+    if (borderAttrs && borderAttrs["val"] !== "nil") {
+      const color = borderAttrs["color"];
+      let size = borderAttrs["size"];
+      if (size) size = eighthPointsToPixels(size);
+      acc[direction] = { color, size, val: borderAttrs["val"] };
+      return acc;
+    }
+    if (borderAttrs && borderAttrs["val"] === "nil") {
+      const border = Object.assign({}, rowBorderAttrs || {});
+      if (!Object.keys(border).length) {
+        return acc;
+      } else {
+        border["val"] = "none";
+        acc[direction] = border;
+        return acc;
+      }
+    }
+    return acc;
+  }, {});
 };
-const getTableCellMergeTag = (node) => {
+const getTableCellVMerge = (node) => {
   const tcPr = node.elements.find((el) => el.name === "w:tcPr");
   const vMerge = tcPr?.elements?.find((el) => el.name === "w:vMerge");
-  return vMerge;
-};
-const getTableCellMargins = (marginTag, referencedStyles) => {
-  const inlineMarginLeftTag = marginTag?.elements?.find((el) => el.name === "w:left");
-  const inlineMarginRightTag = marginTag?.elements?.find((el) => el.name === "w:right");
-  const inlineMarginTopTag = marginTag?.elements?.find((el) => el.name === "w:top");
-  const inlineMarginBottomTag = marginTag?.elements?.find((el) => el.name === "w:bottom");
-  const inlineMarginLeftValue = inlineMarginLeftTag?.attributes["w:w"];
-  const inlineMarginRightValue = inlineMarginRightTag?.attributes["w:w"];
-  const inlineMarginTopValue = inlineMarginTopTag?.attributes["w:w"];
-  const inlineMarginBottomValue = inlineMarginBottomTag?.attributes["w:w"];
+  if (!vMerge) return null;
+  return vMerge.attributes?.["w:val"] || "continue";
+};
+const getTableCellMargins = (inlineMargins, referencedStyles) => {
   const { cellMargins = {} } = referencedStyles;
-  const {
-    marginLeft: marginLeftStyle,
-    marginRight: marginRightStyle,
-    marginTop: marginTopStyle,
-    marginBottom: marginBottomStyle
-  } = cellMargins;
-  const resolveMargin = (inlineValue, styleValue) => {
-    if (inlineValue != null) return inlineValue;
-    if (styleValue == null) return void 0;
-    if (typeof styleValue === "object") return styleValue.value;
-    return styleValue;
-  };
-  const margins = {
-    left: twipsToPixels(resolveMargin(inlineMarginLeftValue, marginLeftStyle)),
-    right: twipsToPixels(resolveMargin(inlineMarginRightValue, marginRightStyle)),
-    top: twipsToPixels(resolveMargin(inlineMarginTopValue, marginTopStyle)),
-    bottom: twipsToPixels(resolveMargin(inlineMarginBottomValue, marginBottomStyle))
-  };
-  return margins;
+  return ["left", "right", "top", "bottom"].reduce((acc, direction) => {
+    const key = `margin${direction.charAt(0).toUpperCase() + direction.slice(1)}`;
+    const inlineValue = inlineMargins ? inlineMargins?.[key]?.value : null;
+    const styleValue = cellMargins ? cellMargins[key] : null;
+    if (inlineValue != null) {
+      acc[direction] = twipsToPixels(inlineValue);
+    } else if (styleValue == null) {
+      acc[direction] = void 0;
+    } else if (typeof styleValue === "object") {
+      acc[direction] = twipsToPixels(styleValue.value);
+    } else {
+      acc[direction] = twipsToPixels(styleValue);
+    }
+    return acc;
+  }, {});
 };
 function translateTableCell(params) {
   const elements = translateChildNodes({
@@ -27985,102 +28180,86 @@ function translateTableCell(params) {
   };
 }
 function generateTableCellProperties(node) {
-  const elements = [];
+  const tableCellProperties = { ...node.attrs?.tableCellProperties || {} };
   const { attrs } = node;
-  const { colwidth = [], cellWidthType = "dxa", background = {}, colspan, rowspan, widthUnit } = attrs;
+  const { colwidth = [], cellWidthType = "dxa", widthUnit } = attrs;
   const colwidthSum = colwidth.reduce((acc, curr) => acc + curr, 0);
-  const cellWidthElement = {
-    name: "w:tcW",
-    attributes: {
-      "w:w": widthUnit === "px" ? pixelsToTwips(colwidthSum) : inchesToTwips(colwidthSum),
-      "w:type": cellWidthType
-    }
-  };
-  elements.push(cellWidthElement);
-  if (colspan) {
-    const gridSpanElement = {
-      name: "w:gridSpan",
-      attributes: { "w:val": `${colspan}` }
+  const propertiesWidthPixels = twipsToPixels(tableCellProperties.cellWidth?.value);
+  if (propertiesWidthPixels !== colwidthSum) {
+    tableCellProperties["cellWidth"] = {
+      value: widthUnit === "px" ? pixelsToTwips(colwidthSum) : inchesToTwips(colwidthSum),
+      type: cellWidthType
     };
-    elements.push(gridSpanElement);
   }
-  const { color } = background || {};
-  if (color) {
-    const cellBgElement = {
-      name: "w:shd",
-      attributes: { "w:fill": color }
-    };
-    elements.push(cellBgElement);
+  const { colspan } = attrs;
+  if (colspan > 1 && tableCellProperties.gridSpan !== colspan) {
+    tableCellProperties["gridSpan"] = colspan;
+  } else if (!colspan || tableCellProperties?.gridSpan === 1) {
+    delete tableCellProperties.gridSpan;
+  }
+  const { background = {} } = attrs;
+  if (background?.color && tableCellProperties.shading?.fill !== background?.color) {
+    tableCellProperties["shading"] = { fill: background.color };
+  } else if (!background?.color && tableCellProperties?.shading?.fill) {
+    delete tableCellProperties.shading;
   }
   const { cellMargins } = attrs;
   if (cellMargins) {
-    const cellMarginsElement = {
-      name: "w:tcMar",
-      elements: generateCellMargins(cellMargins)
-    };
-    elements.push(cellMarginsElement);
+    ["left", "right", "top", "bottom"].forEach((side) => {
+      const key = `margin${side.charAt(0).toUpperCase() + side.slice(1)}`;
+      if (cellMargins[side] != null) {
+        if (!tableCellProperties.cellMargins) tableCellProperties["cellMargins"] = {};
+        let currentPropertyValuePixels = twipsToPixels(tableCellProperties.cellMargins?.[key]?.value);
+        if (currentPropertyValuePixels !== cellMargins[side]) {
+          tableCellProperties.cellMargins[key] = { value: pixelsToTwips(cellMargins[side]), type: "dxa" };
+        }
+      } else if (tableCellProperties?.cellMargins?.[key]) {
+        delete tableCellProperties.cellMargins[key];
+      }
+    });
   }
   const { verticalAlign } = attrs;
-  if (verticalAlign) {
-    const vertAlignElement = {
-      name: "w:vAlign",
-      attributes: { "w:val": verticalAlign }
-    };
-    elements.push(vertAlignElement);
-  }
-  if (rowspan && rowspan > 1) {
-    const vMergeElement = {
-      name: "w:vMerge",
-      type: "element",
-      attributes: { "w:val": "restart" }
-    };
-    elements.push(vMergeElement);
+  if (verticalAlign && verticalAlign !== tableCellProperties.vAlign) {
+    tableCellProperties["vAlign"] = verticalAlign;
+  } else if (!verticalAlign && tableCellProperties?.vAlign) {
+    delete tableCellProperties.vAlign;
+  }
+  const { rowspan } = attrs;
+  if (rowspan && rowspan > 1 && tableCellProperties.vMerge !== "restart") {
+    tableCellProperties["vMerge"] = "restart";
   } else if (attrs.continueMerge) {
-    const vMergeElement = {
-      name: "w:vMerge",
-      type: "element"
-    };
-    elements.push(vMergeElement);
+    tableCellProperties["vMerge"] = "continue";
+  } else if (tableCellProperties?.vMerge) {
+    delete tableCellProperties.vMerge;
   }
   const { borders = {} } = attrs;
   if (!!borders && Object.keys(borders).length) {
-    const cellBordersElement = {
-      name: "w:tcBorders",
-      elements: Object.entries(borders).map(([key, value]) => {
-        if (!value.size || value.val === "none") {
-          return {
-            name: `w:${key}`,
-            attributes: {
-              "w:val": "nil"
-            }
+    ["top", "bottom", "left", "right"].forEach((side) => {
+      if (borders[side]) {
+        let currentPropertyValue = tableCellProperties.borders?.[side];
+        let currentPropertySizePixels = eighthPointsToPixels(currentPropertyValue?.size);
+        let color = borders[side].color;
+        if (borders[side].color && color === "#000000") {
+          color = "auto";
+        }
+        if (currentPropertySizePixels !== borders[side].size || currentPropertyValue?.color !== color || borders[side].val !== currentPropertyValue?.val) {
+          if (!tableCellProperties.borders) tableCellProperties["borders"] = {};
+          tableCellProperties.borders[side] = {
+            size: pixelsToEightPoints(borders[side].size || 0),
+            color,
+            space: borders[side].space || 0,
+            val: borders[side].val || "single"
           };
         }
-        return {
-          name: `w:${key}`,
-          attributes: {
-            "w:val": "single",
-            "w:color": value.color ? value.color.substring(1) : "auto",
-            "w:sz": pixelsToEightPoints(value.size),
-            "w:space": value.space || 0
-          }
-        };
-      })
-    };
-    elements.push(cellBordersElement);
+      } else if (tableCellProperties.borders?.[side]) {
+        delete tableCellProperties.borders[side];
+      }
+    });
+  } else if (tableCellProperties?.borders) {
+    delete tableCellProperties.borders;
   }
-  return {
-    name: "w:tcPr",
-    elements
-  };
-}
-function generateCellMargins(cellMargins) {
-  const elements = [];
-  const { top, right, bottom, left } = cellMargins;
-  if (top != null) elements.push({ name: "w:top", attributes: { "w:w": pixelsToTwips(top) } });
-  if (right != null) elements.push({ name: "w:right", attributes: { "w:w": pixelsToTwips(right) } });
-  if (bottom != null) elements.push({ name: "w:bottom", attributes: { "w:w": pixelsToTwips(bottom) } });
-  if (left != null) elements.push({ name: "w:left", attributes: { "w:w": pixelsToTwips(left) } });
-  return elements;
+  const result = translator$d.decode({ node: { ...node, attrs: { ...node.attrs, tableCellProperties } } });
+  return result;
 }
 const XML_NODE_NAME$d = "w:tc";
 const SD_NODE_NAME$b = "tableCell";
@@ -28492,6 +28671,7 @@ function sdtNodeTypeStrategy(node) {
   }
   return { type: "unknown", handler: null };
 }
+const DRAWING_XML_TAG = "w:drawing";
 function handleImageNode(node, params, isAnchor) {
   const { docx, filename } = params;
   const { attributes } = node;
@@ -28503,32 +28683,10 @@ function handleImageNode(node, params, isAnchor) {
   };
   const extent = node.elements.find((el) => el.name === "wp:extent");
   const size = {
-    width: emuToPixels(extent.attributes?.cx),
-    height: emuToPixels(extent.attributes?.cy)
+    width: emuToPixels(extent?.attributes?.cx),
+    height: emuToPixels(extent?.attributes?.cy)
   };
-  const graphic = node.elements.find((el) => el.name === "a:graphic");
-  const graphicData = graphic.elements.find((el) => el.name === "a:graphicData");
-  const { uri: uri2 } = graphicData?.attributes || {};
-  const shapeURI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
-  if (!!uri2 && uri2 === shapeURI) {
-    return handleShapeDrawing(params, node, graphicData);
-  }
-  const picture = graphicData.elements.find((el) => el.name === "pic:pic");
-  if (!picture || !picture.elements) return null;
-  const blipFill = picture.elements.find((el) => el.name === "pic:blipFill");
-  const blip = blipFill.elements.find((el) => el.name === "a:blip");
-  const spPr = picture.elements.find((el) => el.name === "pic:spPr");
   let transformData = {};
-  if (spPr) {
-    const xfrm = spPr.elements.find((el) => el.name === "a:xfrm");
-    if (xfrm?.attributes) {
-      transformData = {
-        rotation: rotToDegrees(xfrm.attributes["rot"]),
-        verticalFlip: xfrm.attributes["flipV"] === "1",
-        horizontalFlip: xfrm.attributes["flipH"] === "1"
-      };
-    }
-  }
   const effectExtent = node.elements.find((el) => el.name === "wp:effectExtent");
   if (effectExtent) {
     const sanitizeEmuValue = (value) => {
@@ -28537,22 +28695,26 @@ function handleImageNode(node, params, isAnchor) {
       return Number.isFinite(numeric) ? numeric : 0;
     };
     transformData.sizeExtension = {
-      left: emuToPixels(sanitizeEmuValue(effectExtent.attributes["l"])),
-      top: emuToPixels(sanitizeEmuValue(effectExtent.attributes["t"])),
-      right: emuToPixels(sanitizeEmuValue(effectExtent.attributes["r"])),
-      bottom: emuToPixels(sanitizeEmuValue(effectExtent.attributes["b"]))
+      left: emuToPixels(sanitizeEmuValue(effectExtent.attributes?.["l"])),
+      top: emuToPixels(sanitizeEmuValue(effectExtent.attributes?.["t"])),
+      right: emuToPixels(sanitizeEmuValue(effectExtent.attributes?.["r"])),
+      bottom: emuToPixels(sanitizeEmuValue(effectExtent.attributes?.["b"]))
     };
   }
   const positionHTag = node.elements.find((el) => el.name === "wp:positionH");
   const positionH = positionHTag?.elements.find((el) => el.name === "wp:posOffset");
   const positionHValue = emuToPixels(positionH?.elements[0]?.text);
-  const hRelativeFrom = positionHTag?.attributes.relativeFrom;
-  const alignH = positionHTag?.elements.find((el) => el.name === "wp:align")?.elements[0]?.text;
+  const hRelativeFrom = positionHTag?.attributes?.relativeFrom;
+  const alignH = positionHTag?.elements.find((el) => el.name === "wp:align")?.elements?.[0]?.text;
   const positionVTag = node.elements.find((el) => el.name === "wp:positionV");
   const positionV = positionVTag?.elements?.find((el) => el.name === "wp:posOffset");
   const positionVValue = emuToPixels(positionV?.elements[0]?.text);
-  const vRelativeFrom = positionVTag?.attributes.relativeFrom;
-  const alignV = positionVTag?.elements?.find((el) => el.name === "wp:align")?.elements[0]?.text;
+  const vRelativeFrom = positionVTag?.attributes?.relativeFrom;
+  const alignV = positionVTag?.elements?.find((el) => el.name === "wp:align")?.elements?.[0]?.text;
+  const marginOffset = {
+    horizontal: positionHValue,
+    top: positionVValue
+  };
   const simplePos = node.elements.find((el) => el.name === "wp:simplePos");
   const wrapNode = isAnchor ? node.elements.find(
     (el) => ["wp:wrapNone", "wp:wrapSquare", "wp:wrapThrough", "wp:wrapTight", "wp:wrapTopAndBottom"].includes(el.name)
@@ -28560,38 +28722,40 @@ function handleImageNode(node, params, isAnchor) {
   const wrap2 = isAnchor ? { type: wrapNode?.name.slice(7) || "None", attrs: {} } : { type: "Inline" };
   switch (wrap2.type) {
     case "Square":
-      wrap2.attrs.wrapText = wrapNode.attributes.wrapText;
-      if ("distB" in (wrapNode.attributes || {})) {
+      if (wrapNode?.attributes?.wrapText) {
+        wrap2.attrs.wrapText = wrapNode.attributes.wrapText;
+      }
+      if ("distB" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distBottom = emuToPixels(wrapNode.attributes.distB);
       }
-      if ("distL" in (wrapNode.attributes || {})) {
+      if ("distL" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distLeft = emuToPixels(wrapNode.attributes.distL);
       }
-      if ("distR" in (wrapNode.attributes || {})) {
+      if ("distR" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distRight = emuToPixels(wrapNode.attributes.distR);
       }
-      if ("distT" in (wrapNode.attributes || {})) {
+      if ("distT" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distTop = emuToPixels(wrapNode.attributes.distT);
       }
       break;
     case "Tight":
     case "Through": {
-      if ("distL" in (wrapNode.attributes || {})) {
+      if ("distL" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distLeft = emuToPixels(wrapNode.attributes.distL);
       }
-      if ("distR" in (wrapNode.attributes || {})) {
+      if ("distR" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distRight = emuToPixels(wrapNode.attributes.distR);
       }
-      if ("distT" in (wrapNode.attributes || {})) {
+      if ("distT" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distTop = emuToPixels(wrapNode.attributes.distT);
       }
-      if ("distB" in (wrapNode.attributes || {})) {
+      if ("distB" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distBottom = emuToPixels(wrapNode.attributes.distB);
       }
-      if ("wrapText" in (wrapNode.attributes || {})) {
+      if ("wrapText" in (wrapNode?.attributes || {})) {
         wrap2.attrs.wrapText = wrapNode.attributes.wrapText;
       }
-      const polygon = wrapNode.elements?.find((el) => el.name === "wp:wrapPolygon");
+      const polygon = wrapNode?.elements?.find((el) => el.name === "wp:wrapPolygon");
       if (polygon) {
         wrap2.attrs.polygon = polygonToObj(polygon);
         if (polygon.attributes?.edited !== void 0) {
@@ -28601,10 +28765,10 @@ function handleImageNode(node, params, isAnchor) {
       break;
     }
     case "TopAndBottom":
-      if ("distB" in (wrapNode.attributes || {})) {
+      if ("distB" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distBottom = emuToPixels(wrapNode.attributes.distB);
       }
-      if ("distT" in (wrapNode.attributes || {})) {
+      if ("distT" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distTop = emuToPixels(wrapNode.attributes.distT);
       }
       break;
@@ -28622,17 +28786,42 @@ function handleImageNode(node, params, isAnchor) {
       alignV
     };
   }
-  const marginOffset = {
-    horizontal: positionHValue,
-    top: positionVValue
-  };
+  const graphic = node.elements.find((el) => el.name === "a:graphic");
+  const graphicData = graphic?.elements.find((el) => el.name === "a:graphicData");
+  const { uri: uri2 } = graphicData?.attributes || {};
+  const shapeURI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
+  if (!!uri2 && uri2 === shapeURI) {
+    const shapeMarginOffset = {
+      left: positionHValue,
+      horizontal: positionHValue,
+      top: positionVValue
+    };
+    return handleShapeDrawing(params, node, graphicData, size, padding, shapeMarginOffset);
+  }
+  const picture = graphicData?.elements.find((el) => el.name === "pic:pic");
+  if (!picture || !picture.elements) return null;
+  const blipFill = picture.elements.find((el) => el.name === "pic:blipFill");
+  const blip = blipFill?.elements.find((el) => el.name === "a:blip");
+  if (!blip) return null;
+  const spPr = picture.elements.find((el) => el.name === "pic:spPr");
+  if (spPr) {
+    const xfrm = spPr.elements.find((el) => el.name === "a:xfrm");
+    if (xfrm?.attributes) {
+      transformData = {
+        ...transformData,
+        rotation: rotToDegrees(xfrm.attributes["rot"]),
+        verticalFlip: xfrm.attributes["flipV"] === "1",
+        horizontalFlip: xfrm.attributes["flipH"] === "1"
+      };
+    }
+  }
   const { attributes: blipAttributes = {} } = blip;
   const rEmbed = blipAttributes["r:embed"];
   if (!rEmbed) return null;
   const currentFile = filename || "document.xml";
   let rels = docx[`word/_rels/${currentFile}.rels`];
   if (!rels) rels = docx[`word/_rels/document.xml.rels`];
-  const relationships = rels.elements.find((el) => el.name === "Relationships");
+  const relationships = rels?.elements.find((el) => el.name === "Relationships");
   const { elements } = relationships || [];
   const rel = elements?.find((el) => el.attributes["Id"] === rEmbed);
   if (!rel) return null;
@@ -28645,10 +28834,10 @@ function handleImageNode(node, params, isAnchor) {
     type: "image",
     attrs: {
       src: path,
-      alt: ["emf", "wmf"].includes(extension) ? "Unable to render EMF/WMF image" : docPr?.attributes.name || "Image",
+      alt: ["emf", "wmf"].includes(extension) ? "Unable to render EMF/WMF image" : docPr?.attributes?.name || "Image",
       extension,
-      id: docPr?.attributes.id || "",
-      title: docPr?.attributes.descr || "Image",
+      id: docPr?.attributes?.id || "",
+      title: docPr?.attributes?.descr || "Image",
       inline: true,
       padding,
       marginOffset,
@@ -28663,6 +28852,10 @@ function handleImageNode(node, params, isAnchor) {
         }
       },
       wrap: wrap2,
+      ...wrap2.type === "Square" && wrap2.attrs.wrapText ? {
+        wrapText: wrap2.attrs.wrapText
+      } : {},
+      wrapTopAndBottom: wrap2.type === "TopAndBottom",
       originalPadding: {
         distT: attributes["distT"],
         distB: attributes["distB"],
@@ -28674,7 +28867,7 @@ function handleImageNode(node, params, isAnchor) {
     }
   };
 }
-const handleShapeDrawing = (params, node, graphicData) => {
+const handleShapeDrawing = (params, node, graphicData, size, padding, marginOffset) => {
   const wsp = graphicData.elements.find((el) => el.name === "wps:wsp");
   const textBox = wsp.elements.find((el) => el.name === "wps:txbx");
   const textBoxContent = textBox?.elements?.find((el) => el.name === "w:txbxContent");
@@ -28685,21 +28878,14 @@ const handleShapeDrawing = (params, node, graphicData) => {
     return getRectangleShape(params, spPr);
   }
   if (!textBoxContent) {
-    return null;
+    return buildShapePlaceholder(node, size, padding, marginOffset, "drawing");
   }
-  const { nodeListHandler } = params;
-  const translatedElement = nodeListHandler.handler({
-    ...params,
-    node: textBoxContent.elements[0],
-    nodes: textBoxContent.elements,
-    path: [...params.path || [], textBoxContent]
-  });
-  return translatedElement[0];
+  return buildShapePlaceholder(node, size, padding, marginOffset, "textbox");
 };
 const getRectangleShape = (params, node) => {
   const schemaAttrs = {};
   const [drawingNode] = params.nodes;
-  if (drawingNode?.name === "w:drawing") {
+  if (drawingNode?.name === DRAWING_XML_TAG) {
     schemaAttrs.drawingContent = drawingNode;
   }
   const xfrm = node.elements.find((el) => el.name === "a:xfrm");
@@ -28723,6 +28909,52 @@ const getRectangleShape = (params, node) => {
     attrs: schemaAttrs
   };
 };
+const buildShapePlaceholder = (node, size, padding, marginOffset, shapeType) => {
+  const attrs = {
+    drawingContent: {
+      name: DRAWING_XML_TAG,
+      elements: [carbonCopy(node)]
+    },
+    attributes: {
+      "data-shape-type": shapeType
+    }
+  };
+  if (size && (Number.isFinite(size.width) || Number.isFinite(size.height))) {
+    attrs.size = {
+      ...Number.isFinite(size.width) ? { width: size.width } : {},
+      ...Number.isFinite(size.height) ? { height: size.height } : {}
+    };
+  }
+  if (padding) {
+    const paddingData = {};
+    if (Number.isFinite(padding.top)) paddingData["data-padding-top"] = padding.top;
+    if (Number.isFinite(padding.right)) paddingData["data-padding-right"] = padding.right;
+    if (Number.isFinite(padding.bottom)) paddingData["data-padding-bottom"] = padding.bottom;
+    if (Number.isFinite(padding.left)) paddingData["data-padding-left"] = padding.left;
+    if (Object.keys(paddingData).length) {
+      attrs.attributes = {
+        ...attrs.attributes,
+        ...paddingData
+      };
+    }
+  }
+  if (marginOffset) {
+    const offsetData = {};
+    const horizontal = Number.isFinite(marginOffset.horizontal) ? marginOffset.horizontal : Number.isFinite(marginOffset.left) ? marginOffset.left : void 0;
+    if (Number.isFinite(horizontal)) offsetData["data-offset-x"] = horizontal;
+    if (Number.isFinite(marginOffset.top)) offsetData["data-offset-y"] = marginOffset.top;
+    if (Object.keys(offsetData).length) {
+      attrs.attributes = {
+        ...attrs.attributes,
+        ...offsetData
+      };
+    }
+  }
+  return {
+    type: "contentBlock",
+    attrs
+  };
+};
 function handleAnchorNode(params) {
   const { node } = params.extraParams;
   if (node.name !== "wp:anchor") {
@@ -31692,8 +31924,8 @@ const trackChangeNodeHandlerEntity = {
   handlerName: "trackChangeNodeHandler",
   handler: handleTrackChangeNode
 };
-const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$Z);
-const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$Y);
+const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$1c);
+const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$1b);
 function parseProperties(node) {
   const marks = [];
   const unknownMarks = [];
@@ -31785,7 +32017,7 @@ const handleParagraphNode = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$19.encode(params);
+  const schemaNode = translator$1o.encode(params);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -31888,7 +32120,7 @@ const handler = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$1c.encode(params);
+  const result = translator$1r.encode(params);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -32514,7 +32746,7 @@ const handleTabNode = (params) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$1a.encode(params);
+  const node = translator$1p.encode(params);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
@@ -32766,12 +32998,14 @@ const createDocumentJson = (docx, converter, editor) => {
     const content = pruneIgnoredNodes(contentElements);
     const comments = importCommentData({ docx, converter, editor });
     const lists = {};
+    const inlineDocumentFonts = [];
     let parsedContent = nodeListHandler.handler({
       nodes: content,
       nodeListHandler,
       docx,
       converter,
       editor,
+      inlineDocumentFonts,
       lists,
       path: []
     });
@@ -32794,6 +33028,7 @@ const createDocumentJson = (docx, converter, editor) => {
       savedTagsToRestore: node,
       pageStyles: getDocumentStyles(node, docx, converter, editor),
       comments,
+      inlineDocumentFonts,
       linkedStyles: getStyleDefinitions(docx),
       numbering: getNumberingDefinitions(docx)
     };
@@ -32857,6 +33092,7 @@ const createNodeListHandler = (nodeHandlers) => {
     filename,
     parentStyleId,
     lists,
+    inlineDocumentFonts,
     path = []
   }) => {
     if (!elements || !elements.length) return [];
@@ -32883,6 +33119,7 @@ const createNodeListHandler = (nodeHandlers) => {
                 filename,
                 parentStyleId,
                 lists,
+                inlineDocumentFonts,
                 path
               });
             },
@@ -33570,21 +33807,21 @@ function exportSchemaToJson(params) {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$19,
-    run: translator$Y,
+    paragraph: translator$1o,
+    run: translator$1b,
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$1c,
-    table: translator$d,
-    tableRow: translator$K,
+    lineBreak: translator$1r,
+    table: translator$s,
+    tableRow: translator$Z,
     tableCell: translator$c,
     bookmarkStart: translator$7,
     bookmarkEnd: translator$6,
     fieldAnnotation: translator$8,
-    tab: translator$1a,
+    tab: translator$1p,
     image: translator$9,
-    hardBreak: translator$1c,
+    hardBreak: translator$1r,
     commentRangeStart: commentRangeStartTranslator,
     commentRangeEnd: commentRangeEndTranslator,
     commentReference: () => null,
@@ -33945,7 +34182,7 @@ function translateTextNode(params) {
   }
   const isLinkNode = node.marks?.some((m2) => m2.type === "link");
   if (isLinkNode && !extraParams?.linkProcessed) {
-    return translator$Z.decode(params);
+    return translator$1c.decode(params);
   }
   const { text, marks = [] } = node;
   return getTextNodeForExport(text, marks, params);
@@ -34205,7 +34442,7 @@ function translateMark(mark) {
       markElement.type = "element";
       break;
     case "underline": {
-      const translated = translator$16.decode({
+      const translated = translator$1l.decode({
         node: {
           attrs: {
             underlineType: attrs.underlineType ?? attrs.underline ?? null,
@@ -34269,7 +34506,7 @@ function translateMark(mark) {
       break;
     case "highlight": {
       const highlightValue = attrs.color ?? attrs.highlight ?? null;
-      const translated = translator$1b.decode({ node: { attrs: { highlight: highlightValue } } });
+      const translated = translator$1q.decode({ node: { attrs: { highlight: highlightValue } } });
       return translated || {};
     }
     case "link":
@@ -34648,6 +34885,7 @@ const _SuperConverter = class _SuperConverter {
     this.fonts = params?.fonts || {};
     this.addedMedia = {};
     this.comments = [];
+    this.inlineDocumentFonts = [];
     this.docHiglightColors = /* @__PURE__ */ new Set([]);
     this.xml = params?.xml;
     this.declaration = null;
@@ -34934,6 +35172,23 @@ const _SuperConverter = class _SuperConverter {
     return result;
   }
   getDocumentFonts() {
+    const inlineDocumentFonts = [...new Set(this.inlineDocumentFonts || [])];
+    const fontTable = this.convertedXml["word/fontTable.xml"];
+    if (!fontTable) {
+      return inlineDocumentFonts;
+    }
+    const wFonts = fontTable.elements?.find((element) => element.name === "w:fonts");
+    if (!wFonts) {
+      return inlineDocumentFonts;
+    }
+    if (!wFonts.elements) {
+      return inlineDocumentFonts;
+    }
+    const fontsInFontTable = wFonts.elements.filter((element) => element.name === "w:font").map((element) => element.attributes["w:name"]);
+    const allFonts = [...inlineDocumentFonts, ...fontsInFontTable];
+    return [...new Set(allFonts)];
+  }
+  getFontFaceImportString() {
     const fontTable = this.convertedXml["word/fontTable.xml"];
     if (!fontTable || !Object.keys(this.fonts).length) return;
     const fonts = fontTable.elements.find((el) => el.name === "w:fonts");
@@ -34947,6 +35202,7 @@ const _SuperConverter = class _SuperConverter {
     const rels = this.convertedXml["word/_rels/fontTable.xml.rels"];
     const relationships = rels?.elements.find((el) => el.name === "Relationships") || {};
     const { elements } = relationships;
+    const fontsImported = [];
     let styleString = "";
     for (const font of fontsToInclude) {
       const filePath = elements.find((el) => el.attributes.Id === font.attributes["r:id"])?.attributes?.Target;
@@ -34963,6 +35219,9 @@ const _SuperConverter = class _SuperConverter {
       const isItalic = font.name.includes("Italic");
       const isLight = font.name.includes("Light");
       const fontWeight = isNormal ? "normal" : isBold ? "bold" : isLight ? "200" : "normal";
+      if (!fontsImported.includes(font.fontFamily)) {
+        fontsImported.push(font.fontFamily);
+      }
       styleString += `
         @font-face {
           font-style: ${isItalic ? "italic" : "normal"};
@@ -34973,7 +35232,10 @@ const _SuperConverter = class _SuperConverter {
         }
       `;
     }
-    return styleString;
+    return {
+      styleString,
+      fontsImported
+    };
   }
   getDocumentInternalId() {
     const settingsLocation = "word/settings.xml";
@@ -35028,6 +35290,7 @@ const _SuperConverter = class _SuperConverter {
       this.numbering = result.numbering;
       this.comments = result.comments;
       this.linkedStyles = result.linkedStyles;
+      this.inlineDocumentFonts = result.inlineDocumentFonts;
       return result.pmDoc;
     } else {
       return null;
@@ -35403,7 +35666,7 @@ export {
   objectIncludes as Z,
   AddMarkStep as _,
   Plugin as a,
-  translator$E as a$,
+  translator$b as a$,
   twipsToLines as a0,
   pixelsToTwips as a1,
   helpers as a2,
@@ -35414,33 +35677,33 @@ export {
   createDocFromMarkdown as a7,
   createDocFromHTML as a8,
   EditorState as a9,
-  xmljs as aA,
-  vClickOutside as aB,
-  getActiveFormatting as aC,
-  readFromClipboard as aD,
-  handleClipboardPaste as aE,
-  getFileObject as aF,
-  runPropertyTranslators as aG,
-  commentRangeEndTranslator as aH,
-  commentRangeStartTranslator as aI,
-  translator$a as aJ,
-  translator$b as aK,
-  translator$M as aL,
-  translator$N as aM,
-  translator$16 as aN,
-  translator$L as aO,
-  translator$O as aP,
-  translator$K as aQ,
-  translator$k as aR,
-  translator$c as aS,
-  translator$x as aT,
-  translator$y as aU,
-  translator$z as aV,
-  translator$A as aW,
-  translator$B as aX,
-  translator$g as aY,
-  translator$C as aZ,
-  translator$D as a_,
+  getDefaultExportFromCjs$2 as aA,
+  getContentTypesFromXml as aB,
+  xmljs as aC,
+  vClickOutside as aD,
+  getActiveFormatting as aE,
+  readFromClipboard as aF,
+  handleClipboardPaste as aG,
+  getFileObject as aH,
+  runPropertyTranslators as aI,
+  translator$d as aJ,
+  translator$k as aK,
+  translator$m as aL,
+  translator$e as aM,
+  translator$f as aN,
+  translator$n as aO,
+  translator$o as aP,
+  translator$j as aQ,
+  translator$g as aR,
+  translator$r as aS,
+  translator$i as aT,
+  translator$l as aU,
+  translator$h as aV,
+  translator$q as aW,
+  translator$p as aX,
+  commentRangeEndTranslator as aY,
+  commentRangeStartTranslator as aZ,
+  translator$a as a_,
   hasSomeParentWithClass as aa,
   isActive as ab,
   unflattenListsInHtml as ac,
@@ -35458,66 +35721,83 @@ export {
   docxNumberigHelpers as ao,
   parseIndentElement as ap,
   combineIndents as aq,
-  SelectionRange as ar,
-  Transform as as,
-  isInTable as at,
-  generateDocxRandomId as au,
-  insertNewRelationship as av,
-  inchesToPixels as aw,
-  commonjsGlobal as ax,
-  getDefaultExportFromCjs$2 as ay,
-  getContentTypesFromXml as az,
+  twipsToPixels as ar,
+  PIXELS_PER_INCH as as,
+  SelectionRange as at,
+  Transform as au,
+  isInTable as av,
+  generateDocxRandomId as aw,
+  insertNewRelationship as ax,
+  inchesToPixels as ay,
+  commonjsGlobal as az,
   Slice as b,
-  translator$F as b0,
-  translator$P as b1,
-  translator$e as b2,
-  translator$G as b3,
-  translator$Q as b4,
-  translator$h as b5,
-  translator$H as b6,
-  translator$i as b7,
-  translator$d as b8,
-  translator$1a as b9,
-  translator$14 as bA,
-  translator$W as bB,
-  translator$X as bC,
-  translator$1c as bD,
-  translator$w as bE,
-  translator$7 as bF,
-  translator$6 as bG,
-  translator$J as bH,
-  translator$18 as bI,
-  translator$4 as bJ,
-  translator$5 as bK,
-  translator$1 as bL,
-  _sfc_main as bM,
-  translator$10 as ba,
-  translator$11 as bb,
-  translator$15 as bc,
-  translator$m as bd,
-  translator$I as be,
-  translator$8 as bf,
-  translator$o as bg,
-  translator$12 as bh,
-  translator$_ as bi,
-  translator$13 as bj,
-  translator$Y as bk,
-  translator$19 as bl,
-  translator$q as bm,
-  translator$R as bn,
-  translator$r as bo,
+  translator$5 as b$,
+  translator$$ as b0,
+  translator$10 as b1,
+  translator$1l as b2,
+  translator$_ as b3,
+  translator$11 as b4,
+  translator$Z as b5,
+  translator$z as b6,
+  translator$c as b7,
+  translator$M as b8,
+  translator$N as b9,
+  translator$1i as bA,
+  translator$1b as bB,
+  translator$1o as bC,
+  translator$F as bD,
+  translator$14 as bE,
+  translator$G as bF,
+  translator$H as bG,
+  translator$1m as bH,
+  translator$1c as bI,
+  translator$1q as bJ,
+  translator$15 as bK,
+  translator$u as bL,
+  translator$16 as bM,
+  translator$17 as bN,
+  translator$J as bO,
+  translator$9 as bP,
+  translator$18 as bQ,
+  translator$1j as bR,
+  translator$19 as bS,
+  translator$1a as bT,
+  translator$1r as bU,
+  translator$L as bV,
+  translator$7 as bW,
+  translator$6 as bX,
+  translator$Y as bY,
+  translator$1n as bZ,
+  translator$4 as b_,
+  translator$O as ba,
+  translator$P as bb,
+  translator$Q as bc,
+  translator$v as bd,
+  translator$R as be,
+  translator$S as bf,
+  translator$T as bg,
+  translator$U as bh,
+  translator$12 as bi,
+  translator$t as bj,
+  translator$V as bk,
+  translator$13 as bl,
+  translator$w as bm,
+  translator$W as bn,
+  translator$x as bo,
   translator$s as bp,
-  translator$17 as bq,
-  translator$Z as br,
-  translator$1b as bs,
-  translator$S as bt,
-  translator$f as bu,
-  translator$T as bv,
-  translator$U as bw,
-  translator$u as bx,
-  translator$9 as by,
-  translator$V as bz,
+  translator$1p as bq,
+  translator$1f as br,
+  translator$1g as bs,
+  translator$1k as bt,
+  translator$B as bu,
+  translator$X as bv,
+  translator$8 as bw,
+  translator$D as bx,
+  translator$1h as by,
+  translator$1d as bz,
   DOMParser$1 as c,
+  translator$1 as c0,
+  _sfc_main as c1,
   Mark as d,
   dropPoint as e,
   callOrGet as f,