@harbour-enterprises/superdoc 0.22.1 → 0.23.0-next.10

package/dist/super-editor/chunks/{converter-UuZxU-p8.js → converter-ClnqoStR.js}

@@ -5092,6 +5092,19 @@ function requireSafeRegexTest() {
   };
   return safeRegexTest;
 }
+var generatorFunction;
+var hasRequiredGeneratorFunction;
+function requireGeneratorFunction() {
+  if (hasRequiredGeneratorFunction) return generatorFunction;
+  hasRequiredGeneratorFunction = 1;
+  const cached = (
+    /** @type {GeneratorFunctionConstructor} */
+    function* () {
+    }.constructor
+  );
+  generatorFunction = () => cached;
+  return generatorFunction;
+}
 var isGeneratorFunction;
 var hasRequiredIsGeneratorFunction;
 function requireIsGeneratorFunction() {
@@ -5104,16 +5117,7 @@ function requireIsGeneratorFunction() {
   var getProto2 = requireGetProto();
   var toStr = callBound2("Object.prototype.toString");
   var fnToStr = callBound2("Function.prototype.toString");
-  var getGeneratorFunc = function() {
-    if (!hasToStringTag) {
-      return false;
-    }
-    try {
-      return Function("return function*() {}")();
-    } catch (e) {
-    }
-  };
-  var GeneratorFunction;
+  var getGeneratorFunction = /* @__PURE__ */ requireGeneratorFunction();
   isGeneratorFunction = function isGeneratorFunction2(fn) {
     if (typeof fn !== "function") {
       return false;
@@ -5128,14 +5132,8 @@ function requireIsGeneratorFunction() {
     if (!getProto2) {
       return false;
     }
-    if (typeof GeneratorFunction === "undefined") {
-      var generatorFunc = getGeneratorFunc();
-      GeneratorFunction = generatorFunc ? (
-        /** @type {GeneratorFunctionConstructor} */
-        getProto2(generatorFunc)
-      ) : false;
-    }
-    return getProto2(fn) === GeneratorFunction;
+    var GeneratorFunction = getGeneratorFunction();
+    return GeneratorFunction && getProto2(fn) === GeneratorFunction.prototype;
   };
   return isGeneratorFunction;
 }
@@ -22966,13 +22964,56 @@ function translateChildNodes(params) {
   const { content: nodes } = params.node;
   if (!nodes) return [];
   const translatedNodes = [];
-  nodes.forEach((node) => {
+  const hyperlinkGroup = [];
+  let index = 0;
+  while (index < nodes.length) {
+    const node = nodes[index];
+    const linkMark = _isLinkNode(node);
+    if (linkMark) {
+      hyperlinkGroup.push(node);
+      const nextNode = index + 1 < nodes.length ? nodes[index + 1] : null;
+      const nextIsLink = _isLinkNode(nextNode, linkMark);
+      if (nextIsLink) {
+        index++;
+        continue;
+      } else {
+        let translatedLinkGroup = exportSchemaToJson({
+          ...params,
+          node: hyperlinkGroup[0],
+          extraParams: { ...params.extraParams || {}, hyperlinkGroup: hyperlinkGroup.slice() }
+        });
+        if (translatedLinkGroup instanceof Array) translatedNodes.push(...translatedLinkGroup);
+        else translatedNodes.push(translatedLinkGroup);
+        hyperlinkGroup.length = 0;
+        index++;
+        continue;
+      }
+    }
     let translatedNode = exportSchemaToJson({ ...params, node });
     if (translatedNode instanceof Array) translatedNodes.push(...translatedNode);
     else translatedNodes.push(translatedNode);
-  });
+    index++;
+  }
   return translatedNodes.filter((n) => n);
 }
+function _isLinkNode(node, referenceMark = null) {
+  if (!node || !node.marks && !node.attrs?.marksAsAttrs) return null;
+  const marks = node.marks || node.attrs.marksAsAttrs;
+  const linkMark = marks.find((mark) => mark.type === "link");
+  if (!linkMark) return null;
+  if (referenceMark) {
+    return _isSameLinkMark(linkMark.attrs, referenceMark.attrs) ? linkMark : null;
+  }
+  return linkMark;
+}
+function _isSameLinkMark(attrsA, attrsB) {
+  for (let key of ["anchor", "docLocation", "history", "href", "rId", "target"]) {
+    if (attrsA[key] != attrsB[key]) {
+      return false;
+    }
+  }
+  return true;
+}
 const baseNumbering = {
   declaration: {
     attributes: {
@@ -24328,37 +24369,37 @@ const _NodeTranslator = class _NodeTranslator {
 /** @type {typeof TranslatorTypes} */
 __publicField(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$18 = (attributes) => {
+const encode$1b = (attributes) => {
   return attributes["w:type"];
 };
-const decode$$ = (attrs) => {
+const decode$11 = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
 const attrConfig$F = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$18,
-  decode: decode$$
+  encode: encode$1b,
+  decode: decode$11
 });
-const encode$17 = (attributes) => {
+const encode$1a = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$_ = (attrs) => {
+const decode$10 = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
 const attrConfig$E = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$17,
-  decode: decode$_
+  encode: encode$1a,
+  decode: decode$10
 });
 const validXmlAttributes$m = [attrConfig$F, attrConfig$E];
-const XML_NODE_NAME$u = "w:br";
-const SD_NODE_NAME$d = "lineBreak";
-const encode$16 = (_2, encodedAttrs) => {
+const XML_NODE_NAME$x = "w:br";
+const SD_NODE_NAME$f = "lineBreak";
+const encode$19 = (_2, encodedAttrs) => {
   const isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -24368,7 +24409,7 @@ const encode$16 = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$Z = (params, decodedAttrs) => {
+const decode$$ = (params, decodedAttrs) => {
   const { node } = params;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24385,39 +24426,39 @@ const decode$Z = (params, decodedAttrs) => {
   };
   return translated;
 };
-const config$s = {
-  xmlName: XML_NODE_NAME$u,
-  sdNodeOrKeyName: SD_NODE_NAME$d,
+const config$v = {
+  xmlName: XML_NODE_NAME$x,
+  sdNodeOrKeyName: SD_NODE_NAME$f,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$16,
-  decode: decode$Z,
+  encode: encode$19,
+  decode: decode$$,
   attributes: validXmlAttributes$m
 };
-const translator$16 = NodeTranslator.from(config$s);
-const encode$15 = (attributes) => attributes?.["w:val"];
-const decode$Y = (attrs) => attrs?.highlight;
+const translator$19 = NodeTranslator.from(config$v);
+const encode$18 = (attributes) => attributes?.["w:val"];
+const decode$_ = (attrs) => attrs?.highlight;
 const attrConfig$D = Object.freeze({
   xmlName: "w:val",
   sdName: "highlight",
-  encode: encode$15,
-  decode: decode$Y
+  encode: encode$18,
+  decode: decode$_
 });
 const validXmlAttributes$l = [attrConfig$D];
-const XML_NODE_NAME$t = "w:highlight";
-const SD_ATTR_KEY$f = "highlight";
+const XML_NODE_NAME$w = "w:highlight";
+const SD_ATTR_KEY$g = "highlight";
 const DISABLED_TOKENS = /* @__PURE__ */ new Set(["transparent", "none", "inherit"]);
-const encode$14 = (params, encodedAttrs = {}) => {
+const encode$17 = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const value = encodedAttrs.highlight ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$t,
-    sdNodeOrKeyName: SD_ATTR_KEY$f,
+    xmlName: XML_NODE_NAME$w,
+    sdNodeOrKeyName: SD_ATTR_KEY$g,
     attributes: { "w:val": value ?? null }
   };
 };
-const decode$X = (params) => {
+const decode$Z = (params) => {
   const attrs = params?.node?.attrs || {};
   const highlightValue = attrs.highlight ?? attrs.color ?? null;
   if (!highlightValue) return void 0;
@@ -24425,14 +24466,14 @@ const decode$X = (params) => {
   if (!normalizedValue) return void 0;
   if (DISABLED_TOKENS.has(normalizedValue)) {
     return {
-      name: XML_NODE_NAME$t,
+      name: XML_NODE_NAME$w,
       attributes: { "w:val": "none" }
     };
   }
   const keyword = getDocxHighlightKeywordFromHex(highlightValue);
   if (keyword) {
     return {
-      name: XML_NODE_NAME$t,
+      name: XML_NODE_NAME$w,
       attributes: { "w:val": keyword }
     };
   }
@@ -24447,63 +24488,63 @@ const decode$X = (params) => {
     }
   };
 };
-const config$r = {
-  xmlName: XML_NODE_NAME$t,
-  sdNodeOrKeyName: SD_ATTR_KEY$f,
+const config$u = {
+  xmlName: XML_NODE_NAME$w,
+  sdNodeOrKeyName: SD_ATTR_KEY$g,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$14,
-  decode: decode$X,
+  encode: encode$17,
+  decode: decode$Z,
   attributes: validXmlAttributes$l
 };
-const translator$15 = NodeTranslator.from(config$r);
-const encode$13 = (attributes) => {
+const translator$18 = NodeTranslator.from(config$u);
+const encode$16 = (attributes) => {
   return attributes["w:val"];
 };
-const decode$W = (attrs) => {
+const decode$Y = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
 const attrConfig$C = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$13,
-  decode: decode$W
+  encode: encode$16,
+  decode: decode$Y
 });
-const encode$12 = (attributes) => {
+const encode$15 = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$V = (attrs) => {
+const decode$X = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
 const attrConfig$B = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$12,
-  decode: decode$V
+  encode: encode$15,
+  decode: decode$X
 });
-const encode$11 = (attributes) => {
+const encode$14 = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$U = (attrs) => {
+const decode$W = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
 const attrConfig$A = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$11,
-  decode: decode$U
+  encode: encode$14,
+  decode: decode$W
 });
 const validXmlAttributes$k = [attrConfig$C, attrConfig$A, attrConfig$B];
-const XML_NODE_NAME$s = "w:tab";
-const SD_NODE_NAME$c = "tab";
-const encode$10 = (_2, encodedAttrs = {}) => {
+const XML_NODE_NAME$v = "w:tab";
+const SD_NODE_NAME$e = "tab";
+const encode$13 = (_2, encodedAttrs = {}) => {
   const translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$T = (params, decodedAttrs = {}) => {
+const decode$V = (params, decodedAttrs = {}) => {
   const { node } = params || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24519,15 +24560,15 @@ const decode$T = (params, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$q = {
-  xmlName: XML_NODE_NAME$s,
-  sdNodeOrKeyName: SD_NODE_NAME$c,
+const config$t = {
+  xmlName: XML_NODE_NAME$v,
+  sdNodeOrKeyName: SD_NODE_NAME$e,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$10,
-  decode: decode$T,
+  encode: encode$13,
+  decode: decode$V,
   attributes: validXmlAttributes$k
 };
-const translator$14 = NodeTranslator.from(config$q);
+const translator$17 = NodeTranslator.from(config$t);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -24901,104 +24942,10 @@ const getDefaultParagraphStyle = (docx, styleId = "") => {
     justify: pPrByIdJcAttr
   };
 };
-const preProcessNodesForFldChar = (nodes = []) => {
-  const processedNodes = [];
-  let buffer2 = [];
-  let collecting = false;
-  for (const node of nodes) {
-    const fldCharEl = node.elements?.find((el) => el.name === "w:fldChar");
-    const fldType = fldCharEl?.attributes?.["w:fldCharType"];
-    if (fldType === "begin") {
-      buffer2 = [node];
-      collecting = true;
-      continue;
-    }
-    if (fldType === "separate" && collecting) {
-      buffer2.push(node);
-      continue;
-    }
-    if (fldType === "end" && collecting) {
-      buffer2.push(node);
-      processedNodes.push(...processCombinedNodesForFldChar(buffer2));
-      buffer2 = [];
-      collecting = false;
-      continue;
-    }
-    if (collecting) {
-      buffer2.push(node);
-    } else {
-      processedNodes.push(node);
-    }
-  }
-  if (buffer2.length) {
-    processedNodes.push(...buffer2);
-  }
-  return processedNodes;
-};
-const processCombinedNodesForFldChar = (nodesToCombine = []) => {
-  let processedNodes = [];
-  let hasPageMarker = false;
-  let isNumPages = false;
-  const textStart = nodesToCombine.findIndex(
-    (n) => n.elements?.some((el) => el.name === "w:fldChar" && el.attributes["w:fldCharType"] === "separate")
-  );
-  const textEnd = nodesToCombine.findIndex(
-    (n) => n.elements?.some((el) => el.name === "w:fldChar" && el.attributes["w:fldCharType"] === "end")
-  );
-  const textNodes = nodesToCombine.slice(textStart + 1, textEnd);
-  const instrTextContainer = nodesToCombine.find((n) => n.elements?.some((el) => el.name === "w:instrText"));
-  const instrTextNode = instrTextContainer?.elements?.find((el) => el.name === "w:instrText");
-  const instrText = instrTextNode?.elements[0].text;
-  if (!hasPageMarker) hasPageMarker = instrText?.trim().startsWith("PAGE");
-  if (!isNumPages) isNumPages = instrText?.trim().startsWith("NUMPAGES");
-  const urlMatch = instrText?.match(/HYPERLINK\s+"([^"]+)"/);
-  if (hasPageMarker) {
-    const pageNumNode = {
-      name: "sd:autoPageNumber",
-      type: "element"
-    };
-    nodesToCombine.forEach((n) => {
-      const rPrNode = n.elements.find((el) => el.name === "w:rPr");
-      if (rPrNode) pageNumNode.elements = [rPrNode];
-    });
-    processedNodes.push(pageNumNode);
-  } else if (isNumPages) {
-    const totalPageNumNode = {
-      name: "sd:totalPageNumber",
-      type: "element"
-    };
-    nodesToCombine.forEach((n) => {
-      const rPrNode = n.elements.find((el) => el.name === "w:rPr");
-      if (rPrNode) totalPageNumNode.elements = [rPrNode];
-    });
-    processedNodes.push(totalPageNumNode);
-  } else if (urlMatch && urlMatch?.length >= 2) {
-    const url = urlMatch[1];
-    const textMarks = [];
-    textNodes.forEach((n) => {
-      const rPr2 = n.elements.find((el) => el.name === "w:rPr");
-      if (!rPr2) return;
-      const { elements } = rPr2;
-      elements.forEach((el) => {
-        textMarks.push(el);
-      });
-    });
-    const linkMark = { name: "link", attributes: { href: url } };
-    const rPr = { name: "w:rPr", type: "element", elements: [linkMark, ...textMarks] };
-    processedNodes.push({
-      name: "w:r",
-      type: "element",
-      elements: [rPr, ...textNodes]
-    });
-  }
-  return processedNodes;
-};
 const handleParagraphNode$1 = (params) => {
   const { nodes, docx, nodeListHandler, filename } = params;
   const node = carbonCopy(nodes[0]);
   let schemaNode;
-  let processedElements = preProcessNodesForFldChar(node.elements);
-  node.elements = processedElements;
   const handleStandardNode2 = nodeListHandler.handlerEntities.find(
     (e) => e.handlerName === "standardNodeHandler"
   )?.handler;
@@ -25139,89 +25086,89 @@ const handleParagraphNode$1 = (params) => {
   }
   return schemaNode;
 };
-const encode$$ = (attributes) => {
+const encode$12 = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$S = (attrs) => {
+const decode$U = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$z = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$$,
-  decode: decode$S
+  encode: encode$12,
+  decode: decode$U
 });
-const encode$_ = (attributes) => {
+const encode$11 = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$R = (attrs) => {
+const decode$T = (attrs) => {
   return attrs.rsidP;
 };
 const attrConfig$y = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$_,
-  decode: decode$R
+  encode: encode$11,
+  decode: decode$T
 });
-const encode$Z = (attributes) => {
+const encode$10 = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$Q = (attrs) => {
+const decode$S = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$x = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$Z,
-  decode: decode$Q
+  encode: encode$10,
+  decode: decode$S
 });
-const encode$Y = (attributes) => {
+const encode$$ = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$P = (attrs) => {
+const decode$R = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$w = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$Y,
-  decode: decode$P
+  encode: encode$$,
+  decode: decode$R
 });
-const encode$X = (attributes) => {
+const encode$_ = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$O = (attrs) => {
+const decode$Q = (attrs) => {
   return attrs.rsidRDefault;
 };
 const attrConfig$v = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$X,
-  decode: decode$O
+  encode: encode$_,
+  decode: decode$Q
 });
-const encode$W = (attributes) => {
+const encode$Z = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$N = (attrs) => {
+const decode$P = (attrs) => {
   return attrs.paraId;
 };
 const attrConfig$u = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$W,
-  decode: decode$N
+  encode: encode$Z,
+  decode: decode$P
 });
-const encode$V = (attributes) => {
+const encode$Y = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$M = (attrs) => {
+const decode$O = (attrs) => {
   return attrs.textId;
 };
 const attrConfig$t = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$V,
-  decode: decode$M
+  encode: encode$Y,
+  decode: decode$O
 });
 const validXmlAttributes$j = [
   attrConfig$u,
@@ -25232,9 +25179,9 @@ const validXmlAttributes$j = [
   attrConfig$w,
   attrConfig$z
 ];
-const XML_NODE_NAME$r = "w:p";
-const SD_NODE_NAME$b = "paragraph";
-const encode$U = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$u = "w:p";
+const SD_NODE_NAME$d = "paragraph";
+const encode$X = (params, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25242,7 +25189,7 @@ const encode$U = (params, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$L = (params, decodedAttrs = {}) => {
+const decode$N = (params, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25250,16 +25197,16 @@ const decode$L = (params, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$p = {
-  xmlName: XML_NODE_NAME$r,
-  sdNodeOrKeyName: SD_NODE_NAME$b,
+const config$s = {
+  xmlName: XML_NODE_NAME$u,
+  sdNodeOrKeyName: SD_NODE_NAME$d,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$U,
-  decode: decode$L,
+  encode: encode$X,
+  decode: decode$N,
   attributes: validXmlAttributes$j
 };
-const translator$13 = NodeTranslator.from(config$p);
-const encode$T = (attributes) => {
+const translator$16 = NodeTranslator.from(config$s);
+const encode$W = (attributes) => {
   const raw = attributes?.["w:val"];
   if (raw === void 0 || raw === null) return void 0;
   if (typeof raw === "boolean") return raw;
@@ -25269,24 +25216,24 @@ const encode$T = (attributes) => {
   if (val === "1" || val === "true" || val === "on") return true;
   return void 0;
 };
-const decode$K = (runProps) => {
+const decode$M = (runProps) => {
   if (runProps?.bold === false) return "0";
   return void 0;
 };
 const attrConfig$s = Object.freeze({
   xmlName: "w:val",
   sdName: "bold",
-  encode: encode$T,
-  decode: decode$K
+  encode: encode$W,
+  decode: decode$M
 });
 const validXmlAttributes$i = [attrConfig$s];
-const XML_NODE_NAME$q = "w:b";
-const SD_ATTR_KEY$e = "bold";
-const encode$S = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$t = "w:b";
+const SD_ATTR_KEY$f = "bold";
+const encode$V = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes[0];
   if (!node) return void 0;
-  const val = encodedAttrs?.[SD_ATTR_KEY$e];
+  const val = encodedAttrs?.[SD_ATTR_KEY$f];
   let attributes;
   if (val === false) attributes = { "w:val": "0" };
   else if (val === true)
@@ -25294,85 +25241,85 @@ const encode$S = (params, encodedAttrs = {}) => {
   else attributes = node.attributes || {};
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$q,
-    sdNodeOrKeyName: SD_ATTR_KEY$e,
+    xmlName: XML_NODE_NAME$t,
+    sdNodeOrKeyName: SD_ATTR_KEY$f,
     attributes
   };
 };
-const config$o = {
-  xmlName: XML_NODE_NAME$q,
-  sdNodeOrKeyName: SD_ATTR_KEY$e,
+const config$r = {
+  xmlName: XML_NODE_NAME$t,
+  sdNodeOrKeyName: SD_ATTR_KEY$f,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$S,
+  encode: encode$V,
   attributes: validXmlAttributes$i
 };
-const translator$12 = NodeTranslator.from(config$o);
-const XML_NODE_NAME$p = "w:i";
-const SD_ATTR_KEY$d = "italic";
-const encode$R = (params) => {
+const translator$15 = NodeTranslator.from(config$r);
+const XML_NODE_NAME$s = "w:i";
+const SD_ATTR_KEY$e = "italic";
+const encode$U = (params) => {
   const { nodes } = params;
   const node = nodes?.[0];
   if (!node) return void 0;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$p,
-    sdNodeOrKeyName: SD_ATTR_KEY$d,
+    xmlName: XML_NODE_NAME$s,
+    sdNodeOrKeyName: SD_ATTR_KEY$e,
     attributes: {
       "w:val": node.attributes?.["w:val"] ?? null
     }
   };
 };
-const config$n = {
-  xmlName: XML_NODE_NAME$p,
-  sdNodeOrKeyName: SD_ATTR_KEY$d,
+const config$q = {
+  xmlName: XML_NODE_NAME$s,
+  sdNodeOrKeyName: SD_ATTR_KEY$e,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$R
+  encode: encode$U
 };
-const translator$11 = NodeTranslator.from(config$n);
-const encode$Q = (attributes) => attributes?.["w:val"];
-const decode$J = (attrs) => attrs?.underline;
+const translator$14 = NodeTranslator.from(config$q);
+const encode$T = (attributes) => attributes?.["w:val"];
+const decode$L = (attrs) => attrs?.underline;
 const attrConfig$r = Object.freeze({
   xmlName: "w:val",
   sdName: "underline",
-  encode: encode$Q,
-  decode: decode$J
+  encode: encode$T,
+  decode: decode$L
 });
-const encode$P = (attributes) => attributes?.["w:color"];
-const decode$I = (attrs) => attrs?.color;
+const encode$S = (attributes) => attributes?.["w:color"];
+const decode$K = (attrs) => attrs?.color;
 const attrConfig$q = Object.freeze({
   xmlName: "w:color",
   sdName: "color",
-  encode: encode$P,
-  decode: decode$I
+  encode: encode$S,
+  decode: decode$K
 });
-const encode$O = (attributes) => attributes?.["w:themeColor"];
-const decode$H = (attrs) => attrs?.themeColor;
+const encode$R = (attributes) => attributes?.["w:themeColor"];
+const decode$J = (attrs) => attrs?.themeColor;
 const attrConfig$p = Object.freeze({
   xmlName: "w:themeColor",
   sdName: "themeColor",
-  encode: encode$O,
-  decode: decode$H
+  encode: encode$R,
+  decode: decode$J
 });
-const encode$N = (attributes) => attributes?.["w:themeTint"];
-const decode$G = (attrs) => attrs?.themeTint;
+const encode$Q = (attributes) => attributes?.["w:themeTint"];
+const decode$I = (attrs) => attrs?.themeTint;
 const attrConfig$o = Object.freeze({
   xmlName: "w:themeTint",
   sdName: "themeTint",
-  encode: encode$N,
-  decode: decode$G
+  encode: encode$Q,
+  decode: decode$I
 });
-const encode$M = (attributes) => attributes?.["w:themeShade"];
-const decode$F = (attrs) => attrs?.themeShade;
+const encode$P = (attributes) => attributes?.["w:themeShade"];
+const decode$H = (attrs) => attrs?.themeShade;
 const attrConfig$n = Object.freeze({
   xmlName: "w:themeShade",
   sdName: "themeShade",
-  encode: encode$M,
-  decode: decode$F
+  encode: encode$P,
+  decode: decode$H
 });
 const validXmlAttributes$h = [attrConfig$r, attrConfig$q, attrConfig$p, attrConfig$o, attrConfig$n];
-const XML_NODE_NAME$o = "w:u";
-const SD_ATTR_KEY$c = "underline";
-const encode$L = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$r = "w:u";
+const SD_ATTR_KEY$d = "underline";
+const encode$O = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25388,12 +25335,12 @@ const encode$L = (params, encodedAttrs = {}) => {
   if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$o,
-    sdNodeOrKeyName: SD_ATTR_KEY$c,
+    xmlName: XML_NODE_NAME$r,
+    sdNodeOrKeyName: SD_ATTR_KEY$d,
     attributes
   };
 };
-const decode$E = (params) => {
+const decode$G = (params) => {
   const attrs = params?.node?.attrs || {};
   const underlineType = attrs.underlineType ?? attrs.underline ?? null;
   const color = attrs.underlineColor ?? attrs.color ?? null;
@@ -25411,20 +25358,20 @@ const decode$E = (params) => {
   if (themeTint) attributes["w:themeTint"] = themeTint;
   if (themeShade) attributes["w:themeShade"] = themeShade;
   return {
-    name: XML_NODE_NAME$o,
+    name: XML_NODE_NAME$r,
     attributes
   };
 };
-const config$m = {
-  xmlName: XML_NODE_NAME$o,
-  sdNodeOrKeyName: SD_ATTR_KEY$c,
+const config$p = {
+  xmlName: XML_NODE_NAME$r,
+  sdNodeOrKeyName: SD_ATTR_KEY$d,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$L,
-  decode: decode$E,
+  encode: encode$O,
+  decode: decode$G,
   attributes: validXmlAttributes$h
 };
-const translator$10 = NodeTranslator.from(config$m);
-const encode$K = (attributes) => {
+const translator$13 = NodeTranslator.from(config$p);
+const encode$N = (attributes) => {
   const raw = attributes?.["w:val"];
   if (raw === void 0 || raw === null) return void 0;
   if (typeof raw === "boolean") return raw;
@@ -25434,24 +25381,24 @@ const encode$K = (attributes) => {
   if (val === "1" || val === "true" || val === "on") return true;
   return void 0;
 };
-const decode$D = (attrs) => {
+const decode$F = (attrs) => {
   if (attrs?.strike === false) return "0";
   return void 0;
 };
 const attrConfig$m = Object.freeze({
   xmlName: "w:val",
   sdName: "strike",
-  encode: encode$K,
-  decode: decode$D
+  encode: encode$N,
+  decode: decode$F
 });
 const validXmlAttributes$g = [attrConfig$m];
-const XML_NODE_NAME$n = "w:strike";
-const SD_ATTR_KEY$b = "strike";
-const encode$J = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$q = "w:strike";
+const SD_ATTR_KEY$c = "strike";
+const encode$M = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   if (!node) return void 0;
-  const val = encodedAttrs?.[SD_ATTR_KEY$b];
+  const val = encodedAttrs?.[SD_ATTR_KEY$c];
   let attributes;
   if (val === false) attributes = { "w:val": "0" };
   else if (val === true) attributes = {};
@@ -25460,55 +25407,55 @@ const encode$J = (params, encodedAttrs = {}) => {
   else if (val === true && attributes["w:val"] === void 0) delete attributes["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$n,
-    sdNodeOrKeyName: SD_ATTR_KEY$b,
+    xmlName: XML_NODE_NAME$q,
+    sdNodeOrKeyName: SD_ATTR_KEY$c,
     attributes
   };
 };
-const config$l = {
-  xmlName: XML_NODE_NAME$n,
-  sdNodeOrKeyName: SD_ATTR_KEY$b,
+const config$o = {
+  xmlName: XML_NODE_NAME$q,
+  sdNodeOrKeyName: SD_ATTR_KEY$c,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$J,
+  encode: encode$M,
   attributes: validXmlAttributes$g
 };
-const translator$$ = NodeTranslator.from(config$l);
-const encode$I = (attributes) => attributes?.["w:val"];
-const decode$C = (attrs) => attrs?.color;
+const translator$12 = NodeTranslator.from(config$o);
+const encode$L = (attributes) => attributes?.["w:val"];
+const decode$E = (attrs) => attrs?.color;
 const attrConfig$l = Object.freeze({
   xmlName: "w:val",
   sdName: "color",
-  encode: encode$I,
-  decode: decode$C
+  encode: encode$L,
+  decode: decode$E
 });
-const encode$H = (attributes) => attributes?.["w:themeColor"];
-const decode$B = (attrs) => attrs?.themeColor;
+const encode$K = (attributes) => attributes?.["w:themeColor"];
+const decode$D = (attrs) => attrs?.themeColor;
 const attrConfig$k = Object.freeze({
   xmlName: "w:themeColor",
   sdName: "themeColor",
-  encode: encode$H,
-  decode: decode$B
+  encode: encode$K,
+  decode: decode$D
 });
-const encode$G = (attributes) => attributes?.["w:themeTint"];
-const decode$A = (attrs) => attrs?.themeTint;
+const encode$J = (attributes) => attributes?.["w:themeTint"];
+const decode$C = (attrs) => attrs?.themeTint;
 const attrConfig$j = Object.freeze({
   xmlName: "w:themeTint",
   sdName: "themeTint",
-  encode: encode$G,
-  decode: decode$A
+  encode: encode$J,
+  decode: decode$C
 });
-const encode$F = (attributes) => attributes?.["w:themeShade"];
-const decode$z = (attrs) => attrs?.themeShade;
+const encode$I = (attributes) => attributes?.["w:themeShade"];
+const decode$B = (attrs) => attrs?.themeShade;
 const attrConfig$i = Object.freeze({
   xmlName: "w:themeShade",
   sdName: "themeShade",
-  encode: encode$F,
-  decode: decode$z
+  encode: encode$I,
+  decode: decode$B
 });
 const validXmlAttributes$f = [attrConfig$l, attrConfig$k, attrConfig$j, attrConfig$i];
-const XML_NODE_NAME$m = "w:color";
-const SD_ATTR_KEY$a = "color";
-const encode$E = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$p = "w:color";
+const SD_ATTR_KEY$b = "color";
+const encode$H = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25523,63 +25470,63 @@ const encode$E = (params, encodedAttrs = {}) => {
   if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$m,
-    sdNodeOrKeyName: SD_ATTR_KEY$a,
-    attributes
+    xmlName: XML_NODE_NAME$p,
+    sdNodeOrKeyName: SD_ATTR_KEY$b,
+    attributes
   };
 };
-const config$k = {
-  xmlName: XML_NODE_NAME$m,
-  sdNodeOrKeyName: SD_ATTR_KEY$a,
+const config$n = {
+  xmlName: XML_NODE_NAME$p,
+  sdNodeOrKeyName: SD_ATTR_KEY$b,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$E,
+  encode: encode$H,
   attributes: validXmlAttributes$f
 };
-const translator$_ = NodeTranslator.from(config$k);
-const encode$D = (attributes) => attributes?.["w:eastAsia"];
-const decode$y = (attrs) => attrs?.eastAsia;
+const translator$11 = NodeTranslator.from(config$n);
+const encode$G = (attributes) => attributes?.["w:eastAsia"];
+const decode$A = (attrs) => attrs?.eastAsia;
 const attrConfig$h = Object.freeze({
   xmlName: "w:eastAsia",
   sdName: "eastAsia",
-  encode: encode$D,
-  decode: decode$y
+  encode: encode$G,
+  decode: decode$A
 });
-const encode$C = (attributes) => attributes?.["w:ascii"];
-const decode$x = (attrs) => attrs?.ascii;
+const encode$F = (attributes) => attributes?.["w:ascii"];
+const decode$z = (attrs) => attrs?.ascii;
 const attrConfig$g = Object.freeze({
   xmlName: "w:ascii",
   sdName: "ascii",
-  encode: encode$C,
-  decode: decode$x
+  encode: encode$F,
+  decode: decode$z
 });
-const encode$B = (attributes) => attributes?.["w:hAnsi"];
-const decode$w = (attrs) => attrs?.hAnsi;
+const encode$E = (attributes) => attributes?.["w:hAnsi"];
+const decode$y = (attrs) => attrs?.hAnsi;
 const attrConfig$f = Object.freeze({
   xmlName: "w:hAnsi",
   sdName: "hAnsi",
-  encode: encode$B,
-  decode: decode$w
+  encode: encode$E,
+  decode: decode$y
 });
-const encode$A = (attributes) => attributes?.["w:cs"];
-const decode$v = (attrs) => attrs?.cs;
+const encode$D = (attributes) => attributes?.["w:cs"];
+const decode$x = (attrs) => attrs?.cs;
 const attrConfig$e = Object.freeze({
   xmlName: "w:cs",
   sdName: "cs",
-  encode: encode$A,
-  decode: decode$v
+  encode: encode$D,
+  decode: decode$x
 });
-const encode$z = (attributes) => attributes?.["w:val"];
-const decode$u = (attrs) => attrs?.value;
+const encode$C = (attributes) => attributes?.["w:val"];
+const decode$w = (attrs) => attrs?.value;
 const attrConfig$d = Object.freeze({
   xmlName: "w:val",
   sdName: "value",
-  encode: encode$z,
-  decode: decode$u
+  encode: encode$C,
+  decode: decode$w
 });
 const validXmlAttributes$e = [attrConfig$h, attrConfig$g, attrConfig$f, attrConfig$e, attrConfig$d];
-const XML_NODE_NAME$l = "w:rFonts";
-const SD_ATTR_KEY$9 = "fontFamily";
-const encode$y = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$o = "w:rFonts";
+const SD_ATTR_KEY$a = "fontFamily";
+const encode$B = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25605,120 +25552,281 @@ const encode$y = (params, encodedAttrs = {}) => {
   if (attributes["w:val"] === void 0) delete attributes["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$l,
-    sdNodeOrKeyName: SD_ATTR_KEY$9,
+    xmlName: XML_NODE_NAME$o,
+    sdNodeOrKeyName: SD_ATTR_KEY$a,
     attributes
   };
 };
-const config$j = {
-  xmlName: XML_NODE_NAME$l,
-  sdNodeOrKeyName: SD_ATTR_KEY$9,
+const config$m = {
+  xmlName: XML_NODE_NAME$o,
+  sdNodeOrKeyName: SD_ATTR_KEY$a,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$y,
+  encode: encode$B,
   attributes: validXmlAttributes$e
 };
-const translator$Z = NodeTranslator.from(config$j);
-const encode$x = (attributes) => attributes?.["w:val"];
-const decode$t = (attrs) => attrs?.styleId;
+const translator$10 = NodeTranslator.from(config$m);
+const encode$A = (attributes) => attributes?.["w:val"];
+const decode$v = (attrs) => attrs?.styleId;
 const attrConfig$c = Object.freeze({
   xmlName: "w:val",
   sdName: "styleId",
-  encode: encode$x,
-  decode: decode$t
+  encode: encode$A,
+  decode: decode$v
 });
 const validXmlAttributes$d = [attrConfig$c];
-const XML_NODE_NAME$k = "w:rStyle";
-const SD_ATTR_KEY$8 = "styleId";
-const encode$w = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$n = "w:rStyle";
+const SD_ATTR_KEY$9 = "styleId";
+const encode$z = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const value = encodedAttrs.styleId ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$k,
-    sdNodeOrKeyName: SD_ATTR_KEY$8,
+    xmlName: XML_NODE_NAME$n,
+    sdNodeOrKeyName: SD_ATTR_KEY$9,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$i = {
-  xmlName: XML_NODE_NAME$k,
-  sdNodeOrKeyName: SD_ATTR_KEY$8,
+const config$l = {
+  xmlName: XML_NODE_NAME$n,
+  sdNodeOrKeyName: SD_ATTR_KEY$9,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$w,
+  encode: encode$z,
   attributes: validXmlAttributes$d
 };
-const translator$Y = NodeTranslator.from(config$i);
-const encode$v = (attributes) => attributes?.["w:val"];
-const decode$s = (attrs) => attrs?.fontSize;
+const translator$$ = NodeTranslator.from(config$l);
+const encode$y = (attributes) => attributes?.["w:val"];
+const decode$u = (attrs) => attrs?.fontSize;
 const attrConfig$b = Object.freeze({
   xmlName: "w:val",
   sdName: "fontSize",
-  encode: encode$v,
-  decode: decode$s
+  encode: encode$y,
+  decode: decode$u
 });
 const validXmlAttributes$c = [attrConfig$b];
-const XML_NODE_NAME$j = "w:sz";
-const SD_ATTR_KEY$7 = "fontSize";
-const encode$u = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$m = "w:sz";
+const SD_ATTR_KEY$8 = "fontSize";
+const encode$x = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const value = encodedAttrs.fontSize ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$j,
-    sdNodeOrKeyName: SD_ATTR_KEY$7,
+    xmlName: XML_NODE_NAME$m,
+    sdNodeOrKeyName: SD_ATTR_KEY$8,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$h = {
-  xmlName: XML_NODE_NAME$j,
-  sdNodeOrKeyName: SD_ATTR_KEY$7,
+const config$k = {
+  xmlName: XML_NODE_NAME$m,
+  sdNodeOrKeyName: SD_ATTR_KEY$8,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$u,
+  encode: encode$x,
   attributes: validXmlAttributes$c
 };
-const translator$X = NodeTranslator.from(config$h);
-const encode$t = (attributes) => attributes?.["w:val"];
-const decode$r = (attrs) => attrs?.fontSizeCs;
+const translator$_ = NodeTranslator.from(config$k);
+const encode$w = (attributes) => attributes?.["w:val"];
+const decode$t = (attrs) => attrs?.fontSizeCs;
 const attrConfig$a = Object.freeze({
   xmlName: "w:val",
   sdName: "fontSizeCs",
-  encode: encode$t,
-  decode: decode$r
+  encode: encode$w,
+  decode: decode$t
 });
 const validXmlAttributes$b = [attrConfig$a];
-const XML_NODE_NAME$i = "w:szCs";
-const SD_ATTR_KEY$6 = "fontSizeCs";
-const encode$s = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$l = "w:szCs";
+const SD_ATTR_KEY$7 = "fontSizeCs";
+const encode$v = (params, encodedAttrs = {}) => {
   const { nodes } = params;
   const node = nodes?.[0];
   const value = encodedAttrs.fontSizeCs ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$i,
-    sdNodeOrKeyName: SD_ATTR_KEY$6,
+    xmlName: XML_NODE_NAME$l,
+    sdNodeOrKeyName: SD_ATTR_KEY$7,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$g = {
-  xmlName: XML_NODE_NAME$i,
-  sdNodeOrKeyName: SD_ATTR_KEY$6,
+const config$j = {
+  xmlName: XML_NODE_NAME$l,
+  sdNodeOrKeyName: SD_ATTR_KEY$7,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$s,
+  encode: encode$v,
   attributes: validXmlAttributes$b
 };
-const translator$W = NodeTranslator.from(config$g);
+const translator$Z = NodeTranslator.from(config$j);
+const generateV2HandlerEntity = (handlerName, translator2) => ({
+  handlerName,
+  handler: (params) => {
+    const { nodes } = params;
+    if (nodes.length === 0 || nodes[0].name !== translator2.xmlName) {
+      return { nodes: [], consumed: 0 };
+    }
+    const result = translator2.encode(params);
+    if (!result) return { nodes: [], consumed: 0 };
+    return {
+      nodes: Array.isArray(result) ? result : [result],
+      consumed: 1
+    };
+  }
+});
+function createSingleAttrPropertyHandler(xmlName, sdName = null, attrName = "w:val", transformEncode = null, transformDecode = null) {
+  if (!sdName) sdName = xmlName.split(":")[1];
+  if (!transformEncode) transformEncode = (v2) => v2;
+  if (!transformDecode) transformDecode = (v2) => v2;
+  return {
+    xmlName,
+    sdNodeOrKeyName: sdName,
+    encode: ({ nodes }) => {
+      return transformEncode(nodes[0].attributes[attrName]) ?? void 0;
+    },
+    decode: ({ node }) => {
+      const value = node.attrs?.[sdName] != null ? transformDecode(node.attrs[sdName]) : void 0;
+      return value != null ? { name: xmlName, attributes: { [attrName]: value } } : void 0;
+    }
+  };
+}
+function createMeasurementPropertyHandler(xmlName, sdName = null) {
+  if (!sdName) sdName = xmlName.split(":")[1];
+  return {
+    xmlName,
+    sdNodeOrKeyName: sdName,
+    attributes: [
+      createAttributeHandler("w:w", "value", parseInteger, integerToString),
+      createAttributeHandler("w:type")
+    ],
+    encode: (_2, encodedAttrs) => {
+      return encodedAttrs["value"] != null ? encodedAttrs : void 0;
+    },
+    decode: function({ node }) {
+      const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs[sdName] || {} } });
+      return decodedAttrs["w:w"] != null ? { attributes: decodedAttrs } : void 0;
+    }
+  };
+}
+function createBorderPropertyHandler(xmlName, sdName = null) {
+  if (!sdName) sdName = xmlName.split(":")[1];
+  return {
+    xmlName,
+    sdNodeOrKeyName: sdName,
+    attributes: [
+      createAttributeHandler("w:val"),
+      createAttributeHandler("w:color"),
+      createAttributeHandler("w:themeColor"),
+      createAttributeHandler("w:themeTint"),
+      createAttributeHandler("w:themeShade"),
+      createAttributeHandler("w:sz", "size", parseInteger, integerToString),
+      createAttributeHandler("w:space", null, parseInteger, integerToString),
+      createAttributeHandler("w:shadow", null, parseBoolean, booleanToString),
+      createAttributeHandler("w:frame", null, parseBoolean, booleanToString)
+    ],
+    encode: (params, encodedAttrs) => {
+      return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
+    },
+    decode: function({ node }, context) {
+      const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs[sdName] || {} } });
+      return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
+    }
+  };
+}
+const createAttributeHandler = (xmlName, sdName = null, transformEncode = null, transformDecode = null) => {
+  if (!transformEncode) transformEncode = (v2) => v2;
+  if (!transformDecode) transformDecode = (v2) => v2;
+  if (!sdName) sdName = xmlName.split(":")[1];
+  return {
+    xmlName,
+    sdName,
+    encode: (attributes) => transformEncode(attributes[xmlName]),
+    decode: (attributes) => transformDecode(attributes[sdName])
+  };
+};
+function encodeProperties(node, translatorsByXmlName, asArray = false) {
+  if (!node?.elements || node.elements.length === 0) {
+    return asArray ? [] : {};
+  }
+  const attributes = asArray ? [] : {};
+  node.elements.forEach((el) => {
+    const translator2 = translatorsByXmlName[el.name];
+    if (translator2) {
+      const encodedAttr = translator2.encode({ nodes: [el] });
+      if (encodedAttr != null) {
+        if (asArray) {
+          attributes.push({ [translator2.sdNodeOrKeyName]: encodedAttr });
+        } else {
+          attributes[translator2.sdNodeOrKeyName] = encodedAttr;
+        }
+      }
+    }
+  });
+  return attributes;
+}
+function decodeProperties(translatorsBySdName, properties) {
+  if (!properties || typeof properties !== "object") {
+    return [];
+  }
+  const elements = [];
+  Object.keys(properties).forEach((key) => {
+    const translator2 = translatorsBySdName[key];
+    if (translator2) {
+      const result = translator2.decode({ node: { attrs: { [key]: properties[key] } } });
+      if (result != null) {
+        result.name = translator2.xmlName;
+        elements.push(result);
+      }
+    }
+  });
+  return elements;
+}
+const parseBoolean = (value) => value != null ? ["1", "true"].includes(value) : void 0;
+const booleanToString = (value) => value != null ? value ? "1" : "0" : void 0;
+const parseInteger = (value) => {
+  if (value == null) return void 0;
+  const intValue = parseInt(value, 10);
+  return isNaN(intValue) ? void 0 : intValue;
+};
+const integerToString = (value) => {
+  const intValue = parseInteger(value);
+  return intValue != void 0 ? String(intValue) : void 0;
+};
+const XML_NODE_NAME$k = "w:caps";
+const SD_ATTR_KEY$6 = "textTransform";
+const encode$u = (params, encodedAttrs = {}) => {
+  const { nodes } = params;
+  const node = nodes[0];
+  if (!node) return void 0;
+  let result;
+  if (!["false", "0"].includes(encodedAttrs.val)) {
+    result = "uppercase";
+  } else {
+    return void 0;
+  }
+  return {
+    type: "attr",
+    xmlName: XML_NODE_NAME$k,
+    sdNodeOrKeyName: SD_ATTR_KEY$6,
+    attributes: { [SD_ATTR_KEY$6]: result }
+  };
+};
+const config$i = {
+  xmlName: XML_NODE_NAME$k,
+  sdNodeOrKeyName: SD_ATTR_KEY$6,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$u,
+  attributes: [createAttributeHandler("w:val")]
+};
+const translator$Y = NodeTranslator.from(config$i);
 const runPropertyTranslators = Object.freeze({
-  "w:b": translator$12,
-  "w:i": translator$11,
-  "w:u": translator$10,
-  "w:strike": translator$$,
-  "w:color": translator$_,
-  "w:highlight": translator$15,
-  "w:rFonts": translator$Z,
-  "w:rStyle": translator$Y,
-  "w:sz": translator$X,
-  "w:szCs": translator$W
+  "w:b": translator$15,
+  "w:i": translator$14,
+  "w:u": translator$13,
+  "w:strike": translator$12,
+  "w:color": translator$11,
+  "w:highlight": translator$18,
+  "w:rFonts": translator$10,
+  "w:rStyle": translator$$,
+  "w:sz": translator$_,
+  "w:szCs": translator$Z,
+  "w:caps": translator$Y
 });
 const rawRunPropertyXmlNames = Object.freeze(["w:lang", "w:shd"]);
 const RAW_CHILD_NAME_SET = new Set(rawRunPropertyXmlNames);
@@ -25732,9 +25840,9 @@ const toRunPropertyEntry = (candidate) => {
     attributes: { ...candidate.attributes || {} }
   };
 };
-const XML_NODE_NAME$h = "w:rPr";
+const XML_NODE_NAME$j = "w:rPr";
 const SD_ATTR_KEY$5 = "runProperties";
-const encode$r = (params) => {
+const encode$t = (params) => {
   const { nodes } = params;
   const node = nodes?.[0] || {};
   const contents = Array.isArray(node.elements) ? node.elements : [];
@@ -25768,16 +25876,16 @@ const encode$r = (params) => {
     attributes: runPropsArray
   };
 };
-const config$f = {
-  xmlName: XML_NODE_NAME$h,
+const config$h = {
+  xmlName: XML_NODE_NAME$j,
   sdNodeOrKeyName: SD_ATTR_KEY$5,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$r
+  encode: encode$t
 };
-const translator$V = NodeTranslator.from(config$f);
+const translator$X = NodeTranslator.from(config$h);
 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$V) => {
+const collectRunProperties = (params, rPrNode, translator2 = translator$X) => {
   if (!rPrNode) return { entries: [], hadRPr: false, styleChangeMarks: [] };
   const result = translator2.encode({ ...params, nodes: [rPrNode] }) || {};
   let entries = [];
@@ -25846,7 +25954,10 @@ const applyRunMarks = (node, inlineMarks, textStyleAttrs) => {
 };
 const deriveStyleMarks = ({ docx, paragraphStyleId, runStyleId }) => {
   const paragraphStyleMarks = collectStyleMarks(paragraphStyleId, docx);
-  const runStyleMarks = collectStyleMarks(runStyleId, docx);
+  if (paragraphStyleId?.startsWith("TOC")) {
+    return paragraphStyleMarks;
+  }
+  let runStyleMarks = collectStyleMarks(runStyleId, docx);
   const inlineMarks = mergeInlineMarkSets(paragraphStyleMarks.inlineMarks, runStyleMarks.inlineMarks);
   const textStyleAttrs = mergeTextStyleAttrs(paragraphStyleMarks.textStyleAttrs, runStyleMarks.textStyleAttrs);
   return { inlineMarks, textStyleAttrs };
@@ -26072,6 +26183,13 @@ const splitRunProperties = (entries = [], docx = null) => {
         }
         break;
       }
+      case "w:caps": {
+        if (attributes["textTransform"] != null) {
+          hasTextStyle = true;
+          textStyleAttrs.textTransform = attributes["textTransform"];
+        }
+        break;
+      }
       case "w:rFonts": {
         const asciiFamily = attributes["w:ascii"] || attributes["w:hAnsi"] || (attributes["w:eastAsia"] ? void 0 : attributes["w:val"]);
         const eastAsiaFamily = attributes["w:eastAsia"];
@@ -26091,9 +26209,10 @@ const splitRunProperties = (entries = [], docx = null) => {
       case "w:sz":
       case "w:szCs": {
         const rawSize = Number(attributes["w:val"]);
+        const attrName = entry.xmlName === "w:sz" ? "fontSize" : "fontSizeCs";
         if (Number.isFinite(rawSize) && rawSize > 0) {
           hasTextStyle = true;
-          textStyleAttrs.fontSize = `${rawSize / 2}pt`;
+          textStyleAttrs[attrName] = `${rawSize / 2}pt`;
         }
         break;
       }
@@ -26239,46 +26358,166 @@ const ensureTrackedWrapper = (runs, trackingMarksByType = /* @__PURE__ */ new Ma
   }
   return runs;
 };
-const encode$q = (attributes) => {
+const XML_NODE_NAME$i = "w:hyperlink";
+const SD_NODE_NAME$c = "link";
+const _createAttributeHandler = (xmlName, sdName) => ({
+  xmlName,
+  sdName,
+  encode: (attributes) => attributes[xmlName],
+  decode: (attributes) => attributes[sdName]
+});
+const validXmlAttributes$a = [
+  _createAttributeHandler("w:anchor", "anchor"),
+  _createAttributeHandler("w:docLocation", "docLocation"),
+  {
+    xmlName: "w:history",
+    sdName: "history",
+    encode: (attributes) => attributes["w:history"] === "1" || attributes["w:history"] === "true",
+    decode: (attributes) => attributes["history"] ? "1" : "0"
+  },
+  _createAttributeHandler("w:tooltip", "tooltip"),
+  _createAttributeHandler("r:id", "rId"),
+  _createAttributeHandler("w:tgtFrame", "target")
+];
+const encode$s = (params, encodedAttrs) => {
+  const { nodes, docx, nodeListHandler } = params;
+  const node = nodes[0];
+  let href = _resolveHref(docx, encodedAttrs);
+  const linkMark = { type: "link", attrs: { ...encodedAttrs, href } };
+  const referenceNodeTypes = ["sd:pageReference", "sd:autoPageNumber", "sd:totalPageNumber"];
+  const contentNodes = node.elements.filter((el) => el.name === "w:r" || referenceNodeTypes.includes(el.name));
+  contentNodes.forEach((contentNode) => {
+    const existingMarks = Array.isArray(contentNode.marks) ? contentNode.marks : [];
+    const marksWithoutLink = existingMarks.filter((mark) => mark?.type !== "link");
+    contentNode.marks = [...marksWithoutLink, linkMark];
+  });
+  const updatedNode = nodeListHandler.handler({
+    ...params,
+    nodes: contentNodes,
+    path: [...params.path || [], node]
+  });
+  return updatedNode;
+};
+const _resolveHref = (docx, encodedAttrs) => {
+  const rels = docx["word/_rels/document.xml.rels"];
+  const relationships = rels.elements.find((el) => el.name === "Relationships");
+  const { elements } = relationships;
+  const { rId, anchor } = encodedAttrs;
+  let href;
+  if (!rId && anchor) {
+    href = `#${anchor}`;
+  } else if (rId) {
+    const rel = elements.find((el) => el.attributes["Id"] === rId) || {};
+    const { attributes: relAttributes = {} } = rel;
+    href = relAttributes["Target"];
+  }
+  return href;
+};
+function decode$s(params) {
+  const { hyperlinkGroup = [params.node] } = params.extraParams || {};
+  const node = hyperlinkGroup[0];
+  const linkMark = node.marks.find((m2) => m2.type === "link");
+  const linkAttrs = this.decodeAttributes({ ...params, node: linkMark });
+  let { anchor, href: link } = linkMark.attrs;
+  const isExternalLink = !anchor;
+  if (isExternalLink) {
+    linkAttrs["r:id"] = _addNewLinkRelationship(params, link, linkAttrs["r:id"]);
+  }
+  let contentNodes = [];
+  hyperlinkGroup.forEach((linkNode) => {
+    if ("marks" in linkNode) {
+      linkNode.marks = linkNode.marks.filter((m2) => m2.type !== "link");
+    } else {
+      linkNode.attrs.marksAsAttrs = linkNode.attrs.marksAsAttrs.filter((m2) => m2.type !== "link");
+    }
+    const outputNode = exportSchemaToJson({ ...params, node: linkNode });
+    if (outputNode) {
+      if (outputNode instanceof Array) contentNodes.push(...outputNode);
+      else contentNodes.push(outputNode);
+    }
+  });
+  const newNode = {
+    name: "w:hyperlink",
+    type: "element",
+    attributes: {
+      ...linkAttrs
+    },
+    elements: contentNodes
+  };
+  return newNode;
+}
+function _addNewLinkRelationship(params, link, rId) {
+  if (!rId) rId = generateDocxRandomId();
+  if (!params.relationships || !Array.isArray(params.relationships)) {
+    params.relationships = [];
+  }
+  const existingRel = params.relationships.find(
+    (rel) => rel.attributes && rel.attributes.Id === rId && rel.attributes.Target === link
+  );
+  if (existingRel) {
+    return rId;
+  }
+  params.relationships.push({
+    type: "element",
+    name: "Relationship",
+    attributes: {
+      Id: rId,
+      Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
+      Target: link,
+      TargetMode: "External"
+    }
+  });
+  return rId;
+}
+const config$g = {
+  xmlName: XML_NODE_NAME$i,
+  sdNodeOrKeyName: SD_NODE_NAME$c,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$s,
+  decode: decode$s,
+  attributes: validXmlAttributes$a
+};
+const translator$W = NodeTranslator.from(config$g);
+const encode$r = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$q = (attrs) => {
+const decode$r = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$9 = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$q,
-  decode: decode$q
+  encode: encode$r,
+  decode: decode$r
 });
-const encode$p = (attributes) => {
+const encode$q = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$p = (attrs) => {
+const decode$q = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$8 = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$p,
-  decode: decode$p
+  encode: encode$q,
+  decode: decode$q
 });
-const encode$o = (attributes) => {
+const encode$p = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$o = (attrs) => {
+const decode$p = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$7 = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$o,
-  decode: decode$o
+  encode: encode$p,
+  decode: decode$p
 });
-const validXmlAttributes$a = [attrConfig$9, attrConfig$8, attrConfig$7];
-const XML_NODE_NAME$g = "w:r";
+const validXmlAttributes$9 = [attrConfig$9, attrConfig$8, attrConfig$7];
+const XML_NODE_NAME$h = "w:r";
 const SD_KEY_NAME = "run";
-const encode$n = (params, encodedAttrs = {}) => {
+const encode$o = (params, encodedAttrs = {}) => {
   const { nodes = [], nodeListHandler } = params || {};
   const runNode = nodes[0];
   if (!runNode) return void 0;
@@ -26326,9 +26565,11 @@ const encode$n = (params, encodedAttrs = {}) => {
   }
   return runNodeResult;
 };
-const decode$n = (params, decodedAttrs = {}) => {
+const decode$o = (params, decodedAttrs = {}) => {
   const { node } = params || {};
   if (!node) return void 0;
+  const isLinkNode = node.marks?.some((m2) => m2.type === "link");
+  if (isLinkNode) return translator$W.decode(params);
   const { runNode: runNodeForExport, trackingMarksByType } = prepareRunTrackingContext(node);
   const runAttrs = runNodeForExport.attrs || {};
   const runProperties = Array.isArray(runAttrs.runProperties) ? runAttrs.runProperties : [];
@@ -26383,7 +26624,7 @@ const decode$n = (params, decodedAttrs = {}) => {
       runs.push(trackedClone);
       return;
     }
-    const runWrapper = { name: XML_NODE_NAME$g, elements: [] };
+    const runWrapper = { name: XML_NODE_NAME$h, elements: [] };
     applyBaseRunProps(runWrapper);
     if (!Array.isArray(runWrapper.elements)) runWrapper.elements = [];
     runWrapper.elements.push(cloneXmlNode(child));
@@ -26391,7 +26632,7 @@ const decode$n = (params, decodedAttrs = {}) => {
   });
   const trackedRuns = ensureTrackedWrapper(runs, trackingMarksByType);
   if (!trackedRuns.length) {
-    const emptyRun = { name: XML_NODE_NAME$g, elements: [] };
+    const emptyRun = { name: XML_NODE_NAME$h, elements: [] };
     applyBaseRunProps(emptyRun);
     trackedRuns.push(emptyRun);
   }
@@ -26405,148 +26646,15 @@ const decode$n = (params, decodedAttrs = {}) => {
   }
   return trackedRuns;
 };
-const config$e = {
-  xmlName: XML_NODE_NAME$g,
+const config$f = {
+  xmlName: XML_NODE_NAME$h,
   sdNodeOrKeyName: SD_KEY_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$n,
-  decode: decode$n,
-  attributes: validXmlAttributes$a
-};
-const translator$U = NodeTranslator.from(config$e);
-const generateV2HandlerEntity = (handlerName, translator2) => ({
-  handlerName,
-  handler: (params) => {
-    const { nodes } = params;
-    if (nodes.length === 0 || nodes[0].name !== translator2.xmlName) {
-      return { nodes: [], consumed: 0 };
-    }
-    const result = translator2.encode(params);
-    if (!result) return { nodes: [], consumed: 0 };
-    return {
-      nodes: Array.isArray(result) ? result : [result],
-      consumed: 1
-    };
-  }
-});
-function createSingleAttrPropertyHandler(xmlName, sdName = null, attrName = "w:val", transformEncode = null, transformDecode = null) {
-  if (!sdName) sdName = xmlName.split(":")[1];
-  if (!transformEncode) transformEncode = (v2) => v2;
-  if (!transformDecode) transformDecode = (v2) => v2;
-  return {
-    xmlName,
-    sdNodeOrKeyName: sdName,
-    encode: ({ nodes }) => {
-      return transformEncode(nodes[0].attributes[attrName]) ?? void 0;
-    },
-    decode: ({ node }) => {
-      const value = node.attrs?.[sdName] != null ? transformDecode(node.attrs[sdName]) : void 0;
-      return value != null ? { name: xmlName, attributes: { [attrName]: value } } : void 0;
-    }
-  };
-}
-function createMeasurementPropertyHandler(xmlName, sdName = null) {
-  if (!sdName) sdName = xmlName.split(":")[1];
-  return {
-    xmlName,
-    sdNodeOrKeyName: sdName,
-    attributes: [
-      createAttributeHandler("w:w", "value", parseInteger, integerToString),
-      createAttributeHandler("w:type")
-    ],
-    encode: (_2, encodedAttrs) => {
-      return encodedAttrs["value"] != null ? encodedAttrs : void 0;
-    },
-    decode: function({ node }) {
-      const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs[sdName] || {} } });
-      return decodedAttrs["w:w"] != null ? { attributes: decodedAttrs } : void 0;
-    }
-  };
-}
-function createBorderPropertyHandler(xmlName, sdName = null) {
-  if (!sdName) sdName = xmlName.split(":")[1];
-  return {
-    xmlName,
-    sdNodeOrKeyName: sdName,
-    attributes: [
-      createAttributeHandler("w:val"),
-      createAttributeHandler("w:color"),
-      createAttributeHandler("w:themeColor"),
-      createAttributeHandler("w:themeTint"),
-      createAttributeHandler("w:themeShade"),
-      createAttributeHandler("w:sz", "size", parseInteger, integerToString),
-      createAttributeHandler("w:space", null, parseInteger, integerToString),
-      createAttributeHandler("w:shadow", null, parseBoolean, booleanToString),
-      createAttributeHandler("w:frame", null, parseBoolean, booleanToString)
-    ],
-    encode: (params, encodedAttrs) => {
-      return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
-    },
-    decode: function({ node }, context) {
-      const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs[sdName] || {} } });
-      return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
-    }
-  };
-}
-const createAttributeHandler = (xmlName, sdName = null, transformEncode = null, transformDecode = null) => {
-  if (!transformEncode) transformEncode = (v2) => v2;
-  if (!transformDecode) transformDecode = (v2) => v2;
-  if (!sdName) sdName = xmlName.split(":")[1];
-  return {
-    xmlName,
-    sdName,
-    encode: (attributes) => transformEncode(attributes[xmlName]),
-    decode: (attributes) => transformDecode(attributes[sdName])
-  };
-};
-function encodeProperties(node, translatorsByXmlName, asArray = false) {
-  if (!node?.elements || node.elements.length === 0) {
-    return asArray ? [] : {};
-  }
-  const attributes = asArray ? [] : {};
-  node.elements.forEach((el) => {
-    const translator2 = translatorsByXmlName[el.name];
-    if (translator2) {
-      const encodedAttr = translator2.encode({ nodes: [el] });
-      if (encodedAttr != null) {
-        if (asArray) {
-          attributes.push({ [translator2.sdNodeOrKeyName]: encodedAttr });
-        } else {
-          attributes[translator2.sdNodeOrKeyName] = encodedAttr;
-        }
-      }
-    }
-  });
-  return attributes;
-}
-function decodeProperties(translatorsBySdName, properties) {
-  if (!properties || typeof properties !== "object") {
-    return [];
-  }
-  const elements = [];
-  Object.keys(properties).forEach((key) => {
-    const translator2 = translatorsBySdName[key];
-    if (translator2) {
-      const result = translator2.decode({ node: { attrs: { [key]: properties[key] } } });
-      if (result != null) {
-        result.name = translator2.xmlName;
-        elements.push(result);
-      }
-    }
-  });
-  return elements;
-}
-const parseBoolean = (value) => value != null ? ["1", "true"].includes(value) : void 0;
-const booleanToString = (value) => value != null ? value ? "1" : "0" : void 0;
-const parseInteger = (value) => {
-  if (value == null) return void 0;
-  const intValue = parseInt(value, 10);
-  return isNaN(intValue) ? void 0 : intValue;
-};
-const integerToString = (value) => {
-  const intValue = parseInteger(value);
-  return intValue != void 0 ? String(intValue) : void 0;
+  encode: encode$o,
+  decode: decode$o,
+  attributes: validXmlAttributes$9
 };
+const translator$V = NodeTranslator.from(config$f);
 function preProcessVerticalMergeCells(table, { editorSchema }) {
   if (!table || !Array.isArray(table.content)) {
     return table;
@@ -26587,13 +26695,13 @@ function preProcessVerticalMergeCells(table, { editorSchema }) {
   }
   return table;
 }
-const translator$T = NodeTranslator.from({
+const translator$U = 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$S = NodeTranslator.from({
+const translator$T = NodeTranslator.from({
   xmlName: "w:cnfStyle",
   sdNodeOrKeyName: "cnfStyle",
   attributes: [
@@ -26619,8 +26727,8 @@ const translator$S = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$R = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
-const translator$Q = NodeTranslator.from(
+const translator$S = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
+const translator$R = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridAfter",
     null,
@@ -26629,7 +26737,7 @@ const translator$Q = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$P = NodeTranslator.from(
+const translator$Q = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridBefore",
     null,
@@ -26638,21 +26746,21 @@ const translator$P = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$O = NodeTranslator.from({
+const translator$P = 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$N = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc", "justification"));
-const translator$M = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
-const translator$L = NodeTranslator.from({
+const translator$O = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc", "justification"));
+const translator$N = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
+const translator$M = 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$K = NodeTranslator.from({
+const translator$L = NodeTranslator.from({
   xmlName: "w:trHeight",
   sdNodeOrKeyName: "rowHeight",
   encode: ({ nodes }) => {
@@ -26679,11 +26787,11 @@ const translator$K = NodeTranslator.from({
     return Object.keys(heightAttrs).length > 0 ? { attributes: heightAttrs } : void 0;
   }
 });
-const translator$J = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
-const translator$I = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
-const XML_NODE_NAME$f = "w:trPr";
+const translator$K = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
+const translator$J = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
+const XML_NODE_NAME$g = "w:trPr";
 const SD_ATTR_KEY$4 = "tableRowProperties";
-const encode$m = (params) => {
+const encode$n = (params) => {
   const { nodes } = params;
   const node = nodes[0];
   let attributes = {
@@ -26697,12 +26805,12 @@ const encode$m = (params) => {
   };
   return {
     type: NodeTranslator.translatorTypes.ATTRIBUTE,
-    xmlName: XML_NODE_NAME$f,
+    xmlName: XML_NODE_NAME$g,
     sdNodeOrKeyName: SD_ATTR_KEY$4,
     attributes
   };
 };
-const decode$m = (params) => {
+const decode$n = (params) => {
   const { tableRowProperties = {} } = params.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName$2, tableRowProperties);
   const newNode = {
@@ -26714,6 +26822,7 @@ const decode$m = (params) => {
   return newNode;
 };
 const propertyTranslators$3 = [
+  translator$U,
   translator$T,
   translator$S,
   translator$R,
@@ -26724,8 +26833,7 @@ const propertyTranslators$3 = [
   translator$M,
   translator$L,
   translator$K,
-  translator$J,
-  translator$I
+  translator$J
 ];
 const propertyTranslatorsByXmlName$2 = {};
 propertyTranslators$3.forEach((translator2) => {
@@ -26735,25 +26843,25 @@ const propertyTranslatorsBySdName$2 = {};
 propertyTranslators$3.forEach((translator2) => {
   propertyTranslatorsBySdName$2[translator2.sdNodeOrKeyName] = translator2;
 });
-const config$d = {
-  xmlName: XML_NODE_NAME$f,
+const config$e = {
+  xmlName: XML_NODE_NAME$g,
   sdNodeOrKeyName: SD_ATTR_KEY$4,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$m,
-  decode: decode$m
+  encode: encode$n,
+  decode: decode$n
 };
-const translator$H = NodeTranslator.from(config$d);
-const XML_NODE_NAME$e = "w:tr";
-const SD_NODE_NAME$a = "tableRow";
-const validXmlAttributes$9 = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
+const translator$I = NodeTranslator.from(config$e);
+const XML_NODE_NAME$f = "w:tr";
+const SD_NODE_NAME$b = "tableRow";
+const validXmlAttributes$8 = ["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) {
-    ({ attributes: tableRowProperties } = translator$H.encode({
+    ({ attributes: tableRowProperties } = translator$I.encode({
       ...params,
       nodes: [tPr]
     }));
@@ -26766,7 +26874,7 @@ const encode$l = (params, encodedAttrs) => {
   let currentColumnIndex = 0;
   const content = cellNodes?.map((n) => {
     let columnWidth = gridColumnWidths?.[currentColumnIndex] || null;
-    const result = translator$8.encode({
+    const result = translator$9.encode({
       ...params,
       extraParams: {
         ...params.extraParams,
@@ -26788,7 +26896,7 @@ const encode$l = (params, encodedAttrs) => {
   };
   return newNode;
 };
-const decode$l = (params, decodedAttrs) => {
+const decode$m = (params, decodedAttrs) => {
   const { node } = params;
   const elements = translateChildNodes(params);
   if (node.attrs?.tableRowProperties) {
@@ -26800,7 +26908,7 @@ const decode$l = (params, decodedAttrs) => {
       }
     }
     tableRowProperties["cantSplit"] = node.attrs["cantSplit"];
-    const trPr = translator$H.decode({
+    const trPr = translator$I.decode({
       ...params,
       node: { ...node, attrs: { ...node.attrs, tableRowProperties } }
     });
@@ -26812,22 +26920,22 @@ const decode$l = (params, decodedAttrs) => {
     elements
   };
 };
-const config$c = {
-  xmlName: XML_NODE_NAME$e,
-  sdNodeOrKeyName: SD_NODE_NAME$a,
+const config$d = {
+  xmlName: XML_NODE_NAME$f,
+  sdNodeOrKeyName: SD_NODE_NAME$b,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$l,
-  decode: decode$l,
-  attributes: validXmlAttributes$9
+  encode: encode$m,
+  decode: decode$m,
+  attributes: validXmlAttributes$8
 };
-const translator$G = NodeTranslator.from(config$c);
-const translator$F = NodeTranslator.from({
+const translator$H = NodeTranslator.from(config$d);
+const translator$G = 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$E = NodeTranslator.from({
+const translator$F = NodeTranslator.from({
   xmlName: "w:shd",
   sdNodeOrKeyName: "shading",
   attributes: [
@@ -26849,11 +26957,11 @@ const translator$E = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$D = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblCaption", "caption"));
-const translator$C = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblDescription", "description"));
-const translator$B = NodeTranslator.from(createMeasurementPropertyHandler("w:tblInd", "tableIndent"));
-const translator$A = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblLayout", "tableLayout", "w:type"));
-const translator$z = NodeTranslator.from({
+const translator$E = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblCaption", "caption"));
+const translator$D = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblDescription", "description"));
+const translator$C = NodeTranslator.from(createMeasurementPropertyHandler("w:tblInd", "tableIndent"));
+const translator$B = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblLayout", "tableLayout", "w:type"));
+const translator$A = 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")]),
@@ -26865,16 +26973,16 @@ const translator$z = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$y = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblOverlap", "overlap"));
-const translator$x = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblStyle", "tableStyleId"));
-const translator$w = NodeTranslator.from(
+const translator$z = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblOverlap", "overlap"));
+const translator$y = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblStyle", "tableStyleId"));
+const translator$x = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:tblStyleColBandSize", "tableStyleColBandSize")
 );
-const translator$v = NodeTranslator.from(
+const translator$w = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:tblStyleRowBandSize", "tableStyleRowBandSize")
 );
-const translator$u = NodeTranslator.from(createMeasurementPropertyHandler("w:tblW", "tableWidth"));
-const translator$t = NodeTranslator.from({
+const translator$v = NodeTranslator.from(createMeasurementPropertyHandler("w:tblW", "tableWidth"));
+const translator$u = 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))),
@@ -26886,29 +26994,29 @@ const translator$t = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$s = NodeTranslator.from(createBorderPropertyHandler("w:bottom"));
-const translator$r = NodeTranslator.from(createMeasurementPropertyHandler("w:bottom", "marginBottom"));
-const translator$q = NodeTranslator.from(createBorderPropertyHandler("w:end"));
-const translator$p = NodeTranslator.from(createMeasurementPropertyHandler("w:end", "marginEnd"));
-const translator$o = NodeTranslator.from(createBorderPropertyHandler("w:insideH"));
-const translator$n = NodeTranslator.from(createBorderPropertyHandler("w:insideV"));
-const translator$m = NodeTranslator.from(createBorderPropertyHandler("w:left"));
-const translator$l = NodeTranslator.from(createMeasurementPropertyHandler("w:left", "marginLeft"));
-const translator$k = NodeTranslator.from(createBorderPropertyHandler("w:right"));
-const translator$j = NodeTranslator.from(createMeasurementPropertyHandler("w:right", "marginRight"));
-const translator$i = NodeTranslator.from(createBorderPropertyHandler("w:start"));
-const translator$h = NodeTranslator.from(createMeasurementPropertyHandler("w:start", "marginStart"));
-const translator$g = NodeTranslator.from(createBorderPropertyHandler("w:top"));
-const translator$f = NodeTranslator.from(createMeasurementPropertyHandler("w:top", "marginTop"));
-const XML_NODE_NAME$d = "w:tblBorders";
+const translator$t = NodeTranslator.from(createBorderPropertyHandler("w:bottom"));
+const translator$s = NodeTranslator.from(createMeasurementPropertyHandler("w:bottom", "marginBottom"));
+const translator$r = NodeTranslator.from(createBorderPropertyHandler("w:end"));
+const translator$q = NodeTranslator.from(createMeasurementPropertyHandler("w:end", "marginEnd"));
+const translator$p = NodeTranslator.from(createBorderPropertyHandler("w:insideH"));
+const translator$o = NodeTranslator.from(createBorderPropertyHandler("w:insideV"));
+const translator$n = NodeTranslator.from(createBorderPropertyHandler("w:left"));
+const translator$m = NodeTranslator.from(createMeasurementPropertyHandler("w:left", "marginLeft"));
+const translator$l = NodeTranslator.from(createBorderPropertyHandler("w:right"));
+const translator$k = NodeTranslator.from(createMeasurementPropertyHandler("w:right", "marginRight"));
+const translator$j = NodeTranslator.from(createBorderPropertyHandler("w:start"));
+const translator$i = NodeTranslator.from(createMeasurementPropertyHandler("w:start", "marginStart"));
+const translator$h = NodeTranslator.from(createBorderPropertyHandler("w:top"));
+const translator$g = NodeTranslator.from(createMeasurementPropertyHandler("w:top", "marginTop"));
+const XML_NODE_NAME$e = "w:tblBorders";
 const SD_ATTR_KEY$3 = "borders";
-const encode$k = (params) => {
+const encode$l = (params) => {
   const { nodes } = params;
   const node = nodes[0];
   const attributes = encodeProperties(node, tblBordersTranslatorsByXmlName);
   return Object.keys(attributes).length > 0 ? attributes : void 0;
 };
-const decode$k = (params) => {
+const decode$l = (params) => {
   const { borders = {} } = params.node.attrs || {};
   const elements = decodeProperties(tblBordersTranslatorsBySdName, borders);
   const newNode = {
@@ -26920,14 +27028,14 @@ const decode$k = (params) => {
   return newNode;
 };
 const propertyTranslators$2 = [
-  translator$s,
-  translator$q,
+  translator$t,
+  translator$r,
+  translator$p,
   translator$o,
   translator$n,
-  translator$m,
-  translator$k,
-  translator$i,
-  translator$g
+  translator$l,
+  translator$j,
+  translator$h
 ];
 const tblBordersTranslatorsByXmlName = {};
 const tblBordersTranslatorsBySdName = {};
@@ -26935,27 +27043,27 @@ propertyTranslators$2.forEach((translator2) => {
   tblBordersTranslatorsByXmlName[translator2.xmlName] = translator2;
   tblBordersTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
 });
-const translator$e = NodeTranslator.from({
-  xmlName: XML_NODE_NAME$d,
+const translator$f = NodeTranslator.from({
+  xmlName: XML_NODE_NAME$e,
   sdNodeOrKeyName: SD_ATTR_KEY$3,
   type: NodeTranslator.translatorTypes.NODE,
   attributes: [],
-  encode: encode$k,
-  decode: decode$k
+  encode: encode$l,
+  decode: decode$l
 });
-const XML_NODE_NAME$c = "w:tblCellMar";
+const XML_NODE_NAME$d = "w:tblCellMar";
 const SD_ATTR_KEY$2 = "cellMargins";
-const encode$j = (params) => {
+const encode$k = (params) => {
   const { nodes } = params;
   const node = nodes[0];
   const attributes = encodeProperties(node, propertyTranslatorsByXmlName$1);
   return Object.keys(attributes).length > 0 ? attributes : void 0;
 };
-const decode$j = (params) => {
+const decode$k = (params) => {
   const { cellMargins = {} } = params.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName$1, cellMargins);
   const newNode = {
-    name: XML_NODE_NAME$c,
+    name: XML_NODE_NAME$d,
     type: "element",
     attributes: {},
     elements
@@ -26963,12 +27071,12 @@ const decode$j = (params) => {
   return newNode;
 };
 const propertyTranslators$1 = [
-  translator$r,
-  translator$p,
-  translator$l,
-  translator$j,
-  translator$h,
-  translator$f
+  translator$s,
+  translator$q,
+  translator$m,
+  translator$k,
+  translator$i,
+  translator$g
 ];
 const propertyTranslatorsByXmlName$1 = {};
 const propertyTranslatorsBySdName$1 = {};
@@ -26976,27 +27084,27 @@ propertyTranslators$1.forEach((translator2) => {
   propertyTranslatorsByXmlName$1[translator2.xmlName] = translator2;
   propertyTranslatorsBySdName$1[translator2.sdNodeOrKeyName] = translator2;
 });
-const translator$d = NodeTranslator.from({
-  xmlName: XML_NODE_NAME$c,
+const translator$e = NodeTranslator.from({
+  xmlName: XML_NODE_NAME$d,
   sdNodeOrKeyName: SD_ATTR_KEY$2,
   type: NodeTranslator.translatorTypes.NODE,
   attributes: [],
-  encode: encode$j,
-  decode: decode$j
+  encode: encode$k,
+  decode: decode$k
 });
-const XML_NODE_NAME$b = "w:tblPr";
+const XML_NODE_NAME$c = "w:tblPr";
 const SD_ATTR_KEY$1 = "tableProperties";
-const encode$i = (params) => {
+const encode$j = (params) => {
   const { nodes } = params;
   const node = nodes[0];
   const attributes = encodeProperties(node, propertyTranslatorsByXmlName);
   return {
-    xmlName: XML_NODE_NAME$b,
+    xmlName: XML_NODE_NAME$c,
     sdNodeOrKeyName: SD_ATTR_KEY$1,
     attributes
   };
 };
-const decode$i = (params) => {
+const decode$j = (params) => {
   const { tableProperties = {} } = params.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName, tableProperties);
   const newNode = {
@@ -27008,11 +27116,12 @@ const decode$i = (params) => {
   return newNode;
 };
 const propertyTranslators = [
+  translator$G,
+  translator$O,
   translator$F,
-  translator$N,
   translator$E,
+  translator$N,
   translator$D,
-  translator$M,
   translator$C,
   translator$B,
   translator$A,
@@ -27022,24 +27131,23 @@ const propertyTranslators = [
   translator$w,
   translator$v,
   translator$u,
-  translator$t,
-  translator$e,
-  translator$d
+  translator$f,
+  translator$e
 ];
 const propertyTranslatorsByXmlName = {};
 const propertyTranslatorsBySdName = {};
 propertyTranslators.forEach((translator2) => {
   propertyTranslatorsByXmlName[translator2.xmlName] = translator2;
   propertyTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
-});
-const config$b = {
-  xmlName: XML_NODE_NAME$b,
+});
+const config$c = {
+  xmlName: XML_NODE_NAME$c,
   sdNodeOrKeyName: SD_ATTR_KEY$1,
-  encode: encode$i,
-  decode: decode$i
+  encode: encode$j,
+  decode: decode$j
 };
-const translator$c = NodeTranslator.from(config$b);
-const translator$b = NodeTranslator.from(
+const translator$d = NodeTranslator.from(config$c);
+const translator$c = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:gridCol", "col", "w:w", parseInteger, integerToString)
 );
 const DEFAULT_COLUMN_WIDTH_PX = 100;
@@ -27089,20 +27197,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 = "grid";
 const cellMinWidth = pixelsToTwips(10);
-const encode$h = (params) => {
+const encode$i = (params) => {
   const { nodes } = params;
   const node = nodes[0];
-  const attributes = encodeProperties(node, { [translator$b.xmlName]: translator$b }, true);
+  const attributes = encodeProperties(node, { [translator$c.xmlName]: translator$c }, true);
   return {
-    xmlName: XML_NODE_NAME$a,
+    xmlName: XML_NODE_NAME$b,
     sdNodeOrKeyName: SD_ATTR_KEY,
     attributes
   };
 };
-const decode$h = (params) => {
+const decode$i = (params) => {
   const { grid: rawGrid } = params.node.attrs || {};
   const grid = Array.isArray(rawGrid) ? rawGrid : [];
   const { firstRow = {} } = params.extraParams || {};
@@ -27121,10 +27229,10 @@ const decode$h = (params) => {
       numericWidth = fallbackColumnWidthTwips;
     }
     numericWidth = Math.max(numericWidth, cellMinWidth);
-    const decoded = translator$b.decode({
+    const decoded = translator$c.decode({
       node: { type: (
         /** @type {string} */
-        translator$b.sdNodeOrKeyName
+        translator$c.sdNodeOrKeyName
       ), attrs: { col: numericWidth } }
     });
     if (decoded) elements.push(decoded);
@@ -27159,19 +27267,19 @@ const decode$h = (params) => {
     columnIndex++;
   }
   const newNode = {
-    name: XML_NODE_NAME$a,
+    name: XML_NODE_NAME$b,
     attributes: {},
     elements
   };
   return newNode;
 };
-const config$a = {
-  xmlName: XML_NODE_NAME$a,
+const config$b = {
+  xmlName: XML_NODE_NAME$b,
   sdNodeOrKeyName: SD_ATTR_KEY,
-  encode: encode$h,
-  decode: decode$h
+  encode: encode$i,
+  decode: decode$i
 };
-const translator$a = NodeTranslator.from(config$a);
+const translator$b = NodeTranslator.from(config$b);
 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;
@@ -27234,19 +27342,19 @@ const buildFallbackGridForTable = ({ params, rows, tableWidth, tableWidthMeasure
     columnWidths: Array(columnCount).fill(fallbackColumnWidthPx)
   };
 };
-const XML_NODE_NAME$9 = "w:tbl";
-const SD_NODE_NAME$9 = "table";
-const encode$g = (params, encodedAttrs) => {
+const XML_NODE_NAME$a = "w:tbl";
+const SD_NODE_NAME$a = "table";
+const encode$h = (params, encodedAttrs) => {
   const { nodes } = params;
   const node = nodes[0];
   const tblPr = node.elements.find((el) => el.name === "w:tblPr");
   if (tblPr) {
-    const encodedProperties = translator$c.encode({ ...params, nodes: [tblPr] });
+    const encodedProperties = translator$d.encode({ ...params, nodes: [tblPr] });
     encodedAttrs["tableProperties"] = encodedProperties?.attributes || {};
   }
   const tblGrid = node.elements.find((el) => el.name === "w:tblGrid");
   if (tblGrid) {
-    encodedAttrs["grid"] = translator$a.encode({ ...params, nodes: [tblGrid] }).attributes;
+    encodedAttrs["grid"] = translator$b.encode({ ...params, nodes: [tblGrid] }).attributes;
   }
   [
     "tableStyleId",
@@ -27313,7 +27421,7 @@ const encode$g = (params, encodedAttrs) => {
   }
   const content = [];
   rows.forEach((row) => {
-    const result = translator$G.encode({
+    const result = translator$H.encode({
       ...params,
       nodes: [row],
       extraParams: {
@@ -27332,13 +27440,13 @@ const encode$g = (params, encodedAttrs) => {
     attrs: encodedAttrs
   };
 };
-const decode$g = (params, decodedAttrs) => {
+const decode$h = (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$a.decode({
+  const element = translator$b.decode({
     ...params,
     node: { ...node, attrs: { ...node.attrs, grid: properties } },
     extraParams: {
@@ -27348,7 +27456,7 @@ const decode$g = (params, decodedAttrs) => {
   if (element) elements.unshift(element);
   if (node.attrs?.tableProperties) {
     const properties2 = { ...node.attrs.tableProperties };
-    const element2 = translator$c.decode({
+    const element2 = translator$d.decode({
       ...params,
       node: { ...node, attrs: { ...node.attrs, tableProperties: properties2 } }
     });
@@ -27414,7 +27522,7 @@ function _getReferencedTableStyles(tableStyleReference, params) {
     if (baseTblPr && baseTblPr.elements) {
       tblPr.elements.push(...baseTblPr.elements);
     }
-    const tableProperties = translator$c.encode({ ...params, nodes: [tblPr] }).attributes;
+    const tableProperties = translator$d.encode({ ...params, nodes: [tblPr] }).attributes;
     const { borders, rowBorders } = _processTableBorders(tableProperties.borders || {});
     if (borders) stylesToReturn.borders = borders;
     if (rowBorders) stylesToReturn.rowBorders = rowBorders;
@@ -27431,16 +27539,16 @@ function _getReferencedTableStyles(tableStyleReference, params) {
   }
   return stylesToReturn;
 }
-const config$9 = {
-  xmlName: XML_NODE_NAME$9,
-  sdNodeOrKeyName: SD_NODE_NAME$9,
+const config$a = {
+  xmlName: XML_NODE_NAME$a,
+  sdNodeOrKeyName: SD_NODE_NAME$a,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$g,
-  decode: decode$g,
+  encode: encode$h,
+  decode: decode$h,
   attributes: []
 };
-const translator$9 = NodeTranslator.from(config$9);
-const tableNodeHandlerEntity = generateV2HandlerEntity("tableNodeHandler", translator$9);
+const translator$a = NodeTranslator.from(config$a);
+const tableNodeHandlerEntity = generateV2HandlerEntity("tableNodeHandler", translator$a);
 function getReferencedTableStyles(tblStyleTag, docx) {
   if (!tblStyleTag) return null;
   const stylesToReturn = {};
@@ -27802,10 +27910,10 @@ function generateCellMargins(cellMargins) {
   if (left != null) elements.push({ name: "w:left", attributes: { "w:w": pixelsToTwips(left) } });
   return elements;
 }
-const XML_NODE_NAME$8 = "w:tc";
-const SD_NODE_NAME$8 = "tableCell";
-const validXmlAttributes$8 = [];
-function encode$f(params, encodedAttrs) {
+const XML_NODE_NAME$9 = "w:tc";
+const SD_NODE_NAME$9 = "tableCell";
+const validXmlAttributes$7 = [];
+function encode$g(params, encodedAttrs) {
   const {
     node,
     table,
@@ -27832,162 +27940,22 @@ function encode$f(params, encodedAttrs) {
   }
   return schemaNode;
 }
-function decode$f(params, decodedAttrs) {
+function decode$g(params, decodedAttrs) {
   const translated = translateTableCell(params);
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
     translated.attributes = { ...translated.attributes || {}, ...decodedAttrs };
   }
   return translated;
 }
-const config$8 = {
-  xmlName: XML_NODE_NAME$8,
-  sdNodeOrKeyName: SD_NODE_NAME$8,
-  type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$f,
-  decode: decode$f,
-  attributes: validXmlAttributes$8
-};
-const translator$8 = NodeTranslator.from(config$8);
-const XML_NODE_NAME$7 = "w:hyperlink";
-const SD_NODE_NAME$7 = "link";
-const _createAttributeHandler = (xmlName, sdName) => ({
-  xmlName,
-  sdName,
-  encode: (attributes) => attributes[xmlName],
-  decode: (attributes) => attributes[sdName]
-});
-const validXmlAttributes$7 = [
-  _createAttributeHandler("w:anchor", "anchor"),
-  _createAttributeHandler("w:docLocation", "docLocation"),
-  {
-    xmlName: "w:history",
-    sdName: "history",
-    encode: (attributes) => attributes["w:history"] === "1" || attributes["w:history"] === "true",
-    decode: (attributes) => attributes["history"] ? "1" : "0"
-  },
-  _createAttributeHandler("w:tooltip", "tooltip"),
-  _createAttributeHandler("r:id", "rId"),
-  _createAttributeHandler("w:tgtFrame", "target")
-];
-const encode$e = (params, encodedAttrs) => {
-  const { nodes, docx, nodeListHandler } = params;
-  const node = nodes[0];
-  let href = _resolveHref(docx, encodedAttrs);
-  const linkMark = { attrs: { ...encodedAttrs, href } };
-  const runNodes = node.elements.filter((el) => el.name === "w:r");
-  runNodes.forEach((runNode) => {
-    const existingRunMarks = Array.isArray(runNode.marks) ? runNode.marks : [];
-    const runMarksWithoutLink = existingRunMarks.filter((mark) => mark?.type !== "link");
-    runNode.marks = runMarksWithoutLink;
-  });
-  const updatedNode = nodeListHandler.handler({
-    ...params,
-    nodes: runNodes,
-    path: [...params.path || [], node]
-  });
-  const cloneMark2 = (mark) => {
-    if (!mark || typeof mark !== "object") return mark;
-    if (!mark.attrs) return { ...mark };
-    return { ...mark, attrs: { ...mark.attrs } };
-  };
-  const ensureLinkMark = (child) => {
-    if (!child || typeof child !== "object") return child;
-    if (Array.isArray(child.content)) {
-      const updatedContent = child.content.map((item) => ensureLinkMark(item));
-      if (updatedContent !== child.content) {
-        child = { ...child, content: updatedContent };
-      }
-    }
-    if (child.type === "run") {
-      const existingMarks2 = Array.isArray(child.marks) ? child.marks : [];
-      const filteredMarks = existingMarks2.filter((mark) => mark?.type !== "link").map((mark) => cloneMark2(mark));
-      if (filteredMarks.length !== existingMarks2.length) {
-        if (filteredMarks.length) child = { ...child, marks: filteredMarks };
-        else {
-          const { marks: _removedMarks, ...rest } = child;
-          child = rest;
-        }
-      }
-      return child;
-    }
-    if (child.type !== "text") return child;
-    const existingMarks = Array.isArray(child.marks) ? child.marks.map((mark) => cloneMark2(mark)) : [];
-    const hasLink = existingMarks.some((mark) => mark?.type === "link");
-    if (hasLink) return child;
-    const linkClone = { type: "link", attrs: { ...linkMark.attrs } };
-    return { ...child, marks: [...existingMarks, linkClone] };
-  };
-  if (!Array.isArray(updatedNode)) return updatedNode;
-  return updatedNode.map((child) => ensureLinkMark(child));
-};
-const _resolveHref = (docx, encodedAttrs) => {
-  const rels = docx["word/_rels/document.xml.rels"];
-  const relationships = rels.elements.find((el) => el.name === "Relationships");
-  const { elements } = relationships;
-  const { rId, anchor } = encodedAttrs;
-  let href;
-  if (!rId && anchor) {
-    href = `#${anchor}`;
-  } else if (rId) {
-    const rel = elements.find((el) => el.attributes["Id"] === rId) || {};
-    const { attributes: relAttributes = {} } = rel;
-    href = relAttributes["Target"];
-  }
-  return href;
-};
-function decode$e(params) {
-  const { node } = params;
-  const linkMark = node.marks.find((m2) => m2.type === "link");
-  const linkAttrs = this.decodeAttributes({ ...params, node: linkMark });
-  let { anchor, href: link } = linkMark.attrs;
-  const isExternalLink = !anchor;
-  if (isExternalLink) {
-    linkAttrs["r:id"] = _addNewLinkRelationship(params, link, linkAttrs["r:id"]);
-  }
-  node.marks = node.marks.filter((m2) => m2.type !== "link");
-  const outputNode = exportSchemaToJson({ ...params, node });
-  const newNode = {
-    name: "w:hyperlink",
-    type: "element",
-    attributes: {
-      ...linkAttrs
-    },
-    elements: [outputNode]
-  };
-  return newNode;
-}
-function _addNewLinkRelationship(params, link, rId) {
-  if (!rId) rId = generateDocxRandomId();
-  if (!params.relationships || !Array.isArray(params.relationships)) {
-    params.relationships = [];
-  }
-  const existingRel = params.relationships.find(
-    (rel) => rel.attributes && rel.attributes.Id === rId && rel.attributes.Target === link
-  );
-  if (existingRel) {
-    return rId;
-  }
-  params.relationships.push({
-    type: "element",
-    name: "Relationship",
-    attributes: {
-      Id: rId,
-      Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
-      Target: link,
-      TargetMode: "External"
-    }
-  });
-  return rId;
-}
-const config$7 = {
-  xmlName: XML_NODE_NAME$7,
-  sdNodeOrKeyName: SD_NODE_NAME$7,
+const config$9 = {
+  xmlName: XML_NODE_NAME$9,
+  sdNodeOrKeyName: SD_NODE_NAME$9,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$e,
-  decode: decode$e,
+  encode: encode$g,
+  decode: decode$g,
   attributes: validXmlAttributes$7
 };
-const translator$7 = NodeTranslator.from(config$7);
+const translator$9 = NodeTranslator.from(config$9);
 function parseTagValueJSON(json) {
   if (typeof json !== "string") {
     return {};
@@ -28123,12 +28091,32 @@ function handleDocPartObj(params) {
   }
   const content = node?.elements.find((el) => el.name === "w:sdtContent");
   const handler2 = validGalleryTypeMap[docPartGalleryType];
-  const result = handler2({ ...params, nodes: [content] });
+  const result = handler2({
+    ...params,
+    nodes: [content],
+    extraParams: { ...params.extraParams || {}, sdtPr }
+  });
   return result;
 }
 const tableOfContentsHandler = (params) => {
   const node = params.nodes[0];
-  return params.nodeListHandler.handler({ ...params, nodes: node.elements });
+  const translatedContent = params.nodeListHandler.handler({
+    ...params,
+    nodes: node.elements,
+    path: [...params.path || [], node]
+  });
+  const sdtPr = params.extraParams.sdtPr;
+  const id = sdtPr.elements?.find((el) => el.name === "w:id")?.attributes["w:val"] || "";
+  const result = {
+    type: "documentPartObject",
+    content: translatedContent,
+    attrs: {
+      id,
+      docPartGallery: "Table of Contents",
+      docPartUnique: true
+    }
+  };
+  return result;
 };
 const validGalleryTypeMap = {
   "Table of Contents": tableOfContentsHandler
@@ -28786,32 +28774,32 @@ function translateAnchorNode(params) {
     elements: [...anchorElements, ...elementsWithWrap]
   };
 }
-const XML_NODE_NAME$6 = "wp:anchor";
-const SD_NODE_NAME$6 = ["image"];
+const XML_NODE_NAME$8 = "wp:anchor";
+const SD_NODE_NAME$8 = ["image"];
 const validXmlAttributes$6 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
-function encode$d(params) {
+function encode$f(params) {
   const { node } = params.extraParams;
   if (!node || !node.type) {
     return null;
   }
   return handleAnchorNode(params);
 }
-function decode$d(params) {
+function decode$f(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
   }
   return translateAnchorNode(params);
 }
-const config$6 = {
-  xmlName: XML_NODE_NAME$6,
-  sdNodeOrKeyName: SD_NODE_NAME$6,
+const config$8 = {
+  xmlName: XML_NODE_NAME$8,
+  sdNodeOrKeyName: SD_NODE_NAME$8,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$d,
-  decode: decode$d,
+  encode: encode$f,
+  decode: decode$f,
   attributes: validXmlAttributes$6
 };
-const translator$6 = NodeTranslator.from(config$6);
+const translator$8 = NodeTranslator.from(config$8);
 function handleInlineNode(params) {
   const { node } = params.extraParams;
   if (node.name !== "wp:inline") {
@@ -28827,41 +28815,41 @@ function translateInlineNode(params) {
     elements: nodeElements.elements
   };
 }
-const XML_NODE_NAME$5 = "wp:inline";
-const SD_NODE_NAME$5 = ["image"];
+const XML_NODE_NAME$7 = "wp:inline";
+const SD_NODE_NAME$7 = ["image"];
 const validXmlAttributes$5 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
-function encode$c(params) {
+function encode$e(params) {
   const { node } = params.extraParams;
   if (!node || !node.type) {
     return null;
   }
   return handleInlineNode(params);
 }
-function decode$c(params) {
+function decode$e(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
   }
   return translateInlineNode(params);
 }
-const config$5 = {
-  xmlName: XML_NODE_NAME$5,
-  sdNodeOrKeyName: SD_NODE_NAME$5,
+const config$7 = {
+  xmlName: XML_NODE_NAME$7,
+  sdNodeOrKeyName: SD_NODE_NAME$7,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$c,
-  decode: decode$c,
+  encode: encode$e,
+  decode: decode$e,
   attributes: validXmlAttributes$5
 };
-const translator$5 = NodeTranslator.from(config$5);
-const XML_NODE_NAME$4 = "w:drawing";
-const SD_NODE_NAME$4 = [];
+const translator$7 = NodeTranslator.from(config$7);
+const XML_NODE_NAME$6 = "w:drawing";
+const SD_NODE_NAME$6 = [];
 const validXmlAttributes$4 = [];
-function encode$b(params) {
+function encode$d(params) {
   const nodes = params.nodes;
   const node = nodes[0];
   const translatorByChildName = {
-    "wp:anchor": translator$6,
-    "wp:inline": translator$5
+    "wp:anchor": translator$8,
+    "wp:inline": translator$7
   };
   return node.elements.reduce((acc, child) => {
     if (acc) return acc;
@@ -28870,12 +28858,12 @@ function encode$b(params) {
     return translator2.encode({ ...params, extraParams: { node: child } }) || acc;
   }, null);
 }
-function decode$b(params) {
+function decode$d(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
   }
-  const childTranslator = node.attrs.isAnchor ? translator$6 : translator$5;
+  const childTranslator = node.attrs.isAnchor ? translator$8 : translator$7;
   const resultNode = childTranslator.decode(params);
   return wrapTextInRun(
     {
@@ -28885,15 +28873,15 @@ function decode$b(params) {
     []
   );
 }
-const config$4 = {
-  xmlName: XML_NODE_NAME$4,
-  sdNodeOrKeyName: SD_NODE_NAME$4,
+const config$6 = {
+  xmlName: XML_NODE_NAME$6,
+  sdNodeOrKeyName: SD_NODE_NAME$6,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$b,
-  decode: decode$b,
+  encode: encode$d,
+  decode: decode$d,
   attributes: validXmlAttributes$4
 };
-const translator$4 = NodeTranslator.from(config$4);
+const translator$6 = NodeTranslator.from(config$6);
 class CommandService {
   /**
    * @param {import('./commands/types/index.js').CommandServiceOptions} props
@@ -30231,7 +30219,7 @@ function prepareTextAnnotation(params) {
   return getTextNodeForExport(attrs.displayLabel, [...marks, ...marksFromAttrs], params);
 }
 function prepareImageAnnotation(params, imageSize) {
-  return translator$4.decode({
+  return translator$6.decode({
     ...params,
     imageSize
   });
@@ -30451,6 +30439,49 @@ const generateSdtPrTagForDocumentSection = (id, title, tag) => {
     ]
   };
 };
+function translateDocumentPartObj(params) {
+  const { node } = params;
+  const { attrs = {} } = node;
+  const childContent = translateChildNodes({ ...params, nodes: node.content });
+  const nodeElements = [
+    {
+      name: "w:sdtPr",
+      elements: [
+        {
+          name: "w:id",
+          attributes: {
+            "w:val": attrs.id
+          }
+        },
+        {
+          name: "w:docPartObj",
+          elements: [
+            {
+              name: "w:docPartGallery",
+              attributes: {
+                "w:val": attrs.docPartGallery
+              }
+            },
+            ...attrs.docPartUnique ? [
+              {
+                name: "w:docPartUnique"
+              }
+            ] : []
+          ]
+        }
+      ]
+    },
+    {
+      name: "w:sdtContent",
+      elements: childContent
+    }
+  ];
+  const result = {
+    name: "w:sdt",
+    elements: nodeElements
+  };
+  return result;
+}
 function translateStructuredContent(params) {
   const { node } = params;
   const childContent = translateChildNodes({ ...params, nodes: node.content });
@@ -30502,10 +30533,10 @@ function generateSdtPrTagForStructuredContent({ node }) {
   };
   return result;
 }
-const XML_NODE_NAME$3 = "w:sdt";
-const SD_NODE_NAME$3 = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
+const XML_NODE_NAME$5 = "w:sdt";
+const SD_NODE_NAME$5 = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
 const validXmlAttributes$3 = [];
-function encode$a(params) {
+function encode$c(params) {
   const nodes = params.nodes;
   const node = nodes[0];
   const { type: sdtType, handler: handler2 } = sdtNodeTypeStrategy(node);
@@ -30515,7 +30546,7 @@ function encode$a(params) {
   const result = handler2(params);
   return result;
 }
-function decode$a(params) {
+function decode$c(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
@@ -30525,91 +30556,93 @@ function decode$a(params) {
     structuredContent: () => translateStructuredContent(params),
     structuredContentBlock: () => translateStructuredContent(params),
     documentSection: () => translateDocumentSection(params),
+    documentPartObject: () => translateDocumentPartObj(params),
+    // Handled in doc-part-obj translator
     default: () => null
   };
   const decoder = types2[node.type] ?? types2.default;
   const result = decoder();
   return result;
 }
-const config$3 = {
-  xmlName: XML_NODE_NAME$3,
-  sdNodeOrKeyName: SD_NODE_NAME$3,
+const config$5 = {
+  xmlName: XML_NODE_NAME$5,
+  sdNodeOrKeyName: SD_NODE_NAME$5,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$a,
-  decode: decode$a,
+  encode: encode$c,
+  decode: decode$c,
   attributes: validXmlAttributes$3
 };
-const translator$3 = NodeTranslator.from(config$3);
-const encode$9 = (attributes) => {
+const translator$5 = NodeTranslator.from(config$5);
+const encode$b = (attributes) => {
   return attributes["w:id"];
 };
-const decode$9 = (attrs) => {
+const decode$b = (attrs) => {
   return attrs.id;
 };
 const attrConfig$6 = Object.freeze({
   xmlName: "w:id",
   sdName: "id",
-  encode: encode$9,
-  decode: decode$9
+  encode: encode$b,
+  decode: decode$b
 });
-const encode$8 = (attributes) => {
+const encode$a = (attributes) => {
   return attributes["w:name"];
 };
-const decode$8 = (attrs) => {
+const decode$a = (attrs) => {
   return attrs.name;
 };
 const attrConfig$5 = Object.freeze({
   xmlName: "w:name",
   sdName: "name",
-  encode: encode$8,
-  decode: decode$8
+  encode: encode$a,
+  decode: decode$a
 });
-const encode$7 = (attributes) => {
+const encode$9 = (attributes) => {
   return attributes["w:colFirst"];
 };
-const decode$7 = (attrs) => {
+const decode$9 = (attrs) => {
   return attrs.colFirst;
 };
 const attrConfig$4 = Object.freeze({
   xmlName: "w:colFirst",
   sdName: "colFirst",
-  encode: encode$7,
-  decode: decode$7
+  encode: encode$9,
+  decode: decode$9
 });
-const encode$6 = (attributes) => {
+const encode$8 = (attributes) => {
   return attributes["w:colLast"];
 };
-const decode$6 = (attrs) => {
+const decode$8 = (attrs) => {
   return attrs.colLast;
 };
 const attrConfig$3 = Object.freeze({
   xmlName: "w:colLast",
   sdName: "colLast",
-  encode: encode$6,
-  decode: decode$6
+  encode: encode$8,
+  decode: decode$8
 });
-const encode$5 = (attributes) => {
+const encode$7 = (attributes) => {
   return attributes["w:displacedByCustomXml"];
 };
-const decode$5 = (attrs) => {
+const decode$7 = (attrs) => {
   return attrs.displacedByCustomXml;
 };
 const attrConfig$2 = Object.freeze({
   xmlName: "w:displacedByCustomXml",
   sdName: "displacedByCustomXml",
-  encode: encode$5,
-  decode: decode$5
+  encode: encode$7,
+  decode: decode$7
 });
 const validXmlAttributes$2 = [attrConfig$6, attrConfig$5, attrConfig$4, attrConfig$3, attrConfig$2];
-const XML_NODE_NAME$2 = "w:bookmarkStart";
-const SD_NODE_NAME$2 = "bookmarkStart";
-const encode$4 = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$4 = "w:bookmarkStart";
+const SD_NODE_NAME$4 = "bookmarkStart";
+const encode$6 = (params, encodedAttrs = {}) => {
   return {
     type: "bookmarkStart",
     attrs: encodedAttrs
   };
 };
-const decode$4 = (params, decodedAttrs = {}) => {
+const decode$6 = (params, decodedAttrs = {}) => {
   const result = {
     name: "w:bookmarkStart",
     elements: []
@@ -30619,49 +30652,49 @@ const decode$4 = (params, decodedAttrs = {}) => {
   }
   return result;
 };
-const config$2 = {
-  xmlName: XML_NODE_NAME$2,
-  sdNodeOrKeyName: SD_NODE_NAME$2,
+const config$4 = {
+  xmlName: XML_NODE_NAME$4,
+  sdNodeOrKeyName: SD_NODE_NAME$4,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$4,
-  decode: decode$4,
+  encode: encode$6,
+  decode: decode$6,
   attributes: validXmlAttributes$2
 };
-const translator$2 = NodeTranslator.from(config$2);
-const encode$3 = (attributes) => {
+const translator$4 = NodeTranslator.from(config$4);
+const encode$5 = (attributes) => {
   return attributes["w:id"];
 };
-const decode$3 = (attrs) => {
+const decode$5 = (attrs) => {
   return attrs.id;
 };
 const attrConfig$1 = Object.freeze({
   xmlName: "w:id",
   sdName: "id",
-  encode: encode$3,
-  decode: decode$3
+  encode: encode$5,
+  decode: decode$5
 });
-const encode$2 = (attributes) => {
+const encode$4 = (attributes) => {
   return attributes["w:displacedByCustomXml"];
 };
-const decode$2 = (attrs) => {
+const decode$4 = (attrs) => {
   return attrs.displacedByCustomXml;
 };
 const attrConfig = Object.freeze({
   xmlName: "w:displacedByCustomXml",
   sdName: "displacedByCustomXml",
-  encode: encode$2,
-  decode: decode$2
+  encode: encode$4,
+  decode: decode$4
 });
 const validXmlAttributes$1 = [attrConfig$1, attrConfig];
-const XML_NODE_NAME$1 = "w:bookmarkEnd";
-const SD_NODE_NAME$1 = "bookmarkEnd";
-const encode$1 = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$3 = "w:bookmarkEnd";
+const SD_NODE_NAME$3 = "bookmarkEnd";
+const encode$3 = (params, encodedAttrs = {}) => {
   return {
     type: "bookmarkEnd",
     attrs: encodedAttrs
   };
 };
-const decode$1 = (params, decodedAttrs = {}) => {
+const decode$3 = (params, decodedAttrs = {}) => {
   const result = {
     name: "w:bookmarkEnd",
     elements: []
@@ -30671,19 +30704,19 @@ const decode$1 = (params, decodedAttrs = {}) => {
   }
   return result;
 };
-const config$1 = {
-  xmlName: XML_NODE_NAME$1,
-  sdNodeOrKeyName: SD_NODE_NAME$1,
+const config$3 = {
+  xmlName: XML_NODE_NAME$3,
+  sdNodeOrKeyName: SD_NODE_NAME$3,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$1,
-  decode: decode$1,
+  encode: encode$3,
+  decode: decode$3,
   attributes: validXmlAttributes$1
 };
-const translator$1 = NodeTranslator.from(config$1);
-const XML_NODE_NAME = "mc:AlternateContent";
-const SD_NODE_NAME = [];
+const translator$3 = NodeTranslator.from(config$3);
+const XML_NODE_NAME$2 = "mc:AlternateContent";
+const SD_NODE_NAME$2 = [];
 const validXmlAttributes = [];
-function encode(params) {
+function encode$2(params) {
   const { nodeListHandler } = params;
   const { node } = params.extraParams;
   if (!node || !node.type) {
@@ -30703,7 +30736,7 @@ function encode(params) {
     path: [...params.path || [], wpsNode]
   });
 }
-function decode(params) {
+function decode$2(params) {
   const { node } = params;
   const { drawingContent } = node.attrs;
   const drawing = {
@@ -30720,13 +30753,186 @@ function decode(params) {
     elements: [choice]
   };
 }
+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
+};
+const translator$2 = NodeTranslator.from(config$2);
+const XML_NODE_NAME$1 = "sd:pageReference";
+const SD_NODE_NAME$1 = "pageReference";
+const encode$1 = (params, _2) => {
+  const { nodes = [], nodeListHandler } = params || {};
+  const node = nodes[0];
+  const processedText = nodeListHandler.handler({
+    ...params,
+    nodes: node.elements
+  });
+  const processedNode = {
+    type: "pageReference",
+    attrs: {
+      instruction: node.attributes?.instruction || "",
+      marksAsAttrs: node.marks || []
+    },
+    content: processedText
+  };
+  return processedNode;
+};
+const decode$1 = (params, _2) => {
+  const { node } = params;
+  const outputMarks = processOutputMarks(node.attrs?.marksAsAttrs || []);
+  const contentNodes = (node.content ?? []).flatMap((n) => exportSchemaToJson({ ...params, node: n }));
+  const translated = [
+    {
+      name: "w:r",
+      elements: [
+        {
+          name: "w:rPr",
+          elements: outputMarks
+        },
+        {
+          name: "w:fldChar",
+          attributes: {
+            "w:fldCharType": "begin"
+          }
+        }
+      ]
+    },
+    {
+      name: "w:r",
+      elements: [
+        {
+          name: "w:rPr",
+          elements: outputMarks
+        },
+        {
+          name: "w:instrText",
+          attributes: { "xml:space": "preserve" },
+          elements: [
+            {
+              type: "text",
+              text: `${node.attrs.instruction}`
+            }
+          ]
+        }
+      ]
+    },
+    {
+      name: "w:r",
+      elements: [
+        {
+          name: "w:rPr",
+          elements: outputMarks
+        },
+        {
+          name: "w:fldChar",
+          attributes: {
+            "w:fldCharType": "separate"
+          }
+        }
+      ]
+    },
+    ...contentNodes,
+    {
+      name: "w:r",
+      elements: [
+        {
+          name: "w:rPr",
+          elements: outputMarks
+        },
+        {
+          name: "w:fldChar",
+          attributes: {
+            "w:fldCharType": "end"
+          }
+        }
+      ]
+    }
+  ];
+  return translated;
+};
+const config$1 = {
+  xmlName: XML_NODE_NAME$1,
+  sdNodeOrKeyName: SD_NODE_NAME$1,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$1,
+  decode: decode$1
+};
+const translator$1 = NodeTranslator.from(config$1);
+const XML_NODE_NAME = "sd:tableOfContents";
+const SD_NODE_NAME = "tableOfContents";
+const encode = (params, _2) => {
+  const { nodes = [], nodeListHandler } = params || {};
+  const node = nodes[0];
+  const processedContent = nodeListHandler.handler({
+    ...params,
+    nodes: node.elements || []
+  });
+  const processedNode = {
+    type: "tableOfContents",
+    attrs: {
+      instruction: node.attributes?.instruction || ""
+    },
+    content: processedContent
+  };
+  return processedNode;
+};
+const decode = (params, _2) => {
+  const { node } = params;
+  const contentNodes = node.content.map((n) => exportSchemaToJson({ ...params, node: n }));
+  const tocBeginElements = [
+    {
+      name: "w:r",
+      elements: [{ name: "w:fldChar", attributes: { "w:fldCharType": "begin" }, elements: [] }]
+    },
+    {
+      name: "w:r",
+      elements: [
+        {
+          name: "w:instrText",
+          attributes: { "xml:space": "preserve" },
+          elements: [{ text: node.attrs?.instruction || "", type: "text", name: "#text", elements: [] }]
+        }
+      ]
+    },
+    { name: "w:r", elements: [{ name: "w:fldChar", attributes: { "w:fldCharType": "separate" }, elements: [] }] }
+  ];
+  if (contentNodes.length > 0) {
+    const firstParagraph = contentNodes[0];
+    let insertIndex = 0;
+    if (firstParagraph.elements) {
+      const pPrIndex = firstParagraph.elements.findIndex((el) => el.name === "w:pPr");
+      insertIndex = pPrIndex >= 0 ? pPrIndex + 1 : 0;
+    } else {
+      firstParagraph.elements = [];
+    }
+    firstParagraph.elements.splice(insertIndex, 0, ...tocBeginElements);
+  } else {
+    contentNodes.push({
+      name: "w:p",
+      elements: tocBeginElements
+    });
+  }
+  const tocEndElements = [
+    { name: "w:r", elements: [{ name: "w:fldChar", attributes: { "w:fldCharType": "end" }, elements: [] }] }
+  ];
+  const lastParagraph = contentNodes[contentNodes.length - 1];
+  if (lastParagraph.elements) {
+    lastParagraph.elements.push(...tocEndElements);
+  } else {
+    lastParagraph.elements = [...tocEndElements];
+  }
+  return contentNodes;
+};
 const config = {
   xmlName: XML_NODE_NAME,
   sdNodeOrKeyName: SD_NODE_NAME,
   type: NodeTranslator.translatorTypes.NODE,
   encode,
-  decode,
-  attributes: validXmlAttributes
+  decode
 };
 const translator = NodeTranslator.from(config);
 const DEFAULT_SECTION_PROPS_TWIPS = Object.freeze({
@@ -30800,32 +31006,35 @@ function exportSchemaToJson(params) {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$13,
-    run: translator$U,
+    paragraph: translator$16,
+    run: translator$V,
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$16,
-    table: translator$9,
-    tableRow: translator$G,
-    tableCell: translator$8,
-    bookmarkStart: translator$2,
-    bookmarkEnd: translator$1,
-    fieldAnnotation: translator$3,
-    tab: translator$14,
-    image: translator$4,
-    hardBreak: translator$16,
+    lineBreak: translator$19,
+    table: translator$a,
+    tableRow: translator$H,
+    tableCell: translator$9,
+    bookmarkStart: translator$4,
+    bookmarkEnd: translator$3,
+    fieldAnnotation: translator$5,
+    tab: translator$17,
+    image: translator$6,
+    hardBreak: translator$19,
     commentRangeStart: () => translateCommentNode(params, "Start"),
     commentRangeEnd: () => translateCommentNode(params, "End"),
     commentReference: () => null,
     shapeContainer: translateShapeContainer,
     shapeTextbox: translateShapeTextbox,
     contentBlock: translateContentBlock,
-    structuredContent: translator$3,
-    structuredContentBlock: translator$3,
-    documentSection: translator$3,
+    structuredContent: translator$5,
+    structuredContentBlock: translator$5,
+    documentPartObject: translator$5,
+    documentSection: translator$5,
     "page-number": translatePageNumberNode,
-    "total-page-number": translateTotalPageNumberNode
+    "total-page-number": translateTotalPageNumberNode,
+    pageReference: translator$1,
+    tableOfContents: translator
   };
   let handler2 = router[type2];
   if (handler2 && "decode" in handler2 && typeof handler2.decode === "function") {
@@ -31163,8 +31372,6 @@ function translateTextNode(params) {
   const trackedMarks = [TrackInsertMarkName, TrackDeleteMarkName];
   const isTrackedNode = node.marks?.some((m2) => trackedMarks.includes(m2.type));
   if (isTrackedNode) return translateTrackedNode(params);
-  const isLinkNode = node.marks?.some((m2) => m2.type === "link");
-  if (isLinkNode) return translator$7.decode(params);
   const { text, marks = [] } = node;
   return getTextNodeForExport(text, marks, params);
 }
@@ -31470,7 +31677,7 @@ function translateMark(mark) {
       markElement.type = "element";
       break;
     case "underline": {
-      const translated = translator$10.decode({
+      const translated = translator$13.decode({
         node: {
           attrs: {
             underlineType: attrs.underlineType ?? attrs.underline ?? null,
@@ -31534,7 +31741,7 @@ function translateMark(mark) {
       break;
     case "highlight": {
       const highlightValue = attrs.color ?? attrs.highlight ?? null;
-      const translated = translator$15.decode({ node: { attrs: { highlight: highlightValue } } });
+      const translated = translator$18.decode({ node: { attrs: { highlight: highlightValue } } });
       return translated || {};
     }
   }
@@ -31594,7 +31801,7 @@ function translateContentBlock(params) {
   if (vmlAttributes || horizontalRule) {
     return translateVRectContentBlock(params);
   }
-  const alternateContent = translator.decode(params);
+  const alternateContent = translator$2.decode(params);
   return wrapTextInRun(alternateContent);
 }
 function translateVRectContentBlock(params) {
@@ -31740,6 +31947,7 @@ const getAutoPageJson = (type2, outputMarks = []) => {
         },
         {
           name: "w:instrText",
+          attributes: { "xml:space": "preserve" },
           elements: [
             {
               type: "text",
@@ -31799,7 +32007,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$4.encode(params);
+  const schemaNode = translator$6.encode(params);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -31901,8 +32109,8 @@ const trackChangeNodeHandlerEntity = {
   handlerName: "trackChangeNodeHandler",
   handler: handleTrackChangeNode
 };
-const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$7);
-const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$U);
+const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$W);
+const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$V);
 const handleTextNode = (params) => {
   const { nodes, insideTrackChange } = params;
   if (nodes.length === 0 || !(nodes[0].name === "w:t" || insideTrackChange && nodes[0].name === "w:delText")) {
@@ -31943,7 +32151,7 @@ const handleParagraphNode = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$13.encode(params);
+  const schemaNode = translator$16.encode(params);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -31956,7 +32164,7 @@ const handleSdtNode = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:sdt") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$3.encode(params);
+  const result = translator$5.encode(params);
   if (!result) {
     return { nodes: [], consumed: 0 };
   }
@@ -32046,7 +32254,7 @@ const handler = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$16.encode(params);
+  const result = translator$19.encode(params);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -32118,7 +32326,7 @@ const handleBookmarkStartNode = (params) => {
   if (isCustomMarkBookmark(nodes[0], params.editor)) {
     return handleBookmarkNode(params);
   }
-  const node = translator$2.encode(params);
+  const node = translator$4.encode(params);
   if (!node) return { nodes: [], consumed: 0 };
   return { nodes: [node], consumed: 1 };
 };
@@ -32150,7 +32358,7 @@ const handleBookmarkEndNode = (params) => {
   if (!nodes.length || nodes[0].name !== "w:bookmarkEnd") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$1.encode(params);
+  const node = translator$3.encode(params);
   if (!node) return { nodes: [], consumed: 0 };
   return { nodes: [node], consumed: 1 };
 };
@@ -32283,6 +32491,7 @@ const autoTotalPageCountEntity = {
   handlerName: "autoTotalPageCountEntity",
   handler: handleAutoTotalPageNumber
 };
+const pageReferenceEntity = generateV2HandlerEntity("pageReferenceNodeHandler", translator$1);
 const handlePictNode = (params) => {
   const { nodes } = params;
   if (!nodes.length || nodes[0].name !== "w:p") {
@@ -32781,6 +32990,7 @@ const getDefaultStyleDefinition = (defaultStyleId, docx) => {
   const spacing = pPr?.elements?.find((el) => el.name === "w:spacing");
   const justify = pPr?.elements?.find((el) => el.name === "w:jc");
   const indent = pPr?.elements?.find((el) => el.name === "w:ind");
+  const tabs = pPr?.elements?.find((el) => el.name === "w:tabs");
   let lineSpaceBefore, lineSpaceAfter, line;
   if (spacing) {
     lineSpaceBefore = twipsToPixels(spacing?.attributes["w:before"]);
@@ -32794,6 +33004,22 @@ const getDefaultStyleDefinition = (defaultStyleId, docx) => {
     rightIndent = twipsToPixels(indent?.attributes["w:right"]);
     firstLine = twipsToPixels(indent?.attributes["w:firstLine"]);
   }
+  let tabStops = [];
+  if (tabs) {
+    tabStops = (tabs.elements || []).filter((el) => el.name === "w:tab").map((tab) => {
+      let val = tab.attributes["w:val"];
+      if (val == "left") {
+        val = "start";
+      } else if (val == "right") {
+        val = "end";
+      }
+      return {
+        val,
+        pos: twipsToPixels(tab.attributes["w:pos"]),
+        leader: tab.attributes["w:leader"]
+      };
+    });
+  }
   const keepNext = pPr?.elements?.find((el) => el.name === "w:keepNext");
   const keepLines = pPr?.elements?.find((el) => el.name === "w:keepLines");
   const outlineLevel = pPr?.elements?.find((el) => el.name === "w:outlineLvl");
@@ -32826,7 +33052,8 @@ const getDefaultStyleDefinition = (defaultStyleId, docx) => {
   const parsedStyles = {
     spacing: { lineSpaceAfter, lineSpaceBefore, line },
     textAlign,
-    indent: { leftIndent, rightIndent, firstLine }
+    indent: { leftIndent, rightIndent, firstLine },
+    tabStops: tabStops.length > 0 ? tabStops : null
   };
   parsedMarks.forEach((mark) => {
     const { type: type2, attrs } = mark;
@@ -32850,13 +33077,213 @@ const handleTabNode = (params) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$14.encode(params);
+  const node = translator$17.encode(params);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
   handlerName: "w:tabTranslator",
   handler: handleTabNode
 };
+const tableOfContentsHandlerEntity = generateV2HandlerEntity("tableOfContentsHandler", translator);
+function preProcessPageInstruction(nodesToCombine, _2, __) {
+  const pageNumNode = {
+    name: "sd:autoPageNumber",
+    type: "element"
+  };
+  nodesToCombine.forEach((n) => {
+    const rPrNode = n.elements.find((el) => el.name === "w:rPr");
+    if (rPrNode) pageNumNode.elements = [rPrNode];
+  });
+  return [pageNumNode];
+}
+function preProcessNumPagesInstruction(nodesToCombine, _2, __) {
+  const totalPageNumNode = {
+    name: "sd:totalPageNumber",
+    type: "element"
+  };
+  nodesToCombine.forEach((n) => {
+    const rPrNode = n.elements?.find((el) => el.name === "w:rPr");
+    if (rPrNode) totalPageNumNode.elements = [rPrNode];
+  });
+  return [totalPageNumNode];
+}
+function preProcessPageRefInstruction(nodesToCombine, instrText, _2) {
+  const pageRefNode = {
+    name: "sd:pageReference",
+    type: "element",
+    attributes: {
+      instruction: instrText
+    },
+    elements: nodesToCombine
+  };
+  return [pageRefNode];
+}
+function preProcessHyperlinkInstruction(nodesToCombine, instruction, docx) {
+  const urlMatch = instruction.match(/HYPERLINK\s+"([^"]+)"/);
+  let linkAttributes;
+  if (urlMatch && urlMatch.length >= 2) {
+    const url = urlMatch[1];
+    const rels = docx["word/_rels/document.xml.rels"];
+    const relationships = rels?.elements.find((el) => el.name === "Relationships");
+    if (relationships) {
+      const rId = generateDocxRandomId();
+      relationships.elements.push({
+        type: "element",
+        name: "Relationship",
+        attributes: {
+          Id: rId,
+          Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
+          Target: url,
+          TargetMode: "External"
+        }
+      });
+      linkAttributes = { "r:id": rId };
+    } else {
+      linkAttributes = { "w:anchor": url };
+    }
+  } else {
+    const availableSwitches = {
+      "w:anchor": `l "(?<value>[^"]+)"`,
+      new_window: `
+`,
+      "w:tgtFrame": `	 "(?<value>[^"]+)"`,
+      "w:tooltip": `o "(?<value>[^"]+)"`
+    };
+    const parsedSwitches = {};
+    for (const [key, regex] of Object.entries(availableSwitches)) {
+      const match = instruction.match(new RegExp(regex));
+      if (match) {
+        parsedSwitches[key] = match.groups?.value || true;
+      }
+    }
+    if (parsedSwitches.new_window) {
+      parsedSwitches["w:tgtFrame"] = "_blank";
+      delete parsedSwitches.new_window;
+    }
+    linkAttributes = { ...parsedSwitches };
+  }
+  return [
+    {
+      name: "w:hyperlink",
+      type: "element",
+      attributes: linkAttributes,
+      elements: nodesToCombine
+    }
+  ];
+}
+function preProcessTocInstruction(nodesToCombine, instrText) {
+  return [
+    {
+      name: "sd:tableOfContents",
+      type: "element",
+      attributes: {
+        instruction: instrText
+      },
+      elements: nodesToCombine
+    }
+  ];
+}
+const getInstructionPreProcessor = (instruction) => {
+  const instructionType = instruction.split(" ")[0];
+  switch (instructionType) {
+    case "PAGE":
+      return preProcessPageInstruction;
+    case "NUMPAGES":
+      return preProcessNumPagesInstruction;
+    case "PAGEREF":
+      return preProcessPageRefInstruction;
+    case "HYPERLINK":
+      return preProcessHyperlinkInstruction;
+    case "TOC":
+      return preProcessTocInstruction;
+    default:
+      return null;
+  }
+};
+const preProcessNodesForFldChar = (nodes = [], docx) => {
+  const processedNodes = [];
+  let collectedNodesStack = [];
+  let currentFieldStack = [];
+  let unpairedEnd = null;
+  let collecting = false;
+  const finalizeField = () => {
+    if (collecting) {
+      const collectedNodes = collectedNodesStack.pop().filter((n) => n !== null);
+      const currentField = currentFieldStack.pop();
+      const combined = _processCombinedNodesForFldChar(collectedNodes, currentField.instrText.trim(), docx);
+      if (collectedNodesStack.length === 0) {
+        processedNodes.push(...combined);
+      } else {
+        collectedNodesStack[collectedNodesStack.length - 1].push(...combined);
+      }
+    } else {
+      unpairedEnd = true;
+    }
+  };
+  for (const node of nodes) {
+    const fldCharEl = node.elements?.find((el) => el.name === "w:fldChar");
+    const fldType = fldCharEl?.attributes?.["w:fldCharType"];
+    const instrTextEl = node.elements?.find((el) => el.name === "w:instrText");
+    collecting = collectedNodesStack.length > 0;
+    if (fldType === "begin") {
+      collectedNodesStack.push([null]);
+      currentFieldStack.push({ instrText: "" });
+      continue;
+    }
+    if (instrTextEl && collecting && currentFieldStack.length > 0) {
+      currentFieldStack[currentFieldStack.length - 1].instrText += (instrTextEl.elements?.[0]?.text || "") + " ";
+      continue;
+    }
+    if (fldType === "end") {
+      finalizeField();
+      continue;
+    } else if (fldType === "separate") {
+      continue;
+    }
+    if (Array.isArray(node.elements)) {
+      const childResult = preProcessNodesForFldChar(node.elements, docx);
+      node.elements = childResult.processedNodes;
+      if (childResult.unpairedBegin) {
+        childResult.unpairedBegin.forEach((pendingField) => {
+          currentFieldStack.push(pendingField.fieldInfo);
+          collectedNodesStack.push([node]);
+        });
+      } else if (childResult.unpairedEnd) {
+        collectedNodesStack[collectedNodesStack.length - 1].push(node);
+        finalizeField();
+      } else if (collecting) {
+        collectedNodesStack[collectedNodesStack.length - 1].push(node);
+      } else {
+        processedNodes.push(node);
+      }
+    } else if (collecting) {
+      collectedNodesStack[collectedNodesStack.length - 1].push(node);
+    } else {
+      processedNodes.push(node);
+    }
+  }
+  let unpairedBegin = null;
+  if (collectedNodesStack.length > 0) {
+    unpairedBegin = [];
+    for (let i = 0; i < collectedNodesStack.length; i++) {
+      processedNodes.push(...collectedNodesStack[i].filter((n) => n !== null));
+      unpairedBegin.push({
+        nodes: collectedNodesStack[i],
+        fieldInfo: currentFieldStack[i]
+      });
+    }
+  }
+  return { processedNodes, unpairedBegin, unpairedEnd };
+};
+const _processCombinedNodesForFldChar = (nodesToCombine = [], instrText, docx) => {
+  const instructionType = instrText.trim().split(" ")[0];
+  const instructionPreProcessor = getInstructionPreProcessor(instructionType);
+  if (instructionPreProcessor) {
+    return instructionPreProcessor(nodesToCombine, instrText, docx);
+  } else {
+    return nodesToCombine;
+  }
+};
 const createDocumentJson = (docx, converter, editor) => {
   const json = carbonCopy(getInitialJSON(docx));
   if (!json) return null;
@@ -32886,6 +33313,8 @@ const createDocumentJson = (docx, converter, editor) => {
   if (bodyNode) {
     ensureSectionProperties(bodyNode);
     const node = bodyNode;
+    const { processedNodes } = preProcessNodesForFldChar(node.elements ?? [], docx);
+    node.elements = processedNodes;
     const contentElements = node.elements?.filter((n) => n.name !== "w:sectPr") ?? [];
     const content = pruneIgnoredNodes(contentElements);
     const comments = importCommentData({ docx, converter, editor });
@@ -32941,8 +33370,10 @@ const defaultNodeListHandler = () => {
     trackChangeNodeHandlerEntity,
     tableNodeHandlerEntity,
     tabNodeEntityHandler,
+    tableOfContentsHandlerEntity,
     autoPageHandlerEntity,
     autoTotalPageCountEntity,
+    pageReferenceEntity,
     standardNodeHandlerEntity
   ];
   const handler2 = createNodeListHandler(entities);
@@ -34043,7 +34474,7 @@ export {
   objectIncludes as Z,
   AddMarkStep as _,
   Plugin as a,
-  translator$a as a$,
+  translator$b as a$,
   twipsToLines as a0,
   pixelsToTwips as a1,
   helpers as a2,
@@ -34060,27 +34491,27 @@ export {
   handleClipboardPaste as aD,
   getFileObject as aE,
   runPropertyTranslators as aF,
-  translator$5 as aG,
-  translator$6 as aH,
-  translator$I as aI,
-  translator$J as aJ,
-  translator$10 as aK,
-  translator$H as aL,
-  translator$K as aM,
-  translator$G as aN,
-  translator$g as aO,
-  translator$8 as aP,
-  translator$t as aQ,
-  translator$u as aR,
-  translator$v as aS,
-  translator$w as aT,
-  translator$x as aU,
-  translator$c as aV,
-  translator$y as aW,
-  translator$z as aX,
-  translator$A as aY,
-  translator$B as aZ,
-  translator$L as a_,
+  translator$7 as aG,
+  translator$8 as aH,
+  translator$J as aI,
+  translator$K as aJ,
+  translator$13 as aK,
+  translator$I as aL,
+  translator$L as aM,
+  translator$H as aN,
+  translator$h as aO,
+  translator$9 as aP,
+  translator$u as aQ,
+  translator$v as aR,
+  translator$w as aS,
+  translator$x as aT,
+  translator$y as aU,
+  translator$d as aV,
+  translator$z as aW,
+  translator$A as aX,
+  translator$B as aY,
+  translator$C as aZ,
+  translator$M as a_,
   hasSomeParentWithClass as aa,
   isActive as ab,
   unflattenListsInHtml as ac,
@@ -34108,50 +34539,52 @@ export {
   getContentTypesFromXml as ay,
   xmljs as az,
   Slice as b,
-  translator$C as b0,
-  translator$M as b1,
-  translator$d as b2,
-  translator$D as b3,
-  translator$e as b4,
-  translator$9 as b5,
-  translator$14 as b6,
-  translator$W as b7,
-  translator$X as b8,
-  translator$$ as b9,
-  translator$16 as bA,
-  translator$s as bB,
-  translator$2 as bC,
-  translator$1 as bD,
-  translator$F as bE,
-  translator$12 as bF,
+  translator$D as b0,
+  translator$N as b1,
+  translator$e as b2,
+  translator$E as b3,
+  translator$f as b4,
+  translator$a as b5,
+  translator$17 as b6,
+  translator$Z as b7,
+  translator$_ as b8,
+  translator$12 as b9,
+  translator$19 as bA,
+  translator$t as bB,
+  translator$4 as bC,
+  translator$3 as bD,
+  translator$G as bE,
+  translator$15 as bF,
   translator as bG,
-  _sfc_main as bH,
-  translator$i as ba,
-  translator$E as bb,
-  translator$3 as bc,
-  translator$k as bd,
-  translator$Y as be,
-  translator$V as bf,
-  translator$Z as bg,
-  translator$U as bh,
-  translator$13 as bi,
-  translator$m as bj,
-  translator$N as bk,
-  translator$n as bl,
-  translator$o as bm,
-  translator$11 as bn,
-  translator$7 as bo,
-  translator$15 as bp,
-  translator$O as bq,
-  translator$b as br,
-  translator$P as bs,
-  translator$Q as bt,
-  translator$q as bu,
-  translator$4 as bv,
-  translator$R as bw,
-  translator$_ as bx,
-  translator$S as by,
-  translator$T as bz,
+  translator$1 as bH,
+  translator$2 as bI,
+  _sfc_main as bJ,
+  translator$j as ba,
+  translator$F as bb,
+  translator$5 as bc,
+  translator$l as bd,
+  translator$$ as be,
+  translator$X as bf,
+  translator$10 as bg,
+  translator$V as bh,
+  translator$16 as bi,
+  translator$n as bj,
+  translator$O as bk,
+  translator$o as bl,
+  translator$p as bm,
+  translator$14 as bn,
+  translator$W as bo,
+  translator$18 as bp,
+  translator$P as bq,
+  translator$c as br,
+  translator$Q as bs,
+  translator$R as bt,
+  translator$r as bu,
+  translator$6 as bv,
+  translator$S as bw,
+  translator$11 as bx,
+  translator$T as by,
+  translator$U as bz,
   DOMParser$1 as c,
   Mark as d,
   dropPoint as e,