@harbour-enterprises/superdoc 0.21.0 → 0.21.1

package/dist/chunks/{super-editor.es-U-GVCd_F.cjs → super-editor.es-HekVJogH.cjs}

@@ -24333,37 +24333,37 @@ const _NodeTranslator = class _NodeTranslator2 {
 };
 __publicField$2(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$17 = (attributes) => {
+const encode$18 = (attributes) => {
   return attributes["w:type"];
 };
-const decode$_ = (attrs) => {
+const decode$$ = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
 const attrConfig$F = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$17,
-  decode: decode$_
+  encode: encode$18,
+  decode: decode$$
 });
-const encode$16 = (attributes) => {
+const encode$17 = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$Z = (attrs) => {
+const decode$_ = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
 const attrConfig$E = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$16,
-  decode: decode$Z
+  encode: encode$17,
+  decode: decode$_
 });
-const validXmlAttributes$l = [attrConfig$F, attrConfig$E];
-const XML_NODE_NAME$t = "w:br";
-const SD_NODE_NAME$c = "lineBreak";
-const encode$15 = (_2, encodedAttrs) => {
+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 isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -24373,7 +24373,7 @@ const encode$15 = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$Y = (params2, decodedAttrs) => {
+const decode$Z = (params2, decodedAttrs) => {
   const { node } = params2;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24390,39 +24390,39 @@ const decode$Y = (params2, decodedAttrs) => {
   };
   return translated;
 };
-const config$r = {
-  xmlName: XML_NODE_NAME$t,
-  sdNodeOrKeyName: SD_NODE_NAME$c,
+const config$s = {
+  xmlName: XML_NODE_NAME$u,
+  sdNodeOrKeyName: SD_NODE_NAME$d,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$15,
-  decode: decode$Y,
-  attributes: validXmlAttributes$l
+  encode: encode$16,
+  decode: decode$Z,
+  attributes: validXmlAttributes$m
 };
-const translator$15 = NodeTranslator.from(config$r);
-const encode$14 = (attributes) => attributes?.["w:val"];
-const decode$X = (attrs) => attrs?.highlight;
+const translator$16 = NodeTranslator.from(config$s);
+const encode$15 = (attributes) => attributes?.["w:val"];
+const decode$Y = (attrs) => attrs?.highlight;
 const attrConfig$D = Object.freeze({
   xmlName: "w:val",
   sdName: "highlight",
-  encode: encode$14,
-  decode: decode$X
+  encode: encode$15,
+  decode: decode$Y
 });
-const validXmlAttributes$k = [attrConfig$D];
-const XML_NODE_NAME$s = "w:highlight";
+const validXmlAttributes$l = [attrConfig$D];
+const XML_NODE_NAME$t = "w:highlight";
 const SD_ATTR_KEY$f = "highlight";
 const DISABLED_TOKENS = /* @__PURE__ */ new Set(["transparent", "none", "inherit"]);
-const encode$13 = (params2, encodedAttrs = {}) => {
+const encode$14 = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const value = encodedAttrs.highlight ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$s,
+    xmlName: XML_NODE_NAME$t,
     sdNodeOrKeyName: SD_ATTR_KEY$f,
     attributes: { "w:val": value ?? null }
   };
 };
-const decode$W = (params2) => {
+const decode$X = (params2) => {
   const attrs = params2?.node?.attrs || {};
   const highlightValue = attrs.highlight ?? attrs.color ?? null;
   if (!highlightValue) return void 0;
@@ -24430,14 +24430,14 @@ const decode$W = (params2) => {
   if (!normalizedValue) return void 0;
   if (DISABLED_TOKENS.has(normalizedValue)) {
     return {
-      name: XML_NODE_NAME$s,
+      name: XML_NODE_NAME$t,
       attributes: { "w:val": "none" }
     };
   }
   const keyword = getDocxHighlightKeywordFromHex(highlightValue);
   if (keyword) {
     return {
-      name: XML_NODE_NAME$s,
+      name: XML_NODE_NAME$t,
       attributes: { "w:val": keyword }
     };
   }
@@ -24452,63 +24452,63 @@ const decode$W = (params2) => {
     }
   };
 };
-const config$q = {
-  xmlName: XML_NODE_NAME$s,
+const config$r = {
+  xmlName: XML_NODE_NAME$t,
   sdNodeOrKeyName: SD_ATTR_KEY$f,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$13,
-  decode: decode$W,
-  attributes: validXmlAttributes$k
+  encode: encode$14,
+  decode: decode$X,
+  attributes: validXmlAttributes$l
 };
-const translator$14 = NodeTranslator.from(config$q);
-const encode$12 = (attributes) => {
+const translator$15 = NodeTranslator.from(config$r);
+const encode$13 = (attributes) => {
   return attributes["w:val"];
 };
-const decode$V = (attrs) => {
+const decode$W = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
 const attrConfig$C = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$12,
-  decode: decode$V
+  encode: encode$13,
+  decode: decode$W
 });
-const encode$11 = (attributes) => {
+const encode$12 = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$U = (attrs) => {
+const decode$V = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
 const attrConfig$B = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$11,
-  decode: decode$U
+  encode: encode$12,
+  decode: decode$V
 });
-const encode$10 = (attributes) => {
+const encode$11 = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$T = (attrs) => {
+const decode$U = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
 const attrConfig$A = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$10,
-  decode: decode$T
+  encode: encode$11,
+  decode: decode$U
 });
-const validXmlAttributes$j = [attrConfig$C, attrConfig$A, attrConfig$B];
-const XML_NODE_NAME$r = "w:tab";
-const SD_NODE_NAME$b = "tab";
-const encode$$ = (_2, encodedAttrs = {}) => {
+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 translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$S = (params2, decodedAttrs = {}) => {
+const decode$T = (params2, decodedAttrs = {}) => {
   const { node } = params2 || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24524,15 +24524,15 @@ const decode$S = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$p = {
-  xmlName: XML_NODE_NAME$r,
-  sdNodeOrKeyName: SD_NODE_NAME$b,
+const config$q = {
+  xmlName: XML_NODE_NAME$s,
+  sdNodeOrKeyName: SD_NODE_NAME$c,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$$,
-  decode: decode$S,
-  attributes: validXmlAttributes$j
+  encode: encode$10,
+  decode: decode$T,
+  attributes: validXmlAttributes$k
 };
-const translator$13 = NodeTranslator.from(config$p);
+const translator$14 = NodeTranslator.from(config$q);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -24856,17 +24856,16 @@ const getParagraphSpacing = (node, docx, styleId = "", marks = [], options = {})
 };
 const getDefaultParagraphStyle = (docx, styleId = "") => {
   const styles = docx["word/styles.xml"];
-  if (!styles) {
+  const rootElements = styles?.elements?.[0]?.elements;
+  if (!rootElements?.length) {
     return {};
   }
-  const defaults = styles.elements[0].elements?.find((el) => el.name === "w:docDefaults");
-  const pDefault = defaults.elements.find((el) => el.name === "w:pPrDefault");
+  const defaults = rootElements.find((el) => el.name === "w:docDefaults");
+  const pDefault = defaults?.elements?.find((el) => el.name === "w:pPrDefault") || {};
   const pPrDefault = pDefault?.elements?.find((el) => el.name === "w:pPr");
   const pPrDefaultSpacingTag = pPrDefault?.elements?.find((el) => el.name === "w:spacing") || {};
   const pPrDefaultIndentTag = pPrDefault?.elements?.find((el) => el.name === "w:ind") || {};
-  const stylesNormal = styles.elements[0].elements?.find(
-    (el) => el.name === "w:style" && el.attributes["w:styleId"] === "Normal"
-  );
+  const stylesNormal = rootElements.find((el) => el.name === "w:style" && el.attributes["w:styleId"] === "Normal");
   const pPrNormal = stylesNormal?.elements?.find((el) => el.name === "w:pPr");
   const pPrNormalSpacingTag = pPrNormal?.elements?.find((el) => el.name === "w:spacing") || {};
   const pPrNormalIndentTag = pPrNormal?.elements?.find((el) => el.name === "w:ind") || {};
@@ -24875,9 +24874,7 @@ const getDefaultParagraphStyle = (docx, styleId = "") => {
   let pPrStyleIdIndentTag = {};
   let pPrStyleJc = {};
   if (styleId) {
-    const stylesById = styles.elements[0].elements?.find(
-      (el) => el.name === "w:style" && el.attributes["w:styleId"] === styleId
-    );
+    const stylesById = rootElements.find((el) => el.name === "w:style" && el.attributes["w:styleId"] === styleId);
     const pPrById = stylesById?.elements?.find((el) => el.name === "w:pPr");
     pPrStyleIdSpacingTag = pPrById?.elements?.find((el) => el.name === "w:spacing") || {};
     pPrStyleIdIndentTag = pPrById?.elements?.find((el) => el.name === "w:ind") || {};
@@ -25147,91 +25144,91 @@ const handleParagraphNode$1 = (params2) => {
   }
   return schemaNode;
 };
-const encode$_ = (attributes) => {
+const encode$$ = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$R = (attrs) => {
+const decode$S = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$z = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$_,
-  decode: decode$R
+  encode: encode$$,
+  decode: decode$S
 });
-const encode$Z = (attributes) => {
+const encode$_ = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$Q = (attrs) => {
+const decode$R = (attrs) => {
   return attrs.rsidP;
 };
 const attrConfig$y = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$Z,
-  decode: decode$Q
+  encode: encode$_,
+  decode: decode$R
 });
-const encode$Y = (attributes) => {
+const encode$Z = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$P = (attrs) => {
+const decode$Q = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$x = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$Y,
-  decode: decode$P
+  encode: encode$Z,
+  decode: decode$Q
 });
-const encode$X = (attributes) => {
+const encode$Y = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$O = (attrs) => {
+const decode$P = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$w = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$X,
-  decode: decode$O
+  encode: encode$Y,
+  decode: decode$P
 });
-const encode$W = (attributes) => {
+const encode$X = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$N = (attrs) => {
+const decode$O = (attrs) => {
   return attrs.rsidRDefault;
 };
 const attrConfig$v = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$W,
-  decode: decode$N
+  encode: encode$X,
+  decode: decode$O
 });
-const encode$V = (attributes) => {
+const encode$W = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$M = (attrs) => {
+const decode$N = (attrs) => {
   return attrs.paraId;
 };
 const attrConfig$u = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$V,
-  decode: decode$M
+  encode: encode$W,
+  decode: decode$N
 });
-const encode$U = (attributes) => {
+const encode$V = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$L = (attrs) => {
+const decode$M = (attrs) => {
   return attrs.textId;
 };
 const attrConfig$t = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$U,
-  decode: decode$L
+  encode: encode$V,
+  decode: decode$M
 });
-const validXmlAttributes$i = [
+const validXmlAttributes$j = [
   attrConfig$u,
   attrConfig$t,
   attrConfig$x,
@@ -25240,9 +25237,9 @@ const validXmlAttributes$i = [
   attrConfig$w,
   attrConfig$z
 ];
-const XML_NODE_NAME$q = "w:p";
-const SD_NODE_NAME$a = "paragraph";
-const encode$T = (params2, encodedAttrs = {}) => {
+const XML_NODE_NAME$r = "w:p";
+const SD_NODE_NAME$b = "paragraph";
+const encode$U = (params2, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params2);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25250,7 +25247,7 @@ const encode$T = (params2, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$K = (params2, decodedAttrs = {}) => {
+const decode$L = (params2, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params2);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25258,16 +25255,16 @@ const decode$K = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$o = {
-  xmlName: XML_NODE_NAME$q,
-  sdNodeOrKeyName: SD_NODE_NAME$a,
+const config$p = {
+  xmlName: XML_NODE_NAME$r,
+  sdNodeOrKeyName: SD_NODE_NAME$b,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$T,
-  decode: decode$K,
-  attributes: validXmlAttributes$i
+  encode: encode$U,
+  decode: decode$L,
+  attributes: validXmlAttributes$j
 };
-const translator$12 = NodeTranslator.from(config$o);
-const encode$S = (attributes) => {
+const translator$13 = NodeTranslator.from(config$p);
+const encode$T = (attributes) => {
   const raw = attributes?.["w:val"];
   if (raw === void 0 || raw === null) return void 0;
   if (typeof raw === "boolean") return raw;
@@ -25277,20 +25274,20 @@ const encode$S = (attributes) => {
   if (val === "1" || val === "true" || val === "on") return true;
   return void 0;
 };
-const decode$J = (runProps) => {
+const decode$K = (runProps) => {
   if (runProps?.bold === false) return "0";
   return void 0;
 };
 const attrConfig$s = Object.freeze({
   xmlName: "w:val",
   sdName: "bold",
-  encode: encode$S,
-  decode: decode$J
+  encode: encode$T,
+  decode: decode$K
 });
-const validXmlAttributes$h = [attrConfig$s];
-const XML_NODE_NAME$p = "w:b";
+const validXmlAttributes$i = [attrConfig$s];
+const XML_NODE_NAME$q = "w:b";
 const SD_ATTR_KEY$e = "bold";
-const encode$R = (params2, encodedAttrs = {}) => {
+const encode$S = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes[0];
   if (!node) return void 0;
@@ -25302,85 +25299,85 @@ const encode$R = (params2, encodedAttrs = {}) => {
   else attributes = node.attributes || {};
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$p,
+    xmlName: XML_NODE_NAME$q,
     sdNodeOrKeyName: SD_ATTR_KEY$e,
     attributes
   };
 };
-const config$n = {
-  xmlName: XML_NODE_NAME$p,
+const config$o = {
+  xmlName: XML_NODE_NAME$q,
   sdNodeOrKeyName: SD_ATTR_KEY$e,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$R,
-  attributes: validXmlAttributes$h
+  encode: encode$S,
+  attributes: validXmlAttributes$i
 };
-const translator$11 = NodeTranslator.from(config$n);
-const XML_NODE_NAME$o = "w:i";
+const translator$12 = NodeTranslator.from(config$o);
+const XML_NODE_NAME$p = "w:i";
 const SD_ATTR_KEY$d = "italic";
-const encode$Q = (params2) => {
+const encode$R = (params2) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   if (!node) return void 0;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$o,
+    xmlName: XML_NODE_NAME$p,
     sdNodeOrKeyName: SD_ATTR_KEY$d,
     attributes: {
       "w:val": node.attributes?.["w:val"] ?? null
     }
   };
 };
-const config$m = {
-  xmlName: XML_NODE_NAME$o,
+const config$n = {
+  xmlName: XML_NODE_NAME$p,
   sdNodeOrKeyName: SD_ATTR_KEY$d,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$Q
+  encode: encode$R
 };
-const translator$10 = NodeTranslator.from(config$m);
-const encode$P = (attributes) => attributes?.["w:val"];
-const decode$I = (attrs) => attrs?.underline;
+const translator$11 = NodeTranslator.from(config$n);
+const encode$Q = (attributes) => attributes?.["w:val"];
+const decode$J = (attrs) => attrs?.underline;
 const attrConfig$r = Object.freeze({
   xmlName: "w:val",
   sdName: "underline",
-  encode: encode$P,
-  decode: decode$I
+  encode: encode$Q,
+  decode: decode$J
 });
-const encode$O = (attributes) => attributes?.["w:color"];
-const decode$H = (attrs) => attrs?.color;
+const encode$P = (attributes) => attributes?.["w:color"];
+const decode$I = (attrs) => attrs?.color;
 const attrConfig$q = Object.freeze({
   xmlName: "w:color",
   sdName: "color",
-  encode: encode$O,
-  decode: decode$H
+  encode: encode$P,
+  decode: decode$I
 });
-const encode$N = (attributes) => attributes?.["w:themeColor"];
-const decode$G = (attrs) => attrs?.themeColor;
+const encode$O = (attributes) => attributes?.["w:themeColor"];
+const decode$H = (attrs) => attrs?.themeColor;
 const attrConfig$p = Object.freeze({
   xmlName: "w:themeColor",
   sdName: "themeColor",
-  encode: encode$N,
-  decode: decode$G
+  encode: encode$O,
+  decode: decode$H
 });
-const encode$M = (attributes) => attributes?.["w:themeTint"];
-const decode$F = (attrs) => attrs?.themeTint;
+const encode$N = (attributes) => attributes?.["w:themeTint"];
+const decode$G = (attrs) => attrs?.themeTint;
 const attrConfig$o = Object.freeze({
   xmlName: "w:themeTint",
   sdName: "themeTint",
-  encode: encode$M,
-  decode: decode$F
+  encode: encode$N,
+  decode: decode$G
 });
-const encode$L = (attributes) => attributes?.["w:themeShade"];
-const decode$E = (attrs) => attrs?.themeShade;
+const encode$M = (attributes) => attributes?.["w:themeShade"];
+const decode$F = (attrs) => attrs?.themeShade;
 const attrConfig$n = Object.freeze({
   xmlName: "w:themeShade",
   sdName: "themeShade",
-  encode: encode$L,
-  decode: decode$E
+  encode: encode$M,
+  decode: decode$F
 });
-const validXmlAttributes$g = [attrConfig$r, attrConfig$q, attrConfig$p, attrConfig$o, attrConfig$n];
-const XML_NODE_NAME$n = "w:u";
+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$K = (params2, encodedAttrs = {}) => {
+const encode$L = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25396,12 +25393,12 @@ const encode$K = (params2, encodedAttrs = {}) => {
   if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$n,
+    xmlName: XML_NODE_NAME$o,
     sdNodeOrKeyName: SD_ATTR_KEY$c,
     attributes
   };
 };
-const decode$D = (params2) => {
+const decode$E = (params2) => {
   const attrs = params2?.node?.attrs || {};
   const underlineType = attrs.underlineType ?? attrs.underline ?? null;
   const color = attrs.underlineColor ?? attrs.color ?? null;
@@ -25419,20 +25416,20 @@ const decode$D = (params2) => {
   if (themeTint) attributes["w:themeTint"] = themeTint;
   if (themeShade) attributes["w:themeShade"] = themeShade;
   return {
-    name: XML_NODE_NAME$n,
+    name: XML_NODE_NAME$o,
     attributes
   };
 };
-const config$l = {
-  xmlName: XML_NODE_NAME$n,
+const config$m = {
+  xmlName: XML_NODE_NAME$o,
   sdNodeOrKeyName: SD_ATTR_KEY$c,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$K,
-  decode: decode$D,
-  attributes: validXmlAttributes$g
+  encode: encode$L,
+  decode: decode$E,
+  attributes: validXmlAttributes$h
 };
-const translator$$ = NodeTranslator.from(config$l);
-const encode$J = (attributes) => {
+const translator$10 = NodeTranslator.from(config$m);
+const encode$K = (attributes) => {
   const raw = attributes?.["w:val"];
   if (raw === void 0 || raw === null) return void 0;
   if (typeof raw === "boolean") return raw;
@@ -25442,20 +25439,20 @@ const encode$J = (attributes) => {
   if (val === "1" || val === "true" || val === "on") return true;
   return void 0;
 };
-const decode$C = (attrs) => {
+const decode$D = (attrs) => {
   if (attrs?.strike === false) return "0";
   return void 0;
 };
 const attrConfig$m = Object.freeze({
   xmlName: "w:val",
   sdName: "strike",
-  encode: encode$J,
-  decode: decode$C
+  encode: encode$K,
+  decode: decode$D
 });
-const validXmlAttributes$f = [attrConfig$m];
-const XML_NODE_NAME$m = "w:strike";
+const validXmlAttributes$g = [attrConfig$m];
+const XML_NODE_NAME$n = "w:strike";
 const SD_ATTR_KEY$b = "strike";
-const encode$I = (params2, encodedAttrs = {}) => {
+const encode$J = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   if (!node) return void 0;
@@ -25468,55 +25465,55 @@ const encode$I = (params2, encodedAttrs = {}) => {
   else if (val === true && attributes["w:val"] === void 0) delete attributes["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$m,
+    xmlName: XML_NODE_NAME$n,
     sdNodeOrKeyName: SD_ATTR_KEY$b,
     attributes
   };
 };
-const config$k = {
-  xmlName: XML_NODE_NAME$m,
+const config$l = {
+  xmlName: XML_NODE_NAME$n,
   sdNodeOrKeyName: SD_ATTR_KEY$b,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$I,
-  attributes: validXmlAttributes$f
+  encode: encode$J,
+  attributes: validXmlAttributes$g
 };
-const translator$_ = NodeTranslator.from(config$k);
-const encode$H = (attributes) => attributes?.["w:val"];
-const decode$B = (attrs) => attrs?.color;
+const translator$$ = NodeTranslator.from(config$l);
+const encode$I = (attributes) => attributes?.["w:val"];
+const decode$C = (attrs) => attrs?.color;
 const attrConfig$l = Object.freeze({
   xmlName: "w:val",
   sdName: "color",
-  encode: encode$H,
-  decode: decode$B
+  encode: encode$I,
+  decode: decode$C
 });
-const encode$G = (attributes) => attributes?.["w:themeColor"];
-const decode$A = (attrs) => attrs?.themeColor;
+const encode$H = (attributes) => attributes?.["w:themeColor"];
+const decode$B = (attrs) => attrs?.themeColor;
 const attrConfig$k = Object.freeze({
   xmlName: "w:themeColor",
   sdName: "themeColor",
-  encode: encode$G,
-  decode: decode$A
+  encode: encode$H,
+  decode: decode$B
 });
-const encode$F = (attributes) => attributes?.["w:themeTint"];
-const decode$z = (attrs) => attrs?.themeTint;
+const encode$G = (attributes) => attributes?.["w:themeTint"];
+const decode$A = (attrs) => attrs?.themeTint;
 const attrConfig$j = Object.freeze({
   xmlName: "w:themeTint",
   sdName: "themeTint",
-  encode: encode$F,
-  decode: decode$z
+  encode: encode$G,
+  decode: decode$A
 });
-const encode$E = (attributes) => attributes?.["w:themeShade"];
-const decode$y = (attrs) => attrs?.themeShade;
+const encode$F = (attributes) => attributes?.["w:themeShade"];
+const decode$z = (attrs) => attrs?.themeShade;
 const attrConfig$i = Object.freeze({
   xmlName: "w:themeShade",
   sdName: "themeShade",
-  encode: encode$E,
-  decode: decode$y
+  encode: encode$F,
+  decode: decode$z
 });
-const validXmlAttributes$e = [attrConfig$l, attrConfig$k, attrConfig$j, attrConfig$i];
-const XML_NODE_NAME$l = "w:color";
+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$D = (params2, encodedAttrs = {}) => {
+const encode$E = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25531,63 +25528,63 @@ const encode$D = (params2, encodedAttrs = {}) => {
   if (themeShade !== void 0 && themeShade !== null) attributes["w:themeShade"] = themeShade;
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$l,
+    xmlName: XML_NODE_NAME$m,
     sdNodeOrKeyName: SD_ATTR_KEY$a,
     attributes
   };
 };
-const config$j = {
-  xmlName: XML_NODE_NAME$l,
+const config$k = {
+  xmlName: XML_NODE_NAME$m,
   sdNodeOrKeyName: SD_ATTR_KEY$a,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$D,
-  attributes: validXmlAttributes$e
+  encode: encode$E,
+  attributes: validXmlAttributes$f
 };
-const translator$Z = NodeTranslator.from(config$j);
-const encode$C = (attributes) => attributes?.["w:eastAsia"];
-const decode$x = (attrs) => attrs?.eastAsia;
+const translator$_ = NodeTranslator.from(config$k);
+const encode$D = (attributes) => attributes?.["w:eastAsia"];
+const decode$y = (attrs) => attrs?.eastAsia;
 const attrConfig$h = Object.freeze({
   xmlName: "w:eastAsia",
   sdName: "eastAsia",
-  encode: encode$C,
-  decode: decode$x
+  encode: encode$D,
+  decode: decode$y
 });
-const encode$B = (attributes) => attributes?.["w:ascii"];
-const decode$w = (attrs) => attrs?.ascii;
+const encode$C = (attributes) => attributes?.["w:ascii"];
+const decode$x = (attrs) => attrs?.ascii;
 const attrConfig$g = Object.freeze({
   xmlName: "w:ascii",
   sdName: "ascii",
-  encode: encode$B,
-  decode: decode$w
+  encode: encode$C,
+  decode: decode$x
 });
-const encode$A = (attributes) => attributes?.["w:hAnsi"];
-const decode$v = (attrs) => attrs?.hAnsi;
+const encode$B = (attributes) => attributes?.["w:hAnsi"];
+const decode$w = (attrs) => attrs?.hAnsi;
 const attrConfig$f = Object.freeze({
   xmlName: "w:hAnsi",
   sdName: "hAnsi",
-  encode: encode$A,
-  decode: decode$v
+  encode: encode$B,
+  decode: decode$w
 });
-const encode$z = (attributes) => attributes?.["w:cs"];
-const decode$u = (attrs) => attrs?.cs;
+const encode$A = (attributes) => attributes?.["w:cs"];
+const decode$v = (attrs) => attrs?.cs;
 const attrConfig$e = Object.freeze({
   xmlName: "w:cs",
   sdName: "cs",
-  encode: encode$z,
-  decode: decode$u
+  encode: encode$A,
+  decode: decode$v
 });
-const encode$y = (attributes) => attributes?.["w:val"];
-const decode$t = (attrs) => attrs?.value;
+const encode$z = (attributes) => attributes?.["w:val"];
+const decode$u = (attrs) => attrs?.value;
 const attrConfig$d = Object.freeze({
   xmlName: "w:val",
   sdName: "value",
-  encode: encode$y,
-  decode: decode$t
+  encode: encode$z,
+  decode: decode$u
 });
-const validXmlAttributes$d = [attrConfig$h, attrConfig$g, attrConfig$f, attrConfig$e, attrConfig$d];
-const XML_NODE_NAME$k = "w:rFonts";
+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$x = (params2, encodedAttrs = {}) => {
+const encode$y = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const sourceAttrs = node?.attributes || {};
@@ -25613,120 +25610,120 @@ const encode$x = (params2, encodedAttrs = {}) => {
   if (attributes["w:val"] === void 0) delete attributes["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$k,
+    xmlName: XML_NODE_NAME$l,
     sdNodeOrKeyName: SD_ATTR_KEY$9,
     attributes
   };
 };
-const config$i = {
-  xmlName: XML_NODE_NAME$k,
+const config$j = {
+  xmlName: XML_NODE_NAME$l,
   sdNodeOrKeyName: SD_ATTR_KEY$9,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$x,
-  attributes: validXmlAttributes$d
+  encode: encode$y,
+  attributes: validXmlAttributes$e
 };
-const translator$Y = NodeTranslator.from(config$i);
-const encode$w = (attributes) => attributes?.["w:val"];
-const decode$s = (attrs) => attrs?.styleId;
+const translator$Z = NodeTranslator.from(config$j);
+const encode$x = (attributes) => attributes?.["w:val"];
+const decode$t = (attrs) => attrs?.styleId;
 const attrConfig$c = Object.freeze({
   xmlName: "w:val",
   sdName: "styleId",
-  encode: encode$w,
-  decode: decode$s
+  encode: encode$x,
+  decode: decode$t
 });
-const validXmlAttributes$c = [attrConfig$c];
-const XML_NODE_NAME$j = "w:rStyle";
+const validXmlAttributes$d = [attrConfig$c];
+const XML_NODE_NAME$k = "w:rStyle";
 const SD_ATTR_KEY$8 = "styleId";
-const encode$v = (params2, encodedAttrs = {}) => {
+const encode$w = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const value = encodedAttrs.styleId ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$j,
+    xmlName: XML_NODE_NAME$k,
     sdNodeOrKeyName: SD_ATTR_KEY$8,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$h = {
-  xmlName: XML_NODE_NAME$j,
+const config$i = {
+  xmlName: XML_NODE_NAME$k,
   sdNodeOrKeyName: SD_ATTR_KEY$8,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$v,
-  attributes: validXmlAttributes$c
+  encode: encode$w,
+  attributes: validXmlAttributes$d
 };
-const translator$X = NodeTranslator.from(config$h);
-const encode$u = (attributes) => attributes?.["w:val"];
-const decode$r = (attrs) => attrs?.fontSize;
+const translator$Y = NodeTranslator.from(config$i);
+const encode$v = (attributes) => attributes?.["w:val"];
+const decode$s = (attrs) => attrs?.fontSize;
 const attrConfig$b = Object.freeze({
   xmlName: "w:val",
   sdName: "fontSize",
-  encode: encode$u,
-  decode: decode$r
+  encode: encode$v,
+  decode: decode$s
 });
-const validXmlAttributes$b = [attrConfig$b];
-const XML_NODE_NAME$i = "w:sz";
+const validXmlAttributes$c = [attrConfig$b];
+const XML_NODE_NAME$j = "w:sz";
 const SD_ATTR_KEY$7 = "fontSize";
-const encode$t = (params2, encodedAttrs = {}) => {
+const encode$u = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const value = encodedAttrs.fontSize ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$i,
+    xmlName: XML_NODE_NAME$j,
     sdNodeOrKeyName: SD_ATTR_KEY$7,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$g = {
-  xmlName: XML_NODE_NAME$i,
+const config$h = {
+  xmlName: XML_NODE_NAME$j,
   sdNodeOrKeyName: SD_ATTR_KEY$7,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$t,
-  attributes: validXmlAttributes$b
+  encode: encode$u,
+  attributes: validXmlAttributes$c
 };
-const translator$W = NodeTranslator.from(config$g);
-const encode$s = (attributes) => attributes?.["w:val"];
-const decode$q = (attrs) => attrs?.fontSizeCs;
+const translator$X = NodeTranslator.from(config$h);
+const encode$t = (attributes) => attributes?.["w:val"];
+const decode$r = (attrs) => attrs?.fontSizeCs;
 const attrConfig$a = Object.freeze({
   xmlName: "w:val",
   sdName: "fontSizeCs",
-  encode: encode$s,
-  decode: decode$q
+  encode: encode$t,
+  decode: decode$r
 });
-const validXmlAttributes$a = [attrConfig$a];
-const XML_NODE_NAME$h = "w:szCs";
+const validXmlAttributes$b = [attrConfig$a];
+const XML_NODE_NAME$i = "w:szCs";
 const SD_ATTR_KEY$6 = "fontSizeCs";
-const encode$r = (params2, encodedAttrs = {}) => {
+const encode$s = (params2, encodedAttrs = {}) => {
   const { nodes } = params2;
   const node = nodes?.[0];
   const value = encodedAttrs.fontSizeCs ?? node?.attributes?.["w:val"];
   return {
     type: "attr",
-    xmlName: XML_NODE_NAME$h,
+    xmlName: XML_NODE_NAME$i,
     sdNodeOrKeyName: SD_ATTR_KEY$6,
     attributes: { "w:val": value ?? null }
   };
 };
-const config$f = {
-  xmlName: XML_NODE_NAME$h,
+const config$g = {
+  xmlName: XML_NODE_NAME$i,
   sdNodeOrKeyName: SD_ATTR_KEY$6,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$r,
-  attributes: validXmlAttributes$a
+  encode: encode$s,
+  attributes: validXmlAttributes$b
 };
-const translator$V = NodeTranslator.from(config$f);
+const translator$W = NodeTranslator.from(config$g);
 const runPropertyTranslators = Object.freeze({
-  "w:b": translator$11,
-  "w:i": translator$10,
-  "w:u": translator$$,
-  "w:strike": translator$_,
-  "w:color": translator$Z,
-  "w:highlight": translator$14,
-  "w:rFonts": translator$Y,
-  "w:rStyle": translator$X,
-  "w:sz": translator$W,
-  "w:szCs": translator$V
+  "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
 });
 const rawRunPropertyXmlNames = Object.freeze(["w:lang", "w:shd"]);
 const RAW_CHILD_NAME_SET = new Set(rawRunPropertyXmlNames);
@@ -25740,9 +25737,9 @@ const toRunPropertyEntry = (candidate) => {
     attributes: { ...candidate.attributes || {} }
   };
 };
-const XML_NODE_NAME$g = "w:rPr";
+const XML_NODE_NAME$h = "w:rPr";
 const SD_ATTR_KEY$5 = "runProperties";
-const encode$q = (params2) => {
+const encode$r = (params2) => {
   const { nodes } = params2;
   const node = nodes?.[0] || {};
   const contents = Array.isArray(node.elements) ? node.elements : [];
@@ -25776,16 +25773,16 @@ const encode$q = (params2) => {
     attributes: runPropsArray
   };
 };
-const config$e = {
-  xmlName: XML_NODE_NAME$g,
+const config$f = {
+  xmlName: XML_NODE_NAME$h,
   sdNodeOrKeyName: SD_ATTR_KEY$5,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$q
+  encode: encode$r
 };
-const translator$U = NodeTranslator.from(config$e);
+const translator$V = NodeTranslator.from(config$f);
 const EAST_ASIAN_CHARACTER_REGEX = /[\u1100-\u11FF\u2E80-\u2EFF\u2F00-\u2FDF\u3040-\u30FF\u3100-\u312F\u3130-\u318F\u31A0-\u31BF\u3400-\u4DBF\u4E00-\u9FFF\uA960-\uA97F\uAC00-\uD7AF\uF900-\uFAFF\uFF00-\uFFEF]/u;
 const containsEastAsianCharacters = (text) => EAST_ASIAN_CHARACTER_REGEX.test(text);
-const collectRunProperties = (params2, rPrNode, translator2 = translator$U) => {
+const collectRunProperties = (params2, rPrNode, translator2 = translator$V) => {
   if (!rPrNode) return { entries: [], hadRPr: false, styleChangeMarks: [] };
   const result = translator2.encode({ ...params2, nodes: [rPrNode] }) || {};
   let entries = [];
@@ -26247,46 +26244,46 @@ const ensureTrackedWrapper = (runs, trackingMarksByType = /* @__PURE__ */ new Ma
   }
   return runs;
 };
-const encode$p = (attributes) => {
+const encode$q = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$p = (attrs) => {
+const decode$q = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$9 = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$p,
-  decode: decode$p
+  encode: encode$q,
+  decode: decode$q
 });
-const encode$o = (attributes) => {
+const encode$p = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$o = (attrs) => {
+const decode$p = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$8 = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$o,
-  decode: decode$o
+  encode: encode$p,
+  decode: decode$p
 });
-const encode$n = (attributes) => {
+const encode$o = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$n = (attrs) => {
+const decode$o = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$7 = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$n,
-  decode: decode$n
+  encode: encode$o,
+  decode: decode$o
 });
-const validXmlAttributes$9 = [attrConfig$9, attrConfig$8, attrConfig$7];
-const XML_NODE_NAME$f = "w:r";
+const validXmlAttributes$a = [attrConfig$9, attrConfig$8, attrConfig$7];
+const XML_NODE_NAME$g = "w:r";
 const SD_KEY_NAME = "run";
-const encode$m = (params2, encodedAttrs = {}) => {
+const encode$n = (params2, encodedAttrs = {}) => {
   const { nodes = [], nodeListHandler } = params2 || {};
   const runNode = nodes[0];
   if (!runNode) return void 0;
@@ -26334,7 +26331,7 @@ const encode$m = (params2, encodedAttrs = {}) => {
   }
   return runNodeResult;
 };
-const decode$m = (params2, decodedAttrs = {}) => {
+const decode$n = (params2, decodedAttrs = {}) => {
   const { node } = params2 || {};
   if (!node) return void 0;
   const { runNode: runNodeForExport, trackingMarksByType } = prepareRunTrackingContext(node);
@@ -26391,7 +26388,7 @@ const decode$m = (params2, decodedAttrs = {}) => {
       runs.push(trackedClone);
       return;
     }
-    const runWrapper = { name: XML_NODE_NAME$f, elements: [] };
+    const runWrapper = { name: XML_NODE_NAME$g, elements: [] };
     applyBaseRunProps(runWrapper);
     if (!Array.isArray(runWrapper.elements)) runWrapper.elements = [];
     runWrapper.elements.push(cloneXmlNode(child));
@@ -26399,7 +26396,7 @@ const decode$m = (params2, decodedAttrs = {}) => {
   });
   const trackedRuns = ensureTrackedWrapper(runs, trackingMarksByType);
   if (!trackedRuns.length) {
-    const emptyRun = { name: XML_NODE_NAME$f, elements: [] };
+    const emptyRun = { name: XML_NODE_NAME$g, elements: [] };
     applyBaseRunProps(emptyRun);
     trackedRuns.push(emptyRun);
   }
@@ -26413,15 +26410,15 @@ const decode$m = (params2, decodedAttrs = {}) => {
   }
   return trackedRuns;
 };
-const config$d = {
-  xmlName: XML_NODE_NAME$f,
+const config$e = {
+  xmlName: XML_NODE_NAME$g,
   sdNodeOrKeyName: SD_KEY_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$m,
-  decode: decode$m,
-  attributes: validXmlAttributes$9
+  encode: encode$n,
+  decode: decode$n,
+  attributes: validXmlAttributes$a
 };
-const translator$T = NodeTranslator.from(config$d);
+const translator$U = NodeTranslator.from(config$e);
 const generateV2HandlerEntity = (handlerName, translator2) => ({
   handlerName,
   handler: (params2) => {
@@ -26595,13 +26592,13 @@ function preProcessVerticalMergeCells(table, { editorSchema }) {
   }
   return table;
 }
-const translator$S = NodeTranslator.from({
+const translator$T = 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$R = NodeTranslator.from({
+const translator$S = NodeTranslator.from({
   xmlName: "w:cnfStyle",
   sdNodeOrKeyName: "cnfStyle",
   attributes: [
@@ -26627,8 +26624,8 @@ const translator$R = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$Q = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
-const translator$P = NodeTranslator.from(
+const translator$R = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
+const translator$Q = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridAfter",
     null,
@@ -26637,7 +26634,7 @@ const translator$P = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$O = NodeTranslator.from(
+const translator$P = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridBefore",
     null,
@@ -26646,21 +26643,21 @@ const translator$O = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$N = NodeTranslator.from({
+const translator$O = 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$M = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc", "justification"));
-const translator$L = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
-const translator$K = NodeTranslator.from({
+const translator$N = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc", "justification"));
+const translator$M = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
+const translator$L = 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$J = NodeTranslator.from({
+const translator$K = NodeTranslator.from({
   xmlName: "w:trHeight",
   sdNodeOrKeyName: "rowHeight",
   encode: ({ nodes }) => {
@@ -26687,11 +26684,11 @@ const translator$J = NodeTranslator.from({
     return Object.keys(heightAttrs).length > 0 ? { attributes: heightAttrs } : void 0;
   }
 });
-const translator$I = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
-const translator$H = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
-const XML_NODE_NAME$e = "w:trPr";
+const translator$J = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
+const translator$I = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
+const XML_NODE_NAME$f = "w:trPr";
 const SD_ATTR_KEY$4 = "tableRowProperties";
-const encode$l = (params2) => {
+const encode$m = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
   let attributes = {
@@ -26705,12 +26702,12 @@ const encode$l = (params2) => {
   };
   return {
     type: NodeTranslator.translatorTypes.ATTRIBUTE,
-    xmlName: XML_NODE_NAME$e,
+    xmlName: XML_NODE_NAME$f,
     sdNodeOrKeyName: SD_ATTR_KEY$4,
     attributes
   };
 };
-const decode$l = (params2) => {
+const decode$m = (params2) => {
   const { tableRowProperties = {} } = params2.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName$2, tableRowProperties);
   const newNode = {
@@ -26722,6 +26719,7 @@ const decode$l = (params2) => {
   return newNode;
 };
 const propertyTranslators$3 = [
+  translator$T,
   translator$S,
   translator$R,
   translator$Q,
@@ -26732,8 +26730,7 @@ const propertyTranslators$3 = [
   translator$L,
   translator$K,
   translator$J,
-  translator$I,
-  translator$H
+  translator$I
 ];
 const propertyTranslatorsByXmlName$2 = {};
 propertyTranslators$3.forEach((translator2) => {
@@ -26743,25 +26740,25 @@ const propertyTranslatorsBySdName$2 = {};
 propertyTranslators$3.forEach((translator2) => {
   propertyTranslatorsBySdName$2[translator2.sdNodeOrKeyName] = translator2;
 });
-const config$c = {
-  xmlName: XML_NODE_NAME$e,
+const config$d = {
+  xmlName: XML_NODE_NAME$f,
   sdNodeOrKeyName: SD_ATTR_KEY$4,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$l,
-  decode: decode$l
+  encode: encode$m,
+  decode: decode$m
 };
-const translator$G = NodeTranslator.from(config$c);
-const XML_NODE_NAME$d = "w:tr";
-const SD_NODE_NAME$9 = "tableRow";
-const validXmlAttributes$8 = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
+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(
   (xmlName) => createAttributeHandler(xmlName)
 );
-const encode$k = (params2, encodedAttrs) => {
+const encode$l = (params2, encodedAttrs) => {
   const { row } = params2.extraParams;
   let tableRowProperties = {};
   const tPr = row.elements.find((el) => el.name === "w:trPr");
   if (tPr) {
-    ({ attributes: tableRowProperties } = translator$G.encode({
+    ({ attributes: tableRowProperties } = translator$H.encode({
       ...params2,
       nodes: [tPr]
     }));
@@ -26774,7 +26771,7 @@ const encode$k = (params2, encodedAttrs) => {
   let currentColumnIndex = 0;
   const content = cellNodes?.map((n) => {
     let columnWidth = gridColumnWidths?.[currentColumnIndex] || null;
-    const result = translator$7.encode({
+    const result = translator$8.encode({
       ...params2,
       extraParams: {
         ...params2.extraParams,
@@ -26796,7 +26793,7 @@ const encode$k = (params2, encodedAttrs) => {
   };
   return newNode;
 };
-const decode$k = (params2, decodedAttrs) => {
+const decode$l = (params2, decodedAttrs) => {
   const { node } = params2;
   const elements = translateChildNodes(params2);
   if (node.attrs?.tableRowProperties) {
@@ -26808,7 +26805,7 @@ const decode$k = (params2, decodedAttrs) => {
       }
     }
     tableRowProperties["cantSplit"] = node.attrs["cantSplit"];
-    const trPr = translator$G.decode({
+    const trPr = translator$H.decode({
       ...params2,
       node: { ...node, attrs: { ...node.attrs, tableRowProperties } }
     });
@@ -26820,22 +26817,22 @@ const decode$k = (params2, decodedAttrs) => {
     elements
   };
 };
-const config$b = {
-  xmlName: XML_NODE_NAME$d,
-  sdNodeOrKeyName: SD_NODE_NAME$9,
+const config$c = {
+  xmlName: XML_NODE_NAME$e,
+  sdNodeOrKeyName: SD_NODE_NAME$a,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$k,
-  decode: decode$k,
-  attributes: validXmlAttributes$8
+  encode: encode$l,
+  decode: decode$l,
+  attributes: validXmlAttributes$9
 };
-const translator$F = NodeTranslator.from(config$b);
-const translator$E = NodeTranslator.from({
+const translator$G = NodeTranslator.from(config$c);
+const translator$F = 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$D = NodeTranslator.from({
+const translator$E = NodeTranslator.from({
   xmlName: "w:shd",
   sdNodeOrKeyName: "shading",
   attributes: [
@@ -26857,11 +26854,11 @@ const translator$D = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$C = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblCaption", "caption"));
-const translator$B = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblDescription", "description"));
-const translator$A = NodeTranslator.from(createMeasurementPropertyHandler("w:tblInd", "tableIndent"));
-const translator$z = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblLayout", "tableLayout", "w:type"));
-const translator$y = NodeTranslator.from({
+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({
   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")]),
@@ -26873,16 +26870,16 @@ const translator$y = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$x = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblOverlap", "overlap"));
-const translator$w = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblStyle", "tableStyleId"));
-const translator$v = NodeTranslator.from(
+const translator$y = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblOverlap", "overlap"));
+const translator$x = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblStyle", "tableStyleId"));
+const translator$w = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:tblStyleColBandSize", "tableStyleColBandSize")
 );
-const translator$u = NodeTranslator.from(
+const translator$v = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:tblStyleRowBandSize", "tableStyleRowBandSize")
 );
-const translator$t = NodeTranslator.from(createMeasurementPropertyHandler("w:tblW", "tableWidth"));
-const translator$s = NodeTranslator.from({
+const translator$u = NodeTranslator.from(createMeasurementPropertyHandler("w:tblW", "tableWidth"));
+const translator$t = 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))),
@@ -26894,29 +26891,29 @@ const translator$s = NodeTranslator.from({
     return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$r = NodeTranslator.from(createBorderPropertyHandler("w:bottom"));
-const translator$q = NodeTranslator.from(createMeasurementPropertyHandler("w:bottom", "marginBottom"));
-const translator$p = NodeTranslator.from(createBorderPropertyHandler("w:end"));
-const translator$o = NodeTranslator.from(createMeasurementPropertyHandler("w:end", "marginEnd"));
-const translator$n = NodeTranslator.from(createBorderPropertyHandler("w:insideH"));
-const translator$m = NodeTranslator.from(createBorderPropertyHandler("w:insideV"));
-const translator$l = NodeTranslator.from(createBorderPropertyHandler("w:left"));
-const translator$k = NodeTranslator.from(createMeasurementPropertyHandler("w:left", "marginLeft"));
-const translator$j = NodeTranslator.from(createBorderPropertyHandler("w:right"));
-const translator$i = NodeTranslator.from(createMeasurementPropertyHandler("w:right", "marginRight"));
-const translator$h = NodeTranslator.from(createBorderPropertyHandler("w:start"));
-const translator$g = NodeTranslator.from(createMeasurementPropertyHandler("w:start", "marginStart"));
-const translator$f = NodeTranslator.from(createBorderPropertyHandler("w:top"));
-const translator$e = NodeTranslator.from(createMeasurementPropertyHandler("w:top", "marginTop"));
-const XML_NODE_NAME$c = "w:tblBorders";
+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 SD_ATTR_KEY$3 = "borders";
-const encode$j = (params2) => {
+const encode$k = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
   const attributes = encodeProperties(node, tblBordersTranslatorsByXmlName);
   return Object.keys(attributes).length > 0 ? attributes : void 0;
 };
-const decode$j = (params2) => {
+const decode$k = (params2) => {
   const { borders = {} } = params2.node.attrs || {};
   const elements = decodeProperties(tblBordersTranslatorsBySdName, borders);
   const newNode = {
@@ -26928,14 +26925,14 @@ const decode$j = (params2) => {
   return newNode;
 };
 const propertyTranslators$2 = [
-  translator$r,
-  translator$p,
+  translator$s,
+  translator$q,
+  translator$o,
   translator$n,
   translator$m,
-  translator$l,
-  translator$j,
-  translator$h,
-  translator$f
+  translator$k,
+  translator$i,
+  translator$g
 ];
 const tblBordersTranslatorsByXmlName = {};
 const tblBordersTranslatorsBySdName = {};
@@ -26943,27 +26940,27 @@ propertyTranslators$2.forEach((translator2) => {
   tblBordersTranslatorsByXmlName[translator2.xmlName] = translator2;
   tblBordersTranslatorsBySdName[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$3,
   type: NodeTranslator.translatorTypes.NODE,
   attributes: [],
-  encode: encode$j,
-  decode: decode$j
+  encode: encode$k,
+  decode: decode$k
 });
-const XML_NODE_NAME$b = "w:tblCellMar";
+const XML_NODE_NAME$c = "w:tblCellMar";
 const SD_ATTR_KEY$2 = "cellMargins";
-const encode$i = (params2) => {
+const encode$j = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
   const attributes = encodeProperties(node, propertyTranslatorsByXmlName$1);
   return Object.keys(attributes).length > 0 ? attributes : void 0;
 };
-const decode$i = (params2) => {
+const decode$j = (params2) => {
   const { cellMargins = {} } = params2.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName$1, cellMargins);
   const newNode = {
-    name: XML_NODE_NAME$b,
+    name: XML_NODE_NAME$c,
     type: "element",
     attributes: {},
     elements
@@ -26971,12 +26968,12 @@ const decode$i = (params2) => {
   return newNode;
 };
 const propertyTranslators$1 = [
-  translator$q,
-  translator$o,
-  translator$k,
-  translator$i,
-  translator$g,
-  translator$e
+  translator$r,
+  translator$p,
+  translator$l,
+  translator$j,
+  translator$h,
+  translator$f
 ];
 const propertyTranslatorsByXmlName$1 = {};
 const propertyTranslatorsBySdName$1 = {};
@@ -26984,27 +26981,27 @@ propertyTranslators$1.forEach((translator2) => {
   propertyTranslatorsByXmlName$1[translator2.xmlName] = translator2;
   propertyTranslatorsBySdName$1[translator2.sdNodeOrKeyName] = translator2;
 });
-const translator$c = NodeTranslator.from({
-  xmlName: XML_NODE_NAME$b,
+const translator$d = NodeTranslator.from({
+  xmlName: XML_NODE_NAME$c,
   sdNodeOrKeyName: SD_ATTR_KEY$2,
   type: NodeTranslator.translatorTypes.NODE,
   attributes: [],
-  encode: encode$i,
-  decode: decode$i
+  encode: encode$j,
+  decode: decode$j
 });
-const XML_NODE_NAME$a = "w:tblPr";
+const XML_NODE_NAME$b = "w:tblPr";
 const SD_ATTR_KEY$1 = "tableProperties";
-const encode$h = (params2) => {
+const encode$i = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
   const attributes = encodeProperties(node, propertyTranslatorsByXmlName);
   return {
-    xmlName: XML_NODE_NAME$a,
+    xmlName: XML_NODE_NAME$b,
     sdNodeOrKeyName: SD_ATTR_KEY$1,
     attributes
   };
 };
-const decode$h = (params2) => {
+const decode$i = (params2) => {
   const { tableProperties = {} } = params2.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName, tableProperties);
   const newNode = {
@@ -27016,11 +27013,12 @@ const decode$h = (params2) => {
   return newNode;
 };
 const propertyTranslators = [
+  translator$F,
+  translator$N,
   translator$E,
-  translator$M,
   translator$D,
+  translator$M,
   translator$C,
-  translator$L,
   translator$B,
   translator$A,
   translator$z,
@@ -27030,9 +27028,8 @@ const propertyTranslators = [
   translator$v,
   translator$u,
   translator$t,
-  translator$s,
-  translator$d,
-  translator$c
+  translator$e,
+  translator$d
 ];
 const propertyTranslatorsByXmlName = {};
 const propertyTranslatorsBySdName = {};
@@ -27040,14 +27037,14 @@ propertyTranslators.forEach((translator2) => {
   propertyTranslatorsByXmlName[translator2.xmlName] = translator2;
   propertyTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
 });
-const config$a = {
-  xmlName: XML_NODE_NAME$a,
+const config$b = {
+  xmlName: XML_NODE_NAME$b,
   sdNodeOrKeyName: SD_ATTR_KEY$1,
-  encode: encode$h,
-  decode: decode$h
+  encode: encode$i,
+  decode: decode$i
 };
-const translator$b = NodeTranslator.from(config$a);
-const translator$a = NodeTranslator.from(
+const translator$c = NodeTranslator.from(config$b);
+const translator$b = NodeTranslator.from(
   createSingleAttrPropertyHandler("w:gridCol", "col", "w:w", parseInteger, integerToString)
 );
 const DEFAULT_COLUMN_WIDTH_PX = 100;
@@ -27097,20 +27094,20 @@ const resolveFallbackColumnWidthTwips = (params2, totalColumns, cellMinWidthTwip
   }
   return Math.max(fallbackWidthTwips, cellMinWidthTwips);
 };
-const XML_NODE_NAME$9 = "w:tblGrid";
+const XML_NODE_NAME$a = "w:tblGrid";
 const SD_ATTR_KEY = "grid";
 const cellMinWidth = pixelsToTwips(10);
-const encode$g = (params2) => {
+const encode$h = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
-  const attributes = encodeProperties(node, { [translator$a.xmlName]: translator$a }, true);
+  const attributes = encodeProperties(node, { [translator$b.xmlName]: translator$b }, true);
   return {
-    xmlName: XML_NODE_NAME$9,
+    xmlName: XML_NODE_NAME$a,
     sdNodeOrKeyName: SD_ATTR_KEY,
     attributes
   };
 };
-const decode$g = (params2) => {
+const decode$h = (params2) => {
   const { grid: rawGrid } = params2.node.attrs || {};
   const grid = Array.isArray(rawGrid) ? rawGrid : [];
   const { firstRow = {} } = params2.extraParams || {};
@@ -27129,10 +27126,10 @@ const decode$g = (params2) => {
       numericWidth = fallbackColumnWidthTwips;
     }
     numericWidth = Math.max(numericWidth, cellMinWidth);
-    const decoded = translator$a.decode({
+    const decoded = translator$b.decode({
       node: { type: (
         /** @type {string} */
-        translator$a.sdNodeOrKeyName
+        translator$b.sdNodeOrKeyName
       ), attrs: { col: numericWidth } }
     });
     if (decoded) elements.push(decoded);
@@ -27167,39 +27164,100 @@ const decode$g = (params2) => {
     columnIndex++;
   }
   const newNode = {
-    name: XML_NODE_NAME$9,
+    name: XML_NODE_NAME$a,
     attributes: {},
     elements
   };
   return newNode;
 };
-const config$9 = {
-  xmlName: XML_NODE_NAME$9,
+const config$a = {
+  xmlName: XML_NODE_NAME$a,
   sdNodeOrKeyName: SD_ATTR_KEY,
-  encode: encode$g,
-  decode: decode$g
+  encode: encode$h,
+  decode: decode$h
 };
-const translator$9 = NodeTranslator.from(config$9);
-const XML_NODE_NAME$8 = "w:tbl";
-const SD_NODE_NAME$8 = "table";
-const encode$f = (params2, encodedAttrs) => {
+const translator$a = NodeTranslator.from(config$a);
+const DEFAULT_PAGE_WIDTH_TWIPS = 12240;
+const DEFAULT_PAGE_MARGIN_TWIPS = 1440;
+const DEFAULT_CONTENT_WIDTH_TWIPS = DEFAULT_PAGE_WIDTH_TWIPS - 2 * DEFAULT_PAGE_MARGIN_TWIPS;
+const MIN_COLUMN_WIDTH_TWIPS = pixelsToTwips(10);
+const pctToPercent = (value) => {
+  if (value == null) return null;
+  return value / 50;
+};
+const resolveContentWidthTwips = () => DEFAULT_CONTENT_WIDTH_TWIPS;
+const resolveMeasurementWidthPx = (measurement) => {
+  if (!measurement || typeof measurement.value !== "number" || measurement.value <= 0) return null;
+  const { value, type: type2 } = measurement;
+  if (!type2 || type2 === "auto") return null;
+  if (type2 === "dxa") return twipsToPixels(value);
+  if (type2 === "pct") {
+    const percent2 = pctToPercent(value);
+    if (percent2 == null || percent2 <= 0) return null;
+    const widthTwips = resolveContentWidthTwips() * percent2 / 100;
+    return twipsToPixels(widthTwips);
+  }
+  return null;
+};
+const countColumnsInRow = (row) => {
+  if (!row?.elements?.length) return 0;
+  return row.elements.reduce((count, element) => {
+    if (element.name !== "w:tc") return count;
+    const tcPr = element.elements?.find((el) => el.name === "w:tcPr");
+    const gridSpan = tcPr?.elements?.find((el) => el.name === "w:gridSpan");
+    const spanValue = parseInt(gridSpan?.attributes?.["w:val"] || "1", 10);
+    return count + (Number.isFinite(spanValue) && spanValue > 0 ? spanValue : 1);
+  }, 0);
+};
+const clampColumnWidthTwips = (value) => Math.max(Math.round(value), MIN_COLUMN_WIDTH_TWIPS);
+const createFallbackGrid = (columnCount, columnWidthTwips) => Array.from({ length: columnCount }, () => ({ col: clampColumnWidthTwips(columnWidthTwips) }));
+const buildFallbackGridForTable = ({ params: params2, rows, tableWidth, tableWidthMeasurement }) => {
+  const firstRow = rows.find((row) => row.elements?.some((el) => el.name === "w:tc"));
+  const columnCount = countColumnsInRow(firstRow);
+  if (!columnCount) return null;
+  const schemaDefaultPx = getSchemaDefaultColumnWidthPx(
+    /** @type {any} */
+    params2
+  );
+  const minimumColumnWidthPx = Number.isFinite(schemaDefaultPx) && schemaDefaultPx > 0 ? schemaDefaultPx : DEFAULT_COLUMN_WIDTH_PX;
+  let totalWidthPx;
+  if (tableWidthMeasurement) {
+    const resolved = resolveMeasurementWidthPx(tableWidthMeasurement);
+    if (resolved != null) totalWidthPx = resolved;
+  }
+  if (totalWidthPx == null && tableWidth?.width && tableWidth.width > 0) {
+    totalWidthPx = tableWidth.width;
+  }
+  if (totalWidthPx == null) {
+    totalWidthPx = minimumColumnWidthPx * columnCount;
+  }
+  const rawColumnWidthPx = Math.max(totalWidthPx / columnCount, minimumColumnWidthPx);
+  const columnWidthTwips = clampColumnWidthTwips(pixelsToTwips(rawColumnWidthPx));
+  const fallbackColumnWidthPx = twipsToPixels(columnWidthTwips);
+  return {
+    grid: createFallbackGrid(columnCount, columnWidthTwips),
+    columnWidths: Array(columnCount).fill(fallbackColumnWidthPx)
+  };
+};
+const XML_NODE_NAME$9 = "w:tbl";
+const SD_NODE_NAME$9 = "table";
+const encode$g = (params2, encodedAttrs) => {
   const { nodes } = params2;
   const node = nodes[0];
   const tblPr = node.elements.find((el) => el.name === "w:tblPr");
   if (tblPr) {
-    const encodedProperties = translator$b.encode({ ...params2, nodes: [tblPr] });
+    const encodedProperties = translator$c.encode({ ...params2, nodes: [tblPr] });
     encodedAttrs["tableProperties"] = encodedProperties?.attributes || {};
   }
   const tblGrid = node.elements.find((el) => el.name === "w:tblGrid");
   if (tblGrid) {
-    encodedAttrs["grid"] = translator$9.encode({ ...params2, nodes: [tblGrid] }).attributes;
+    encodedAttrs["grid"] = translator$a.encode({ ...params2, nodes: [tblGrid] }).attributes;
   }
   [
     "tableStyleId",
     "justification",
     "tableLayout",
     ["tableIndent", ({ value, type: type2 }) => ({ width: twipsToPixels(value), type: type2 })],
-    ["tableWidth", ({ value, type: type2 }) => ({ width: twipsToPixels(value), type: type2 })],
     ["tableCellSpacing", ({ value, type: type2 }) => ({ w: String(value), type: type2 })]
   ].forEach((prop) => {
     let key2;
@@ -27217,6 +27275,21 @@ const encode$f = (params2, encodedAttrs) => {
   if (encodedAttrs.tableCellSpacing) {
     encodedAttrs["borderCollapse"] = "separate";
   }
+  if (encodedAttrs.tableProperties?.tableWidth) {
+    const tableWidthMeasurement = encodedAttrs.tableProperties.tableWidth;
+    const widthPx = twipsToPixels(tableWidthMeasurement.value);
+    if (widthPx != null) {
+      encodedAttrs.tableWidth = {
+        width: widthPx,
+        type: tableWidthMeasurement.type
+      };
+    } else if (tableWidthMeasurement.type === "auto") {
+      encodedAttrs.tableWidth = {
+        width: 0,
+        type: tableWidthMeasurement.type
+      };
+    }
+  }
   const { borders, rowBorders } = _processTableBorders(encodedAttrs.tableProperties?.borders || {});
   const referencedStyles = _getReferencedTableStyles(encodedAttrs.tableStyleId, params2);
   if (referencedStyles?.cellMargins && !encodedAttrs.tableProperties?.cellMargins) {
@@ -27230,10 +27303,22 @@ const encode$f = (params2, encodedAttrs) => {
   const borderRowData = Object.assign({}, referencedStyles?.rowBorders || {}, rowBorders || {});
   encodedAttrs["borders"] = borderData;
   const tblStyleTag = tblPr?.elements?.find((el) => el.name === "w:tblStyle");
-  const columnWidths = (encodedAttrs["grid"] ?? []).map((item) => twipsToPixels(item.col));
+  let columnWidths = Array.isArray(encodedAttrs["grid"]) ? encodedAttrs["grid"].map((item) => twipsToPixels(item.col)) : [];
+  if (!columnWidths.length) {
+    const fallback = buildFallbackGridForTable({
+      params: params2,
+      rows,
+      tableWidth: encodedAttrs.tableWidth,
+      tableWidthMeasurement: encodedAttrs.tableProperties?.tableWidth
+    });
+    if (fallback) {
+      encodedAttrs.grid = fallback.grid;
+      columnWidths = fallback.columnWidths;
+    }
+  }
   const content = [];
   rows.forEach((row) => {
-    const result = translator$F.encode({
+    const result = translator$G.encode({
       ...params2,
       nodes: [row],
       extraParams: {
@@ -27252,13 +27337,13 @@ const encode$f = (params2, encodedAttrs) => {
     attrs: encodedAttrs
   };
 };
-const decode$f = (params2, decodedAttrs) => {
+const decode$g = (params2, decodedAttrs) => {
   params2.node = preProcessVerticalMergeCells(params2.node, params2);
   const { node } = params2;
   const elements = translateChildNodes(params2);
   const firstRow = node.content?.find((n) => n.type === "tableRow");
   const properties = node.attrs.grid;
-  const element = translator$9.decode({
+  const element = translator$a.decode({
     ...params2,
     node: { ...node, attrs: { ...node.attrs, grid: properties } },
     extraParams: {
@@ -27268,7 +27353,7 @@ const decode$f = (params2, decodedAttrs) => {
   if (element) elements.unshift(element);
   if (node.attrs?.tableProperties) {
     const properties2 = { ...node.attrs.tableProperties };
-    const element2 = translator$b.decode({
+    const element2 = translator$c.decode({
       ...params2,
       node: { ...node, attrs: { ...node.attrs, tableProperties: properties2 } }
     });
@@ -27334,7 +27419,7 @@ function _getReferencedTableStyles(tableStyleReference, params2) {
     if (baseTblPr && baseTblPr.elements) {
       tblPr.elements.push(...baseTblPr.elements);
     }
-    const tableProperties = translator$b.encode({ ...params2, nodes: [tblPr] }).attributes;
+    const tableProperties = translator$c.encode({ ...params2, nodes: [tblPr] }).attributes;
     const { borders, rowBorders } = _processTableBorders(tableProperties.borders || {});
     if (borders) stylesToReturn.borders = borders;
     if (rowBorders) stylesToReturn.rowBorders = rowBorders;
@@ -27351,16 +27436,16 @@ function _getReferencedTableStyles(tableStyleReference, params2) {
   }
   return stylesToReturn;
 }
-const config$8 = {
-  xmlName: XML_NODE_NAME$8,
-  sdNodeOrKeyName: SD_NODE_NAME$8,
+const config$9 = {
+  xmlName: XML_NODE_NAME$9,
+  sdNodeOrKeyName: SD_NODE_NAME$9,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$f,
-  decode: decode$f,
+  encode: encode$g,
+  decode: decode$g,
   attributes: []
 };
-const translator$8 = NodeTranslator.from(config$8);
-const tableNodeHandlerEntity = generateV2HandlerEntity("tableNodeHandler", translator$8);
+const translator$9 = NodeTranslator.from(config$9);
+const tableNodeHandlerEntity = generateV2HandlerEntity("tableNodeHandler", translator$9);
 function getReferencedTableStyles(tblStyleTag, docx) {
   if (!tblStyleTag) return null;
   const stylesToReturn = {};
@@ -27722,10 +27807,10 @@ function generateCellMargins(cellMargins) {
   if (left2 != null) elements.push({ name: "w:left", attributes: { "w:w": pixelsToTwips(left2) } });
   return elements;
 }
-const XML_NODE_NAME$7 = "w:tc";
-const SD_NODE_NAME$7 = "tableCell";
-const validXmlAttributes$7 = [];
-function encode$e(params2, encodedAttrs) {
+const XML_NODE_NAME$8 = "w:tc";
+const SD_NODE_NAME$8 = "tableCell";
+const validXmlAttributes$8 = [];
+function encode$f(params2, encodedAttrs) {
   const {
     node,
     table,
@@ -27752,31 +27837,31 @@ function encode$e(params2, encodedAttrs) {
   }
   return schemaNode;
 }
-function decode$e(params2, decodedAttrs) {
+function decode$f(params2, decodedAttrs) {
   const translated = translateTableCell(params2);
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
     translated.attributes = { ...translated.attributes || {}, ...decodedAttrs };
   }
   return translated;
 }
-const config$7 = {
-  xmlName: XML_NODE_NAME$7,
-  sdNodeOrKeyName: SD_NODE_NAME$7,
+const config$8 = {
+  xmlName: XML_NODE_NAME$8,
+  sdNodeOrKeyName: SD_NODE_NAME$8,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$e,
-  decode: decode$e,
-  attributes: validXmlAttributes$7
+  encode: encode$f,
+  decode: decode$f,
+  attributes: validXmlAttributes$8
 };
-const translator$7 = NodeTranslator.from(config$7);
-const XML_NODE_NAME$6 = "w:hyperlink";
-const SD_NODE_NAME$6 = "link";
+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$6 = [
+const validXmlAttributes$7 = [
   _createAttributeHandler("w:anchor", "anchor"),
   _createAttributeHandler("w:docLocation", "docLocation"),
   {
@@ -27789,7 +27874,7 @@ const validXmlAttributes$6 = [
   _createAttributeHandler("r:id", "rId"),
   _createAttributeHandler("w:tgtFrame", "target")
 ];
-const encode$d = (params2, encodedAttrs) => {
+const encode$e = (params2, encodedAttrs) => {
   const { nodes, docx, nodeListHandler } = params2;
   const node = nodes[0];
   let href = _resolveHref(docx, encodedAttrs);
@@ -27855,7 +27940,7 @@ const _resolveHref = (docx, encodedAttrs) => {
   }
   return href;
 };
-function decode$d(params2) {
+function decode$e(params2) {
   const { node } = params2;
   const linkMark = node.marks.find((m2) => m2.type === "link");
   const linkAttrs = this.decodeAttributes({ ...params2, node: linkMark });
@@ -27899,15 +27984,15 @@ function _addNewLinkRelationship(params2, link, rId) {
   });
   return rId;
 }
-const config$6 = {
-  xmlName: XML_NODE_NAME$6,
-  sdNodeOrKeyName: SD_NODE_NAME$6,
+const config$7 = {
+  xmlName: XML_NODE_NAME$7,
+  sdNodeOrKeyName: SD_NODE_NAME$7,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$d,
-  decode: decode$d,
-  attributes: validXmlAttributes$6
+  encode: encode$e,
+  decode: decode$e,
+  attributes: validXmlAttributes$7
 };
-const translator$6 = NodeTranslator.from(config$6);
+const translator$7 = NodeTranslator.from(config$7);
 function parseTagValueJSON(json) {
   if (typeof json !== "string") {
     return {};
@@ -28702,32 +28787,32 @@ function translateAnchorNode(params2) {
     elements: [...anchorElements, ...elementsWithWrap]
   };
 }
-const XML_NODE_NAME$5 = "wp:anchor";
-const SD_NODE_NAME$5 = ["image"];
-const validXmlAttributes$5 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
-function encode$c(params2) {
+const XML_NODE_NAME$6 = "wp:anchor";
+const SD_NODE_NAME$6 = ["image"];
+const validXmlAttributes$6 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
+function encode$d(params2) {
   const { node } = params2.extraParams;
   if (!node || !node.type) {
     return null;
   }
   return handleAnchorNode(params2);
 }
-function decode$c(params2) {
+function decode$d(params2) {
   const { node } = params2;
   if (!node || !node.type) {
     return null;
   }
   return translateAnchorNode(params2);
 }
-const config$5 = {
-  xmlName: XML_NODE_NAME$5,
-  sdNodeOrKeyName: SD_NODE_NAME$5,
+const config$6 = {
+  xmlName: XML_NODE_NAME$6,
+  sdNodeOrKeyName: SD_NODE_NAME$6,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$c,
-  decode: decode$c,
-  attributes: validXmlAttributes$5
+  encode: encode$d,
+  decode: decode$d,
+  attributes: validXmlAttributes$6
 };
-const translator$5 = NodeTranslator.from(config$5);
+const translator$6 = NodeTranslator.from(config$6);
 function handleInlineNode(params2) {
   const { node } = params2.extraParams;
   if (node.name !== "wp:inline") {
@@ -28743,41 +28828,41 @@ function translateInlineNode(params2) {
     elements: nodeElements.elements
   };
 }
-const XML_NODE_NAME$4 = "wp:inline";
-const SD_NODE_NAME$4 = ["image"];
-const validXmlAttributes$4 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
-function encode$b(params2) {
+const XML_NODE_NAME$5 = "wp:inline";
+const SD_NODE_NAME$5 = ["image"];
+const validXmlAttributes$5 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
+function encode$c(params2) {
   const { node } = params2.extraParams;
   if (!node || !node.type) {
     return null;
   }
   return handleInlineNode(params2);
 }
-function decode$b(params2) {
+function decode$c(params2) {
   const { node } = params2;
   if (!node || !node.type) {
     return null;
   }
   return translateInlineNode(params2);
 }
-const config$4 = {
-  xmlName: XML_NODE_NAME$4,
-  sdNodeOrKeyName: SD_NODE_NAME$4,
+const config$5 = {
+  xmlName: XML_NODE_NAME$5,
+  sdNodeOrKeyName: SD_NODE_NAME$5,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$b,
-  decode: decode$b,
-  attributes: validXmlAttributes$4
+  encode: encode$c,
+  decode: decode$c,
+  attributes: validXmlAttributes$5
 };
-const translator$4 = NodeTranslator.from(config$4);
-const XML_NODE_NAME$3 = "w:drawing";
-const SD_NODE_NAME$3 = [];
-const validXmlAttributes$3 = [];
-function encode$a(params2) {
+const translator$5 = NodeTranslator.from(config$5);
+const XML_NODE_NAME$4 = "w:drawing";
+const SD_NODE_NAME$4 = [];
+const validXmlAttributes$4 = [];
+function encode$b(params2) {
   const nodes = params2.nodes;
   const node = nodes[0];
   const translatorByChildName = {
-    "wp:anchor": translator$5,
-    "wp:inline": translator$4
+    "wp:anchor": translator$6,
+    "wp:inline": translator$5
   };
   return node.elements.reduce((acc, child) => {
     if (acc) return acc;
@@ -28786,12 +28871,12 @@ function encode$a(params2) {
     return translator2.encode({ ...params2, extraParams: { node: child } }) || acc;
   }, null);
 }
-function decode$a(params2) {
+function decode$b(params2) {
   const { node } = params2;
   if (!node || !node.type) {
     return null;
   }
-  const childTranslator = node.attrs.isAnchor ? translator$5 : translator$4;
+  const childTranslator = node.attrs.isAnchor ? translator$6 : translator$5;
   const resultNode = childTranslator.decode(params2);
   return wrapTextInRun(
     {
@@ -28801,15 +28886,15 @@ function decode$a(params2) {
     []
   );
 }
-const config$3 = {
-  xmlName: XML_NODE_NAME$3,
-  sdNodeOrKeyName: SD_NODE_NAME$3,
+const config$4 = {
+  xmlName: XML_NODE_NAME$4,
+  sdNodeOrKeyName: SD_NODE_NAME$4,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$a,
-  decode: decode$a,
-  attributes: validXmlAttributes$3
+  encode: encode$b,
+  decode: decode$b,
+  attributes: validXmlAttributes$4
 };
-const translator$3 = NodeTranslator.from(config$3);
+const translator$4 = NodeTranslator.from(config$4);
 class CommandService {
   /**
    * @param {import('./commands/types/index.js').CommandServiceOptions} props
@@ -30147,7 +30232,7 @@ function prepareTextAnnotation(params2) {
   return getTextNodeForExport(attrs.displayLabel, [...marks, ...marksFromAttrs], params2);
 }
 function prepareImageAnnotation(params2, imageSize) {
-  return translator$3.decode({
+  return translator$4.decode({
     ...params2,
     imageSize
   });
@@ -30384,10 +30469,10 @@ function translateStructuredContent(params2) {
   };
   return result;
 }
-const XML_NODE_NAME$2 = "w:sdt";
-const SD_NODE_NAME$2 = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
-const validXmlAttributes$2 = [];
-function encode$9(params2) {
+const XML_NODE_NAME$3 = "w:sdt";
+const SD_NODE_NAME$3 = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
+const validXmlAttributes$3 = [];
+function encode$a(params2) {
   const nodes = params2.nodes;
   const node = nodes[0];
   const { type: sdtType, handler: handler2 } = sdtNodeTypeStrategy(node);
@@ -30397,7 +30482,7 @@ function encode$9(params2) {
   const result = handler2(params2);
   return result;
 }
-function decode$9(params2) {
+function decode$a(params2) {
   const { node } = params2;
   if (!node || !node.type) {
     return null;
@@ -30413,85 +30498,85 @@ function decode$9(params2) {
   const result = decoder();
   return result;
 }
-const config$2 = {
-  xmlName: XML_NODE_NAME$2,
-  sdNodeOrKeyName: SD_NODE_NAME$2,
+const config$3 = {
+  xmlName: XML_NODE_NAME$3,
+  sdNodeOrKeyName: SD_NODE_NAME$3,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$9,
-  decode: decode$9,
-  attributes: validXmlAttributes$2
+  encode: encode$a,
+  decode: decode$a,
+  attributes: validXmlAttributes$3
 };
-const translator$2 = NodeTranslator.from(config$2);
-const encode$8 = (attributes) => {
+const translator$3 = NodeTranslator.from(config$3);
+const encode$9 = (attributes) => {
   return attributes["w:id"];
 };
-const decode$8 = (attrs) => {
+const decode$9 = (attrs) => {
   return attrs.id;
 };
 const attrConfig$6 = Object.freeze({
   xmlName: "w:id",
   sdName: "id",
-  encode: encode$8,
-  decode: decode$8
+  encode: encode$9,
+  decode: decode$9
 });
-const encode$7 = (attributes) => {
+const encode$8 = (attributes) => {
   return attributes["w:name"];
 };
-const decode$7 = (attrs) => {
+const decode$8 = (attrs) => {
   return attrs.name;
 };
 const attrConfig$5 = Object.freeze({
   xmlName: "w:name",
   sdName: "name",
-  encode: encode$7,
-  decode: decode$7
+  encode: encode$8,
+  decode: decode$8
 });
-const encode$6 = (attributes) => {
+const encode$7 = (attributes) => {
   return attributes["w:colFirst"];
 };
-const decode$6 = (attrs) => {
+const decode$7 = (attrs) => {
   return attrs.colFirst;
 };
 const attrConfig$4 = Object.freeze({
   xmlName: "w:colFirst",
   sdName: "colFirst",
-  encode: encode$6,
-  decode: decode$6
+  encode: encode$7,
+  decode: decode$7
 });
-const encode$5 = (attributes) => {
+const encode$6 = (attributes) => {
   return attributes["w:colLast"];
 };
-const decode$5 = (attrs) => {
+const decode$6 = (attrs) => {
   return attrs.colLast;
 };
 const attrConfig$3 = Object.freeze({
   xmlName: "w:colLast",
   sdName: "colLast",
-  encode: encode$5,
-  decode: decode$5
+  encode: encode$6,
+  decode: decode$6
 });
-const encode$4 = (attributes) => {
+const encode$5 = (attributes) => {
   return attributes["w:displacedByCustomXml"];
 };
-const decode$4 = (attrs) => {
+const decode$5 = (attrs) => {
   return attrs.displacedByCustomXml;
 };
 const attrConfig$2 = Object.freeze({
   xmlName: "w:displacedByCustomXml",
   sdName: "displacedByCustomXml",
-  encode: encode$4,
-  decode: decode$4
+  encode: encode$5,
+  decode: decode$5
 });
-const validXmlAttributes$1 = [attrConfig$6, attrConfig$5, attrConfig$4, attrConfig$3, attrConfig$2];
-const XML_NODE_NAME$1 = "w:bookmarkStart";
-const SD_NODE_NAME$1 = "bookmarkStart";
-const encode$3 = (params2, encodedAttrs = {}) => {
+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 = (params2, encodedAttrs = {}) => {
   return {
     type: "bookmarkStart",
     attrs: encodedAttrs
   };
 };
-const decode$3 = (params2, decodedAttrs = {}) => {
+const decode$4 = (params2, decodedAttrs = {}) => {
   const result = {
     name: "w:bookmarkStart",
     elements: []
@@ -30501,49 +30586,49 @@ const decode$3 = (params2, decodedAttrs = {}) => {
   }
   return result;
 };
-const config$1 = {
-  xmlName: XML_NODE_NAME$1,
-  sdNodeOrKeyName: SD_NODE_NAME$1,
+const config$2 = {
+  xmlName: XML_NODE_NAME$2,
+  sdNodeOrKeyName: SD_NODE_NAME$2,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$3,
-  decode: decode$3,
-  attributes: validXmlAttributes$1
+  encode: encode$4,
+  decode: decode$4,
+  attributes: validXmlAttributes$2
 };
-const translator$1 = NodeTranslator.from(config$1);
-const encode$2 = (attributes) => {
+const translator$2 = NodeTranslator.from(config$2);
+const encode$3 = (attributes) => {
   return attributes["w:id"];
 };
-const decode$2 = (attrs) => {
+const decode$3 = (attrs) => {
   return attrs.id;
 };
 const attrConfig$1 = Object.freeze({
   xmlName: "w:id",
   sdName: "id",
-  encode: encode$2,
-  decode: decode$2
+  encode: encode$3,
+  decode: decode$3
 });
-const encode$1 = (attributes) => {
+const encode$2 = (attributes) => {
   return attributes["w:displacedByCustomXml"];
 };
-const decode$1 = (attrs) => {
+const decode$2 = (attrs) => {
   return attrs.displacedByCustomXml;
 };
 const attrConfig = Object.freeze({
   xmlName: "w:displacedByCustomXml",
   sdName: "displacedByCustomXml",
-  encode: encode$1,
-  decode: decode$1
+  encode: encode$2,
+  decode: decode$2
 });
-const validXmlAttributes = [attrConfig$1, attrConfig];
-const XML_NODE_NAME = "w:bookmarkEnd";
-const SD_NODE_NAME = "bookmarkEnd";
-const encode$18 = (params2, encodedAttrs = {}) => {
+const validXmlAttributes$1 = [attrConfig$1, attrConfig];
+const XML_NODE_NAME$1 = "w:bookmarkEnd";
+const SD_NODE_NAME$1 = "bookmarkEnd";
+const encode$1 = (params2, encodedAttrs = {}) => {
   return {
     type: "bookmarkEnd",
     attrs: encodedAttrs
   };
 };
-const decode = (params2, decodedAttrs = {}) => {
+const decode$1 = (params2, decodedAttrs = {}) => {
   const result = {
     name: "w:bookmarkEnd",
     elements: []
@@ -30553,15 +30638,121 @@ const decode = (params2, decodedAttrs = {}) => {
   }
   return result;
 };
+const config$1 = {
+  xmlName: XML_NODE_NAME$1,
+  sdNodeOrKeyName: SD_NODE_NAME$1,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$1,
+  decode: decode$1,
+  attributes: validXmlAttributes$1
+};
+const translator$1 = NodeTranslator.from(config$1);
+const XML_NODE_NAME = "mc:AlternateContent";
+const SD_NODE_NAME = [];
+const validXmlAttributes = [];
+function encode$19(params2) {
+  const { nodeListHandler } = params2;
+  const { node } = params2.extraParams;
+  if (!node || !node.type) {
+    return null;
+  }
+  const allowedNamespaces = ["wps", "wp14", "w14", "w15"];
+  const wpsNode = node.elements.find(
+    (el) => el.name === "mc:Choice" && allowedNamespaces.includes(el.attributes["Requires"])
+  );
+  if (!wpsNode) {
+    return null;
+  }
+  const contents = wpsNode.elements;
+  return nodeListHandler.handler({
+    ...params2,
+    nodes: contents,
+    path: [...params2.path || [], wpsNode]
+  });
+}
+function decode(params2) {
+  const { node } = params2;
+  const { drawingContent } = node.attrs;
+  const drawing = {
+    name: "w:drawing",
+    elements: [...drawingContent ? [...drawingContent.elements || []] : []]
+  };
+  const choice = {
+    name: "mc:Choice",
+    attributes: { Requires: "wps" },
+    elements: [drawing]
+  };
+  return {
+    name: "mc:AlternateContent",
+    elements: [choice]
+  };
+}
 const config = {
   xmlName: XML_NODE_NAME,
   sdNodeOrKeyName: SD_NODE_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$18,
+  encode: encode$19,
   decode,
   attributes: validXmlAttributes
 };
 const translator = NodeTranslator.from(config);
+const DEFAULT_SECTION_PROPS_TWIPS = Object.freeze({
+  pageSize: Object.freeze({ width: "12240", height: "15840" }),
+  pageMargins: Object.freeze({
+    top: "1440",
+    right: "1440",
+    bottom: "1440",
+    left: "1440",
+    header: "720",
+    footer: "720",
+    gutter: "0"
+  })
+});
+const ensureSectionLayoutDefaults = (sectPr, converter) => {
+  if (!sectPr) {
+    return {
+      type: "element",
+      name: "w:sectPr",
+      elements: []
+    };
+  }
+  if (!sectPr.elements) sectPr.elements = [];
+  const ensureChild = (name) => {
+    let child = sectPr.elements.find((n) => n.name === name);
+    if (!child) {
+      child = {
+        type: "element",
+        name,
+        elements: [],
+        attributes: {}
+      };
+      sectPr.elements.push(child);
+    } else {
+      if (!child.elements) child.elements = [];
+      if (!child.attributes) child.attributes = {};
+    }
+    return child;
+  };
+  const pageSize = converter?.pageStyles?.pageSize;
+  const pgSz = ensureChild("w:pgSz");
+  if (pageSize?.width != null) pgSz.attributes["w:w"] = String(inchesToTwips(pageSize.width));
+  if (pageSize?.height != null) pgSz.attributes["w:h"] = String(inchesToTwips(pageSize.height));
+  if (pgSz.attributes["w:w"] == null) pgSz.attributes["w:w"] = DEFAULT_SECTION_PROPS_TWIPS.pageSize.width;
+  if (pgSz.attributes["w:h"] == null) pgSz.attributes["w:h"] = DEFAULT_SECTION_PROPS_TWIPS.pageSize.height;
+  const pageMargins = converter?.pageStyles?.pageMargins;
+  const pgMar = ensureChild("w:pgMar");
+  if (pageMargins) {
+    Object.entries(pageMargins).forEach(([key2, value]) => {
+      const converted = inchesToTwips(value);
+      if (converted != null) pgMar.attributes[`w:${key2}`] = String(converted);
+    });
+  }
+  Object.entries(DEFAULT_SECTION_PROPS_TWIPS.pageMargins).forEach(([key2, value]) => {
+    const attrKey = `w:${key2}`;
+    if (pgMar.attributes[attrKey] == null) pgMar.attributes[attrKey] = value;
+  });
+  return sectPr;
+};
 const isLineBreakOnlyRun = (node) => {
   if (!node) return false;
   if (node.type === "lineBreak" || node.type === "hardBreak") return true;
@@ -30576,30 +30767,30 @@ function exportSchemaToJson(params2) {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$12,
-    run: translator$T,
+    paragraph: translator$13,
+    run: translator$U,
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$15,
-    table: translator$8,
-    tableRow: translator$F,
-    tableCell: translator$7,
-    bookmarkStart: translator$1,
-    bookmarkEnd: translator,
-    fieldAnnotation: translator$2,
-    tab: translator$13,
-    image: translator$3,
-    hardBreak: translator$15,
+    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,
     commentRangeStart: () => translateCommentNode(params2, "Start"),
     commentRangeEnd: () => translateCommentNode(params2, "End"),
     commentReference: () => null,
     shapeContainer: translateShapeContainer,
     shapeTextbox: translateShapeTextbox,
     contentBlock: translateContentBlock,
-    structuredContent: translator$2,
-    structuredContentBlock: translator$2,
-    documentSection: translator$2,
+    structuredContent: translator$3,
+    structuredContentBlock: translator$3,
+    documentSection: translator$3,
     "page-number": translatePageNumberNode,
     "total-page-number": translateTotalPageNumberNode
   };
@@ -30614,28 +30805,30 @@ function exportSchemaToJson(params2) {
   return handler2(params2);
 }
 function translateBodyNode(params2) {
-  let sectPr = params2.bodyNode?.elements.find((n) => n.name === "w:sectPr") || {};
+  let sectPr = params2.bodyNode?.elements?.find((n) => n.name === "w:sectPr");
+  if (!sectPr) {
+    sectPr = {
+      type: "element",
+      name: "w:sectPr",
+      elements: []
+    };
+  } else if (!sectPr.elements) {
+    sectPr = { ...sectPr, elements: [] };
+  }
+  sectPr = ensureSectionLayoutDefaults(sectPr, params2.converter);
   if (params2.converter) {
-    const hasHeader = sectPr?.elements?.some((n) => n.name === "w:headerReference");
+    const hasHeader = sectPr.elements?.some((n) => n.name === "w:headerReference");
     const hasDefaultHeader = params2.converter.headerIds?.default;
     if (!hasHeader && hasDefaultHeader && !params2.editor.options.isHeaderOrFooter) {
       const defaultHeader = generateDefaultHeaderFooter("header", params2.converter.headerIds?.default);
       sectPr.elements.push(defaultHeader);
     }
-    const hasFooter = sectPr?.elements?.some((n) => n.name === "w:footerReference");
+    const hasFooter = sectPr.elements?.some((n) => n.name === "w:footerReference");
     const hasDefaultFooter = params2.converter.footerIds?.default;
     if (!hasFooter && hasDefaultFooter && !params2.editor.options.isHeaderOrFooter) {
       const defaultFooter = generateDefaultHeaderFooter("footer", params2.converter.footerIds?.default);
       sectPr.elements.push(defaultFooter);
     }
-    const newMargins = params2.converter.pageStyles.pageMargins;
-    const sectPrMargins = sectPr.elements.find((n) => n.name === "w:pgMar");
-    const { attributes } = sectPrMargins;
-    Object.entries(newMargins).forEach(([key2, value]) => {
-      const convertedValue = inchesToTwips(value);
-      attributes[`w:${key2}`] = convertedValue;
-    });
-    sectPrMargins.attributes = attributes;
   }
   const elements = translateChildNodes(params2);
   if (params2.isHeaderFooter) {
@@ -30938,7 +31131,7 @@ function translateTextNode(params2) {
   const isTrackedNode = node.marks?.some((m2) => trackedMarks.includes(m2.type));
   if (isTrackedNode) return translateTrackedNode(params2);
   const isLinkNode = node.marks?.some((m2) => m2.type === "link");
-  if (isLinkNode) return translator$6.decode(params2);
+  if (isLinkNode) return translator$7.decode(params2);
   const { text, marks = [] } = node;
   return getTextNodeForExport(text, marks, params2);
 }
@@ -31244,7 +31437,7 @@ function translateMark(mark) {
       markElement.type = "element";
       break;
     case "underline": {
-      const translated = translator$$.decode({
+      const translated = translator$10.decode({
         node: {
           attrs: {
             underlineType: attrs.underlineType ?? attrs.underline ?? null,
@@ -31308,7 +31501,7 @@ function translateMark(mark) {
       break;
     case "highlight": {
       const highlightValue = attrs.color ?? attrs.highlight ?? null;
-      const translated = translator$14.decode({ node: { attrs: { highlight: highlightValue } } });
+      const translated = translator$15.decode({ node: { attrs: { highlight: highlightValue } } });
       return translated || {};
     }
   }
@@ -31364,23 +31557,11 @@ function translateShapeTextbox(params2) {
 }
 function translateContentBlock(params2) {
   const { node } = params2;
-  const { drawingContent, vmlAttributes, horizontalRule } = node.attrs;
+  const { vmlAttributes, horizontalRule } = node.attrs;
   if (vmlAttributes || horizontalRule) {
     return translateVRectContentBlock(params2);
   }
-  const drawing = {
-    name: "w:drawing",
-    elements: [...drawingContent ? [...drawingContent.elements || []] : []]
-  };
-  const choice = {
-    name: "mc:Choice",
-    attributes: { Requires: "wps" },
-    elements: [drawing]
-  };
-  const alternateContent = {
-    name: "mc:AlternateContent",
-    elements: [choice]
-  };
+  const alternateContent = translator.decode(params2);
   return wrapTextInRun(alternateContent);
 }
 function translateVRectContentBlock(params2) {
@@ -31584,7 +31765,7 @@ const handleDrawingNode = (params2) => {
   if (mainNode.name === "w:drawing") node = mainNode;
   else node = mainNode.elements.find((el) => el.name === "w:drawing");
   if (!node) return { nodes: [], consumed: 0 };
-  const schemaNode = translator$3.encode(params2);
+  const schemaNode = translator$4.encode(params2);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -31686,8 +31867,8 @@ const trackChangeNodeHandlerEntity = {
   handlerName: "trackChangeNodeHandler",
   handler: handleTrackChangeNode
 };
-const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$6);
-const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$T);
+const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$7);
+const runNodeHandlerEntity = generateV2HandlerEntity("runNodeHandler", translator$U);
 const handleTextNode = (params2) => {
   const { nodes, insideTrackChange } = params2;
   if (nodes.length === 0 || !(nodes[0].name === "w:t" || insideTrackChange && nodes[0].name === "w:delText")) {
@@ -31728,7 +31909,7 @@ const handleParagraphNode = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$12.encode(params2);
+  const schemaNode = translator$13.encode(params2);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -31741,7 +31922,7 @@ const handleSdtNode = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:sdt") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$2.encode(params2);
+  const result = translator$3.encode(params2);
   if (!result) {
     return { nodes: [], consumed: 0 };
   }
@@ -31831,7 +32012,7 @@ const handler = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$15.encode(params2);
+  const result = translator$16.encode(params2);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -31903,7 +32084,7 @@ const handleBookmarkStartNode = (params2) => {
   if (isCustomMarkBookmark(nodes[0], params2.editor)) {
     return handleBookmarkNode(params2);
   }
-  const node = translator$1.encode(params2);
+  const node = translator$2.encode(params2);
   if (!node) return { nodes: [], consumed: 0 };
   return { nodes: [node], consumed: 1 };
 };
@@ -31935,7 +32116,7 @@ const handleBookmarkEndNode = (params2) => {
   if (!nodes.length || nodes[0].name !== "w:bookmarkEnd") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator.encode(params2);
+  const node = translator$1.encode(params2);
   if (!node) return { nodes: [], consumed: 0 };
   return { nodes: [node], consumed: 1 };
 };
@@ -31943,32 +32124,86 @@ const bookmarkEndNodeHandlerEntity = {
   handlerName: "w:bookmarkEndTranslator",
   handler: handleBookmarkEndNode
 };
+const ALTERNATE_CONTENT_NODE = "mc:AlternateContent";
+const SUPPORTED_REQUIRES = /* @__PURE__ */ new Set([
+  "wps",
+  "wp14",
+  "w14",
+  "w15",
+  "w16",
+  "w16cex",
+  "w16cid",
+  "w16du",
+  "w16sdtdh",
+  "w16sdtfl",
+  "w16se"
+]);
+const skipHandlerResponse = { nodes: [], consumed: 0 };
+const isAlternateContentNode = (node) => node?.name === ALTERNATE_CONTENT_NODE;
+const isSupportedChoice = (choice) => {
+  if (!choice?.attributes) return false;
+  const requires = choice.attributes.Requires || choice.attributes.requires;
+  if (!requires) return false;
+  return requires.split(/\s+/).filter(Boolean).some((namespace2) => SUPPORTED_REQUIRES.has(namespace2));
+};
+const resolveAlternateContentElements = (alternateContent) => {
+  if (!alternateContent?.elements?.length) return null;
+  const choices = alternateContent.elements.filter((el) => el.name === "mc:Choice");
+  const fallback = alternateContent.elements.find((el) => el.name === "mc:Fallback");
+  const supportedChoice = choices.find(isSupportedChoice);
+  const selectedElements = supportedChoice?.elements || fallback?.elements || choices[0]?.elements;
+  if (!selectedElements) return null;
+  return carbonCopy(selectedElements);
+};
+const buildNodeWithoutAlternateContent = (node) => {
+  const { elements } = node || {};
+  if (!elements?.length) return null;
+  let replaced = false;
+  const updatedElements = [];
+  elements.forEach((element) => {
+    if (isAlternateContentNode(element)) {
+      const resolved = resolveAlternateContentElements(element);
+      if (resolved) {
+        updatedElements.push(...resolved);
+        replaced = true;
+        return;
+      }
+      updatedElements.push(carbonCopy(element));
+      return;
+    }
+    updatedElements.push(carbonCopy(element));
+  });
+  if (!replaced) return null;
+  const clone = carbonCopy(node);
+  clone.elements = updatedElements;
+  return clone;
+};
 const handleAlternateChoice = (params2) => {
-  const skipHandlerResponse = { nodes: [], consumed: 0 };
   const { nodes, nodeListHandler } = params2;
-  if (nodes.length === 0 || nodes[0].name !== "w:p") {
+  if (!nodes?.length) {
     return skipHandlerResponse;
   }
-  const mainNode = nodes[0];
-  const node = mainNode?.elements?.find((el) => el.name === "w:r");
-  const hasAltChoice = node?.elements?.some((el) => el.name === "mc:AlternateContent");
-  if (!hasAltChoice) {
-    return skipHandlerResponse;
+  const [currentNode] = nodes;
+  if (isAlternateContentNode(currentNode)) {
+    const resolvedElements = resolveAlternateContentElements(currentNode);
+    if (!resolvedElements) {
+      return skipHandlerResponse;
+    }
+    const result2 = nodeListHandler.handler({
+      ...params2,
+      nodes: resolvedElements,
+      path: [...params2.path || [], currentNode]
+    });
+    return { nodes: result2, consumed: 1 };
   }
-  const altChoiceNode = node.elements.find((el) => el.name === "mc:AlternateContent");
-  node.elements.findIndex((el) => el.name === "mc:AlternateContent");
-  const allowedNamespaces = ["wps", "wp14", "w14", "w15"];
-  const wpsNode = altChoiceNode.elements.find(
-    (el) => el.name === "mc:Choice" && allowedNamespaces.includes(el.attributes["Requires"])
-  );
-  if (!wpsNode) {
+  const sanitizedNode = buildNodeWithoutAlternateContent(currentNode);
+  if (!sanitizedNode) {
     return skipHandlerResponse;
   }
-  const contents = wpsNode.elements;
   const result = nodeListHandler.handler({
     ...params2,
-    nodes: contents,
-    path: [...params2.path || [], wpsNode]
+    nodes: [sanitizedNode],
+    path: [...params2.path || [], sanitizedNode]
   });
   return { nodes: result, consumed: 1 };
 };
@@ -32574,7 +32809,7 @@ const handleTabNode = (params2) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$13.encode(params2);
+  const node = translator$14.encode(params2);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
@@ -32608,6 +32843,7 @@ const createDocumentJson = (docx, converter, editor) => {
   const nodeListHandler = defaultNodeListHandler();
   const bodyNode = json.elements[0].elements.find((el) => el.name === "w:body");
   if (bodyNode) {
+    ensureSectionProperties(bodyNode);
     const node = bodyNode;
     const contentElements = node.elements?.filter((n) => n.name !== "w:sectPr") ?? [];
     const content = pruneIgnoredNodes(contentElements);
@@ -32841,6 +33077,59 @@ function getDocumentStyles(node, docx, converter, editor) {
   styles.alternateHeaders = isAlternatingHeadersOddEven(docx);
   return styles;
 }
+const DEFAULT_SECTION_PROPS = Object.freeze({
+  pageSize: Object.freeze({ width: "12240", height: "15840" }),
+  pageMargins: Object.freeze({
+    top: "1440",
+    right: "1440",
+    bottom: "1440",
+    left: "1440",
+    header: "720",
+    footer: "720",
+    gutter: "0"
+  })
+});
+function ensureSectionProperties(bodyNode, converter) {
+  if (!bodyNode.elements) bodyNode.elements = [];
+  let sectPr = bodyNode.elements.find((el) => el.name === "w:sectPr");
+  if (!sectPr) {
+    sectPr = {
+      type: "element",
+      name: "w:sectPr",
+      elements: []
+    };
+    bodyNode.elements.push(sectPr);
+  } else if (!sectPr.elements) {
+    sectPr.elements = [];
+  }
+  const ensureChild = (name, factory) => {
+    let child = sectPr.elements.find((el) => el.name === name);
+    if (!child) {
+      child = factory();
+      sectPr.elements.push(child);
+    } else if (!child.attributes) {
+      child.attributes = {};
+    }
+    return child;
+  };
+  const pgSz = ensureChild("w:pgSz", () => ({
+    type: "element",
+    name: "w:pgSz",
+    attributes: {}
+  }));
+  pgSz.attributes["w:w"] = pgSz.attributes["w:w"] ?? DEFAULT_SECTION_PROPS.pageSize.width;
+  pgSz.attributes["w:h"] = pgSz.attributes["w:h"] ?? DEFAULT_SECTION_PROPS.pageSize.height;
+  const pgMar = ensureChild("w:pgMar", () => ({
+    type: "element",
+    name: "w:pgMar",
+    attributes: {}
+  }));
+  Object.entries(DEFAULT_SECTION_PROPS.pageMargins).forEach(([key2, value]) => {
+    const attrKey = `w:${key2}`;
+    if (pgMar.attributes[attrKey] == null) pgMar.attributes[attrKey] = value;
+  });
+  return sectPr;
+}
 function getStyleDefinitions(docx) {
   const styles = docx["word/styles.xml"];
   if (!styles) return [];
@@ -33033,6 +33322,36 @@ const FONT_FAMILY_FALLBACKS = Object.freeze({
   auto: "sans-serif"
 });
 const DEFAULT_GENERIC_FALLBACK = "sans-serif";
+const DEFAULT_FONT_SIZE_PT = 10;
+const collectRunDefaultProperties = (runProps, { allowOverrideTypeface = true, allowOverrideSize = true, themeResolver, state: state2 }) => {
+  if (!runProps?.elements?.length || !state2) return;
+  const fontsNode = runProps.elements.find((el) => el.name === "w:rFonts");
+  if (fontsNode?.attributes) {
+    const themeName = fontsNode.attributes["w:asciiTheme"];
+    if (themeName) {
+      const themeInfo = themeResolver?.(themeName) || {};
+      if ((allowOverrideTypeface || !state2.typeface) && themeInfo.typeface) state2.typeface = themeInfo.typeface;
+      if ((allowOverrideTypeface || !state2.panose) && themeInfo.panose) state2.panose = themeInfo.panose;
+    }
+    const ascii = fontsNode.attributes["w:ascii"];
+    if ((allowOverrideTypeface || !state2.typeface) && ascii) {
+      state2.typeface = ascii;
+    }
+  }
+  const sizeNode = runProps.elements.find((el) => el.name === "w:sz");
+  if (sizeNode?.attributes?.["w:val"]) {
+    const sizeTwips = Number(sizeNode.attributes["w:val"]);
+    if (Number.isFinite(sizeTwips)) {
+      if (state2.fallbackSzTwips === void 0) state2.fallbackSzTwips = sizeTwips;
+      const sizePt = sizeTwips / 2;
+      if (allowOverrideSize || state2.fontSizePt === void 0) state2.fontSizePt = sizePt;
+    }
+  }
+  const kernNode = runProps.elements.find((el) => el.name === "w:kern");
+  if (kernNode?.attributes?.["w:val"]) {
+    if (allowOverrideSize || state2.kern === void 0) state2.kern = kernNode.attributes["w:val"];
+  }
+};
 const _SuperConverter = class _SuperConverter2 {
   constructor(params2 = null) {
     __privateAdd$2(this, _SuperConverter_instances);
@@ -33138,7 +33457,7 @@ const _SuperConverter = class _SuperConverter2 {
       return;
     }
   }
-  static updateDocumentVersion(docx = this.convertedXml, version2 = "0.20.2") {
+  static updateDocumentVersion(docx = this.convertedXml, version2 = "0.21.1") {
     const customLocation = "docProps/custom.xml";
     if (!docx[customLocation]) {
       docx[customLocation] = generateCustomXml();
@@ -33160,49 +33479,45 @@ const _SuperConverter = class _SuperConverter2 {
   }
   getDocumentDefaultStyles() {
     const styles = this.convertedXml["word/styles.xml"];
-    if (!styles) return {};
-    const defaults = styles.elements[0].elements.find((el) => el.name === "w:docDefaults");
-    const rDefault = defaults.elements.find((el) => el.name === "w:rPrDefault");
-    if (!rDefault.elements) return {};
-    const rElements = rDefault.elements[0].elements;
-    const rFonts = rElements?.find((el) => el.name === "w:rFonts");
-    if ("elements" in rDefault) {
-      const fontThemeName = rElements.find((el) => el.name === "w:rFonts")?.attributes["w:asciiTheme"];
-      let typeface, panose, fontSizeNormal;
-      if (fontThemeName) {
-        const fontInfo = this.getThemeInfo(fontThemeName);
-        typeface = fontInfo.typeface;
-        panose = fontInfo.panose;
-      } else if (rFonts) {
-        typeface = rFonts?.attributes["w:ascii"];
-      }
-      const paragraphDefaults = styles.elements[0].elements.filter((el) => {
-        return el.name === "w:style" && el.attributes["w:styleId"] === "Normal";
-      }) || [];
-      paragraphDefaults.forEach((el) => {
-        const rPr = el.elements.find((el2) => el2.name === "w:rPr");
-        const fonts = rPr?.elements?.find((el2) => el2.name === "w:rFonts");
-        typeface = fonts?.attributes["w:ascii"];
-        fontSizeNormal = Number(rPr?.elements?.find((el2) => el2.name === "w:sz")?.attributes["w:val"]) / 2;
-      });
-      const rPrDefaults = defaults?.elements?.find((el) => el.name === "w:rPrDefault");
-      if (rPrDefaults) {
-        const rPr = rPrDefaults.elements?.find((el) => el.name === "w:rPr");
-        const fonts = rPr?.elements?.find((el) => el.name === "w:rFonts");
-        if (fonts?.attributes?.["w:ascii"]) {
-          typeface = fonts.attributes["w:ascii"];
-        }
-        const fontSizeRaw = rPr?.elements?.find((el) => el.name === "w:sz")?.attributes?.["w:val"];
-        if (!fontSizeNormal && fontSizeRaw) {
-          fontSizeNormal = Number(fontSizeRaw) / 2;
-        }
-      }
-      const fallbackSz = Number(rElements.find((el) => el.name === "w:sz")?.attributes?.["w:val"]);
-      const fontSizePt = fontSizeNormal ?? (Number.isFinite(fallbackSz) ? fallbackSz / 2 : void 0) ?? 10;
-      const kern = rElements.find((el) => el.name === "w:kern")?.attributes["w:val"];
-      const fontFamilyCss = _SuperConverter2.toCssFontFamily(typeface, this.convertedXml);
-      return { fontSizePt, kern, typeface, panose, fontFamilyCss };
-    }
+    const styleRoot = styles?.elements?.[0];
+    const styleElements = styleRoot?.elements || [];
+    if (!styleElements.length) return {};
+    const defaults = styleElements.find((el) => el.name === "w:docDefaults");
+    const normalStyle = styleElements.find((el) => el.name === "w:style" && el.attributes?.["w:styleId"] === "Normal");
+    const defaultsState = {
+      typeface: void 0,
+      panose: void 0,
+      fontSizePt: void 0,
+      kern: void 0,
+      fallbackSzTwips: void 0
+    };
+    const docDefaultRun = defaults?.elements?.find((el) => el.name === "w:rPrDefault");
+    const docDefaultProps = docDefaultRun?.elements?.find((el) => el.name === "w:rPr") ?? docDefaultRun;
+    collectRunDefaultProperties(docDefaultProps, {
+      allowOverrideTypeface: true,
+      allowOverrideSize: true,
+      themeResolver: (theme) => this.getThemeInfo(theme),
+      state: defaultsState
+    });
+    const normalRunProps = normalStyle?.elements?.find((el) => el.name === "w:rPr") ?? null;
+    collectRunDefaultProperties(normalRunProps, {
+      allowOverrideTypeface: true,
+      allowOverrideSize: true,
+      themeResolver: (theme) => this.getThemeInfo(theme),
+      state: defaultsState
+    });
+    if (defaultsState.fontSizePt === void 0) {
+      if (Number.isFinite(defaultsState.fallbackSzTwips)) defaultsState.fontSizePt = defaultsState.fallbackSzTwips / 2;
+      else defaultsState.fontSizePt = DEFAULT_FONT_SIZE_PT;
+    }
+    const fontFamilyCss = defaultsState.typeface ? _SuperConverter2.toCssFontFamily(defaultsState.typeface, this.convertedXml) : void 0;
+    const result = {};
+    if (defaultsState.fontSizePt !== void 0) result.fontSizePt = defaultsState.fontSizePt;
+    if (defaultsState.kern !== void 0) result.kern = defaultsState.kern;
+    if (defaultsState.typeface) result.typeface = defaultsState.typeface;
+    if (defaultsState.panose) result.panose = defaultsState.panose;
+    if (fontFamilyCss) result.fontFamilyCss = fontFamilyCss;
+    return result;
   }
   getDocumentFonts() {
     const fontTable = this.convertedXml["word/fontTable.xml"];
@@ -33631,7 +33946,7 @@ function storeSuperdocVersion(docx) {
 function generateCustomXml() {
   return DEFAULT_CUSTOM_XML;
 }
-function generateSuperdocVersion(pid = 2, version2 = "0.20.2") {
+function generateSuperdocVersion(pid = 2, version2 = "0.21.1") {
   return {
     type: "element",
     name: "property",
@@ -36069,14 +36384,19 @@ class DocxZipper {
   /**
    * Update [Content_Types].xml with extensions of new Image annotations
    */
-  async updateContentTypes(docx, media, fromJson) {
+  async updateContentTypes(docx, media, fromJson, updatedDocs = {}) {
+    const additionalPartNames = Object.keys(updatedDocs || {});
     const newMediaTypes = Object.keys(media).map((name) => {
       return this.getFileExtension(name);
     }).filter(Boolean);
     const contentTypesPath = "[Content_Types].xml";
     let contentTypesXml;
     if (fromJson) {
-      contentTypesXml = docx.files.find((file) => file.name === contentTypesPath)?.content || "";
+      if (Array.isArray(docx.files)) {
+        contentTypesXml = docx.files.find((file) => file.name === contentTypesPath)?.content || "";
+      } else {
+        contentTypesXml = docx.files?.[contentTypesPath] || "";
+      }
     } else contentTypesXml = await docx.file(contentTypesPath).async("string");
     let typesString = "";
     const defaultMediaTypes = getContentTypesFromXml(contentTypesXml);
@@ -36102,24 +36422,39 @@ class DocxZipper {
     const hasCommentsExtensible = types2.elements?.some(
       (el) => el.name === "Override" && el.attributes.PartName === "/word/commentsExtensible.xml"
     );
-    if (docx.files["word/comments.xml"]) {
+    const hasFile = (filename) => {
+      if (!docx?.files) return false;
+      if (!fromJson) return Boolean(docx.files[filename]);
+      if (Array.isArray(docx.files)) return docx.files.some((file) => file.name === filename);
+      return Boolean(docx.files[filename]);
+    };
+    if (hasFile("word/comments.xml")) {
       const commentsDef = `<Override PartName="/word/comments.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml" />`;
       if (!hasComments) typesString += commentsDef;
     }
-    if (docx.files["word/commentsExtended.xml"]) {
+    if (hasFile("word/commentsExtended.xml")) {
       const commentsExtendedDef = `<Override PartName="/word/commentsExtended.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml" />`;
       if (!hasCommentsExtended) typesString += commentsExtendedDef;
     }
-    if (docx.files["word/commentsIds.xml"]) {
+    if (hasFile("word/commentsIds.xml")) {
       const commentsIdsDef = `<Override PartName="/word/commentsIds.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.commentsIds+xml" />`;
       if (!hasCommentsIds) typesString += commentsIdsDef;
     }
-    if (docx.files["word/commentsExtensible.xml"]) {
+    if (hasFile("word/commentsExtensible.xml")) {
       const commentsExtendedDef = `<Override PartName="/word/commentsExtensible.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtensible+xml" />`;
       if (!hasCommentsExtensible) typesString += commentsExtendedDef;
     }
-    Object.keys(docx.files).forEach((name) => {
-      if (name.includes(".rels") || !name.includes("header") && !name.includes("footer")) return;
+    const partNames = new Set(additionalPartNames);
+    if (docx?.files) {
+      if (fromJson && Array.isArray(docx.files)) {
+        docx.files.forEach((file) => partNames.add(file.name));
+      } else {
+        Object.keys(docx.files).forEach((key2) => partNames.add(key2));
+      }
+    }
+    partNames.forEach((name) => {
+      if (name.includes(".rels")) return;
+      if (!name.includes("header") && !name.includes("footer")) return;
       const hasExtensible = types2.elements?.some(
         (el) => el.name === "Override" && el.attributes.PartName === `/${name}`
       );
@@ -36130,7 +36465,48 @@ class DocxZipper {
       }
     });
     const beginningString = '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">';
-    const updatedContentTypesXml = contentTypesXml.replace(beginningString, `${beginningString}${typesString}`);
+    let updatedContentTypesXml = contentTypesXml.replace(beginningString, `${beginningString}${typesString}`);
+    let relationshipsXml = updatedDocs["word/_rels/document.xml.rels"];
+    if (!relationshipsXml) {
+      if (fromJson) {
+        if (Array.isArray(docx.files)) {
+          relationshipsXml = docx.files.find((file) => file.name === "word/_rels/document.xml.rels")?.content;
+        } else {
+          relationshipsXml = docx.files?.["word/_rels/document.xml.rels"];
+        }
+      } else {
+        relationshipsXml = await docx.file("word/_rels/document.xml.rels")?.async("string");
+      }
+    }
+    if (relationshipsXml) {
+      try {
+        const relJson = xmljs.xml2js(relationshipsXml, { compact: false });
+        const relationships = relJson.elements?.find((el) => el.name === "Relationships");
+        relationships?.elements?.forEach((rel) => {
+          const type2 = rel.attributes?.Type;
+          const target = rel.attributes?.Target;
+          if (!type2 || !target) return;
+          const isHeader = type2.includes("/header");
+          const isFooter = type2.includes("/footer");
+          if (!isHeader && !isFooter) return;
+          let sanitizedTarget = target.replace(/^\.\//, "");
+          if (sanitizedTarget.startsWith("../")) sanitizedTarget = sanitizedTarget.slice(3);
+          if (sanitizedTarget.startsWith("/")) sanitizedTarget = sanitizedTarget.slice(1);
+          const partName = sanitizedTarget.startsWith("word/") ? sanitizedTarget : `word/${sanitizedTarget}`;
+          partNames.add(partName);
+        });
+      } catch (error) {
+        console.warn("Failed to parse document relationships while updating content types", error);
+      }
+    }
+    partNames.forEach((name) => {
+      if (name.includes(".rels")) return;
+      if (!name.includes("header") && !name.includes("footer")) return;
+      if (updatedContentTypesXml.includes(`PartName="/${name}"`)) return;
+      const type2 = name.includes("header") ? "header" : "footer";
+      const extendedDef = `<Override PartName="/${name}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.${type2}+xml"/>`;
+      updatedContentTypesXml = updatedContentTypesXml.replace("</Types>", `${extendedDef}</Types>`);
+    });
     if (fromJson) return updatedContentTypesXml;
     docx.file(contentTypesPath, updatedContentTypesXml);
   }
@@ -36171,7 +36547,7 @@ class DocxZipper {
     for (const [fontName, fontUintArray] of Object.entries(fonts)) {
       zip.file(fontName, fontUintArray);
     }
-    await this.updateContentTypes(zip, media);
+    await this.updateContentTypes(zip, media, false, updatedDocs);
     return zip;
   }
   /**
@@ -36197,7 +36573,7 @@ class DocxZipper {
     Object.keys(media).forEach((path) => {
       unzippedOriginalDocx.file(path, media[path]);
     });
-    await this.updateContentTypes(unzippedOriginalDocx, media);
+    await this.updateContentTypes(unzippedOriginalDocx, media, false, updatedDocs);
     return unzippedOriginalDocx;
   }
 }
@@ -47855,9 +48231,11 @@ const toggleHeaderFooterEditMode = ({ editor, focusedSectionEditor, isEditMode,
     item.editor.view.dom.setAttribute("documentmode", documentMode);
   });
   if (isEditMode) {
-    const pm = document.querySelector(".ProseMirror");
-    pm.classList.add("header-footer-edit");
-    pm.setAttribute("aria-readonly", true);
+    const pm = editor.view?.dom || editor.options.element?.querySelector?.(".ProseMirror");
+    if (pm) {
+      pm.classList.add("header-footer-edit");
+      pm.setAttribute("aria-readonly", true);
+    }
   }
   if (focusedSectionEditor) {
     focusedSectionEditor.view.focus();
@@ -48887,6 +49265,7 @@ const generateTableIfNecessary = ({ tableNode, annotationValues, tr, state: stat
     const mappedRowStart = tr.mapping.map(absoluteRowStart);
     const rowEnd = mappedRowStart + rowNode.nodeSize;
     tr.replaceWith(mappedRowStart, rowEnd, Fragment.from(newRows));
+    tr.setMeta("tableGeneration", true);
   } catch (error) {
     console.error("Error during row generation:", error);
     throw error;
@@ -49291,7 +49670,7 @@ function findFieldAnnotationsBetween(from2, to, doc2) {
 }
 function findRemovedFieldAnnotations(tr) {
   let removedNodes = [];
-  if (!tr.steps.length || tr.meta && !Object.keys(tr.meta).every((meta) => ["inputType", "uiEvent", "paste"].includes(meta)) || ["historyUndo", "historyRedo"].includes(tr.getMeta("inputType")) || ["drop"].includes(tr.getMeta("uiEvent")) || tr.getMeta("fieldAnnotationUpdate") === true) {
+  if (!tr.steps.length || tr.meta && !Object.keys(tr.meta).every((meta) => ["inputType", "uiEvent", "paste"].includes(meta)) || ["historyUndo", "historyRedo"].includes(tr.getMeta("inputType")) || ["drop"].includes(tr.getMeta("uiEvent")) || tr.getMeta("fieldAnnotationUpdate") === true || tr.getMeta("tableGeneration") === true) {
     return removedNodes;
   }
   const hasDeletion = transactionDeletedAnything(tr);
@@ -50469,7 +50848,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
   setDocumentMode(documentMode) {
     let cleanedMode = documentMode?.toLowerCase() || "editing";
     if (!this.extensionService || !this.state) return;
-    const pm = document.querySelector(".ProseMirror");
+    const pm = this.view?.dom || this.options.element?.querySelector?.(".ProseMirror");
     if (this.options.role === "viewer") cleanedMode = "viewing";
     if (this.options.role === "suggester" && cleanedMode === "editing") cleanedMode = "suggesting";
     if (cleanedMode === "viewing") {
@@ -50699,6 +51078,8 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
     element.style.isolation = "isolate";
     proseMirror.style.outline = "none";
     proseMirror.style.border = "none";
+    element.style.backgroundColor = "#fff";
+    proseMirror.style.backgroundColor = "#fff";
     const { typeface, fontSizePt, fontFamilyCss } = this.converter.getDocumentDefaultStyles() ?? {};
     const resolvedFontFamily = fontFamilyCss || typeface;
     if (resolvedFontFamily) {
@@ -50955,7 +51336,8 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
             files: this.options.content
           },
           media,
-          true
+          true,
+          updatedDocs
         );
         return updatedDocs;
       }
@@ -51021,7 +51403,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
    * @returns {Object | void} Migration results
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "0.20.2");
+    console.debug("[checkVersionMigrations] Current editor version", "0.21.1");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -51441,9 +51823,11 @@ createView_fn = function(element) {
           isEditMode: false,
           documentMode: this.options.documentMode
         });
-        const pm = document.querySelector(".ProseMirror");
-        pm.classList.remove("header-footer-edit");
-        pm.setAttribute("aria-readonly", false);
+        const pm = this.view?.dom || this.options.element?.querySelector?.(".ProseMirror");
+        if (pm) {
+          pm.classList.remove("header-footer-edit");
+          pm.setAttribute("aria-readonly", false);
+        }
       }
       setWordSelection(view, pos);
     }
@@ -53498,6 +53882,30 @@ const intToJapaneseCounting = (num) => {
   }
   return result;
 };
+const isKeyboardInvocation = (event) => {
+  return event.type === "contextmenu" && typeof event.detail === "number" && event.detail === 0 && (event.button === 0 || event.button === void 0) && event.clientX === 0 && event.clientY === 0;
+};
+const prefersNativeMenu = (event) => {
+  if (!event) return false;
+  if (event.ctrlKey || event.metaKey) {
+    return true;
+  }
+  return isKeyboardInvocation(event);
+};
+const shouldAllowNativeContextMenu = (event) => {
+  return prefersNativeMenu(event);
+};
+const shouldBypassContextMenu = shouldAllowNativeContextMenu;
+const DEFAULT_SELECTION_STATE = Object.freeze({
+  focused: false,
+  preservedSelection: null,
+  showVisualSelection: false,
+  skipFocusReset: false
+});
+const normalizeSelectionState = (state2 = {}) => ({
+  ...DEFAULT_SELECTION_STATE,
+  ...state2
+});
 const CustomSelectionPluginKey = new PluginKey("CustomSelection");
 const handleClickOutside = (event, editor) => {
   const editorElem = editor?.options?.element;
@@ -53535,11 +53943,7 @@ const CustomSelection = Extension.create({
     const customSelectionPlugin = new Plugin({
       key: CustomSelectionPluginKey,
       state: {
-        init: () => ({
-          focused: false,
-          preservedSelection: null,
-          showVisualSelection: false
-        }),
+        init: () => ({ ...DEFAULT_SELECTION_STATE }),
         apply: (tr, value) => {
           const meta = getFocusMeta(tr);
           if (meta !== void 0) {
@@ -53560,6 +53964,9 @@ const CustomSelection = Extension.create({
       props: {
         handleDOMEvents: {
           contextmenu: (view, event) => {
+            if (shouldAllowNativeContextMenu(event)) {
+              return false;
+            }
             event.preventDefault();
             const { selection } = view.state;
             if (!selection.empty) {
@@ -53567,7 +53974,8 @@ const CustomSelection = Extension.create({
                 setFocusMeta(view.state.tr, {
                   focused: true,
                   preservedSelection: selection,
-                  showVisualSelection: true
+                  showVisualSelection: true,
+                  skipFocusReset: true
                 })
               );
             }
@@ -53578,6 +53986,9 @@ const CustomSelection = Extension.create({
           },
           mousedown: (view, event) => {
             if (event.button === 2) {
+              if (shouldAllowNativeContextMenu(event)) {
+                return false;
+              }
               event.preventDefault();
               const { selection: selection2 } = view.state;
               if (!selection2.empty) {
@@ -53585,7 +53996,8 @@ const CustomSelection = Extension.create({
                   setFocusMeta(view.state.tr, {
                     focused: true,
                     preservedSelection: selection2,
-                    showVisualSelection: true
+                    showVisualSelection: true,
+                    skipFocusReset: true
                   })
                 );
                 this.editor.setOptions({
@@ -53608,7 +54020,8 @@ const CustomSelection = Extension.create({
                 setFocusMeta(view.state.tr, {
                   focused: true,
                   preservedSelection: selection,
-                  showVisualSelection: true
+                  showVisualSelection: true,
+                  skipFocusReset: false
                 })
               );
               this.editor.setOptions({
@@ -53626,7 +54039,8 @@ const CustomSelection = Extension.create({
                   setFocusMeta(view.state.tr, {
                     focused: true,
                     preservedSelection: selection,
-                    showVisualSelection: true
+                    showVisualSelection: true,
+                    skipFocusReset: false
                   })
                 );
               }
@@ -53637,7 +54051,8 @@ const CustomSelection = Extension.create({
                 setFocusMeta(view.state.tr, {
                   focused: false,
                   preservedSelection: null,
-                  showVisualSelection: false
+                  showVisualSelection: false,
+                  skipFocusReset: false
                 })
               );
               if (!selection.empty && !this.editor.options.element?.contains(target)) {
@@ -53654,12 +54069,20 @@ const CustomSelection = Extension.create({
             const isElement2 = target instanceof Element;
             const isToolbarBtn = isElement2 && isToolbarButton(target);
             const isToolbarInp = isElement2 && isToolbarInput(target);
+            const focusState = getFocusState(view.state);
+            if (focusState?.skipFocusReset) {
+              view.dispatch(
+                setFocusMeta(view.state.tr, normalizeSelectionState({ ...focusState, skipFocusReset: false }))
+              );
+              return false;
+            }
             if (!isToolbarBtn && !isToolbarInp) {
               view.dispatch(
                 setFocusMeta(view.state.tr, {
                   focused: false,
                   preservedSelection: null,
-                  showVisualSelection: false
+                  showVisualSelection: false,
+                  skipFocusReset: false
                 })
               );
             }
@@ -53670,12 +54093,16 @@ const CustomSelection = Extension.create({
             const isToolbarBtn = isElement2 && isToolbarButton(target);
             const isToolbarInp = isElement2 && isToolbarInput(target);
             const state2 = getFocusState(view.state);
+            if (state2?.skipFocusReset) {
+              return false;
+            }
             if (isToolbarBtn || isToolbarInp) {
               view.dispatch(
                 setFocusMeta(view.state.tr, {
                   focused: true,
                   preservedSelection: state2.preservedSelection || view.state.selection,
-                  showVisualSelection: true
+                  showVisualSelection: true,
+                  skipFocusReset: false
                 })
               );
             } else {
@@ -53683,7 +54110,8 @@ const CustomSelection = Extension.create({
                 setFocusMeta(view.state.tr, {
                   focused: false,
                   preservedSelection: null,
-                  showVisualSelection: false
+                  showVisualSelection: false,
+                  skipFocusReset: false
                 })
               );
             }
@@ -69458,7 +69886,8 @@ const nodeResizer = (nodeNames = ["image"], editor) => {
           const prevSelection = prevState.selection;
           if (selection.from !== prevSelection.from || selection.to !== prevSelection.to) {
             setTimeout(() => {
-              const selectedResizableWrapper = document.querySelector(".sd-editor-resizable-wrapper");
+              const searchRoot = editorView?.dom;
+              const selectedResizableWrapper = searchRoot?.querySelector(".sd-editor-resizable-wrapper");
               if (selectedResizableWrapper) {
                 showResizeHandles(view2, selectedResizableWrapper);
               } else {
@@ -82994,7 +83423,7 @@ class SuperToolbar extends EventEmitter2 {
         if (!argument) return;
         item.onActivate({ zoom: argument });
         this.emit("superdoc-command", { item, argument });
-        const layers = document.querySelector(this.superdoc.config.selector)?.querySelector(".layers");
+        const layers = this.superdoc.element?.querySelector(".layers");
         if (!layers) return;
         const isMobileDevice = typeof screen.orientation !== "undefined";
         const isSmallScreen = window.matchMedia("(max-width: 834px)").matches;
@@ -83569,6 +83998,115 @@ runCommandWithArgumentOnly_fn = function({ item, argument, noArgumentCallback =
     this.updateToolbarState();
   }
 };
+const onMarginClickCursorChange = (event, editor) => {
+  const y2 = event.clientY;
+  const x = event.clientX;
+  const { view } = editor;
+  const editorRect = view.dom.getBoundingClientRect();
+  let coords = {
+    left: 0,
+    top: y2
+  };
+  let isRightMargin = false;
+  if (x > editorRect.right) {
+    coords.left = editorRect.left + editorRect.width - 1;
+    isRightMargin = true;
+  } else if (x < editorRect.left) {
+    coords.left = editorRect.left;
+  }
+  const pos = view.posAtCoords(coords)?.pos;
+  if (pos) {
+    let cursorPos = pos;
+    if (isRightMargin) {
+      const $pos = view.state.doc.resolve(pos);
+      const charOffset = $pos.textOffset;
+      const node = view.state.doc.nodeAt(pos);
+      const text = node?.text;
+      const charAtPos = text?.charAt(charOffset);
+      cursorPos = node?.isText && charAtPos !== " " ? pos - 1 : pos;
+    }
+    const transaction = view.state.tr.setSelection(TextSelection$1.create(view.state.doc, cursorPos));
+    view.dispatch(transaction);
+    view.focus();
+  }
+};
+const checkNodeSpecificClicks = (editor, event, popoverControls) => {
+  if (!editor) return;
+  if (selectionHasNodeOrMark(editor.view.state, "link", { requireEnds: true })) {
+    popoverControls.component = LinkInput;
+    popoverControls.position = {
+      left: `${event.clientX - editor.element.getBoundingClientRect().left}px`,
+      top: `${event.clientY - editor.element.getBoundingClientRect().top + 15}px`
+    };
+    popoverControls.props = {
+      showInput: true
+    };
+    popoverControls.visible = true;
+  }
+};
+function selectionHasNodeOrMark(state2, name, options = {}) {
+  const { requireEnds = false } = options;
+  const $from = state2.selection.$from;
+  const $to = state2.selection.$to;
+  if (requireEnds) {
+    for (let d2 = $from.depth; d2 > 0; d2--) {
+      if ($from.node(d2).type.name === name) {
+        return true;
+      }
+    }
+    for (let d2 = $to.depth; d2 > 0; d2--) {
+      if ($to.node(d2).type.name === name) {
+        return true;
+      }
+    }
+  } else {
+    for (let d2 = $from.depth; d2 > 0; d2--) {
+      if ($from.node(d2).type.name === name) {
+        return true;
+      }
+    }
+  }
+  const markType = state2.schema.marks[name];
+  if (markType) {
+    const { from: from2, to, empty: empty2 } = state2.selection;
+    if (requireEnds) {
+      const fromMarks = markType.isInSet($from.marks());
+      const toMarks = markType.isInSet($to.marks());
+      if (fromMarks || toMarks) {
+        return true;
+      }
+      if (empty2 && markType.isInSet(state2.storedMarks || $from.marks())) {
+        return true;
+      }
+    } else {
+      if (empty2) {
+        if (markType.isInSet(state2.storedMarks || $from.marks())) {
+          return true;
+        }
+      } else {
+        let hasMark = false;
+        state2.doc.nodesBetween(from2, to, (node) => {
+          if (markType.isInSet(node.marks)) {
+            hasMark = true;
+            return false;
+          }
+        });
+        if (hasMark) return true;
+      }
+    }
+  }
+  return false;
+}
+function moveCursorToMouseEvent(event, editor) {
+  const { view } = editor;
+  const coords = { left: event.clientX, top: event.clientY };
+  const pos = view.posAtCoords(coords)?.pos;
+  if (typeof pos === "number") {
+    const tr = view.state.tr.setSelection(TextSelection$1.create(view.state.doc, pos));
+    view.dispatch(tr);
+    view.focus();
+  }
+}
 const ICONS = {
   addRowBefore: plusIconSvg,
   addRowAfter: plusIconSvg,
@@ -83768,6 +84306,30 @@ const getPropsByItemId = (itemId, props) => {
       return baseProps;
   }
 };
+function normalizeClipboardContent(rawClipboardContent) {
+  if (!rawClipboardContent) {
+    return {
+      html: null,
+      text: null,
+      hasContent: false,
+      raw: null
+    };
+  }
+  const html = typeof rawClipboardContent.html === "string" ? rawClipboardContent.html : null;
+  const text = typeof rawClipboardContent.text === "string" ? rawClipboardContent.text : null;
+  const hasHtml = !!html && html.trim().length > 0;
+  const hasText = !!text && text.length > 0;
+  const isObject2 = typeof rawClipboardContent === "object" && rawClipboardContent !== null;
+  const fragmentSize = typeof rawClipboardContent.size === "number" ? rawClipboardContent.size : null;
+  const nestedSize = isObject2 && rawClipboardContent.content && typeof rawClipboardContent.content.size === "number" ? rawClipboardContent.content.size : null;
+  const hasFragmentContent = (fragmentSize ?? nestedSize ?? 0) > 0;
+  return {
+    html,
+    text,
+    hasContent: hasHtml || hasText || hasFragmentContent,
+    raw: rawClipboardContent
+  };
+}
 async function getEditorContext(editor, event) {
   const { view } = editor;
   const { state: state2 } = view;
@@ -83783,123 +84345,144 @@ async function getEditorContext(editor, event) {
     pos = from2;
     node = state2.doc.nodeAt(pos);
   }
-  const clipboardContent = await readFromClipboard(state2);
+  const rawClipboardContent = await readFromClipboard(state2);
+  const clipboardContent = normalizeClipboardContent(rawClipboardContent);
+  const structureFromResolvedPos = pos !== null ? getStructureFromResolvedPos(state2, pos) : null;
+  const isInTable2 = structureFromResolvedPos?.isInTable ?? selectionHasNodeOrMark(state2, "table", { requireEnds: true });
+  const isInList = structureFromResolvedPos?.isInList ?? (selectionHasNodeOrMark(state2, "bulletList", { requireEnds: false }) || selectionHasNodeOrMark(state2, "orderedList", { requireEnds: false }));
+  const isInSectionNode = structureFromResolvedPos?.isInSectionNode ?? selectionHasNodeOrMark(state2, "documentSection", { requireEnds: true });
+  const currentNodeType = node?.type?.name || null;
+  const activeMarks = [];
+  if (event && pos !== null) {
+    const $pos = state2.doc.resolve(pos);
+    if ($pos.marks && typeof $pos.marks === "function") {
+      $pos.marks().forEach((mark) => activeMarks.push(mark.type.name));
+    }
+    if (node && node.marks) {
+      node.marks.forEach((mark) => activeMarks.push(mark.type.name));
+    }
+  } else {
+    state2.storedMarks?.forEach((mark) => activeMarks.push(mark.type.name));
+    state2.selection.$head.marks().forEach((mark) => activeMarks.push(mark.type.name));
+  }
+  const isTrackedChange = activeMarks.includes("trackInsert") || activeMarks.includes("trackDelete");
+  let trackedChangeId = null;
+  if (isTrackedChange && event && pos !== null) {
+    const $pos = state2.doc.resolve(pos);
+    const marksAtPos = $pos.marks();
+    const trackedMark = marksAtPos.find((mark) => mark.type.name === "trackInsert" || mark.type.name === "trackDelete");
+    if (trackedMark) {
+      trackedChangeId = trackedMark.attrs.id;
+    }
+  }
+  const cursorCoords = pos ? view.coordsAtPos(pos) : null;
+  const cursorPosition = cursorCoords ? {
+    x: cursorCoords.left,
+    y: cursorCoords.top
+  } : null;
   return {
-    editor,
+    // Selection info
     selectedText,
+    hasSelection: !empty2,
+    selectionStart: from2,
+    selectionEnd: to,
+    // Document structure
+    isInTable: isInTable2,
+    isInList,
+    isInSectionNode,
+    currentNodeType,
+    activeMarks,
+    // Document state
+    isTrackedChange,
+    trackedChangeId,
+    documentMode: editor.options?.documentMode || "editing",
+    canUndo: computeCanUndo(editor, state2),
+    canRedo: computeCanRedo(editor, state2),
+    isEditable: editor.isEditable,
+    // Clipboard
+    clipboardContent,
+    // Position and trigger info
+    cursorPosition,
     pos,
     node,
     event,
-    clipboardContent
+    // Editor reference for advanced use cases
+    editor
   };
 }
-const onMarginClickCursorChange = (event, editor) => {
-  const y2 = event.clientY;
-  const x = event.clientX;
-  const { view } = editor;
-  const editorRect = view.dom.getBoundingClientRect();
-  let coords = {
-    left: 0,
-    top: y2
-  };
-  let isRightMargin = false;
-  if (x > editorRect.right) {
-    coords.left = editorRect.left + editorRect.width - 1;
-    isRightMargin = true;
-  } else if (x < editorRect.left) {
-    coords.left = editorRect.left;
+function computeCanUndo(editor, state2) {
+  if (typeof editor?.can === "function") {
+    try {
+      const can = editor.can();
+      if (can && typeof can.undo === "function") {
+        return !!can.undo();
+      }
+    } catch (error) {
+      console.warn("[SlashMenu] Unable to determine undo availability via editor.can():", error);
+    }
   }
-  const pos = view.posAtCoords(coords)?.pos;
-  if (pos) {
-    let cursorPos = pos;
-    if (isRightMargin) {
-      const $pos = view.state.doc.resolve(pos);
-      const charOffset = $pos.textOffset;
-      const node = view.state.doc.nodeAt(pos);
-      const text = node?.text;
-      const charAtPos = text?.charAt(charOffset);
-      cursorPos = node?.isText && charAtPos !== " " ? pos - 1 : pos;
+  if (isCollaborationEnabled(editor)) {
+    try {
+      const undoManager = yUndoPluginKey.getState(state2)?.undoManager;
+      return !!undoManager && undoManager.undoStack.length > 0;
+    } catch (error) {
+      console.warn("[SlashMenu] Unable to determine undo availability via y-prosemirror:", error);
     }
-    const transaction = view.state.tr.setSelection(TextSelection$1.create(view.state.doc, cursorPos));
-    view.dispatch(transaction);
-    view.focus();
   }
-};
-const checkNodeSpecificClicks = (editor, event, popoverControls) => {
-  if (!editor) return;
-  if (selectionHasNodeOrMark(editor.view.state, "link", { requireEnds: true })) {
-    popoverControls.component = LinkInput;
-    popoverControls.position = {
-      left: `${event.clientX - editor.element.getBoundingClientRect().left}px`,
-      top: `${event.clientY - editor.element.getBoundingClientRect().top + 15}px`
-    };
-    popoverControls.props = {
-      showInput: true
-    };
-    popoverControls.visible = true;
+  try {
+    return undoDepth(state2) > 0;
+  } catch (error) {
+    console.warn("[SlashMenu] Unable to determine undo availability via history plugin:", error);
+    return false;
   }
-};
-function selectionHasNodeOrMark(state2, name, options = {}) {
-  const { requireEnds = false } = options;
-  const $from = state2.selection.$from;
-  const $to = state2.selection.$to;
-  if (requireEnds) {
-    for (let d2 = $from.depth; d2 > 0; d2--) {
-      if ($from.node(d2).type.name === name) {
-        return true;
-      }
-    }
-    for (let d2 = $to.depth; d2 > 0; d2--) {
-      if ($to.node(d2).type.name === name) {
-        return true;
-      }
-    }
-  } else {
-    for (let d2 = $from.depth; d2 > 0; d2--) {
-      if ($from.node(d2).type.name === name) {
-        return true;
+}
+function computeCanRedo(editor, state2) {
+  if (typeof editor?.can === "function") {
+    try {
+      const can = editor.can();
+      if (can && typeof can.redo === "function") {
+        return !!can.redo();
       }
+    } catch (error) {
+      console.warn("[SlashMenu] Unable to determine redo availability via editor.can():", error);
     }
   }
-  const markType = state2.schema.marks[name];
-  if (markType) {
-    const { from: from2, to, empty: empty2 } = state2.selection;
-    if (requireEnds) {
-      const fromMarks = markType.isInSet($from.marks());
-      const toMarks = markType.isInSet($to.marks());
-      if (fromMarks || toMarks) {
-        return true;
-      }
-      if (empty2 && markType.isInSet(state2.storedMarks || $from.marks())) {
-        return true;
-      }
-    } else {
-      if (empty2) {
-        if (markType.isInSet(state2.storedMarks || $from.marks())) {
-          return true;
-        }
-      } else {
-        let hasMark = false;
-        state2.doc.nodesBetween(from2, to, (node) => {
-          if (markType.isInSet(node.marks)) {
-            hasMark = true;
-            return false;
-          }
-        });
-        if (hasMark) return true;
-      }
+  if (isCollaborationEnabled(editor)) {
+    try {
+      const undoManager = yUndoPluginKey.getState(state2)?.undoManager;
+      return !!undoManager && undoManager.redoStack.length > 0;
+    } catch (error) {
+      console.warn("[SlashMenu] Unable to determine redo availability via y-prosemirror:", error);
     }
   }
-  return false;
+  try {
+    return redoDepth(state2) > 0;
+  } catch (error) {
+    console.warn("[SlashMenu] Unable to determine redo availability via history plugin:", error);
+    return false;
+  }
 }
-function moveCursorToMouseEvent(event, editor) {
-  const { view } = editor;
-  const coords = { left: event.clientX, top: event.clientY };
-  const pos = view.posAtCoords(coords)?.pos;
-  if (typeof pos === "number") {
-    const tr = view.state.tr.setSelection(TextSelection$1.create(view.state.doc, pos));
-    view.dispatch(tr);
-    view.focus();
+function isCollaborationEnabled(editor) {
+  return Boolean(editor?.options?.collaborationProvider && editor?.options?.ydoc);
+}
+function getStructureFromResolvedPos(state2, pos) {
+  try {
+    const $pos = state2.doc.resolve(pos);
+    const ancestors = /* @__PURE__ */ new Set();
+    for (let depth = $pos.depth; depth > 0; depth--) {
+      ancestors.add($pos.node(depth).type.name);
+    }
+    const isInList = ancestors.has("bulletList") || ancestors.has("orderedList");
+    const isInTable2 = ancestors.has("table") || ancestors.has("tableRow") || ancestors.has("tableCell") || ancestors.has("tableHeader");
+    const isInSectionNode = ancestors.has("documentSection");
+    return {
+      isInTable: isInTable2,
+      isInList,
+      isInSectionNode
+    };
+  } catch (error) {
+    console.warn("[SlashMenu] Unable to resolve position for structural context:", error);
+    return null;
   }
 }
 const isModuleEnabled = (editorOptions, moduleName) => {
@@ -83913,8 +84496,52 @@ const isModuleEnabled = (editorOptions, moduleName) => {
       return true;
   }
 };
+function applyCustomMenuConfiguration(defaultSections, context) {
+  const { editor } = context;
+  const slashMenuConfig = editor.options?.slashMenuConfig;
+  if (!slashMenuConfig) {
+    return defaultSections;
+  }
+  let sections = [];
+  if (slashMenuConfig.includeDefaultItems !== false) {
+    sections = [...defaultSections];
+  }
+  if (slashMenuConfig.customItems && Array.isArray(slashMenuConfig.customItems)) {
+    sections = [...sections, ...slashMenuConfig.customItems];
+  }
+  if (typeof slashMenuConfig.menuProvider === "function") {
+    try {
+      sections = slashMenuConfig.menuProvider(context, sections) || sections;
+    } catch (error) {
+      console.warn("[SlashMenu] Error in custom menuProvider:", error);
+    }
+  }
+  return sections;
+}
+function filterCustomItems(sections, context) {
+  return sections.map((section) => {
+    const filteredItems = section.items.filter((item) => {
+      if (typeof item.showWhen === "function") {
+        try {
+          return item.showWhen(context);
+        } catch (error) {
+          console.warn(`[SlashMenu] Error in showWhen for item ${item.id}:`, error);
+          return false;
+        }
+      }
+      return true;
+    });
+    return {
+      ...section,
+      items: filteredItems
+    };
+  }).filter((section) => section.items.length > 0);
+}
 function getItems(context) {
   const { editor, selectedText, trigger: trigger2, clipboardContent } = context;
+  const clipboardHasContent = Boolean(
+    clipboardContent?.hasContent || clipboardContent?.html || clipboardContent?.text || typeof clipboardContent?.size === "number" && clipboardContent.size > 0 || clipboardContent && typeof clipboardContent?.content?.size === "number" && clipboardContent.content.size > 0 || clipboardContent?.raw && typeof clipboardContent.raw.size === "number" && clipboardContent.raw.size > 0 || clipboardContent?.raw && typeof clipboardContent.raw?.content?.size === "number" && clipboardContent.raw.content.size > 0
+  );
   const isInTable2 = selectionHasNodeOrMark(editor.view.state, "table", { requireEnds: true });
   const isInSectionNode = selectionHasNodeOrMark(editor.view.state, "documentSection", { requireEnds: true });
   const sections = [
@@ -84051,12 +84678,13 @@ function getItems(context) {
       ]
     }
   ];
-  const filteredSections = sections.map((section) => {
+  let allSections = applyCustomMenuConfiguration(sections, context);
+  const filteredSections = allSections.map((section) => {
     const filteredItems = section.items.filter((item) => {
       if (item.requiresModule && !isModuleEnabled(editor?.options, item.requiresModule)) return false;
       if (item.requiresSelection && !selectedText) return false;
       if (!item.allowedTriggers.includes(trigger2)) return false;
-      if (item.requiresClipboard && !clipboardContent) return false;
+      if (item.requiresClipboard && !clipboardHasContent) return false;
       if (item.requiresTableParent && !isInTable2 || item.id === "insert-table" && isInTable2) return false;
       if (item.requiresSectionParent && !isInSectionNode) return false;
       return true;
@@ -84066,7 +84694,8 @@ function getItems(context) {
       items: filteredItems
     };
   }).filter((section) => section.items.length > 0);
-  return filteredSections;
+  const finalSections = filterCustomItems(filteredSections, context);
+  return finalSections;
 }
 const _hoisted_1$3 = { class: "slash-menu-items" };
 const _hoisted_2$1 = {
@@ -84101,6 +84730,7 @@ const _sfc_main$4 = {
     const menuRef = vue.ref(null);
     const sections = vue.ref([]);
     const selectedId = vue.ref(null);
+    const currentContext = vue.ref(null);
     const handleEditorUpdate = () => {
       if (!props.editor?.isEditable && isOpen.value) {
         closeMenu({ restoreCursor: false });
@@ -84146,6 +84776,44 @@ const _sfc_main$4 = {
         selectedId.value = newItems[0].id;
       }
     });
+    const customItemRefs = /* @__PURE__ */ new Map();
+    const setCustomItemRef = (el, item) => {
+      if (el && item.render) {
+        customItemRefs.set(item.id, { element: el, item });
+        vue.nextTick(() => {
+          renderCustomItem(item.id);
+        });
+      }
+    };
+    const renderCustomItem = async (itemId) => {
+      const refData = customItemRefs.get(itemId);
+      if (!refData || refData.element.hasCustomContent) return;
+      const { element, item } = refData;
+      try {
+        if (!currentContext.value) {
+          currentContext.value = await getEditorContext(props.editor);
+        }
+        const context = currentContext.value;
+        const customElement = item.render(context);
+        if (customElement instanceof HTMLElement) {
+          element.innerHTML = "";
+          element.appendChild(customElement);
+          element.hasCustomContent = true;
+        }
+      } catch (error) {
+        console.warn(`[SlashMenu] Error rendering custom item ${itemId}:`, error);
+        element.innerHTML = `<span>${item.label || "Custom Item"}</span>`;
+        element.hasCustomContent = true;
+      }
+    };
+    const cleanupCustomItems = () => {
+      customItemRefs.forEach((refData) => {
+        if (refData.element) {
+          refData.element.hasCustomContent = false;
+        }
+      });
+      customItemRefs.clear();
+    };
     const handleGlobalKeyDown = (event) => {
       if (event.key === "Escape") {
         event.preventDefault();
@@ -84191,27 +84859,27 @@ const _sfc_main$4 = {
     };
     const handleRightClick = async (event) => {
       const readOnly = !props.editor?.isEditable;
-      const isHoldingCtrl = event.ctrlKey;
-      if (readOnly || isHoldingCtrl) {
+      if (readOnly || shouldBypassContextMenu(event)) {
         return;
       }
       event.preventDefault();
+      const context = await getEditorContext(props.editor, event);
+      currentContext.value = context;
+      sections.value = getItems({ ...context, trigger: "click" });
+      selectedId.value = flattenedItems.value[0]?.id || null;
+      searchQuery.value = "";
       props.editor.view.dispatch(
         props.editor.view.state.tr.setMeta(SlashMenuPluginKey, {
           type: "open",
-          pos: props.editor.view.state.selection.from,
+          pos: context?.pos ?? props.editor.view.state.selection.from,
           clientX: event.clientX,
           clientY: event.clientY
         })
       );
-      searchQuery.value = "";
-      const context = await getEditorContext(props.editor, event);
-      sections.value = getItems({ ...context, trigger: "click" });
-      selectedId.value = flattenedItems.value[0]?.id || null;
     };
     const executeCommand = async (item) => {
       if (props.editor) {
-        item.action ? await item.action(props.editor) : null;
+        item.action ? await item.action(props.editor, currentContext.value) : null;
         if (item.component) {
           menuRef.value;
           const componentProps = getPropsByItemId(item.id, props);
@@ -84229,7 +84897,7 @@ const _sfc_main$4 = {
     const closeMenu = (options = { restoreCursor: true }) => {
       if (props.editor?.view) {
         const pluginState = SlashMenuPluginKey.getState(props.editor.view.state);
-        const { anchorPos } = pluginState;
+        const anchorPos = pluginState?.anchorPos;
         props.editor.view.dispatch(
           props.editor.view.state.tr.setMeta(SlashMenuPluginKey, {
             type: "close"
@@ -84242,6 +84910,8 @@ const _sfc_main$4 = {
           props.editor.view.dispatch(tr);
           props.editor.view.focus();
         }
+        cleanupCustomItems();
+        currentContext.value = null;
         isOpen.value = false;
         searchQuery.value = "";
         sections.value = [];
@@ -84258,19 +84928,29 @@ const _sfc_main$4 = {
         isOpen.value = true;
         menuPosition.value = event.menuPosition;
         searchQuery.value = "";
-        const context = await getEditorContext(props.editor);
-        sections.value = getItems({ ...context, trigger: "slash" });
-        selectedId.value = flattenedItems.value[0]?.id || null;
+        if (!currentContext.value) {
+          const context = await getEditorContext(props.editor);
+          currentContext.value = context;
+          sections.value = getItems({ ...context, trigger: "slash" });
+          selectedId.value = flattenedItems.value[0]?.id || null;
+        } else if (sections.value.length === 0) {
+          const trigger2 = currentContext.value.event?.type === "contextmenu" ? "click" : "slash";
+          sections.value = getItems({ ...currentContext.value, trigger: trigger2 });
+          selectedId.value = flattenedItems.value[0]?.id || null;
+        }
       });
       props.editor.view.dom.addEventListener("contextmenu", handleRightClick);
       props.editor.on("slashMenu:close", () => {
+        cleanupCustomItems();
         isOpen.value = false;
         searchQuery.value = "";
+        currentContext.value = null;
       });
     });
     vue.onBeforeUnmount(() => {
       document.removeEventListener("keydown", handleGlobalKeyDown);
       document.removeEventListener("mousedown", handleGlobalOutsideClick);
+      cleanupCustomItems();
       if (props.editor) {
         try {
           props.editor.off("slashMenu:open");
@@ -84317,12 +84997,19 @@ const _sfc_main$4 = {
                   class: vue.normalizeClass(["slash-menu-item", { "is-selected": item.id === selectedId.value }]),
                   onClick: ($event) => executeCommand(item)
                 }, [
-                  item.icon ? (vue.openBlock(), vue.createElementBlock("span", {
+                  item.render ? (vue.openBlock(), vue.createElementBlock("div", {
                     key: 0,
-                    class: "slash-menu-item-icon",
-                    innerHTML: item.icon
-                  }, null, 8, _hoisted_4)) : vue.createCommentVNode("", true),
-                  vue.createBaseVNode("span", null, vue.toDisplayString(item.label), 1)
+                    ref_for: true,
+                    ref: (el) => setCustomItemRef(el, item),
+                    class: "slash-menu-custom-item"
+                  }, null, 512)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                    item.icon ? (vue.openBlock(), vue.createElementBlock("span", {
+                      key: 0,
+                      class: "slash-menu-item-icon",
+                      innerHTML: item.icon
+                    }, null, 8, _hoisted_4)) : vue.createCommentVNode("", true),
+                    vue.createBaseVNode("span", null, vue.toDisplayString(item.label), 1)
+                  ], 64))
                 ], 10, _hoisted_3$1);
               }), 128))
             ], 64);
@@ -85017,34 +85704,76 @@ const _sfc_main = {
   }
 };
 const SuperInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4d5cff52"]]);
+const additionalHandlers = Object.freeze({
+  "mc:AlternateContent": translator,
+  "w:b": translator$12,
+  "w:bidiVisual": translator$F,
+  "w:bookmarkEnd": translator$1,
+  "w:bookmarkStart": translator$2,
+  "w:bottom": translator$s,
+  "w:br": translator$16,
+  "w:cantSplit": translator$T,
+  "w:cnfStyle": translator$S,
+  "w:color": translator$_,
+  "w:divId": translator$R,
+  "w:drawing": translator$4,
+  "w:end": translator$q,
+  "w:gridAfter": translator$Q,
+  "w:gridBefore": translator$P,
+  "w:gridCol": translator$b,
+  "w:hidden": translator$O,
+  "w:highlight": translator$15,
+  "w:hyperlink": translator$7,
+  "w:i": translator$11,
+  "w:insideH": translator$o,
+  "w:insideV": translator$n,
+  "w:jc": translator$N,
+  "w:left": translator$m,
+  "w:p": translator$13,
+  "w:r": translator$U,
+  "w:rFonts": translator$Z,
+  "w:rPr": translator$V,
+  "w:rStyle": translator$Y,
+  "w:right": translator$k,
+  "w:sdt": translator$3,
+  "w:shd": translator$E,
+  "w:start": translator$i,
+  "w:strike": translator$$,
+  "w:sz": translator$X,
+  "w:szCs": translator$W,
+  "w:tab": translator$14,
+  "w:tbl": translator$9,
+  "w:tblBorders": translator$e,
+  "w:tblCaption": translator$D,
+  "w:tblCellMar": translator$d,
+  "w:tblCellSpacing": translator$M,
+  "w:tblDescription": translator$C,
+  "w:tblGrid": translator$a,
+  "w:tblHeader": translator$L,
+  "w:tblInd": translator$B,
+  "w:tblLayout": translator$A,
+  "w:tblLook": translator$z,
+  "w:tblOverlap": translator$y,
+  "w:tblPr": translator$c,
+  "w:tblStyle": translator$x,
+  "w:tblStyleColBandSize": translator$w,
+  "w:tblStyleRowBandSize": translator$v,
+  "w:tblW": translator$u,
+  "w:tblpPr": translator$t,
+  "w:tc": translator$8,
+  "w:top": translator$g,
+  "w:tr": translator$G,
+  "w:trHeight": translator$K,
+  "w:trPr": translator$H,
+  "w:u": translator$10,
+  "w:wAfter": translator$J,
+  "w:wBefore": translator$I,
+  "wp:anchor": translator$6,
+  "wp:inline": translator$5
+});
 const baseHandlers = {
   ...runPropertyTranslators,
-  "w:br": translator$15,
-  "w:cantSplit": translator$S,
-  "w:cnfStyle": translator$R,
-  "w:divId": translator$Q,
-  "w:gridAfter": translator$P,
-  "w:gridBefore": translator$O,
-  "w:hidden": translator$N,
-  "w:hyperlink": translator$6,
-  "w:jc": translator$M,
-  "w:p": translator$12,
-  "w:r": translator$T,
-  "w:rPr": translator$U,
-  "w:sdt": translator$2,
-  "w:tab": translator$13,
-  "w:tblCellSpacing": translator$L,
-  "w:tblHeader": translator$K,
-  "w:tc": translator$7,
-  "w:tr": translator$F,
-  "w:trHeight": translator$J,
-  "w:trPr": translator$G,
-  "w:wAfter": translator$I,
-  "w:wBefore": translator$H,
-  "wp:anchor": translator$5,
-  "wp:inline": translator$4,
-  "w:bookmarkStart": translator$1,
-  "w:bookmarkEnd": translator
+  ...additionalHandlers
 };
 const registeredHandlers = Object.freeze(baseHandlers);
 const Extensions = {