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

package/dist/chunks/{super-editor.es-C2QwEj1z.es.js → super-editor.es-kuaVTS8t.es.js}

@@ -25594,37 +25594,37 @@ const _NodeTranslator = class _NodeTranslator2 {
 };
 __publicField$2(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$g = (attributes) => {
+const encode$i = (attributes) => {
   return attributes["w:type"];
 };
-const decode$g = (attrs) => {
+const decode$i = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
 const attrConfig$b = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$g,
-  decode: decode$g
+  encode: encode$i,
+  decode: decode$i
 });
-const encode$f = (attributes) => {
+const encode$h = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$f = (attrs) => {
+const decode$h = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
 const attrConfig$a = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$f,
-  decode: decode$f
+  encode: encode$h,
+  decode: decode$h
 });
-const validXmlAttributes$4 = [attrConfig$b, attrConfig$a];
-const XML_NODE_NAME$4 = "w:br";
-const SD_NODE_NAME$4 = "lineBreak";
-const encode$e = (_2, encodedAttrs) => {
+const validXmlAttributes$5 = [attrConfig$b, attrConfig$a];
+const XML_NODE_NAME$6 = "w:br";
+const SD_NODE_NAME$5 = "lineBreak";
+const encode$g = (_2, encodedAttrs) => {
   const isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -25634,7 +25634,7 @@ const encode$e = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$e = (params2, decodedAttrs) => {
+const decode$g = (params2, decodedAttrs) => {
   const { node: node2 } = params2;
   if (!node2) return;
   const wBreak = { name: "w:br" };
@@ -25651,63 +25651,63 @@ const decode$e = (params2, decodedAttrs) => {
   };
   return translated;
 };
-const config$4 = {
-  xmlName: XML_NODE_NAME$4,
-  sdNodeOrKeyName: SD_NODE_NAME$4,
+const config$6 = {
+  xmlName: XML_NODE_NAME$6,
+  sdNodeOrKeyName: SD_NODE_NAME$5,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$e,
-  decode: decode$e,
-  attributes: validXmlAttributes$4
+  encode: encode$g,
+  decode: decode$g,
+  attributes: validXmlAttributes$5
 };
-const translator$4 = NodeTranslator.from(config$4);
-const encode$d = (attributes) => {
+const translator$i = NodeTranslator.from(config$6);
+const encode$f = (attributes) => {
   return attributes["w:val"];
 };
-const decode$d = (attrs) => {
+const decode$f = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
 const attrConfig$9 = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$d,
-  decode: decode$d
+  encode: encode$f,
+  decode: decode$f
 });
-const encode$c = (attributes) => {
+const encode$e = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$c = (attrs) => {
+const decode$e = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
 const attrConfig$8 = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$c,
-  decode: decode$c
+  encode: encode$e,
+  decode: decode$e
 });
-const encode$b = (attributes) => {
+const encode$d = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$b = (attrs) => {
+const decode$d = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
 const attrConfig$7 = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$b,
-  decode: decode$b
+  encode: encode$d,
+  decode: decode$d
 });
-const validXmlAttributes$3 = [attrConfig$9, attrConfig$7, attrConfig$8];
-const XML_NODE_NAME$3 = "w:tab";
-const SD_NODE_NAME$3 = "tab";
-const encode$a = (_2, encodedAttrs = {}) => {
+const validXmlAttributes$4 = [attrConfig$9, attrConfig$7, attrConfig$8];
+const XML_NODE_NAME$5 = "w:tab";
+const SD_NODE_NAME$4 = "tab";
+const encode$c = (_2, encodedAttrs = {}) => {
   const translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$a = (params2, decodedAttrs = {}) => {
+const decode$c = (params2, decodedAttrs = {}) => {
   const { node: node2 } = params2 || {};
   if (!node2) return;
   const wTab = { name: "w:tab" };
@@ -25723,15 +25723,15 @@ const decode$a = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$3 = {
-  xmlName: XML_NODE_NAME$3,
-  sdNodeOrKeyName: SD_NODE_NAME$3,
+const config$5 = {
+  xmlName: XML_NODE_NAME$5,
+  sdNodeOrKeyName: SD_NODE_NAME$4,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$a,
-  decode: decode$a,
-  attributes: validXmlAttributes$3
+  encode: encode$c,
+  decode: decode$c,
+  attributes: validXmlAttributes$4
 };
-const translator$3 = NodeTranslator.from(config$3);
+const translator$h = NodeTranslator.from(config$5);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -26301,91 +26301,91 @@ const handleParagraphNode$1 = (params2) => {
   }
   return schemaNode;
 };
-const encode$9 = (attributes) => {
+const encode$b = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$9 = (attrs) => {
+const decode$b = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$6 = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$9,
-  decode: decode$9
+  encode: encode$b,
+  decode: decode$b
 });
-const encode$8 = (attributes) => {
+const encode$a = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$8 = (attrs) => {
+const decode$a = (attrs) => {
   return attrs.rsidP;
 };
 const attrConfig$5 = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$8,
-  decode: decode$8
+  encode: encode$a,
+  decode: decode$a
 });
-const encode$7 = (attributes) => {
+const encode$9 = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$7 = (attrs) => {
+const decode$9 = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$4 = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$7,
-  decode: decode$7
+  encode: encode$9,
+  decode: decode$9
 });
-const encode$6 = (attributes) => {
+const encode$8 = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$6 = (attrs) => {
+const decode$8 = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$3 = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$6,
-  decode: decode$6
+  encode: encode$8,
+  decode: decode$8
 });
-const encode$5 = (attributes) => {
+const encode$7 = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$5 = (attrs) => {
+const decode$7 = (attrs) => {
   return attrs.rsidRDefault;
 };
 const attrConfig$2 = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$5,
-  decode: decode$5
+  encode: encode$7,
+  decode: decode$7
 });
-const encode$4 = (attributes) => {
+const encode$6 = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$4 = (attrs) => {
+const decode$6 = (attrs) => {
   return attrs.paraId;
 };
 const attrConfig$1 = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$4,
-  decode: decode$4
+  encode: encode$6,
+  decode: decode$6
 });
-const encode$3 = (attributes) => {
+const encode$5 = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$3 = (attrs) => {
+const decode$5 = (attrs) => {
   return attrs.textId;
 };
 const attrConfig = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$3,
-  decode: decode$3
+  encode: encode$5,
+  decode: decode$5
 });
-const validXmlAttributes$2 = [
+const validXmlAttributes$3 = [
   attrConfig$1,
   attrConfig,
   attrConfig$4,
@@ -26394,9 +26394,9 @@ const validXmlAttributes$2 = [
   attrConfig$3,
   attrConfig$6
 ];
-const XML_NODE_NAME$2 = "w:p";
-const SD_NODE_NAME$2 = "paragraph";
-const encode$2 = (params2, encodedAttrs = {}) => {
+const XML_NODE_NAME$4 = "w:p";
+const SD_NODE_NAME$3 = "paragraph";
+const encode$4 = (params2, encodedAttrs = {}) => {
   const node2 = handleParagraphNode$1(params2);
   if (!node2) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -26404,7 +26404,7 @@ const encode$2 = (params2, encodedAttrs = {}) => {
   }
   return node2;
 };
-const decode$2 = (params2, decodedAttrs = {}) => {
+const decode$4 = (params2, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params2);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -26412,6 +26412,356 @@ const decode$2 = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
+const config$4 = {
+  xmlName: XML_NODE_NAME$4,
+  sdNodeOrKeyName: SD_NODE_NAME$3,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$4,
+  decode: decode$4,
+  attributes: validXmlAttributes$3
+};
+const translator$g = NodeTranslator.from(config$4);
+const generateV2HandlerEntity = (handlerName, translator2) => ({
+  handlerName,
+  handler: (params2) => {
+    const { nodes } = params2;
+    if (nodes.length === 0 || nodes[0].name !== translator2.xmlName) {
+      return { nodes: [], consumed: 0 };
+    }
+    const result = translator2.encode(params2);
+    if (!result) return { nodes: [], consumed: 0 };
+    return {
+      nodes: Array.isArray(result) ? result : [result],
+      consumed: 1
+    };
+  }
+});
+function createSingleAttrPropertyHandler(xmlName, sdName = null, attrName = "w:val", transformEncode = null, transformDecode = null) {
+  if (!sdName) sdName = xmlName.split(":")[1];
+  if (!transformEncode) transformEncode = (v2) => v2;
+  if (!transformDecode) transformDecode = (v2) => v2;
+  return {
+    xmlName,
+    sdNodeOrKeyName: sdName,
+    encode: ({ nodes }) => {
+      return transformEncode(nodes[0].attributes[attrName]) ?? void 0;
+    },
+    decode: ({ node: node2 }) => {
+      const value = node2.attrs?.[sdName] != null ? transformDecode(node2.attrs[sdName]) : void 0;
+      return value != null ? { [attrName]: value } : void 0;
+    }
+  };
+}
+function createMeasurementPropertyHandler(xmlName, sdName = null) {
+  if (!sdName) sdName = xmlName.split(":")[1];
+  return {
+    xmlName,
+    sdNodeOrKeyName: sdName,
+    attributes: [
+      createAttributeHandler("w:w", "value", parseInteger, integerToString),
+      createAttributeHandler("w:type")
+    ],
+    encode: (_2, encodedAttrs) => {
+      return encodedAttrs["value"] != null ? encodedAttrs : void 0;
+    },
+    decode: function({ node: node2 }, _2) {
+      const decodedAttrs = this.decodeAttributes({ node: { ...node2, attrs: node2.attrs[sdName] || {} } });
+      return decodedAttrs["w:w"] != null ? decodedAttrs : void 0;
+    }
+  };
+}
+const createAttributeHandler = (xmlName, sdName = null, transformEncode = null, transformDecode = null) => {
+  if (!transformEncode) transformEncode = (v2) => v2;
+  if (!transformDecode) transformDecode = (v2) => v2;
+  if (!sdName) sdName = xmlName.split(":")[1];
+  return {
+    xmlName,
+    sdName,
+    encode: (attributes) => transformEncode(attributes[xmlName]),
+    decode: (attributes) => transformDecode(attributes[sdName])
+  };
+};
+function encodeProperties(node2, translatorsByXmlName, asArray = false) {
+  let attributes = asArray ? [] : {};
+  node2.elements.forEach((el) => {
+    const translator2 = translatorsByXmlName[el.name];
+    if (translator2) {
+      const encodedAttr = translator2.encode({ nodes: [el] });
+      if (encodedAttr != null) {
+        if (asArray) {
+          attributes.push({ [translator2.sdNodeOrKeyName]: encodedAttr });
+        } else {
+          attributes[translator2.sdNodeOrKeyName] = encodedAttr;
+        }
+      }
+    }
+  });
+  return attributes;
+}
+function decodeProperties(translatorsBySdName, properties) {
+  const elements = [];
+  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 });
+      }
+    }
+  });
+  return elements;
+}
+const parseBoolean = (value) => ["1", "true"].includes(value);
+const parseInteger = (value) => {
+  if (value == null) return void 0;
+  const intValue = parseInt(value, 10);
+  return isNaN(intValue) ? void 0 : intValue;
+};
+const integerToString = (value) => {
+  const intValue = parseInteger(value);
+  return intValue != void 0 ? String(intValue) : void 0;
+};
+const translator$f = NodeTranslator.from({
+  xmlName: "w:cantSplit",
+  sdNodeOrKeyName: "cantSplit",
+  encode: ({ nodes }) => ["1", "true"].includes(nodes[0].attributes?.["w:val"] ?? "1"),
+  decode: ({ node: node2 }) => node2.attrs?.cantSplit ? {} : void 0
+});
+const translator$e = NodeTranslator.from({
+  xmlName: "w:cnfStyle",
+  sdNodeOrKeyName: "cnfStyle",
+  attributes: [
+    "w:evenHBand",
+    "w:evenVBand",
+    "w:firstColumn",
+    "w:firstRow",
+    "w:firstRowFirstColumn",
+    "w:firstRowLastColumn",
+    "w:lastColumn",
+    "w:lastRow",
+    "w:lastRowFirstColumn",
+    "w:lastRowLastColumn",
+    "w:oddHBand",
+    "w:oddVBand",
+    "w:val"
+  ].map((attr) => createAttributeHandler(attr)),
+  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: node2 }) => {
+    if (!node2.attrs?.cnfStyle) return;
+    const cnfStyleAttrs = {};
+    Object.entries(node2.attrs.cnfStyle).forEach(([key, value]) => {
+      cnfStyleAttrs[`w:${key}`] = value ? "1" : "0";
+    });
+    return Object.keys(cnfStyleAttrs).length > 0 ? cnfStyleAttrs : void 0;
+  }
+});
+const translator$d = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
+const translator$c = NodeTranslator.from(
+  createSingleAttrPropertyHandler(
+    "w:gridAfter",
+    null,
+    "w:val",
+    (v2) => parseInteger(v2) ?? void 0,
+    (v2) => integerToString(v2)
+  )
+);
+const translator$b = NodeTranslator.from(
+  createSingleAttrPropertyHandler(
+    "w:gridBefore",
+    null,
+    "w:val",
+    (v2) => parseInteger(v2) ?? void 0,
+    (v2) => integerToString(v2)
+  )
+);
+const translator$a = NodeTranslator.from({
+  xmlName: "w:hidden",
+  sdNodeOrKeyName: "hidden",
+  encode: ({ nodes }) => parseBoolean(nodes[0].attributes?.["w:val"] ?? "1"),
+  decode: ({ node: node2 }) => node2.attrs.hidden ? {} : void 0
+});
+const translator$9 = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc"));
+const translator$8 = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "cellSpacing"));
+const translator$7 = NodeTranslator.from({
+  xmlName: "w:tblHeader",
+  sdNodeOrKeyName: "repeatHeader",
+  encode: ({ nodes }) => parseBoolean(nodes[0].attributes?.["w:val"] ?? "1"),
+  decode: ({ node: node2 }) => node2.attrs.repeatHeader ? {} : void 0
+});
+const translator$6 = NodeTranslator.from({
+  xmlName: "w:trHeight",
+  sdNodeOrKeyName: "rowHeight",
+  encode: ({ nodes }) => {
+    const heightAttrs = {};
+    const val = nodes[0].attributes["w:val"];
+    if (val) {
+      heightAttrs["value"] = parseInt(val, 10);
+    }
+    const rule = nodes[0].attributes["w:hRule"];
+    if (rule) {
+      heightAttrs["rule"] = rule;
+    }
+    return Object.keys(heightAttrs).length > 0 ? heightAttrs : void 0;
+  },
+  decode: ({ node: node2 }) => {
+    if (!node2.attrs?.rowHeight) return;
+    const heightAttrs = {};
+    if (typeof node2.attrs.rowHeight.value === "number" && !isNaN(node2.attrs.rowHeight.value)) {
+      heightAttrs["w:val"] = String(node2.attrs.rowHeight.value);
+    }
+    if (node2.attrs.rowHeight.rule) {
+      heightAttrs["w:hRule"] = node2.attrs.rowHeight.rule;
+    }
+    return Object.keys(heightAttrs).length > 0 ? heightAttrs : void 0;
+  }
+});
+const translator$5 = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
+const translator$4 = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
+const XML_NODE_NAME$3 = "w:trPr";
+const SD_ATTR_KEY = "tableRowProperties";
+const encode$3 = (params2) => {
+  const { nodes } = params2;
+  const node2 = nodes[0];
+  let attributes = {
+    cantSplit: false,
+    hidden: false,
+    repeatHeader: false
+  };
+  attributes = {
+    ...attributes,
+    ...encodeProperties(node2, propertyTranslatorsByXmlName)
+  };
+  return {
+    type: NodeTranslator.translatorTypes.ATTRIBUTE,
+    xmlName: XML_NODE_NAME$3,
+    sdNodeOrKeyName: SD_ATTR_KEY,
+    attributes
+  };
+};
+const decode$3 = (params2) => {
+  const { tableRowProperties = {} } = params2.node.attrs || {};
+  const elements = decodeProperties(propertyTranslatorsBySdName, tableRowProperties);
+  const newNode = {
+    name: "w:trPr",
+    type: "element",
+    attributes: {},
+    elements
+  };
+  return newNode;
+};
+const propertyTranslators = [
+  translator$f,
+  translator$e,
+  translator$d,
+  translator$c,
+  translator$b,
+  translator$a,
+  translator$9,
+  translator$8,
+  translator$7,
+  translator$6,
+  translator$5,
+  translator$4
+];
+const propertyTranslatorsByXmlName = {};
+propertyTranslators.forEach((translator2) => {
+  propertyTranslatorsByXmlName[translator2.xmlName] = translator2;
+});
+const propertyTranslatorsBySdName = {};
+propertyTranslators.forEach((translator2) => {
+  propertyTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
+});
+const config$3 = {
+  xmlName: XML_NODE_NAME$3,
+  sdNodeOrKeyName: SD_ATTR_KEY,
+  type: NodeTranslator.translatorTypes.ATTRIBUTE,
+  encode: encode$3,
+  decode: decode$3
+};
+const translator$3 = NodeTranslator.from(config$3);
+const XML_NODE_NAME$2 = "w:tr";
+const SD_NODE_NAME$2 = "tableRow";
+const validXmlAttributes$2 = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
+  (xmlName) => createAttributeHandler(xmlName)
+);
+const encode$2 = (params2, encodedAttrs) => {
+  const { row, table } = params2.extraParams;
+  let tableRowProperties = {};
+  const tPr = row.elements.find((el) => el.name === "w:trPr");
+  if (tPr) {
+    ({ attributes: tableRowProperties } = translator$3.encode({
+      ...params2,
+      nodes: [tPr]
+    }));
+  }
+  encodedAttrs["tableRowProperties"] = Object.freeze(tableRowProperties);
+  encodedAttrs["rowHeight"] = twipsToPixels(tableRowProperties["rowHeight"]?.value);
+  encodedAttrs["cantSplit"] = tableRowProperties["cantSplit"];
+  const gridColumnWidths = _getGridColumnWidths(table);
+  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$1.encode({
+      ...params2,
+      extraParams: {
+        ...params2.extraParams,
+        node: n,
+        columnIndex: currentColumnIndex,
+        columnWidth
+      }
+    });
+    const tcPr = n.elements?.find((el) => el.name === "w:tcPr");
+    const colspanTag = tcPr?.elements?.find((el) => el.name === "w:gridSpan");
+    const colspan = parseInt(colspanTag?.attributes["w:val"] || 1, 10);
+    currentColumnIndex += colspan;
+    return result;
+  }) || [];
+  const newNode = {
+    type: "tableRow",
+    content,
+    attrs: 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$2 = (params2, decodedAttrs) => {
+  const { node: node2 } = params2;
+  const elements = translateChildNodes(params2);
+  if (node2.attrs?.tableRowProperties) {
+    const tableRowProperties = { ...node2.attrs.tableRowProperties };
+    if (node2.attrs.rowHeight != null) {
+      const rowHeightPixels = twipsToPixels(node2.attrs.tableRowProperties["rowHeight"]?.value);
+      if (rowHeightPixels !== node2.attrs.rowHeight) {
+        tableRowProperties["rowHeight"] = { value: String(pixelsToTwips(node2.attrs["rowHeight"])) };
+      }
+    }
+    tableRowProperties["cantSplit"] = node2.attrs["cantSplit"];
+    const trPr = translator$3.decode({
+      ...params2,
+      node: { ...node2, attrs: { ...node2.attrs, tableRowProperties } }
+    });
+    if (trPr) elements.unshift(trPr);
+  }
+  return {
+    name: "w:tr",
+    attributes: decodedAttrs || {},
+    elements
+  };
+};
 const config$2 = {
   xmlName: XML_NODE_NAME$2,
   sdNodeOrKeyName: SD_NODE_NAME$2,
@@ -26484,7 +26834,16 @@ function handleTableNode(node2, params2) {
   attrs["borders"] = borderData;
   const content = [];
   rows.forEach((row) => {
-    const result = handleTableRowNode(row, node2, borderRowData, tblStyleTag, params2);
+    const result = translator$2.encode({
+      ...params2,
+      nodes: [row],
+      extraParams: {
+        row,
+        table: node2,
+        rowBorders: borderRowData,
+        styleTag: tblStyleTag
+      }
+    });
     if (result.content?.length) content.push(result);
   });
   return {
@@ -26493,31 +26852,6 @@ function handleTableNode(node2, params2) {
     attrs
   };
 }
-function handleTableCellNode$1({
-  params: params2,
-  node: node2,
-  table,
-  row,
-  rowBorders,
-  styleTag,
-  columnIndex,
-  columnWidth = null
-}) {
-  const translatorParams = {
-    ...params2,
-    extraParams: {
-      node: node2,
-      table,
-      row,
-      rowBorders,
-      styleTag,
-      columnIndex,
-      columnWidth
-    }
-  };
-  const schemaNode = translator$1.encode(translatorParams);
-  return schemaNode;
-}
 function getReferencedTableStyles(tblStyleTag, docx) {
   if (!tblStyleTag) return null;
   const stylesToReturn = {};
@@ -26598,50 +26932,6 @@ function processTableBorders(borderElements) {
     rowBorders
   };
 }
-function handleTableRowNode(node2, table, rowBorders, styleTag, params2) {
-  const attrs = {};
-  const tPr = node2.elements.find((el) => el.name === "w:trPr");
-  const rowHeightTag = tPr?.elements?.find((el) => el.name === "w:trHeight");
-  const rowHeight = rowHeightTag?.attributes["w:val"];
-  const cantSplitTag = tPr?.elements?.find((el) => el.name === "w:cantSplit");
-  if (cantSplitTag) {
-    attrs["cantSplit"] = true;
-  }
-  const borders = {};
-  if (rowBorders?.insideH) borders["bottom"] = rowBorders.insideH;
-  if (rowBorders?.insideV) borders["right"] = rowBorders.insideV;
-  attrs["borders"] = borders;
-  if (rowHeight) {
-    attrs["rowHeight"] = twipsToPixels(rowHeight);
-  }
-  const gridColumnWidths = getGridColumnWidths(table);
-  const cellNodes = node2.elements.filter((el) => el.name === "w:tc");
-  let currentColumnIndex = 0;
-  const content = cellNodes?.map((n) => {
-    let colWidth = gridColumnWidths?.[currentColumnIndex] || null;
-    const result = handleTableCellNode$1({
-      params: params2,
-      node: n,
-      table,
-      row: node2,
-      rowBorders: borders,
-      styleTag,
-      columnIndex: currentColumnIndex,
-      columnWidth: colWidth
-    });
-    const tcPr = n.elements?.find((el) => el.name === "w:tcPr");
-    const colspanTag = tcPr?.elements?.find((el) => el.name === "w:gridSpan");
-    const colspan = parseInt(colspanTag?.attributes["w:val"] || 1, 10);
-    currentColumnIndex += colspan;
-    return result;
-  }) || [];
-  const newNode = {
-    type: "tableRow",
-    content,
-    attrs
-  };
-  return newNode;
-}
 const getGridColumnWidths = (tableNode) => {
   const tblGrid = tableNode.elements.find((el) => el.name === "w:tblGrid");
   if (!tblGrid) return [];
@@ -26664,6 +26954,14 @@ function handleTableCellNode({
   const { docx, nodeListHandler: nodeListHandler2 } = params2;
   const tcPr = node2.elements.find((el) => el.name === "w:tcPr");
   const borders = tcPr?.elements?.find((el) => el.name === "w:tcBorders");
+  if (rowBorders?.insideH) {
+    rowBorders["bottom"] = rowBorders.insideH;
+    delete rowBorders.insideH;
+  }
+  if (rowBorders?.insideV) {
+    rowBorders["right"] = rowBorders.insideV;
+    delete rowBorders?.insideV;
+  }
   const inlineBorders = processInlineCellBorders(borders, rowBorders);
   const gridColumnWidths = getGridColumnWidths(table);
   const tcWidth = tcPr?.elements?.find((el) => el.name === "w:tcW");
@@ -26974,7 +27272,7 @@ const validXmlAttributes = [
   _createAttributeHandler("r:id", "rId"),
   _createAttributeHandler("w:tgtFrame", "target")
 ];
-const encode$h = (params2, encodedAttrs) => {
+const encode$j = (params2, encodedAttrs) => {
   const { nodes, docx, nodeListHandler: nodeListHandler2 } = params2;
   const node2 = nodes[0];
   let href = _resolveHref(docx, encodedAttrs);
@@ -27053,7 +27351,7 @@ const config = {
   xmlName: XML_NODE_NAME,
   sdNodeOrKeyName: SD_NODE_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$h,
+  encode: encode$j,
   decode,
   attributes: validXmlAttributes
 };
@@ -27064,19 +27362,19 @@ function exportSchemaToJson(params2) {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$2,
+    paragraph: translator$g,
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$4,
+    lineBreak: translator$i,
     table: translateTable,
-    tableRow: translateTableRow,
+    tableRow: translator$2,
     tableCell: translator$1,
     bookmarkStart: translateBookmarkStart,
     fieldAnnotation: translateFieldAnnotation,
-    tab: translator$3,
+    tab: translator$h,
     image: translateImageNode,
-    hardBreak: translator$4,
+    hardBreak: translator$i,
     commentRangeStart: () => translateCommentNode(params2, "Start"),
     commentRangeEnd: () => translateCommentNode(params2, "End"),
     commentReference: () => null,
@@ -27856,36 +28154,6 @@ function generateTableGrid(node2, params2) {
     elements
   };
 }
-function translateTableRow(params2) {
-  const elements = translateChildNodes(params2);
-  const tableRowProperties = generateTableRowProperties(params2.node);
-  if (tableRowProperties.elements.length) elements.unshift(tableRowProperties);
-  return {
-    name: "w:tr",
-    elements
-  };
-}
-function generateTableRowProperties(node2) {
-  const { attrs } = node2;
-  const elements = [];
-  const { rowHeight, rowHeightType } = attrs;
-  if (rowHeight) {
-    const attributes = { "w:val": pixelsToTwips(rowHeight) };
-    if (rowHeightType) attributes["w:hRule"] = rowHeightType;
-    const rowHeightElement = {
-      name: "w:trHeight",
-      attributes
-    };
-    elements.push(rowHeightElement);
-  }
-  if (attrs?.cantSplit) {
-    elements.push({ name: "w:cantSplit" });
-  }
-  return {
-    name: "w:trPr",
-    elements
-  };
-}
 function translateBookmarkStart(params2) {
   const bookmarkStartNode = {
     name: "w:bookmarkStart",
@@ -29105,21 +29373,6 @@ const trackChangeNodeHandlerEntity = {
   handlerName: "trackChangeNodeHandler",
   handler: handleTrackChangeNode
 };
-const generateV2HandlerEntity = (handlerName, translator2) => ({
-  handlerName,
-  handler: (params2) => {
-    const { nodes } = params2;
-    if (nodes.length === 0 || nodes[0].name !== translator2.xmlName) {
-      return { nodes: [], consumed: 0 };
-    }
-    const result = translator2.encode(params2);
-    if (!result) return { nodes: [], consumed: 0 };
-    return {
-      nodes: Array.isArray(result) ? result : [result],
-      consumed: 1
-    };
-  }
-});
 const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator);
 const handleRunNode = (params2) => {
   const { nodes, nodeListHandler: nodeListHandler2, parentStyleId, docx } = params2;
@@ -29232,7 +29485,7 @@ const handleParagraphNode = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$2.encode(params2);
+  const schemaNode = translator$g.encode(params2);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -29545,7 +29798,7 @@ const handler = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$4.encode(params2);
+  const result = translator$i.encode(params2);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -30241,7 +30494,7 @@ const handleTabNode = (params2) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node2 = translator$3.encode(params2);
+  const node2 = translator$h.encode(params2);
   return { nodes: [node2], consumed: 1 };
 };
 const tabNodeEntityHandler = {
@@ -55982,7 +56235,49 @@ const TableRow = Node$1.create({
           if (!cantSplit) return {};
           return { "data-cant-split": "true" };
         }
-      }
+      },
+      /**
+       * @category Attribute
+       * @param {TableRowProperties} [tableRowProperties] - Properties for the table row.
+       * @see {@link https://ecma-international.org/publications-and-standards/standards/ecma-376/} "Fundamentals And Markup Language Reference", page 377-482
+       */
+      tableRowProperties: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {string} [rsidDel] - Unique identifier used to track the editing session when the row was deleted from the main document.
+       * @see {@link https://ecma-international.org/publications-and-standards/standards/ecma-376/} "Fundamentals And Markup Language Reference", page 472
+       */
+      rsidDel: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {string} [rsidR] - Unique identifier used to track the editing session when the table row was added to the main document.
+       * @see {@link https://ecma-international.org/publications-and-standards/standards/ecma-376/} "Fundamentals And Markup Language Reference", page 472
+       */
+      rsidR: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {string} [rsidRPr] - Unique identifier used to track the editing session when the glyph character representing the table row mark was last modified in the main document.
+       * @see {@link https://ecma-international.org/publications-and-standards/standards/ecma-376/} "Fundamentals And Markup Language Reference", page 473
+       */
+      rsidRPr: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {string} [rsidTr] - Unique identifier used to track the editing session when the table row's properties were last modified in this document.
+       * @see {@link https://ecma-international.org/publications-and-standards/standards/ecma-376/} "Fundamentals And Markup Language Reference", page 473
+       */
+      rsidTr: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {string} [paraId] - A randomly generated unique identifier for the table row.
+       * @see {@link https://learn.microsoft.com/en-us/openspecs/office_standards/ms-docx/a0e7d2e2-2246-44c6-96e8-1cf009823615}
+       */
+      paraId: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {string} [textId] - A randomly generated unique identifier for the text of the table row.
+       * @see {@link https://learn.microsoft.com/en-us/openspecs/office_standards/ms-docx/b7eeddec-7c50-47fb-88b6-1feec3ed832c}
+       */
+      textId: { rendered: false }
     };
   },
   parseDOM() {
@@ -81366,9 +81661,9 @@ const _sfc_main = {
 };
 const SuperInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4d5cff52"]]);
 const registeredHandlers = Object.freeze({
-  "w:br": translator$4,
-  "w:tab": translator$3,
-  "w:p": translator$2
+  "w:br": translator$i,
+  "w:tab": translator$h,
+  "w:p": translator$g
 });
 const Extensions = {
   Node: Node$1,