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

package/dist/chunks/{super-editor.es-BkjovEJQ.es.js → super-editor.es-iMAoOYOw.es.js}

@@ -15090,14 +15090,21 @@ function twipsToInches(twips) {
 function twipsToPixels(twips) {
   if (twips == null) return;
   const inches = twipsToInches(twips);
+  return inchesToPixels(inches);
+}
+function pixelsToTwips(pixels) {
+  const inches = pixelsToInches(pixels);
+  return inchesToTwips(inches);
+}
+function inchesToPixels(inches) {
   if (inches == null) return;
   const pixels = inches * 96;
   return Math.round(pixels * 1e3) / 1e3;
 }
-function pixelsToTwips(pixels) {
+function pixelsToInches(pixels) {
   if (pixels == null) return;
   const inches = Number(pixels) / 96;
-  return inchesToTwips(inches);
+  return inches;
 }
 function twipsToLines(twips) {
   if (twips == null) return;
@@ -15148,6 +15155,71 @@ function degreesToRot(degrees) {
   if (degrees == null) return;
   return degrees * 6e4;
 }
+function pixelsToPolygonUnits(pixels) {
+  if (pixels == null) return;
+  const pu = pixels * 96;
+  return Math.round(pu);
+}
+function polygonUnitsToPixels(pu) {
+  if (pu == null) return;
+  const pixels = Number(pu) / 96;
+  return Math.round(pixels * 1e3) / 1e3;
+}
+function polygonToObj(polygonNode) {
+  if (!polygonNode) return null;
+  const points = [];
+  polygonNode.elements.forEach((element) => {
+    if (["wp:start", "wp:lineTo"].includes(element.name)) {
+      const { x, y: y2 } = element.attributes;
+      points.push([polygonUnitsToPixels(x), polygonUnitsToPixels(y2)]);
+    }
+  });
+  if (points.length > 1) {
+    const firstPoint = points[0];
+    const lastPoint = points[points.length - 1];
+    if (firstPoint[0] === lastPoint[0] && firstPoint[1] === lastPoint[1]) {
+      points.pop();
+    }
+  }
+  return points;
+}
+function objToPolygon(points) {
+  if (!points || !Array.isArray(points)) return null;
+  const polygonNode = {
+    name: "wp:wrapPolygon",
+    type: "wp:wrapPolygon",
+    attributes: {
+      edited: "0"
+    },
+    elements: []
+  };
+  points.forEach((point, index2) => {
+    const [x, y2] = point;
+    const tagName = index2 === 0 ? "wp:start" : "wp:lineTo";
+    const pointNode = {
+      name: tagName,
+      type: tagName,
+      attributes: {
+        x: pixelsToPolygonUnits(x),
+        y: pixelsToPolygonUnits(y2)
+      }
+    };
+    polygonNode.elements.push(pointNode);
+  });
+  if (points.length > 0) {
+    const [startX, startY] = points[0];
+    const closePointNode = {
+      name: "wp:lineTo",
+      type: "wp:lineTo",
+      attributes: {
+        x: pixelsToPolygonUnits(startX),
+        y: pixelsToPolygonUnits(startY)
+      }
+    };
+    polygonNode.elements.push(closePointNode);
+  }
+  return polygonNode;
+}
 const getTextIndentExportValue = (indent) => {
   const [value, unit] = parseSizeUnit(indent);
   const functionsMap = {
@@ -24463,37 +24535,37 @@ const _NodeTranslator = class _NodeTranslator2 {
 };
 __publicField$2(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$1c = (attributes) => {
+const encode$1e = (attributes) => {
   return attributes["w:type"];
 };
-const decode$14 = (attrs) => {
+const decode$16 = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
 const attrConfig$G = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$1c,
-  decode: decode$14
+  encode: encode$1e,
+  decode: decode$16
 });
-const encode$1b = (attributes) => {
+const encode$1d = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$13 = (attrs) => {
+const decode$15 = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
 const attrConfig$F = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$1b,
-  decode: decode$13
+  encode: encode$1d,
+  decode: decode$15
 });
-const validXmlAttributes$n = [attrConfig$G, attrConfig$F];
-const XML_NODE_NAME$z = "w:br";
+const validXmlAttributes$p = [attrConfig$G, attrConfig$F];
+const XML_NODE_NAME$B = "w:br";
 const SD_NODE_NAME$h = "lineBreak";
-const encode$1a = (_2, encodedAttrs) => {
+const encode$1c = (_2, encodedAttrs) => {
   const isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -24503,7 +24575,7 @@ const encode$1a = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$12 = (params2, decodedAttrs) => {
+const decode$14 = (params2, decodedAttrs) => {
   const { node } = params2;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24520,39 +24592,39 @@ const decode$12 = (params2, decodedAttrs) => {
   };
   return translated;
 };
-const config$w = {
-  xmlName: XML_NODE_NAME$z,
+const config$y = {
+  xmlName: XML_NODE_NAME$B,
   sdNodeOrKeyName: SD_NODE_NAME$h,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$1a,
-  decode: decode$12,
-  attributes: validXmlAttributes$n
+  encode: encode$1c,
+  decode: decode$14,
+  attributes: validXmlAttributes$p
 };
-const translator$1a = NodeTranslator.from(config$w);
-const encode$19 = (attributes) => attributes?.["w:val"];
-const decode$11 = (attrs) => attrs?.highlight;
+const translator$1c = NodeTranslator.from(config$y);
+const encode$1b = (attributes) => attributes?.["w:val"];
+const decode$13 = (attrs) => attrs?.highlight;
 const attrConfig$E = Object.freeze({
   xmlName: "w:val",
   sdName: "highlight",
-  encode: encode$19,
-  decode: decode$11
+  encode: encode$1b,
+  decode: decode$13
 });
-const validXmlAttributes$m = [attrConfig$E];
-const XML_NODE_NAME$y = "w:highlight";
-const SD_ATTR_KEY$g = "highlight";
+const validXmlAttributes$o = [attrConfig$E];
+const XML_NODE_NAME$A = "w:highlight";
+const SD_ATTR_KEY$i = "highlight";
 const DISABLED_TOKENS = /* @__PURE__ */ new Set(["transparent", "none", "inherit"]);
-const encode$18 = (params2, encodedAttrs = {}) => {
+const encode$1a = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const value = encodedAttrs.highlight ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$y,
-    sdNodeOrKeyName: SD_ATTR_KEY$g,
+    xmlName: XML_NODE_NAME$A,
+    sdNodeOrKeyName: SD_ATTR_KEY$i,
     attributes: { "w:val": value ?? null }
   };
 };
-const decode$10 = (params2) => {
+const decode$12 = (params2) => {
   const attrs = params2?.node?.attrs || {};
   const highlightValue = attrs.highlight ?? attrs.color ?? null;
   if (!highlightValue) return void 0;
@@ -24560,14 +24632,14 @@ const decode$10 = (params2) => {
   if (!normalizedValue) return void 0;
   if (DISABLED_TOKENS.has(normalizedValue)) {
     return {
-      name: XML_NODE_NAME$y,
+      name: XML_NODE_NAME$A,
       attributes: { "w:val": "none" }
     };
   }
   const keyword = getDocxHighlightKeywordFromHex(highlightValue);
   if (keyword) {
     return {
-      name: XML_NODE_NAME$y,
+      name: XML_NODE_NAME$A,
       attributes: { "w:val": keyword }
     };
   }
@@ -24582,63 +24654,63 @@ const decode$10 = (params2) => {
     }
   };
 };
-const config$v = {
-  xmlName: XML_NODE_NAME$y,
-  sdNodeOrKeyName: SD_ATTR_KEY$g,
+const config$x = {
+  xmlName: XML_NODE_NAME$A,
+  sdNodeOrKeyName: SD_ATTR_KEY$i,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$18,
-  decode: decode$10,
-  attributes: validXmlAttributes$m
+  encode: encode$1a,
+  decode: decode$12,
+  attributes: validXmlAttributes$o
 };
-const translator$19 = NodeTranslator.from(config$v);
-const encode$17 = (attributes) => {
+const translator$1b = NodeTranslator.from(config$x);
+const encode$19 = (attributes) => {
   return attributes["w:val"];
 };
-const decode$$ = (attrs) => {
+const decode$11 = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
 const attrConfig$D = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$17,
-  decode: decode$$
+  encode: encode$19,
+  decode: decode$11
 });
-const encode$16 = (attributes) => {
+const encode$18 = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$_ = (attrs) => {
+const decode$10 = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
 const attrConfig$C = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$16,
-  decode: decode$_
+  encode: encode$18,
+  decode: decode$10
 });
-const encode$15 = (attributes) => {
+const encode$17 = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$Z = (attrs) => {
+const decode$$ = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
 const attrConfig$B = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$15,
-  decode: decode$Z
+  encode: encode$17,
+  decode: decode$$
 });
-const validXmlAttributes$l = [attrConfig$D, attrConfig$B, attrConfig$C];
-const XML_NODE_NAME$x = "w:tab";
+const validXmlAttributes$n = [attrConfig$D, attrConfig$B, attrConfig$C];
+const XML_NODE_NAME$z = "w:tab";
 const SD_NODE_NAME$g = "tab";
-const encode$14 = (_2, encodedAttrs = {}) => {
+const encode$16 = (_2, encodedAttrs = {}) => {
   const translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$Y = (params2, decodedAttrs = {}) => {
+const decode$_ = (params2, decodedAttrs = {}) => {
   const { node } = params2 || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24654,15 +24726,15 @@ const decode$Y = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$u = {
-  xmlName: XML_NODE_NAME$x,
+const config$w = {
+  xmlName: XML_NODE_NAME$z,
   sdNodeOrKeyName: SD_NODE_NAME$g,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$14,
-  decode: decode$Y,
-  attributes: validXmlAttributes$l
+  encode: encode$16,
+  decode: decode$_,
+  attributes: validXmlAttributes$n
 };
-const translator$18 = NodeTranslator.from(config$u);
+const translator$1a = NodeTranslator.from(config$w);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -25180,91 +25252,91 @@ const handleParagraphNode$1 = (params2) => {
   }
   return schemaNode;
 };
-const encode$13 = (attributes) => {
+const encode$15 = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$X = (attrs) => {
+const decode$Z = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$A = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$13,
-  decode: decode$X
+  encode: encode$15,
+  decode: decode$Z
 });
-const encode$12 = (attributes) => {
+const encode$14 = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$W = (attrs) => {
+const decode$Y = (attrs) => {
   return attrs.rsidP;
 };
 const attrConfig$z = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$12,
-  decode: decode$W
+  encode: encode$14,
+  decode: decode$Y
 });
-const encode$11 = (attributes) => {
+const encode$13 = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$V = (attrs) => {
+const decode$X = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$y = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$11,
-  decode: decode$V
+  encode: encode$13,
+  decode: decode$X
 });
-const encode$10 = (attributes) => {
+const encode$12 = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$U = (attrs) => {
+const decode$W = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$x = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$10,
-  decode: decode$U
+  encode: encode$12,
+  decode: decode$W
 });
-const encode$$ = (attributes) => {
+const encode$11 = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$T = (attrs) => {
+const decode$V = (attrs) => {
   return attrs.rsidRDefault;
 };
 const attrConfig$w = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$$,
-  decode: decode$T
+  encode: encode$11,
+  decode: decode$V
 });
-const encode$_ = (attributes) => {
+const encode$10 = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$S = (attrs) => {
+const decode$U = (attrs) => {
   return attrs.paraId;
 };
 const attrConfig$v = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$_,
-  decode: decode$S
+  encode: encode$10,
+  decode: decode$U
 });
-const encode$Z = (attributes) => {
+const encode$$ = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$R = (attrs) => {
+const decode$T = (attrs) => {
   return attrs.textId;
 };
 const attrConfig$u = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$Z,
-  decode: decode$R
+  encode: encode$$,
+  decode: decode$T
 });
-const validXmlAttributes$k = [
+const validXmlAttributes$m = [
   attrConfig$v,
   attrConfig$u,
   attrConfig$y,
@@ -25273,9 +25345,9 @@ const validXmlAttributes$k = [
   attrConfig$x,
   attrConfig$A
 ];
-const XML_NODE_NAME$w = "w:p";
+const XML_NODE_NAME$y = "w:p";
 const SD_NODE_NAME$f = "paragraph";
-const encode$Y = (params2, encodedAttrs = {}) => {
+const encode$_ = (params2, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params2);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25283,7 +25355,7 @@ const encode$Y = (params2, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$Q = (params2, decodedAttrs = {}) => {
+const decode$S = (params2, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params2);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25291,16 +25363,16 @@ const decode$Q = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$t = {
-  xmlName: XML_NODE_NAME$w,
+const config$v = {
+  xmlName: XML_NODE_NAME$y,
   sdNodeOrKeyName: SD_NODE_NAME$f,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$Y,
-  decode: decode$Q,
-  attributes: validXmlAttributes$k
+  encode: encode$_,
+  decode: decode$S,
+  attributes: validXmlAttributes$m
 };
-const translator$17 = NodeTranslator.from(config$t);
-const encode$X = (attributes) => {
+const translator$19 = NodeTranslator.from(config$v);
+const encode$Z = (attributes) => {
   const raw = attributes?.["w:val"];
   if (raw === void 0 || raw === null) return void 0;
   if (typeof raw === "boolean") return raw;
@@ -25310,24 +25382,24 @@ const encode$X = (attributes) => {
   if (val === "1" || val === "true" || val === "on") return true;
   return void 0;
 };
-const decode$P = (runProps) => {
+const decode$R = (runProps) => {
   if (runProps?.bold === false) return "0";
   return void 0;
 };
 const attrConfig$t = Object.freeze({
   xmlName: "w:val",
   sdName: "bold",
-  encode: encode$X,
-  decode: decode$P
+  encode: encode$Z,
+  decode: decode$R
 });
-const validXmlAttributes$j = [attrConfig$t];
-const XML_NODE_NAME$v = "w:b";
-const SD_ATTR_KEY$f = "bold";
-const encode$W = (params2, encodedAttrs = {}) => {
+const validXmlAttributes$l = [attrConfig$t];
+const XML_NODE_NAME$x = "w:b";
+const SD_ATTR_KEY$h = "bold";
+const encode$Y = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes[0];
   if (!node) return void 0;
-  const val = encodedAttrs?.[SD_ATTR_KEY$f];
+  const val = encodedAttrs?.[SD_ATTR_KEY$h];
   let attributes;
   if (val === false) attributes = { "w:val": "0" };
   else if (val === true)
@@ -25335,85 +25407,85 @@ const encode$W = (params2, encodedAttrs = {}) => {
   else attributes = node.attributes || {};
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$v,
-    sdNodeOrKeyName: SD_ATTR_KEY$f,
+    xmlName: XML_NODE_NAME$x,
+    sdNodeOrKeyName: SD_ATTR_KEY$h,
     attributes
   };
 };
-const config$s = {
-  xmlName: XML_NODE_NAME$v,
-  sdNodeOrKeyName: SD_ATTR_KEY$f,
+const config$u = {
+  xmlName: XML_NODE_NAME$x,
+  sdNodeOrKeyName: SD_ATTR_KEY$h,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$W,
-  attributes: validXmlAttributes$j
+  encode: encode$Y,
+  attributes: validXmlAttributes$l
 };
-const translator$16 = NodeTranslator.from(config$s);
-const XML_NODE_NAME$u = "w:i";
-const SD_ATTR_KEY$e = "italic";
-const encode$V = (params2) => {
+const translator$18 = NodeTranslator.from(config$u);
+const XML_NODE_NAME$w = "w:i";
+const SD_ATTR_KEY$g = "italic";
+const encode$X = (params2) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   if (!node) return void 0;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$u,
-    sdNodeOrKeyName: SD_ATTR_KEY$e,
+    xmlName: XML_NODE_NAME$w,
+    sdNodeOrKeyName: SD_ATTR_KEY$g,
     attributes: {
       "w:val": node.attributes?.["w:val"] ?? null
     }
   };
 };
-const config$r = {
-  xmlName: XML_NODE_NAME$u,
-  sdNodeOrKeyName: SD_ATTR_KEY$e,
+const config$t = {
+  xmlName: XML_NODE_NAME$w,
+  sdNodeOrKeyName: SD_ATTR_KEY$g,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$V
+  encode: encode$X
 };
-const translator$15 = NodeTranslator.from(config$r);
-const encode$U = (attributes) => attributes?.["w:val"];
-const decode$O = (attrs) => attrs?.underline;
+const translator$17 = NodeTranslator.from(config$t);
+const encode$W = (attributes) => attributes?.["w:val"];
+const decode$Q = (attrs) => attrs?.underline;
 const attrConfig$s = Object.freeze({
   xmlName: "w:val",
   sdName: "underline",
-  encode: encode$U,
-  decode: decode$O
+  encode: encode$W,
+  decode: decode$Q
 });
-const encode$T = (attributes) => attributes?.["w:color"];
-const decode$N = (attrs) => attrs?.color;
+const encode$V = (attributes) => attributes?.["w:color"];
+const decode$P = (attrs) => attrs?.color;
 const attrConfig$r = Object.freeze({
   xmlName: "w:color",
   sdName: "color",
-  encode: encode$T,
-  decode: decode$N
+  encode: encode$V,
+  decode: decode$P
 });
-const encode$S = (attributes) => attributes?.["w:themeColor"];
-const decode$M = (attrs) => attrs?.themeColor;
+const encode$U = (attributes) => attributes?.["w:themeColor"];
+const decode$O = (attrs) => attrs?.themeColor;
 const attrConfig$q = Object.freeze({
   xmlName: "w:themeColor",
   sdName: "themeColor",
-  encode: encode$S,
-  decode: decode$M
+  encode: encode$U,
+  decode: decode$O
 });
-const encode$R = (attributes) => attributes?.["w:themeTint"];
-const decode$L = (attrs) => attrs?.themeTint;
+const encode$T = (attributes) => attributes?.["w:themeTint"];
+const decode$N = (attrs) => attrs?.themeTint;
 const attrConfig$p = Object.freeze({
   xmlName: "w:themeTint",
   sdName: "themeTint",
-  encode: encode$R,
-  decode: decode$L
+  encode: encode$T,
+  decode: decode$N
 });
-const encode$Q = (attributes) => attributes?.["w:themeShade"];
-const decode$K = (attrs) => attrs?.themeShade;
+const encode$S = (attributes) => attributes?.["w:themeShade"];
+const decode$M = (attrs) => attrs?.themeShade;
 const attrConfig$o = Object.freeze({
   xmlName: "w:themeShade",
   sdName: "themeShade",
-  encode: encode$Q,
-  decode: decode$K
+  encode: encode$S,
+  decode: decode$M
 });
-const validXmlAttributes$i = [attrConfig$s, attrConfig$r, attrConfig$q, attrConfig$p, attrConfig$o];
-const XML_NODE_NAME$t = "w:u";
-const SD_ATTR_KEY$d = "underline";
-const encode$P = (params2, encodedAttrs = {}) => {
+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 = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25429,12 +25501,12 @@ const encode$P = (params2, 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$v,
+    sdNodeOrKeyName: SD_ATTR_KEY$f,
     attributes
   };
 };
-const decode$J = (params2) => {
+const decode$L = (params2) => {
   const attrs = params2?.node?.attrs || {};
   const underlineType = attrs.underlineType ?? attrs.underline ?? null;
   const color = attrs.underlineColor ?? attrs.color ?? null;
@@ -25452,20 +25524,20 @@ const decode$J = (params2) => {
   if (themeTint) attributes["w:themeTint"] = themeTint;
   if (themeShade) attributes["w:themeShade"] = themeShade;
   return {
-    name: XML_NODE_NAME$t,
+    name: XML_NODE_NAME$v,
     attributes
   };
 };
-const config$q = {
-  xmlName: XML_NODE_NAME$t,
-  sdNodeOrKeyName: SD_ATTR_KEY$d,
+const config$s = {
+  xmlName: XML_NODE_NAME$v,
+  sdNodeOrKeyName: SD_ATTR_KEY$f,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$P,
-  decode: decode$J,
-  attributes: validXmlAttributes$i
+  encode: encode$R,
+  decode: decode$L,
+  attributes: validXmlAttributes$k
 };
-const translator$14 = NodeTranslator.from(config$q);
-const encode$O = (attributes) => {
+const translator$16 = NodeTranslator.from(config$s);
+const encode$Q = (attributes) => {
   const raw = attributes?.["w:val"];
   if (raw === void 0 || raw === null) return void 0;
   if (typeof raw === "boolean") return raw;
@@ -25475,24 +25547,24 @@ const encode$O = (attributes) => {
   if (val === "1" || val === "true" || val === "on") return true;
   return void 0;
 };
-const decode$I = (attrs) => {
+const decode$K = (attrs) => {
   if (attrs?.strike === false) return "0";
   return void 0;
 };
 const attrConfig$n = Object.freeze({
   xmlName: "w:val",
   sdName: "strike",
-  encode: encode$O,
-  decode: decode$I
+  encode: encode$Q,
+  decode: decode$K
 });
-const validXmlAttributes$h = [attrConfig$n];
-const XML_NODE_NAME$s = "w:strike";
-const SD_ATTR_KEY$c = "strike";
-const encode$N = (params2, encodedAttrs = {}) => {
+const validXmlAttributes$j = [attrConfig$n];
+const XML_NODE_NAME$u = "w:strike";
+const SD_ATTR_KEY$e = "strike";
+const encode$P = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   if (!node) return void 0;
-  const val = encodedAttrs?.[SD_ATTR_KEY$c];
+  const val = encodedAttrs?.[SD_ATTR_KEY$e];
   let attributes;
   if (val === false) attributes = { "w:val": "0" };
   else if (val === true) attributes = {};
@@ -25501,55 +25573,55 @@ const encode$N = (params2, encodedAttrs = {}) => {
   else if (val === true && attributes["w:val"] === void 0) delete attributes["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$s,
-    sdNodeOrKeyName: SD_ATTR_KEY$c,
+    xmlName: XML_NODE_NAME$u,
+    sdNodeOrKeyName: SD_ATTR_KEY$e,
     attributes
   };
 };
-const config$p = {
-  xmlName: XML_NODE_NAME$s,
-  sdNodeOrKeyName: SD_ATTR_KEY$c,
+const config$r = {
+  xmlName: XML_NODE_NAME$u,
+  sdNodeOrKeyName: SD_ATTR_KEY$e,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$N,
-  attributes: validXmlAttributes$h
+  encode: encode$P,
+  attributes: validXmlAttributes$j
 };
-const translator$13 = NodeTranslator.from(config$p);
-const encode$M = (attributes) => attributes?.["w:val"];
-const decode$H = (attrs) => attrs?.color;
+const translator$15 = NodeTranslator.from(config$r);
+const encode$O = (attributes) => attributes?.["w:val"];
+const decode$J = (attrs) => attrs?.color;
 const attrConfig$m = Object.freeze({
   xmlName: "w:val",
   sdName: "color",
-  encode: encode$M,
-  decode: decode$H
+  encode: encode$O,
+  decode: decode$J
 });
-const encode$L = (attributes) => attributes?.["w:themeColor"];
-const decode$G = (attrs) => attrs?.themeColor;
+const encode$N = (attributes) => attributes?.["w:themeColor"];
+const decode$I = (attrs) => attrs?.themeColor;
 const attrConfig$l = Object.freeze({
   xmlName: "w:themeColor",
   sdName: "themeColor",
-  encode: encode$L,
-  decode: decode$G
+  encode: encode$N,
+  decode: decode$I
 });
-const encode$K = (attributes) => attributes?.["w:themeTint"];
-const decode$F = (attrs) => attrs?.themeTint;
+const encode$M = (attributes) => attributes?.["w:themeTint"];
+const decode$H = (attrs) => attrs?.themeTint;
 const attrConfig$k = Object.freeze({
   xmlName: "w:themeTint",
   sdName: "themeTint",
-  encode: encode$K,
-  decode: decode$F
+  encode: encode$M,
+  decode: decode$H
 });
-const encode$J = (attributes) => attributes?.["w:themeShade"];
-const decode$E = (attrs) => attrs?.themeShade;
+const encode$L = (attributes) => attributes?.["w:themeShade"];
+const decode$G = (attrs) => attrs?.themeShade;
 const attrConfig$j = Object.freeze({
   xmlName: "w:themeShade",
   sdName: "themeShade",
-  encode: encode$J,
-  decode: decode$E
+  encode: encode$L,
+  decode: decode$G
 });
-const validXmlAttributes$g = [attrConfig$m, attrConfig$l, attrConfig$k, attrConfig$j];
-const XML_NODE_NAME$r = "w:color";
-const SD_ATTR_KEY$b = "color";
-const encode$I = (params2, encodedAttrs = {}) => {
+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 = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25564,63 +25636,63 @@ const encode$I = (params2, encodedAttrs = {}) => {
   if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$r,
-    sdNodeOrKeyName: SD_ATTR_KEY$b,
+    xmlName: XML_NODE_NAME$t,
+    sdNodeOrKeyName: SD_ATTR_KEY$d,
     attributes
   };
 };
-const config$o = {
-  xmlName: XML_NODE_NAME$r,
-  sdNodeOrKeyName: SD_ATTR_KEY$b,
+const config$q = {
+  xmlName: XML_NODE_NAME$t,
+  sdNodeOrKeyName: SD_ATTR_KEY$d,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$I,
-  attributes: validXmlAttributes$g
+  encode: encode$K,
+  attributes: validXmlAttributes$i
 };
-const translator$12 = NodeTranslator.from(config$o);
-const encode$H = (attributes) => attributes?.["w:eastAsia"];
-const decode$D = (attrs) => attrs?.eastAsia;
+const translator$14 = NodeTranslator.from(config$q);
+const encode$J = (attributes) => attributes?.["w:eastAsia"];
+const decode$F = (attrs) => attrs?.eastAsia;
 const attrConfig$i = Object.freeze({
   xmlName: "w:eastAsia",
   sdName: "eastAsia",
-  encode: encode$H,
-  decode: decode$D
+  encode: encode$J,
+  decode: decode$F
 });
-const encode$G = (attributes) => attributes?.["w:ascii"];
-const decode$C = (attrs) => attrs?.ascii;
+const encode$I = (attributes) => attributes?.["w:ascii"];
+const decode$E = (attrs) => attrs?.ascii;
 const attrConfig$h = Object.freeze({
   xmlName: "w:ascii",
   sdName: "ascii",
-  encode: encode$G,
-  decode: decode$C
+  encode: encode$I,
+  decode: decode$E
 });
-const encode$F = (attributes) => attributes?.["w:hAnsi"];
-const decode$B = (attrs) => attrs?.hAnsi;
+const encode$H = (attributes) => attributes?.["w:hAnsi"];
+const decode$D = (attrs) => attrs?.hAnsi;
 const attrConfig$g = Object.freeze({
   xmlName: "w:hAnsi",
   sdName: "hAnsi",
-  encode: encode$F,
-  decode: decode$B
+  encode: encode$H,
+  decode: decode$D
 });
-const encode$E = (attributes) => attributes?.["w:cs"];
-const decode$A = (attrs) => attrs?.cs;
+const encode$G = (attributes) => attributes?.["w:cs"];
+const decode$C = (attrs) => attrs?.cs;
 const attrConfig$f = Object.freeze({
   xmlName: "w:cs",
   sdName: "cs",
-  encode: encode$E,
-  decode: decode$A
+  encode: encode$G,
+  decode: decode$C
 });
-const encode$D = (attributes) => attributes?.["w:val"];
-const decode$z = (attrs) => attrs?.value;
+const encode$F = (attributes) => attributes?.["w:val"];
+const decode$B = (attrs) => attrs?.value;
 const attrConfig$e = Object.freeze({
   xmlName: "w:val",
   sdName: "value",
-  encode: encode$D,
-  decode: decode$z
+  encode: encode$F,
+  decode: decode$B
 });
-const validXmlAttributes$f = [attrConfig$i, attrConfig$h, attrConfig$g, attrConfig$f, attrConfig$e];
-const XML_NODE_NAME$q = "w:rFonts";
-const SD_ATTR_KEY$a = "fontFamily";
-const encode$C = (params2, encodedAttrs = {}) => {
+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 = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25646,109 +25718,109 @@ const encode$C = (params2, encodedAttrs = {}) => {
   if (attributes["w:val"] === void 0) delete attributes["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$q,
-    sdNodeOrKeyName: SD_ATTR_KEY$a,
+    xmlName: XML_NODE_NAME$s,
+    sdNodeOrKeyName: SD_ATTR_KEY$c,
     attributes
   };
 };
-const config$n = {
-  xmlName: XML_NODE_NAME$q,
-  sdNodeOrKeyName: SD_ATTR_KEY$a,
+const config$p = {
+  xmlName: XML_NODE_NAME$s,
+  sdNodeOrKeyName: SD_ATTR_KEY$c,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$C,
-  attributes: validXmlAttributes$f
+  encode: encode$E,
+  attributes: validXmlAttributes$h
 };
-const translator$11 = NodeTranslator.from(config$n);
-const encode$B = (attributes) => attributes?.["w:val"];
-const decode$y = (attrs) => attrs?.styleId;
+const translator$13 = NodeTranslator.from(config$p);
+const encode$D = (attributes) => attributes?.["w:val"];
+const decode$A = (attrs) => attrs?.styleId;
 const attrConfig$d = Object.freeze({
   xmlName: "w:val",
   sdName: "styleId",
-  encode: encode$B,
-  decode: decode$y
+  encode: encode$D,
+  decode: decode$A
 });
-const validXmlAttributes$e = [attrConfig$d];
-const XML_NODE_NAME$p = "w:rStyle";
-const SD_ATTR_KEY$9 = "styleId";
-const encode$A = (params2, encodedAttrs = {}) => {
+const validXmlAttributes$g = [attrConfig$d];
+const XML_NODE_NAME$r = "w:rStyle";
+const SD_ATTR_KEY$b = "styleId";
+const encode$C = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const value = encodedAttrs.styleId ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$p,
-    sdNodeOrKeyName: SD_ATTR_KEY$9,
+    xmlName: XML_NODE_NAME$r,
+    sdNodeOrKeyName: SD_ATTR_KEY$b,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$m = {
-  xmlName: XML_NODE_NAME$p,
-  sdNodeOrKeyName: SD_ATTR_KEY$9,
+const config$o = {
+  xmlName: XML_NODE_NAME$r,
+  sdNodeOrKeyName: SD_ATTR_KEY$b,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$A,
-  attributes: validXmlAttributes$e
+  encode: encode$C,
+  attributes: validXmlAttributes$g
 };
-const translator$10 = NodeTranslator.from(config$m);
-const encode$z = (attributes) => attributes?.["w:val"];
-const decode$x = (attrs) => attrs?.fontSize;
+const translator$12 = NodeTranslator.from(config$o);
+const encode$B = (attributes) => attributes?.["w:val"];
+const decode$z = (attrs) => attrs?.fontSize;
 const attrConfig$c = Object.freeze({
   xmlName: "w:val",
   sdName: "fontSize",
-  encode: encode$z,
-  decode: decode$x
+  encode: encode$B,
+  decode: decode$z
 });
-const validXmlAttributes$d = [attrConfig$c];
-const XML_NODE_NAME$o = "w:sz";
-const SD_ATTR_KEY$8 = "fontSize";
-const encode$y = (params2, encodedAttrs = {}) => {
+const validXmlAttributes$f = [attrConfig$c];
+const XML_NODE_NAME$q = "w:sz";
+const SD_ATTR_KEY$a = "fontSize";
+const encode$A = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const value = encodedAttrs.fontSize ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$o,
-    sdNodeOrKeyName: SD_ATTR_KEY$8,
+    xmlName: XML_NODE_NAME$q,
+    sdNodeOrKeyName: SD_ATTR_KEY$a,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$l = {
-  xmlName: XML_NODE_NAME$o,
-  sdNodeOrKeyName: SD_ATTR_KEY$8,
+const config$n = {
+  xmlName: XML_NODE_NAME$q,
+  sdNodeOrKeyName: SD_ATTR_KEY$a,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$y,
-  attributes: validXmlAttributes$d
+  encode: encode$A,
+  attributes: validXmlAttributes$f
 };
-const translator$$ = NodeTranslator.from(config$l);
-const encode$x = (attributes) => attributes?.["w:val"];
-const decode$w = (attrs) => attrs?.fontSizeCs;
+const translator$11 = NodeTranslator.from(config$n);
+const encode$z = (attributes) => attributes?.["w:val"];
+const decode$y = (attrs) => attrs?.fontSizeCs;
 const attrConfig$b = Object.freeze({
   xmlName: "w:val",
   sdName: "fontSizeCs",
-  encode: encode$x,
-  decode: decode$w
+  encode: encode$z,
+  decode: decode$y
 });
-const validXmlAttributes$c = [attrConfig$b];
-const XML_NODE_NAME$n = "w:szCs";
-const SD_ATTR_KEY$7 = "fontSizeCs";
-const encode$w = (params2, encodedAttrs = {}) => {
+const validXmlAttributes$e = [attrConfig$b];
+const XML_NODE_NAME$p = "w:szCs";
+const SD_ATTR_KEY$9 = "fontSizeCs";
+const encode$y = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const value = encodedAttrs.fontSizeCs ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$n,
-    sdNodeOrKeyName: SD_ATTR_KEY$7,
+    xmlName: XML_NODE_NAME$p,
+    sdNodeOrKeyName: SD_ATTR_KEY$9,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$k = {
-  xmlName: XML_NODE_NAME$n,
-  sdNodeOrKeyName: SD_ATTR_KEY$7,
+const config$m = {
+  xmlName: XML_NODE_NAME$p,
+  sdNodeOrKeyName: SD_ATTR_KEY$9,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$w,
-  attributes: validXmlAttributes$c
+  encode: encode$y,
+  attributes: validXmlAttributes$e
 };
-const translator$_ = NodeTranslator.from(config$k);
+const translator$10 = NodeTranslator.from(config$m);
 const generateV2HandlerEntity = (handlerName, translator2) => ({
   handlerName,
   handler: (params2) => {
@@ -25882,9 +25954,9 @@ const integerToString = (value) => {
   const intValue = parseInteger(value);
   return intValue != void 0 ? String(intValue) : void 0;
 };
-const XML_NODE_NAME$m = "w:caps";
-const SD_ATTR_KEY$6 = "textTransform";
-const encode$v = (params2, encodedAttrs = {}) => {
+const XML_NODE_NAME$o = "w:caps";
+const SD_ATTR_KEY$8 = "textTransform";
+const encode$x = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes[0];
   if (!node) return void 0;
@@ -25896,31 +25968,31 @@ const encode$v = (params2, encodedAttrs = {}) => {
   }
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$m,
-    sdNodeOrKeyName: SD_ATTR_KEY$6,
-    attributes: { [SD_ATTR_KEY$6]: result }
+    xmlName: XML_NODE_NAME$o,
+    sdNodeOrKeyName: SD_ATTR_KEY$8,
+    attributes: { [SD_ATTR_KEY$8]: result }
   };
 };
-const config$j = {
-  xmlName: XML_NODE_NAME$m,
-  sdNodeOrKeyName: SD_ATTR_KEY$6,
+const config$l = {
+  xmlName: XML_NODE_NAME$o,
+  sdNodeOrKeyName: SD_ATTR_KEY$8,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$v,
+  encode: encode$x,
   attributes: [createAttributeHandler("w:val")]
 };
-const translator$Z = NodeTranslator.from(config$j);
+const translator$$ = NodeTranslator.from(config$l);
 const runPropertyTranslators = Object.freeze({
-  "w:b": translator$16,
-  "w:i": translator$15,
-  "w:u": translator$14,
-  "w:strike": translator$13,
-  "w:color": translator$12,
-  "w:highlight": translator$19,
-  "w:rFonts": translator$11,
-  "w:rStyle": translator$10,
-  "w:sz": translator$$,
-  "w:szCs": translator$_,
-  "w:caps": translator$Z
+  "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$$
 });
 const rawRunPropertyXmlNames = Object.freeze(["w:lang", "w:shd"]);
 const RAW_CHILD_NAME_SET = new Set(rawRunPropertyXmlNames);
@@ -25934,9 +26006,9 @@ const toRunPropertyEntry = (candidate) => {
     attributes: { ...candidate.attributes || {} }
   };
 };
-const XML_NODE_NAME$l = "w:rPr";
-const SD_ATTR_KEY$5 = "runProperties";
-const encode$u = (params2) => {
+const XML_NODE_NAME$n = "w:rPr";
+const SD_ATTR_KEY$7 = "runProperties";
+const encode$w = (params2) => {
   const { nodes } = params2;
   const node = nodes?.[0] || {};
   const contents = Array.isArray(node.elements) ? node.elements : [];
@@ -25970,16 +26042,16 @@ const encode$u = (params2) => {
     attributes: runPropsArray
   };
 };
-const config$i = {
-  xmlName: XML_NODE_NAME$l,
-  sdNodeOrKeyName: SD_ATTR_KEY$5,
+const config$k = {
+  xmlName: XML_NODE_NAME$n,
+  sdNodeOrKeyName: SD_ATTR_KEY$7,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$u
+  encode: encode$w
 };
-const translator$Y = NodeTranslator.from(config$i);
+const translator$_ = NodeTranslator.from(config$k);
 const EAST_ASIAN_CHARACTER_REGEX = /[\u1100-\u11FF\u2E80-\u2EFF\u2F00-\u2FDF\u3040-\u30FF\u3100-\u312F\u3130-\u318F\u31A0-\u31BF\u3400-\u4DBF\u4E00-\u9FFF\uA960-\uA97F\uAC00-\uD7AF\uF900-\uFAFF\uFF00-\uFFEF]/u;
 const containsEastAsianCharacters = (text) => EAST_ASIAN_CHARACTER_REGEX.test(text);
-const collectRunProperties = (params2, rPrNode, translator2 = translator$Y) => {
+const collectRunProperties = (params2, rPrNode, translator2 = translator$_) => {
   if (!rPrNode) return { entries: [], hadRPr: false, styleChangeMarks: [] };
   const result = translator2.encode({ ...params2, nodes: [rPrNode] }) || {};
   let entries = [];
@@ -26452,7 +26524,7 @@ const ensureTrackedWrapper = (runs, trackingMarksByType = /* @__PURE__ */ new Ma
   }
   return runs;
 };
-const XML_NODE_NAME$k = "w:hyperlink";
+const XML_NODE_NAME$m = "w:hyperlink";
 const SD_NODE_NAME$e = "link";
 const _createAttributeHandler = (xmlName, sdName) => ({
   xmlName,
@@ -26460,7 +26532,7 @@ const _createAttributeHandler = (xmlName, sdName) => ({
   encode: (attributes) => attributes[xmlName],
   decode: (attributes) => attributes[sdName]
 });
-const validXmlAttributes$b = [
+const validXmlAttributes$d = [
   _createAttributeHandler("w:anchor", "anchor"),
   _createAttributeHandler("w:docLocation", "docLocation"),
   {
@@ -26473,7 +26545,7 @@ const validXmlAttributes$b = [
   _createAttributeHandler("r:id", "rId"),
   _createAttributeHandler("w:tgtFrame", "target")
 ];
-const encode$t = (params2, encodedAttrs) => {
+const encode$v = (params2, encodedAttrs) => {
   const { nodes, docx, nodeListHandler } = params2;
   const node = nodes[0];
   let href = _resolveHref(docx, encodedAttrs);
@@ -26507,7 +26579,7 @@ const _resolveHref = (docx, encodedAttrs) => {
   }
   return href;
 };
-function decode$v(params2) {
+function decode$x(params2) {
   const { hyperlinkGroup = [params2.node] } = params2.extraParams || {};
   const node = hyperlinkGroup[0];
   const linkMark = node.marks.find((m2) => m2.type === "link");
@@ -26556,55 +26628,55 @@ function _addNewLinkRelationship(params2, link) {
   });
   return id;
 }
-const config$h = {
-  xmlName: XML_NODE_NAME$k,
+const config$j = {
+  xmlName: XML_NODE_NAME$m,
   sdNodeOrKeyName: SD_NODE_NAME$e,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$t,
-  decode: decode$v,
-  attributes: validXmlAttributes$b
+  encode: encode$v,
+  decode: decode$x,
+  attributes: validXmlAttributes$d
 };
-const translator$X = NodeTranslator.from(config$h);
-const encode$s = (attributes) => {
+const translator$Z = NodeTranslator.from(config$j);
+const encode$u = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$u = (attrs) => {
+const decode$w = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$a = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$s,
-  decode: decode$u
+  encode: encode$u,
+  decode: decode$w
 });
-const encode$r = (attributes) => {
+const encode$t = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$t = (attrs) => {
+const decode$v = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$9 = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$r,
-  decode: decode$t
+  encode: encode$t,
+  decode: decode$v
 });
-const encode$q = (attributes) => {
+const encode$s = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$s = (attrs) => {
+const decode$u = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$8 = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$q,
-  decode: decode$s
+  encode: encode$s,
+  decode: decode$u
 });
-const validXmlAttributes$a = [attrConfig$a, attrConfig$9, attrConfig$8];
-const XML_NODE_NAME$j = "w:r";
+const validXmlAttributes$c = [attrConfig$a, attrConfig$9, attrConfig$8];
+const XML_NODE_NAME$l = "w:r";
 const SD_KEY_NAME = "run";
-const encode$p = (params2, encodedAttrs = {}) => {
+const encode$r = (params2, encodedAttrs = {}) => {
   const { nodes = [], nodeListHandler } = params2 || {};
   const runNode = nodes[0];
   if (!runNode) return void 0;
@@ -26652,11 +26724,17 @@ const encode$p = (params2, encodedAttrs = {}) => {
   }
   return runNodeResult;
 };
-const decode$r = (params2, decodedAttrs = {}) => {
+const decode$t = (params2, decodedAttrs = {}) => {
   const { node } = params2 || {};
   if (!node) return void 0;
   const isLinkNode = node.marks?.some((m2) => m2.type === "link");
-  if (isLinkNode) return translator$X.decode(params2);
+  if (isLinkNode) {
+    const extraParams = {
+      ...params2.extraParams,
+      linkProcessed: true
+    };
+    return translator$Z.decode({ ...params2, extraParams });
+  }
   const { runNode: runNodeForExport, trackingMarksByType } = prepareRunTrackingContext(node);
   const runAttrs = runNodeForExport.attrs || {};
   const runProperties = Array.isArray(runAttrs.runProperties) ? runAttrs.runProperties : [];
@@ -26711,7 +26789,7 @@ const decode$r = (params2, decodedAttrs = {}) => {
       runs.push(trackedClone);
       return;
     }
-    const runWrapper = { name: XML_NODE_NAME$j, elements: [] };
+    const runWrapper = { name: XML_NODE_NAME$l, elements: [] };
     applyBaseRunProps(runWrapper);
     if (!Array.isArray(runWrapper.elements)) runWrapper.elements = [];
     runWrapper.elements.push(cloneXmlNode(child));
@@ -26719,7 +26797,7 @@ const decode$r = (params2, decodedAttrs = {}) => {
   });
   const trackedRuns = ensureTrackedWrapper(runs, trackingMarksByType);
   if (!trackedRuns.length) {
-    const emptyRun = { name: XML_NODE_NAME$j, elements: [] };
+    const emptyRun = { name: XML_NODE_NAME$l, elements: [] };
     applyBaseRunProps(emptyRun);
     trackedRuns.push(emptyRun);
   }
@@ -26733,15 +26811,15 @@ const decode$r = (params2, decodedAttrs = {}) => {
   }
   return trackedRuns;
 };
-const config$g = {
-  xmlName: XML_NODE_NAME$j,
+const config$i = {
+  xmlName: XML_NODE_NAME$l,
   sdNodeOrKeyName: SD_KEY_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$p,
-  decode: decode$r,
-  attributes: validXmlAttributes$a
+  encode: encode$r,
+  decode: decode$t,
+  attributes: validXmlAttributes$c
 };
-const translator$W = NodeTranslator.from(config$g);
+const translator$Y = NodeTranslator.from(config$i);
 function preProcessVerticalMergeCells(table, { editorSchema }) {
   if (!table || !Array.isArray(table.content)) {
     return table;
@@ -26782,13 +26860,13 @@ function preProcessVerticalMergeCells(table, { editorSchema }) {
   }
   return table;
 }
-const translator$V = NodeTranslator.from({
+const translator$X = 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$U = NodeTranslator.from({
+const translator$W = NodeTranslator.from({
   xmlName: "w:cnfStyle",
   sdNodeOrKeyName: "cnfStyle",
   attributes: [
@@ -26814,8 +26892,8 @@ const translator$U = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$T = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
-const translator$S = NodeTranslator.from(
+const translator$V = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
+const translator$U = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridAfter",
     null,
@@ -26824,7 +26902,7 @@ const translator$S = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$R = NodeTranslator.from(
+const translator$T = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridBefore",
     null,
@@ -26833,21 +26911,21 @@ const translator$R = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$Q = NodeTranslator.from({
+const translator$S = 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$P = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc", "justification"));
-const translator$O = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
-const translator$N = NodeTranslator.from({
+const translator$R = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc", "justification"));
+const translator$Q = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
+const translator$P = 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$M = NodeTranslator.from({
+const translator$O = NodeTranslator.from({
   xmlName: "w:trHeight",
   sdNodeOrKeyName: "rowHeight",
   encode: ({ nodes }) => {
@@ -26874,11 +26952,11 @@ const translator$M = NodeTranslator.from({
     return Object.keys(heightAttrs).length > 0 ? { attributes: heightAttrs } : void 0;
   }
 });
-const translator$L = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
-const translator$K = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
-const XML_NODE_NAME$i = "w:trPr";
-const SD_ATTR_KEY$4 = "tableRowProperties";
-const encode$o = (params2) => {
+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 = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
   let attributes = {
@@ -26892,12 +26970,12 @@ const encode$o = (params2) => {
   };
   return {
     type: NodeTranslator.translatorTypes.ATTRIBUTE,
-    xmlName: XML_NODE_NAME$i,
-    sdNodeOrKeyName: SD_ATTR_KEY$4,
+    xmlName: XML_NODE_NAME$k,
+    sdNodeOrKeyName: SD_ATTR_KEY$6,
     attributes
   };
 };
-const decode$q = (params2) => {
+const decode$s = (params2) => {
   const { tableRowProperties = {} } = params2.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName$2, tableRowProperties);
   const newNode = {
@@ -26909,6 +26987,8 @@ const decode$q = (params2) => {
   return newNode;
 };
 const propertyTranslators$3 = [
+  translator$X,
+  translator$W,
   translator$V,
   translator$U,
   translator$T,
@@ -26918,9 +26998,7 @@ const propertyTranslators$3 = [
   translator$P,
   translator$O,
   translator$N,
-  translator$M,
-  translator$L,
-  translator$K
+  translator$M
 ];
 const propertyTranslatorsByXmlName$2 = {};
 propertyTranslators$3.forEach((translator2) => {
@@ -26930,25 +27008,25 @@ const propertyTranslatorsBySdName$2 = {};
 propertyTranslators$3.forEach((translator2) => {
   propertyTranslatorsBySdName$2[translator2.sdNodeOrKeyName] = translator2;
 });
-const config$f = {
-  xmlName: XML_NODE_NAME$i,
-  sdNodeOrKeyName: SD_ATTR_KEY$4,
+const config$h = {
+  xmlName: XML_NODE_NAME$k,
+  sdNodeOrKeyName: SD_ATTR_KEY$6,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$o,
-  decode: decode$q
+  encode: encode$q,
+  decode: decode$s
 };
-const translator$J = NodeTranslator.from(config$f);
-const XML_NODE_NAME$h = "w:tr";
+const translator$L = NodeTranslator.from(config$h);
+const XML_NODE_NAME$j = "w:tr";
 const SD_NODE_NAME$d = "tableRow";
-const validXmlAttributes$9 = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
+const validXmlAttributes$b = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
   (xmlName) => createAttributeHandler(xmlName)
 );
-const encode$n = (params2, encodedAttrs) => {
+const encode$p = (params2, encodedAttrs) => {
   const { row } = params2.extraParams;
   let tableRowProperties = {};
   const tPr = row.elements.find((el) => el.name === "w:trPr");
   if (tPr) {
-    ({ attributes: tableRowProperties } = translator$J.encode({
+    ({ attributes: tableRowProperties } = translator$L.encode({
       ...params2,
       nodes: [tPr]
     }));
@@ -26961,7 +27039,7 @@ const encode$n = (params2, encodedAttrs) => {
   let currentColumnIndex = 0;
   const content = cellNodes?.map((n) => {
     let columnWidth = gridColumnWidths?.[currentColumnIndex] || null;
-    const result = translator$a.encode({
+    const result = translator$c.encode({
       ...params2,
       extraParams: {
         ...params2.extraParams,
@@ -26983,7 +27061,7 @@ const encode$n = (params2, encodedAttrs) => {
   };
   return newNode;
 };
-const decode$p = (params2, decodedAttrs) => {
+const decode$r = (params2, decodedAttrs) => {
   const { node } = params2;
   const elements = translateChildNodes(params2);
   if (node.attrs?.tableRowProperties) {
@@ -26995,7 +27073,7 @@ const decode$p = (params2, decodedAttrs) => {
       }
     }
     tableRowProperties["cantSplit"] = node.attrs["cantSplit"];
-    const trPr = translator$J.decode({
+    const trPr = translator$L.decode({
       ...params2,
       node: { ...node, attrs: { ...node.attrs, tableRowProperties } }
     });
@@ -27007,22 +27085,22 @@ const decode$p = (params2, decodedAttrs) => {
     elements
   };
 };
-const config$e = {
-  xmlName: XML_NODE_NAME$h,
+const config$g = {
+  xmlName: XML_NODE_NAME$j,
   sdNodeOrKeyName: SD_NODE_NAME$d,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$n,
-  decode: decode$p,
-  attributes: validXmlAttributes$9
+  encode: encode$p,
+  decode: decode$r,
+  attributes: validXmlAttributes$b
 };
-const translator$I = NodeTranslator.from(config$e);
-const translator$H = NodeTranslator.from({
+const translator$K = NodeTranslator.from(config$g);
+const translator$J = 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$G = NodeTranslator.from({
+const translator$I = NodeTranslator.from({
   xmlName: "w:shd",
   sdNodeOrKeyName: "shading",
   attributes: [
@@ -27044,11 +27122,11 @@ const translator$G = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$F = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblCaption", "caption"));
-const translator$E = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblDescription", "description"));
-const translator$D = NodeTranslator.from(createMeasurementPropertyHandler("w:tblInd", "tableIndent"));
-const translator$C = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblLayout", "tableLayout", "w:type"));
-const translator$B = NodeTranslator.from({
+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({
   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")]),
@@ -27060,16 +27138,16 @@ const translator$B = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$A = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblOverlap", "overlap"));
-const translator$z = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblStyle", "tableStyleId"));
-const translator$y = NodeTranslator.from(
+const translator$C = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblOverlap", "overlap"));
+const translator$B = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblStyle", "tableStyleId"));
+const translator$A = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:tblStyleColBandSize", "tableStyleColBandSize")
 );
-const translator$x = NodeTranslator.from(
+const translator$z = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:tblStyleRowBandSize", "tableStyleRowBandSize")
 );
-const translator$w = NodeTranslator.from(createMeasurementPropertyHandler("w:tblW", "tableWidth"));
-const translator$v = NodeTranslator.from({
+const translator$y = NodeTranslator.from(createMeasurementPropertyHandler("w:tblW", "tableWidth"));
+const translator$x = 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))),
@@ -27081,29 +27159,29 @@ const translator$v = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$u = NodeTranslator.from(createBorderPropertyHandler("w:bottom"));
-const translator$t = NodeTranslator.from(createMeasurementPropertyHandler("w:bottom", "marginBottom"));
-const translator$s = NodeTranslator.from(createBorderPropertyHandler("w:end"));
-const translator$r = NodeTranslator.from(createMeasurementPropertyHandler("w:end", "marginEnd"));
-const translator$q = NodeTranslator.from(createBorderPropertyHandler("w:insideH"));
-const translator$p = NodeTranslator.from(createBorderPropertyHandler("w:insideV"));
-const translator$o = NodeTranslator.from(createBorderPropertyHandler("w:left"));
-const translator$n = NodeTranslator.from(createMeasurementPropertyHandler("w:left", "marginLeft"));
-const translator$m = NodeTranslator.from(createBorderPropertyHandler("w:right"));
-const translator$l = NodeTranslator.from(createMeasurementPropertyHandler("w:right", "marginRight"));
-const translator$k = NodeTranslator.from(createBorderPropertyHandler("w:start"));
-const translator$j = NodeTranslator.from(createMeasurementPropertyHandler("w:start", "marginStart"));
-const translator$i = NodeTranslator.from(createBorderPropertyHandler("w:top"));
-const translator$h = NodeTranslator.from(createMeasurementPropertyHandler("w:top", "marginTop"));
-const XML_NODE_NAME$g = "w:tblBorders";
-const SD_ATTR_KEY$3 = "borders";
-const encode$m = (params2) => {
+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 = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
   const attributes = encodeProperties(node, tblBordersTranslatorsByXmlName);
   return Object.keys(attributes).length > 0 ? attributes : void 0;
 };
-const decode$o = (params2) => {
+const decode$q = (params2) => {
   const { borders = {} } = params2.node.attrs || {};
   const elements = decodeProperties(tblBordersTranslatorsBySdName, borders);
   const newNode = {
@@ -27115,14 +27193,14 @@ const decode$o = (params2) => {
   return newNode;
 };
 const propertyTranslators$2 = [
+  translator$w,
   translator$u,
   translator$s,
+  translator$r,
   translator$q,
-  translator$p,
   translator$o,
   translator$m,
-  translator$k,
-  translator$i
+  translator$k
 ];
 const tblBordersTranslatorsByXmlName = {};
 const tblBordersTranslatorsBySdName = {};
@@ -27130,27 +27208,27 @@ propertyTranslators$2.forEach((translator2) => {
   tblBordersTranslatorsByXmlName[translator2.xmlName] = translator2;
   tblBordersTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
 });
-const translator$g = NodeTranslator.from({
-  xmlName: XML_NODE_NAME$g,
-  sdNodeOrKeyName: SD_ATTR_KEY$3,
+const translator$i = NodeTranslator.from({
+  xmlName: XML_NODE_NAME$i,
+  sdNodeOrKeyName: SD_ATTR_KEY$5,
   type: NodeTranslator.translatorTypes.NODE,
   attributes: [],
-  encode: encode$m,
-  decode: decode$o
+  encode: encode$o,
+  decode: decode$q
 });
-const XML_NODE_NAME$f = "w:tblCellMar";
-const SD_ATTR_KEY$2 = "cellMargins";
-const encode$l = (params2) => {
+const XML_NODE_NAME$h = "w:tblCellMar";
+const SD_ATTR_KEY$4 = "cellMargins";
+const encode$n = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
   const attributes = encodeProperties(node, propertyTranslatorsByXmlName$1);
   return Object.keys(attributes).length > 0 ? attributes : void 0;
 };
-const decode$n = (params2) => {
+const decode$p = (params2) => {
   const { cellMargins = {} } = params2.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName$1, cellMargins);
   const newNode = {
-    name: XML_NODE_NAME$f,
+    name: XML_NODE_NAME$h,
     type: "element",
     attributes: {},
     elements
@@ -27158,12 +27236,12 @@ const decode$n = (params2) => {
   return newNode;
 };
 const propertyTranslators$1 = [
+  translator$v,
   translator$t,
-  translator$r,
+  translator$p,
   translator$n,
   translator$l,
-  translator$j,
-  translator$h
+  translator$j
 ];
 const propertyTranslatorsByXmlName$1 = {};
 const propertyTranslatorsBySdName$1 = {};
@@ -27171,27 +27249,27 @@ propertyTranslators$1.forEach((translator2) => {
   propertyTranslatorsByXmlName$1[translator2.xmlName] = translator2;
   propertyTranslatorsBySdName$1[translator2.sdNodeOrKeyName] = translator2;
 });
-const translator$f = NodeTranslator.from({
-  xmlName: XML_NODE_NAME$f,
-  sdNodeOrKeyName: SD_ATTR_KEY$2,
+const translator$h = NodeTranslator.from({
+  xmlName: XML_NODE_NAME$h,
+  sdNodeOrKeyName: SD_ATTR_KEY$4,
   type: NodeTranslator.translatorTypes.NODE,
   attributes: [],
-  encode: encode$l,
-  decode: decode$n
+  encode: encode$n,
+  decode: decode$p
 });
-const XML_NODE_NAME$e = "w:tblPr";
-const SD_ATTR_KEY$1 = "tableProperties";
-const encode$k = (params2) => {
+const XML_NODE_NAME$g = "w:tblPr";
+const SD_ATTR_KEY$3 = "tableProperties";
+const encode$m = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
   const attributes = encodeProperties(node, propertyTranslatorsByXmlName);
   return {
-    xmlName: XML_NODE_NAME$e,
-    sdNodeOrKeyName: SD_ATTR_KEY$1,
+    xmlName: XML_NODE_NAME$g,
+    sdNodeOrKeyName: SD_ATTR_KEY$3,
     attributes
   };
 };
-const decode$m = (params2) => {
+const decode$o = (params2) => {
   const { tableProperties = {} } = params2.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName, tableProperties);
   const newNode = {
@@ -27203,11 +27281,13 @@ const decode$m = (params2) => {
   return newNode;
 };
 const propertyTranslators = [
+  translator$J,
+  translator$R,
+  translator$I,
   translator$H,
-  translator$P,
+  translator$Q,
   translator$G,
   translator$F,
-  translator$O,
   translator$E,
   translator$D,
   translator$C,
@@ -27216,10 +27296,8 @@ const propertyTranslators = [
   translator$z,
   translator$y,
   translator$x,
-  translator$w,
-  translator$v,
-  translator$g,
-  translator$f
+  translator$i,
+  translator$h
 ];
 const propertyTranslatorsByXmlName = {};
 const propertyTranslatorsBySdName = {};
@@ -27227,14 +27305,14 @@ propertyTranslators.forEach((translator2) => {
   propertyTranslatorsByXmlName[translator2.xmlName] = translator2;
   propertyTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
 });
-const config$d = {
-  xmlName: XML_NODE_NAME$e,
-  sdNodeOrKeyName: SD_ATTR_KEY$1,
-  encode: encode$k,
-  decode: decode$m
+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$d);
-const translator$d = NodeTranslator.from(
+const translator$g = NodeTranslator.from(config$f);
+const translator$f = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:gridCol", "col", "w:w", parseInteger, integerToString)
 );
 const DEFAULT_COLUMN_WIDTH_PX = 100;
@@ -27284,20 +27362,20 @@ const resolveFallbackColumnWidthTwips = (params2, totalColumns, cellMinWidthTwip
   }
   return Math.max(fallbackWidthTwips, cellMinWidthTwips);
 };
-const XML_NODE_NAME$d = "w:tblGrid";
-const SD_ATTR_KEY = "grid";
+const XML_NODE_NAME$f = "w:tblGrid";
+const SD_ATTR_KEY$2 = "grid";
 const cellMinWidth = pixelsToTwips(10);
-const encode$j = (params2) => {
+const encode$l = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
-  const attributes = encodeProperties(node, { [translator$d.xmlName]: translator$d }, true);
+  const attributes = encodeProperties(node, { [translator$f.xmlName]: translator$f }, true);
   return {
-    xmlName: XML_NODE_NAME$d,
-    sdNodeOrKeyName: SD_ATTR_KEY,
+    xmlName: XML_NODE_NAME$f,
+    sdNodeOrKeyName: SD_ATTR_KEY$2,
     attributes
   };
 };
-const decode$l = (params2) => {
+const decode$n = (params2) => {
   const { grid: rawGrid } = params2.node.attrs || {};
   const grid = Array.isArray(rawGrid) ? rawGrid : [];
   const { firstRow = {} } = params2.extraParams || {};
@@ -27316,10 +27394,10 @@ const decode$l = (params2) => {
       numericWidth = fallbackColumnWidthTwips;
     }
     numericWidth = Math.max(numericWidth, cellMinWidth);
-    const decoded = translator$d.decode({
+    const decoded = translator$f.decode({
       node: { type: (
         /** @type {string} */
-        translator$d.sdNodeOrKeyName
+        translator$f.sdNodeOrKeyName
       ), attrs: { col: numericWidth } }
     });
     if (decoded) elements.push(decoded);
@@ -27354,19 +27432,19 @@ const decode$l = (params2) => {
     columnIndex++;
   }
   const newNode = {
-    name: XML_NODE_NAME$d,
+    name: XML_NODE_NAME$f,
     attributes: {},
     elements
   };
   return newNode;
 };
-const config$c = {
-  xmlName: XML_NODE_NAME$d,
-  sdNodeOrKeyName: SD_ATTR_KEY,
-  encode: encode$j,
-  decode: decode$l
+const config$e = {
+  xmlName: XML_NODE_NAME$f,
+  sdNodeOrKeyName: SD_ATTR_KEY$2,
+  encode: encode$l,
+  decode: decode$n
 };
-const translator$c = NodeTranslator.from(config$c);
+const translator$e = NodeTranslator.from(config$e);
 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;
@@ -27429,19 +27507,19 @@ const buildFallbackGridForTable = ({ params: params2, rows, tableWidth, tableWid
     columnWidths: Array(columnCount).fill(fallbackColumnWidthPx)
   };
 };
-const XML_NODE_NAME$c = "w:tbl";
+const XML_NODE_NAME$e = "w:tbl";
 const SD_NODE_NAME$c = "table";
-const encode$i = (params2, encodedAttrs) => {
+const encode$k = (params2, encodedAttrs) => {
   const { nodes } = params2;
   const node = nodes[0];
   const tblPr = node.elements.find((el) => el.name === "w:tblPr");
   if (tblPr) {
-    const encodedProperties = translator$e.encode({ ...params2, nodes: [tblPr] });
+    const encodedProperties = translator$g.encode({ ...params2, nodes: [tblPr] });
     encodedAttrs["tableProperties"] = encodedProperties?.attributes || {};
   }
   const tblGrid = node.elements.find((el) => el.name === "w:tblGrid");
   if (tblGrid) {
-    encodedAttrs["grid"] = translator$c.encode({ ...params2, nodes: [tblGrid] }).attributes;
+    encodedAttrs["grid"] = translator$e.encode({ ...params2, nodes: [tblGrid] }).attributes;
   }
   [
     "tableStyleId",
@@ -27508,7 +27586,7 @@ const encode$i = (params2, encodedAttrs) => {
   }
   const content = [];
   rows.forEach((row) => {
-    const result = translator$I.encode({
+    const result = translator$K.encode({
       ...params2,
       nodes: [row],
       extraParams: {
@@ -27527,13 +27605,13 @@ const encode$i = (params2, encodedAttrs) => {
     attrs: encodedAttrs
   };
 };
-const decode$k = (params2, decodedAttrs) => {
+const decode$m = (params2, decodedAttrs) => {
   params2.node = preProcessVerticalMergeCells(params2.node, params2);
   const { node } = params2;
   const elements = translateChildNodes(params2);
   const firstRow = node.content?.find((n) => n.type === "tableRow");
   const properties = node.attrs.grid;
-  const element = translator$c.decode({
+  const element = translator$e.decode({
     ...params2,
     node: { ...node, attrs: { ...node.attrs, grid: properties } },
     extraParams: {
@@ -27543,7 +27621,7 @@ const decode$k = (params2, decodedAttrs) => {
   if (element) elements.unshift(element);
   if (node.attrs?.tableProperties) {
     const properties2 = { ...node.attrs.tableProperties };
-    const element2 = translator$e.decode({
+    const element2 = translator$g.decode({
       ...params2,
       node: { ...node, attrs: { ...node.attrs, tableProperties: properties2 } }
     });
@@ -27609,7 +27687,7 @@ function _getReferencedTableStyles(tableStyleReference, params2) {
     if (baseTblPr && baseTblPr.elements) {
       tblPr.elements.push(...baseTblPr.elements);
     }
-    const tableProperties = translator$e.encode({ ...params2, nodes: [tblPr] }).attributes;
+    const tableProperties = translator$g.encode({ ...params2, nodes: [tblPr] }).attributes;
     const { borders, rowBorders } = _processTableBorders(tableProperties.borders || {});
     if (borders) stylesToReturn.borders = borders;
     if (rowBorders) stylesToReturn.rowBorders = rowBorders;
@@ -27626,16 +27704,16 @@ function _getReferencedTableStyles(tableStyleReference, params2) {
   }
   return stylesToReturn;
 }
-const config$b = {
-  xmlName: XML_NODE_NAME$c,
+const config$d = {
+  xmlName: XML_NODE_NAME$e,
   sdNodeOrKeyName: SD_NODE_NAME$c,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$i,
-  decode: decode$k,
+  encode: encode$k,
+  decode: decode$m,
   attributes: []
 };
-const translator$b = NodeTranslator.from(config$b);
-const tableNodeHandlerEntity = generateV2HandlerEntity("tableNodeHandler", translator$b);
+const translator$d = NodeTranslator.from(config$d);
+const tableNodeHandlerEntity = generateV2HandlerEntity("tableNodeHandler", translator$d);
 function getReferencedTableStyles(tblStyleTag, docx) {
   if (!tblStyleTag) return null;
   const stylesToReturn = {};
@@ -27997,10 +28075,10 @@ function generateCellMargins(cellMargins) {
   if (left2 != null) elements.push({ name: "w:left", attributes: { "w:w": pixelsToTwips(left2) } });
   return elements;
 }
-const XML_NODE_NAME$b = "w:tc";
+const XML_NODE_NAME$d = "w:tc";
 const SD_NODE_NAME$b = "tableCell";
-const validXmlAttributes$8 = [];
-function encode$h(params2, encodedAttrs) {
+const validXmlAttributes$a = [];
+function encode$j(params2, encodedAttrs) {
   const {
     node,
     table,
@@ -28027,22 +28105,22 @@ function encode$h(params2, encodedAttrs) {
   }
   return schemaNode;
 }
-function decode$j(params2, decodedAttrs) {
+function decode$l(params2, decodedAttrs) {
   const translated = translateTableCell(params2);
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
     translated.attributes = { ...translated.attributes || {}, ...decodedAttrs };
   }
   return translated;
 }
-const config$a = {
-  xmlName: XML_NODE_NAME$b,
+const config$c = {
+  xmlName: XML_NODE_NAME$d,
   sdNodeOrKeyName: SD_NODE_NAME$b,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$h,
-  decode: decode$j,
-  attributes: validXmlAttributes$8
+  encode: encode$j,
+  decode: decode$l,
+  attributes: validXmlAttributes$a
 };
-const translator$a = NodeTranslator.from(config$a);
+const translator$c = NodeTranslator.from(config$c);
 function parseTagValueJSON(json) {
   if (typeof json !== "string") {
     return {};
@@ -28469,8 +28547,64 @@ function handleImageNode(node, params2, isAnchor) {
   const vRelativeFrom = positionVTag?.attributes.relativeFrom;
   const alignV = positionVTag?.elements?.find((el) => el.name === "wp:align")?.elements[0]?.text;
   const simplePos = node.elements.find((el) => el.name === "wp:simplePos");
-  const wrapSquare = node.elements.find((el) => el.name === "wp:wrapSquare");
-  const wrapTopAndBottom = node.elements.find((el) => el.name === "wp:wrapTopAndBottom");
+  const wrapNode = isAnchor ? node.elements.find(
+    (el) => ["wp:wrapNone", "wp:wrapSquare", "wp:wrapThrough", "wp:wrapTight", "wp:wrapTopAndBottom"].includes(el.name)
+  ) : null;
+  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 || {})) {
+        wrap2.attrs.distBottom = emuToPixels(wrapNode.attributes.distB);
+      }
+      if ("distL" in (wrapNode.attributes || {})) {
+        wrap2.attrs.distLeft = emuToPixels(wrapNode.attributes.distL);
+      }
+      if ("distR" in (wrapNode.attributes || {})) {
+        wrap2.attrs.distRight = emuToPixels(wrapNode.attributes.distR);
+      }
+      if ("distT" in (wrapNode.attributes || {})) {
+        wrap2.attrs.distTop = emuToPixels(wrapNode.attributes.distT);
+      }
+      break;
+    case "Tight":
+    case "Through": {
+      if ("distL" in (wrapNode.attributes || {})) {
+        wrap2.attrs.distLeft = emuToPixels(wrapNode.attributes.distL);
+      }
+      if ("distR" in (wrapNode.attributes || {})) {
+        wrap2.attrs.distRight = emuToPixels(wrapNode.attributes.distR);
+      }
+      if ("distT" in (wrapNode.attributes || {})) {
+        wrap2.attrs.distTop = emuToPixels(wrapNode.attributes.distT);
+      }
+      if ("distB" in (wrapNode.attributes || {})) {
+        wrap2.attrs.distBottom = emuToPixels(wrapNode.attributes.distB);
+      }
+      if ("wrapText" in (wrapNode.attributes || {})) {
+        wrap2.attrs.wrapText = wrapNode.attributes.wrapText;
+      }
+      const polygon = wrapNode.elements?.find((el) => el.name === "wp:wrapPolygon");
+      if (polygon) {
+        wrap2.attrs.polygon = polygonToObj(polygon);
+        if (polygon.attributes?.edited !== void 0) {
+          wrap2.attrs.polygonEdited = polygon.attributes.edited;
+        }
+      }
+      break;
+    }
+    case "TopAndBottom":
+      if ("distB" in (wrapNode.attributes || {})) {
+        wrap2.attrs.distBottom = emuToPixels(wrapNode.attributes.distB);
+      }
+      if ("distT" in (wrapNode.attributes || {})) {
+        wrap2.attrs.distTop = emuToPixels(wrapNode.attributes.distT);
+      }
+      break;
+    case "None":
+      wrap2.attrs.behindDoc = node.attributes?.behindDoc === "1";
+      break;
+  }
   const docPr = node.elements.find((el) => el.name === "wp:docPr");
   let anchorData = null;
   if (hRelativeFrom || alignH || vRelativeFrom || alignV) {
@@ -28482,7 +28616,7 @@ function handleImageNode(node, params2, isAnchor) {
     };
   }
   const marginOffset = {
-    left: positionHValue,
+    horizontal: positionHValue,
     top: positionVValue
   };
   const { attributes: blipAttributes = {} } = blip;
@@ -28521,10 +28655,7 @@ function handleImageNode(node, params2, isAnchor) {
           y: simplePos.attributes.y
         }
       },
-      ...wrapSquare && {
-        wrapText: wrapSquare.attributes.wrapText
-      },
-      wrapTopAndBottom: !!wrapTopAndBottom,
+      wrap: wrap2,
       originalPadding: {
         distT: attributes["distT"],
         distB: attributes["distB"],
@@ -28872,7 +29003,6 @@ function addNewImageRelationship(params2, imagePath) {
 function translateAnchorNode(params2) {
   const { attrs } = params2.node;
   const anchorElements = [];
-  const wrapElements = [];
   if (attrs.simplePos) {
     anchorElements.push({
       name: "wp:simplePos",
@@ -28884,10 +29014,10 @@ function translateAnchorNode(params2) {
   }
   if (attrs.anchorData) {
     const hElements = [];
-    if (attrs.marginOffset.left !== void 0) {
+    if (attrs.marginOffset.horizontal !== void 0) {
       hElements.push({
         name: "wp:posOffset",
-        elements: [{ type: "text", text: pixelsToEmu(attrs.marginOffset.left).toString() }]
+        elements: [{ type: "text", text: pixelsToEmu(attrs.marginOffset.horizontal).toString() }]
       });
     }
     if (attrs.anchorData.alignH) {
@@ -28920,38 +29050,110 @@ function translateAnchorNode(params2) {
       ...vElements.length && { elements: vElements }
     });
   }
-  if (attrs.wrapText) {
-    wrapElements.push({
-      name: "wp:wrapSquare",
-      attributes: {
-        wrapText: attrs.wrapText
-      }
-    });
+  const nodeElements = translateImageNode(params2);
+  const inlineAttrs = {
+    ...attrs.originalAttributes || {},
+    ...nodeElements.attributes || {}
+  };
+  if (inlineAttrs.relativeHeight == null) {
+    inlineAttrs.relativeHeight = 1;
   }
-  if (attrs.wrapTopAndBottom) {
-    wrapElements.push({
-      name: "wp:wrapTopAndBottom"
-    });
+  if (attrs.originalAttributes?.simplePos !== void 0) {
+    inlineAttrs.simplePos = attrs.originalAttributes.simplePos;
+  } else if (attrs.simplePos !== void 0) {
+    inlineAttrs.simplePos = attrs.simplePos;
   }
-  if (!wrapElements.length) {
-    wrapElements.push({
-      name: "wp:wrapNone"
-    });
+  if (attrs.originalAttributes?.locked !== void 0) {
+    inlineAttrs.locked = attrs.originalAttributes.locked;
   }
-  const nodeElements = translateImageNode(params2);
-  const inlineAttrs = {
-    ...nodeElements.attributes,
-    simplePos: attrs.originalAttributes?.simplePos,
-    relativeHeight: 1,
-    behindDoc: attrs.originalAttributes?.behindDoc,
-    locked: attrs.originalAttributes?.locked,
-    layoutInCell: attrs.originalAttributes?.layoutInCell,
-    allowOverlap: attrs.originalAttributes?.allowOverlap
+  if (attrs.originalAttributes?.layoutInCell !== void 0) {
+    inlineAttrs.layoutInCell = attrs.originalAttributes.layoutInCell;
+  }
+  if (attrs.originalAttributes?.allowOverlap !== void 0) {
+    inlineAttrs.allowOverlap = attrs.originalAttributes.allowOverlap;
+  }
+  const wrapElement = {
+    name: `wp:wrap${attrs.wrap?.type || "None"}`
+    // Important: wp:anchor will break if no wrapping is specified. We need to use wrapNone.
   };
+  switch (attrs.wrap?.type) {
+    case "Square":
+      wrapElement.attributes = {
+        wrapText: attrs.wrap.attrs.wrapText
+      };
+      if ("distBottom" in (attrs.wrap.attrs || {})) {
+        wrapElement.attributes.distB = pixelsToEmu(attrs.wrap.attrs.distBottom);
+      }
+      if ("distLeft" in (attrs.wrap.attrs || {})) {
+        wrapElement.attributes.distL = pixelsToEmu(attrs.wrap.attrs.distLeft);
+      }
+      if ("distRight" in (attrs.wrap.attrs || {})) {
+        wrapElement.attributes.distR = pixelsToEmu(attrs.wrap.attrs.distRight);
+      }
+      if ("distTop" in (attrs.wrap.attrs || {})) {
+        wrapElement.attributes.distT = pixelsToEmu(attrs.wrap.attrs.distTop);
+      }
+      break;
+    case "TopAndBottom": {
+      const attributes = {};
+      let hasKeys = false;
+      if ("distBottom" in (attrs.wrap.attrs || {})) {
+        attributes.distB = pixelsToEmu(attrs.wrap.attrs.distBottom);
+        hasKeys = true;
+      }
+      if ("distTop" in (attrs.wrap.attrs || {})) {
+        attributes.distT = pixelsToEmu(attrs.wrap.attrs.distTop);
+        hasKeys = true;
+      }
+      if (hasKeys) {
+        wrapElement.attributes = attributes;
+      }
+      break;
+    }
+    case "Through":
+    case "Tight": {
+      const attributes = {};
+      if ("distLeft" in (attrs.wrap.attrs || {})) {
+        attributes.distL = pixelsToEmu(attrs.wrap.attrs.distLeft);
+      }
+      if ("distRight" in (attrs.wrap.attrs || {})) {
+        attributes.distR = pixelsToEmu(attrs.wrap.attrs.distRight);
+      }
+      if ("distTop" in (attrs.wrap.attrs || {})) {
+        attributes.distT = pixelsToEmu(attrs.wrap.attrs.distTop);
+      }
+      if ("distBottom" in (attrs.wrap.attrs || {})) {
+        attributes.distB = pixelsToEmu(attrs.wrap.attrs.distBottom);
+      }
+      const wrapText = attrs.wrap.attrs?.wrapText || "bothSides";
+      {
+        attributes.wrapText = wrapText;
+      }
+      if (Object.keys(attributes).length) {
+        wrapElement.attributes = attributes;
+      }
+      if (attrs.wrap.attrs?.polygon) {
+        const polygonNode = objToPolygon(attrs.wrap.attrs.polygon);
+        if (polygonNode) {
+          if (attrs.wrap.attrs?.polygonEdited !== void 0) {
+            polygonNode.attributes = {
+              ...polygonNode.attributes || {},
+              edited: String(attrs.wrap.attrs.polygonEdited)
+            };
+          }
+          wrapElement.elements = [polygonNode];
+        }
+      }
+      break;
+    }
+    case "None":
+      inlineAttrs.behindDoc = attrs.wrap.attrs?.behindDoc ? "1" : "0";
+      break;
+  }
   const effectIndex = nodeElements.elements.findIndex((el) => el.name === "wp:effectExtent");
   const elementsWithWrap = [
     ...nodeElements.elements.slice(0, effectIndex + 1),
-    ...wrapElements,
+    wrapElement,
     ...nodeElements.elements.slice(effectIndex + 1)
   ];
   return {
@@ -28960,32 +29162,32 @@ function translateAnchorNode(params2) {
     elements: [...anchorElements, ...elementsWithWrap]
   };
 }
-const XML_NODE_NAME$a = "wp:anchor";
+const XML_NODE_NAME$c = "wp:anchor";
 const SD_NODE_NAME$a = ["image"];
-const validXmlAttributes$7 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
-function encode$g(params2) {
+const validXmlAttributes$9 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
+function encode$i(params2) {
   const { node } = params2.extraParams;
   if (!node || !node.type) {
     return null;
   }
   return handleAnchorNode(params2);
 }
-function decode$i(params2) {
+function decode$k(params2) {
   const { node } = params2;
   if (!node || !node.type) {
     return null;
   }
   return translateAnchorNode(params2);
 }
-const config$9 = {
-  xmlName: XML_NODE_NAME$a,
+const config$b = {
+  xmlName: XML_NODE_NAME$c,
   sdNodeOrKeyName: SD_NODE_NAME$a,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$g,
-  decode: decode$i,
-  attributes: validXmlAttributes$7
+  encode: encode$i,
+  decode: decode$k,
+  attributes: validXmlAttributes$9
 };
-const translator$9 = NodeTranslator.from(config$9);
+const translator$b = NodeTranslator.from(config$b);
 function handleInlineNode(params2) {
   const { node } = params2.extraParams;
   if (node.name !== "wp:inline") {
@@ -29001,41 +29203,41 @@ function translateInlineNode(params2) {
     elements: nodeElements.elements
   };
 }
-const XML_NODE_NAME$9 = "wp:inline";
+const XML_NODE_NAME$b = "wp:inline";
 const SD_NODE_NAME$9 = ["image"];
-const validXmlAttributes$6 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
-function encode$f(params2) {
+const validXmlAttributes$8 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
+function encode$h(params2) {
   const { node } = params2.extraParams;
   if (!node || !node.type) {
     return null;
   }
   return handleInlineNode(params2);
 }
-function decode$h(params2) {
+function decode$j(params2) {
   const { node } = params2;
   if (!node || !node.type) {
     return null;
   }
   return translateInlineNode(params2);
 }
-const config$8 = {
-  xmlName: XML_NODE_NAME$9,
+const config$a = {
+  xmlName: XML_NODE_NAME$b,
   sdNodeOrKeyName: SD_NODE_NAME$9,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$f,
-  decode: decode$h,
-  attributes: validXmlAttributes$6
+  encode: encode$h,
+  decode: decode$j,
+  attributes: validXmlAttributes$8
 };
-const translator$8 = NodeTranslator.from(config$8);
-const XML_NODE_NAME$8 = "w:drawing";
+const translator$a = NodeTranslator.from(config$a);
+const XML_NODE_NAME$a = "w:drawing";
 const SD_NODE_NAME$8 = [];
-const validXmlAttributes$5 = [];
-function encode$e(params2) {
+const validXmlAttributes$7 = [];
+function encode$g(params2) {
   const nodes = params2.nodes;
   const node = nodes[0];
   const translatorByChildName = {
-    "wp:anchor": translator$9,
-    "wp:inline": translator$8
+    "wp:anchor": translator$b,
+    "wp:inline": translator$a
   };
   return node.elements.reduce((acc, child) => {
     if (acc) return acc;
@@ -29044,12 +29246,12 @@ function encode$e(params2) {
     return translator2.encode({ ...params2, extraParams: { node: child } }) || acc;
   }, null);
 }
-function decode$g(params2) {
+function decode$i(params2) {
   const { node } = params2;
   if (!node || !node.type) {
     return null;
   }
-  const childTranslator = node.attrs.isAnchor ? translator$9 : translator$8;
+  const childTranslator = node.attrs.isAnchor ? translator$b : translator$a;
   const resultNode = childTranslator.decode(params2);
   return wrapTextInRun(
     {
@@ -29059,15 +29261,15 @@ function decode$g(params2) {
     []
   );
 }
-const config$7 = {
-  xmlName: XML_NODE_NAME$8,
+const config$9 = {
+  xmlName: XML_NODE_NAME$a,
   sdNodeOrKeyName: SD_NODE_NAME$8,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$e,
-  decode: decode$g,
-  attributes: validXmlAttributes$5
+  encode: encode$g,
+  decode: decode$i,
+  attributes: validXmlAttributes$7
 };
-const translator$7 = NodeTranslator.from(config$7);
+const translator$9 = NodeTranslator.from(config$9);
 class CommandService {
   /**
    * @param {import('./commands/types/index.js').CommandServiceOptions} props
@@ -30415,7 +30617,7 @@ function prepareTextAnnotation(params2) {
   return getTextNodeForExport(attrs.displayLabel, [...marks, ...marksFromAttrs], params2);
 }
 function prepareImageAnnotation(params2, imageSize) {
-  return translator$7.decode({
+  return translator$9.decode({
     ...params2,
     imageSize
   });
@@ -30730,10 +30932,10 @@ function generateSdtPrTagForStructuredContent({ node }) {
   };
   return result;
 }
-const XML_NODE_NAME$7 = "w:sdt";
+const XML_NODE_NAME$9 = "w:sdt";
 const SD_NODE_NAME$7 = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
-const validXmlAttributes$4 = [];
-function encode$d(params2) {
+const validXmlAttributes$6 = [];
+function encode$f(params2) {
   const nodes = params2.nodes;
   const node = nodes[0];
   const { type: sdtType, handler: handler2 } = sdtNodeTypeStrategy(node);
@@ -30743,7 +30945,7 @@ function encode$d(params2) {
   const result = handler2(params2);
   return result;
 }
-function decode$f(params2) {
+function decode$h(params2) {
   const { node } = params2;
   if (!node || !node.type) {
     return null;
@@ -30761,85 +30963,85 @@ function decode$f(params2) {
   const result = decoder();
   return result;
 }
-const config$6 = {
-  xmlName: XML_NODE_NAME$7,
+const config$8 = {
+  xmlName: XML_NODE_NAME$9,
   sdNodeOrKeyName: SD_NODE_NAME$7,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$d,
-  decode: decode$f,
-  attributes: validXmlAttributes$4
+  encode: encode$f,
+  decode: decode$h,
+  attributes: validXmlAttributes$6
 };
-const translator$6 = NodeTranslator.from(config$6);
-const encode$c = (attributes) => {
+const translator$8 = NodeTranslator.from(config$8);
+const encode$e = (attributes) => {
   return attributes["w:id"];
 };
-const decode$e = (attrs) => {
+const decode$g = (attrs) => {
   return attrs.id;
 };
 const attrConfig$7 = Object.freeze({
   xmlName: "w:id",
   sdName: "id",
-  encode: encode$c,
-  decode: decode$e
+  encode: encode$e,
+  decode: decode$g
 });
-const encode$b = (attributes) => {
+const encode$d = (attributes) => {
   return attributes["w:name"];
 };
-const decode$d = (attrs) => {
+const decode$f = (attrs) => {
   return attrs.name;
 };
 const attrConfig$6 = Object.freeze({
   xmlName: "w:name",
   sdName: "name",
-  encode: encode$b,
-  decode: decode$d
+  encode: encode$d,
+  decode: decode$f
 });
-const encode$a = (attributes) => {
+const encode$c = (attributes) => {
   return attributes["w:colFirst"];
 };
-const decode$c = (attrs) => {
+const decode$e = (attrs) => {
   return attrs.colFirst;
 };
 const attrConfig$5 = Object.freeze({
   xmlName: "w:colFirst",
   sdName: "colFirst",
-  encode: encode$a,
-  decode: decode$c
+  encode: encode$c,
+  decode: decode$e
 });
-const encode$9 = (attributes) => {
+const encode$b = (attributes) => {
   return attributes["w:colLast"];
 };
-const decode$b = (attrs) => {
+const decode$d = (attrs) => {
   return attrs.colLast;
 };
 const attrConfig$4 = Object.freeze({
   xmlName: "w:colLast",
   sdName: "colLast",
-  encode: encode$9,
-  decode: decode$b
+  encode: encode$b,
+  decode: decode$d
 });
-const encode$8 = (attributes) => {
+const encode$a = (attributes) => {
   return attributes["w:displacedByCustomXml"];
 };
-const decode$a = (attrs) => {
+const decode$c = (attrs) => {
   return attrs.displacedByCustomXml;
 };
 const attrConfig$3 = Object.freeze({
   xmlName: "w:displacedByCustomXml",
   sdName: "displacedByCustomXml",
-  encode: encode$8,
-  decode: decode$a
+  encode: encode$a,
+  decode: decode$c
 });
-const validXmlAttributes$3 = [attrConfig$7, attrConfig$6, attrConfig$5, attrConfig$4, attrConfig$3];
-const XML_NODE_NAME$6 = "w:bookmarkStart";
+const validXmlAttributes$5 = [attrConfig$7, attrConfig$6, attrConfig$5, attrConfig$4, attrConfig$3];
+const XML_NODE_NAME$8 = "w:bookmarkStart";
 const SD_NODE_NAME$6 = "bookmarkStart";
-const encode$7 = (params2, encodedAttrs = {}) => {
+const encode$9 = (params2, encodedAttrs = {}) => {
   return {
     type: "bookmarkStart",
     attrs: encodedAttrs
   };
 };
-const decode$9 = (params2, decodedAttrs = {}) => {
+const decode$b = (params2, decodedAttrs = {}) => {
   const result = {
     name: "w:bookmarkStart",
     elements: []
@@ -30849,49 +31051,49 @@ const decode$9 = (params2, decodedAttrs = {}) => {
   }
   return result;
 };
-const config$5 = {
-  xmlName: XML_NODE_NAME$6,
+const config$7 = {
+  xmlName: XML_NODE_NAME$8,
   sdNodeOrKeyName: SD_NODE_NAME$6,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$7,
-  decode: decode$9,
-  attributes: validXmlAttributes$3
+  encode: encode$9,
+  decode: decode$b,
+  attributes: validXmlAttributes$5
 };
-const translator$5 = NodeTranslator.from(config$5);
-const encode$6 = (attributes) => {
+const translator$7 = NodeTranslator.from(config$7);
+const encode$8 = (attributes) => {
   return attributes["w:id"];
 };
-const decode$8 = (attrs) => {
+const decode$a = (attrs) => {
   return attrs.id;
 };
 const attrConfig$2 = Object.freeze({
   xmlName: "w:id",
   sdName: "id",
-  encode: encode$6,
-  decode: decode$8
+  encode: encode$8,
+  decode: decode$a
 });
-const encode$5 = (attributes) => {
+const encode$7 = (attributes) => {
   return attributes["w:displacedByCustomXml"];
 };
-const decode$7 = (attrs) => {
+const decode$9 = (attrs) => {
   return attrs.displacedByCustomXml;
 };
 const attrConfig$1 = Object.freeze({
   xmlName: "w:displacedByCustomXml",
   sdName: "displacedByCustomXml",
-  encode: encode$5,
-  decode: decode$7
+  encode: encode$7,
+  decode: decode$9
 });
-const validXmlAttributes$2 = [attrConfig$2, attrConfig$1];
-const XML_NODE_NAME$5 = "w:bookmarkEnd";
+const validXmlAttributes$4 = [attrConfig$2, attrConfig$1];
+const XML_NODE_NAME$7 = "w:bookmarkEnd";
 const SD_NODE_NAME$5 = "bookmarkEnd";
-const encode$4 = (params2, encodedAttrs = {}) => {
+const encode$6 = (params2, encodedAttrs = {}) => {
   return {
     type: "bookmarkEnd",
     attrs: encodedAttrs
   };
 };
-const decode$6 = (params2, decodedAttrs = {}) => {
+const decode$8 = (params2, decodedAttrs = {}) => {
   const result = {
     name: "w:bookmarkEnd",
     elements: []
@@ -30901,27 +31103,27 @@ const decode$6 = (params2, decodedAttrs = {}) => {
   }
   return result;
 };
-const config$4 = {
-  xmlName: XML_NODE_NAME$5,
+const config$6 = {
+  xmlName: XML_NODE_NAME$7,
   sdNodeOrKeyName: SD_NODE_NAME$5,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$4,
-  decode: decode$6,
-  attributes: validXmlAttributes$2
+  encode: encode$6,
+  decode: decode$8,
+  attributes: validXmlAttributes$4
 };
-const translator$4 = NodeTranslator.from(config$4);
-const decode$5 = (attrs) => attrs?.["w:id"];
+const translator$6 = NodeTranslator.from(config$6);
+const decode$7 = (attrs) => attrs?.["w:id"];
 const attrConfig = Object.freeze({
   xmlName: "w:id",
   sdName: "w:id",
   // We do not translate it from 'w:id' to 'id' when encoding, so the name is the same
   encode: () => {
   },
-  decode: decode$5
+  decode: decode$7
 });
-const XML_NODE_NAME$4 = "w:commentRange";
+const XML_NODE_NAME$6 = "w:commentRange";
 const SD_NODE_NAME$4 = "commentRange";
-const decode$4 = (params2) => {
+const decode$6 = (params2) => {
   const { node, comments, commentsExportType, exportedCommentDefs } = params2;
   if (!node) return;
   if (!comments) return;
@@ -30964,19 +31166,19 @@ const getCommentSchema = (type2, commentIndex) => {
   };
 };
 const getConfig = (type2) => ({
-  xmlName: `${XML_NODE_NAME$4}${type2}`,
+  xmlName: `${XML_NODE_NAME$6}${type2}`,
   sdNodeOrKeyName: `${SD_NODE_NAME$4}${type2}`,
   type: NodeTranslator.translatorTypes.NODE,
   encode: () => {
   },
-  decode: decode$4,
+  decode: decode$6,
   attributes: [attrConfig]
 });
 const commentRangeStartTranslator = NodeTranslator.from(getConfig("Start"));
 const commentRangeEndTranslator = NodeTranslator.from(getConfig("End"));
-const XML_NODE_NAME$3 = "sd:pageReference";
+const XML_NODE_NAME$5 = "sd:pageReference";
 const SD_NODE_NAME$3 = "pageReference";
-const encode$3 = (params2) => {
+const encode$5 = (params2) => {
   const { nodes = [], nodeListHandler } = params2 || {};
   const node = nodes[0];
   const processedText = nodeListHandler.handler({
@@ -30993,7 +31195,7 @@ const encode$3 = (params2) => {
   };
   return processedNode;
 };
-const decode$3 = (params2) => {
+const decode$5 = (params2) => {
   const { node } = params2;
   const outputMarks = processOutputMarks(node.attrs?.marksAsAttrs || []);
   const contentNodes = (node.content ?? []).flatMap((n) => exportSchemaToJson({ ...params2, node: n }));
@@ -31066,17 +31268,17 @@ const decode$3 = (params2) => {
   ];
   return translated;
 };
-const config$3 = {
-  xmlName: XML_NODE_NAME$3,
+const config$5 = {
+  xmlName: XML_NODE_NAME$5,
   sdNodeOrKeyName: SD_NODE_NAME$3,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$3,
-  decode: decode$3
+  encode: encode$5,
+  decode: decode$5
 };
-const translator$3 = NodeTranslator.from(config$3);
-const XML_NODE_NAME$2 = "sd:tableOfContents";
+const translator$5 = NodeTranslator.from(config$5);
+const XML_NODE_NAME$4 = "sd:tableOfContents";
 const SD_NODE_NAME$2 = "tableOfContents";
-const encode$2 = (params2) => {
+const encode$4 = (params2) => {
   const { nodes = [], nodeListHandler } = params2 || {};
   const node = nodes[0];
   const processedContent = nodeListHandler.handler({
@@ -31092,7 +31294,7 @@ const encode$2 = (params2) => {
   };
   return processedNode;
 };
-const decode$2 = (params2) => {
+const decode$4 = (params2) => {
   const { node } = params2;
   const contentNodes = node.content.map((n) => exportSchemaToJson({ ...params2, node: n }));
   const tocBeginElements = [
@@ -31139,14 +31341,14 @@ const decode$2 = (params2) => {
   }
   return contentNodes;
 };
-const config$2 = {
-  xmlName: XML_NODE_NAME$2,
+const config$4 = {
+  xmlName: XML_NODE_NAME$4,
   sdNodeOrKeyName: SD_NODE_NAME$2,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$2,
-  decode: decode$2
+  encode: encode$4,
+  decode: decode$4
 };
-const translator$2 = NodeTranslator.from(config$2);
+const translator$4 = NodeTranslator.from(config$4);
 function parseInlineStyles(styleString) {
   if (!styleString) return {};
   return styleString.split(";").filter((style2) => !!style2.trim()).reduce((acc, style2) => {
@@ -31280,7 +31482,7 @@ const handleDrawingNode = (params2) => {
   if (mainNode.name === "w:drawing") node = mainNode;
   else node = mainNode.elements.find((el) => el.name === "w:drawing");
   if (!node) return { nodes: [], consumed: 0 };
-  const schemaNode = translator$7.encode(params2);
+  const schemaNode = translator$9.encode(params2);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -31288,6 +31490,203 @@ const drawingNodeHandlerEntity = {
   handlerName: "drawingNodeHandler",
   handler: handleDrawingNode
 };
+const createTrackStyleMark = (marks) => {
+  const trackStyleMark = marks.find((mark) => mark.type === "trackFormat");
+  if (trackStyleMark) {
+    return {
+      type: "element",
+      name: "w:rPrChange",
+      attributes: {
+        "w:id": trackStyleMark.attrs.id,
+        "w:author": trackStyleMark.attrs.author,
+        "w:authorEmail": trackStyleMark.attrs.authorEmail,
+        "w:date": trackStyleMark.attrs.date
+      },
+      elements: trackStyleMark.attrs.before.map((mark) => processOutputMarks([mark])).filter((r2) => r2 !== void 0)
+    };
+  }
+  return void 0;
+};
+const XML_NODE_NAME$3 = "w:del";
+const SD_ATTR_KEY$1 = "trackDelete";
+const validXmlAttributes$3 = [
+  createAttributeHandler("w:id", "id"),
+  createAttributeHandler("w:date", "date"),
+  createAttributeHandler("w:author", "author"),
+  createAttributeHandler("w:authorEmail", "authorEmail")
+];
+const encode$3 = (params2, encodedAttrs = {}) => {
+  const { nodeListHandler, extraParams = {} } = params2;
+  const { node } = extraParams;
+  const subs = nodeListHandler.handler({
+    ...params2,
+    insideTrackChange: true,
+    nodes: node.elements,
+    path: [...params2.path || [], node]
+  });
+  encodedAttrs.importedAuthor = `${encodedAttrs.author} (imported)`;
+  subs.forEach((subElement) => {
+    if (subElement.marks === void 0) subElement.marks = [];
+    subElement.marks.push({ type: "trackDelete", attrs: encodedAttrs });
+  });
+  return subs;
+};
+function decode$3(params2) {
+  const { node } = params2;
+  if (!node || !node.type) {
+    return null;
+  }
+  const trackingMarks = ["trackInsert", "trackFormat", "trackDelete"];
+  const marks = node.marks;
+  const trackedMark = marks.find((m2) => m2.type === "trackDelete");
+  const trackStyleMark = createTrackStyleMark(marks);
+  node.marks = marks.filter((m2) => !trackingMarks.includes(m2.type));
+  if (trackStyleMark) {
+    node.marks.push(trackStyleMark);
+  }
+  const translatedTextNode = exportSchemaToJson({ ...params2, node });
+  const textNode = translatedTextNode.elements.find((n) => n.name === "w:t");
+  textNode.name = "w:delText";
+  return {
+    name: "w:del",
+    attributes: {
+      "w:id": trackedMark.attrs.id,
+      "w:author": trackedMark.attrs.author,
+      "w:authorEmail": trackedMark.attrs.authorEmail,
+      "w:date": trackedMark.attrs.date
+    },
+    elements: [translatedTextNode]
+  };
+}
+const config$3 = {
+  xmlName: XML_NODE_NAME$3,
+  sdNodeOrKeyName: SD_ATTR_KEY$1,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$3,
+  decode: decode$3,
+  attributes: validXmlAttributes$3
+};
+const translator$3 = NodeTranslator.from(config$3);
+const XML_NODE_NAME$2 = "w:ins";
+const SD_ATTR_KEY = "trackInsert";
+const validXmlAttributes$2 = [
+  createAttributeHandler("w:id", "id"),
+  createAttributeHandler("w:date", "date"),
+  createAttributeHandler("w:author", "author"),
+  createAttributeHandler("w:authorEmail", "authorEmail")
+];
+const encode$2 = (params2, encodedAttrs = {}) => {
+  const { nodeListHandler, extraParams = {} } = params2;
+  const { node } = extraParams;
+  const subs = nodeListHandler.handler({
+    ...params2,
+    insideTrackChange: true,
+    nodes: node.elements,
+    path: [...params2.path || [], node]
+  });
+  encodedAttrs.importedAuthor = `${encodedAttrs.author} (imported)`;
+  subs.forEach((subElement) => {
+    if (subElement.marks === void 0) subElement.marks = [];
+    subElement.marks.push({ type: "trackInsert", attrs: encodedAttrs });
+  });
+  return subs;
+};
+function decode$2(params2) {
+  const { node } = params2;
+  if (!node || !node.type) {
+    return null;
+  }
+  const trackingMarks = ["trackInsert", "trackFormat", "trackDelete"];
+  const marks = node.marks;
+  const trackedMark = marks.find((m2) => m2.type === "trackInsert");
+  const trackStyleMark = createTrackStyleMark(marks);
+  node.marks = marks.filter((m2) => !trackingMarks.includes(m2.type));
+  if (trackStyleMark) {
+    node.marks.push(trackStyleMark);
+  }
+  const translatedTextNode = exportSchemaToJson({ ...params2, node });
+  return {
+    name: "w:ins",
+    attributes: {
+      "w:id": trackedMark.attrs.id,
+      "w:author": trackedMark.attrs.author,
+      "w:authorEmail": trackedMark.attrs.authorEmail,
+      "w:date": trackedMark.attrs.date
+    },
+    elements: [translatedTextNode]
+  };
+}
+const config$2 = {
+  xmlName: XML_NODE_NAME$2,
+  sdNodeOrKeyName: SD_ATTR_KEY,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$2,
+  decode: decode$2,
+  attributes: validXmlAttributes$2
+};
+const translator$2 = NodeTranslator.from(config$2);
+const isTrackChangeElement = (node) => node?.name === "w:del" || node?.name === "w:ins";
+const unwrapTrackChangeNode = (node) => {
+  if (!node) {
+    return null;
+  }
+  if (isTrackChangeElement(node)) {
+    return node;
+  }
+  if (node.name === "w:sdt") {
+    const content = node.elements?.find((element) => element.name === "w:sdtContent");
+    if (!content?.elements?.length) {
+      return null;
+    }
+    for (const child of content.elements) {
+      const trackChange = unwrapTrackChangeNode(child);
+      if (trackChange) {
+        return trackChange;
+      }
+    }
+  }
+  return null;
+};
+const handleTrackChangeNode = (params2) => {
+  const { nodes } = params2;
+  if (nodes.length === 0) {
+    return { nodes: [], consumed: 0 };
+  }
+  const mainNode = unwrapTrackChangeNode(nodes[0]);
+  if (!mainNode) {
+    return { nodes: [], consumed: 0 };
+  }
+  let result;
+  const translatorParams = {
+    ...params2,
+    nodes: [mainNode]
+  };
+  switch (mainNode.name) {
+    case "w:del":
+      result = translator$3.encode({
+        extraParams: {
+          node: mainNode
+        },
+        ...translatorParams
+      });
+      break;
+    case "w:ins":
+      result = translator$2.encode({
+        extraParams: {
+          node: mainNode
+        },
+        ...translatorParams
+      });
+      break;
+  }
+  return { nodes: result, consumed: 1 };
+};
+const trackChangeNodeHandlerEntity = {
+  handlerName: "trackChangeNodeHandler",
+  handler: handleTrackChangeNode
+};
+const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$Z);
+const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$Y);
 function parseProperties(node) {
   const marks = [];
   const unknownMarks = [];
@@ -31339,51 +31738,6 @@ function getElementName(element) {
 const isPropertiesElement = (element) => {
   return !!SuperConverter.propertyTypes[element.name || element.type];
 };
-const handleTrackChangeNode = (params2) => {
-  const { nodes, nodeListHandler } = params2;
-  if (nodes.length === 0 || !(nodes[0].name === "w:del" || nodes[0].name === "w:ins" || nodes[0].name === "w:sdt")) {
-    return { nodes: [], consumed: 0 };
-  }
-  const mainNode = nodes[0];
-  let node;
-  if (["w:ins", "w:del"].includes(mainNode.name)) {
-    node = mainNode;
-  } else {
-    const sdtContent = mainNode.elements.find((el) => el.name === "w:sdtContent");
-    const trackedChange = sdtContent?.elements.find((el) => ["w:ins", "w:del"].includes(el.name));
-    if (trackedChange) node = trackedChange;
-  }
-  if (!node) {
-    return { nodes: [], consumed: 0 };
-  }
-  const { name } = node;
-  const { attributes, elements } = parseProperties(node);
-  const subs = nodeListHandler.handler({
-    ...params2,
-    insideTrackChange: true,
-    nodes: elements,
-    path: [...params2.path || [], node]
-  });
-  const changeType = name === "w:del" ? TrackDeleteMarkName : TrackInsertMarkName;
-  const mappedAttributes = {
-    id: attributes["w:id"],
-    date: attributes["w:date"],
-    author: attributes["w:author"],
-    authorEmail: attributes["w:authorEmail"],
-    importedAuthor: `${attributes["w:author"]} (imported)`
-  };
-  subs.forEach((subElement) => {
-    if (subElement.marks === void 0) subElement.marks = [];
-    subElement.marks.push({ type: changeType, attrs: mappedAttributes });
-  });
-  return { nodes: subs, consumed: 1 };
-};
-const trackChangeNodeHandlerEntity = {
-  handlerName: "trackChangeNodeHandler",
-  handler: handleTrackChangeNode
-};
-const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$X);
-const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$W);
 const handleTextNode = (params2) => {
   const { nodes, insideTrackChange } = params2;
   if (nodes.length === 0 || !(nodes[0].name === "w:t" || insideTrackChange && nodes[0].name === "w:delText")) {
@@ -31424,7 +31778,7 @@ const handleParagraphNode = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$17.encode(params2);
+  const schemaNode = translator$19.encode(params2);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -31437,7 +31791,7 @@ const handleSdtNode = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:sdt") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$6.encode(params2);
+  const result = translator$8.encode(params2);
   if (!result) {
     return { nodes: [], consumed: 0 };
   }
@@ -31527,7 +31881,7 @@ const handler = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$1a.encode(params2);
+  const result = translator$1c.encode(params2);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -31599,7 +31953,7 @@ const handleBookmarkStartNode = (params2) => {
   if (isCustomMarkBookmark(nodes[0], params2.editor)) {
     return handleBookmarkNode(params2);
   }
-  const node = translator$5.encode(params2);
+  const node = translator$7.encode(params2);
   if (!node) return { nodes: [], consumed: 0 };
   return { nodes: [node], consumed: 1 };
 };
@@ -31631,7 +31985,7 @@ const handleBookmarkEndNode = (params2) => {
   if (!nodes.length || nodes[0].name !== "w:bookmarkEnd") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$4.encode(params2);
+  const node = translator$6.encode(params2);
   if (!node) return { nodes: [], consumed: 0 };
   return { nodes: [node], consumed: 1 };
 };
@@ -31764,7 +32118,7 @@ const autoTotalPageCountEntity = {
   handlerName: "autoTotalPageCountEntity",
   handler: handleAutoTotalPageNumber
 };
-const pageReferenceEntity = generateV2HandlerEntity("pageReferenceNodeHandler", translator$3);
+const pageReferenceEntity = generateV2HandlerEntity("pageReferenceNodeHandler", translator$5);
 const handlePictNode = (params2) => {
   const { nodes } = params2;
   if (!nodes.length || nodes[0].name !== "w:p") {
@@ -32153,14 +32507,14 @@ const handleTabNode = (params2) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$18.encode(params2);
+  const node = translator$1a.encode(params2);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
   handlerName: "w:tabTranslator",
   handler: handleTabNode
 };
-const tableOfContentsHandlerEntity = generateV2HandlerEntity("tableOfContentsHandler", translator$2);
+const tableOfContentsHandlerEntity = generateV2HandlerEntity("tableOfContentsHandler", translator$4);
 function preProcessPageInstruction(nodesToCombine) {
   const pageNumNode = {
     name: "sd:autoPageNumber",
@@ -33101,7 +33455,7 @@ function translateVRectContentBlock(params2) {
 const XML_NODE_NAME = "w:pict";
 const SD_NODE_NAME = ["shapeContainer", "contentBlock"];
 const validXmlAttributes = [];
-function encode$1d(params2) {
+function encode$1f(params2) {
   const { node, pNode } = params2.extraParams;
   const { type: pictType, handler: handler2 } = pictNodeTypeStrategy(node);
   if (!handler2 || pictType === "unknown") {
@@ -33133,7 +33487,7 @@ const config = {
   xmlName: XML_NODE_NAME,
   sdNodeOrKeyName: SD_NODE_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$1d,
+  encode: encode$1f,
   decode,
   attributes: validXmlAttributes
 };
@@ -33209,35 +33563,35 @@ function exportSchemaToJson(params2) {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$17,
-    run: translator$W,
+    paragraph: translator$19,
+    run: translator$Y,
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$1a,
-    table: translator$b,
-    tableRow: translator$I,
-    tableCell: translator$a,
-    bookmarkStart: translator$5,
-    bookmarkEnd: translator$4,
-    fieldAnnotation: translator$6,
-    tab: translator$18,
-    image: translator$7,
-    hardBreak: translator$1a,
+    lineBreak: translator$1c,
+    table: translator$d,
+    tableRow: translator$K,
+    tableCell: translator$c,
+    bookmarkStart: translator$7,
+    bookmarkEnd: translator$6,
+    fieldAnnotation: translator$8,
+    tab: translator$1a,
+    image: translator$9,
+    hardBreak: translator$1c,
     commentRangeStart: commentRangeStartTranslator,
     commentRangeEnd: commentRangeEndTranslator,
     commentReference: () => null,
     shapeContainer: translator,
     shapeTextbox: translator,
     contentBlock: translator,
-    structuredContent: translator$6,
-    structuredContentBlock: translator$6,
-    documentPartObject: translator$6,
-    documentSection: translator$6,
+    structuredContent: translator$8,
+    structuredContentBlock: translator$8,
+    documentPartObject: translator$8,
+    documentSection: translator$8,
     "page-number": translatePageNumberNode,
     "total-page-number": translateTotalPageNumberNode,
-    pageReference: translator$3,
-    tableOfContents: translator$2
+    pageReference: translator$5,
+    tableOfContents: translator$4
   };
   let handler2 = router[type2];
   if (handler2 && "decode" in handler2 && typeof handler2.decode === "function") {
@@ -33571,59 +33925,23 @@ function getTextNodeForExport(text, marks, params2) {
   return wrapTextInRun(textNodes, outputMarks);
 }
 function translateTextNode(params2) {
-  const { node } = params2;
+  const { node, extraParams } = params2;
   const trackedMarks = [TrackInsertMarkName, TrackDeleteMarkName];
-  const isTrackedNode = node.marks?.some((m2) => trackedMarks.includes(m2.type));
-  if (isTrackedNode) return translateTrackedNode(params2);
-  const { text, marks = [] } = node;
-  return getTextNodeForExport(text, marks, params2);
-}
-function createTrackStyleMark(marks) {
-  const trackStyleMark = marks.find((mark) => mark.type === TrackFormatMarkName);
-  if (trackStyleMark) {
-    const markElement = {
-      type: "element",
-      name: "w:rPrChange",
-      attributes: {
-        "w:id": trackStyleMark.attrs.id,
-        "w:author": trackStyleMark.attrs.author,
-        "w:authorEmail": trackStyleMark.attrs.authorEmail,
-        "w:date": trackStyleMark.attrs.date
-      },
-      elements: trackStyleMark.attrs.before.map((mark) => processOutputMarks([mark])).filter((r2) => r2 !== void 0)
-    };
-    return markElement;
-  }
-  return void 0;
-}
-function translateTrackedNode(params2) {
-  const { node } = params2;
-  const marks = node.marks;
-  const trackingMarks = [TrackInsertMarkName, TrackDeleteMarkName, TrackFormatMarkName];
-  const trackedMark = marks.find((m2) => trackingMarks.includes(m2.type));
-  const isInsert = trackedMark.type === TrackInsertMarkName;
-  const trackStyleMark = createTrackStyleMark(marks);
-  node.marks = marks.filter((m2) => !trackingMarks.includes(m2.type));
-  if (trackStyleMark) {
-    node.marks.push(trackStyleMark);
+  const trackedMark = node.marks?.find((m2) => trackedMarks.includes(m2.type));
+  if (trackedMark) {
+    switch (trackedMark.type) {
+      case "trackDelete":
+        return translator$3.decode(params2);
+      case "trackInsert":
+        return translator$2.decode(params2);
+    }
   }
-  const translatedTextNode = exportSchemaToJson({ ...params2, node });
-  if (!isInsert) {
-    const textNode = translatedTextNode.elements.find((n) => n.name === "w:t");
-    textNode.name = "w:delText";
+  const isLinkNode = node.marks?.some((m2) => m2.type === "link");
+  if (isLinkNode && !extraParams?.linkProcessed) {
+    return translator$Z.decode(params2);
   }
-  const trackedNode = {
-    name: isInsert ? "w:ins" : "w:del",
-    type: "element",
-    attributes: {
-      "w:id": trackedMark.attrs.id,
-      "w:author": trackedMark.attrs.author,
-      "w:authorEmail": trackedMark.attrs.authorEmail,
-      "w:date": trackedMark.attrs.date
-    },
-    elements: [translatedTextNode]
-  };
-  return trackedNode;
+  const { text, marks = [] } = node;
+  return getTextNodeForExport(text, marks, params2);
 }
 function wrapTextInRun(nodeOrNodes, marks) {
   let elements = [];
@@ -33880,7 +34198,7 @@ function translateMark(mark) {
       markElement.type = "element";
       break;
     case "underline": {
-      const translated = translator$14.decode({
+      const translated = translator$16.decode({
         node: {
           attrs: {
             underlineType: attrs.underlineType ?? attrs.underline ?? null,
@@ -33944,9 +34262,11 @@ function translateMark(mark) {
       break;
     case "highlight": {
       const highlightValue = attrs.color ?? attrs.highlight ?? null;
-      const translated = translator$19.decode({ node: { attrs: { highlight: highlightValue } } });
+      const translated = translator$1b.decode({ node: { attrs: { highlight: highlightValue } } });
       return translated || {};
     }
+    case "link":
+      return {};
   }
   return markElement;
 }
@@ -63885,6 +64205,58 @@ const registerImages = async (foundImages, editor, view) => {
     }
   });
 };
+const normalizeWrap = (attrs = {}) => {
+  const wrap2 = attrs.wrap;
+  if (wrap2?.type && wrap2.type !== "Inline") {
+    return {
+      type: wrap2.type,
+      attrs: wrap2.attrs ?? {}
+    };
+  }
+  if (wrap2?.type === "Inline" && Object.keys(wrap2.attrs ?? {}).length) {
+    return {
+      type: "Inline",
+      attrs: wrap2.attrs
+    };
+  }
+  if (!wrap2 && attrs.wrapText) {
+    return {
+      type: "Square",
+      attrs: {
+        wrapText: attrs.wrapText
+      }
+    };
+  }
+  if (!wrap2 && attrs.wrapTopAndBottom) {
+    return {
+      type: "TopAndBottom",
+      attrs: {}
+    };
+  }
+  if (wrap2?.type === "Inline") {
+    return {
+      type: "Inline",
+      attrs: wrap2.attrs ?? {}
+    };
+  }
+  return {
+    type: "Inline",
+    attrs: {}
+  };
+};
+const normalizeMarginOffset = (marginOffset = {}) => {
+  const { left: left2, horizontal, ...rest } = marginOffset;
+  return {
+    ...rest,
+    horizontal: horizontal ?? left2
+  };
+};
+const getNormalizedImageAttrs = (attrs = {}) => {
+  return {
+    wrap: normalizeWrap(attrs),
+    marginOffset: normalizeMarginOffset(attrs.marginOffset ?? {})
+  };
+};
 const ImagePositionPluginKey = new PluginKey("ImagePosition");
 const ImagePositionPlugin = ({ editor }) => {
   const { view } = editor;
@@ -63932,7 +64304,8 @@ const getImagePositionDecorations = (state2, view) => {
       let style2 = "";
       let className = "";
       const { vRelativeFrom, alignH } = node.attrs.anchorData;
-      const { size: size2, padding, marginOffset } = node.attrs;
+      const { size: size2, padding } = node.attrs;
+      const { marginOffset } = getNormalizedImageAttrs(node.attrs);
       const pageBreak = findPreviousDomNodeWithClass(view, pos, "pagination-break-wrapper");
       if (pageBreak) {
         switch (alignH) {
@@ -64049,7 +64422,24 @@ const Image = Node$1.create({
         rendered: false
       },
       originalAttributes: { rendered: false },
-      wrapTopAndBottom: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {Object} wrap - Wrapping options
+       * @param {string} wrap.type - Wrap type: "None", "Square", "Through", "Tight", "TopAndBottom", "Inline"
+       * @param {Object} [wrap.attrs] - Wrap attributes (only allowed attributes for the given type will be accepted)
+       * @param {string} [wrap.attrs.wrapText] - Text wrapping mode for Square type: "bothSides", "largest", "left", "right"
+       * @param {number} [wrap.attrs.distTop] - Top distance in pixels
+       * @param {number} [wrap.attrs.distBottom] - Bottom distance in pixels
+       * @param {number} [wrap.attrs.distLeft] - Left distance in pixels
+       * @param {number} [wrap.attrs.distRight] - Right distance in pixels
+       * @param {Array} [wrap.attrs.polygon] - Polygon points for Through/Tight types: [[x1,y1], [x2,y2], ...]
+       * @param {boolean} [wrap.attrs.behindDoc] - Whether image should be behind document text (for wrapNone)
+       */
+      wrap: {
+        default: { type: "Inline" },
+        rendered: false
+        // Handled in main renderDOM
+      },
       anchorData: {
         default: null,
         rendered: false
@@ -64095,7 +64485,6 @@ const Image = Node$1.create({
        * @private
        */
       simplePos: { rendered: false },
-      wrapText: { rendered: false },
       extension: { rendered: false },
       size: {
         default: {},
@@ -64111,55 +64500,13 @@ const Image = Node$1.create({
       },
       padding: {
         default: {},
-        renderDOM: ({ size: size2 = {}, padding, marginOffset, transformData = {} }) => {
-          let { left: left2 = 0, top: top2 = 0, bottom: bottom2 = 0, right: right2 = 0 } = padding ?? {};
-          const { rotation } = transformData;
-          const { height, width } = size2;
-          if (rotation && height && width) {
-            const { horizontal, vertical } = getRotationMargins(width, height, rotation);
-            left2 += horizontal;
-            right2 += horizontal;
-            top2 += vertical;
-            bottom2 += vertical;
-          }
-          let style2 = "";
-          if (left2 && marginOffset?.left == null) style2 += `margin-left: ${left2}px;`;
-          if (top2 && marginOffset?.top == null) style2 += `margin-top: ${top2}px;`;
-          if (bottom2) style2 += `margin-bottom: ${bottom2}px;`;
-          if (right2) style2 += `margin-right: ${right2}px;`;
-          return { style: style2 };
-        }
+        rendered: false
+        // Handled in main renderDOM
       },
       marginOffset: {
         default: {},
-        renderDOM: ({ marginOffset, anchorData, transformData, size: size2 }) => {
-          const hasAnchorData = Boolean(anchorData);
-          const hasMarginOffsets = marginOffset?.left != null || marginOffset?.top != null;
-          if (!hasAnchorData && !hasMarginOffsets) return {};
-          const relativeFromPageV = anchorData?.vRelativeFrom === "page";
-          const maxMarginV = 500;
-          const baseLeft = marginOffset?.left ?? 0;
-          const baseTop = marginOffset?.top ?? 0;
-          let rotationLeft = 0;
-          let rotationTop = 0;
-          const { rotation } = transformData ?? {};
-          const { height, width } = size2 ?? {};
-          if (rotation && height && width) {
-            const { horizontal, vertical } = getRotationMargins(width, height, rotation);
-            rotationLeft = horizontal;
-            rotationTop = vertical;
-          }
-          const left2 = baseLeft + rotationLeft;
-          const top2 = baseTop + rotationTop;
-          let style2 = "";
-          if (left2) style2 += `margin-left: ${left2}px;`;
-          if (top2) {
-            if (relativeFromPageV && top2 >= maxMarginV) style2 += `margin-top: ${maxMarginV}px;`;
-            else style2 += `margin-top: ${top2}px;`;
-          }
-          if (!style2) return {};
-          return { style: style2 };
-        }
+        rendered: false
+        // Handled in main renderDOM
       },
       style: {
         default: null,
@@ -64178,8 +64525,181 @@ const Image = Node$1.create({
       }
     ];
   },
-  renderDOM({ htmlAttributes }) {
-    return ["img", Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes)];
+  renderDOM({ node, htmlAttributes }) {
+    const { wrap: wrap2, marginOffset } = getNormalizedImageAttrs(node.attrs);
+    const { anchorData, padding, transformData = {}, size: size2 = { width: 0, height: 0 } } = node.attrs;
+    const margin = {
+      left: 0,
+      right: 0,
+      top: 0,
+      bottom: 0
+    };
+    let centered = false;
+    let floatRight = false;
+    let baseHorizontal = marginOffset?.horizontal || 0;
+    let style2 = "";
+    if (padding) {
+      if (padding.left) margin.left += padding.left;
+      if (padding.right) margin.right += padding.right;
+      if (padding.top) margin.top += padding.top;
+      if (padding.bottom) margin.bottom += padding.bottom;
+    }
+    const { rotation } = transformData;
+    const { height, width } = size2;
+    if (rotation && height && width) {
+      const { horizontal, vertical } = getRotationMargins(width, height, rotation);
+      margin.left += horizontal;
+      margin.right += horizontal;
+      margin.top += vertical;
+      margin.bottom += vertical;
+    }
+    if (wrap2 && wrap2.type) {
+      const { type: type2, attrs = {} } = wrap2;
+      switch (type2) {
+        case "None":
+          style2 += "position: absolute;";
+          if (attrs.behindDoc) {
+            style2 += "z-index: -1;";
+          } else {
+            style2 += "z-index: 1;";
+          }
+          break;
+        case "Square":
+          style2 += "shape-outside: border-box; clear: both;";
+          if (attrs.wrapText === "right") {
+            style2 += "float: left;";
+          } else if (attrs.wrapText === "left") {
+            style2 += "float: right;";
+            floatRight = true;
+          } else if (["largest", "bothSides"].includes(attrs.wrapText)) {
+            const pageStyles2 = this.editor?.converter?.pageStyles;
+            if (pageStyles2?.pageSize && pageStyles2?.pageMargins && size2.width) {
+              const pageWidth = inchesToPixels(pageStyles2.pageSize.width);
+              const leftMargin = inchesToPixels(pageStyles2.pageMargins.left);
+              const rightMargin = inchesToPixels(pageStyles2.pageMargins.right);
+              const contentWidth = pageWidth - leftMargin - rightMargin;
+              const imageWidth = size2.width + (attrs.distLeft || 0) + (attrs.distRight || 0);
+              const leftSpace = marginOffset.horizontal;
+              const rightSpace = contentWidth - leftSpace - imageWidth;
+              if (rightSpace < 0) {
+                style2 += "float: left;";
+              } else if (rightSpace > leftSpace) {
+                style2 += "float: left;";
+              } else {
+                style2 += "float: right;";
+                floatRight = true;
+                baseHorizontal = rightSpace;
+              }
+            } else {
+              style2 += "float: left;";
+            }
+          }
+          if (attrs.distTop) margin.top += attrs.distTop;
+          if (attrs.distBottom) margin.bottom += attrs.distBottom;
+          if (attrs.distLeft) margin.left += attrs.distLeft;
+          if (attrs.distRight) margin.right += attrs.distRight;
+          break;
+        case "Through":
+        case "Tight":
+          style2 += "clear: both;";
+          const pageStyles = this.editor?.converter?.pageStyles;
+          if (pageStyles?.pageSize && pageStyles?.pageMargins && size2.width) {
+            const pageWidth = inchesToPixels(pageStyles.pageSize.width);
+            const leftMargin = inchesToPixels(pageStyles.pageMargins.left);
+            const rightMargin = inchesToPixels(pageStyles.pageMargins.right);
+            const contentWidth = pageWidth - leftMargin - rightMargin;
+            const imageWidth = size2.width + (attrs.distLeft || 0) + (attrs.distRight || 0);
+            const leftSpace = marginOffset.horizontal;
+            const rightSpace = contentWidth - leftSpace - imageWidth;
+            if (rightSpace < 0) {
+              style2 += "float: left;";
+            } else if (rightSpace > leftSpace) {
+              style2 += "float: left;";
+            } else {
+              style2 += "float: right;";
+              floatRight = true;
+              baseHorizontal = rightSpace;
+            }
+          } else {
+            style2 += "float: left;";
+          }
+          if (attrs.distTop) margin.top += attrs.distTop;
+          if (attrs.distBottom) margin.bottom += attrs.distBottom;
+          if (attrs.distLeft) margin.left += attrs.distLeft;
+          if (attrs.distRight) margin.right += attrs.distRight;
+          if (attrs.polygon) {
+            let horizontalOffset = floatRight ? attrs.polygon[0][0] || 0 : marginOffset.horizontal + 15;
+            let maxX = 0;
+            let minX = 0;
+            let minY = 0;
+            let maxY = 0;
+            attrs.polygon.forEach(([x, y2]) => {
+              if (floatRight && x < horizontalOffset) horizontalOffset = x;
+              if (x > maxX) maxX = x;
+              if (x < minX) minX = x;
+              if (y2 > maxY) maxY = y2;
+              if (y2 < minY) minY = y2;
+            });
+            const originalWidth = maxX - minX;
+            const originalHeight = maxY - minY;
+            const scaleWidth = Math.min(1, size2.width / originalWidth);
+            const scaleHeight = Math.min(1, size2.height / originalHeight);
+            const verticalOffset = Math.max(0, marginOffset.top);
+            const points = attrs.polygon.map(([x, y2]) => `${horizontalOffset + x * scaleWidth}px ${verticalOffset + y2 * scaleHeight}px`).join(", ");
+            style2 += `shape-outside: polygon(${points});`;
+          }
+          break;
+        case "TopAndBottom":
+          style2 += "display: block; clear: both;";
+          if (attrs.distTop) margin.top += attrs.distTop;
+          if (attrs.distBottom) margin.bottom += attrs.distBottom;
+          centered = true;
+          break;
+      }
+    }
+    const hasAnchorData = Boolean(anchorData);
+    const hasMarginOffsets = marginOffset?.horizontal != null || marginOffset?.top != null;
+    if (hasAnchorData || hasMarginOffsets) {
+      const relativeFromPageV = anchorData?.vRelativeFrom === "page";
+      const maxMarginV = 500;
+      const baseTop = Math.max(0, marginOffset?.top ?? 0);
+      let rotationHorizontal = 0;
+      let rotationTop = 0;
+      const { rotation: rotation2 } = transformData ?? {};
+      const { height: height2, width: width2 } = size2 ?? {};
+      if (rotation2 && height2 && width2) {
+        const { horizontal: horizontal2, vertical } = getRotationMargins(width2, height2, rotation2);
+        rotationHorizontal = horizontal2;
+        rotationTop = vertical;
+      }
+      const horizontal = baseHorizontal + rotationHorizontal;
+      const top2 = baseTop + rotationTop;
+      if (horizontal) {
+        if (floatRight) {
+          margin.right += horizontal;
+        } else {
+          margin.left += horizontal;
+        }
+      }
+      if (top2) {
+        if (relativeFromPageV && top2 >= maxMarginV) margin.top += maxMarginV;
+        else margin.top += top2;
+      }
+    }
+    if (centered) {
+      style2 += "margin-left: auto; margin-right: auto;";
+    } else {
+      if (margin.left) style2 += `margin-left: ${margin.left}px;`;
+      if (margin.right) style2 += `margin-right: ${margin.right}px;`;
+    }
+    if (margin.top) style2 += `margin-top: ${margin.top}px;`;
+    if (margin.bottom) style2 += `margin-bottom: ${margin.bottom}px;`;
+    const finalAttributes = { ...htmlAttributes };
+    if (style2) {
+      const existingStyle = finalAttributes.style || "";
+      finalAttributes.style = existingStyle + (existingStyle ? " " : "") + style2;
+    }
+    return ["img", Attribute2.mergeAttributes(this.options.htmlAttributes, finalAttributes)];
   },
   addCommands() {
     return {
@@ -64201,6 +64721,85 @@ const Image = Node$1.create({
           type: this.name,
           attrs: options
         });
+      },
+      /**
+       * Set the wrapping mode and attributes for the selected image
+       * @category Command
+       * @param {Object} options - Wrapping options
+       * @param {string} options.type - Wrap type: "None", "Square", "Through", "Tight", "TopAndBottom", "Inline"
+       * @param {Object} [options.attrs] - Wrap attributes (only allowed attributes for the given type will be accepted)
+       * @param {string} [options.attrs.wrapText] - Text wrapping mode for Square type: "bothSides", "largest", "left", "right"
+       * @param {number} [options.attrs.distTop] - Top distance in pixels
+       * @param {number} [options.attrs.distBottom] - Bottom distance in pixels
+       * @param {number} [options.attrs.distLeft] - Left distance in pixels
+       * @param {number} [options.attrs.distRight] - Right distance in pixels
+       * @param {Array} [options.attrs.polygon] - Polygon points for Through/Tight types: [[x1,y1], [x2,y2], ...]
+       * @param {boolean} [options.attrs.behindDoc] - Whether image should be behind document text (for wrapNone)
+       * @example
+       * // No wrapping, behind document
+       * editor.commands.setWrapping({ type: 'None', attrs: {behindDoc: true} })
+       *
+       * // Square wrapping on both sides with distances
+       * editor.commands.setWrapping({
+       *   type: 'Square',
+       *   attrs: {
+       *     wrapText: 'bothSides',
+       *     distTop: 10,
+       *     distBottom: 10,
+       *     distLeft: 10,
+       *     distRight: 10
+       *   }
+       * })
+       *
+       * // Tight wrapping with polygon
+       * editor.commands.setWrapping({
+       *   type: 'Tight',
+       *   attrs: {
+       *     polygon: [[0, 0], [100, 0], [100, 100], [0, 100]]
+       *   }
+       * })
+       *
+       * // Top and bottom wrapping
+       * editor.commands.setWrapping({
+       *   type: 'TopAndBottom',
+       *   attrs: {
+       *     distTop: 15,
+       *     distBottom: 15
+       *   }
+       * })
+       */
+      setWrapping: (options) => ({ chain, state: state2 }) => {
+        const { selection } = state2;
+        const { $from } = selection;
+        const node = $from.nodeAfter;
+        if (!node || node.type.name !== this.name) {
+          return false;
+        }
+        const { type: type2, attrs = {} } = options;
+        const allowedAttrs = {};
+        const allowedAttributes = {
+          None: ["behindDoc"],
+          Square: ["wrapText", "distTop", "distBottom", "distLeft", "distRight"],
+          Through: ["distTop", "distBottom", "distLeft", "distRight", "polygon"],
+          Tight: ["distTop", "distBottom", "distLeft", "distRight", "polygon"],
+          TopAndBottom: ["distTop", "distBottom"],
+          Inline: []
+        };
+        const allowedForType = allowedAttributes[type2] || [];
+        Object.keys(attrs).forEach((key2) => {
+          if (allowedForType.includes(key2)) {
+            allowedAttrs[key2] = attrs[key2];
+          }
+        });
+        const updatedAttrs = {
+          ...node.attrs,
+          wrap: {
+            type: type2,
+            attrs: allowedAttrs
+          },
+          isAnchor: type2 !== "Inline"
+        };
+        return chain().updateAttributes(this.name, updatedAttrs).run();
       }
     };
   },
@@ -87549,72 +88148,72 @@ const _sfc_main = {
 const SuperInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4d5cff52"]]);
 const additionalHandlers = Object.freeze({
   "mc:AlternateContent": translator$1,
-  "sd:pageReference": translator$3,
-  "sd:tableOfContents": translator$2,
-  "w:b": translator$16,
-  "w:bidiVisual": translator$H,
-  "w:bookmarkEnd": translator$4,
-  "w:bookmarkStart": translator$5,
-  "w:bottom": translator$u,
-  "w:br": translator$1a,
-  "w:cantSplit": translator$V,
-  "w:cnfStyle": translator$U,
-  "w:color": translator$12,
-  "w:divId": translator$T,
-  "w:drawing": translator$7,
-  "w:end": translator$s,
-  "w:gridAfter": translator$S,
-  "w:gridBefore": translator$R,
-  "w:gridCol": translator$d,
-  "w:hidden": translator$Q,
-  "w:highlight": translator$19,
-  "w:hyperlink": translator$X,
-  "w:i": translator$15,
-  "w:insideH": translator$q,
-  "w:insideV": translator$p,
-  "w:jc": translator$P,
-  "w:left": translator$o,
-  "w:p": translator$17,
-  "w:r": translator$W,
-  "w:rFonts": translator$11,
-  "w:rPr": translator$Y,
-  "w:rStyle": translator$10,
-  "w:right": translator$m,
-  "w:sdt": translator$6,
-  "w:shd": translator$G,
-  "w:start": translator$k,
-  "w:strike": translator$13,
-  "w:sz": translator$$,
-  "w:szCs": translator$_,
-  "w:tab": translator$18,
-  "w:tbl": translator$b,
-  "w:tblBorders": translator$g,
-  "w:tblCaption": translator$F,
-  "w:tblCellMar": translator$f,
-  "w:tblCellSpacing": translator$O,
-  "w:tblDescription": translator$E,
-  "w:tblGrid": translator$c,
-  "w:tblHeader": translator$N,
-  "w:tblInd": translator$D,
-  "w:tblLayout": translator$C,
-  "w:tblLook": translator$B,
-  "w:tblOverlap": translator$A,
-  "w:tblPr": translator$e,
-  "w:tblStyle": translator$z,
-  "w:tblStyleColBandSize": translator$y,
-  "w:tblStyleRowBandSize": translator$x,
-  "w:tblW": translator$w,
-  "w:tblpPr": translator$v,
-  "w:tc": translator$a,
-  "w:top": translator$i,
-  "w:tr": translator$I,
-  "w:trHeight": translator$M,
-  "w:trPr": translator$J,
-  "w:u": translator$14,
-  "w:wAfter": translator$L,
-  "w:wBefore": translator$K,
-  "wp:anchor": translator$9,
-  "wp:inline": translator$8,
+  "sd:pageReference": translator$5,
+  "sd:tableOfContents": translator$4,
+  "w:b": translator$18,
+  "w:bidiVisual": translator$J,
+  "w:bookmarkEnd": translator$6,
+  "w:bookmarkStart": translator$7,
+  "w:bottom": translator$w,
+  "w:br": translator$1c,
+  "w:cantSplit": translator$X,
+  "w:cnfStyle": translator$W,
+  "w:color": translator$14,
+  "w:divId": translator$V,
+  "w:drawing": translator$9,
+  "w:end": translator$u,
+  "w:gridAfter": translator$U,
+  "w:gridBefore": translator$T,
+  "w:gridCol": translator$f,
+  "w:hidden": translator$S,
+  "w:highlight": translator$1b,
+  "w:hyperlink": translator$Z,
+  "w:i": translator$17,
+  "w:insideH": translator$s,
+  "w:insideV": translator$r,
+  "w:jc": translator$R,
+  "w:left": translator$q,
+  "w:p": translator$19,
+  "w:r": translator$Y,
+  "w:rFonts": translator$13,
+  "w:rPr": translator$_,
+  "w:rStyle": translator$12,
+  "w:right": translator$o,
+  "w:sdt": translator$8,
+  "w:shd": translator$I,
+  "w:start": translator$m,
+  "w:strike": translator$15,
+  "w:sz": translator$11,
+  "w:szCs": translator$10,
+  "w:tab": translator$1a,
+  "w:tbl": translator$d,
+  "w:tblBorders": translator$i,
+  "w:tblCaption": translator$H,
+  "w:tblCellMar": translator$h,
+  "w:tblCellSpacing": translator$Q,
+  "w:tblDescription": translator$G,
+  "w:tblGrid": translator$e,
+  "w:tblHeader": translator$P,
+  "w:tblInd": translator$F,
+  "w:tblLayout": translator$E,
+  "w:tblLook": translator$D,
+  "w:tblOverlap": translator$C,
+  "w:tblPr": translator$g,
+  "w:tblStyle": translator$B,
+  "w:tblStyleColBandSize": translator$A,
+  "w:tblStyleRowBandSize": translator$z,
+  "w:tblW": translator$y,
+  "w:tblpPr": translator$x,
+  "w:tc": translator$c,
+  "w:top": translator$k,
+  "w:tr": translator$K,
+  "w:trHeight": translator$O,
+  "w:trPr": translator$L,
+  "w:u": translator$16,
+  "w:wAfter": translator$N,
+  "w:wBefore": translator$M,
+  "wp:anchor": translator$b,
+  "wp:inline": translator$a,
   "w:commentRangeStart": commentRangeStartTranslator,
   "w:commentRangeEnd": commentRangeEndTranslator
 });