@harbour-enterprises/superdoc 0.20.0-next.1 → 0.20.0-next.11

package/dist/super-editor/chunks/{converter-Dq0PLazx.js → converter-DhWdHs1e.js}

@@ -14779,22 +14779,25 @@ async function readFromClipboard(state2) {
 function inchesToTwips(inches) {
   if (inches == null) return;
   if (typeof inches === "string") inches = parseFloat(inches);
-  return Math.round(inches * 1440);
+  return Math.round(Number(inches) * 1440);
 }
 function twipsToInches(twips) {
   if (twips == null) return;
-  if (typeof twips === "string") twips = parseInt(twips, 10);
-  return Math.round(twips / 1440 * 100) / 100;
+  const value = Number(twips);
+  if (Number.isNaN(value)) return;
+  return value / 1440;
 }
 function twipsToPixels(twips) {
   if (twips == null) return;
-  twips = twipsToInches(twips);
-  return Math.round(twips * 96);
+  const inches = twipsToInches(twips);
+  if (inches == null) return;
+  const pixels = inches * 96;
+  return Math.round(pixels * 1e3) / 1e3;
 }
 function pixelsToTwips(pixels) {
   if (pixels == null) return;
-  pixels = pixels / 96;
-  return inchesToTwips(pixels);
+  const inches = Number(pixels) / 96;
+  return inchesToTwips(inches);
 }
 function twipsToLines(twips) {
   if (twips == null) return;
@@ -14837,6 +14840,14 @@ function ptToTwips(pt) {
   if (pt == null) return;
   return pt * 20;
 }
+function rotToDegrees(rot) {
+  if (rot == null) return;
+  return rot / 6e4;
+}
+function degreesToRot(degrees) {
+  if (degrees == null) return;
+  return degrees * 6e4;
+}
 const getTextIndentExportValue = (indent) => {
   const [value, unit] = parseSizeUnit(indent);
   const functionsMap = {
@@ -16392,41 +16403,6 @@ const prepareCommentsXmlFilesForExport = ({ convertedXml, defs, commentsWithPara
     documentXml: updatedXml
   };
 };
-const getColStyleDeclaration = (minWidth, width) => {
-  if (width) {
-    return ["width", `${Math.max(width, minWidth)}px`];
-  }
-  return ["min-width", `${minWidth}px`];
-};
-const createColGroup = (node, cellMinWidth, overrideCol, overrideValue) => {
-  let totalWidth = 0;
-  let fixedWidth = true;
-  const cols = [];
-  const colsValues = [];
-  const row = node.firstChild;
-  if (!row) return {};
-  for (let i = 0, col = 0; i < row.childCount; i++) {
-    const { colspan, colwidth } = row.child(i).attrs;
-    for (let j2 = 0; j2 < colspan; j2++, col++) {
-      const hasWidth = overrideCol === col ? overrideValue : colwidth && colwidth[j2];
-      totalWidth += hasWidth || cellMinWidth;
-      if (!hasWidth) fixedWidth = false;
-      const [prop, value] = getColStyleDeclaration(cellMinWidth, hasWidth);
-      cols.push(["col", { style: `${prop}: ${value}` }]);
-      colsValues.push(parseInt(value, 10));
-    }
-  }
-  const tableWidth = fixedWidth ? `${totalWidth}px` : "";
-  const tableMinWidth = fixedWidth ? "" : `${totalWidth}px`;
-  const colgroup = ["colgroup", {}, ...cols];
-  const colgroupValues = [...colsValues];
-  return {
-    colgroup,
-    tableWidth,
-    tableMinWidth,
-    colgroupValues
-  };
-};
 const lower16 = 65535;
 const factor16 = Math.pow(2, 16);
 function makeRecover(index, offset) {
@@ -21371,7 +21347,7 @@ const isInTable = (state2) => {
 };
 function stripHtmlStyles(html) {
   if (!html) return "";
-  const parser = new DOMParser();
+  const parser = new window.DOMParser();
   const doc2 = parser.parseFromString(html, "text/html");
   const SUPPORTED_ATTRS = [
     "href",
@@ -21390,7 +21366,7 @@ function stripHtmlStyles(html) {
     "styleid"
   ];
   const cleanNode = (node) => {
-    if (node.nodeType !== Node.ELEMENT_NODE) return;
+    if (node.nodeType !== window.Node.ELEMENT_NODE) return;
     [...node.attributes].forEach((attr) => {
       const name = attr.name.toLowerCase();
       const shouldKeep = SUPPORTED_ATTRS.includes(name) || name.startsWith("data-");
@@ -22529,6 +22505,23 @@ function processContent({ content, type: type2, schema }) {
   }
   return doc2;
 }
+const defaultBooleans = ["required", "readonly", "disabled", "checked", "multiple", "autofocus"];
+function updateDOMAttributes(dom, attrs = {}, options = {}) {
+  const customBooleans = options.customBooleans || [];
+  const booleans = [...defaultBooleans, ...customBooleans];
+  Object.entries(attrs).forEach(([key, value]) => {
+    if (booleans.includes(key)) {
+      if (!value) dom.removeAttribute(key);
+      else dom.setAttribute(key, "");
+      return;
+    }
+    if (value != null) {
+      dom.setAttribute(key, value);
+    } else {
+      dom.removeAttribute(key);
+    }
+  });
+}
 const helpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   chainableEditorState,
@@ -22561,7 +22554,8 @@ const helpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   isNodeActive,
   isTextSelection,
   posToDOMRect,
-  processContent
+  processContent,
+  updateDOMAttributes
 }, Symbol.toStringTag, { value: "Module" }));
 const generateNewListDefinition = ({ numId, listType, level, start, text, fmt, editor }) => {
   if (typeof listType === "string") listType = editor.schema.nodes[listType];
@@ -24303,37 +24297,37 @@ const _NodeTranslator = class _NodeTranslator {
 /** @type {typeof TranslatorTypes} */
 __publicField(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$j = (attributes) => {
+const encode$A = (attributes) => {
   return attributes["w:type"];
 };
-const decode$j = (attrs) => {
+const decode$A = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
-const attrConfig$b = Object.freeze({
+const attrConfig$i = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$j,
-  decode: decode$j
+  encode: encode$A,
+  decode: decode$A
 });
-const encode$i = (attributes) => {
+const encode$z = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$i = (attrs) => {
+const decode$z = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
-const attrConfig$a = Object.freeze({
+const attrConfig$h = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$i,
-  decode: decode$i
+  encode: encode$z,
+  decode: decode$z
 });
-const validXmlAttributes$6 = [attrConfig$b, attrConfig$a];
-const XML_NODE_NAME$7 = "w:br";
-const SD_NODE_NAME$6 = "lineBreak";
-const encode$h = (_2, encodedAttrs) => {
+const validXmlAttributes$b = [attrConfig$i, attrConfig$h];
+const XML_NODE_NAME$h = "w:br";
+const SD_NODE_NAME$c = "lineBreak";
+const encode$y = (_2, encodedAttrs) => {
   const isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -24343,7 +24337,7 @@ const encode$h = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$h = (params, decodedAttrs) => {
+const decode$y = (params, decodedAttrs) => {
   const { node } = params;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24360,63 +24354,63 @@ const decode$h = (params, decodedAttrs) => {
   };
   return translated;
 };
-const config$7 = {
-  xmlName: XML_NODE_NAME$7,
-  sdNodeOrKeyName: SD_NODE_NAME$6,
+const config$f = {
+  xmlName: XML_NODE_NAME$h,
+  sdNodeOrKeyName: SD_NODE_NAME$c,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$h,
-  decode: decode$h,
-  attributes: validXmlAttributes$6
+  encode: encode$y,
+  decode: decode$y,
+  attributes: validXmlAttributes$b
 };
-const translator$j = NodeTranslator.from(config$7);
-const encode$g = (attributes) => {
+const translator$V = NodeTranslator.from(config$f);
+const encode$x = (attributes) => {
   return attributes["w:val"];
 };
-const decode$g = (attrs) => {
+const decode$x = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
-const attrConfig$9 = Object.freeze({
+const attrConfig$g = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$g,
-  decode: decode$g
+  encode: encode$x,
+  decode: decode$x
 });
-const encode$f = (attributes) => {
+const encode$w = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$f = (attrs) => {
+const decode$w = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
-const attrConfig$8 = Object.freeze({
+const attrConfig$f = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$f,
-  decode: decode$f
+  encode: encode$w,
+  decode: decode$w
 });
-const encode$e = (attributes) => {
+const encode$v = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$e = (attrs) => {
+const decode$v = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
-const attrConfig$7 = Object.freeze({
+const attrConfig$e = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$e,
-  decode: decode$e
+  encode: encode$v,
+  decode: decode$v
 });
-const validXmlAttributes$5 = [attrConfig$9, attrConfig$7, attrConfig$8];
-const XML_NODE_NAME$6 = "w:tab";
-const SD_NODE_NAME$5 = "tab";
-const encode$d = (_2, encodedAttrs = {}) => {
+const validXmlAttributes$a = [attrConfig$g, attrConfig$e, attrConfig$f];
+const XML_NODE_NAME$g = "w:tab";
+const SD_NODE_NAME$b = "tab";
+const encode$u = (_2, encodedAttrs = {}) => {
   const translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$d = (params, decodedAttrs = {}) => {
+const decode$u = (params, decodedAttrs = {}) => {
   const { node } = params || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24432,15 +24426,15 @@ const decode$d = (params, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$6 = {
-  xmlName: XML_NODE_NAME$6,
-  sdNodeOrKeyName: SD_NODE_NAME$5,
+const config$e = {
+  xmlName: XML_NODE_NAME$g,
+  sdNodeOrKeyName: SD_NODE_NAME$b,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$d,
-  decode: decode$d,
-  attributes: validXmlAttributes$5
+  encode: encode$u,
+  decode: decode$u,
+  attributes: validXmlAttributes$a
 };
-const translator$i = NodeTranslator.from(config$6);
+const translator$U = NodeTranslator.from(config$e);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -24704,13 +24698,15 @@ const getParagraphIndent = (node, docx, styleId = "") => {
   }
   return indent;
 };
-const getParagraphSpacing = (node, docx, styleId = "", marks = []) => {
+const getParagraphSpacing = (node, docx, styleId = "", marks = [], options = {}) => {
+  const { insideTable = false } = options;
   const spacing = {};
-  const { spacing: pDefaultSpacing = {} } = getDefaultParagraphStyle(docx, styleId);
+  const { spacing: pDefaultSpacing = {}, spacingSource } = getDefaultParagraphStyle(docx, styleId);
   let lineSpaceAfter, lineSpaceBefore, line, lineRuleStyle;
   const pPr = node.elements?.find((el) => el.name === "w:pPr");
   const inLineSpacingTag = pPr?.elements?.find((el) => el.name === "w:spacing");
   const inLineSpacing = inLineSpacingTag?.attributes || {};
+  const hasInlineSpacing = !!Object.keys(inLineSpacing).length;
   const textStyleMark = marks.find((el) => el.type === "textStyle");
   const fontSize = textStyleMark?.attrs?.fontSize;
   const lineSpacing = inLineSpacing?.["w:line"] || line || pDefaultSpacing?.["w:line"];
@@ -24732,6 +24728,12 @@ const getParagraphSpacing = (node, docx, styleId = "", marks = []) => {
   if (afterAutospacing === "1" && fontSize) {
     spacing.lineSpaceAfter += Math.round(parseInt(fontSize) * 0.5 * 96 / 72);
   }
+  if (insideTable && !hasInlineSpacing && spacingSource === "docDefault") {
+    const hasExplicitSpacing = Object.keys(inLineSpacing).length > 0;
+    if (!hasExplicitSpacing) {
+      return void 0;
+    }
+  }
   return spacing;
 };
 const getDefaultParagraphStyle = (docx, styleId = "") => {
@@ -24772,9 +24774,20 @@ const getDefaultParagraphStyle = (docx, styleId = "") => {
   const { attributes: pPrByIdIndentAttr } = pPrStyleIdIndentTag;
   const spacingRest = isNormalAsDefault ? pPrNormalSpacingAttr || pPrDefaultSpacingAttr : pPrDefaultSpacingAttr || pPrNormalSpacingAttr;
   const indentRest = isNormalAsDefault ? pPrNormalIndentAttr || pPrDefaultIndentAttr : pPrDefaultIndentAttr || pPrNormalIndentAttr;
+  let spacingToUse = pPrByIdSpacingAttr || spacingRest;
+  let spacingSource = "docDefault";
+  if (pPrByIdSpacingAttr) {
+    spacingSource = "style";
+  } else if (spacingRest === pPrNormalSpacingAttr && pPrNormalSpacingAttr) {
+    spacingSource = isNormalAsDefault ? "docDefault" : "normal";
+  } else if (spacingRest === pPrDefaultSpacingAttr && pPrDefaultSpacingAttr) {
+    spacingSource = "docDefault";
+  }
+  let indentToUse = pPrByIdIndentAttr || indentRest;
   return {
-    spacing: pPrByIdSpacingAttr || spacingRest,
-    indent: pPrByIdIndentAttr || indentRest,
+    spacing: spacingToUse,
+    spacingSource,
+    indent: indentToUse,
     justify: pPrByIdJcAttr
   };
 };
@@ -24949,7 +24962,13 @@ const handleParagraphNode$1 = (params) => {
   }
   if (docx) {
     const defaultStyleId = node.attributes?.["w:rsidRDefault"];
-    schemaNode.attrs["spacing"] = getParagraphSpacing(node, docx, styleId, schemaNode.attrs.marksAttrs);
+    const insideTable = (params.path || []).some((ancestor) => ancestor.name === "w:tc");
+    const spacing = getParagraphSpacing(node, docx, styleId, schemaNode.attrs.marksAttrs, {
+      insideTable
+    });
+    if (spacing) {
+      schemaNode.attrs["spacing"] = spacing;
+    }
     schemaNode.attrs["rsidRDefault"] = defaultStyleId;
   }
   if (docx) {
@@ -25010,102 +25029,102 @@ const handleParagraphNode$1 = (params) => {
   }
   return schemaNode;
 };
-const encode$c = (attributes) => {
+const encode$t = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$c = (attrs) => {
+const decode$t = (attrs) => {
   return attrs.rsidDel;
 };
-const attrConfig$6 = Object.freeze({
+const attrConfig$d = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$c,
-  decode: decode$c
+  encode: encode$t,
+  decode: decode$t
 });
-const encode$b = (attributes) => {
+const encode$s = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$b = (attrs) => {
+const decode$s = (attrs) => {
   return attrs.rsidP;
 };
-const attrConfig$5 = Object.freeze({
+const attrConfig$c = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$b,
-  decode: decode$b
+  encode: encode$s,
+  decode: decode$s
 });
-const encode$a = (attributes) => {
+const encode$r = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$a = (attrs) => {
+const decode$r = (attrs) => {
   return attrs.rsidR;
 };
-const attrConfig$4 = Object.freeze({
+const attrConfig$b = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$a,
-  decode: decode$a
+  encode: encode$r,
+  decode: decode$r
 });
-const encode$9 = (attributes) => {
+const encode$q = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$9 = (attrs) => {
+const decode$q = (attrs) => {
   return attrs.rsidRPr;
 };
-const attrConfig$3 = Object.freeze({
+const attrConfig$a = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$9,
-  decode: decode$9
+  encode: encode$q,
+  decode: decode$q
 });
-const encode$8 = (attributes) => {
+const encode$p = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$8 = (attrs) => {
+const decode$p = (attrs) => {
   return attrs.rsidRDefault;
 };
-const attrConfig$2 = Object.freeze({
+const attrConfig$9 = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$8,
-  decode: decode$8
+  encode: encode$p,
+  decode: decode$p
 });
-const encode$7 = (attributes) => {
+const encode$o = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$7 = (attrs) => {
+const decode$o = (attrs) => {
   return attrs.paraId;
 };
-const attrConfig$1 = Object.freeze({
+const attrConfig$8 = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$7,
-  decode: decode$7
+  encode: encode$o,
+  decode: decode$o
 });
-const encode$6 = (attributes) => {
+const encode$n = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$6 = (attrs) => {
+const decode$n = (attrs) => {
   return attrs.textId;
 };
-const attrConfig = Object.freeze({
+const attrConfig$7 = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$6,
-  decode: decode$6
+  encode: encode$n,
+  decode: decode$n
 });
-const validXmlAttributes$4 = [
-  attrConfig$1,
-  attrConfig,
-  attrConfig$4,
-  attrConfig$2,
-  attrConfig$5,
-  attrConfig$3,
-  attrConfig$6
+const validXmlAttributes$9 = [
+  attrConfig$8,
+  attrConfig$7,
+  attrConfig$b,
+  attrConfig$9,
+  attrConfig$c,
+  attrConfig$a,
+  attrConfig$d
 ];
-const XML_NODE_NAME$5 = "w:p";
-const SD_NODE_NAME$4 = "paragraph";
-const encode$5 = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$f = "w:p";
+const SD_NODE_NAME$a = "paragraph";
+const encode$m = (params, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25113,7 +25132,7 @@ const encode$5 = (params, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$5 = (params, decodedAttrs = {}) => {
+const decode$m = (params, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25121,15 +25140,15 @@ const decode$5 = (params, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$5 = {
-  xmlName: XML_NODE_NAME$5,
-  sdNodeOrKeyName: SD_NODE_NAME$4,
+const config$d = {
+  xmlName: XML_NODE_NAME$f,
+  sdNodeOrKeyName: SD_NODE_NAME$a,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$5,
-  decode: decode$5,
-  attributes: validXmlAttributes$4
+  encode: encode$m,
+  decode: decode$m,
+  attributes: validXmlAttributes$9
 };
-const translator$h = NodeTranslator.from(config$5);
+const translator$T = NodeTranslator.from(config$d);
 const generateV2HandlerEntity = (handlerName, translator2) => ({
   handlerName,
   handler: (params) => {
@@ -25157,7 +25176,7 @@ function createSingleAttrPropertyHandler(xmlName, sdName = null, attrName = "w:v
     },
     decode: ({ node }) => {
       const value = node.attrs?.[sdName] != null ? transformDecode(node.attrs[sdName]) : void 0;
-      return value != null ? { [attrName]: value } : void 0;
+      return value != null ? { name: xmlName, attributes: { [attrName]: value } } : void 0;
     }
   };
 }
@@ -25175,7 +25194,32 @@ function createMeasurementPropertyHandler(xmlName, sdName = null) {
     },
     decode: function({ node }) {
       const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs[sdName] || {} } });
-      return decodedAttrs["w:w"] != null ? decodedAttrs : void 0;
+      return decodedAttrs["w:w"] != null ? { attributes: decodedAttrs } : void 0;
+    }
+  };
+}
+function createBorderPropertyHandler(xmlName, sdName = null) {
+  if (!sdName) sdName = xmlName.split(":")[1];
+  return {
+    xmlName,
+    sdNodeOrKeyName: sdName,
+    attributes: [
+      createAttributeHandler("w:val"),
+      createAttributeHandler("w:color"),
+      createAttributeHandler("w:themeColor"),
+      createAttributeHandler("w:themeTint"),
+      createAttributeHandler("w:themeShade"),
+      createAttributeHandler("w:sz", "size", parseInteger, integerToString),
+      createAttributeHandler("w:space", null, parseInteger, integerToString),
+      createAttributeHandler("w:shadow", null, parseBoolean, booleanToString),
+      createAttributeHandler("w:frame", null, parseBoolean, booleanToString)
+    ],
+    encode: (params, encodedAttrs) => {
+      return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
+    },
+    decode: function({ node }, context) {
+      const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs[sdName] || {} } });
+      return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
     }
   };
 }
@@ -25218,15 +25262,17 @@ function decodeProperties(translatorsBySdName, properties) {
   Object.keys(properties).forEach((key) => {
     const translator2 = translatorsBySdName[key];
     if (translator2) {
-      const attributes = translator2.decode({ node: { attrs: { [key]: properties[key] } } });
-      if (attributes != null) {
-        elements.push({ name: translator2.xmlName, attributes });
+      const result = translator2.decode({ node: { attrs: { [key]: properties[key] } } });
+      if (result != null) {
+        result.name = translator2.xmlName;
+        elements.push(result);
       }
     }
   });
   return elements;
 }
-const parseBoolean = (value) => ["1", "true"].includes(value);
+const parseBoolean = (value) => value != null ? ["1", "true"].includes(value) : void 0;
+const booleanToString = (value) => value != null ? value ? "1" : "0" : void 0;
 const parseInteger = (value) => {
   if (value == null) return void 0;
   const intValue = parseInt(value, 10);
@@ -25236,13 +25282,53 @@ const integerToString = (value) => {
   const intValue = parseInteger(value);
   return intValue != void 0 ? String(intValue) : void 0;
 };
-const translator$g = NodeTranslator.from({
+function preProcessVerticalMergeCells(table, { editorSchema }) {
+  if (!table || !Array.isArray(table.content)) {
+    return table;
+  }
+  const rows = table.content;
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+    const row = rows[rowIndex];
+    if (!row) continue;
+    if (!Array.isArray(row.content)) {
+      row.content = [];
+    }
+    for (let cellIndex = 0; cellIndex < row.content.length; cellIndex++) {
+      const cell = row.content[cellIndex];
+      if (!cell) continue;
+      const attrs = cell.attrs || {};
+      if (!attrs.rowspan || attrs.rowspan <= 1) continue;
+      const maxRowspan = Math.min(attrs.rowspan, rows.length - rowIndex);
+      for (let offset = 1; offset < maxRowspan; offset++) {
+        const rowToChange = rows[rowIndex + offset];
+        if (!rowToChange) continue;
+        if (!Array.isArray(rowToChange.content)) {
+          rowToChange.content = [];
+        }
+        const existingCell = rowToChange.content[cellIndex];
+        if (existingCell?.attrs?.continueMerge) continue;
+        const mergedCell = {
+          type: cell.type,
+          content: [editorSchema.nodes.paragraph.createAndFill().toJSON()],
+          attrs: {
+            ...cell.attrs,
+            rowspan: null,
+            continueMerge: true
+          }
+        };
+        rowToChange.content.splice(cellIndex, 0, mergedCell);
+      }
+    }
+  }
+  return table;
+}
+const translator$S = NodeTranslator.from({
   xmlName: "w:cantSplit",
   sdNodeOrKeyName: "cantSplit",
   encode: ({ nodes }) => ["1", "true"].includes(nodes[0].attributes?.["w:val"] ?? "1"),
-  decode: ({ node }) => node.attrs?.cantSplit ? {} : void 0
+  decode: ({ node }) => node.attrs?.cantSplit ? { attributes: {} } : void 0
 });
-const translator$f = NodeTranslator.from({
+const translator$R = NodeTranslator.from({
   xmlName: "w:cnfStyle",
   sdNodeOrKeyName: "cnfStyle",
   attributes: [
@@ -25257,26 +25343,19 @@ const translator$f = NodeTranslator.from({
     "w:lastRowFirstColumn",
     "w:lastRowLastColumn",
     "w:oddHBand",
-    "w:oddVBand",
-    "w:val"
-  ].map((attr) => createAttributeHandler(attr)),
+    "w:oddVBand"
+  ].map((attr) => createAttributeHandler(attr, null, parseBoolean, booleanToString)).concat([createAttributeHandler("w:val")]),
   encode: (_2, encodedAttrs) => {
-    Object.keys(encodedAttrs).forEach((key) => {
-      encodedAttrs[key] = ["1", "true"].includes(encodedAttrs[key]);
-    });
     return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
   },
-  decode: ({ node }) => {
+  decode: function({ node }) {
     if (!node.attrs?.cnfStyle) return;
-    const cnfStyleAttrs = {};
-    Object.entries(node.attrs.cnfStyle).forEach(([key, value]) => {
-      cnfStyleAttrs[`w:${key}`] = value ? "1" : "0";
-    });
-    return Object.keys(cnfStyleAttrs).length > 0 ? cnfStyleAttrs : void 0;
+    const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs.cnfStyle || {} } });
+    return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
 });
-const translator$e = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
-const translator$d = NodeTranslator.from(
+const translator$Q = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
+const translator$P = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridAfter",
     null,
@@ -25285,7 +25364,7 @@ const translator$d = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$c = NodeTranslator.from(
+const translator$O = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridBefore",
     null,
@@ -25294,21 +25373,21 @@ const translator$c = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$b = NodeTranslator.from({
+const translator$N = NodeTranslator.from({
   xmlName: "w:hidden",
   sdNodeOrKeyName: "hidden",
   encode: ({ nodes }) => parseBoolean(nodes[0].attributes?.["w:val"] ?? "1"),
-  decode: ({ node }) => node.attrs.hidden ? {} : void 0
+  decode: ({ node }) => node.attrs.hidden ? { attributes: {} } : void 0
 });
-const translator$a = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc"));
-const translator$9 = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "cellSpacing"));
-const translator$8 = NodeTranslator.from({
+const translator$M = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc", "justification"));
+const translator$L = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
+const translator$K = NodeTranslator.from({
   xmlName: "w:tblHeader",
   sdNodeOrKeyName: "repeatHeader",
   encode: ({ nodes }) => parseBoolean(nodes[0].attributes?.["w:val"] ?? "1"),
-  decode: ({ node }) => node.attrs.repeatHeader ? {} : void 0
+  decode: ({ node }) => node.attrs.repeatHeader ? { attributes: {} } : void 0
 });
-const translator$7 = NodeTranslator.from({
+const translator$J = NodeTranslator.from({
   xmlName: "w:trHeight",
   sdNodeOrKeyName: "rowHeight",
   encode: ({ nodes }) => {
@@ -25332,14 +25411,14 @@ const translator$7 = NodeTranslator.from({
     if (node.attrs.rowHeight.rule) {
       heightAttrs["w:hRule"] = node.attrs.rowHeight.rule;
     }
-    return Object.keys(heightAttrs).length > 0 ? heightAttrs : void 0;
+    return Object.keys(heightAttrs).length > 0 ? { attributes: heightAttrs } : void 0;
   }
 });
-const translator$6 = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
-const translator$5 = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
-const XML_NODE_NAME$4 = "w:trPr";
-const SD_ATTR_KEY = "tableRowProperties";
-const encode$4 = (params) => {
+const translator$I = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
+const translator$H = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
+const XML_NODE_NAME$e = "w:trPr";
+const SD_ATTR_KEY$4 = "tableRowProperties";
+const encode$l = (params) => {
   const { nodes } = params;
   const node = nodes[0];
   let attributes = {
@@ -25349,18 +25428,18 @@ const encode$4 = (params) => {
   };
   attributes = {
     ...attributes,
-    ...encodeProperties(node, propertyTranslatorsByXmlName)
+    ...encodeProperties(node, propertyTranslatorsByXmlName$2)
   };
   return {
     type: NodeTranslator.translatorTypes.ATTRIBUTE,
-    xmlName: XML_NODE_NAME$4,
-    sdNodeOrKeyName: SD_ATTR_KEY,
+    xmlName: XML_NODE_NAME$e,
+    sdNodeOrKeyName: SD_ATTR_KEY$4,
     attributes
   };
 };
-const decode$4 = (params) => {
+const decode$l = (params) => {
   const { tableRowProperties = {} } = params.node.attrs || {};
-  const elements = decodeProperties(propertyTranslatorsBySdName, tableRowProperties);
+  const elements = decodeProperties(propertyTranslatorsBySdName$2, tableRowProperties);
   const newNode = {
     name: "w:trPr",
     type: "element",
@@ -25369,47 +25448,47 @@ const decode$4 = (params) => {
   };
   return newNode;
 };
-const propertyTranslators = [
-  translator$g,
-  translator$f,
-  translator$e,
-  translator$d,
-  translator$c,
-  translator$b,
-  translator$a,
-  translator$9,
-  translator$8,
-  translator$7,
-  translator$6,
-  translator$5
+const propertyTranslators$3 = [
+  translator$S,
+  translator$R,
+  translator$Q,
+  translator$P,
+  translator$O,
+  translator$N,
+  translator$M,
+  translator$L,
+  translator$K,
+  translator$J,
+  translator$I,
+  translator$H
 ];
-const propertyTranslatorsByXmlName = {};
-propertyTranslators.forEach((translator2) => {
-  propertyTranslatorsByXmlName[translator2.xmlName] = translator2;
+const propertyTranslatorsByXmlName$2 = {};
+propertyTranslators$3.forEach((translator2) => {
+  propertyTranslatorsByXmlName$2[translator2.xmlName] = translator2;
 });
-const propertyTranslatorsBySdName = {};
-propertyTranslators.forEach((translator2) => {
-  propertyTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
+const propertyTranslatorsBySdName$2 = {};
+propertyTranslators$3.forEach((translator2) => {
+  propertyTranslatorsBySdName$2[translator2.sdNodeOrKeyName] = translator2;
 });
-const config$4 = {
-  xmlName: XML_NODE_NAME$4,
-  sdNodeOrKeyName: SD_ATTR_KEY,
+const config$c = {
+  xmlName: XML_NODE_NAME$e,
+  sdNodeOrKeyName: SD_ATTR_KEY$4,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$4,
-  decode: decode$4
+  encode: encode$l,
+  decode: decode$l
 };
-const translator$4 = NodeTranslator.from(config$4);
-const XML_NODE_NAME$3 = "w:tr";
-const SD_NODE_NAME$3 = "tableRow";
-const validXmlAttributes$3 = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
+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(
   (xmlName) => createAttributeHandler(xmlName)
 );
-const encode$3 = (params, encodedAttrs) => {
-  const { row, table } = params.extraParams;
+const encode$k = (params, encodedAttrs) => {
+  const { row } = params.extraParams;
   let tableRowProperties = {};
   const tPr = row.elements.find((el) => el.name === "w:trPr");
   if (tPr) {
-    ({ attributes: tableRowProperties } = translator$4.encode({
+    ({ attributes: tableRowProperties } = translator$G.encode({
       ...params,
       nodes: [tPr]
     }));
@@ -25417,12 +25496,12 @@ const encode$3 = (params, encodedAttrs) => {
   encodedAttrs["tableRowProperties"] = Object.freeze(tableRowProperties);
   encodedAttrs["rowHeight"] = twipsToPixels(tableRowProperties["rowHeight"]?.value);
   encodedAttrs["cantSplit"] = tableRowProperties["cantSplit"];
-  const gridColumnWidths = _getGridColumnWidths(table);
+  const { columnWidths: gridColumnWidths } = params.extraParams;
   const cellNodes = row.elements.filter((el) => el.name === "w:tc");
   let currentColumnIndex = 0;
   const content = cellNodes?.map((n) => {
     let columnWidth = gridColumnWidths?.[currentColumnIndex] || null;
-    const result = translator$2.encode({
+    const result = translator$7.encode({
       ...params,
       extraParams: {
         ...params.extraParams,
@@ -25444,16 +25523,7 @@ const encode$3 = (params, encodedAttrs) => {
   };
   return newNode;
 };
-const _getGridColumnWidths = (tableNode) => {
-  const tblGrid = tableNode.elements.find((el) => el.name === "w:tblGrid");
-  if (!tblGrid) return [];
-  const columnWidths = tblGrid?.elements?.flatMap((el) => {
-    if (el.name !== "w:gridCol") return [];
-    return twipsToPixels(el.attributes["w:w"]);
-  }) || [];
-  return columnWidths;
-};
-const decode$3 = (params, decodedAttrs) => {
+const decode$k = (params, decodedAttrs) => {
   const { node } = params;
   const elements = translateChildNodes(params);
   if (node.attrs?.tableRowProperties) {
@@ -25465,7 +25535,7 @@ const decode$3 = (params, decodedAttrs) => {
       }
     }
     tableRowProperties["cantSplit"] = node.attrs["cantSplit"];
-    const trPr = translator$4.decode({
+    const trPr = translator$G.decode({
       ...params,
       node: { ...node, attrs: { ...node.attrs, tableRowProperties } }
     });
@@ -25477,98 +25547,549 @@ const decode$3 = (params, decodedAttrs) => {
     elements
   };
 };
-const config$3 = {
-  xmlName: XML_NODE_NAME$3,
-  sdNodeOrKeyName: SD_NODE_NAME$3,
+const config$b = {
+  xmlName: XML_NODE_NAME$d,
+  sdNodeOrKeyName: SD_NODE_NAME$9,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$3,
-  decode: decode$3,
-  attributes: validXmlAttributes$3
+  encode: encode$k,
+  decode: decode$k,
+  attributes: validXmlAttributes$8
+};
+const translator$F = NodeTranslator.from(config$b);
+const translator$E = 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({
+  xmlName: "w:shd",
+  sdNodeOrKeyName: "shading",
+  attributes: [
+    "w:color",
+    "w:fill",
+    "w:themeColor",
+    "w:themeFill",
+    "w:themeFillShade",
+    "w:themeFillTint",
+    "w:themeShade",
+    "w:themeTint",
+    "w:val"
+  ].map((attr) => createAttributeHandler(attr)),
+  encode: (params, encodedAttrs) => {
+    return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
+  },
+  decode: function({ node }, context) {
+    const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs.shading || {} } });
+    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({
+  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")]),
+  encode: (params, encodedAttrs) => {
+    return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
+  },
+  decode: function({ node }, context) {
+    const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs.tblLook || {} } });
+    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(
+  createSingleAttrPropertyHandler("w:tblStyleColBandSize", "tableStyleColBandSize")
+);
+const translator$u = NodeTranslator.from(
+  createSingleAttrPropertyHandler("w:tblStyleRowBandSize", "tableStyleRowBandSize")
+);
+const translator$t = NodeTranslator.from(createMeasurementPropertyHandler("w:tblW", "tableWidth"));
+const translator$s = 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))),
+  encode: (params, encodedAttrs) => {
+    return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
+  },
+  decode: function({ node }, context) {
+    const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs.floatingTableProperties || {} } });
+    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 SD_ATTR_KEY$3 = "borders";
+const encode$j = (params) => {
+  const { nodes } = params;
+  const node = nodes[0];
+  const attributes = encodeProperties(node, tblBordersTranslatorsByXmlName);
+  return Object.keys(attributes).length > 0 ? attributes : void 0;
 };
-const translator$3 = NodeTranslator.from(config$3);
-const handleAllTableNodes = (params) => {
+const decode$j = (params) => {
+  const { borders = {} } = params.node.attrs || {};
+  const elements = decodeProperties(tblBordersTranslatorsBySdName, borders);
+  const newNode = {
+    name: "w:tblBorders",
+    type: "element",
+    attributes: {},
+    elements
+  };
+  return newNode;
+};
+const propertyTranslators$2 = [
+  translator$r,
+  translator$p,
+  translator$n,
+  translator$m,
+  translator$l,
+  translator$j,
+  translator$h,
+  translator$f
+];
+const tblBordersTranslatorsByXmlName = {};
+const tblBordersTranslatorsBySdName = {};
+propertyTranslators$2.forEach((translator2) => {
+  tblBordersTranslatorsByXmlName[translator2.xmlName] = translator2;
+  tblBordersTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
+});
+const translator$d = NodeTranslator.from({
+  xmlName: XML_NODE_NAME$c,
+  sdNodeOrKeyName: SD_ATTR_KEY$3,
+  type: NodeTranslator.translatorTypes.NODE,
+  attributes: [],
+  encode: encode$j,
+  decode: decode$j
+});
+const XML_NODE_NAME$b = "w:tblCellMar";
+const SD_ATTR_KEY$2 = "cellMargins";
+const encode$i = (params) => {
   const { nodes } = params;
-  if (nodes.length === 0) {
-    return { nodes: [], consumed: 0 };
-  }
   const node = nodes[0];
-  switch (node.name) {
-    case "w:tbl":
-      return { nodes: [handleTableNode(node, params)], consumed: 1 };
-  }
-  return { nodes: [], consumed: 0 };
+  const attributes = encodeProperties(node, propertyTranslatorsByXmlName$1);
+  return Object.keys(attributes).length > 0 ? attributes : void 0;
 };
-const tableNodeHandlerEntity = {
-  handlerName: "tableNodeHandler",
-  handler: handleAllTableNodes
+const decode$i = (params) => {
+  const { cellMargins = {} } = params.node.attrs || {};
+  const elements = decodeProperties(propertyTranslatorsBySdName$1, cellMargins);
+  const newNode = {
+    name: XML_NODE_NAME$b,
+    type: "element",
+    attributes: {},
+    elements
+  };
+  return newNode;
 };
-function handleTableNode(node, params) {
-  const { docx, nodeListHandler } = params;
-  const tblPr = node.elements.find((el) => el.name === "w:tblPr");
-  const tableBordersElement = tblPr.elements.find((el) => el.name === "w:tblBorders");
-  const tableBorders = tableBordersElement?.elements || [];
-  const { borders, rowBorders } = processTableBorders(tableBorders);
-  const tblStyleTag = tblPr.elements.find((el) => el.name === "w:tblStyle");
-  const tableStyleId = tblStyleTag?.attributes["w:val"];
-  const attrs = { tableStyleId };
-  const tableIndent = tblPr?.elements.find((el) => el.name === "w:tblInd");
-  if (tableIndent) {
-    const { "w:w": width, "w:type": type2 } = tableIndent.attributes;
-    attrs["tableIndent"] = { width: twipsToPixels(width), type: type2 };
-  }
-  const tableLayout = tblPr?.elements.find((el) => el.name === "w:tblLayout");
-  if (tableLayout) {
-    const { "w:type": type2 } = tableLayout.attributes;
-    attrs["tableLayout"] = type2;
-  }
-  const referencedStyles = getReferencedTableStyles(tblStyleTag, docx);
-  const tblW = tblPr.elements.find((el) => el.name === "w:tblW");
-  if (tblW) {
-    attrs["tableWidth"] = {
-      width: twipsToPixels(tblW.attributes["w:w"]),
-      type: tblW.attributes["w:type"]
-    };
+const propertyTranslators$1 = [
+  translator$q,
+  translator$o,
+  translator$k,
+  translator$i,
+  translator$g,
+  translator$e
+];
+const propertyTranslatorsByXmlName$1 = {};
+const propertyTranslatorsBySdName$1 = {};
+propertyTranslators$1.forEach((translator2) => {
+  propertyTranslatorsByXmlName$1[translator2.xmlName] = translator2;
+  propertyTranslatorsBySdName$1[translator2.sdNodeOrKeyName] = translator2;
+});
+const translator$c = NodeTranslator.from({
+  xmlName: XML_NODE_NAME$b,
+  sdNodeOrKeyName: SD_ATTR_KEY$2,
+  type: NodeTranslator.translatorTypes.NODE,
+  attributes: [],
+  encode: encode$i,
+  decode: decode$i
+});
+const XML_NODE_NAME$a = "w:tblPr";
+const SD_ATTR_KEY$1 = "tableProperties";
+const encode$h = (params) => {
+  const { nodes } = params;
+  const node = nodes[0];
+  const attributes = encodeProperties(node, propertyTranslatorsByXmlName);
+  return {
+    xmlName: XML_NODE_NAME$a,
+    sdNodeOrKeyName: SD_ATTR_KEY$1,
+    attributes
+  };
+};
+const decode$h = (params) => {
+  const { tableProperties = {} } = params.node.attrs || {};
+  const elements = decodeProperties(propertyTranslatorsBySdName, tableProperties);
+  const newNode = {
+    name: "w:tblPr",
+    type: "element",
+    attributes: {},
+    elements
+  };
+  return newNode;
+};
+const propertyTranslators = [
+  translator$E,
+  translator$M,
+  translator$D,
+  translator$C,
+  translator$L,
+  translator$B,
+  translator$A,
+  translator$z,
+  translator$y,
+  translator$x,
+  translator$w,
+  translator$v,
+  translator$u,
+  translator$t,
+  translator$s,
+  translator$d,
+  translator$c
+];
+const propertyTranslatorsByXmlName = {};
+const propertyTranslatorsBySdName = {};
+propertyTranslators.forEach((translator2) => {
+  propertyTranslatorsByXmlName[translator2.xmlName] = translator2;
+  propertyTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
+});
+const config$a = {
+  xmlName: XML_NODE_NAME$a,
+  sdNodeOrKeyName: SD_ATTR_KEY$1,
+  encode: encode$h,
+  decode: decode$h
+};
+const translator$b = NodeTranslator.from(config$a);
+const translator$a = NodeTranslator.from(
+  createSingleAttrPropertyHandler("w:gridCol", "col", "w:w", parseInteger, integerToString)
+);
+const DEFAULT_COLUMN_WIDTH_PX = 100;
+const normalizeTwipWidth = (value) => {
+  if (value == null) return null;
+  const numericValue = typeof value === "string" ? parseInt(value, 10) : value;
+  if (!Number.isFinite(numericValue) || Number.isNaN(numericValue) || numericValue <= 0) {
+    return null;
   }
-  const tblCellSpacing = tblPr.elements.find((el) => el.name === "w:tblCellSpacing");
-  if (tblCellSpacing) {
-    attrs["tableCellSpacing"] = {
-      w: tblCellSpacing.attributes["w:w"],
-      type: tblCellSpacing.attributes["w:type"]
-    };
-    attrs["borderCollapse"] = "separate";
+  return numericValue;
+};
+const getSchemaDefaultColumnWidthPx = (params) => {
+  const defaultValue = params?.editor?.schema?.nodes?.tableCell?.spec?.attrs?.colwidth?.default;
+  if (Array.isArray(defaultValue)) {
+    const numericWidth = defaultValue.find((width) => typeof width === "number" && Number.isFinite(width) && width > 0);
+    if (numericWidth != null) return numericWidth;
+  } else if (typeof defaultValue === "number" && Number.isFinite(defaultValue) && defaultValue > 0) {
+    return defaultValue;
   }
-  const tblJustification = tblPr.elements.find((el) => el.name === "w:jc");
-  if (tblJustification?.attributes) {
-    attrs["justification"] = tblJustification.attributes["w:val"];
+  return DEFAULT_COLUMN_WIDTH_PX;
+};
+const getTableWidthPx = (params) => {
+  const explicitWidth = params?.node?.attrs?.tableWidth?.width;
+  if (typeof explicitWidth === "number" && explicitWidth > 0) return explicitWidth;
+  const tableWidth = params?.node?.attrs?.tableProperties?.tableWidth;
+  if (tableWidth?.value != null && typeof tableWidth.value === "number" && tableWidth.value > 0) {
+    const { value, type: type2 } = tableWidth;
+    if (!type2 || type2 === "auto" || type2 === "dxa") {
+      return twipsToPixels(value);
+    }
   }
-  const rows = node.elements.filter((el) => el.name === "w:tr");
-  const refStylesBorders = referencedStyles?.borders || {};
-  const refStylesRowBorders = referencedStyles?.rowBorders || {};
-  const borderData = Object.keys(borders)?.length ? Object.assign(refStylesBorders, borders) : refStylesBorders;
-  const borderRowData = Object.keys(rowBorders)?.length ? Object.assign(refStylesRowBorders, rowBorders) : refStylesRowBorders;
-  attrs["borders"] = borderData;
-  const content = [];
-  rows.forEach((row) => {
-    const result = translator$3.encode({
-      ...params,
-      nodes: [row],
-      extraParams: {
-        row,
-        table: node,
-        rowBorders: borderRowData,
-        styleTag: tblStyleTag
-      }
-    });
-    if (result.content?.length) content.push(result);
-  });
+  return null;
+};
+const resolveFallbackColumnWidthTwips = (params, totalColumns, cellMinWidthTwips) => {
+  const columnCount = Math.max(totalColumns, 1);
+  const defaultColumnWidthPx = getSchemaDefaultColumnWidthPx(params);
+  const tableWidthPx = getTableWidthPx(params);
+  const safeDefaultPx = Number.isFinite(defaultColumnWidthPx) && defaultColumnWidthPx > 0 ? defaultColumnWidthPx : DEFAULT_COLUMN_WIDTH_PX;
+  let fallbackWidthPx = safeDefaultPx;
+  if (typeof tableWidthPx === "number" && tableWidthPx > 0) {
+    fallbackWidthPx = tableWidthPx / columnCount;
+  }
+  const fallbackWidthTwips = pixelsToTwips(fallbackWidthPx);
+  if (!Number.isFinite(fallbackWidthTwips) || Number.isNaN(fallbackWidthTwips) || fallbackWidthTwips <= 0) {
+    const safeDefault = Math.max(pixelsToTwips(safeDefaultPx), cellMinWidthTwips);
+    return safeDefault;
+  }
+  return Math.max(fallbackWidthTwips, cellMinWidthTwips);
+};
+const XML_NODE_NAME$9 = "w:tblGrid";
+const SD_ATTR_KEY = "grid";
+const cellMinWidth = pixelsToTwips(10);
+const encode$g = (params) => {
+  const { nodes } = params;
+  const node = nodes[0];
+  const attributes = encodeProperties(node, { [translator$a.xmlName]: translator$a }, true);
   return {
-    type: "table",
-    content,
-    attrs
+    xmlName: XML_NODE_NAME$9,
+    sdNodeOrKeyName: SD_ATTR_KEY,
+    attributes
   };
-}
-function getReferencedTableStyles(tblStyleTag, docx) {
-  if (!tblStyleTag) return null;
+};
+const decode$g = (params) => {
+  const { grid: rawGrid } = params.node.attrs || {};
+  const grid = Array.isArray(rawGrid) ? rawGrid : [];
+  const { firstRow = {} } = params.extraParams || {};
+  const cellNodes = firstRow.content?.filter((n) => n.type === "tableCell") ?? [];
+  const columnCountFromCells = cellNodes.reduce((count, cell) => {
+    const spanCount = Math.max(1, cell?.attrs?.colspan ?? 1);
+    return count + spanCount;
+  }, 0);
+  const totalColumns = Math.max(columnCountFromCells, grid.length);
+  const fallbackColumnWidthTwips = resolveFallbackColumnWidthTwips(params, totalColumns, cellMinWidth);
+  const elements = [];
+  let columnIndex = 0;
+  const pushColumn = (widthTwips) => {
+    let numericWidth = typeof widthTwips === "string" ? parseInt(widthTwips, 10) : widthTwips;
+    if (numericWidth == null || Number.isNaN(numericWidth) || numericWidth <= 0) {
+      numericWidth = fallbackColumnWidthTwips;
+    }
+    numericWidth = Math.max(numericWidth, cellMinWidth);
+    const decoded = translator$a.decode({
+      node: { type: (
+        /** @type {string} */
+        translator$a.sdNodeOrKeyName
+      ), attrs: { col: numericWidth } }
+    });
+    if (decoded) elements.push(decoded);
+  };
+  cellNodes.forEach((cell) => {
+    const { colspan = 1, colwidth } = cell?.attrs || {};
+    const spanCount = Math.max(1, colspan);
+    for (let span = 0; span < spanCount; span++) {
+      const cellWidthPixels = Array.isArray(colwidth) ? colwidth[span] : void 0;
+      const colGridAttrs = grid?.[columnIndex] || {};
+      const gridWidthTwips = normalizeTwipWidth(colGridAttrs.col);
+      const gridWidthPixels = gridWidthTwips != null ? twipsToPixels(gridWidthTwips) : null;
+      let cellWidthTwips;
+      if (cellWidthPixels != null) {
+        if (gridWidthTwips != null && gridWidthPixels === cellWidthPixels) {
+          cellWidthTwips = gridWidthTwips;
+        } else {
+          cellWidthTwips = pixelsToTwips(cellWidthPixels);
+        }
+      } else if (gridWidthTwips != null) {
+        cellWidthTwips = gridWidthTwips;
+      } else {
+        cellWidthTwips = fallbackColumnWidthTwips;
+      }
+      pushColumn(cellWidthTwips);
+      columnIndex++;
+    }
+  });
+  while (columnIndex < grid.length) {
+    const gridWidthTwips = normalizeTwipWidth(grid[columnIndex]?.col);
+    pushColumn(gridWidthTwips);
+    columnIndex++;
+  }
+  const newNode = {
+    name: XML_NODE_NAME$9,
+    attributes: {},
+    elements
+  };
+  return newNode;
+};
+const config$9 = {
+  xmlName: XML_NODE_NAME$9,
+  sdNodeOrKeyName: SD_ATTR_KEY,
+  encode: encode$g,
+  decode: decode$g
+};
+const translator$9 = NodeTranslator.from(config$9);
+const XML_NODE_NAME$8 = "w:tbl";
+const SD_NODE_NAME$8 = "table";
+const encode$f = (params, encodedAttrs) => {
+  const { nodes } = params;
+  const node = nodes[0];
+  const tblPr = node.elements.find((el) => el.name === "w:tblPr");
+  if (tblPr) {
+    const encodedProperties = translator$b.encode({ ...params, nodes: [tblPr] });
+    encodedAttrs["tableProperties"] = encodedProperties?.attributes || {};
+  }
+  const tblGrid = node.elements.find((el) => el.name === "w:tblGrid");
+  if (tblGrid) {
+    encodedAttrs["grid"] = translator$9.encode({ ...params, 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 key;
+    let transform;
+    if (Array.isArray(prop)) {
+      [key, transform] = prop;
+    } else {
+      key = prop;
+      transform = (v2) => v2;
+    }
+    if (encodedAttrs.tableProperties && encodedAttrs.tableProperties[key]) {
+      encodedAttrs[key] = transform(encodedAttrs.tableProperties[key]);
+    }
+  });
+  if (encodedAttrs.tableCellSpacing) {
+    encodedAttrs["borderCollapse"] = "separate";
+  }
+  const { borders, rowBorders } = _processTableBorders(encodedAttrs.tableProperties?.borders || {});
+  const referencedStyles = _getReferencedTableStyles(encodedAttrs.tableStyleId, params);
+  if (referencedStyles?.cellMargins && !encodedAttrs.tableProperties?.cellMargins) {
+    encodedAttrs.tableProperties = {
+      ...encodedAttrs.tableProperties || {},
+      cellMargins: referencedStyles.cellMargins
+    };
+  }
+  const rows = node.elements.filter((el) => el.name === "w:tr");
+  const borderData = Object.assign({}, referencedStyles?.borders || {}, borders || {});
+  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));
+  const content = [];
+  rows.forEach((row) => {
+    const result = translator$F.encode({
+      ...params,
+      nodes: [row],
+      extraParams: {
+        row,
+        table: node,
+        rowBorders: borderRowData,
+        styleTag: tblStyleTag,
+        columnWidths
+      }
+    });
+    if (result.content?.length) content.push(result);
+  });
+  return {
+    type: "table",
+    content,
+    attrs: encodedAttrs
+  };
+};
+const decode$f = (params, decodedAttrs) => {
+  params.node = preProcessVerticalMergeCells(params.node, params);
+  const { node } = params;
+  const elements = translateChildNodes(params);
+  const firstRow = node.content?.find((n) => n.type === "tableRow");
+  const properties = node.attrs.grid;
+  const element = translator$9.decode({
+    ...params,
+    node: { ...node, attrs: { ...node.attrs, grid: properties } },
+    extraParams: {
+      firstRow
+    }
+  });
+  if (element) elements.unshift(element);
+  if (node.attrs?.tableProperties) {
+    const properties2 = { ...node.attrs.tableProperties };
+    const element2 = translator$b.decode({
+      ...params,
+      node: { ...node, attrs: { ...node.attrs, tableProperties: properties2 } }
+    });
+    if (element2) elements.unshift(element2);
+  }
+  return {
+    name: "w:tbl",
+    attributes: decodedAttrs || {},
+    elements
+  };
+};
+function _processTableBorders(rawBorders) {
+  const borders = {};
+  const rowBorders = {};
+  Object.entries(rawBorders).forEach(([name, attributes]) => {
+    const attrs = {};
+    const color = attributes.color;
+    const size = attributes.size;
+    if (color && color !== "auto") attrs["color"] = color.startsWith("#") ? color : `#${color}`;
+    if (size && size !== "auto") attrs["size"] = eigthPointsToPixels(size);
+    const rowBorderNames = ["insideH", "insideV"];
+    if (rowBorderNames.includes(name)) rowBorders[name] = attrs;
+    borders[name] = attrs;
+  });
+  return {
+    borders,
+    rowBorders
+  };
+}
+function _getReferencedTableStyles(tableStyleReference, params) {
+  if (!tableStyleReference) return null;
+  const stylesToReturn = {};
+  const { docx } = params;
+  const styles = docx["word/styles.xml"];
+  const { elements } = styles.elements[0];
+  const styleElements = elements.filter((el) => el.name === "w:style");
+  const styleTag = styleElements.find((el) => el.attributes["w:styleId"] === tableStyleReference);
+  if (!styleTag) return null;
+  stylesToReturn.name = styleTag.elements.find((el) => el.name === "w:name");
+  const basedOn = styleTag.elements.find((el) => el.name === "w:basedOn");
+  let baseTblPr;
+  if (basedOn?.attributes) {
+    const baseStyles = styleElements.find((el) => el.attributes["w:styleId"] === basedOn.attributes["w:val"]);
+    baseTblPr = baseStyles ? baseStyles.elements.find((el) => el.name === "w:tblPr") : {};
+  }
+  const pPr = styleTag.elements.find((el) => el.name === "w:pPr");
+  if (pPr) {
+    const justification = pPr.elements.find((el) => el.name === "w:jc");
+    if (justification?.attributes) stylesToReturn.justification = justification.attributes["w:val"];
+  }
+  const rPr = styleTag?.elements.find((el) => el.name === "w:rPr");
+  if (rPr) {
+    const fonts = rPr.elements.find((el) => el.name === "w:rFonts");
+    if (fonts) {
+      const { "w:ascii": ascii, "w:hAnsi": hAnsi, "w:cs": cs } = fonts.attributes;
+      stylesToReturn.fonts = { ascii, hAnsi, cs };
+    }
+    const fontSize = rPr.elements.find((el) => el.name === "w:sz");
+    if (fontSize?.attributes) stylesToReturn.fontSize = halfPointToPoints(fontSize.attributes["w:val"]) + "pt";
+  }
+  const tblPr = styleTag.elements.find((el) => el.name === "w:tblPr");
+  if (tblPr && tblPr.elements) {
+    if (baseTblPr && baseTblPr.elements) {
+      tblPr.elements.push(...baseTblPr.elements);
+    }
+    const tableProperties = translator$b.encode({ ...params, nodes: [tblPr] }).attributes;
+    const { borders, rowBorders } = _processTableBorders(tableProperties.borders || {});
+    if (borders) stylesToReturn.borders = borders;
+    if (rowBorders) stylesToReturn.rowBorders = rowBorders;
+    const cellMargins = {};
+    Object.entries(tableProperties.cellMargins || {}).forEach(([key, attrs]) => {
+      if (attrs?.value != null) {
+        cellMargins[key] = {
+          value: attrs.value,
+          type: attrs.type || "dxa"
+        };
+      }
+    });
+    if (Object.keys(cellMargins).length) stylesToReturn.cellMargins = cellMargins;
+  }
+  return stylesToReturn;
+}
+const config$8 = {
+  xmlName: XML_NODE_NAME$8,
+  sdNodeOrKeyName: SD_NODE_NAME$8,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$f,
+  decode: decode$f,
+  attributes: []
+};
+const translator$8 = NodeTranslator.from(config$8);
+const tableNodeHandlerEntity = generateV2HandlerEntity("tableNodeHandler", translator$8);
+function getReferencedTableStyles(tblStyleTag, docx) {
+  if (!tblStyleTag) return null;
   const stylesToReturn = {};
   const { attributes = {} } = tblStyleTag;
   const tableStyleReference = attributes["w:val"];
@@ -25647,15 +26168,6 @@ function processTableBorders(borderElements) {
     rowBorders
   };
 }
-const getGridColumnWidths = (tableNode) => {
-  const tblGrid = tableNode.elements.find((el) => el.name === "w:tblGrid");
-  if (!tblGrid) return [];
-  const columnWidths = tblGrid?.elements?.flatMap((el) => {
-    if (el.name !== "w:gridCol") return [];
-    return twipsToPixels(el.attributes["w:w"]);
-  }) || [];
-  return columnWidths;
-};
 function handleTableCellNode({
   params,
   node,
@@ -25664,7 +26176,8 @@ function handleTableCellNode({
   rowBorders,
   styleTag,
   columnIndex,
-  columnWidth = null
+  columnWidth = null,
+  allColumnWidths = []
 }) {
   const { docx, nodeListHandler } = params;
   const tcPr = node.elements.find((el) => el.name === "w:tcPr");
@@ -25678,7 +26191,7 @@ function handleTableCellNode({
     delete rowBorders?.insideV;
   }
   const inlineBorders = processInlineCellBorders(borders, rowBorders);
-  const gridColumnWidths = getGridColumnWidths(table);
+  const gridColumnWidths = allColumnWidths;
   const tcWidth = tcPr?.elements?.find((el) => el.name === "w:tcW");
   let width = tcWidth ? twipsToPixels(tcWidth.attributes["w:w"]) : null;
   const widthType = tcWidth?.attributes["w:type"];
@@ -25812,11 +26325,17 @@ const getTableCellMargins = (marginTag, referencedStyles) => {
     marginTop: marginTopStyle,
     marginBottom: marginBottomStyle
   } = cellMargins;
+  const resolveMargin = (inlineValue, styleValue) => {
+    if (inlineValue != null) return inlineValue;
+    if (styleValue == null) return void 0;
+    if (typeof styleValue === "object") return styleValue.value;
+    return styleValue;
+  };
   const margins = {
-    left: twipsToPixels(inlineMarginLeftValue ?? marginLeftStyle),
-    right: twipsToPixels(inlineMarginRightValue ?? marginRightStyle),
-    top: twipsToPixels(inlineMarginTopValue ?? marginTopStyle),
-    bottom: twipsToPixels(inlineMarginBottomValue ?? marginBottomStyle)
+    left: twipsToPixels(resolveMargin(inlineMarginLeftValue, marginLeftStyle)),
+    right: twipsToPixels(resolveMargin(inlineMarginRightValue, marginRightStyle)),
+    top: twipsToPixels(resolveMargin(inlineMarginTopValue, marginTopStyle)),
+    bottom: twipsToPixels(resolveMargin(inlineMarginBottomValue, marginBottomStyle))
   };
   return margins;
 };
@@ -25930,11 +26449,20 @@ function generateCellMargins(cellMargins) {
   if (left != null) elements.push({ name: "w:left", attributes: { "w:w": pixelsToTwips(left) } });
   return elements;
 }
-const XML_NODE_NAME$2 = "w:tc";
-const SD_NODE_NAME$2 = "tableCell";
-const validXmlAttributes$2 = [];
-function encode$2(params, encodedAttrs) {
-  const { node, table, row, rowBorders, styleTag, columnIndex, columnWidth } = params.extraParams;
+const XML_NODE_NAME$7 = "w:tc";
+const SD_NODE_NAME$7 = "tableCell";
+const validXmlAttributes$7 = [];
+function encode$e(params, encodedAttrs) {
+  const {
+    node,
+    table,
+    row,
+    rowBorders,
+    styleTag,
+    columnIndex,
+    columnWidth,
+    columnWidths: allColumnWidths
+  } = params.extraParams;
   const schemaNode = handleTableCellNode({
     params,
     node,
@@ -25943,38 +26471,39 @@ function encode$2(params, encodedAttrs) {
     rowBorders,
     styleTag,
     columnIndex,
-    columnWidth
+    columnWidth,
+    allColumnWidths
   });
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
     schemaNode.attrs = { ...schemaNode.attrs, ...encodedAttrs };
   }
   return schemaNode;
 }
-function decode$2(params, decodedAttrs) {
+function decode$e(params, decodedAttrs) {
   const translated = translateTableCell(params);
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
     translated.attributes = { ...translated.attributes || {}, ...decodedAttrs };
   }
   return translated;
 }
-const config$2 = {
-  xmlName: XML_NODE_NAME$2,
-  sdNodeOrKeyName: SD_NODE_NAME$2,
+const config$7 = {
+  xmlName: XML_NODE_NAME$7,
+  sdNodeOrKeyName: SD_NODE_NAME$7,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$2,
-  decode: decode$2,
-  attributes: validXmlAttributes$2
+  encode: encode$e,
+  decode: decode$e,
+  attributes: validXmlAttributes$7
 };
-const translator$2 = NodeTranslator.from(config$2);
-const XML_NODE_NAME$1 = "w:hyperlink";
-const SD_NODE_NAME$1 = "link";
+const translator$7 = NodeTranslator.from(config$7);
+const XML_NODE_NAME$6 = "w:hyperlink";
+const SD_NODE_NAME$6 = "link";
 const _createAttributeHandler = (xmlName, sdName) => ({
   xmlName,
   sdName,
   encode: (attributes) => attributes[xmlName],
   decode: (attributes) => attributes[sdName]
 });
-const validXmlAttributes$1 = [
+const validXmlAttributes$6 = [
   _createAttributeHandler("w:anchor", "anchor"),
   _createAttributeHandler("w:docLocation", "docLocation"),
   {
@@ -25987,7 +26516,7 @@ const validXmlAttributes$1 = [
   _createAttributeHandler("r:id", "rId"),
   _createAttributeHandler("w:tgtFrame", "target")
 ];
-const encode$1 = (params, encodedAttrs) => {
+const encode$d = (params, encodedAttrs) => {
   const { nodes, docx, nodeListHandler } = params;
   const node = nodes[0];
   let href = _resolveHref(docx, encodedAttrs);
@@ -26018,7 +26547,7 @@ const _resolveHref = (docx, encodedAttrs) => {
   }
   return href;
 };
-function decode$1(params) {
+function decode$d(params) {
   const { node } = params;
   const linkMark = node.marks.find((m2) => m2.type === "link");
   const linkAttrs = this.decodeAttributes({ ...params, node: linkMark });
@@ -26062,15 +26591,15 @@ function _addNewLinkRelationship(params, link, rId) {
   });
   return rId;
 }
-const config$1 = {
-  xmlName: XML_NODE_NAME$1,
-  sdNodeOrKeyName: SD_NODE_NAME$1,
+const config$6 = {
+  xmlName: XML_NODE_NAME$6,
+  sdNodeOrKeyName: SD_NODE_NAME$6,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$1,
-  decode: decode$1,
-  attributes: validXmlAttributes$1
+  encode: encode$d,
+  decode: decode$d,
+  attributes: validXmlAttributes$6
 };
-const translator$1 = NodeTranslator.from(config$1);
+const translator$6 = NodeTranslator.from(config$6);
 function parseTagValueJSON(json) {
   if (typeof json !== "string") {
     return {};
@@ -26081,7 +26610,7 @@ function parseTagValueJSON(json) {
   }
   try {
     return JSON.parse(trimmed);
-  } catch (err) {
+  } catch {
     return {};
   }
 }
@@ -26312,6 +26841,813 @@ function sdtNodeTypeStrategy(node) {
   }
   return { type: "unknown", handler: null };
 }
+function handleImageNode(node, params, isAnchor) {
+  const { docx, filename } = params;
+  const { attributes } = node;
+  const padding = {
+    top: emuToPixels(attributes["distT"]),
+    bottom: emuToPixels(attributes["distB"]),
+    left: emuToPixels(attributes["distL"]),
+    right: emuToPixels(attributes["distR"])
+  };
+  const extent = node.elements.find((el) => el.name === "wp:extent");
+  const size = {
+    width: emuToPixels(extent.attributes?.cx),
+    height: emuToPixels(extent.attributes?.cy)
+  };
+  const graphic = node.elements.find((el) => el.name === "a:graphic");
+  const graphicData = graphic.elements.find((el) => el.name === "a:graphicData");
+  const { uri: uri2 } = graphicData?.attributes || {};
+  const shapeURI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
+  if (!!uri2 && uri2 === shapeURI) {
+    return handleShapeDrawing(params, node, graphicData);
+  }
+  const picture = graphicData.elements.find((el) => el.name === "pic:pic");
+  if (!picture || !picture.elements) return null;
+  const blipFill = picture.elements.find((el) => el.name === "pic:blipFill");
+  const blip = blipFill.elements.find((el) => el.name === "a:blip");
+  const spPr = picture.elements.find((el) => el.name === "pic:spPr");
+  let transformData = {};
+  if (spPr) {
+    const xfrm = spPr.elements.find((el) => el.name === "a:xfrm");
+    if (xfrm?.attributes) {
+      transformData = {
+        rotation: rotToDegrees(xfrm.attributes["rot"]),
+        verticalFlip: xfrm.attributes["flipV"] === "1",
+        horizontalFlip: xfrm.attributes["flipH"] === "1"
+      };
+    }
+  }
+  const effectExtent = node.elements.find((el) => el.name === "wp:effectExtent");
+  if (effectExtent) {
+    const sanitizeEmuValue = (value) => {
+      if (value === null || value === void 0) return 0;
+      const numeric = Number(value);
+      return Number.isFinite(numeric) ? numeric : 0;
+    };
+    transformData.sizeExtension = {
+      left: emuToPixels(sanitizeEmuValue(effectExtent.attributes["l"])),
+      top: emuToPixels(sanitizeEmuValue(effectExtent.attributes["t"])),
+      right: emuToPixels(sanitizeEmuValue(effectExtent.attributes["r"])),
+      bottom: emuToPixels(sanitizeEmuValue(effectExtent.attributes["b"]))
+    };
+  }
+  const positionHTag = node.elements.find((el) => el.name === "wp:positionH");
+  const positionH = positionHTag?.elements.find((el) => el.name === "wp:posOffset");
+  const positionHValue = emuToPixels(positionH?.elements[0]?.text);
+  const hRelativeFrom = positionHTag?.attributes.relativeFrom;
+  const alignH = positionHTag?.elements.find((el) => el.name === "wp:align")?.elements[0]?.text;
+  const positionVTag = node.elements.find((el) => el.name === "wp:positionV");
+  const positionV = positionVTag?.elements?.find((el) => el.name === "wp:posOffset");
+  const positionVValue = emuToPixels(positionV?.elements[0]?.text);
+  const vRelativeFrom = positionVTag?.attributes.relativeFrom;
+  const alignV = positionVTag?.elements?.find((el) => el.name === "wp:align")?.elements[0]?.text;
+  const simplePos = node.elements.find((el) => el.name === "wp:simplePos");
+  const wrapSquare = node.elements.find((el) => el.name === "wp:wrapSquare");
+  const wrapTopAndBottom = node.elements.find((el) => el.name === "wp:wrapTopAndBottom");
+  const docPr = node.elements.find((el) => el.name === "wp:docPr");
+  let anchorData = null;
+  if (hRelativeFrom || alignH || vRelativeFrom || alignV) {
+    anchorData = {
+      hRelativeFrom,
+      vRelativeFrom,
+      alignH,
+      alignV
+    };
+  }
+  const marginOffset = {
+    left: positionHValue,
+    top: positionVValue
+  };
+  const { attributes: blipAttributes = {} } = blip;
+  const rEmbed = blipAttributes["r:embed"];
+  if (!rEmbed) return null;
+  const currentFile = filename || "document.xml";
+  let rels = docx[`word/_rels/${currentFile}.rels`];
+  if (!rels) rels = docx[`word/_rels/document.xml.rels`];
+  const relationships = rels.elements.find((el) => el.name === "Relationships");
+  const { elements } = relationships || [];
+  const rel = elements?.find((el) => el.attributes["Id"] === rEmbed);
+  if (!rel) return null;
+  const { attributes: relAttributes } = rel;
+  const targetPath = relAttributes["Target"];
+  let path = `word/${targetPath}`;
+  if (targetPath.startsWith("/word") || targetPath.startsWith("/media")) path = targetPath.substring(1);
+  const extension = targetPath.substring(targetPath.lastIndexOf(".") + 1);
+  return {
+    type: "image",
+    attrs: {
+      src: path,
+      alt: ["emf", "wmf"].includes(extension) ? "Unable to render EMF/WMF image" : docPr?.attributes.name || "Image",
+      extension,
+      id: docPr?.attributes.id || "",
+      title: docPr?.attributes.descr || "Image",
+      inline: true,
+      padding,
+      marginOffset,
+      size,
+      anchorData,
+      isAnchor,
+      transformData,
+      ...simplePos && {
+        simplePos: {
+          x: simplePos.attributes.x,
+          y: simplePos.attributes.y
+        }
+      },
+      ...wrapSquare && {
+        wrapText: wrapSquare.attributes.wrapText
+      },
+      wrapTopAndBottom: !!wrapTopAndBottom,
+      originalPadding: {
+        distT: attributes["distT"],
+        distB: attributes["distB"],
+        distL: attributes["distL"],
+        distR: attributes["distR"]
+      },
+      originalAttributes: node.attributes,
+      rId: relAttributes["Id"]
+    }
+  };
+}
+const handleShapeDrawing = (params, node, graphicData) => {
+  const wsp = graphicData.elements.find((el) => el.name === "wps:wsp");
+  const textBox = wsp.elements.find((el) => el.name === "wps:txbx");
+  const textBoxContent = textBox?.elements?.find((el) => el.name === "w:txbxContent");
+  node.elements.find((el) => el.name === "wp:docPr");
+  const spPr = wsp.elements.find((el) => el.name === "wps:spPr");
+  const prstGeom = spPr?.elements.find((el) => el.name === "a:prstGeom");
+  if (!!prstGeom && prstGeom.attributes["prst"] === "rect" && !textBoxContent) {
+    return getRectangleShape(params, spPr);
+  }
+  if (!textBoxContent) {
+    return null;
+  }
+  const { nodeListHandler } = params;
+  const translatedElement = nodeListHandler.handler({
+    ...params,
+    node: textBoxContent.elements[0],
+    nodes: textBoxContent.elements,
+    path: [...params.path || [], textBoxContent]
+  });
+  return translatedElement[0];
+};
+const getRectangleShape = (params, node) => {
+  const schemaAttrs = {};
+  const [drawingNode] = params.nodes;
+  if (drawingNode?.name === "w:drawing") {
+    schemaAttrs.drawingContent = drawingNode;
+  }
+  const xfrm = node.elements.find((el) => el.name === "a:xfrm");
+  const start = xfrm.elements.find((el) => el.name === "a:off");
+  const size = xfrm.elements.find((el) => el.name === "a:ext");
+  const solidFill = node.elements.find((el) => el.name === "a:solidFill");
+  node.elements.find((el) => el.name === "a:ln");
+  const rectangleSize = {
+    top: emuToPixels(start.attributes["y"]),
+    left: emuToPixels(start.attributes["x"]),
+    width: emuToPixels(size.attributes["cx"]),
+    height: emuToPixels(size.attributes["cy"])
+  };
+  schemaAttrs.size = rectangleSize;
+  const background = solidFill?.elements[0]?.attributes["val"];
+  if (background) {
+    schemaAttrs.background = "#" + background;
+  }
+  return {
+    type: "contentBlock",
+    attrs: schemaAttrs
+  };
+};
+function handleAnchorNode(params) {
+  const { node } = params.extraParams;
+  if (node.name !== "wp:anchor") {
+    return null;
+  }
+  return handleImageNode(node, params, true);
+}
+const sanitizeDocxMediaName = (value, fallback = "image") => {
+  if (!value) return fallback;
+  const sanitized = value.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return sanitized || fallback;
+};
+const getFallbackImageNameFromDataUri = (src = "", fallback = "image") => {
+  if (!src || typeof src !== "string") return fallback;
+  const [prefix] = src.split(";");
+  const [, maybeType] = prefix.split("/");
+  const extension = maybeType?.toLowerCase();
+  return extension ? `${fallback}.${extension}` : fallback;
+};
+const translateImageNode = (params) => {
+  const {
+    node: { attrs = {} },
+    tableCell,
+    imageSize
+  } = params;
+  let imageId = attrs.rId;
+  const src = attrs.src || attrs.imageSrc;
+  const { originalWidth, originalHeight } = getPngDimensions(src);
+  let imageName;
+  if (params.node.type === "image") {
+    if (src?.startsWith("data:")) {
+      imageName = getFallbackImageNameFromDataUri(src);
+    } else {
+      imageName = src?.split("/").pop();
+    }
+  } else {
+    imageName = attrs.fieldId;
+  }
+  imageName = sanitizeDocxMediaName(imageName);
+  let size = attrs.size ? {
+    w: pixelsToEmu(attrs.size.width),
+    h: pixelsToEmu(attrs.size.height)
+  } : imageSize;
+  if (originalWidth && originalHeight) {
+    const boxWidthPx = emuToPixels(size.w);
+    const boxHeightPx = emuToPixels(size.h);
+    const { scaledWidth, scaledHeight } = getScaledSize(originalWidth, originalHeight, boxWidthPx, boxHeightPx);
+    size = {
+      w: pixelsToEmu(scaledWidth),
+      h: pixelsToEmu(scaledHeight)
+    };
+  }
+  if (tableCell) {
+    const colwidthSum = tableCell.attrs.colwidth.reduce((acc, curr) => acc + curr, 0);
+    const leftMargin = tableCell.attrs.cellMargins?.left || 8;
+    const rightMargin = tableCell.attrs.cellMargins?.right || 8;
+    const maxWidthEmu = pixelsToEmu(colwidthSum - (leftMargin + rightMargin));
+    const { width: w2, height: h2 } = resizeKeepAspectRatio(size.w, size.h, maxWidthEmu);
+    if (w2 && h2) size = { w: w2, h: h2 };
+  }
+  if (params.node.type === "image" && !imageId) {
+    const path = src?.split("word/")[1];
+    imageId = addNewImageRelationship(params, path);
+  } else if (params.node.type === "fieldAnnotation" && !imageId) {
+    const type2 = src?.split(";")[0].split("/")[1];
+    if (!type2) {
+      return prepareTextAnnotation(params);
+    }
+    const sanitizedHash = sanitizeDocxMediaName(attrs.hash, generateDocxRandomId(4));
+    const fileName = `${imageName}_${sanitizedHash}.${type2}`;
+    const relationshipTarget = `media/${fileName}`;
+    const packagePath = `word/${relationshipTarget}`;
+    imageId = addNewImageRelationship(params, relationshipTarget);
+    params.media[packagePath] = src;
+  }
+  const inlineAttrs = attrs.originalPadding || {
+    distT: 0,
+    distB: 0,
+    distL: 0,
+    distR: 0
+  };
+  const xfrmAttrs = {};
+  const effectExtentAttrs = {
+    l: 0,
+    t: 0,
+    r: 0,
+    b: 0
+  };
+  const transformData = attrs.transformData;
+  if (transformData) {
+    if (transformData.rotation) {
+      xfrmAttrs.rot = degreesToRot(transformData.rotation);
+    }
+    if (transformData.verticalFlip) {
+      xfrmAttrs.flipV = "1";
+    }
+    if (transformData.horizontalFlip) {
+      xfrmAttrs.flipH = "1";
+    }
+    if (transformData.sizeExtension) {
+      effectExtentAttrs.l = pixelsToEmu(transformData.sizeExtension.left);
+      effectExtentAttrs.t = pixelsToEmu(transformData.sizeExtension.top);
+      effectExtentAttrs.r = pixelsToEmu(transformData.sizeExtension.right);
+      effectExtentAttrs.b = pixelsToEmu(transformData.sizeExtension.bottom);
+    }
+  }
+  const drawingXmlns = "http://schemas.openxmlformats.org/drawingml/2006/main";
+  const pictureXmlns = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+  return {
+    attributes: inlineAttrs,
+    elements: [
+      {
+        name: "wp:extent",
+        attributes: {
+          cx: size.w,
+          cy: size.h
+        }
+      },
+      {
+        name: "wp:effectExtent",
+        attributes: effectExtentAttrs
+      },
+      {
+        name: "wp:docPr",
+        attributes: {
+          id: attrs.id || 0,
+          name: attrs.alt || `Picture ${imageName}`
+        }
+      },
+      {
+        name: "wp:cNvGraphicFramePr",
+        elements: [
+          {
+            name: "a:graphicFrameLocks",
+            attributes: {
+              "xmlns:a": drawingXmlns,
+              noChangeAspect: 1
+            }
+          }
+        ]
+      },
+      {
+        name: "a:graphic",
+        attributes: { "xmlns:a": drawingXmlns },
+        elements: [
+          {
+            name: "a:graphicData",
+            attributes: { uri: pictureXmlns },
+            elements: [
+              {
+                name: "pic:pic",
+                attributes: { "xmlns:pic": pictureXmlns },
+                elements: [
+                  {
+                    name: "pic:nvPicPr",
+                    elements: [
+                      {
+                        name: "pic:cNvPr",
+                        attributes: {
+                          id: attrs.id || 0,
+                          name: attrs.title || `Picture ${imageName}`
+                        }
+                      },
+                      {
+                        name: "pic:cNvPicPr",
+                        elements: [
+                          {
+                            name: "a:picLocks",
+                            attributes: {
+                              noChangeAspect: 1,
+                              noChangeArrowheads: 1
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  },
+                  {
+                    name: "pic:blipFill",
+                    elements: [
+                      {
+                        name: "a:blip",
+                        attributes: {
+                          "r:embed": imageId
+                        }
+                      },
+                      {
+                        name: "a:stretch",
+                        elements: [{ name: "a:fillRect" }]
+                      }
+                    ]
+                  },
+                  {
+                    name: "pic:spPr",
+                    attributes: {
+                      bwMode: "auto"
+                    },
+                    elements: [
+                      {
+                        name: "a:xfrm",
+                        attributes: xfrmAttrs,
+                        elements: [
+                          {
+                            name: "a:ext",
+                            attributes: {
+                              cx: size.w,
+                              cy: size.h
+                            }
+                          },
+                          {
+                            name: "a:off",
+                            attributes: {
+                              x: 0,
+                              y: 0
+                            }
+                          }
+                        ]
+                      },
+                      {
+                        name: "a:prstGeom",
+                        attributes: { prst: "rect" },
+                        elements: [{ name: "a:avLst" }]
+                      },
+                      {
+                        name: "a:noFill"
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+};
+function getPngDimensions(base64) {
+  if (!base64) return {};
+  const type2 = base64.split(";")[0].split("/")[1];
+  if (!base64 || type2 !== "png") {
+    return {
+      originalWidth: void 0,
+      originalHeight: void 0
+    };
+  }
+  let header = base64.split(",")[1].slice(0, 50);
+  let uint8 = Uint8Array.from(atob(header), (c) => c.charCodeAt(0));
+  let dataView = new DataView(uint8.buffer, 0, 28);
+  return {
+    originalWidth: dataView.getInt32(16),
+    originalHeight: dataView.getInt32(20)
+  };
+}
+function getScaledSize(originalWidth, originalHeight, maxWidth, maxHeight) {
+  let scaledWidth = originalWidth;
+  let scaledHeight = originalHeight;
+  let ratio = Math.min(maxWidth / originalWidth, maxHeight / originalHeight);
+  scaledWidth = Math.round(scaledWidth * ratio);
+  scaledHeight = Math.round(scaledHeight * ratio);
+  return { scaledWidth, scaledHeight };
+}
+function resizeKeepAspectRatio(width, height, maxWidth) {
+  if (width > maxWidth) {
+    let scale = maxWidth / width;
+    let newHeight = Math.round(height * scale);
+    return { width: maxWidth, height: newHeight };
+  }
+  return { width, height };
+}
+function addNewImageRelationship(params, imagePath) {
+  const newId = "rId" + generateDocxRandomId();
+  const newRel = {
+    type: "element",
+    name: "Relationship",
+    attributes: {
+      Id: newId,
+      Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+      Target: imagePath
+    }
+  };
+  params.relationships.push(newRel);
+  return newId;
+}
+function translateAnchorNode(params) {
+  const { attrs } = params.node;
+  const anchorElements = [];
+  const wrapElements = [];
+  if (attrs.simplePos) {
+    anchorElements.push({
+      name: "wp:simplePos",
+      attributes: {
+        x: 0,
+        y: 0
+      }
+    });
+  }
+  if (attrs.anchorData) {
+    const hElements = [];
+    if (attrs.marginOffset.left !== void 0) {
+      hElements.push({
+        name: "wp:posOffset",
+        elements: [{ type: "text", text: pixelsToEmu(attrs.marginOffset.left).toString() }]
+      });
+    }
+    if (attrs.anchorData.alignH) {
+      hElements.push({
+        name: "wp:align",
+        elements: [{ type: "text", text: attrs.anchorData.alignH }]
+      });
+    }
+    anchorElements.push({
+      name: "wp:positionH",
+      attributes: { relativeFrom: attrs.anchorData.hRelativeFrom },
+      ...hElements.length && { elements: hElements }
+    });
+    const vElements = [];
+    if (attrs.marginOffset.top !== void 0) {
+      vElements.push({
+        name: "wp:posOffset",
+        elements: [{ type: "text", text: pixelsToEmu(attrs.marginOffset.top).toString() }]
+      });
+    }
+    if (attrs.anchorData.alignV) {
+      vElements.push({
+        name: "wp:align",
+        elements: [{ type: "text", text: attrs.anchorData.alignV }]
+      });
+    }
+    anchorElements.push({
+      name: "wp:positionV",
+      attributes: { relativeFrom: attrs.anchorData.vRelativeFrom },
+      ...vElements.length && { elements: vElements }
+    });
+  }
+  if (attrs.wrapText) {
+    wrapElements.push({
+      name: "wp:wrapSquare",
+      attributes: {
+        wrapText: attrs.wrapText
+      }
+    });
+  }
+  if (attrs.wrapTopAndBottom) {
+    wrapElements.push({
+      name: "wp:wrapTopAndBottom"
+    });
+  }
+  if (!wrapElements.length) {
+    wrapElements.push({
+      name: "wp:wrapNone"
+    });
+  }
+  const nodeElements = translateImageNode(params);
+  const inlineAttrs = {
+    ...nodeElements.attributes,
+    simplePos: attrs.originalAttributes?.simplePos,
+    relativeHeight: 1,
+    behindDoc: attrs.originalAttributes?.behindDoc,
+    locked: attrs.originalAttributes?.locked,
+    layoutInCell: attrs.originalAttributes?.layoutInCell,
+    allowOverlap: attrs.originalAttributes?.allowOverlap
+  };
+  const effectIndex = nodeElements.elements.findIndex((el) => el.name === "wp:effectExtent");
+  const elementsWithWrap = [
+    ...nodeElements.elements.slice(0, effectIndex + 1),
+    ...wrapElements,
+    ...nodeElements.elements.slice(effectIndex + 1)
+  ];
+  return {
+    name: "wp:anchor",
+    attributes: inlineAttrs,
+    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(params) {
+  const { node } = params.extraParams;
+  if (!node || !node.type) {
+    return null;
+  }
+  return handleAnchorNode(params);
+}
+function decode$c(params) {
+  const { node } = params;
+  if (!node || !node.type) {
+    return null;
+  }
+  return translateAnchorNode(params);
+}
+const config$5 = {
+  xmlName: XML_NODE_NAME$5,
+  sdNodeOrKeyName: SD_NODE_NAME$5,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$c,
+  decode: decode$c,
+  attributes: validXmlAttributes$5
+};
+const translator$5 = NodeTranslator.from(config$5);
+function handleInlineNode(params) {
+  const { node } = params.extraParams;
+  if (node.name !== "wp:inline") {
+    return null;
+  }
+  return handleImageNode(node, params, false);
+}
+function translateInlineNode(params) {
+  const nodeElements = translateImageNode(params);
+  return {
+    name: "wp:inline",
+    attributes: nodeElements.attributes,
+    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(params) {
+  const { node } = params.extraParams;
+  if (!node || !node.type) {
+    return null;
+  }
+  return handleInlineNode(params);
+}
+function decode$b(params) {
+  const { node } = params;
+  if (!node || !node.type) {
+    return null;
+  }
+  return translateInlineNode(params);
+}
+const config$4 = {
+  xmlName: XML_NODE_NAME$4,
+  sdNodeOrKeyName: SD_NODE_NAME$4,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$b,
+  decode: decode$b,
+  attributes: validXmlAttributes$4
+};
+const translator$4 = NodeTranslator.from(config$4);
+const encode$a = (attributes) => {
+  return attributes["w:id"];
+};
+const decode$a = (attrs) => {
+  return attrs.id;
+};
+const attrConfig$6 = Object.freeze({
+  xmlName: "w:id",
+  sdName: "id",
+  encode: encode$a,
+  decode: decode$a
+});
+const encode$9 = (attributes) => {
+  return attributes["w:name"];
+};
+const decode$9 = (attrs) => {
+  return attrs.name;
+};
+const attrConfig$5 = Object.freeze({
+  xmlName: "w:name",
+  sdName: "name",
+  encode: encode$9,
+  decode: decode$9
+});
+const encode$8 = (attributes) => {
+  return attributes["w:colFirst"];
+};
+const decode$8 = (attrs) => {
+  return attrs.colFirst;
+};
+const attrConfig$4 = Object.freeze({
+  xmlName: "w:colFirst",
+  sdName: "colFirst",
+  encode: encode$8,
+  decode: decode$8
+});
+const encode$7 = (attributes) => {
+  return attributes["w:colLast"];
+};
+const decode$7 = (attrs) => {
+  return attrs.colLast;
+};
+const attrConfig$3 = Object.freeze({
+  xmlName: "w:colLast",
+  sdName: "colLast",
+  encode: encode$7,
+  decode: decode$7
+});
+const encode$6 = (attributes) => {
+  return attributes["w:displacedByCustomXml"];
+};
+const decode$6 = (attrs) => {
+  return attrs.displacedByCustomXml;
+};
+const attrConfig$2 = Object.freeze({
+  xmlName: "w:displacedByCustomXml",
+  sdName: "displacedByCustomXml",
+  encode: encode$6,
+  decode: decode$6
+});
+const validXmlAttributes$3 = [attrConfig$6, attrConfig$5, attrConfig$4, attrConfig$3, attrConfig$2];
+const XML_NODE_NAME$3 = "w:bookmarkStart";
+const SD_NODE_NAME$3 = "bookmarkStart";
+const encode$5 = (params, encodedAttrs = {}) => {
+  return {
+    type: "bookmarkStart",
+    attrs: encodedAttrs
+  };
+};
+const decode$5 = (params, decodedAttrs = {}) => {
+  const result = {
+    name: "w:bookmarkStart",
+    elements: []
+  };
+  if (decodedAttrs && Object.keys(decodedAttrs).length) {
+    result.attributes = decodedAttrs;
+  }
+  return result;
+};
+const config$3 = {
+  xmlName: XML_NODE_NAME$3,
+  sdNodeOrKeyName: SD_NODE_NAME$3,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$5,
+  decode: decode$5,
+  attributes: validXmlAttributes$3
+};
+const translator$3 = NodeTranslator.from(config$3);
+const encode$4 = (attributes) => {
+  return attributes["w:id"];
+};
+const decode$4 = (attrs) => {
+  return attrs.id;
+};
+const attrConfig$1 = Object.freeze({
+  xmlName: "w:id",
+  sdName: "id",
+  encode: encode$4,
+  decode: decode$4
+});
+const encode$3 = (attributes) => {
+  return attributes["w:displacedByCustomXml"];
+};
+const decode$3 = (attrs) => {
+  return attrs.displacedByCustomXml;
+};
+const attrConfig = Object.freeze({
+  xmlName: "w:displacedByCustomXml",
+  sdName: "displacedByCustomXml",
+  encode: encode$3,
+  decode: decode$3
+});
+const validXmlAttributes$2 = [attrConfig$1, attrConfig];
+const XML_NODE_NAME$2 = "w:bookmarkEnd";
+const SD_NODE_NAME$2 = "bookmarkEnd";
+const encode$2 = (params, encodedAttrs = {}) => {
+  return {
+    type: "bookmarkEnd",
+    attrs: encodedAttrs
+  };
+};
+const decode$2 = (params, decodedAttrs = {}) => {
+  const result = {
+    name: "w:bookmarkEnd",
+    elements: []
+  };
+  if (decodedAttrs && Object.keys(decodedAttrs).length) {
+    result.attributes = decodedAttrs;
+  }
+  return result;
+};
+const config$2 = {
+  xmlName: XML_NODE_NAME$2,
+  sdNodeOrKeyName: SD_NODE_NAME$2,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$2,
+  decode: decode$2,
+  attributes: validXmlAttributes$2
+};
+const translator$2 = NodeTranslator.from(config$2);
+const registeredHandlers = Object.freeze({
+  "w:br": translator$V,
+  "w:tab": translator$U,
+  "w:p": translator$T,
+  "wp:anchor": translator$5,
+  "wp:inline": translator$4,
+  "w:bookmarkStart": translator$3,
+  "w:bookmarkEnd": translator$2
+});
+const XML_NODE_NAME$1 = "w:drawing";
+const SD_NODE_NAME$1 = [];
+const validXmlAttributes$1 = [];
+function encode$1(params) {
+  const nodes = params.nodes;
+  const node = nodes[0];
+  const validChildTranslators = ["wp:anchor", "wp:inline"];
+  return node.elements.reduce((acc, child) => {
+    if (acc) return acc;
+    if (!validChildTranslators.includes(child.name)) return acc;
+    const translator2 = registeredHandlers[child.name];
+    return translator2.encode({ ...params, extraParams: { node: child } }) || acc;
+  }, null);
+}
+function decode$1(params) {
+  const { node } = params;
+  if (!node || !node.type) {
+    return null;
+  }
+  const handlerName = node.attrs.isAnchor ? "wp:anchor" : "wp:inline";
+  const resultNode = registeredHandlers[handlerName].decode(params);
+  return wrapTextInRun(
+    {
+      name: "w:drawing",
+      elements: [resultNode]
+    },
+    []
+  );
+}
+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);
 class CommandService {
   /**
    * @param {import('./commands/types/index.js').CommandServiceOptions} props
@@ -27649,7 +28985,10 @@ function prepareTextAnnotation(params) {
   return getTextNodeForExport(attrs.displayLabel, [...marks, ...marksFromAttrs], params);
 }
 function prepareImageAnnotation(params, imageSize) {
-  return translateImageNode(params, imageSize);
+  return translator$1.decode({
+    ...params,
+    imageSize
+  });
 }
 function prepareCheckboxAnnotation(params) {
   const {
@@ -27886,7 +29225,7 @@ function translateStructuredContent(params) {
 const XML_NODE_NAME = "w:sdt";
 const SD_NODE_NAME = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
 const validXmlAttributes = [];
-function encode(params, encodedAttrs) {
+function encode(params) {
   const nodes = params.nodes;
   const node = nodes[0];
   const { type: sdtType, handler: handler2 } = sdtNodeTypeStrategy(node);
@@ -27896,7 +29235,7 @@ function encode(params, encodedAttrs) {
   const result = handler2(params);
   return result;
 }
-function decode(params, decodedAttrs) {
+function decode(params) {
   const { node } = params;
   if (!node || !node.type) {
     return null;
@@ -27927,19 +29266,20 @@ function exportSchemaToJson(params) {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$h,
+    paragraph: translator$T,
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$j,
-    table: translateTable,
-    tableRow: translator$3,
-    tableCell: translator$2,
-    bookmarkStart: translateBookmarkStart,
+    lineBreak: translator$V,
+    table: translator$8,
+    tableRow: translator$F,
+    tableCell: translator$7,
+    bookmarkStart: translator$3,
+    bookmarkEnd: translator$2,
     fieldAnnotation: translator,
-    tab: translator$i,
-    image: translateImageNode,
-    hardBreak: translator$j,
+    tab: translator$U,
+    image: translator$1,
+    hardBreak: translator$V,
     commentRangeStart: () => translateCommentNode(params, "Start"),
     commentRangeEnd: () => translateCommentNode(params, "End"),
     commentReference: () => null,
@@ -28271,7 +29611,7 @@ function translateTextNode(params) {
   const isTrackedNode = node.marks?.some((m2) => trackedMarks.includes(m2.type));
   if (isTrackedNode) return translateTrackedNode(params);
   const isLinkNode = node.marks?.some((m2) => m2.type === "link");
-  if (isLinkNode) return translator$1.decode(params);
+  if (isLinkNode) return translator$6.decode(params);
   const { text, marks = [] } = node;
   return getTextNodeForExport(text, marks, params);
 }
@@ -28404,20 +29744,6 @@ function addNewLinkRelationship(params, link) {
   });
   return newId;
 }
-function addNewImageRelationship(params, imagePath) {
-  const newId = "rId" + generateDocxRandomId();
-  const newRel = {
-    type: "element",
-    name: "Relationship",
-    attributes: {
-      Id: newId,
-      Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
-      Target: imagePath
-    }
-  };
-  params.relationships.push(newRel);
-  return newId;
-}
 function translateList(params) {
   const { node, editor } = params;
   const listItem = node.content[0];
@@ -28560,181 +29886,6 @@ const generateNumPrTag = (numId, level) => {
     ]
   };
 };
-function translateTable(params) {
-  params.node = preProcessVerticalMergeCells(params.node, params);
-  const elements = translateChildNodes(params);
-  const tableProperties = generateTableProperties(params.node);
-  const gridProperties = generateTableGrid(params.node, params);
-  elements.unshift(tableProperties);
-  elements.unshift(gridProperties);
-  return {
-    name: "w:tbl",
-    elements
-  };
-}
-function preProcessVerticalMergeCells(table, { editorSchema }) {
-  const { content } = table;
-  for (let rowIndex = 0; rowIndex < content.length; rowIndex++) {
-    const row = content[rowIndex];
-    if (!row.content) continue;
-    for (let cellIndex = 0; cellIndex < row.content?.length; cellIndex++) {
-      const cell = row.content[cellIndex];
-      if (!cell) continue;
-      const { attrs } = cell;
-      if (attrs.rowspan > 1) {
-        const rowsToChange = content.slice(rowIndex + 1, rowIndex + attrs.rowspan);
-        const mergedCell = {
-          type: cell.type,
-          content: [
-            // cells must end with a paragraph
-            editorSchema.nodes.paragraph.createAndFill().toJSON()
-          ],
-          attrs: {
-            ...cell.attrs,
-            // reset colspan and rowspan
-            colspan: null,
-            rowspan: null,
-            // to add vMerge
-            continueMerge: true
-          }
-        };
-        rowsToChange.forEach((rowToChange) => {
-          rowToChange.content.splice(cellIndex, 0, mergedCell);
-        });
-      }
-    }
-  }
-  return table;
-}
-function generateTableProperties(node) {
-  const elements = [];
-  const { attrs } = node;
-  const { tableWidth, tableStyleId, borders, tableIndent, tableLayout, tableCellSpacing, justification } = attrs;
-  if (tableStyleId) {
-    const tableStyleElement = {
-      name: "w:tblStyle",
-      attributes: { "w:val": tableStyleId }
-    };
-    elements.push(tableStyleElement);
-  }
-  if (borders) {
-    const borderElement = generateTableBorders(node);
-    elements.push(borderElement);
-  }
-  if (tableIndent) {
-    const { width, type: type2 } = tableIndent;
-    const tableIndentElement = {
-      name: "w:tblInd",
-      attributes: { "w:w": pixelsToTwips(width), "w:type": type2 }
-    };
-    elements.push(tableIndentElement);
-  }
-  if (tableLayout) {
-    const tableLayoutElement = {
-      name: "w:tblLayout",
-      attributes: { "w:type": tableLayout }
-    };
-    elements.push(tableLayoutElement);
-  }
-  if (tableWidth && tableWidth.width) {
-    const tableWidthElement = {
-      name: "w:tblW",
-      attributes: { "w:w": pixelsToTwips(tableWidth.width), "w:type": tableWidth.type }
-    };
-    elements.push(tableWidthElement);
-  }
-  if (tableCellSpacing) {
-    elements.push({
-      name: "w:tblCellSpacing",
-      attributes: {
-        "w:w": tableCellSpacing.w,
-        "w:type": tableCellSpacing.type
-      }
-    });
-  }
-  if (justification) {
-    const justificationElement = {
-      name: "w:jc",
-      attributes: { "w:val": justification }
-    };
-    elements.push(justificationElement);
-  }
-  return {
-    name: "w:tblPr",
-    elements
-  };
-}
-function generateTableBorders(node) {
-  const { borders } = node.attrs;
-  const elements = [];
-  if (!borders) return;
-  const borderTypes = ["top", "bottom", "left", "right", "insideH", "insideV"];
-  borderTypes.forEach((type2) => {
-    const border = borders[type2];
-    if (!border) return;
-    let attributes = {};
-    if (!Object.keys(border).length || !border.size) {
-      attributes = {
-        "w:val": "nil"
-      };
-    } else {
-      attributes = {
-        "w:val": "single",
-        "w:sz": pixelsToEightPoints(border.size),
-        "w:space": border.space || 0,
-        "w:color": border?.color?.substring(1) || "000000"
-      };
-    }
-    const borderElement = {
-      name: `w:${type2}`,
-      attributes
-    };
-    elements.push(borderElement);
-  });
-  return {
-    name: "w:tblBorders",
-    elements
-  };
-}
-function generateTableGrid(node, params) {
-  const { editorSchema } = params;
-  let colgroup = [];
-  try {
-    const pmNode = editorSchema.nodeFromJSON(node);
-    const cellMinWidth = 10;
-    const { colgroupValues } = createColGroup(pmNode, cellMinWidth);
-    colgroup = colgroupValues;
-  } catch {
-    colgroup = [];
-  }
-  const elements = [];
-  colgroup?.forEach((width) => {
-    elements.push({
-      name: "w:gridCol",
-      attributes: { "w:w": pixelsToTwips(width) }
-    });
-  });
-  return {
-    name: "w:tblGrid",
-    elements
-  };
-}
-function translateBookmarkStart(params) {
-  const bookmarkStartNode = {
-    name: "w:bookmarkStart",
-    attributes: {
-      "w:id": params.node.attrs.id,
-      "w:name": params.node.attrs.name
-    }
-  };
-  const bookmarkEndNode = {
-    name: "w:bookmarkEnd",
-    attributes: {
-      "w:id": params.node.attrs.id
-    }
-  };
-  return [bookmarkStartNode, bookmarkEndNode];
-}
 function translateMark(mark) {
   const xmlMark = SuperConverter.markTypes.find((m2) => m2.type === mark.type);
   if (!xmlMark) {
@@ -28785,356 +29936,30 @@ function translateMark(mark) {
       markElement.attributes["w:val"] = processedColor;
       break;
     case "textAlign":
-      markElement.attributes["w:val"] = attrs.textAlign;
-      break;
-    case "textIndent":
-      markElement.attributes["w:firstline"] = inchesToTwips(attrs.textIndent);
-      break;
-    case "textTransform":
-      if (attrs?.textTransform === "none") {
-        markElement.attributes["w:val"] = "0";
-      } else {
-        delete markElement.attributes;
-      }
-      markElement.type = "element";
-      break;
-    case "lineHeight":
-      markElement.attributes["w:line"] = linesToTwips(attrs.lineHeight);
-      break;
-    case "highlight":
-      markElement.attributes["w:fill"] = attrs.color?.substring(1);
-      markElement.attributes["w:color"] = "auto";
-      markElement.attributes["w:val"] = "clear";
-      markElement.name = "w:shd";
-      break;
-  }
-  return markElement;
-}
-function getPngDimensions(base64) {
-  if (!base64) return {};
-  const type2 = base64.split(";")[0].split("/")[1];
-  if (!base64 || type2 !== "png") {
-    return {
-      originalWidth: void 0,
-      originalHeight: void 0
-    };
-  }
-  let header = base64.split(",")[1].slice(0, 50);
-  let uint8 = Uint8Array.from(atob(header), (c) => c.charCodeAt(0));
-  let dataView = new DataView(uint8.buffer, 0, 28);
-  return {
-    originalWidth: dataView.getInt32(16),
-    originalHeight: dataView.getInt32(20)
-  };
-}
-function getScaledSize(originalWidth, originalHeight, maxWidth, maxHeight) {
-  let scaledWidth = originalWidth;
-  let scaledHeight = originalHeight;
-  let ratio = Math.min(maxWidth / originalWidth, maxHeight / originalHeight);
-  scaledWidth = Math.round(scaledWidth * ratio);
-  scaledHeight = Math.round(scaledHeight * ratio);
-  return { scaledWidth, scaledHeight };
-}
-function translateImageNode(params, imageSize) {
-  const {
-    node: { attrs = {} },
-    tableCell
-  } = params;
-  let imageId = attrs.rId;
-  const src = attrs.src || attrs.imageSrc;
-  const { originalWidth, originalHeight } = getPngDimensions(src);
-  const imageName = params.node.type === "image" ? src.split("/").pop() : attrs.fieldId?.replace("-", "_");
-  let size = attrs.size ? {
-    w: pixelsToEmu(attrs.size.width),
-    h: pixelsToEmu(attrs.size.height)
-  } : imageSize;
-  if (originalWidth && originalHeight) {
-    const boxWidthPx = emuToPixels(size.w);
-    const boxHeightPx = emuToPixels(size.h);
-    const { scaledWidth, scaledHeight } = getScaledSize(originalWidth, originalHeight, boxWidthPx, boxHeightPx);
-    size = {
-      w: pixelsToEmu(scaledWidth),
-      h: pixelsToEmu(scaledHeight)
-    };
-  }
-  if (tableCell) {
-    const colwidthSum = tableCell.attrs.colwidth.reduce((acc, curr) => acc + curr, 0);
-    const leftMargin = tableCell.attrs.cellMargins?.left || 8;
-    const rightMargin = tableCell.attrs.cellMargins?.right || 8;
-    const maxWidthEmu = pixelsToEmu(colwidthSum - (leftMargin + rightMargin));
-    const { width: w2, height: h2 } = resizeKeepAspectRatio(size.w, size.h, maxWidthEmu);
-    if (w2 && h2) size = { w: w2, h: h2 };
-  }
-  if (params.node.type === "image" && !imageId) {
-    const path = src?.split("word/")[1];
-    imageId = addNewImageRelationship(params, path);
-  } else if (params.node.type === "fieldAnnotation" && !imageId) {
-    const type2 = src?.split(";")[0].split("/")[1];
-    if (!type2) {
-      return prepareTextAnnotation(params);
-    }
-    const imageUrl = `media/${imageName}_${attrs.hash}.${type2}`;
-    imageId = addNewImageRelationship(params, imageUrl);
-    params.media[`${imageName}_${attrs.hash}.${type2}`] = src;
-  }
-  let inlineAttrs = attrs.originalPadding || {
-    distT: 0,
-    distB: 0,
-    distL: 0,
-    distR: 0
-  };
-  const anchorElements = [];
-  let wrapProp = [];
-  if (attrs.isAnchor) {
-    inlineAttrs = {
-      ...inlineAttrs,
-      simplePos: attrs.originalAttributes?.simplePos,
-      relativeHeight: 1,
-      behindDoc: attrs.originalAttributes?.behindDoc,
-      locked: attrs.originalAttributes?.locked,
-      layoutInCell: attrs.originalAttributes?.layoutInCell,
-      allowOverlap: attrs.originalAttributes?.allowOverlap
-    };
-    if (attrs.simplePos) {
-      anchorElements.push({
-        name: "wp:simplePos",
-        attributes: {
-          x: 0,
-          y: 0
-        }
-      });
-    }
-    if (attrs.anchorData) {
-      anchorElements.push({
-        name: "wp:positionH",
-        attributes: {
-          relativeFrom: attrs.anchorData.hRelativeFrom
-        },
-        ...attrs.marginOffset.left !== void 0 && {
-          elements: [
-            {
-              name: "wp:posOffset",
-              elements: [
-                {
-                  type: "text",
-                  text: pixelsToEmu(attrs.marginOffset.left).toString()
-                }
-              ]
-            }
-          ]
-        },
-        ...attrs.anchorData.alignH && {
-          elements: [
-            {
-              name: "wp:align",
-              elements: [
-                {
-                  type: "text",
-                  text: attrs.anchorData.alignH
-                }
-              ]
-            }
-          ]
-        }
-      });
-      anchorElements.push({
-        name: "wp:positionV",
-        attributes: {
-          relativeFrom: attrs.anchorData.vRelativeFrom
-        },
-        ...attrs.marginOffset.top !== void 0 && {
-          elements: [
-            {
-              name: "wp:posOffset",
-              elements: [
-                {
-                  type: "text",
-                  text: pixelsToEmu(attrs.marginOffset.top).toString()
-                }
-              ]
-            }
-          ]
-        },
-        ...attrs.anchorData.alignV && {
-          elements: [
-            {
-              name: "wp:align",
-              elements: [
-                {
-                  type: "text",
-                  text: attrs.anchorData.alignV
-                }
-              ]
-            }
-          ]
-        }
-      });
-    }
-    if (attrs.wrapText) {
-      wrapProp.push({
-        name: "wp:wrapSquare",
-        attributes: {
-          wrapText: attrs.wrapText
-        }
-      });
-    }
-    if (attrs.wrapTopAndBottom) {
-      wrapProp.push({
-        name: "wp:wrapTopAndBottom"
-      });
-    }
-    if (attrs.isAnchor && !wrapProp.length) {
-      wrapProp.push({
-        name: "wp:wrapNone"
-      });
-    }
+      markElement.attributes["w:val"] = attrs.textAlign;
+      break;
+    case "textIndent":
+      markElement.attributes["w:firstline"] = inchesToTwips(attrs.textIndent);
+      break;
+    case "textTransform":
+      if (attrs?.textTransform === "none") {
+        markElement.attributes["w:val"] = "0";
+      } else {
+        delete markElement.attributes;
+      }
+      markElement.type = "element";
+      break;
+    case "lineHeight":
+      markElement.attributes["w:line"] = linesToTwips(attrs.lineHeight);
+      break;
+    case "highlight":
+      markElement.attributes["w:fill"] = attrs.color?.substring(1);
+      markElement.attributes["w:color"] = "auto";
+      markElement.attributes["w:val"] = "clear";
+      markElement.name = "w:shd";
+      break;
   }
-  const drawingXmlns = "http://schemas.openxmlformats.org/drawingml/2006/main";
-  const pictureXmlns = "http://schemas.openxmlformats.org/drawingml/2006/picture";
-  const textNode = wrapTextInRun(
-    {
-      name: "w:drawing",
-      elements: [
-        {
-          name: attrs.isAnchor ? "wp:anchor" : "wp:inline",
-          attributes: inlineAttrs,
-          elements: [
-            ...anchorElements,
-            {
-              name: "wp:extent",
-              attributes: {
-                cx: size.w,
-                cy: size.h
-              }
-            },
-            {
-              name: "wp:effectExtent",
-              attributes: {
-                l: 0,
-                t: 0,
-                r: 0,
-                b: 0
-              }
-            },
-            ...wrapProp,
-            {
-              name: "wp:docPr",
-              attributes: {
-                id: attrs.id || 0,
-                name: attrs.alt || `Picture ${imageName}`
-              }
-            },
-            {
-              name: "wp:cNvGraphicFramePr",
-              elements: [
-                {
-                  name: "a:graphicFrameLocks",
-                  attributes: {
-                    "xmlns:a": drawingXmlns,
-                    noChangeAspect: 1
-                  }
-                }
-              ]
-            },
-            {
-              name: "a:graphic",
-              attributes: { "xmlns:a": drawingXmlns },
-              elements: [
-                {
-                  name: "a:graphicData",
-                  attributes: { uri: pictureXmlns },
-                  elements: [
-                    {
-                      name: "pic:pic",
-                      attributes: { "xmlns:pic": pictureXmlns },
-                      elements: [
-                        {
-                          name: "pic:nvPicPr",
-                          elements: [
-                            {
-                              name: "pic:cNvPr",
-                              attributes: {
-                                id: attrs.id || 0,
-                                name: attrs.title || `Picture ${imageName}`
-                              }
-                            },
-                            {
-                              name: "pic:cNvPicPr",
-                              elements: [
-                                {
-                                  name: "a:picLocks",
-                                  attributes: {
-                                    noChangeAspect: 1,
-                                    noChangeArrowheads: 1
-                                  }
-                                }
-                              ]
-                            }
-                          ]
-                        },
-                        {
-                          name: "pic:blipFill",
-                          elements: [
-                            {
-                              name: "a:blip",
-                              attributes: {
-                                "r:embed": imageId
-                              }
-                            },
-                            {
-                              name: "a:stretch",
-                              elements: [{ name: "a:fillRect" }]
-                            }
-                          ]
-                        },
-                        {
-                          name: "pic:spPr",
-                          attributes: {
-                            bwMode: "auto"
-                          },
-                          elements: [
-                            {
-                              name: "a:xfrm",
-                              elements: [
-                                {
-                                  name: "a:ext",
-                                  attributes: {
-                                    cx: size.w,
-                                    cy: size.h
-                                  }
-                                },
-                                {
-                                  name: "a:off",
-                                  attributes: {
-                                    x: 0,
-                                    y: 0
-                                  }
-                                }
-                              ]
-                            },
-                            {
-                              name: "a:prstGeom",
-                              attributes: { prst: "rect" },
-                              elements: [{ name: "a:avLst" }]
-                            },
-                            {
-                              name: "a:noFill"
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  ]
-                }
-              ]
-            }
-          ]
-        }
-      ]
-    },
-    []
-  );
-  return textNode;
+  return markElement;
 }
 function translateShapeContainer(params) {
   const { node } = params;
@@ -29313,14 +30138,6 @@ generateXml_fn = function(node) {
   if (!selfClosing) tags.push(`</${name}>`);
   return tags;
 };
-function resizeKeepAspectRatio(width, height, maxWidth) {
-  if (width > maxWidth) {
-    let scale = maxWidth / width;
-    let newHeight = Math.round(height * scale);
-    return { width: maxWidth, height: newHeight };
-  }
-  return { width, height };
-}
 const translatePageNumberNode = (params) => {
   const outputMarks = processOutputMarks(params.node.attrs?.marksAsAttrs || []);
   return getAutoPageJson("PAGE", outputMarks);
@@ -29404,7 +30221,7 @@ const getInitialJSON = (parsedDocx, fallbackXml = defaultInitialXml) => {
   return parsedDocx["word/document.xml"] || parseXmlToJson(fallbackXml);
 };
 const handleDrawingNode = (params) => {
-  const { nodes, filename } = params;
+  const { nodes } = params;
   const validNodes = ["w:drawing", "w:p"];
   if (nodes.length === 0 || !validNodes.includes(nodes[0].name)) {
     return { nodes: [], consumed: 0 };
@@ -29414,167 +30231,9 @@ const handleDrawingNode = (params) => {
   if (mainNode.name === "w:drawing") node = mainNode;
   else node = mainNode.elements.find((el) => el.name === "w:drawing");
   if (!node) return { nodes: [], consumed: 0 };
-  let result;
-  const { elements } = node;
-  const currentFileName = filename || null;
-  const isAnchor = elements.find((el) => el.name === "wp:anchor");
-  if (isAnchor) {
-    result = handleImageImport(elements[0], currentFileName, params);
-    if (result && result.attrs) result.attrs.isAnchor = isAnchor;
-  }
-  const inlineImage = elements.find((el) => el.name === "wp:inline");
-  if (inlineImage) result = handleImageImport(inlineImage, currentFileName, params);
-  return { nodes: result ? [result] : [], consumed: 1 };
-};
-function handleImageImport(node, currentFileName, params) {
-  const { docx } = params;
-  const { attributes } = node;
-  const padding = {
-    top: emuToPixels(attributes["distT"]),
-    bottom: emuToPixels(attributes["distB"]),
-    left: emuToPixels(attributes["distL"]),
-    right: emuToPixels(attributes["distR"])
-  };
-  const extent = node.elements.find((el) => el.name === "wp:extent");
-  const size = {
-    width: emuToPixels(extent.attributes?.cx),
-    height: emuToPixels(extent.attributes?.cy)
-  };
-  const graphic = node.elements.find((el) => el.name === "a:graphic");
-  const graphicData = graphic.elements.find((el) => el.name === "a:graphicData");
-  const { uri: uri2 } = graphicData?.attributes || {};
-  const shapeURI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
-  if (!!uri2 && uri2 === shapeURI) {
-    return handleShapeDrawing(params, node, graphicData);
-  }
-  const picture = graphicData.elements.find((el) => el.name === "pic:pic");
-  if (!picture || !picture.elements) return null;
-  const blipFill = picture.elements.find((el) => el.name === "pic:blipFill");
-  const blip = blipFill.elements.find((el) => el.name === "a:blip");
-  const positionHTag = node.elements.find((el) => el.name === "wp:positionH");
-  const positionH = positionHTag?.elements.find((el) => el.name === "wp:posOffset");
-  const positionHValue = emuToPixels(positionH?.elements[0]?.text);
-  const hRelativeFrom = positionHTag?.attributes.relativeFrom;
-  const alignH = positionHTag?.elements.find((el) => el.name === "wp:align")?.elements[0]?.text;
-  const positionVTag = node.elements.find((el) => el.name === "wp:positionV");
-  const positionV = positionVTag?.elements?.find((el) => el.name === "wp:posOffset");
-  const positionVValue = emuToPixels(positionV?.elements[0]?.text);
-  const vRelativeFrom = positionVTag?.attributes.relativeFrom;
-  const alignV = positionVTag?.elements?.find((el) => el.name === "wp:align")?.elements[0]?.text;
-  const simplePos = node.elements.find((el) => el.name === "wp:simplePos");
-  const wrapSquare = node.elements.find((el) => el.name === "wp:wrapSquare");
-  const wrapTopAndBottom = node.elements.find((el) => el.name === "wp:wrapTopAndBottom");
-  const docPr = node.elements.find((el) => el.name === "wp:docPr");
-  let anchorData = null;
-  if (hRelativeFrom || alignH || vRelativeFrom || alignV) {
-    anchorData = {
-      hRelativeFrom,
-      vRelativeFrom,
-      alignH,
-      alignV
-    };
-  }
-  const marginOffset = {
-    left: positionHValue,
-    top: positionVValue
-  };
-  const { attributes: blipAttributes = {} } = blip;
-  const rEmbed = blipAttributes["r:embed"];
-  if (!rEmbed) return null;
-  const currentFile = currentFileName || "document.xml";
-  let rels = docx[`word/_rels/${currentFile}.rels`];
-  if (!rels) rels = docx[`word/_rels/document.xml.rels`];
-  const relationships = rels.elements.find((el) => el.name === "Relationships");
-  const { elements } = relationships;
-  const rel = elements.find((el) => el.attributes["Id"] === rEmbed);
-  if (!rel) return null;
-  const { attributes: relAttributes } = rel;
-  const targetPath = relAttributes["Target"];
-  let path = `word/${targetPath}`;
-  if (targetPath.startsWith("/word") || targetPath.startsWith("/media")) path = targetPath.substring(1);
-  const extension = targetPath.substring(targetPath.lastIndexOf(".") + 1);
-  return {
-    type: "image",
-    attrs: {
-      src: path,
-      alt: ["emf", "wmf"].includes(extension) ? "Unable to render EMF/WMF image" : docPr?.attributes.name || "Image",
-      extension,
-      id: docPr?.attributes.id || "",
-      title: docPr?.attributes.descr || "Image",
-      inline: true,
-      padding,
-      marginOffset,
-      size,
-      anchorData,
-      ...simplePos && {
-        simplePos: {
-          x: simplePos.attributes.x,
-          y: simplePos.attributes.y
-        }
-      },
-      ...wrapSquare && {
-        wrapText: wrapSquare.attributes.wrapText
-      },
-      wrapTopAndBottom: !!wrapTopAndBottom,
-      originalPadding: {
-        distT: attributes["distT"],
-        distB: attributes["distB"],
-        distL: attributes["distL"],
-        distR: attributes["distR"]
-      },
-      originalAttributes: node.attributes,
-      rId: relAttributes["Id"]
-    }
-  };
-}
-const handleShapeDrawing = (params, node, graphicData) => {
-  const wsp = graphicData.elements.find((el) => el.name === "wps:wsp");
-  const textBox = wsp.elements.find((el) => el.name === "wps:txbx");
-  const textBoxContent = textBox?.elements?.find((el) => el.name === "w:txbxContent");
-  node.elements.find((el) => el.name === "wp:docPr");
-  const spPr = wsp.elements.find((el) => el.name === "wps:spPr");
-  const prstGeom = spPr?.elements.find((el) => el.name === "a:prstGeom");
-  if (!!prstGeom && prstGeom.attributes["prst"] === "rect" && !textBoxContent) {
-    return getRectangleShape(params, spPr);
-  }
-  if (!textBoxContent) {
-    return null;
-  }
-  const { nodeListHandler } = params;
-  const translatedElement = nodeListHandler.handler({
-    ...params,
-    node: textBoxContent.elements[0],
-    nodes: textBoxContent.elements,
-    path: [...params.path || [], textBoxContent]
-  });
-  return translatedElement[0];
-};
-const getRectangleShape = (params, node) => {
-  const schemaAttrs = {};
-  const [drawingNode] = params.nodes;
-  if (drawingNode?.name === "w:drawing") {
-    schemaAttrs.drawingContent = drawingNode;
-  }
-  const xfrm = node.elements.find((el) => el.name === "a:xfrm");
-  const start = xfrm.elements.find((el) => el.name === "a:off");
-  const size = xfrm.elements.find((el) => el.name === "a:ext");
-  const solidFill = node.elements.find((el) => el.name === "a:solidFill");
-  node.elements.find((el) => el.name === "a:ln");
-  const rectangleSize = {
-    top: emuToPixels(start.attributes["y"]),
-    left: emuToPixels(start.attributes["x"]),
-    width: emuToPixels(size.attributes["cx"]),
-    height: emuToPixels(size.attributes["cy"])
-  };
-  schemaAttrs.size = rectangleSize;
-  const background = solidFill?.elements[0]?.attributes["val"];
-  if (background) {
-    schemaAttrs.background = "#" + background;
-  }
-  return {
-    type: "contentBlock",
-    attrs: schemaAttrs
-  };
+  const schemaNode = translator$1.encode(params);
+  const newNodes = schemaNode ? [schemaNode] : [];
+  return { nodes: newNodes, consumed: 1 };
 };
 const drawingNodeHandlerEntity = {
   handlerName: "drawingNodeHandler",
@@ -29674,7 +30333,7 @@ const trackChangeNodeHandlerEntity = {
   handlerName: "trackChangeNodeHandler",
   handler: handleTrackChangeNode
 };
-const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$1);
+const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$6);
 const handleRunNode = (params) => {
   const { nodes, nodeListHandler, parentStyleId, docx } = params;
   if (nodes.length === 0 || nodes[0].name !== "w:r") {
@@ -29786,7 +30445,7 @@ const handleParagraphNode = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$h.encode(params);
+  const schemaNode = translator$T.encode(params);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -29889,7 +30548,7 @@ const handler = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$j.encode(params);
+  const result = translator$V.encode(params);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -29953,9 +30612,53 @@ const handleBookmarkNode = (params) => {
   }
   return result;
 };
-const bookmarkNodeHandlerEntity = {
-  handlerName: "bookmarkNodeHandler",
-  handler: handleBookmarkNode
+const handleBookmarkStartNode = (params) => {
+  const { nodes } = params;
+  if (!nodes.length || nodes[0].name !== "w:bookmarkStart") {
+    return { nodes: [], consumed: 0 };
+  }
+  if (isCustomMarkBookmark(nodes[0], params.editor)) {
+    return handleBookmarkNode(params);
+  }
+  const node = translator$3.encode(params);
+  if (!node) return { nodes: [], consumed: 0 };
+  return { nodes: [node], consumed: 1 };
+};
+const isCustomMarkBookmark = (bookmarkStartNode, editor) => {
+  if (!bookmarkStartNode?.attributes || !editor?.extensionService?.extensions) {
+    return false;
+  }
+  const rawBookmarkName = bookmarkStartNode.attributes["w:name"];
+  if (!rawBookmarkName || typeof rawBookmarkName !== "string") {
+    return false;
+  }
+  const [bookmarkName, ...bookmarkPayloadParts] = rawBookmarkName.split(";");
+  if (!bookmarkName) {
+    return false;
+  }
+  const customMarks = editor.extensionService.extensions.filter((extension) => extension.isExternal === true);
+  const matchesCustomMarkName = customMarks.some((mark) => mark.name === bookmarkName);
+  if (!matchesCustomMarkName) {
+    return false;
+  }
+  return bookmarkPayloadParts.some((part) => part && part.includes("="));
+};
+const bookmarkStartNodeHandlerEntity = {
+  handlerName: "w:bookmarkStartTranslator",
+  handler: handleBookmarkStartNode
+};
+const handleBookmarkEndNode = (params) => {
+  const { nodes } = params;
+  if (!nodes.length || nodes[0].name !== "w:bookmarkEnd") {
+    return { nodes: [], consumed: 0 };
+  }
+  const node = translator$2.encode(params);
+  if (!node) return { nodes: [], consumed: 0 };
+  return { nodes: [node], consumed: 1 };
+};
+const bookmarkEndNodeHandlerEntity = {
+  handlerName: "w:bookmarkEndTranslator",
+  handler: handleBookmarkEndNode
 };
 const handleAlternateChoice = (params) => {
   const skipHandlerResponse = { nodes: [], consumed: 0 };
@@ -30585,7 +31288,7 @@ const handleTabNode = (params) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$i.encode(params);
+  const node = translator$U.encode(params);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
@@ -30668,7 +31371,8 @@ const defaultNodeListHandler = () => {
     textNodeHandlerEntity,
     lineBreakNodeHandlerEntity,
     sdtNodeHandlerEntity,
-    bookmarkNodeHandlerEntity,
+    bookmarkStartNodeHandlerEntity,
+    bookmarkEndNodeHandlerEntity,
     hyperlinkNodeHandlerEntity,
     drawingNodeHandlerEntity,
     trackChangeNodeHandlerEntity,
@@ -30890,8 +31594,8 @@ function addDefaultStylesIfMissing(styles) {
 }
 const importHeadersFooters = (docx, converter, mainEditor) => {
   const rels = docx["word/_rels/document.xml.rels"];
-  const relationships = rels.elements.find((el) => el.name === "Relationships");
-  const { elements } = relationships;
+  const relationships = rels?.elements.find((el) => el.name === "Relationships");
+  const { elements } = relationships || { elements: [] };
   const headerType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header";
   const footerType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer";
   const headers = elements.filter((el) => el.attributes["Type"] === headerType);
@@ -30975,6 +31679,7 @@ function filterOutRootInlineNodes(content = []) {
   const INLINE_TYPES = /* @__PURE__ */ new Set([
     "text",
     "bookmarkStart",
+    "bookmarkEnd",
     "lineBreak",
     "hardBreak",
     "pageNumber",
@@ -31665,15 +32370,12 @@ export {
   createDocFromMarkdown as a7,
   createDocFromHTML as a8,
   EditorState as a9,
-  vClickOutside as aA,
-  getActiveFormatting as aB,
-  readFromClipboard as aC,
-  handleClipboardPaste as aD,
-  getFileObject as aE,
-  translator$h as aF,
-  translator$i as aG,
-  translator$j as aH,
-  _sfc_main as aI,
+  getActiveFormatting as aA,
+  readFromClipboard as aB,
+  handleClipboardPaste as aC,
+  getFileObject as aD,
+  _sfc_main as aE,
+  registeredHandlers as aF,
   hasSomeParentWithClass as aa,
   isActive as ab,
   unflattenListsInHtml as ac,
@@ -31688,18 +32390,18 @@ export {
   parseIndentElement as al,
   combineIndents as am,
   StepMap as an,
-  getColStyleDeclaration as ao,
-  SelectionRange as ap,
-  Transform as aq,
-  isInTable as ar,
-  createColGroup as as,
-  generateDocxRandomId as at,
-  insertNewRelationship as au,
-  htmlHandler as av,
-  commonjsGlobal as aw,
-  getDefaultExportFromCjs$1 as ax,
-  getContentTypesFromXml as ay,
-  xmljs as az,
+  SelectionRange as ao,
+  Transform as ap,
+  isInTable as aq,
+  generateDocxRandomId as ar,
+  insertNewRelationship as as,
+  updateDOMAttributes as at,
+  htmlHandler as au,
+  commonjsGlobal as av,
+  getDefaultExportFromCjs$1 as aw,
+  getContentTypesFromXml as ax,
+  xmljs as ay,
+  vClickOutside as az,
   Slice as b,
   DOMParser$1 as c,
   Mark as d,