@harbour-enterprises/superdoc 0.28.0-next.4 → 0.28.0-next.5

package/dist/super-editor/chunks/{converter-CSVDRdnO.js → converter-wp7RjeT9.js}

@@ -16599,9 +16599,6 @@ const COMMENTS_XML_DEFINITIONS = {
   DOCUMENT_RELS_XML_DEF,
   CONTENT_TYPES
 };
-const TrackInsertMarkName = "trackInsert";
-const TrackDeleteMarkName = "trackDelete";
-const TrackFormatMarkName = "trackFormat";
 const carbonCopy = (obj) => {
   if (!obj) return void 0;
   try {
@@ -24656,37 +24653,37 @@ const _NodeTranslator = class _NodeTranslator {
 /** @type {typeof TranslatorTypes} */
 __publicField(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$1b = (attributes) => {
+const encode$1c = (attributes) => {
   return attributes["w:type"];
 };
-const decode$13 = (attrs) => {
+const decode$14 = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
 const attrConfig$G = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$1b,
-  decode: decode$13
+  encode: encode$1c,
+  decode: decode$14
 });
-const encode$1a = (attributes) => {
+const encode$1b = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$12 = (attrs) => {
+const decode$13 = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
 const attrConfig$F = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$1a,
-  decode: decode$12
+  encode: encode$1b,
+  decode: decode$13
 });
-const validXmlAttributes$p = [attrConfig$G, attrConfig$F];
-const XML_NODE_NAME$y = "w:br";
-const SD_NODE_NAME$h = "lineBreak";
-const encode$19 = (_2, encodedAttrs) => {
+const validXmlAttributes$q = [attrConfig$G, attrConfig$F];
+const XML_NODE_NAME$z = "w:br";
+const SD_NODE_NAME$i = "lineBreak";
+const encode$1a = (_2, encodedAttrs) => {
   const isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -24696,7 +24693,7 @@ const encode$19 = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$11 = (params, decodedAttrs) => {
+const decode$12 = (params, decodedAttrs) => {
   const { node } = params;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24713,39 +24710,39 @@ const decode$11 = (params, decodedAttrs) => {
   };
   return translated;
 };
-const config$x = {
-  xmlName: XML_NODE_NAME$y,
-  sdNodeOrKeyName: SD_NODE_NAME$h,
+const config$y = {
+  xmlName: XML_NODE_NAME$z,
+  sdNodeOrKeyName: SD_NODE_NAME$i,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$19,
-  decode: decode$11,
-  attributes: validXmlAttributes$p
+  encode: encode$1a,
+  decode: decode$12,
+  attributes: validXmlAttributes$q
 };
-const translator$1r = NodeTranslator.from(config$x);
-const encode$18 = (attributes) => attributes?.["w:val"];
-const decode$10 = (attrs) => attrs?.highlight;
+const translator$1s = NodeTranslator.from(config$y);
+const encode$19 = (attributes) => attributes?.["w:val"];
+const decode$11 = (attrs) => attrs?.highlight;
 const attrConfig$E = Object.freeze({
   xmlName: "w:val",
   sdName: "highlight",
-  encode: encode$18,
-  decode: decode$10
+  encode: encode$19,
+  decode: decode$11
 });
-const validXmlAttributes$o = [attrConfig$E];
-const XML_NODE_NAME$x = "w:highlight";
+const validXmlAttributes$p = [attrConfig$E];
+const XML_NODE_NAME$y = "w:highlight";
 const SD_ATTR_KEY$f = "highlight";
 const DISABLED_TOKENS = /* @__PURE__ */ new Set(["transparent", "none", "inherit"]);
-const encode$17 = (params, encodedAttrs = {}) => {
+const encode$18 = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const value = encodedAttrs.highlight ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$x,
+    xmlName: XML_NODE_NAME$y,
     sdNodeOrKeyName: SD_ATTR_KEY$f,
     attributes: { "w:val": value ?? null }
   };
 };
-const decode$$ = (params) => {
+const decode$10 = (params) => {
   const attrs = params?.node?.attrs || {};
   const highlightValue = attrs.highlight ?? attrs.color ?? null;
   if (!highlightValue) return void 0;
@@ -24753,14 +24750,14 @@ const decode$$ = (params) => {
   if (!normalizedValue) return void 0;
   if (DISABLED_TOKENS.has(normalizedValue)) {
     return {
-      name: XML_NODE_NAME$x,
+      name: XML_NODE_NAME$y,
       attributes: { "w:val": "none" }
     };
   }
   const keyword = getDocxHighlightKeywordFromHex(highlightValue);
   if (keyword) {
     return {
-      name: XML_NODE_NAME$x,
+      name: XML_NODE_NAME$y,
       attributes: { "w:val": keyword }
     };
   }
@@ -24775,63 +24772,63 @@ const decode$$ = (params) => {
     }
   };
 };
-const config$w = {
-  xmlName: XML_NODE_NAME$x,
+const config$x = {
+  xmlName: XML_NODE_NAME$y,
   sdNodeOrKeyName: SD_ATTR_KEY$f,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$17,
-  decode: decode$$,
-  attributes: validXmlAttributes$o
+  encode: encode$18,
+  decode: decode$10,
+  attributes: validXmlAttributes$p
 };
-const translator$1q = NodeTranslator.from(config$w);
-const encode$16 = (attributes) => {
+const translator$1r = NodeTranslator.from(config$x);
+const encode$17 = (attributes) => {
   return attributes["w:val"];
 };
-const decode$_ = (attrs) => {
+const decode$$ = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
 const attrConfig$D = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$16,
-  decode: decode$_
+  encode: encode$17,
+  decode: decode$$
 });
-const encode$15 = (attributes) => {
+const encode$16 = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$Z = (attrs) => {
+const decode$_ = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
 const attrConfig$C = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$15,
-  decode: decode$Z
+  encode: encode$16,
+  decode: decode$_
 });
-const encode$14 = (attributes) => {
+const encode$15 = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$Y = (attrs) => {
+const decode$Z = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
 const attrConfig$B = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$14,
-  decode: decode$Y
+  encode: encode$15,
+  decode: decode$Z
 });
-const validXmlAttributes$n = [attrConfig$D, attrConfig$B, attrConfig$C];
-const XML_NODE_NAME$w = "w:tab";
-const SD_NODE_NAME$g = "tab";
-const encode$13 = (_2, encodedAttrs = {}) => {
+const validXmlAttributes$o = [attrConfig$D, attrConfig$B, attrConfig$C];
+const XML_NODE_NAME$x = "w:tab";
+const SD_NODE_NAME$h = "tab";
+const encode$14 = (_2, encodedAttrs = {}) => {
   const translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$X = (params, decodedAttrs = {}) => {
+const decode$Y = (params, decodedAttrs = {}) => {
   const { node } = params || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24847,15 +24844,15 @@ const decode$X = (params, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$v = {
-  xmlName: XML_NODE_NAME$w,
-  sdNodeOrKeyName: SD_NODE_NAME$g,
+const config$w = {
+  xmlName: XML_NODE_NAME$x,
+  sdNodeOrKeyName: SD_NODE_NAME$h,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$13,
-  decode: decode$X,
-  attributes: validXmlAttributes$n
+  encode: encode$14,
+  decode: decode$Y,
+  attributes: validXmlAttributes$o
 };
-const translator$1p = NodeTranslator.from(config$v);
+const translator$1q = NodeTranslator.from(config$w);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -24905,6 +24902,9 @@ const canMergeTextNodes = (nodeA, nodeB) => {
 const areAttrsEqual = (attrsA = {}, attrsB = {}) => {
   return objectIncludes(attrsA, attrsB);
 };
+const TrackInsertMarkName = "trackInsert";
+const TrackDeleteMarkName = "trackDelete";
+const TrackFormatMarkName = "trackFormat";
 function parseMarks(property, unknownMarks = [], docx = null) {
   const marks = [];
   const seen = /* @__PURE__ */ new Set();
@@ -25373,91 +25373,91 @@ const handleParagraphNode$1 = (params) => {
   }
   return schemaNode;
 };
-const encode$12 = (attributes) => {
+const encode$13 = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$W = (attrs) => {
+const decode$X = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$A = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$12,
-  decode: decode$W
+  encode: encode$13,
+  decode: decode$X
 });
-const encode$11 = (attributes) => {
+const encode$12 = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$V = (attrs) => {
+const decode$W = (attrs) => {
   return attrs.rsidP;
 };
 const attrConfig$z = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$11,
-  decode: decode$V
+  encode: encode$12,
+  decode: decode$W
 });
-const encode$10 = (attributes) => {
+const encode$11 = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$U = (attrs) => {
+const decode$V = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$y = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$10,
-  decode: decode$U
+  encode: encode$11,
+  decode: decode$V
 });
-const encode$$ = (attributes) => {
+const encode$10 = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$T = (attrs) => {
+const decode$U = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$x = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$$,
-  decode: decode$T
+  encode: encode$10,
+  decode: decode$U
 });
-const encode$_ = (attributes) => {
+const encode$$ = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$S = (attrs) => {
+const decode$T = (attrs) => {
   return attrs.rsidRDefault;
 };
 const attrConfig$w = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$_,
-  decode: decode$S
+  encode: encode$$,
+  decode: decode$T
 });
-const encode$Z = (attributes) => {
+const encode$_ = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$R = (attrs) => {
+const decode$S = (attrs) => {
   return attrs.paraId;
 };
 const attrConfig$v = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$Z,
-  decode: decode$R
+  encode: encode$_,
+  decode: decode$S
 });
-const encode$Y = (attributes) => {
+const encode$Z = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$Q = (attrs) => {
+const decode$R = (attrs) => {
   return attrs.textId;
 };
 const attrConfig$u = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$Y,
-  decode: decode$Q
+  encode: encode$Z,
+  decode: decode$R
 });
-const validXmlAttributes$m = [
+const validXmlAttributes$n = [
   attrConfig$v,
   attrConfig$u,
   attrConfig$y,
@@ -25466,9 +25466,9 @@ const validXmlAttributes$m = [
   attrConfig$x,
   attrConfig$A
 ];
-const XML_NODE_NAME$v = "w:p";
-const SD_NODE_NAME$f = "paragraph";
-const encode$X = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$w = "w:p";
+const SD_NODE_NAME$g = "paragraph";
+const encode$Y = (params, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25476,7 +25476,7 @@ const encode$X = (params, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$P = (params, decodedAttrs = {}) => {
+const decode$Q = (params, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25484,16 +25484,16 @@ const decode$P = (params, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$u = {
-  xmlName: XML_NODE_NAME$v,
-  sdNodeOrKeyName: SD_NODE_NAME$f,
+const config$v = {
+  xmlName: XML_NODE_NAME$w,
+  sdNodeOrKeyName: SD_NODE_NAME$g,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$X,
-  decode: decode$P,
-  attributes: validXmlAttributes$m
+  encode: encode$Y,
+  decode: decode$Q,
+  attributes: validXmlAttributes$n
 };
-const translator$1o = NodeTranslator.from(config$u);
-const encode$W = (attributes) => {
+const translator$1p = NodeTranslator.from(config$v);
+const encode$X = (attributes) => {
   const raw = attributes?.["w:val"];
   if (raw === void 0 || raw === null) return void 0;
   if (typeof raw === "boolean") return raw;
@@ -25503,20 +25503,20 @@ const encode$W = (attributes) => {
   if (val === "1" || val === "true" || val === "on") return true;
   return void 0;
 };
-const decode$O = (runProps) => {
+const decode$P = (runProps) => {
   if (runProps?.bold === false) return "0";
   return void 0;
 };
 const attrConfig$t = Object.freeze({
   xmlName: "w:val",
   sdName: "bold",
-  encode: encode$W,
-  decode: decode$O
+  encode: encode$X,
+  decode: decode$P
 });
-const validXmlAttributes$l = [attrConfig$t];
-const XML_NODE_NAME$u = "w:b";
+const validXmlAttributes$m = [attrConfig$t];
+const XML_NODE_NAME$v = "w:b";
 const SD_ATTR_KEY$e = "bold";
-const encode$V = (params, encodedAttrs = {}) => {
+const encode$W = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes[0];
   if (!node) return void 0;
@@ -25528,85 +25528,85 @@ const encode$V = (params, encodedAttrs = {}) => {
   else attributes = node.attributes || {};
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$u,
+    xmlName: XML_NODE_NAME$v,
     sdNodeOrKeyName: SD_ATTR_KEY$e,
     attributes
   };
 };
-const config$t = {
-  xmlName: XML_NODE_NAME$u,
+const config$u = {
+  xmlName: XML_NODE_NAME$v,
   sdNodeOrKeyName: SD_ATTR_KEY$e,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$V,
-  attributes: validXmlAttributes$l
+  encode: encode$W,
+  attributes: validXmlAttributes$m
 };
-const translator$1n = NodeTranslator.from(config$t);
-const XML_NODE_NAME$t = "w:i";
+const translator$1o = NodeTranslator.from(config$u);
+const XML_NODE_NAME$u = "w:i";
 const SD_ATTR_KEY$d = "italic";
-const encode$U = (params) => {
+const encode$V = (params) => {
   const { nodes } = params;
   const node = nodes?.[0];
   if (!node) return void 0;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$t,
+    xmlName: XML_NODE_NAME$u,
     sdNodeOrKeyName: SD_ATTR_KEY$d,
     attributes: {
       "w:val": node.attributes?.["w:val"] ?? null
     }
   };
 };
-const config$s = {
-  xmlName: XML_NODE_NAME$t,
+const config$t = {
+  xmlName: XML_NODE_NAME$u,
   sdNodeOrKeyName: SD_ATTR_KEY$d,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$U
+  encode: encode$V
 };
-const translator$1m = NodeTranslator.from(config$s);
-const encode$T = (attributes) => attributes?.["w:val"];
-const decode$N = (attrs) => attrs?.underline;
+const translator$1n = NodeTranslator.from(config$t);
+const encode$U = (attributes) => attributes?.["w:val"];
+const decode$O = (attrs) => attrs?.underline;
 const attrConfig$s = Object.freeze({
   xmlName: "w:val",
   sdName: "underline",
-  encode: encode$T,
-  decode: decode$N
+  encode: encode$U,
+  decode: decode$O
 });
-const encode$S = (attributes) => attributes?.["w:color"];
-const decode$M = (attrs) => attrs?.color;
+const encode$T = (attributes) => attributes?.["w:color"];
+const decode$N = (attrs) => attrs?.color;
 const attrConfig$r = Object.freeze({
   xmlName: "w:color",
   sdName: "color",
-  encode: encode$S,
-  decode: decode$M
+  encode: encode$T,
+  decode: decode$N
 });
-const encode$R = (attributes) => attributes?.["w:themeColor"];
-const decode$L = (attrs) => attrs?.themeColor;
+const encode$S = (attributes) => attributes?.["w:themeColor"];
+const decode$M = (attrs) => attrs?.themeColor;
 const attrConfig$q = Object.freeze({
   xmlName: "w:themeColor",
   sdName: "themeColor",
-  encode: encode$R,
-  decode: decode$L
+  encode: encode$S,
+  decode: decode$M
 });
-const encode$Q = (attributes) => attributes?.["w:themeTint"];
-const decode$K = (attrs) => attrs?.themeTint;
+const encode$R = (attributes) => attributes?.["w:themeTint"];
+const decode$L = (attrs) => attrs?.themeTint;
 const attrConfig$p = Object.freeze({
   xmlName: "w:themeTint",
   sdName: "themeTint",
-  encode: encode$Q,
-  decode: decode$K
+  encode: encode$R,
+  decode: decode$L
 });
-const encode$P = (attributes) => attributes?.["w:themeShade"];
-const decode$J = (attrs) => attrs?.themeShade;
+const encode$Q = (attributes) => attributes?.["w:themeShade"];
+const decode$K = (attrs) => attrs?.themeShade;
 const attrConfig$o = Object.freeze({
   xmlName: "w:themeShade",
   sdName: "themeShade",
-  encode: encode$P,
-  decode: decode$J
+  encode: encode$Q,
+  decode: decode$K
 });
-const validXmlAttributes$k = [attrConfig$s, attrConfig$r, attrConfig$q, attrConfig$p, attrConfig$o];
-const XML_NODE_NAME$s = "w:u";
+const validXmlAttributes$l = [attrConfig$s, attrConfig$r, attrConfig$q, attrConfig$p, attrConfig$o];
+const XML_NODE_NAME$t = "w:u";
 const SD_ATTR_KEY$c = "underline";
-const encode$O = (params, encodedAttrs = {}) => {
+const encode$P = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25622,12 +25622,12 @@ const encode$O = (params, encodedAttrs = {}) => {
   if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$s,
+    xmlName: XML_NODE_NAME$t,
     sdNodeOrKeyName: SD_ATTR_KEY$c,
     attributes
   };
 };
-const decode$I = (params) => {
+const decode$J = (params) => {
   const attrs = params?.node?.attrs || {};
   const underlineType = attrs.underlineType ?? attrs.underline ?? null;
   const color = attrs.underlineColor ?? attrs.color ?? null;
@@ -25645,20 +25645,20 @@ const decode$I = (params) => {
   if (themeTint) attributes["w:themeTint"] = themeTint;
   if (themeShade) attributes["w:themeShade"] = themeShade;
   return {
-    name: XML_NODE_NAME$s,
+    name: XML_NODE_NAME$t,
     attributes
   };
 };
-const config$r = {
-  xmlName: XML_NODE_NAME$s,
+const config$s = {
+  xmlName: XML_NODE_NAME$t,
   sdNodeOrKeyName: SD_ATTR_KEY$c,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$O,
-  decode: decode$I,
-  attributes: validXmlAttributes$k
+  encode: encode$P,
+  decode: decode$J,
+  attributes: validXmlAttributes$l
 };
-const translator$1l = NodeTranslator.from(config$r);
-const encode$N = (attributes) => {
+const translator$1m = NodeTranslator.from(config$s);
+const encode$O = (attributes) => {
   const raw = attributes?.["w:val"];
   if (raw === void 0 || raw === null) return void 0;
   if (typeof raw === "boolean") return raw;
@@ -25668,20 +25668,20 @@ const encode$N = (attributes) => {
   if (val === "1" || val === "true" || val === "on") return true;
   return void 0;
 };
-const decode$H = (attrs) => {
+const decode$I = (attrs) => {
   if (attrs?.strike === false) return "0";
   return void 0;
 };
 const attrConfig$n = Object.freeze({
   xmlName: "w:val",
   sdName: "strike",
-  encode: encode$N,
-  decode: decode$H
+  encode: encode$O,
+  decode: decode$I
 });
-const validXmlAttributes$j = [attrConfig$n];
-const XML_NODE_NAME$r = "w:strike";
+const validXmlAttributes$k = [attrConfig$n];
+const XML_NODE_NAME$s = "w:strike";
 const SD_ATTR_KEY$b = "strike";
-const encode$M = (params, encodedAttrs = {}) => {
+const encode$N = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   if (!node) return void 0;
@@ -25694,55 +25694,55 @@ const encode$M = (params, encodedAttrs = {}) => {
   else if (val === true && attributes["w:val"] === void 0) delete attributes["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$r,
+    xmlName: XML_NODE_NAME$s,
     sdNodeOrKeyName: SD_ATTR_KEY$b,
     attributes
   };
 };
-const config$q = {
-  xmlName: XML_NODE_NAME$r,
+const config$r = {
+  xmlName: XML_NODE_NAME$s,
   sdNodeOrKeyName: SD_ATTR_KEY$b,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$M,
-  attributes: validXmlAttributes$j
+  encode: encode$N,
+  attributes: validXmlAttributes$k
 };
-const translator$1k = NodeTranslator.from(config$q);
-const encode$L = (attributes) => attributes?.["w:val"];
-const decode$G = (attrs) => attrs?.color;
+const translator$1l = NodeTranslator.from(config$r);
+const encode$M = (attributes) => attributes?.["w:val"];
+const decode$H = (attrs) => attrs?.color;
 const attrConfig$m = Object.freeze({
   xmlName: "w:val",
   sdName: "color",
-  encode: encode$L,
-  decode: decode$G
+  encode: encode$M,
+  decode: decode$H
 });
-const encode$K = (attributes) => attributes?.["w:themeColor"];
-const decode$F = (attrs) => attrs?.themeColor;
+const encode$L = (attributes) => attributes?.["w:themeColor"];
+const decode$G = (attrs) => attrs?.themeColor;
 const attrConfig$l = Object.freeze({
   xmlName: "w:themeColor",
   sdName: "themeColor",
-  encode: encode$K,
-  decode: decode$F
+  encode: encode$L,
+  decode: decode$G
 });
-const encode$J = (attributes) => attributes?.["w:themeTint"];
-const decode$E = (attrs) => attrs?.themeTint;
+const encode$K = (attributes) => attributes?.["w:themeTint"];
+const decode$F = (attrs) => attrs?.themeTint;
 const attrConfig$k = Object.freeze({
   xmlName: "w:themeTint",
   sdName: "themeTint",
-  encode: encode$J,
-  decode: decode$E
+  encode: encode$K,
+  decode: decode$F
 });
-const encode$I = (attributes) => attributes?.["w:themeShade"];
-const decode$D = (attrs) => attrs?.themeShade;
+const encode$J = (attributes) => attributes?.["w:themeShade"];
+const decode$E = (attrs) => attrs?.themeShade;
 const attrConfig$j = Object.freeze({
   xmlName: "w:themeShade",
   sdName: "themeShade",
-  encode: encode$I,
-  decode: decode$D
+  encode: encode$J,
+  decode: decode$E
 });
-const validXmlAttributes$i = [attrConfig$m, attrConfig$l, attrConfig$k, attrConfig$j];
-const XML_NODE_NAME$q = "w:color";
+const validXmlAttributes$j = [attrConfig$m, attrConfig$l, attrConfig$k, attrConfig$j];
+const XML_NODE_NAME$r = "w:color";
 const SD_ATTR_KEY$a = "color";
-const encode$H = (params, encodedAttrs = {}) => {
+const encode$I = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25757,63 +25757,63 @@ const encode$H = (params, encodedAttrs = {}) => {
   if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$q,
+    xmlName: XML_NODE_NAME$r,
     sdNodeOrKeyName: SD_ATTR_KEY$a,
     attributes
   };
 };
-const config$p = {
-  xmlName: XML_NODE_NAME$q,
+const config$q = {
+  xmlName: XML_NODE_NAME$r,
   sdNodeOrKeyName: SD_ATTR_KEY$a,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$H,
-  attributes: validXmlAttributes$i
+  encode: encode$I,
+  attributes: validXmlAttributes$j
 };
-const translator$1j = NodeTranslator.from(config$p);
-const encode$G = (attributes) => attributes?.["w:eastAsia"];
-const decode$C = (attrs) => attrs?.eastAsia;
+const translator$1k = NodeTranslator.from(config$q);
+const encode$H = (attributes) => attributes?.["w:eastAsia"];
+const decode$D = (attrs) => attrs?.eastAsia;
 const attrConfig$i = Object.freeze({
   xmlName: "w:eastAsia",
   sdName: "eastAsia",
-  encode: encode$G,
-  decode: decode$C
+  encode: encode$H,
+  decode: decode$D
 });
-const encode$F = (attributes) => attributes?.["w:ascii"];
-const decode$B = (attrs) => attrs?.ascii;
+const encode$G = (attributes) => attributes?.["w:ascii"];
+const decode$C = (attrs) => attrs?.ascii;
 const attrConfig$h = Object.freeze({
   xmlName: "w:ascii",
   sdName: "ascii",
-  encode: encode$F,
-  decode: decode$B
+  encode: encode$G,
+  decode: decode$C
 });
-const encode$E = (attributes) => attributes?.["w:hAnsi"];
-const decode$A = (attrs) => attrs?.hAnsi;
+const encode$F = (attributes) => attributes?.["w:hAnsi"];
+const decode$B = (attrs) => attrs?.hAnsi;
 const attrConfig$g = Object.freeze({
   xmlName: "w:hAnsi",
   sdName: "hAnsi",
-  encode: encode$E,
-  decode: decode$A
+  encode: encode$F,
+  decode: decode$B
 });
-const encode$D = (attributes) => attributes?.["w:cs"];
-const decode$z = (attrs) => attrs?.cs;
+const encode$E = (attributes) => attributes?.["w:cs"];
+const decode$A = (attrs) => attrs?.cs;
 const attrConfig$f = Object.freeze({
   xmlName: "w:cs",
   sdName: "cs",
-  encode: encode$D,
-  decode: decode$z
+  encode: encode$E,
+  decode: decode$A
 });
-const encode$C = (attributes) => attributes?.["w:val"];
-const decode$y = (attrs) => attrs?.value;
+const encode$D = (attributes) => attributes?.["w:val"];
+const decode$z = (attrs) => attrs?.value;
 const attrConfig$e = Object.freeze({
   xmlName: "w:val",
   sdName: "value",
-  encode: encode$C,
-  decode: decode$y
+  encode: encode$D,
+  decode: decode$z
 });
-const validXmlAttributes$h = [attrConfig$i, attrConfig$h, attrConfig$g, attrConfig$f, attrConfig$e];
-const XML_NODE_NAME$p = "w:rFonts";
+const validXmlAttributes$i = [attrConfig$i, attrConfig$h, attrConfig$g, attrConfig$f, attrConfig$e];
+const XML_NODE_NAME$q = "w:rFonts";
 const SD_ATTR_KEY$9 = "fontFamily";
-const encode$B = (params, encodedAttrs = {}) => {
+const encode$C = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25847,109 +25847,109 @@ const encode$B = (params, encodedAttrs = {}) => {
   }
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$p,
+    xmlName: XML_NODE_NAME$q,
     sdNodeOrKeyName: SD_ATTR_KEY$9,
     attributes
   };
 };
-const config$o = {
-  xmlName: XML_NODE_NAME$p,
+const config$p = {
+  xmlName: XML_NODE_NAME$q,
   sdNodeOrKeyName: SD_ATTR_KEY$9,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$B,
-  attributes: validXmlAttributes$h
+  encode: encode$C,
+  attributes: validXmlAttributes$i
 };
-const translator$1i = NodeTranslator.from(config$o);
-const encode$A = (attributes) => attributes?.["w:val"];
-const decode$x = (attrs) => attrs?.styleId;
+const translator$1j = NodeTranslator.from(config$p);
+const encode$B = (attributes) => attributes?.["w:val"];
+const decode$y = (attrs) => attrs?.styleId;
 const attrConfig$d = Object.freeze({
   xmlName: "w:val",
   sdName: "styleId",
-  encode: encode$A,
-  decode: decode$x
+  encode: encode$B,
+  decode: decode$y
 });
-const validXmlAttributes$g = [attrConfig$d];
-const XML_NODE_NAME$o = "w:rStyle";
+const validXmlAttributes$h = [attrConfig$d];
+const XML_NODE_NAME$p = "w:rStyle";
 const SD_ATTR_KEY$8 = "styleId";
-const encode$z = (params, encodedAttrs = {}) => {
+const encode$A = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const value = encodedAttrs.styleId ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$o,
+    xmlName: XML_NODE_NAME$p,
     sdNodeOrKeyName: SD_ATTR_KEY$8,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$n = {
-  xmlName: XML_NODE_NAME$o,
+const config$o = {
+  xmlName: XML_NODE_NAME$p,
   sdNodeOrKeyName: SD_ATTR_KEY$8,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$z,
-  attributes: validXmlAttributes$g
+  encode: encode$A,
+  attributes: validXmlAttributes$h
 };
-const translator$1h = NodeTranslator.from(config$n);
-const encode$y = (attributes) => attributes?.["w:val"];
-const decode$w = (attrs) => attrs?.fontSize;
+const translator$1i = NodeTranslator.from(config$o);
+const encode$z = (attributes) => attributes?.["w:val"];
+const decode$x = (attrs) => attrs?.fontSize;
 const attrConfig$c = Object.freeze({
   xmlName: "w:val",
   sdName: "fontSize",
-  encode: encode$y,
-  decode: decode$w
+  encode: encode$z,
+  decode: decode$x
 });
-const validXmlAttributes$f = [attrConfig$c];
-const XML_NODE_NAME$n = "w:sz";
+const validXmlAttributes$g = [attrConfig$c];
+const XML_NODE_NAME$o = "w:sz";
 const SD_ATTR_KEY$7 = "fontSize";
-const encode$x = (params, encodedAttrs = {}) => {
+const encode$y = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const value = encodedAttrs.fontSize ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$n,
+    xmlName: XML_NODE_NAME$o,
     sdNodeOrKeyName: SD_ATTR_KEY$7,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$m = {
-  xmlName: XML_NODE_NAME$n,
+const config$n = {
+  xmlName: XML_NODE_NAME$o,
   sdNodeOrKeyName: SD_ATTR_KEY$7,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$x,
-  attributes: validXmlAttributes$f
+  encode: encode$y,
+  attributes: validXmlAttributes$g
 };
-const translator$1g = NodeTranslator.from(config$m);
-const encode$w = (attributes) => attributes?.["w:val"];
-const decode$v = (attrs) => attrs?.fontSizeCs;
+const translator$1h = NodeTranslator.from(config$n);
+const encode$x = (attributes) => attributes?.["w:val"];
+const decode$w = (attrs) => attrs?.fontSizeCs;
 const attrConfig$b = Object.freeze({
   xmlName: "w:val",
   sdName: "fontSizeCs",
-  encode: encode$w,
-  decode: decode$v
+  encode: encode$x,
+  decode: decode$w
 });
-const validXmlAttributes$e = [attrConfig$b];
-const XML_NODE_NAME$m = "w:szCs";
+const validXmlAttributes$f = [attrConfig$b];
+const XML_NODE_NAME$n = "w:szCs";
 const SD_ATTR_KEY$6 = "fontSizeCs";
-const encode$v = (params, encodedAttrs = {}) => {
+const encode$w = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const value = encodedAttrs.fontSizeCs ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$m,
+    xmlName: XML_NODE_NAME$n,
     sdNodeOrKeyName: SD_ATTR_KEY$6,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$l = {
-  xmlName: XML_NODE_NAME$m,
+const config$m = {
+  xmlName: XML_NODE_NAME$n,
   sdNodeOrKeyName: SD_ATTR_KEY$6,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$v,
-  attributes: validXmlAttributes$e
+  encode: encode$w,
+  attributes: validXmlAttributes$f
 };
-const translator$1f = NodeTranslator.from(config$l);
+const translator$1g = NodeTranslator.from(config$m);
 const generateV2HandlerEntity = (handlerName, translator2) => ({
   handlerName,
   handler: (params) => {
@@ -26138,9 +26138,9 @@ const integerToString = (value) => {
   const intValue = parseInteger(value);
   return intValue != void 0 ? String(intValue) : void 0;
 };
-const XML_NODE_NAME$l = "w:caps";
+const XML_NODE_NAME$m = "w:caps";
 const SD_ATTR_KEY$5 = "textTransform";
-const encode$u = (params, encodedAttrs = {}) => {
+const encode$v = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes[0];
   if (!node) return void 0;
@@ -26152,31 +26152,31 @@ const encode$u = (params, encodedAttrs = {}) => {
   }
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$l,
+    xmlName: XML_NODE_NAME$m,
     sdNodeOrKeyName: SD_ATTR_KEY$5,
     attributes: { [SD_ATTR_KEY$5]: result }
   };
 };
-const config$k = {
-  xmlName: XML_NODE_NAME$l,
+const config$l = {
+  xmlName: XML_NODE_NAME$m,
   sdNodeOrKeyName: SD_ATTR_KEY$5,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$u,
+  encode: encode$v,
   attributes: [createAttributeHandler("w:val")]
 };
-const translator$1e = NodeTranslator.from(config$k);
+const translator$1f = NodeTranslator.from(config$l);
 const runPropertyTranslators = Object.freeze({
-  "w:b": translator$1n,
-  "w:i": translator$1m,
-  "w:u": translator$1l,
-  "w:strike": translator$1k,
-  "w:color": translator$1j,
-  "w:highlight": translator$1q,
-  "w:rFonts": translator$1i,
-  "w:rStyle": translator$1h,
-  "w:sz": translator$1g,
-  "w:szCs": translator$1f,
-  "w:caps": translator$1e
+  "w:b": translator$1o,
+  "w:i": translator$1n,
+  "w:u": translator$1m,
+  "w:strike": translator$1l,
+  "w:color": translator$1k,
+  "w:highlight": translator$1r,
+  "w:rFonts": translator$1j,
+  "w:rStyle": translator$1i,
+  "w:sz": translator$1h,
+  "w:szCs": translator$1g,
+  "w:caps": translator$1f
 });
 const rawRunPropertyXmlNames = Object.freeze(["w:lang", "w:shd"]);
 const RAW_CHILD_NAME_SET = new Set(rawRunPropertyXmlNames);
@@ -26190,9 +26190,9 @@ const toRunPropertyEntry = (candidate) => {
     attributes: { ...candidate.attributes || {} }
   };
 };
-const XML_NODE_NAME$k = "w:rPr";
+const XML_NODE_NAME$l = "w:rPr";
 const SD_ATTR_KEY$4 = "runProperties";
-const encode$t = (params) => {
+const encode$u = (params) => {
   const { nodes } = params;
   const node = nodes?.[0] || {};
   const contents = Array.isArray(node.elements) ? node.elements : [];
@@ -26226,16 +26226,16 @@ const encode$t = (params) => {
     attributes: runPropsArray
   };
 };
-const config$j = {
-  xmlName: XML_NODE_NAME$k,
+const config$k = {
+  xmlName: XML_NODE_NAME$l,
   sdNodeOrKeyName: SD_ATTR_KEY$4,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$t
+  encode: encode$u
 };
-const translator$1d = NodeTranslator.from(config$j);
+const translator$1e = 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 = (params, rPrNode, translator2 = translator$1d) => {
+const collectRunProperties = (params, rPrNode, translator2 = translator$1e) => {
   if (!rPrNode) return { entries: [], hadRPr: false, styleChangeMarks: [] };
   const result = translator2.encode({ ...params, nodes: [rPrNode] }) || {};
   let entries = [];
@@ -26708,15 +26708,15 @@ const ensureTrackedWrapper = (runs, trackingMarksByType = /* @__PURE__ */ new Ma
   }
   return runs;
 };
-const XML_NODE_NAME$j = "w:hyperlink";
-const SD_NODE_NAME$e = "link";
+const XML_NODE_NAME$k = "w:hyperlink";
+const SD_NODE_NAME$f = "link";
 const _createAttributeHandler = (xmlName, sdName) => ({
   xmlName,
   sdName,
   encode: (attributes) => attributes[xmlName],
   decode: (attributes) => attributes[sdName]
 });
-const validXmlAttributes$d = [
+const validXmlAttributes$e = [
   _createAttributeHandler("w:anchor", "anchor"),
   _createAttributeHandler("w:docLocation", "docLocation"),
   {
@@ -26729,7 +26729,7 @@ const validXmlAttributes$d = [
   _createAttributeHandler("r:id", "rId"),
   _createAttributeHandler("w:tgtFrame", "target")
 ];
-const encode$s = (params, encodedAttrs) => {
+const encode$t = (params, encodedAttrs) => {
   const { nodes, docx, nodeListHandler } = params;
   const node = nodes[0];
   let href = _resolveHref(docx, encodedAttrs);
@@ -26763,7 +26763,7 @@ const _resolveHref = (docx, encodedAttrs) => {
   }
   return href;
 };
-function decode$u(params) {
+function decode$v(params) {
   const { hyperlinkGroup = [params.node] } = params.extraParams || {};
   const node = hyperlinkGroup[0];
   const linkMark = node.marks.find((m2) => m2.type === "link");
@@ -26812,55 +26812,55 @@ function _addNewLinkRelationship(params, link) {
   });
   return id;
 }
-const config$i = {
-  xmlName: XML_NODE_NAME$j,
-  sdNodeOrKeyName: SD_NODE_NAME$e,
+const config$j = {
+  xmlName: XML_NODE_NAME$k,
+  sdNodeOrKeyName: SD_NODE_NAME$f,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$s,
-  decode: decode$u,
-  attributes: validXmlAttributes$d
+  encode: encode$t,
+  decode: decode$v,
+  attributes: validXmlAttributes$e
 };
-const translator$1c = NodeTranslator.from(config$i);
-const encode$r = (attributes) => {
+const translator$1d = NodeTranslator.from(config$j);
+const encode$s = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$t = (attrs) => {
+const decode$u = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$a = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$r,
-  decode: decode$t
+  encode: encode$s,
+  decode: decode$u
 });
-const encode$q = (attributes) => {
+const encode$r = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$s = (attrs) => {
+const decode$t = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$9 = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$q,
-  decode: decode$s
+  encode: encode$r,
+  decode: decode$t
 });
-const encode$p = (attributes) => {
+const encode$q = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$r = (attrs) => {
+const decode$s = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$8 = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$p,
-  decode: decode$r
+  encode: encode$q,
+  decode: decode$s
 });
-const validXmlAttributes$c = [attrConfig$a, attrConfig$9, attrConfig$8];
-const XML_NODE_NAME$i = "w:r";
+const validXmlAttributes$d = [attrConfig$a, attrConfig$9, attrConfig$8];
+const XML_NODE_NAME$j = "w:r";
 const SD_KEY_NAME = "run";
-const encode$o = (params, encodedAttrs = {}) => {
+const encode$p = (params, encodedAttrs = {}) => {
   const { nodes = [], nodeListHandler } = params || {};
   const runNode = nodes[0];
   if (!runNode) return void 0;
@@ -26908,7 +26908,7 @@ const encode$o = (params, encodedAttrs = {}) => {
   }
   return runNodeResult;
 };
-const decode$q = (params, decodedAttrs = {}) => {
+const decode$r = (params, decodedAttrs = {}) => {
   const { node } = params || {};
   if (!node) return void 0;
   const isLinkNode = node.marks?.some((m2) => m2.type === "link");
@@ -26917,7 +26917,7 @@ const decode$q = (params, decodedAttrs = {}) => {
       ...params.extraParams,
       linkProcessed: true
     };
-    return translator$1c.decode({ ...params, extraParams });
+    return translator$1d.decode({ ...params, extraParams });
   }
   const { runNode: runNodeForExport, trackingMarksByType } = prepareRunTrackingContext(node);
   const runAttrs = runNodeForExport.attrs || {};
@@ -26973,7 +26973,7 @@ const decode$q = (params, decodedAttrs = {}) => {
       runs.push(trackedClone);
       return;
     }
-    const runWrapper = { name: XML_NODE_NAME$i, elements: [] };
+    const runWrapper = { name: XML_NODE_NAME$j, elements: [] };
     applyBaseRunProps(runWrapper);
     if (!Array.isArray(runWrapper.elements)) runWrapper.elements = [];
     runWrapper.elements.push(cloneXmlNode(child));
@@ -26981,7 +26981,7 @@ const decode$q = (params, decodedAttrs = {}) => {
   });
   const trackedRuns = ensureTrackedWrapper(runs, trackingMarksByType);
   if (!trackedRuns.length) {
-    const emptyRun = { name: XML_NODE_NAME$i, elements: [] };
+    const emptyRun = { name: XML_NODE_NAME$j, elements: [] };
     applyBaseRunProps(emptyRun);
     trackedRuns.push(emptyRun);
   }
@@ -26995,16 +26995,16 @@ const decode$q = (params, decodedAttrs = {}) => {
   }
   return trackedRuns;
 };
-const config$h = {
-  xmlName: XML_NODE_NAME$i,
+const config$i = {
+  xmlName: XML_NODE_NAME$j,
   sdNodeOrKeyName: SD_KEY_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$o,
-  decode: decode$q,
-  attributes: validXmlAttributes$c
+  encode: encode$p,
+  decode: decode$r,
+  attributes: validXmlAttributes$d
 };
-const translator$1b = NodeTranslator.from(config$h);
-const translator$1a = NodeTranslator.from({
+const translator$1c = NodeTranslator.from(config$i);
+const translator$1b = NodeTranslator.from({
   xmlName: "w:cnfStyle",
   sdNodeOrKeyName: "cnfStyle",
   attributes: [
@@ -27030,7 +27030,7 @@ const translator$1a = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$19 = NodeTranslator.from({
+const translator$1a = NodeTranslator.from({
   xmlName: "w:shd",
   sdNodeOrKeyName: "shading",
   attributes: [
@@ -27052,8 +27052,8 @@ const translator$19 = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$18 = NodeTranslator.from(createMeasurementPropertyHandler("w:tcW", "cellWidth"));
-const translator$17 = NodeTranslator.from(
+const translator$19 = NodeTranslator.from(createMeasurementPropertyHandler("w:tcW", "cellWidth"));
+const translator$18 = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridSpan",
     null,
@@ -27062,39 +27062,39 @@ const translator$17 = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$16 = NodeTranslator.from(createSingleAttrPropertyHandler("w:vMerge"));
-const translator$15 = NodeTranslator.from(createBorderPropertyHandler("w:bottom"));
-const translator$14 = NodeTranslator.from(createMeasurementPropertyHandler("w:bottom", "marginBottom"));
-const translator$13 = NodeTranslator.from(createBorderPropertyHandler("w:end"));
-const translator$12 = NodeTranslator.from(createMeasurementPropertyHandler("w:end", "marginEnd"));
-const translator$11 = NodeTranslator.from(createBorderPropertyHandler("w:insideH"));
-const translator$10 = NodeTranslator.from(createBorderPropertyHandler("w:insideV"));
-const translator$$ = NodeTranslator.from(createBorderPropertyHandler("w:left"));
-const translator$_ = NodeTranslator.from(createMeasurementPropertyHandler("w:left", "marginLeft"));
-const translator$Z = NodeTranslator.from(createBorderPropertyHandler("w:right"));
-const translator$Y = NodeTranslator.from(createMeasurementPropertyHandler("w:right", "marginRight"));
-const translator$X = NodeTranslator.from(createBorderPropertyHandler("w:start"));
-const translator$W = NodeTranslator.from(createMeasurementPropertyHandler("w:start", "marginStart"));
-const translator$V = NodeTranslator.from(createBorderPropertyHandler("w:top"));
-const translator$U = NodeTranslator.from(createMeasurementPropertyHandler("w:top", "marginTop"));
-const translator$T = NodeTranslator.from(createBorderPropertyHandler("w:tl2br"));
-const translator$S = NodeTranslator.from(createBorderPropertyHandler("w:tr2bl"));
+const translator$17 = NodeTranslator.from(createSingleAttrPropertyHandler("w:vMerge"));
+const translator$16 = NodeTranslator.from(createBorderPropertyHandler("w:bottom"));
+const translator$15 = NodeTranslator.from(createMeasurementPropertyHandler("w:bottom", "marginBottom"));
+const translator$14 = NodeTranslator.from(createBorderPropertyHandler("w:end"));
+const translator$13 = NodeTranslator.from(createMeasurementPropertyHandler("w:end", "marginEnd"));
+const translator$12 = NodeTranslator.from(createBorderPropertyHandler("w:insideH"));
+const translator$11 = NodeTranslator.from(createBorderPropertyHandler("w:insideV"));
+const translator$10 = NodeTranslator.from(createBorderPropertyHandler("w:left"));
+const translator$$ = NodeTranslator.from(createMeasurementPropertyHandler("w:left", "marginLeft"));
+const translator$_ = NodeTranslator.from(createBorderPropertyHandler("w:right"));
+const translator$Z = NodeTranslator.from(createMeasurementPropertyHandler("w:right", "marginRight"));
+const translator$Y = NodeTranslator.from(createBorderPropertyHandler("w:start"));
+const translator$X = NodeTranslator.from(createMeasurementPropertyHandler("w:start", "marginStart"));
+const translator$W = NodeTranslator.from(createBorderPropertyHandler("w:top"));
+const translator$V = NodeTranslator.from(createMeasurementPropertyHandler("w:top", "marginTop"));
+const translator$U = NodeTranslator.from(createBorderPropertyHandler("w:tl2br"));
+const translator$T = NodeTranslator.from(createBorderPropertyHandler("w:tr2bl"));
 const propertyTranslators$6 = [
-  translator$V,
-  translator$X,
-  translator$$,
-  translator$15,
-  translator$13,
-  translator$Z,
-  translator$11,
+  translator$W,
+  translator$Y,
   translator$10,
-  translator$T,
-  translator$S
+  translator$16,
+  translator$14,
+  translator$_,
+  translator$12,
+  translator$11,
+  translator$U,
+  translator$T
 ];
-const translator$R = NodeTranslator.from(
+const translator$S = NodeTranslator.from(
   createNestedPropertiesTranslator("w:tcBorders", "borders", propertyTranslators$6)
 );
-const translator$Q = NodeTranslator.from(
+const translator$R = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:noWrap",
     null,
@@ -27104,18 +27104,18 @@ const translator$Q = NodeTranslator.from(
   )
 );
 const propertyTranslators$5 = [
-  translator$14,
-  translator$12,
-  translator$_,
-  translator$Y,
-  translator$W,
-  translator$U
+  translator$15,
+  translator$13,
+  translator$$,
+  translator$Z,
+  translator$X,
+  translator$V
 ];
-const translator$P = NodeTranslator.from(
+const translator$Q = NodeTranslator.from(
   createNestedPropertiesTranslator("w:tcMar", "cellMargins", propertyTranslators$5)
 );
-const translator$O = NodeTranslator.from(createSingleAttrPropertyHandler("w:textDirection"));
-const translator$N = NodeTranslator.from(
+const translator$P = NodeTranslator.from(createSingleAttrPropertyHandler("w:textDirection"));
+const translator$O = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:tcFitText",
     null,
@@ -27124,8 +27124,8 @@ const translator$N = NodeTranslator.from(
     (v2) => booleanToString(v2)
   )
 );
-const translator$M = NodeTranslator.from(createSingleAttrPropertyHandler("w:vAlign"));
-const translator$L = NodeTranslator.from(
+const translator$N = NodeTranslator.from(createSingleAttrPropertyHandler("w:vAlign"));
+const translator$M = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:hideMark",
     null,
@@ -27134,55 +27134,55 @@ const translator$L = NodeTranslator.from(
     (v2) => booleanToString(v2)
   )
 );
-const translator$K = NodeTranslator.from(createSingleAttrPropertyHandler("w:header"));
-const XML_NODE_NAME$h = "w:headers";
+const translator$L = NodeTranslator.from(createSingleAttrPropertyHandler("w:header"));
+const XML_NODE_NAME$i = "w:headers";
 const SD_ATTR_KEY$3 = "headers";
-const encode$n = (params) => {
+const encode$o = (params) => {
   const { nodes } = params;
   const node = nodes[0];
-  const attributes = encodeProperties(node, { [translator$K.xmlName]: translator$K }, true);
+  const attributes = encodeProperties(node, { [translator$L.xmlName]: translator$L }, true);
   return {
-    xmlName: XML_NODE_NAME$h,
+    xmlName: XML_NODE_NAME$i,
     sdNodeOrKeyName: SD_ATTR_KEY$3,
     attributes
   };
 };
-const decode$p = (params) => {
+const decode$q = (params) => {
   const { headers = [] } = params.node.attrs || {};
   const newNode = {
-    name: XML_NODE_NAME$h,
+    name: XML_NODE_NAME$i,
     attributes: {},
     elements: headers.map(
-      (header) => translator$K.decode({
+      (header) => translator$L.decode({
         node: { type: "header", attrs: header }
       })
     )
   };
   return newNode;
 };
-const config$g = {
-  xmlName: XML_NODE_NAME$h,
+const config$h = {
+  xmlName: XML_NODE_NAME$i,
   sdNodeOrKeyName: SD_ATTR_KEY$3,
-  encode: encode$n,
-  decode: decode$p
+  encode: encode$o,
+  decode: decode$q
 };
-const translator$J = NodeTranslator.from(config$g);
+const translator$K = NodeTranslator.from(config$h);
 const propertyTranslators$4 = [
-  translator$1a,
+  translator$1b,
+  translator$19,
   translator$18,
   translator$17,
-  translator$16,
+  translator$S,
+  translator$1a,
   translator$R,
-  translator$19,
   translator$Q,
   translator$P,
   translator$O,
   translator$N,
   translator$M,
-  translator$L,
-  translator$J
+  translator$K
 ];
-const translator$I = NodeTranslator.from(
+const translator$J = NodeTranslator.from(
   createNestedPropertiesTranslator("w:tcPr", "tableCellProperties", propertyTranslators$4)
 );
 function handleTableCellNode({
@@ -27200,7 +27200,7 @@ function handleTableCellNode({
   const attributes = {};
   const referencedStyles = _referencedStyles ?? { fontSize: null, fonts: {}, cellMargins: {} };
   const tcPr = node.elements.find((el) => el.name === "w:tcPr");
-  const tableCellProperties = tcPr ? translator$I.encode({ ...params, nodes: [tcPr] }) ?? {} : {};
+  const tableCellProperties = tcPr ? translator$J.encode({ ...params, nodes: [tcPr] }) ?? {} : {};
   attributes["tableCellProperties"] = tableCellProperties;
   if (rowBorders?.insideH) {
     rowBorders["bottom"] = rowBorders.insideH;
@@ -27512,13 +27512,13 @@ function generateTableCellProperties(node) {
   } else if (tableCellProperties?.borders) {
     delete tableCellProperties.borders;
   }
-  const result = translator$I.decode({ node: { ...node, attrs: { ...node.attrs, tableCellProperties } } });
+  const result = translator$J.decode({ node: { ...node, attrs: { ...node.attrs, tableCellProperties } } });
   return result;
 }
-const XML_NODE_NAME$g = "w:tc";
-const SD_NODE_NAME$d = "tableCell";
-const validXmlAttributes$b = [];
-function encode$m(params, encodedAttrs) {
+const XML_NODE_NAME$h = "w:tc";
+const SD_NODE_NAME$e = "tableCell";
+const validXmlAttributes$c = [];
+function encode$n(params, encodedAttrs) {
   const {
     node,
     table,
@@ -27545,30 +27545,30 @@ function encode$m(params, encodedAttrs) {
   }
   return schemaNode;
 }
-function decode$o(params, decodedAttrs) {
+function decode$p(params, decodedAttrs) {
   const translated = translateTableCell(params);
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
     translated.attributes = { ...translated.attributes || {}, ...decodedAttrs };
   }
   return translated;
 }
-const config$f = {
-  xmlName: XML_NODE_NAME$g,
-  sdNodeOrKeyName: SD_NODE_NAME$d,
+const config$g = {
+  xmlName: XML_NODE_NAME$h,
+  sdNodeOrKeyName: SD_NODE_NAME$e,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$m,
-  decode: decode$o,
-  attributes: validXmlAttributes$b
+  encode: encode$n,
+  decode: decode$p,
+  attributes: validXmlAttributes$c
 };
-const translator$H = NodeTranslator.from(config$f);
-const translator$G = NodeTranslator.from({
+const translator$I = NodeTranslator.from(config$g);
+const translator$H = 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$F = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
-const translator$E = NodeTranslator.from(
+const translator$G = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
+const translator$F = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridAfter",
     null,
@@ -27577,7 +27577,7 @@ const translator$E = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$D = NodeTranslator.from(
+const translator$E = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridBefore",
     null,
@@ -27586,21 +27586,21 @@ const translator$D = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$C = NodeTranslator.from({
+const translator$D = 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$B = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc", "justification"));
-const translator$A = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
-const translator$z = NodeTranslator.from({
+const translator$C = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc", "justification"));
+const translator$B = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
+const translator$A = 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$y = NodeTranslator.from({
+const translator$z = NodeTranslator.from({
   xmlName: "w:trHeight",
   sdNodeOrKeyName: "rowHeight",
   encode: ({ nodes }) => {
@@ -27627,11 +27627,12 @@ const translator$y = NodeTranslator.from({
     return Object.keys(heightAttrs).length > 0 ? { attributes: heightAttrs } : void 0;
   }
 });
-const translator$x = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
-const translator$w = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
+const translator$y = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
+const translator$x = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
 const propertyTranslators$3 = [
+  translator$H,
+  translator$1b,
   translator$G,
-  translator$1a,
   translator$F,
   translator$E,
   translator$D,
@@ -27640,10 +27641,9 @@ const propertyTranslators$3 = [
   translator$A,
   translator$z,
   translator$y,
-  translator$x,
-  translator$w
+  translator$x
 ];
-const translator$v = NodeTranslator.from(
+const translator$w = NodeTranslator.from(
   createNestedPropertiesTranslator("w:trPr", "tableRowProperties", propertyTranslators$3, {
     cantSplit: false,
     hidden: false,
@@ -27712,17 +27712,17 @@ const isPlaceholderCell = (cell) => {
   }
   return false;
 };
-const XML_NODE_NAME$f = "w:tr";
-const SD_NODE_NAME$c = "tableRow";
-const validXmlAttributes$a = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
+const XML_NODE_NAME$g = "w:tr";
+const SD_NODE_NAME$d = "tableRow";
+const validXmlAttributes$b = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
   (xmlName) => createAttributeHandler(xmlName)
 );
-const encode$l = (params, encodedAttrs) => {
+const encode$m = (params, encodedAttrs) => {
   const { row } = params.extraParams;
   let tableRowProperties = {};
   const tPr = row.elements.find((el) => el.name === "w:trPr");
   if (tPr) {
-    tableRowProperties = translator$v.encode({
+    tableRowProperties = translator$w.encode({
       ...params,
       nodes: [tPr]
     });
@@ -27759,7 +27759,7 @@ const encode$l = (params, encodedAttrs) => {
     skipOccupiedColumns();
     const startColumn = currentColumnIndex;
     const columnWidth = gridColumnWidths?.[startColumn] || null;
-    const result = translator$H.encode({
+    const result = translator$I.encode({
       ...params,
       extraParams: {
         ...params.extraParams,
@@ -27792,7 +27792,7 @@ const encode$l = (params, encodedAttrs) => {
   };
   return newNode;
 };
-const decode$n = (params, decodedAttrs) => {
+const decode$o = (params, decodedAttrs) => {
   const { node } = params;
   const cells = node.content || [];
   let leadingPlaceholders = 0;
@@ -27832,7 +27832,7 @@ const decode$n = (params, decodedAttrs) => {
       }
     }
     tableRowProperties["cantSplit"] = node.attrs["cantSplit"];
-    const trPr = translator$v.decode({
+    const trPr = translator$w.decode({
       ...params,
       node: { ...node, attrs: { ...node.attrs, tableRowProperties } }
     });
@@ -27844,15 +27844,15 @@ const decode$n = (params, decodedAttrs) => {
     elements
   };
 };
-const config$e = {
-  xmlName: XML_NODE_NAME$f,
-  sdNodeOrKeyName: SD_NODE_NAME$c,
+const config$f = {
+  xmlName: XML_NODE_NAME$g,
+  sdNodeOrKeyName: SD_NODE_NAME$d,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$l,
-  decode: decode$n,
-  attributes: validXmlAttributes$a
+  encode: encode$m,
+  decode: decode$o,
+  attributes: validXmlAttributes$b
 };
-const translator$u = NodeTranslator.from(config$e);
+const translator$v = NodeTranslator.from(config$f);
 function parseTagValueJSON(json) {
   if (typeof json !== "string") {
     return {};
@@ -29175,32 +29175,32 @@ function translateAnchorNode(params) {
     elements: [...anchorElements, ...elementsWithWrap]
   };
 }
-const XML_NODE_NAME$e = "wp:anchor";
-const SD_NODE_NAME$b = ["image"];
-const validXmlAttributes$9 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
-function encode$k(params) {
+const XML_NODE_NAME$f = "wp:anchor";
+const SD_NODE_NAME$c = ["image"];
+const validXmlAttributes$a = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
+function encode$l(params) {
   const { node } = params.extraParams;
   if (!node || !node.type) {
     return null;
   }
   return handleAnchorNode(params);
 }
-function decode$m(params) {
+function decode$n(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
   }
   return translateAnchorNode(params);
 }
-const config$d = {
-  xmlName: XML_NODE_NAME$e,
-  sdNodeOrKeyName: SD_NODE_NAME$b,
+const config$e = {
+  xmlName: XML_NODE_NAME$f,
+  sdNodeOrKeyName: SD_NODE_NAME$c,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$k,
-  decode: decode$m,
-  attributes: validXmlAttributes$9
+  encode: encode$l,
+  decode: decode$n,
+  attributes: validXmlAttributes$a
 };
-const translator$t = NodeTranslator.from(config$d);
+const translator$u = NodeTranslator.from(config$e);
 function handleInlineNode(params) {
   const { node } = params.extraParams;
   if (node.name !== "wp:inline") {
@@ -29216,41 +29216,41 @@ function translateInlineNode(params) {
     elements: nodeElements.elements
   };
 }
-const XML_NODE_NAME$d = "wp:inline";
-const SD_NODE_NAME$a = ["image"];
-const validXmlAttributes$8 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
-function encode$j(params) {
+const XML_NODE_NAME$e = "wp:inline";
+const SD_NODE_NAME$b = ["image"];
+const validXmlAttributes$9 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
+function encode$k(params) {
   const { node } = params.extraParams;
   if (!node || !node.type) {
     return null;
   }
   return handleInlineNode(params);
 }
-function decode$l(params) {
+function decode$m(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
   }
   return translateInlineNode(params);
 }
-const config$c = {
-  xmlName: XML_NODE_NAME$d,
-  sdNodeOrKeyName: SD_NODE_NAME$a,
+const config$d = {
+  xmlName: XML_NODE_NAME$e,
+  sdNodeOrKeyName: SD_NODE_NAME$b,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$j,
-  decode: decode$l,
-  attributes: validXmlAttributes$8
+  encode: encode$k,
+  decode: decode$m,
+  attributes: validXmlAttributes$9
 };
-const translator$s = NodeTranslator.from(config$c);
-const XML_NODE_NAME$c = "w:drawing";
-const SD_NODE_NAME$9 = [];
-const validXmlAttributes$7 = [];
-function encode$i(params) {
+const translator$t = NodeTranslator.from(config$d);
+const XML_NODE_NAME$d = "w:drawing";
+const SD_NODE_NAME$a = [];
+const validXmlAttributes$8 = [];
+function encode$j(params) {
   const nodes = params.nodes;
   const node = nodes[0];
   const translatorByChildName = {
-    "wp:anchor": translator$t,
-    "wp:inline": translator$s
+    "wp:anchor": translator$u,
+    "wp:inline": translator$t
   };
   return node.elements.reduce((acc, child) => {
     if (acc) return acc;
@@ -29259,12 +29259,12 @@ function encode$i(params) {
     return translator2.encode({ ...params, extraParams: { node: child } }) || acc;
   }, null);
 }
-function decode$k(params) {
+function decode$l(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
   }
-  const childTranslator = node.attrs.isAnchor ? translator$t : translator$s;
+  const childTranslator = node.attrs.isAnchor ? translator$u : translator$t;
   const resultNode = childTranslator.decode(params);
   return wrapTextInRun(
     {
@@ -29274,15 +29274,15 @@ function decode$k(params) {
     []
   );
 }
-const config$b = {
-  xmlName: XML_NODE_NAME$c,
-  sdNodeOrKeyName: SD_NODE_NAME$9,
+const config$c = {
+  xmlName: XML_NODE_NAME$d,
+  sdNodeOrKeyName: SD_NODE_NAME$a,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$i,
-  decode: decode$k,
-  attributes: validXmlAttributes$7
+  encode: encode$j,
+  decode: decode$l,
+  attributes: validXmlAttributes$8
 };
-const translator$r = NodeTranslator.from(config$b);
+const translator$s = NodeTranslator.from(config$c);
 class CommandService {
   /**
    * @param {import('./commands/types/index.js').CommandServiceOptions} props
@@ -30630,7 +30630,7 @@ function prepareTextAnnotation(params) {
   return getTextNodeForExport(attrs.displayLabel, [...marks, ...marksFromAttrs], params);
 }
 function prepareImageAnnotation(params, imageSize) {
-  return translator$r.decode({
+  return translator$s.decode({
     ...params,
     imageSize
   });
@@ -30954,10 +30954,10 @@ function generateSdtPrTagForStructuredContent({ node }) {
   };
   return result;
 }
-const XML_NODE_NAME$b = "w:sdt";
-const SD_NODE_NAME$8 = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
-const validXmlAttributes$6 = [];
-function encode$h(params) {
+const XML_NODE_NAME$c = "w:sdt";
+const SD_NODE_NAME$9 = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
+const validXmlAttributes$7 = [];
+function encode$i(params) {
   const nodes = params.nodes;
   const node = nodes[0];
   const { type: sdtType, handler: handler2 } = sdtNodeTypeStrategy(node);
@@ -30967,7 +30967,7 @@ function encode$h(params) {
   const result = handler2(params);
   return result;
 }
-function decode$j(params) {
+function decode$k(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
@@ -30985,15 +30985,15 @@ function decode$j(params) {
   const result = decoder();
   return result;
 }
-const config$a = {
-  xmlName: XML_NODE_NAME$b,
-  sdNodeOrKeyName: SD_NODE_NAME$8,
+const config$b = {
+  xmlName: XML_NODE_NAME$c,
+  sdNodeOrKeyName: SD_NODE_NAME$9,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$h,
-  decode: decode$j,
-  attributes: validXmlAttributes$6
+  encode: encode$i,
+  decode: decode$k,
+  attributes: validXmlAttributes$7
 };
-const translator$q = NodeTranslator.from(config$a);
+const translator$r = NodeTranslator.from(config$b);
 function preProcessVerticalMergeCells(table, { editorSchema }) {
   if (!table || !Array.isArray(table.content)) {
     return table;
@@ -31034,17 +31034,17 @@ function preProcessVerticalMergeCells(table, { editorSchema }) {
   }
   return table;
 }
-const translator$p = NodeTranslator.from({
+const translator$q = 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$o = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblCaption", "caption"));
-const translator$n = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblDescription", "description"));
-const translator$m = NodeTranslator.from(createMeasurementPropertyHandler("w:tblInd", "tableIndent"));
-const translator$l = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblLayout", "tableLayout", "w:type"));
-const translator$k = NodeTranslator.from({
+const translator$p = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblCaption", "caption"));
+const translator$o = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblDescription", "description"));
+const translator$n = NodeTranslator.from(createMeasurementPropertyHandler("w:tblInd", "tableIndent"));
+const translator$m = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblLayout", "tableLayout", "w:type"));
+const translator$l = 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")]),
@@ -31056,16 +31056,16 @@ const translator$k = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$j = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblOverlap", "overlap"));
-const translator$i = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblStyle", "tableStyleId"));
-const translator$h = NodeTranslator.from(
+const translator$k = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblOverlap", "overlap"));
+const translator$j = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblStyle", "tableStyleId"));
+const translator$i = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:tblStyleColBandSize", "tableStyleColBandSize")
 );
-const translator$g = NodeTranslator.from(
+const translator$h = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:tblStyleRowBandSize", "tableStyleRowBandSize")
 );
-const translator$f = NodeTranslator.from(createMeasurementPropertyHandler("w:tblW", "tableWidth"));
-const translator$e = NodeTranslator.from({
+const translator$g = NodeTranslator.from(createMeasurementPropertyHandler("w:tblW", "tableWidth"));
+const translator$f = 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))),
@@ -31078,35 +31078,36 @@ const translator$e = NodeTranslator.from({
   }
 });
 const propertyTranslators$2 = [
-  translator$15,
-  translator$13,
+  translator$16,
+  translator$14,
+  translator$12,
   translator$11,
   translator$10,
+  translator$_,
+  translator$Y,
+  translator$W
+];
+const translator$e = NodeTranslator.from(
+  createNestedPropertiesTranslator("w:tblBorders", "borders", propertyTranslators$2)
+);
+const propertyTranslators$1 = [
+  translator$15,
+  translator$13,
   translator$$,
   translator$Z,
   translator$X,
   translator$V
 ];
 const translator$d = NodeTranslator.from(
-  createNestedPropertiesTranslator("w:tblBorders", "borders", propertyTranslators$2)
-);
-const propertyTranslators$1 = [
-  translator$14,
-  translator$12,
-  translator$_,
-  translator$Y,
-  translator$W,
-  translator$U
-];
-const translator$c = NodeTranslator.from(
-  createNestedPropertiesTranslator("w:tblCellMar", "cellMargins", propertyTranslators$1)
+  createNestedPropertiesTranslator("w:tblCellMar", "cellMargins", propertyTranslators$1)
 );
 const propertyTranslators = [
+  translator$q,
+  translator$C,
+  translator$1a,
   translator$p,
   translator$B,
-  translator$19,
   translator$o,
-  translator$A,
   translator$n,
   translator$m,
   translator$l,
@@ -31117,13 +31118,12 @@ const propertyTranslators = [
   translator$g,
   translator$f,
   translator$e,
-  translator$d,
-  translator$c
+  translator$d
 ];
-const translator$b = NodeTranslator.from(
+const translator$c = NodeTranslator.from(
   createNestedPropertiesTranslator("w:tblPr", "tableProperties", propertyTranslators)
 );
-const translator$a = NodeTranslator.from(
+const translator$b = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:gridCol", "col", "w:w", parseInteger, integerToString)
 );
 const DEFAULT_COLUMN_WIDTH_PX = 100;
@@ -31173,20 +31173,20 @@ const resolveFallbackColumnWidthTwips = (params, totalColumns, cellMinWidthTwips
   }
   return Math.max(fallbackWidthTwips, cellMinWidthTwips);
 };
-const XML_NODE_NAME$a = "w:tblGrid";
+const XML_NODE_NAME$b = "w:tblGrid";
 const SD_ATTR_KEY$2 = "grid";
 const cellMinWidth = pixelsToTwips(10);
-const encode$g = (params) => {
+const encode$h = (params) => {
   const { nodes } = params;
   const node = nodes[0];
-  const attributes = encodeProperties(node, { [translator$a.xmlName]: translator$a }, true);
+  const attributes = encodeProperties(node, { [translator$b.xmlName]: translator$b }, true);
   return {
-    xmlName: XML_NODE_NAME$a,
+    xmlName: XML_NODE_NAME$b,
     sdNodeOrKeyName: SD_ATTR_KEY$2,
     attributes
   };
 };
-const decode$i = (params) => {
+const decode$j = (params) => {
   const { grid: rawGrid } = params.node.attrs || {};
   const grid = Array.isArray(rawGrid) ? rawGrid : [];
   const { firstRow = {} } = params.extraParams || {};
@@ -31209,10 +31209,10 @@ const decode$i = (params) => {
     const roundedWidth = Math.round(numericWidth);
     const minimumWidth = shouldEnforceMinimum ? cellMinWidth : 1;
     const safeWidth = Math.max(roundedWidth, minimumWidth);
-    const decoded = translator$a.decode({
+    const decoded = translator$b.decode({
       node: { type: (
         /** @type {string} */
-        translator$a.sdNodeOrKeyName
+        translator$b.sdNodeOrKeyName
       ), attrs: { col: safeWidth } }
     });
     if (decoded) elements.push(decoded);
@@ -31252,19 +31252,19 @@ const decode$i = (params) => {
     columnIndex++;
   }
   const newNode = {
-    name: XML_NODE_NAME$a,
+    name: XML_NODE_NAME$b,
     attributes: {},
     elements
   };
   return newNode;
 };
-const config$9 = {
-  xmlName: XML_NODE_NAME$a,
+const config$a = {
+  xmlName: XML_NODE_NAME$b,
   sdNodeOrKeyName: SD_ATTR_KEY$2,
-  encode: encode$g,
-  decode: decode$i
+  encode: encode$h,
+  decode: decode$j
 };
-const translator$9 = NodeTranslator.from(config$9);
+const translator$a = NodeTranslator.from(config$a);
 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;
@@ -31327,19 +31327,19 @@ const buildFallbackGridForTable = ({ params, rows, tableWidth, tableWidthMeasure
     columnWidths: Array(columnCount).fill(fallbackColumnWidthPx)
   };
 };
-const XML_NODE_NAME$9 = "w:tbl";
-const SD_NODE_NAME$7 = "table";
-const encode$f = (params, encodedAttrs) => {
+const XML_NODE_NAME$a = "w:tbl";
+const SD_NODE_NAME$8 = "table";
+const encode$g = (params, encodedAttrs) => {
   const { nodes } = params;
   const node = nodes[0];
   const tblPr = node.elements.find((el) => el.name === "w:tblPr");
   if (tblPr) {
-    const encodedProperties = translator$b.encode({ ...params, nodes: [tblPr] });
+    const encodedProperties = translator$c.encode({ ...params, nodes: [tblPr] });
     encodedAttrs["tableProperties"] = encodedProperties || {};
   }
   const tblGrid = node.elements.find((el) => el.name === "w:tblGrid");
   if (tblGrid) {
-    encodedAttrs["grid"] = translator$9.encode({ ...params, nodes: [tblGrid] }).attributes;
+    encodedAttrs["grid"] = translator$a.encode({ ...params, nodes: [tblGrid] }).attributes;
   }
   [
     "tableStyleId",
@@ -31407,7 +31407,7 @@ const encode$f = (params, encodedAttrs) => {
   const totalColumns = columnWidths.length;
   const activeRowSpans = totalColumns > 0 ? new Array(totalColumns).fill(0) : [];
   rows.forEach((row, rowIndex) => {
-    const result = translator$u.encode({
+    const result = translator$v.encode({
       ...params,
       nodes: [row],
       extraParams: {
@@ -31461,13 +31461,13 @@ const encode$f = (params, encodedAttrs) => {
     attrs: encodedAttrs
   };
 };
-const decode$h = (params, decodedAttrs) => {
+const decode$i = (params, decodedAttrs) => {
   params.node = preProcessVerticalMergeCells(params.node, params);
   const { node } = params;
   const elements = translateChildNodes(params);
   const firstRow = node.content?.find((n) => n.type === "tableRow");
   const properties = node.attrs.grid;
-  const element = translator$9.decode({
+  const element = translator$a.decode({
     ...params,
     node: { ...node, attrs: { ...node.attrs, grid: properties } },
     extraParams: {
@@ -31477,7 +31477,7 @@ const decode$h = (params, decodedAttrs) => {
   if (element) elements.unshift(element);
   if (node.attrs?.tableProperties) {
     const properties2 = { ...node.attrs.tableProperties };
-    const element2 = translator$b.decode({
+    const element2 = translator$c.decode({
       ...params,
       node: { ...node, attrs: { ...node.attrs, tableProperties: properties2 } }
     });
@@ -31543,7 +31543,7 @@ function _getReferencedTableStyles(tableStyleReference, params) {
     if (baseTblPr && baseTblPr.elements) {
       tblPr.elements.push(...baseTblPr.elements);
     }
-    const tableProperties = translator$b.encode({ ...params, nodes: [tblPr] });
+    const tableProperties = translator$c.encode({ ...params, nodes: [tblPr] });
     if (tableProperties) {
       const { borders, rowBorders } = _processTableBorders(tableProperties.borders || {});
       if (borders) stylesToReturn.borders = borders;
@@ -31562,85 +31562,85 @@ function _getReferencedTableStyles(tableStyleReference, params) {
   }
   return stylesToReturn;
 }
-const config$8 = {
-  xmlName: XML_NODE_NAME$9,
-  sdNodeOrKeyName: SD_NODE_NAME$7,
+const config$9 = {
+  xmlName: XML_NODE_NAME$a,
+  sdNodeOrKeyName: SD_NODE_NAME$8,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$f,
-  decode: decode$h,
+  encode: encode$g,
+  decode: decode$i,
   attributes: []
 };
-const translator$8 = NodeTranslator.from(config$8);
-const encode$e = (attributes) => {
+const translator$9 = NodeTranslator.from(config$9);
+const encode$f = (attributes) => {
   return attributes["w:id"];
 };
-const decode$g = (attrs) => {
+const decode$h = (attrs) => {
   return attrs.id;
 };
 const attrConfig$7 = Object.freeze({
   xmlName: "w:id",
   sdName: "id",
-  encode: encode$e,
-  decode: decode$g
+  encode: encode$f,
+  decode: decode$h
 });
-const encode$d = (attributes) => {
+const encode$e = (attributes) => {
   return attributes["w:name"];
 };
-const decode$f = (attrs) => {
+const decode$g = (attrs) => {
   return attrs.name;
 };
 const attrConfig$6 = Object.freeze({
   xmlName: "w:name",
   sdName: "name",
-  encode: encode$d,
-  decode: decode$f
+  encode: encode$e,
+  decode: decode$g
 });
-const encode$c = (attributes) => {
+const encode$d = (attributes) => {
   return attributes["w:colFirst"];
 };
-const decode$e = (attrs) => {
+const decode$f = (attrs) => {
   return attrs.colFirst;
 };
 const attrConfig$5 = Object.freeze({
   xmlName: "w:colFirst",
   sdName: "colFirst",
-  encode: encode$c,
-  decode: decode$e
+  encode: encode$d,
+  decode: decode$f
 });
-const encode$b = (attributes) => {
+const encode$c = (attributes) => {
   return attributes["w:colLast"];
 };
-const decode$d = (attrs) => {
+const decode$e = (attrs) => {
   return attrs.colLast;
 };
 const attrConfig$4 = Object.freeze({
   xmlName: "w:colLast",
   sdName: "colLast",
-  encode: encode$b,
-  decode: decode$d
+  encode: encode$c,
+  decode: decode$e
 });
-const encode$a = (attributes) => {
+const encode$b = (attributes) => {
   return attributes["w:displacedByCustomXml"];
 };
-const decode$c = (attrs) => {
+const decode$d = (attrs) => {
   return attrs.displacedByCustomXml;
 };
 const attrConfig$3 = Object.freeze({
   xmlName: "w:displacedByCustomXml",
   sdName: "displacedByCustomXml",
-  encode: encode$a,
-  decode: decode$c
+  encode: encode$b,
+  decode: decode$d
 });
-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$9 = (params, encodedAttrs = {}) => {
+const validXmlAttributes$6 = [attrConfig$7, attrConfig$6, attrConfig$5, attrConfig$4, attrConfig$3];
+const XML_NODE_NAME$9 = "w:bookmarkStart";
+const SD_NODE_NAME$7 = "bookmarkStart";
+const encode$a = (params, encodedAttrs = {}) => {
   return {
     type: "bookmarkStart",
     attrs: encodedAttrs
   };
 };
-const decode$b = (params, decodedAttrs = {}) => {
+const decode$c = (params, decodedAttrs = {}) => {
   const result = {
     name: "w:bookmarkStart",
     elements: []
@@ -31650,49 +31650,49 @@ const decode$b = (params, decodedAttrs = {}) => {
   }
   return result;
 };
-const config$7 = {
-  xmlName: XML_NODE_NAME$8,
-  sdNodeOrKeyName: SD_NODE_NAME$6,
+const config$8 = {
+  xmlName: XML_NODE_NAME$9,
+  sdNodeOrKeyName: SD_NODE_NAME$7,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$9,
-  decode: decode$b,
-  attributes: validXmlAttributes$5
+  encode: encode$a,
+  decode: decode$c,
+  attributes: validXmlAttributes$6
 };
-const translator$7 = NodeTranslator.from(config$7);
-const encode$8 = (attributes) => {
+const translator$8 = NodeTranslator.from(config$8);
+const encode$9 = (attributes) => {
   return attributes["w:id"];
 };
-const decode$a = (attrs) => {
+const decode$b = (attrs) => {
   return attrs.id;
 };
 const attrConfig$2 = Object.freeze({
   xmlName: "w:id",
   sdName: "id",
-  encode: encode$8,
-  decode: decode$a
+  encode: encode$9,
+  decode: decode$b
 });
-const encode$7 = (attributes) => {
+const encode$8 = (attributes) => {
   return attributes["w:displacedByCustomXml"];
 };
-const decode$9 = (attrs) => {
+const decode$a = (attrs) => {
   return attrs.displacedByCustomXml;
 };
 const attrConfig$1 = Object.freeze({
   xmlName: "w:displacedByCustomXml",
   sdName: "displacedByCustomXml",
-  encode: encode$7,
-  decode: decode$9
+  encode: encode$8,
+  decode: decode$a
 });
-const validXmlAttributes$4 = [attrConfig$2, attrConfig$1];
-const XML_NODE_NAME$7 = "w:bookmarkEnd";
-const SD_NODE_NAME$5 = "bookmarkEnd";
-const encode$6 = (params, encodedAttrs = {}) => {
+const validXmlAttributes$5 = [attrConfig$2, attrConfig$1];
+const XML_NODE_NAME$8 = "w:bookmarkEnd";
+const SD_NODE_NAME$6 = "bookmarkEnd";
+const encode$7 = (params, encodedAttrs = {}) => {
   return {
     type: "bookmarkEnd",
     attrs: encodedAttrs
   };
 };
-const decode$8 = (params, decodedAttrs = {}) => {
+const decode$9 = (params, decodedAttrs = {}) => {
   const result = {
     name: "w:bookmarkEnd",
     elements: []
@@ -31702,27 +31702,27 @@ const decode$8 = (params, decodedAttrs = {}) => {
   }
   return result;
 };
-const config$6 = {
-  xmlName: XML_NODE_NAME$7,
-  sdNodeOrKeyName: SD_NODE_NAME$5,
+const config$7 = {
+  xmlName: XML_NODE_NAME$8,
+  sdNodeOrKeyName: SD_NODE_NAME$6,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$6,
-  decode: decode$8,
-  attributes: validXmlAttributes$4
+  encode: encode$7,
+  decode: decode$9,
+  attributes: validXmlAttributes$5
 };
-const translator$6 = NodeTranslator.from(config$6);
-const decode$7 = (attrs) => attrs?.["w:id"];
+const translator$7 = NodeTranslator.from(config$7);
+const decode$8 = (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$7
+  decode: decode$8
 });
-const XML_NODE_NAME$6 = "w:commentRange";
-const SD_NODE_NAME$4 = "commentRange";
-const decode$6 = (params) => {
+const XML_NODE_NAME$7 = "w:commentRange";
+const SD_NODE_NAME$5 = "commentRange";
+const decode$7 = (params) => {
   const { node, comments, commentsExportType, exportedCommentDefs } = params;
   if (!node) return;
   if (!comments) return;
@@ -31765,19 +31765,19 @@ const getCommentSchema = (type2, commentIndex) => {
   };
 };
 const getConfig = (type2) => ({
-  xmlName: `${XML_NODE_NAME$6}${type2}`,
-  sdNodeOrKeyName: `${SD_NODE_NAME$4}${type2}`,
+  xmlName: `${XML_NODE_NAME$7}${type2}`,
+  sdNodeOrKeyName: `${SD_NODE_NAME$5}${type2}`,
   type: NodeTranslator.translatorTypes.NODE,
   encode: () => {
   },
-  decode: decode$6,
+  decode: decode$7,
   attributes: [attrConfig]
 });
 const commentRangeStartTranslator = NodeTranslator.from(getConfig("Start"));
 const commentRangeEndTranslator = NodeTranslator.from(getConfig("End"));
-const XML_NODE_NAME$5 = "sd:pageReference";
-const SD_NODE_NAME$3 = "pageReference";
-const encode$5 = (params) => {
+const XML_NODE_NAME$6 = "sd:pageReference";
+const SD_NODE_NAME$4 = "pageReference";
+const encode$6 = (params) => {
   const { nodes = [], nodeListHandler } = params || {};
   const node = nodes[0];
   const processedText = nodeListHandler.handler({
@@ -31794,7 +31794,7 @@ const encode$5 = (params) => {
   };
   return processedNode;
 };
-const decode$5 = (params) => {
+const decode$6 = (params) => {
   const { node } = params;
   const outputMarks = processOutputMarks(node.attrs?.marksAsAttrs || []);
   const contentNodes = (node.content ?? []).flatMap((n) => exportSchemaToJson({ ...params, node: n }));
@@ -31867,17 +31867,17 @@ const decode$5 = (params) => {
   ];
   return translated;
 };
-const config$5 = {
-  xmlName: XML_NODE_NAME$5,
-  sdNodeOrKeyName: SD_NODE_NAME$3,
+const config$6 = {
+  xmlName: XML_NODE_NAME$6,
+  sdNodeOrKeyName: SD_NODE_NAME$4,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$5,
-  decode: decode$5
+  encode: encode$6,
+  decode: decode$6
 };
-const translator$5 = NodeTranslator.from(config$5);
-const XML_NODE_NAME$4 = "sd:tableOfContents";
-const SD_NODE_NAME$2 = "tableOfContents";
-const encode$4 = (params) => {
+const translator$6 = NodeTranslator.from(config$6);
+const XML_NODE_NAME$5 = "sd:tableOfContents";
+const SD_NODE_NAME$3 = "tableOfContents";
+const encode$5 = (params) => {
   const { nodes = [], nodeListHandler } = params || {};
   const node = nodes[0];
   const processedContent = nodeListHandler.handler({
@@ -31893,7 +31893,7 @@ const encode$4 = (params) => {
   };
   return processedNode;
 };
-const decode$4 = (params) => {
+const decode$5 = (params) => {
   const { node } = params;
   const contentNodes = node.content.map((n) => exportSchemaToJson({ ...params, node: n }));
   const tocBeginElements = [
@@ -31940,14 +31940,14 @@ const decode$4 = (params) => {
   }
   return contentNodes;
 };
-const config$4 = {
-  xmlName: XML_NODE_NAME$4,
-  sdNodeOrKeyName: SD_NODE_NAME$2,
+const config$5 = {
+  xmlName: XML_NODE_NAME$5,
+  sdNodeOrKeyName: SD_NODE_NAME$3,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$4,
-  decode: decode$4
+  encode: encode$5,
+  decode: decode$5
 };
-const translator$4 = NodeTranslator.from(config$4);
+const translator$5 = NodeTranslator.from(config$5);
 function parseInlineStyles(styleString) {
   if (!styleString) return {};
   return styleString.split(";").filter((style) => !!style.trim()).reduce((acc, style) => {
@@ -32083,7 +32083,7 @@ const handleDrawingNode = (params) => {
   if (mainNode.name === "w:drawing") node = mainNode;
   else node = mainNode.elements.find((el) => el.name === "w:drawing");
   if (!node) return { nodes: [], consumed: 0 };
-  const schemaNode = translator$r.encode(params);
+  const schemaNode = translator$s.encode(params);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -32108,15 +32108,15 @@ const createTrackStyleMark = (marks) => {
   }
   return void 0;
 };
-const XML_NODE_NAME$3 = "w:del";
+const XML_NODE_NAME$4 = "w:del";
 const SD_ATTR_KEY$1 = "trackDelete";
-const validXmlAttributes$3 = [
+const validXmlAttributes$4 = [
   createAttributeHandler("w:id", "id"),
   createAttributeHandler("w:date", "date"),
   createAttributeHandler("w:author", "author"),
   createAttributeHandler("w:authorEmail", "authorEmail")
 ];
-const encode$3 = (params, encodedAttrs = {}) => {
+const encode$4 = (params, encodedAttrs = {}) => {
   const { nodeListHandler, extraParams = {} } = params;
   const { node } = extraParams;
   const subs = nodeListHandler.handler({
@@ -32132,7 +32132,7 @@ const encode$3 = (params, encodedAttrs = {}) => {
   });
   return subs;
 };
-function decode$3(params) {
+function decode$4(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
@@ -32159,24 +32159,24 @@ function decode$3(params) {
     elements: [translatedTextNode]
   };
 }
-const config$3 = {
-  xmlName: XML_NODE_NAME$3,
+const config$4 = {
+  xmlName: XML_NODE_NAME$4,
   sdNodeOrKeyName: SD_ATTR_KEY$1,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$3,
-  decode: decode$3,
-  attributes: validXmlAttributes$3
+  encode: encode$4,
+  decode: decode$4,
+  attributes: validXmlAttributes$4
 };
-const translator$3 = NodeTranslator.from(config$3);
-const XML_NODE_NAME$2 = "w:ins";
+const translator$4 = NodeTranslator.from(config$4);
+const XML_NODE_NAME$3 = "w:ins";
 const SD_ATTR_KEY = "trackInsert";
-const validXmlAttributes$2 = [
+const validXmlAttributes$3 = [
   createAttributeHandler("w:id", "id"),
   createAttributeHandler("w:date", "date"),
   createAttributeHandler("w:author", "author"),
   createAttributeHandler("w:authorEmail", "authorEmail")
 ];
-const encode$2 = (params, encodedAttrs = {}) => {
+const encode$3 = (params, encodedAttrs = {}) => {
   const { nodeListHandler, extraParams = {} } = params;
   const { node } = extraParams;
   const subs = nodeListHandler.handler({
@@ -32192,7 +32192,7 @@ const encode$2 = (params, encodedAttrs = {}) => {
   });
   return subs;
 };
-function decode$2(params) {
+function decode$3(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
@@ -32217,15 +32217,15 @@ function decode$2(params) {
     elements: [translatedTextNode]
   };
 }
-const config$2 = {
-  xmlName: XML_NODE_NAME$2,
+const config$3 = {
+  xmlName: XML_NODE_NAME$3,
   sdNodeOrKeyName: SD_ATTR_KEY,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$2,
-  decode: decode$2,
-  attributes: validXmlAttributes$2
+  encode: encode$3,
+  decode: decode$3,
+  attributes: validXmlAttributes$3
 };
-const translator$2 = NodeTranslator.from(config$2);
+const translator$3 = NodeTranslator.from(config$3);
 const isTrackChangeElement = (node) => node?.name === "w:del" || node?.name === "w:ins";
 const unwrapTrackChangeNode = (node) => {
   if (!node) {
@@ -32264,7 +32264,7 @@ const handleTrackChangeNode = (params) => {
   };
   switch (mainNode.name) {
     case "w:del":
-      result = translator$3.encode({
+      result = translator$4.encode({
         extraParams: {
           node: mainNode
         },
@@ -32272,7 +32272,7 @@ const handleTrackChangeNode = (params) => {
       });
       break;
     case "w:ins":
-      result = translator$2.encode({
+      result = translator$3.encode({
         extraParams: {
           node: mainNode
         },
@@ -32286,8 +32286,118 @@ const trackChangeNodeHandlerEntity = {
   handlerName: "trackChangeNodeHandler",
   handler: handleTrackChangeNode
 };
-const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$1c);
-const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$1b);
+const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$1d);
+const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$1c);
+const XML_NODE_NAME$2 = "w:t";
+const SD_NODE_NAME$2 = "text";
+const validXmlAttributes$2 = [createAttributeHandler("xml:space", "xmlSpace")];
+const encode$2 = (params, encodedAttrs = {}) => {
+  const { node } = params.extraParams;
+  const { elements, type: type2, attributes } = node;
+  let text;
+  if (elements.length === 1) {
+    text = elements[0].text;
+    const xmlSpace = encodedAttrs.xmlSpace ?? elements[0]?.attributes?.["xml:space"];
+    if (xmlSpace !== "preserve" && typeof text === "string") {
+      text = text.replace(/^\s+/, "").replace(/\s+$/, "");
+    }
+    text = text.replace(/\[\[sdspace\]\]/g, "");
+  } else if (!elements.length && encodedAttrs.xmlSpace === "preserve") {
+    text = " ";
+  } else return null;
+  return {
+    type: "text",
+    text,
+    attrs: { type: type2, attributes: attributes || {} },
+    marks: []
+  };
+};
+const decode$2 = (params, decodedAttrs = {}) => {
+  const { node, extraParams } = params;
+  if (!node || !node.type) {
+    return null;
+  }
+  const trackedMarks = ["trackDelete", "trackInsert"];
+  const trackedMark = node.marks?.find((m2) => trackedMarks.includes(m2.type));
+  if (trackedMark) {
+    switch (trackedMark.type) {
+      case "trackDelete":
+        return translator$4.decode(params);
+      case "trackInsert":
+        return translator$3.decode(params);
+    }
+  }
+  const isLinkNode = node.marks?.some((m2) => m2.type === "link");
+  if (isLinkNode && !extraParams?.linkProcessed) {
+    return translator$1d.decode(params);
+  }
+  const { text, marks = [] } = node;
+  return getTextNodeForExport(text, marks, params);
+};
+const config$2 = {
+  xmlName: XML_NODE_NAME$2,
+  sdNodeOrKeyName: SD_NODE_NAME$2,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$2,
+  decode: decode$2,
+  attributes: validXmlAttributes$2
+};
+const translator$2 = NodeTranslator.from(config$2);
+const handleTextNode = (params) => {
+  const { nodes, insideTrackChange } = params;
+  if (nodes.length === 0 || !(nodes[0].name === "w:t" || insideTrackChange && nodes[0].name === "w:delText")) {
+    return { nodes: [], consumed: 0 };
+  }
+  const node = nodes[0];
+  const resultNode = translator$2.encode({
+    ...params,
+    extraParams: {
+      ...params.extraParams || {},
+      node
+    }
+  });
+  if (!resultNode) return { nodes: [], consumed: 0 };
+  return {
+    nodes: [resultNode],
+    consumed: 1
+  };
+};
+const textNodeHandlerEntity = {
+  handlerName: "textNodeHandler",
+  handler: handleTextNode
+};
+const handleParagraphNode = (params) => {
+  const { nodes } = params;
+  if (nodes.length === 0 || nodes[0].name !== "w:p") {
+    return { nodes: [], consumed: 0 };
+  }
+  const schemaNode = translator$1p.encode(params);
+  const newNodes = schemaNode ? [schemaNode] : [];
+  return { nodes: newNodes, consumed: 1 };
+};
+const paragraphNodeHandlerEntity = {
+  handlerName: "paragraphNodeHandler",
+  handler: handleParagraphNode
+};
+const handleSdtNode = (params) => {
+  const { nodes } = params;
+  if (nodes.length === 0 || nodes[0].name !== "w:sdt") {
+    return { nodes: [], consumed: 0 };
+  }
+  const result = translator$r.encode(params);
+  if (!result) {
+    return { nodes: [], consumed: 0 };
+  }
+  const resultNodes = Array.isArray(result) ? result : [result];
+  return {
+    nodes: resultNodes,
+    consumed: 1
+  };
+};
+const sdtNodeHandlerEntity = {
+  handlerName: "sdtNodeHandler",
+  handler: handleSdtNode
+};
 function parseProperties(node) {
   const marks = [];
   const unknownMarks = [];
@@ -32339,73 +32449,6 @@ function getElementName(element) {
 const isPropertiesElement = (element) => {
   return !!SuperConverter.propertyTypes[element.name || element.type];
 };
-const handleTextNode = (params) => {
-  const { nodes, insideTrackChange } = params;
-  if (nodes.length === 0 || !(nodes[0].name === "w:t" || insideTrackChange && nodes[0].name === "w:delText")) {
-    return { nodes: [], consumed: 0 };
-  }
-  const node = nodes[0];
-  const { type: type2 } = node;
-  const { attributes, elements, marks = [] } = parseProperties(node);
-  let text;
-  if (elements.length === 1) {
-    text = elements[0].text;
-    const xmlSpace = node.attributes?.["xml:space"] ?? elements[0]?.attributes?.["xml:space"];
-    if (xmlSpace !== "preserve" && typeof text === "string") {
-      text = text.replace(/^\s+/, "").replace(/\s+$/, "");
-    }
-    text = text.replace(/\[\[sdspace\]\]/g, "");
-  } else if (!elements.length && "attributes" in node && node.attributes["xml:space"] === "preserve") {
-    text = " ";
-  } else return { nodes: [], consumed: 0 };
-  return {
-    nodes: [
-      {
-        type: getElementName(node),
-        text,
-        attrs: { type: type2, attributes: attributes || {} },
-        marks
-      }
-    ],
-    consumed: 1
-  };
-};
-const textNodeHandlerEntity = {
-  handlerName: "textNodeHandler",
-  handler: handleTextNode
-};
-const handleParagraphNode = (params) => {
-  const { nodes } = params;
-  if (nodes.length === 0 || nodes[0].name !== "w:p") {
-    return { nodes: [], consumed: 0 };
-  }
-  const schemaNode = translator$1o.encode(params);
-  const newNodes = schemaNode ? [schemaNode] : [];
-  return { nodes: newNodes, consumed: 1 };
-};
-const paragraphNodeHandlerEntity = {
-  handlerName: "paragraphNodeHandler",
-  handler: handleParagraphNode
-};
-const handleSdtNode = (params) => {
-  const { nodes } = params;
-  if (nodes.length === 0 || nodes[0].name !== "w:sdt") {
-    return { nodes: [], consumed: 0 };
-  }
-  const result = translator$q.encode(params);
-  if (!result) {
-    return { nodes: [], consumed: 0 };
-  }
-  const resultNodes = Array.isArray(result) ? result : [result];
-  return {
-    nodes: resultNodes,
-    consumed: 1
-  };
-};
-const sdtNodeHandlerEntity = {
-  handlerName: "sdtNodeHandler",
-  handler: handleSdtNode
-};
 const handleStandardNode = (params) => {
   const { nodes, docx, nodeListHandler } = params;
   if (!nodes || nodes.length === 0) {
@@ -32482,7 +32525,7 @@ const handler = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$1r.encode(params);
+  const result = translator$1s.encode(params);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -32554,7 +32597,7 @@ const handleBookmarkStartNode = (params) => {
   if (isCustomMarkBookmark(nodes[0], params.editor)) {
     return handleBookmarkNode(params);
   }
-  const node = translator$7.encode(params);
+  const node = translator$8.encode(params);
   if (!node) return { nodes: [], consumed: 0 };
   return { nodes: [node], consumed: 1 };
 };
@@ -32586,7 +32629,7 @@ const handleBookmarkEndNode = (params) => {
   if (!nodes.length || nodes[0].name !== "w:bookmarkEnd") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$6.encode(params);
+  const node = translator$7.encode(params);
   if (!node) return { nodes: [], consumed: 0 };
   return { nodes: [node], consumed: 1 };
 };
@@ -32785,7 +32828,7 @@ const autoTotalPageCountEntity = {
   handlerName: "autoTotalPageCountEntity",
   handler: handleAutoTotalPageNumber
 };
-const pageReferenceEntity = generateV2HandlerEntity("pageReferenceNodeHandler", translator$5);
+const pageReferenceEntity = generateV2HandlerEntity("pageReferenceNodeHandler", translator$6);
 const handlePictNode = (params) => {
   const { nodes } = params;
   if (!nodes.length || nodes[0].name !== "w:p") {
@@ -33179,15 +33222,15 @@ const handleTabNode = (params) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$1p.encode(params);
+  const node = translator$1q.encode(params);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
   handlerName: "w:tabTranslator",
   handler: handleTabNode
 };
-const tableNodeHandlerEntity = generateV2HandlerEntity("tableNodeHandler", translator$8);
-const tableOfContentsHandlerEntity = generateV2HandlerEntity("tableOfContentsHandler", translator$4);
+const tableNodeHandlerEntity = generateV2HandlerEntity("tableNodeHandler", translator$9);
+const tableOfContentsHandlerEntity = generateV2HandlerEntity("tableOfContentsHandler", translator$5);
 function preProcessPageInstruction(nodesToCombine) {
   const pageNumNode = {
     name: "sd:autoPageNumber",
@@ -34230,21 +34273,21 @@ function exportSchemaToJson(params) {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$1o,
-    run: translator$1b,
-    text: translateTextNode,
+    paragraph: translator$1p,
+    run: translator$1c,
+    text: translator$2,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$1r,
-    table: translator$8,
-    tableRow: translator$u,
-    tableCell: translator$H,
-    bookmarkStart: translator$7,
-    bookmarkEnd: translator$6,
-    fieldAnnotation: translator$q,
-    tab: translator$1p,
-    image: translator$r,
-    hardBreak: translator$1r,
+    lineBreak: translator$1s,
+    table: translator$9,
+    tableRow: translator$v,
+    tableCell: translator$I,
+    bookmarkStart: translator$8,
+    bookmarkEnd: translator$7,
+    fieldAnnotation: translator$r,
+    tab: translator$1q,
+    image: translator$s,
+    hardBreak: translator$1s,
     commentRangeStart: commentRangeStartTranslator,
     commentRangeEnd: commentRangeEndTranslator,
     commentReference: () => null,
@@ -34252,14 +34295,14 @@ function exportSchemaToJson(params) {
     shapeTextbox: translator,
     contentBlock: translator,
     vectorShape: translateVectorShape,
-    structuredContent: translator$q,
-    structuredContentBlock: translator$q,
-    documentPartObject: translator$q,
-    documentSection: translator$q,
+    structuredContent: translator$r,
+    structuredContentBlock: translator$r,
+    documentPartObject: translator$r,
+    documentSection: translator$r,
     "page-number": translatePageNumberNode,
     "total-page-number": translateTotalPageNumberNode,
-    pageReference: translator$5,
-    tableOfContents: translator$4
+    pageReference: translator$6,
+    tableOfContents: translator$5
   };
   let handler2 = router[type2];
   if (handler2 && "decode" in handler2 && typeof handler2.decode === "function") {
@@ -34592,25 +34635,6 @@ function getTextNodeForExport(text, marks, params) {
   }
   return wrapTextInRun(textNodes, outputMarks);
 }
-function translateTextNode(params) {
-  const { node, extraParams } = params;
-  const trackedMarks = [TrackInsertMarkName, TrackDeleteMarkName];
-  const trackedMark = node.marks?.find((m2) => trackedMarks.includes(m2.type));
-  if (trackedMark) {
-    switch (trackedMark.type) {
-      case "trackDelete":
-        return translator$3.decode(params);
-      case "trackInsert":
-        return translator$2.decode(params);
-    }
-  }
-  const isLinkNode = node.marks?.some((m2) => m2.type === "link");
-  if (isLinkNode && !extraParams?.linkProcessed) {
-    return translator$1c.decode(params);
-  }
-  const { text, marks = [] } = node;
-  return getTextNodeForExport(text, marks, params);
-}
 function wrapTextInRun(nodeOrNodes, marks) {
   let elements = [];
   if (Array.isArray(nodeOrNodes)) elements = nodeOrNodes;
@@ -34866,7 +34890,7 @@ function translateMark(mark) {
       markElement.type = "element";
       break;
     case "underline": {
-      const translated = translator$1l.decode({
+      const translated = translator$1m.decode({
         node: {
           attrs: {
             underlineType: attrs.underlineType ?? attrs.underline ?? null,
@@ -34930,7 +34954,7 @@ function translateMark(mark) {
       break;
     case "highlight": {
       const highlightValue = attrs.color ?? attrs.highlight ?? null;
-      const translated = translator$1q.decode({ node: { attrs: { highlight: highlightValue } } });
+      const translated = translator$1r.decode({ node: { attrs: { highlight: highlightValue } } });
       return translated || {};
     }
     case "link":
@@ -36091,7 +36115,7 @@ export {
   objectIncludes as Z,
   AddMarkStep as _,
   Plugin as a,
-  translator$t as a$,
+  translator$u as a$,
   twipsToLines as a0,
   pixelsToTwips as a1,
   helpers as a2,
@@ -36111,24 +36135,24 @@ export {
   handleClipboardPaste as aG,
   getFileObject as aH,
   runPropertyTranslators as aI,
-  translator$I as aJ,
-  translator$P as aK,
-  translator$R as aL,
-  translator$J as aM,
-  translator$K as aN,
-  translator$S as aO,
-  translator$T as aP,
-  translator$O as aQ,
-  translator$L as aR,
-  translator$18 as aS,
-  translator$N as aT,
-  translator$Q as aU,
-  translator$M as aV,
-  translator$17 as aW,
-  translator$16 as aX,
+  translator$J as aJ,
+  translator$Q as aK,
+  translator$S as aL,
+  translator$K as aM,
+  translator$L as aN,
+  translator$T as aO,
+  translator$U as aP,
+  translator$P as aQ,
+  translator$M as aR,
+  translator$19 as aS,
+  translator$O as aT,
+  translator$R as aU,
+  translator$N as aV,
+  translator$18 as aW,
+  translator$17 as aX,
   commentRangeEndTranslator as aY,
   commentRangeStartTranslator as aZ,
-  translator$s as a_,
+  translator$t as a_,
   hasSomeParentWithClass as aa,
   isActive as ab,
   unflattenListsInHtml as ac,
@@ -36156,70 +36180,70 @@ export {
   inchesToPixels as ay,
   commonjsGlobal as az,
   Slice as b,
-  translator$5 as b$,
-  translator$w as b0,
-  translator$x as b1,
-  translator$1l as b2,
-  translator$v as b3,
-  translator$y as b4,
-  translator$u as b5,
-  translator$V as b6,
-  translator$H as b7,
-  translator$e as b8,
-  translator$f as b9,
-  translator$1i as bA,
-  translator$1b as bB,
-  translator$1o as bC,
-  translator$$ as bD,
-  translator$B as bE,
-  translator$10 as bF,
-  translator$11 as bG,
-  translator$1m as bH,
-  translator$1c as bI,
-  translator$1q as bJ,
-  translator$C as bK,
-  translator$a as bL,
-  translator$D as bM,
-  translator$E as bN,
-  translator$13 as bO,
-  translator$r as bP,
-  translator$F as bQ,
-  translator$1j as bR,
-  translator$1a as bS,
-  translator$G as bT,
-  translator$1r as bU,
-  translator$15 as bV,
-  translator$7 as bW,
-  translator$6 as bX,
-  translator$p as bY,
-  translator$1n as bZ,
-  translator$4 as b_,
-  translator$g as ba,
-  translator$h as bb,
-  translator$i as bc,
-  translator$b as bd,
-  translator$j as be,
-  translator$k as bf,
-  translator$l as bg,
-  translator$m as bh,
-  translator$z as bi,
-  translator$9 as bj,
-  translator$n as bk,
-  translator$A as bl,
-  translator$c as bm,
-  translator$o as bn,
-  translator$d as bo,
-  translator$8 as bp,
-  translator$1p as bq,
-  translator$1f as br,
-  translator$1g as bs,
-  translator$1k as bt,
-  translator$X as bu,
-  translator$19 as bv,
-  translator$q as bw,
-  translator$Z as bx,
-  translator$1h as by,
-  translator$1d as bz,
+  translator$6 as b$,
+  translator$x as b0,
+  translator$y as b1,
+  translator$1m as b2,
+  translator$w as b3,
+  translator$z as b4,
+  translator$v as b5,
+  translator$W as b6,
+  translator$I as b7,
+  translator$f as b8,
+  translator$g as b9,
+  translator$1j as bA,
+  translator$1c as bB,
+  translator$1p as bC,
+  translator$10 as bD,
+  translator$C as bE,
+  translator$11 as bF,
+  translator$12 as bG,
+  translator$1n as bH,
+  translator$1d as bI,
+  translator$1r as bJ,
+  translator$D as bK,
+  translator$b as bL,
+  translator$E as bM,
+  translator$F as bN,
+  translator$14 as bO,
+  translator$s as bP,
+  translator$G as bQ,
+  translator$1k as bR,
+  translator$1b as bS,
+  translator$H as bT,
+  translator$1s as bU,
+  translator$16 as bV,
+  translator$8 as bW,
+  translator$7 as bX,
+  translator$q as bY,
+  translator$1o as bZ,
+  translator$5 as b_,
+  translator$h as ba,
+  translator$i as bb,
+  translator$j as bc,
+  translator$c as bd,
+  translator$k as be,
+  translator$l as bf,
+  translator$m as bg,
+  translator$n as bh,
+  translator$A as bi,
+  translator$a as bj,
+  translator$o as bk,
+  translator$B as bl,
+  translator$d as bm,
+  translator$p as bn,
+  translator$e as bo,
+  translator$9 as bp,
+  translator$1q as bq,
+  translator$1g as br,
+  translator$1h as bs,
+  translator$1l as bt,
+  translator$Y as bu,
+  translator$1a as bv,
+  translator$r as bw,
+  translator$_ as bx,
+  translator$1i as by,
+  translator$1e as bz,
   DOMParser$1 as c,
   translator$1 as c0,
   _sfc_main as c1,