@harbour-enterprises/superdoc 0.20.0-next.5 → 0.20.0-next.6

package/dist/chunks/{super-editor.es-BgBNGRxg.cjs → super-editor.es-BIW7iKAk.cjs}

@@ -16411,41 +16411,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(index2, offset2) {
@@ -24215,46 +24180,6 @@ const baseNumbering = {
     }
   ]
 };
-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 offset2 = 1; offset2 < maxRowspan; offset2++) {
-        const rowToChange = rows[rowIndex + offset2];
-        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 TranslatorTypes = Object.freeze({
   NODE: "node",
   ATTRIBUTE: "attribute"
@@ -24375,37 +24300,37 @@ const _NodeTranslator = class _NodeTranslator2 {
 };
 __publicField$2(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$m = (attributes) => {
+const encode$r = (attributes) => {
   return attributes["w:type"];
 };
-const decode$m = (attrs) => {
+const decode$r = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
 const attrConfig$b = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$m,
-  decode: decode$m
+  encode: encode$r,
+  decode: decode$r
 });
-const encode$l = (attributes) => {
+const encode$q = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$l = (attrs) => {
+const decode$q = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
 const attrConfig$a = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$l,
-  decode: decode$l
+  encode: encode$q,
+  decode: decode$q
 });
 const validXmlAttributes$9 = [attrConfig$b, attrConfig$a];
-const XML_NODE_NAME$a = "w:br";
-const SD_NODE_NAME$9 = "lineBreak";
-const encode$k = (_2, encodedAttrs) => {
+const XML_NODE_NAME$f = "w:br";
+const SD_NODE_NAME$a = "lineBreak";
+const encode$p = (_2, encodedAttrs) => {
   const isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -24415,7 +24340,7 @@ const encode$k = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$k = (params2, decodedAttrs) => {
+const decode$p = (params2, decodedAttrs) => {
   const { node } = params2;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24432,63 +24357,63 @@ const decode$k = (params2, decodedAttrs) => {
   };
   return translated;
 };
-const config$a = {
-  xmlName: XML_NODE_NAME$a,
-  sdNodeOrKeyName: SD_NODE_NAME$9,
+const config$d = {
+  xmlName: XML_NODE_NAME$f,
+  sdNodeOrKeyName: SD_NODE_NAME$a,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$k,
-  decode: decode$k,
+  encode: encode$p,
+  decode: decode$p,
   attributes: validXmlAttributes$9
 };
-const translator$m = NodeTranslator.from(config$a);
-const encode$j = (attributes) => {
+const translator$T = NodeTranslator.from(config$d);
+const encode$o = (attributes) => {
   return attributes["w:val"];
 };
-const decode$j = (attrs) => {
+const decode$o = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
 const attrConfig$9 = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$j,
-  decode: decode$j
+  encode: encode$o,
+  decode: decode$o
 });
-const encode$i = (attributes) => {
+const encode$n = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$i = (attrs) => {
+const decode$n = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
 const attrConfig$8 = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$i,
-  decode: decode$i
+  encode: encode$n,
+  decode: decode$n
 });
-const encode$h = (attributes) => {
+const encode$m = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$h = (attrs) => {
+const decode$m = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
 const attrConfig$7 = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$h,
-  decode: decode$h
+  encode: encode$m,
+  decode: decode$m
 });
 const validXmlAttributes$8 = [attrConfig$9, attrConfig$7, attrConfig$8];
-const XML_NODE_NAME$9 = "w:tab";
-const SD_NODE_NAME$8 = "tab";
-const encode$g = (_2, encodedAttrs = {}) => {
+const XML_NODE_NAME$e = "w:tab";
+const SD_NODE_NAME$9 = "tab";
+const encode$l = (_2, encodedAttrs = {}) => {
   const translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$g = (params2, decodedAttrs = {}) => {
+const decode$l = (params2, decodedAttrs = {}) => {
   const { node } = params2 || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24504,15 +24429,15 @@ const decode$g = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$9 = {
-  xmlName: XML_NODE_NAME$9,
-  sdNodeOrKeyName: SD_NODE_NAME$8,
+const config$c = {
+  xmlName: XML_NODE_NAME$e,
+  sdNodeOrKeyName: SD_NODE_NAME$9,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$g,
-  decode: decode$g,
+  encode: encode$l,
+  decode: decode$l,
   attributes: validXmlAttributes$8
 };
-const translator$l = NodeTranslator.from(config$9);
+const translator$S = NodeTranslator.from(config$c);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -25082,89 +25007,89 @@ const handleParagraphNode$1 = (params2) => {
   }
   return schemaNode;
 };
-const encode$f = (attributes) => {
+const encode$k = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$f = (attrs) => {
+const decode$k = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$6 = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$f,
-  decode: decode$f
+  encode: encode$k,
+  decode: decode$k
 });
-const encode$e = (attributes) => {
+const encode$j = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$e = (attrs) => {
+const decode$j = (attrs) => {
   return attrs.rsidP;
 };
 const attrConfig$5 = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$e,
-  decode: decode$e
+  encode: encode$j,
+  decode: decode$j
 });
-const encode$d = (attributes) => {
+const encode$i = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$d = (attrs) => {
+const decode$i = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$4 = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$d,
-  decode: decode$d
+  encode: encode$i,
+  decode: decode$i
 });
-const encode$c = (attributes) => {
+const encode$h = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$c = (attrs) => {
+const decode$h = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$3 = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$c,
-  decode: decode$c
+  encode: encode$h,
+  decode: decode$h
 });
-const encode$b = (attributes) => {
+const encode$g = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$b = (attrs) => {
+const decode$g = (attrs) => {
   return attrs.rsidRDefault;
 };
 const attrConfig$2 = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$b,
-  decode: decode$b
+  encode: encode$g,
+  decode: decode$g
 });
-const encode$a = (attributes) => {
+const encode$f = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$a = (attrs) => {
+const decode$f = (attrs) => {
   return attrs.paraId;
 };
 const attrConfig$1 = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$a,
-  decode: decode$a
+  encode: encode$f,
+  decode: decode$f
 });
-const encode$9 = (attributes) => {
+const encode$e = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$9 = (attrs) => {
+const decode$e = (attrs) => {
   return attrs.textId;
 };
 const attrConfig = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$9,
-  decode: decode$9
+  encode: encode$e,
+  decode: decode$e
 });
 const validXmlAttributes$7 = [
   attrConfig$1,
@@ -25175,9 +25100,9 @@ const validXmlAttributes$7 = [
   attrConfig$3,
   attrConfig$6
 ];
-const XML_NODE_NAME$8 = "w:p";
-const SD_NODE_NAME$7 = "paragraph";
-const encode$8 = (params2, encodedAttrs = {}) => {
+const XML_NODE_NAME$d = "w:p";
+const SD_NODE_NAME$8 = "paragraph";
+const encode$d = (params2, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params2);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25185,7 +25110,7 @@ const encode$8 = (params2, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$8 = (params2, decodedAttrs = {}) => {
+const decode$d = (params2, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params2);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25193,15 +25118,15 @@ const decode$8 = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$8 = {
-  xmlName: XML_NODE_NAME$8,
-  sdNodeOrKeyName: SD_NODE_NAME$7,
+const config$b = {
+  xmlName: XML_NODE_NAME$d,
+  sdNodeOrKeyName: SD_NODE_NAME$8,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$8,
-  decode: decode$8,
+  encode: encode$d,
+  decode: decode$d,
   attributes: validXmlAttributes$7
 };
-const translator$k = NodeTranslator.from(config$8);
+const translator$R = NodeTranslator.from(config$b);
 const generateV2HandlerEntity = (handlerName, translator2) => ({
   handlerName,
   handler: (params2) => {
@@ -25229,7 +25154,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;
     }
   };
 }
@@ -25247,7 +25172,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: (_2, encodedAttrs) => {
+      return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
+    },
+    decode: function({ node }, _2) {
+      const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs[sdName] || {} } });
+      return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
     }
   };
 }
@@ -25290,15 +25240,17 @@ function decodeProperties(translatorsBySdName, properties) {
   Object.keys(properties).forEach((key2) => {
     const translator2 = translatorsBySdName[key2];
     if (translator2) {
-      const attributes = translator2.decode({ node: { attrs: { [key2]: properties[key2] } } });
-      if (attributes != null) {
-        elements.push({ name: translator2.xmlName, attributes });
+      const result = translator2.decode({ node: { attrs: { [key2]: properties[key2] } } });
+      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);
@@ -25308,13 +25260,53 @@ const integerToString = (value) => {
   const intValue = parseInteger(value);
   return intValue != void 0 ? String(intValue) : void 0;
 };
-const translator$j = 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 offset2 = 1; offset2 < maxRowspan; offset2++) {
+        const rowToChange = rows[rowIndex + offset2];
+        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$Q = 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$i = NodeTranslator.from({
+const translator$P = NodeTranslator.from({
   xmlName: "w:cnfStyle",
   sdNodeOrKeyName: "cnfStyle",
   attributes: [
@@ -25329,26 +25321,19 @@ const translator$i = 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((key2) => {
-      encodedAttrs[key2] = ["1", "true"].includes(encodedAttrs[key2]);
-    });
     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(([key2, value]) => {
-      cnfStyleAttrs[`w:${key2}`] = 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$h = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
-const translator$g = NodeTranslator.from(
+const translator$O = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
+const translator$N = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridAfter",
     null,
@@ -25357,7 +25342,7 @@ const translator$g = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$f = NodeTranslator.from(
+const translator$M = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridBefore",
     null,
@@ -25366,21 +25351,21 @@ const translator$f = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$e = NodeTranslator.from({
+const translator$L = 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$d = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc"));
-const translator$c = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "cellSpacing"));
-const translator$b = NodeTranslator.from({
+const translator$K = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc", "justification"));
+const translator$J = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
+const translator$I = 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$a = NodeTranslator.from({
+const translator$H = NodeTranslator.from({
   xmlName: "w:trHeight",
   sdNodeOrKeyName: "rowHeight",
   encode: ({ nodes }) => {
@@ -25404,14 +25389,14 @@ const translator$a = 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$9 = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
-const translator$8 = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
-const XML_NODE_NAME$7 = "w:trPr";
-const SD_ATTR_KEY = "tableRowProperties";
-const encode$7 = (params2) => {
+const translator$G = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
+const translator$F = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
+const XML_NODE_NAME$c = "w:trPr";
+const SD_ATTR_KEY$4 = "tableRowProperties";
+const encode$c = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
   let attributes = {
@@ -25421,18 +25406,18 @@ const encode$7 = (params2) => {
   };
   attributes = {
     ...attributes,
-    ...encodeProperties(node, propertyTranslatorsByXmlName)
+    ...encodeProperties(node, propertyTranslatorsByXmlName$2)
   };
   return {
     type: NodeTranslator.translatorTypes.ATTRIBUTE,
-    xmlName: XML_NODE_NAME$7,
-    sdNodeOrKeyName: SD_ATTR_KEY,
+    xmlName: XML_NODE_NAME$c,
+    sdNodeOrKeyName: SD_ATTR_KEY$4,
     attributes
   };
 };
-const decode$7 = (params2) => {
+const decode$c = (params2) => {
   const { tableRowProperties = {} } = params2.node.attrs || {};
-  const elements = decodeProperties(propertyTranslatorsBySdName, tableRowProperties);
+  const elements = decodeProperties(propertyTranslatorsBySdName$2, tableRowProperties);
   const newNode = {
     name: "w:trPr",
     type: "element",
@@ -25441,47 +25426,47 @@ const decode$7 = (params2) => {
   };
   return newNode;
 };
-const propertyTranslators = [
-  translator$j,
-  translator$i,
-  translator$h,
-  translator$g,
-  translator$f,
-  translator$e,
-  translator$d,
-  translator$c,
-  translator$b,
-  translator$a,
-  translator$9,
-  translator$8
+const propertyTranslators$3 = [
+  translator$Q,
+  translator$P,
+  translator$O,
+  translator$N,
+  translator$M,
+  translator$L,
+  translator$K,
+  translator$J,
+  translator$I,
+  translator$H,
+  translator$G,
+  translator$F
 ];
-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$7 = {
-  xmlName: XML_NODE_NAME$7,
-  sdNodeOrKeyName: SD_ATTR_KEY,
+const config$a = {
+  xmlName: XML_NODE_NAME$c,
+  sdNodeOrKeyName: SD_ATTR_KEY$4,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$7,
-  decode: decode$7
+  encode: encode$c,
+  decode: decode$c
 };
-const translator$7 = NodeTranslator.from(config$7);
-const XML_NODE_NAME$6 = "w:tr";
-const SD_NODE_NAME$6 = "tableRow";
+const translator$E = NodeTranslator.from(config$a);
+const XML_NODE_NAME$b = "w:tr";
+const SD_NODE_NAME$7 = "tableRow";
 const validXmlAttributes$6 = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
   (xmlName) => createAttributeHandler(xmlName)
 );
-const encode$6 = (params2, encodedAttrs) => {
-  const { row, table } = params2.extraParams;
+const encode$b = (params2, encodedAttrs) => {
+  const { row } = params2.extraParams;
   let tableRowProperties = {};
   const tPr = row.elements.find((el) => el.name === "w:trPr");
   if (tPr) {
-    ({ attributes: tableRowProperties } = translator$7.encode({
+    ({ attributes: tableRowProperties } = translator$E.encode({
       ...params2,
       nodes: [tPr]
     }));
@@ -25489,7 +25474,7 @@ const encode$6 = (params2, encodedAttrs) => {
   encodedAttrs["tableRowProperties"] = Object.freeze(tableRowProperties);
   encodedAttrs["rowHeight"] = twipsToPixels(tableRowProperties["rowHeight"]?.value);
   encodedAttrs["cantSplit"] = tableRowProperties["cantSplit"];
-  const gridColumnWidths = _getGridColumnWidths(table);
+  const { columnWidths: gridColumnWidths } = params2.extraParams;
   const cellNodes = row.elements.filter((el) => el.name === "w:tc");
   let currentColumnIndex = 0;
   const content = cellNodes?.map((n) => {
@@ -25516,16 +25501,7 @@ const encode$6 = (params2, 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$6 = (params2, decodedAttrs) => {
+const decode$b = (params2, decodedAttrs) => {
   const { node } = params2;
   const elements = translateChildNodes(params2);
   if (node.attrs?.tableRowProperties) {
@@ -25537,7 +25513,7 @@ const decode$6 = (params2, decodedAttrs) => {
       }
     }
     tableRowProperties["cantSplit"] = node.attrs["cantSplit"];
-    const trPr = translator$7.decode({
+    const trPr = translator$E.decode({
       ...params2,
       node: { ...node, attrs: { ...node.attrs, tableRowProperties } }
     });
@@ -25549,86 +25525,348 @@ const decode$6 = (params2, decodedAttrs) => {
     elements
   };
 };
-const config$6 = {
-  xmlName: XML_NODE_NAME$6,
-  sdNodeOrKeyName: SD_NODE_NAME$6,
+const config$9 = {
+  xmlName: XML_NODE_NAME$b,
+  sdNodeOrKeyName: SD_NODE_NAME$7,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$6,
-  decode: decode$6,
+  encode: encode$b,
+  decode: decode$b,
   attributes: validXmlAttributes$6
 };
-const translator$6 = NodeTranslator.from(config$6);
-const handleAllTableNodes = (params2) => {
-  const { nodes } = params2;
-  if (nodes.length === 0) {
-    return { nodes: [], consumed: 0 };
+const translator$D = NodeTranslator.from(config$9);
+const translator$C = 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$B = 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: (_2, encodedAttrs) => {
+    return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
+  },
+  decode: function({ node }, _2) {
+    const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs.shading || {} } });
+    return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
   }
+});
+const translator$A = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblCaption", "caption"));
+const translator$z = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblDescription", "description"));
+const translator$y = NodeTranslator.from(createMeasurementPropertyHandler("w:tblInd", "tableIndent"));
+const translator$x = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblLayout", "tableLayout", "w:type"));
+const translator$w = 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: (_2, encodedAttrs) => {
+    return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
+  },
+  decode: function({ node }, _2) {
+    const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs.tblLook || {} } });
+    return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
+  }
+});
+const translator$v = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblOverlap", "overlap"));
+const translator$u = NodeTranslator.from(createSingleAttrPropertyHandler("w:tblStyle", "tableStyleId"));
+const translator$t = NodeTranslator.from(
+  createSingleAttrPropertyHandler("w:tblStyleColBandSize", "tableStyleColBandSize")
+);
+const translator$s = NodeTranslator.from(
+  createSingleAttrPropertyHandler("w:tblStyleRowBandSize", "tableStyleRowBandSize")
+);
+const translator$r = NodeTranslator.from(createMeasurementPropertyHandler("w:tblW", "tableWidth"));
+const translator$q = 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: (_2, encodedAttrs) => {
+    return Object.keys(encodedAttrs).length > 0 ? encodedAttrs : void 0;
+  },
+  decode: function({ node }, _2) {
+    const decodedAttrs = this.decodeAttributes({ node: { ...node, attrs: node.attrs.floatingTableProperties || {} } });
+    return Object.keys(decodedAttrs).length > 0 ? { attributes: decodedAttrs } : void 0;
+  }
+});
+const translator$p = NodeTranslator.from(createBorderPropertyHandler("w:bottom"));
+const translator$o = NodeTranslator.from(createMeasurementPropertyHandler("w:bottom", "marginBottom"));
+const translator$n = NodeTranslator.from(createBorderPropertyHandler("w:end"));
+const translator$m = NodeTranslator.from(createMeasurementPropertyHandler("w:end", "marginEnd"));
+const translator$l = NodeTranslator.from(createBorderPropertyHandler("w:insideH"));
+const translator$k = NodeTranslator.from(createBorderPropertyHandler("w:insideV"));
+const translator$j = NodeTranslator.from(createBorderPropertyHandler("w:left"));
+const translator$i = NodeTranslator.from(createMeasurementPropertyHandler("w:left", "marginLeft"));
+const translator$h = NodeTranslator.from(createBorderPropertyHandler("w:right"));
+const translator$g = NodeTranslator.from(createMeasurementPropertyHandler("w:right", "marginRight"));
+const translator$f = NodeTranslator.from(createBorderPropertyHandler("w:start"));
+const translator$e = NodeTranslator.from(createMeasurementPropertyHandler("w:start", "marginStart"));
+const translator$d = NodeTranslator.from(createBorderPropertyHandler("w:top"));
+const translator$c = NodeTranslator.from(createMeasurementPropertyHandler("w:top", "marginTop"));
+const XML_NODE_NAME$a = "w:tblBorders";
+const SD_ATTR_KEY$3 = "borders";
+const encode$a = (params2, _2) => {
+  const { nodes } = params2;
   const node = nodes[0];
-  switch (node.name) {
-    case "w:tbl":
-      return { nodes: [handleTableNode(node, params2)], consumed: 1 };
+  const attributes = encodeProperties(node, tblBordersTranslatorsByXmlName);
+  return Object.keys(attributes).length > 0 ? attributes : void 0;
+};
+const decode$a = (params2, _2) => {
+  const { borders = {} } = params2.node.attrs || {};
+  const elements = decodeProperties(tblBordersTranslatorsBySdName, borders);
+  const newNode = {
+    name: "w:tblBorders",
+    type: "element",
+    attributes: {},
+    elements
+  };
+  return newNode;
+};
+const propertyTranslators$2 = [
+  translator$p,
+  translator$n,
+  translator$l,
+  translator$k,
+  translator$j,
+  translator$h,
+  translator$f,
+  translator$d
+];
+const tblBordersTranslatorsByXmlName = {};
+const tblBordersTranslatorsBySdName = {};
+propertyTranslators$2.forEach((translator2) => {
+  tblBordersTranslatorsByXmlName[translator2.xmlName] = translator2;
+  tblBordersTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
+});
+const translator$b = NodeTranslator.from({
+  xmlName: XML_NODE_NAME$a,
+  sdNodeOrKeyName: SD_ATTR_KEY$3,
+  type: NodeTranslator.translatorTypes.NODE,
+  attributes: [],
+  encode: encode$a,
+  decode: decode$a
+});
+const XML_NODE_NAME$9 = "w:tblCellMar";
+const SD_ATTR_KEY$2 = "cellMargins";
+const encode$9 = (params2, _2) => {
+  const { nodes } = params2;
+  const node = nodes[0];
+  const attributes = encodeProperties(node, propertyTranslatorsByXmlName$1);
+  return Object.keys(attributes).length > 0 ? attributes : void 0;
+};
+const decode$9 = (params2, _2) => {
+  const { cellMargins = {} } = params2.node.attrs || {};
+  const elements = decodeProperties(propertyTranslatorsBySdName$1, cellMargins);
+  const newNode = {
+    name: XML_NODE_NAME$9,
+    type: "element",
+    attributes: {},
+    elements
+  };
+  return newNode;
+};
+const propertyTranslators$1 = [
+  translator$o,
+  translator$m,
+  translator$i,
+  translator$g,
+  translator$e,
+  translator$c
+];
+const propertyTranslatorsByXmlName$1 = {};
+const propertyTranslatorsBySdName$1 = {};
+propertyTranslators$1.forEach((translator2) => {
+  propertyTranslatorsByXmlName$1[translator2.xmlName] = translator2;
+  propertyTranslatorsBySdName$1[translator2.sdNodeOrKeyName] = translator2;
+});
+const translator$a = NodeTranslator.from({
+  xmlName: XML_NODE_NAME$9,
+  sdNodeOrKeyName: SD_ATTR_KEY$2,
+  type: NodeTranslator.translatorTypes.NODE,
+  attributes: [],
+  encode: encode$9,
+  decode: decode$9
+});
+const XML_NODE_NAME$8 = "w:tblPr";
+const SD_ATTR_KEY$1 = "tableProperties";
+const encode$8 = (params2) => {
+  const { nodes } = params2;
+  const node = nodes[0];
+  const attributes = encodeProperties(node, propertyTranslatorsByXmlName);
+  return {
+    xmlName: XML_NODE_NAME$8,
+    sdNodeOrKeyName: SD_ATTR_KEY$1,
+    attributes
+  };
+};
+const decode$8 = (params2) => {
+  const { tableProperties = {} } = params2.node.attrs || {};
+  const elements = decodeProperties(propertyTranslatorsBySdName, tableProperties);
+  const newNode = {
+    name: "w:tblPr",
+    type: "element",
+    attributes: {},
+    elements
+  };
+  return newNode;
+};
+const propertyTranslators = [
+  translator$C,
+  translator$K,
+  translator$B,
+  translator$A,
+  translator$J,
+  translator$z,
+  translator$y,
+  translator$x,
+  translator$w,
+  translator$v,
+  translator$u,
+  translator$t,
+  translator$s,
+  translator$r,
+  translator$q,
+  translator$b,
+  translator$a
+];
+const propertyTranslatorsByXmlName = {};
+const propertyTranslatorsBySdName = {};
+propertyTranslators.forEach((translator2) => {
+  propertyTranslatorsByXmlName[translator2.xmlName] = translator2;
+  propertyTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
+});
+const config$8 = {
+  xmlName: XML_NODE_NAME$8,
+  sdNodeOrKeyName: SD_ATTR_KEY$1,
+  encode: encode$8,
+  decode: decode$8
+};
+const translator$9 = NodeTranslator.from(config$8);
+const translator$8 = NodeTranslator.from(
+  createSingleAttrPropertyHandler("w:gridCol", "col", "w:w", parseInteger, integerToString)
+);
+const XML_NODE_NAME$7 = "w:tblGrid";
+const SD_ATTR_KEY = "grid";
+const cellMinWidth = pixelsToTwips(10);
+const encode$7 = (params2) => {
+  const { nodes } = params2;
+  const node = nodes[0];
+  const attributes = encodeProperties(node, { [translator$8.xmlName]: translator$8 }, true);
+  return {
+    xmlName: XML_NODE_NAME$7,
+    sdNodeOrKeyName: SD_ATTR_KEY,
+    attributes
+  };
+};
+const decode$7 = (params2) => {
+  const { grid = [] } = params2.node.attrs || {};
+  const { firstRow = {} } = params2.extraParams || {};
+  const cellNodes = firstRow.content?.filter((n) => n.type === "tableCell") ?? [];
+  const numberOfColumns = cellNodes.length || grid.length;
+  const elements = [];
+  for (let cellIdx = 0; cellIdx < numberOfColumns; cellIdx++) {
+    const cell = cellNodes[cellIdx];
+    const { colspan = 1, colwidth } = cell?.attrs || {};
+    for (let mergedCellIdx = 0; mergedCellIdx < colspan; mergedCellIdx++) {
+      const cellWidthPixels = colwidth && colwidth[mergedCellIdx];
+      const colGridAttrs = grid?.[mergedCellIdx] || {};
+      const gridWidthTwips = colGridAttrs.col;
+      const gridWidthPixels = twipsToPixels(gridWidthTwips);
+      let cellWidthTwips;
+      if (gridWidthPixels === cellWidthPixels) {
+        cellWidthTwips = gridWidthTwips;
+      } else if (cellWidthPixels) {
+        cellWidthTwips = pixelsToTwips(cellWidthPixels);
+      }
+      const widthTwips = Math.max(cellWidthTwips, cellMinWidth);
+      elements.push(
+        translator$8.decode({
+          node: { type: (
+            /** @type {string} */
+            translator$8.sdNodeOrKeyName
+          ), attrs: { col: widthTwips } }
+        })
+      );
+    }
   }
-  return { nodes: [], consumed: 0 };
+  const newNode = {
+    name: XML_NODE_NAME$7,
+    attributes: {},
+    elements
+  };
+  return newNode;
 };
-const tableNodeHandlerEntity = {
-  handlerName: "tableNodeHandler",
-  handler: handleAllTableNodes
+const config$7 = {
+  xmlName: XML_NODE_NAME$7,
+  sdNodeOrKeyName: SD_ATTR_KEY,
+  encode: encode$7,
+  decode: decode$7
 };
-function handleTableNode(node, params2) {
-  const { docx, nodeListHandler } = params2;
+const translator$7 = NodeTranslator.from(config$7);
+const XML_NODE_NAME$6 = "w:tbl";
+const SD_NODE_NAME$6 = "table";
+const encode$6 = (params2, encodedAttrs) => {
+  const { nodes } = params2;
+  const node = nodes[0];
   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 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";
-  }
-  const tblJustification = tblPr.elements.find((el) => el.name === "w:jc");
-  if (tblJustification?.attributes) {
-    attrs["justification"] = tblJustification.attributes["w:val"];
+  if (tblPr) {
+    encodedAttrs["tableProperties"] = translator$9.encode({ ...params2, nodes: [tblPr] }).attributes;
+  }
+  const tblGrid = node.elements.find((el) => el.name === "w:tblGrid");
+  if (tblGrid) {
+    encodedAttrs["grid"] = translator$7.encode({ ...params2, nodes: [tblGrid] }).attributes;
   }
+  [
+    "tableStyleId",
+    "justification",
+    "tableLayout",
+    ["tableIndent", ({ value, type: type2 }) => ({ width: twipsToPixels(value), type: type2 })],
+    ["tableWidth", ({ value, type: type2 }) => ({ width: twipsToPixels(value), type: type2 })],
+    ["tableCellSpacing", ({ value, type: type2 }) => ({ w: String(value), type: type2 })]
+  ].forEach((prop) => {
+    let key2;
+    let transform;
+    if (Array.isArray(prop)) {
+      [key2, transform] = prop;
+    } else {
+      key2 = prop;
+      transform = (v2) => v2;
+    }
+    if (encodedAttrs.tableProperties?.[key2]) {
+      encodedAttrs[key2] = transform(encodedAttrs.tableProperties[key2]);
+    }
+  });
+  if (encodedAttrs.tableCellSpacing) {
+    encodedAttrs["borderCollapse"] = "separate";
+  }
+  const { borders, rowBorders } = _processTableBorders(encodedAttrs.tableProperties?.borders || {});
+  const referencedStyles = _getReferencedTableStyles(encodedAttrs.tableStyleId, params2);
   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 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$6.encode({
+    const result = translator$D.encode({
       ...params2,
       nodes: [row],
       extraParams: {
         row,
-        table: node,
         rowBorders: borderRowData,
-        styleTag: tblStyleTag
+        styleTag: tblStyleTag,
+        columnWidths
       }
     });
     if (result.content?.length) content.push(result);
@@ -25636,9 +25874,113 @@ function handleTableNode(node, params2) {
   return {
     type: "table",
     content,
-    attrs
+    attrs: encodedAttrs
+  };
+};
+const decode$6 = (params2, decodedAttrs) => {
+  params2.node = preProcessVerticalMergeCells(params2.node, params2);
+  const { node } = params2;
+  const elements = translateChildNodes(params2);
+  const firstRow = node.content?.find((n) => n.type === "tableRow");
+  const properties = node.attrs.grid;
+  const element = translator$7.decode({
+    ...params2,
+    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$9.decode({
+      ...params2,
+      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 size2 = attributes.size;
+    if (color && color !== "auto") attrs["color"] = color.startsWith("#") ? color : `#${color}`;
+    if (size2 && size2 !== "auto") attrs["size"] = eigthPointsToPixels(size2);
+    const rowBorderNames = ["insideH", "insideV"];
+    if (rowBorderNames.includes(name)) rowBorders[name] = attrs;
+    borders[name] = attrs;
+  });
+  return {
+    borders,
+    rowBorders
   };
 }
+function _getReferencedTableStyles(tableStyleReference, params2) {
+  if (!tableStyleReference) return null;
+  const stylesToReturn = {};
+  const { docx } = params2;
+  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 fontSize2 = rPr.elements.find((el) => el.name === "w:sz");
+    if (fontSize2?.attributes) stylesToReturn.fontSize = halfPointToPoints(fontSize2.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$9.encode({ ...params2, 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(([key2, attrs]) => {
+      if (attrs?.value) cellMargins[key2] = String(attrs.value);
+    });
+    if (Object.keys(cellMargins).length) stylesToReturn.cellMargins = cellMargins;
+  }
+  return stylesToReturn;
+}
+const config$6 = {
+  xmlName: XML_NODE_NAME$6,
+  sdNodeOrKeyName: SD_NODE_NAME$6,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$6,
+  decode: decode$6,
+  attributes: []
+};
+const translator$6 = NodeTranslator.from(config$6);
+const tableNodeHandlerEntity = generateV2HandlerEntity("tableNodeHandler", translator$6);
 function getReferencedTableStyles(tblStyleTag, docx) {
   if (!tblStyleTag) return null;
   const stylesToReturn = {};
@@ -25719,15 +26061,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: params2,
   node,
@@ -25736,7 +26069,8 @@ function handleTableCellNode({
   rowBorders,
   styleTag,
   columnIndex,
-  columnWidth = null
+  columnWidth = null,
+  allColumnWidths = []
 }) {
   const { docx, nodeListHandler } = params2;
   const tcPr = node.elements.find((el) => el.name === "w:tcPr");
@@ -25750,7 +26084,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"];
@@ -26006,7 +26340,16 @@ const XML_NODE_NAME$5 = "w:tc";
 const SD_NODE_NAME$5 = "tableCell";
 const validXmlAttributes$5 = [];
 function encode$5(params2, encodedAttrs) {
-  const { node, table, row, rowBorders, styleTag, columnIndex, columnWidth } = params2.extraParams;
+  const {
+    node,
+    table,
+    row,
+    rowBorders,
+    styleTag,
+    columnIndex,
+    columnWidth,
+    columnWidths: allColumnWidths
+  } = params2.extraParams;
   const schemaNode = handleTableCellNode({
     params: params2,
     node,
@@ -26015,7 +26358,8 @@ function encode$5(params2, encodedAttrs) {
     rowBorders,
     styleTag,
     columnIndex,
-    columnWidth
+    columnWidth,
+    allColumnWidths
   });
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
     schemaNode.attrs = { ...schemaNode.attrs, ...encodedAttrs };
@@ -26957,9 +27301,9 @@ const config$2 = {
 };
 const translator$2 = NodeTranslator.from(config$2);
 const registeredHandlers = Object.freeze({
-  "w:br": translator$m,
-  "w:tab": translator$l,
-  "w:p": translator$k,
+  "w:br": translator$T,
+  "w:tab": translator$S,
+  "w:p": translator$R,
   "wp:anchor": translator$3,
   "wp:inline": translator$2
 });
@@ -28578,7 +28922,7 @@ function translateStructuredContent(params2) {
 const XML_NODE_NAME = "w:sdt";
 const SD_NODE_NAME = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
 const validXmlAttributes = [];
-function encode$n(params2, encodedAttrs) {
+function encode$s(params2, encodedAttrs) {
   const nodes = params2.nodes;
   const node = nodes[0];
   const { type: sdtType, handler: handler2 } = sdtNodeTypeStrategy(node);
@@ -28608,7 +28952,7 @@ const config = {
   xmlName: XML_NODE_NAME,
   sdNodeOrKeyName: SD_NODE_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$n,
+  encode: encode$s,
   decode,
   attributes: validXmlAttributes
 };
@@ -28619,19 +28963,19 @@ function exportSchemaToJson(params2) {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$k,
+    paragraph: translator$R,
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$m,
-    table: translateTable,
-    tableRow: translator$6,
+    lineBreak: translator$T,
+    table: translator$6,
+    tableRow: translator$D,
     tableCell: translator$5,
     bookmarkStart: translateBookmarkStart,
     fieldAnnotation: translator,
-    tab: translator$l,
+    tab: translator$S,
     image: translator$1,
-    hardBreak: translator$m,
+    hardBreak: translator$T,
     commentRangeStart: () => translateCommentNode(params2, "Start"),
     commentRangeEnd: () => translateCommentNode(params2, "End"),
     commentReference: () => null,
@@ -29238,131 +29582,6 @@ const generateNumPrTag = (numId, level) => {
     ]
   };
 };
-function translateTable(params2) {
-  params2.node = preProcessVerticalMergeCells(params2.node, params2);
-  const elements = translateChildNodes(params2);
-  const tableProperties = generateTableProperties(params2.node);
-  const gridProperties = generateTableGrid(params2.node, params2);
-  elements.unshift(tableProperties);
-  elements.unshift(gridProperties);
-  return {
-    name: "w:tbl",
-    elements
-  };
-}
-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, params2) {
-  const { editorSchema } = params2;
-  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(params2) {
   const bookmarkStartNode = {
     name: "w:bookmarkStart",
@@ -29938,7 +30157,7 @@ const handleParagraphNode = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$k.encode(params2);
+  const schemaNode = translator$R.encode(params2);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -30041,7 +30260,7 @@ const handler = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$m.encode(params2);
+  const result = translator$T.encode(params2);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -30737,7 +30956,7 @@ const handleTabNode = (params2) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$l.encode(params2);
+  const node = translator$S.encode(params2);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
@@ -53487,9 +53706,15 @@ const HardBreak = Node$1.create({
     };
   }
 });
+const getColStyleDeclaration = (minWidth, width) => {
+  if (width) {
+    return ["width", `${Math.max(width, minWidth)}px`];
+  }
+  return ["min-width", `${minWidth}px`];
+};
 const createTableView = ({ editor }) => {
   return class TableView {
-    constructor(node, cellMinWidth) {
+    constructor(node, cellMinWidth2) {
       __publicField$1(this, "editor");
       __publicField$1(this, "node");
       __publicField$1(this, "dom");
@@ -53499,13 +53724,13 @@ const createTableView = ({ editor }) => {
       __publicField$1(this, "cellMinWidth");
       this.editor = editor;
       this.node = node;
-      this.cellMinWidth = cellMinWidth;
+      this.cellMinWidth = cellMinWidth2;
       this.dom = document.createElement("div");
       this.dom.className = "tableWrapper";
       this.table = this.dom.appendChild(document.createElement("table"));
       this.colgroup = this.table.appendChild(document.createElement("colgroup"));
       updateTable(this.editor, this.node, this.table);
-      updateColumns(node, this.colgroup, this.table, cellMinWidth);
+      updateColumns(node, this.colgroup, this.table, cellMinWidth2);
       this.contentDOM = this.table.appendChild(document.createElement("tbody"));
       setTimeout(() => {
         updateTableWrapper(this.dom, this.table);
@@ -53530,7 +53755,7 @@ const createTableView = ({ editor }) => {
     }
   };
 };
-function updateColumns(node, colgroup, table, cellMinWidth, overrideCol, overrideValue) {
+function updateColumns(node, colgroup, table, cellMinWidth2, overrideCol, overrideValue) {
   let totalWidth = 0;
   let fixedWidth = true;
   let nextDOM = colgroup.firstChild;
@@ -53541,16 +53766,16 @@ function updateColumns(node, colgroup, table, cellMinWidth, overrideCol, overrid
       for (let j2 = 0; j2 < colspan; j2++, col++) {
         const hasWidth = overrideCol === col ? overrideValue : colwidth && colwidth[j2];
         const cssWidth = hasWidth ? `${hasWidth}px` : "";
-        totalWidth += hasWidth || cellMinWidth;
+        totalWidth += hasWidth || cellMinWidth2;
         if (!hasWidth) fixedWidth = false;
         if (!nextDOM) {
           const col2 = document.createElement("col");
-          const [propKey, propVal] = getColStyleDeclaration(cellMinWidth, hasWidth);
+          const [propKey, propVal] = getColStyleDeclaration(cellMinWidth2, hasWidth);
           col2.style.setProperty(propKey, propVal);
           colgroup.appendChild(col2);
         } else {
           if (nextDOM.style.width !== cssWidth) {
-            const [propKey, propVal] = getColStyleDeclaration(cellMinWidth, hasWidth);
+            const [propKey, propVal] = getColStyleDeclaration(cellMinWidth2, hasWidth);
             nextDOM.style.setProperty(propKey, propVal);
           }
           nextDOM = nextDOM.nextSibling;
@@ -53647,6 +53872,35 @@ const createTable = (schema, rowsCount, colsCount, withHeaderRow, cellContent =
   const tableBorders = createTableBorders();
   return types2.table.createChecked({ borders: tableBorders }, rows);
 };
+const createColGroup = (node, cellMinWidth2, 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 || cellMinWidth2;
+      if (!hasWidth) fixedWidth = false;
+      const [prop, value] = getColStyleDeclaration(cellMinWidth2, 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
+  };
+};
 var readFromCache;
 var addToCache;
 if (typeof WeakMap != "undefined") {
@@ -55464,7 +55718,7 @@ var columnResizingPluginKey = new PluginKey(
 );
 function columnResizing({
   handleWidth = 5,
-  cellMinWidth = 25,
+  cellMinWidth: cellMinWidth2 = 25,
   defaultCellMinWidth = 100,
   View = TableView,
   lastColumnResizable = true
@@ -55500,7 +55754,7 @@ function columnResizing({
           handleMouseLeave(view);
         },
         mousedown: (view, event) => {
-          handleMouseDown2(view, event, cellMinWidth, defaultCellMinWidth);
+          handleMouseDown2(view, event, cellMinWidth2, defaultCellMinWidth);
         }
       },
       decorations: (state2) => {
@@ -55571,7 +55825,7 @@ function handleMouseLeave(view) {
   if (pluginState && pluginState.activeHandle > -1 && !pluginState.dragging)
     updateHandle(view, -1);
 }
-function handleMouseDown2(view, event, cellMinWidth, defaultCellMinWidth) {
+function handleMouseDown2(view, event, cellMinWidth2, defaultCellMinWidth) {
   var _a2;
   if (!view.editable) return false;
   const win = (_a2 = view.dom.ownerDocument.defaultView) != null ? _a2 : window;
@@ -55593,7 +55847,7 @@ function handleMouseDown2(view, event, cellMinWidth, defaultCellMinWidth) {
       updateColumnWidth(
         view,
         pluginState2.activeHandle,
-        draggedWidth(pluginState2.dragging, event2, cellMinWidth)
+        draggedWidth(pluginState2.dragging, event2, cellMinWidth2)
       );
       view.dispatch(
         view.state.tr.setMeta(columnResizingPluginKey, { setDragging: null })
@@ -55605,7 +55859,7 @@ function handleMouseDown2(view, event, cellMinWidth, defaultCellMinWidth) {
     const pluginState2 = columnResizingPluginKey.getState(view.state);
     if (!pluginState2) return;
     if (pluginState2.dragging) {
-      const dragged = draggedWidth(pluginState2.dragging, event2, cellMinWidth);
+      const dragged = draggedWidth(pluginState2.dragging, event2, cellMinWidth2);
       displayColumnWidth(
         view,
         pluginState2.activeHandle,
@@ -55960,6 +56214,24 @@ const Table = Node$1.create({
       tableCellSpacing: {
         default: null,
         rendered: false
+      },
+      /**
+       * @category Attribute
+       * @param {TableProperties} [tableProperties] - Properties for the table.
+       * @see {@link https://ecma-international.org/publications-and-standards/standards/ecma-376/} "Fundamentals And Markup Language Reference", page 371-483
+       */
+      tableProperties: {
+        default: null,
+        rendered: false
+      },
+      /**
+       * @category Attribute
+       * @param {TableGrid} [grid] - Grid definition for the table
+       * @see {@link https://ecma-international.org/publications-and-standards/standards/ecma-376/} "Fundamentals And Markup Language Reference", page 432
+       */
+      grid: {
+        default: null,
+        rendered: false
       }
     };
   },