@beyondwork/docx-react-component 1.0.28 → 1.0.30

package/src/io/export/table-properties-xml.ts

@@ -0,0 +1,318 @@
+interface TableWidthLike {
+  value: number;
+  type: string;
+}
+
+interface BorderSpecLike {
+  value?: string;
+  size?: number;
+  space?: number;
+  color?: string;
+}
+
+interface TableBordersLike {
+  top?: BorderSpecLike;
+  left?: BorderSpecLike;
+  bottom?: BorderSpecLike;
+  right?: BorderSpecLike;
+  insideH?: BorderSpecLike;
+  insideV?: BorderSpecLike;
+}
+
+interface TableCellMarginsLike {
+  top?: number;
+  left?: number;
+  bottom?: number;
+  right?: number;
+}
+
+interface TableLookLike {
+  val?: string;
+  firstRow?: boolean;
+  lastRow?: boolean;
+  firstColumn?: boolean;
+  lastColumn?: boolean;
+  noHBand?: boolean;
+  noVBand?: boolean;
+}
+
+interface CellShadingLike {
+  val?: string;
+  color?: string;
+  fill?: string;
+}
+
+interface TablePropertiesLike {
+  propertiesXml?: string;
+  styleId?: string;
+  width?: TableWidthLike;
+  alignment?: string;
+  borders?: TableBordersLike;
+  cellMargins?: TableCellMarginsLike;
+  tblLook?: TableLookLike;
+}
+
+interface TableRowPropertiesLike {
+  propertiesXml?: string;
+  gridBefore?: number;
+  widthBefore?: TableWidthLike;
+  gridAfter?: number;
+  widthAfter?: TableWidthLike;
+  height?: number;
+  heightRule?: string;
+  isHeader?: boolean;
+}
+
+interface TableCellPropertiesLike {
+  propertiesXml?: string;
+  width?: TableWidthLike;
+  gridSpan?: number;
+  verticalMerge?: "restart" | "continue";
+  borders?: TableBordersLike;
+  shading?: CellShadingLike;
+  verticalAlign?: string;
+}
+
+interface PropertyStripSpec {
+  pairedTags?: string[];
+  selfClosingTags?: string[];
+}
+
+const TABLE_PROPERTY_STRIP_SPEC: PropertyStripSpec = {
+  pairedTags: ["w:tblBorders", "w:tblCellMar"],
+  selfClosingTags: ["w:tblStyle", "w:tblW", "w:jc", "w:tblLook"],
+};
+
+const ROW_PROPERTY_STRIP_SPEC: PropertyStripSpec = {
+  selfClosingTags: ["w:gridBefore", "w:wBefore", "w:gridAfter", "w:wAfter", "w:trHeight", "w:tblHeader"],
+};
+
+const CELL_PROPERTY_STRIP_SPEC: PropertyStripSpec = {
+  pairedTags: ["w:tcBorders"],
+  selfClosingTags: ["w:tcW", "w:gridSpan", "w:vMerge", "w:shd", "w:vAlign"],
+};
+
+export function serializeTablePropertiesXml(table: TablePropertiesLike): string {
+  return mergePropertiesXml(
+    "w:tblPr",
+    table.propertiesXml,
+    buildTablePropertiesInnerXml(table),
+    TABLE_PROPERTY_STRIP_SPEC,
+  );
+}
+
+export function serializeTableRowPropertiesXml(row: TableRowPropertiesLike): string {
+  return mergePropertiesXml(
+    "w:trPr",
+    row.propertiesXml,
+    buildTableRowPropertiesInnerXml(row),
+    ROW_PROPERTY_STRIP_SPEC,
+  );
+}
+
+export function serializeTableCellPropertiesXml(cell: TableCellPropertiesLike): string {
+  return mergePropertiesXml(
+    "w:tcPr",
+    cell.propertiesXml,
+    buildTableCellPropertiesInnerXml(cell),
+    CELL_PROPERTY_STRIP_SPEC,
+  );
+}
+
+function mergePropertiesXml(
+  tagName: "w:tblPr" | "w:trPr" | "w:tcPr",
+  existingXml: string | undefined,
+  supportedInnerXml: string,
+  stripSpec: PropertyStripSpec,
+): string {
+  const preservedInnerXml = stripKnownProperties(
+    extractWrappedChildren(tagName, existingXml),
+    stripSpec,
+  );
+  const mergedInnerXml = [supportedInnerXml, preservedInnerXml]
+    .filter((part) => part.length > 0)
+    .join("");
+  return mergedInnerXml.length > 0 ? `<${tagName}>${mergedInnerXml}</${tagName}>` : "";
+}
+
+function extractWrappedChildren(
+  tagName: "w:tblPr" | "w:trPr" | "w:tcPr",
+  xml: string | undefined,
+): string {
+  if (!xml) {
+    return "";
+  }
+  const trimmed = xml.trim();
+  const wrapped = new RegExp(`^<${tagName}\\b[^>]*>([\\s\\S]*)</${tagName}>$`, "u").exec(trimmed);
+  return wrapped?.[1] ?? trimmed;
+}
+
+function stripKnownProperties(xml: string, stripSpec: PropertyStripSpec): string {
+  let nextXml = xml;
+  for (const tagName of stripSpec.pairedTags ?? []) {
+    nextXml = nextXml.replace(
+      new RegExp(`<${tagName}\\b[^>]*>[\\s\\S]*?</${tagName}>`, "gu"),
+      "",
+    );
+  }
+  for (const tagName of stripSpec.selfClosingTags ?? []) {
+    nextXml = nextXml.replace(new RegExp(`<${tagName}\\b[^>]*/>`, "gu"), "");
+  }
+  return nextXml.trim();
+}
+
+function buildTablePropertiesInnerXml(table: TablePropertiesLike): string {
+  const children: string[] = [];
+  if (table.styleId) {
+    children.push(`<w:tblStyle w:val="${escapeAttribute(table.styleId)}"/>`);
+  }
+  if (table.width) {
+    children.push(serializeWidth("tblW", table.width));
+  }
+  if (table.alignment) {
+    children.push(`<w:jc w:val="${escapeAttribute(table.alignment)}"/>`);
+  }
+  if (table.borders) {
+    const bordersXml = serializeBorders(table.borders);
+    if (bordersXml) {
+      children.push(`<w:tblBorders>${bordersXml}</w:tblBorders>`);
+    }
+  }
+  if (table.cellMargins) {
+    const marginsXml = serializeTableCellMargins(table.cellMargins);
+    if (marginsXml) {
+      children.push(`<w:tblCellMar>${marginsXml}</w:tblCellMar>`);
+    }
+  }
+  if (table.tblLook) {
+    const tblLookXml = serializeTableLook(table.tblLook);
+    if (tblLookXml) {
+      children.push(tblLookXml);
+    }
+  }
+  return children.join("");
+}
+
+function buildTableRowPropertiesInnerXml(row: TableRowPropertiesLike): string {
+  const children: string[] = [];
+  if (row.gridBefore !== undefined) {
+    children.push(`<w:gridBefore w:val="${row.gridBefore}"/>`);
+  }
+  if (row.widthBefore) {
+    children.push(`<w:wBefore w:w="${row.widthBefore.value}" w:type="${row.widthBefore.type}"/>`);
+  }
+  if (row.gridAfter !== undefined) {
+    children.push(`<w:gridAfter w:val="${row.gridAfter}"/>`);
+  }
+  if (row.widthAfter) {
+    children.push(`<w:wAfter w:w="${row.widthAfter.value}" w:type="${row.widthAfter.type}"/>`);
+  }
+  if (row.height !== undefined) {
+    const hRuleAttr = row.heightRule ? ` w:hRule="${escapeAttribute(row.heightRule)}"` : "";
+    children.push(`<w:trHeight w:val="${row.height}"${hRuleAttr}/>`);
+  }
+  if (row.isHeader !== undefined) {
+    children.push(row.isHeader ? `<w:tblHeader/>` : `<w:tblHeader w:val="0"/>`);
+  }
+  return children.join("");
+}
+
+function buildTableCellPropertiesInnerXml(cell: TableCellPropertiesLike): string {
+  const children: string[] = [];
+  if (cell.width) {
+    children.push(serializeWidth("tcW", cell.width));
+  }
+  if (cell.gridSpan && cell.gridSpan > 1) {
+    children.push(`<w:gridSpan w:val="${cell.gridSpan}"/>`);
+  }
+  if (cell.verticalMerge) {
+    children.push(
+      cell.verticalMerge === "restart"
+        ? `<w:vMerge w:val="restart"/>`
+        : `<w:vMerge/>`,
+    );
+  }
+  if (cell.borders) {
+    const bordersXml = serializeBorders(cell.borders);
+    if (bordersXml) {
+      children.push(`<w:tcBorders>${bordersXml}</w:tcBorders>`);
+    }
+  }
+  if (cell.shading) {
+    const shadingXml = serializeCellShading(cell.shading);
+    if (shadingXml) {
+      children.push(shadingXml);
+    }
+  }
+  if (cell.verticalAlign) {
+    children.push(`<w:vAlign w:val="${escapeAttribute(cell.verticalAlign)}"/>`);
+  }
+  return children.join("");
+}
+
+function serializeWidth(elementName: "tblW" | "tcW", width: TableWidthLike): string {
+  return `<w:${elementName} w:w="${width.value}" w:type="${escapeAttribute(width.type)}"/>`;
+}
+
+function serializeBorders(borders: TableBordersLike): string {
+  const sides = ["top", "left", "bottom", "right", "insideH", "insideV"] as const;
+  return sides
+    .filter((side) => borders[side] !== undefined)
+    .map((side) => serializeBorderSpec(side, borders[side]!))
+    .join("");
+}
+
+function serializeBorderSpec(elementName: string, border: BorderSpecLike): string {
+  const attrs: string[] = [];
+  if (border.value) attrs.push(`w:val="${escapeAttribute(border.value)}"`);
+  if (border.size !== undefined) attrs.push(`w:sz="${border.size}"`);
+  if (border.space !== undefined) attrs.push(`w:space="${border.space}"`);
+  if (border.color) attrs.push(`w:color="${escapeAttribute(border.color)}"`);
+  return attrs.length > 0 ? `<w:${elementName} ${attrs.join(" ")}/>` : "";
+}
+
+function serializeTableCellMargins(margins: TableCellMarginsLike): string {
+  const parts: string[] = [];
+  if (margins.top !== undefined) parts.push(`<w:top w:w="${margins.top}" w:type="dxa"/>`);
+  if (margins.left !== undefined) parts.push(`<w:left w:w="${margins.left}" w:type="dxa"/>`);
+  if (margins.bottom !== undefined) parts.push(`<w:bottom w:w="${margins.bottom}" w:type="dxa"/>`);
+  if (margins.right !== undefined) parts.push(`<w:right w:w="${margins.right}" w:type="dxa"/>`);
+  return parts.join("");
+}
+
+function serializeTableLook(tblLook: TableLookLike): string {
+  const attrs: string[] = [];
+  if (tblLook.val) {
+    attrs.push(`w:val="${escapeAttribute(tblLook.val)}"`);
+  }
+  for (const [key, attr] of [
+    ["firstRow", "w:firstRow"],
+    ["lastRow", "w:lastRow"],
+    ["firstColumn", "w:firstColumn"],
+    ["lastColumn", "w:lastColumn"],
+    ["noHBand", "w:noHBand"],
+    ["noVBand", "w:noVBand"],
+  ] as const) {
+    const value = tblLook[key];
+    if (value !== undefined) {
+      attrs.push(`${attr}="${value ? "1" : "0"}"`);
+    }
+  }
+  return attrs.length > 0 ? `<w:tblLook ${attrs.join(" ")}/>` : "";
+}
+
+function serializeCellShading(shading: CellShadingLike): string {
+  const attrs: string[] = [];
+  if (shading.val) attrs.push(`w:val="${escapeAttribute(shading.val)}"`);
+  if (shading.color) attrs.push(`w:color="${escapeAttribute(shading.color)}"`);
+  if (shading.fill) attrs.push(`w:fill="${escapeAttribute(shading.fill)}"`);
+  return attrs.length > 0 ? `<w:shd ${attrs.join(" ")}/>` : "";
+}
+
+function escapeAttribute(value: string): string {
+  return value
+    .replace(/&/gu, "&amp;")
+    .replace(/"/gu, "&quot;")
+    .replace(/</gu, "&lt;")
+    .replace(/>/gu, "&gt;");
+}

package/src/io/normalize/normalize-text.ts

@@ -199,6 +199,11 @@ function normalizeTable(
     ...(table.propertiesXml ? { propertiesXml: table.propertiesXml } : {}),
     gridColumns: table.gridColumns,
     rows,
+    ...(table.width ? { width: table.width } : {}),
+    ...(table.alignment ? { alignment: table.alignment } : {}),
+    ...(table.borders ? { borders: table.borders } : {}),
+    ...(table.cellMargins ? { cellMargins: table.cellMargins } : {}),
+    ...(table.tblLook ? { tblLook: table.tblLook } : {}),
   };
 }
 
@@ -215,6 +220,9 @@ function normalizeTableRow(
     ...(row.widthBefore ? { widthBefore: row.widthBefore } : {}),
     ...(row.gridAfter !== undefined ? { gridAfter: row.gridAfter } : {}),
     ...(row.widthAfter ? { widthAfter: row.widthAfter } : {}),
+    ...(row.height !== undefined ? { height: row.height } : {}),
+    ...(row.heightRule ? { heightRule: row.heightRule } : {}),
+    ...(row.isHeader !== undefined ? { isHeader: row.isHeader } : {}),
     cells,
   };
 }
@@ -237,6 +245,10 @@ function normalizeTableCell(
     ...(cell.propertiesXml ? { propertiesXml: cell.propertiesXml } : {}),
     ...(cell.gridSpan ? { gridSpan: cell.gridSpan } : {}),
     ...(cell.verticalMerge ? { verticalMerge: cell.verticalMerge } : {}),
+    ...(cell.width ? { width: cell.width } : {}),
+    ...(cell.borders ? { borders: cell.borders } : {}),
+    ...(cell.shading ? { shading: cell.shading } : {}),
+    ...(cell.verticalAlign ? { verticalAlign: cell.verticalAlign } : {}),
     children,
   };
 }
@@ -262,6 +274,7 @@ function normalizeCustomXml(
     type: "custom_xml",
     ...(block.uri ? { uri: block.uri } : {}),
     ...(block.element ? { element: block.element } : {}),
+    ...(block.rawXml ? { rawXml: block.rawXml } : {}),
     children: block.children.flatMap((child) => normalizeBlocks(child, state, packagePartName)),
   };
 }
@@ -321,7 +334,7 @@ function normalizeInlineChildren(
             ...(node.marks && node.marks.length > 0 ? { marks: node.marks } : {}),
           });
         }
-        state.cursor += node.text.length;
+        state.cursor += Array.from(node.text).length;
         break;
       }
       case "tab":
@@ -431,6 +444,7 @@ function normalizeInlineChildren(
           ? normalizeInlineChildren(node.children, state, packagePartName)
           : normalizeFieldContentXml(node.contentXml ?? "");
         state.cursor = cursorBeforeField;
+        const renderedLength = measureNormalizedInlineDisplayLength(fieldChildren);
         normalized.push({
           type: "field",
           fieldType: node.fieldType,
@@ -440,7 +454,7 @@ function normalizeInlineChildren(
           ...(classification.target ? { fieldTarget: classification.target } : {}),
           refreshStatus: classification.supported ? "stale" : "preserve-only",
         });
-        state.cursor += fieldChildren.length > 0 ? fieldChildren.length : 1;
+        state.cursor += renderedLength > 0 ? renderedLength : 1;
         break;
       }
     }
@@ -538,7 +552,7 @@ function normalizeHyperlink(node: ParsedHyperlinkNode): {
 function measureHyperlink(node: ParsedHyperlinkNode): number {
   return node.children.reduce<number>((size, child) => {
     if (child.type === "text") {
-      return size + child.text.length;
+      return size + Array.from(child.text).length;
     }
     return size + 1;
   }, 0);
@@ -637,3 +651,20 @@ function normalizeFieldContentXml(contentXml: string | undefined): InlineNode[]
 
   return children;
 }
+
+function measureNormalizedInlineDisplayLength(nodes: InlineNode[]): number {
+  return nodes.reduce((total, node) => {
+    switch (node.type) {
+      case "text":
+        return total + Array.from(node.text).length;
+      case "hyperlink":
+      case "field":
+        return total + measureNormalizedInlineDisplayLength(node.children);
+      case "bookmark_start":
+      case "bookmark_end":
+        return total;
+      default:
+        return total + 1;
+    }
+  }, 0);
+}

package/src/io/ooxml/parse-comments.ts

@@ -164,6 +164,9 @@ export function parseCommentsFromOoxml(
             source: "import",
             rootOoxmlCommentId: rootDefinition.commentId,
             rootParaId: rootDefinition.paraId,
+            detachedReason: "incomplete-markers",
+            actionabilityNote:
+              "Re-anchoring requires the host to supply a valid range. The comment body and thread are preserved for display.",
           },
         }),
       );
@@ -194,6 +197,9 @@ export function parseCommentsFromOoxml(
             source: "import",
             rootOoxmlCommentId: rootDefinition.commentId,
             rootParaId: rootDefinition.paraId,
+            detachedReason: "multi-paragraph",
+            actionabilityNote:
+              "The comment thread and body are preserved. Operators see the thread in the sidebar but cannot navigate to an inline highlight.",
           },
         }),
       );

package/src/io/ooxml/parse-footnotes.ts

@@ -11,6 +11,22 @@ import type {
   TableRowNode,
   TextMark,
 } from "../../model/canonical-document.ts";
+import {
+  readCellBorders,
+  readCellShading,
+  readCellVerticalAlign,
+  readCellWidth,
+  readGridColumns as readSharedGridColumns,
+  readRowHeight,
+  readRowHeightRule,
+  readRowIsHeader,
+  readTableAlignment,
+  readTableBorders,
+  readTableCellMargins,
+  readTableLook,
+  readTableStyleId,
+  readTableWidth,
+} from "./parse-tables.ts";
 
 // ---- XML node types (inline, no external dep) ----
 
@@ -19,11 +35,15 @@ interface XmlElementNode {
   name: string;
   attributes: Record<string, string>;
   children: XmlNode[];
+  start: number;
+  end: number;
 }
 
 interface XmlTextNode {
   type: "text";
   text: string;
+  start: number;
+  end: number;
 }
 
 type XmlNode = XmlElementNode | XmlTextNode;
@@ -656,6 +676,11 @@ function parseSimpleTableElement(tblElement: XmlElementNode): TableNode {
   const rows: TableRowNode[] = [];
   let propertiesXml: string | undefined;
   let styleId: string | undefined;
+  let width: TableNode["width"];
+  let alignment: TableNode["alignment"];
+  let borders: TableNode["borders"];
+  let cellMargins: TableNode["cellMargins"];
+  let tblLook: TableNode["tblLook"];
 
   for (const child of tblElement.children) {
     if (child.type !== "element") continue;
@@ -663,8 +688,12 @@ function parseSimpleTableElement(tblElement: XmlElementNode): TableNode {
 
     if (name === "tblPr") {
       propertiesXml = serializeElementToXml(child);
-      const pStyle = findChildElementOptional(child, "tblStyle");
-      styleId = pStyle?.attributes["w:val"] ?? pStyle?.attributes.val;
+      styleId = readTableStyleId(child);
+      width = readTableWidth(child);
+      alignment = readTableAlignment(child);
+      borders = readTableBorders(child);
+      cellMargins = readTableCellMargins(child);
+      tblLook = readTableLook(child);
     } else if (name === "tblGrid") {
       gridColumns = readGridColumns(child);
     } else if (name === "tr") {
@@ -678,24 +707,24 @@ function parseSimpleTableElement(tblElement: XmlElementNode): TableNode {
     ...(propertiesXml ? { propertiesXml } : {}),
     gridColumns,
     rows,
+    ...(width ? { width } : {}),
+    ...(alignment ? { alignment } : {}),
+    ...(borders ? { borders } : {}),
+    ...(cellMargins ? { cellMargins } : {}),
+    ...(tblLook ? { tblLook } : {}),
   };
 }
 
 function readGridColumns(tblGrid: XmlElementNode): number[] {
-  const columns: number[] = [];
-  for (const child of tblGrid.children) {
-    if (child.type !== "element") continue;
-    if (localName(child.name) === "gridCol") {
-      const w = child.attributes["w:w"] ?? child.attributes.w ?? "0";
-      columns.push(Number.parseInt(w, 10) || 0);
-    }
-  }
-  return columns;
+  return readSharedGridColumns(tblGrid);
 }
 
 function parseSimpleTableRow(trElement: XmlElementNode): TableRowNode {
   const cells: TableCellNode[] = [];
   let propertiesXml: string | undefined;
+  let height: TableRowNode["height"];
+  let heightRule: TableRowNode["heightRule"];
+  let isHeader: TableRowNode["isHeader"];
 
   for (const child of trElement.children) {
     if (child.type !== "element") continue;
@@ -703,6 +732,9 @@ function parseSimpleTableRow(trElement: XmlElementNode): TableRowNode {
 
     if (name === "trPr") {
       propertiesXml = serializeElementToXml(child);
+      height = readRowHeight(child);
+      heightRule = readRowHeightRule(child);
+      isHeader = readRowIsHeader(child);
     } else if (name === "tc") {
       cells.push(parseSimpleTableCell(child));
     }
@@ -711,6 +743,9 @@ function parseSimpleTableRow(trElement: XmlElementNode): TableRowNode {
   return {
     type: "table_row",
     ...(propertiesXml ? { propertiesXml } : {}),
+    ...(height !== undefined ? { height } : {}),
+    ...(heightRule ? { heightRule } : {}),
+    ...(isHeader !== undefined ? { isHeader } : {}),
     cells,
   };
 }
@@ -720,6 +755,10 @@ function parseSimpleTableCell(tcElement: XmlElementNode): TableCellNode {
   let propertiesXml: string | undefined;
   let gridSpan: number | undefined;
   let verticalMerge: "restart" | "continue" | undefined;
+  let width: TableCellNode["width"];
+  let borders: TableCellNode["borders"];
+  let shading: TableCellNode["shading"];
+  let verticalAlign: TableCellNode["verticalAlign"];
 
   for (const child of tcElement.children) {
     if (child.type !== "element") continue;
@@ -736,6 +775,10 @@ function parseSimpleTableCell(tcElement: XmlElementNode): TableCellNode {
         const vmVal = vmEl.attributes["w:val"] ?? vmEl.attributes.val ?? "continue";
         verticalMerge = vmVal === "restart" ? "restart" : "continue";
       }
+      width = readCellWidth(child);
+      borders = readCellBorders(child);
+      shading = readCellShading(child);
+      verticalAlign = readCellVerticalAlign(child);
     } else if (name === "p") {
       children.push(parseParagraphElement(child));
     }
@@ -746,6 +789,10 @@ function parseSimpleTableCell(tcElement: XmlElementNode): TableCellNode {
     ...(propertiesXml ? { propertiesXml } : {}),
     ...(gridSpan ? { gridSpan } : {}),
     ...(verticalMerge ? { verticalMerge } : {}),
+    ...(width ? { width } : {}),
+    ...(borders ? { borders } : {}),
+    ...(shading ? { shading } : {}),
+    ...(verticalAlign ? { verticalAlign } : {}),
     children: children.length > 0 ? children : [{ type: "paragraph", children: [] }],
   };
 }
@@ -791,6 +838,8 @@ function parseXml(xml: string): XmlElementNode {
     name: "__root__",
     attributes: {},
     children: [],
+    start: 0,
+    end: xml.length,
   };
   const stack: XmlElementNode[] = [root];
   let cursor = 0;
@@ -814,6 +863,8 @@ function parseXml(xml: string): XmlElementNode {
       stack[stack.length - 1]?.children.push({
         type: "text",
         text: xml.slice(cursor + 9, textEnd),
+        start: cursor,
+        end: end >= 0 ? end + 3 : xml.length,
       });
       cursor = end >= 0 ? end + 3 : xml.length;
       continue;
@@ -824,7 +875,7 @@ function parseXml(xml: string): XmlElementNode {
       const end = nextTag >= 0 ? nextTag : xml.length;
       const text = decodeXmlEntities(xml.slice(cursor, end));
       if (text.trim().length > 0 || (text.length > 0 && stack.length > 1)) {
-        stack[stack.length - 1]?.children.push({ type: "text", text });
+        stack[stack.length - 1]?.children.push({ type: "text", text, start: cursor, end });
       }
       cursor = end;
       continue;
@@ -833,7 +884,10 @@ function parseXml(xml: string): XmlElementNode {
     if (xml[cursor + 1] === "/") {
       const end = xml.indexOf(">", cursor);
       if (end < 0) break;
-      stack.pop();
+      const current = stack.pop();
+      if (current) {
+        current.end = end + 1;
+      }
       cursor = end + 1;
       continue;
     }
@@ -855,6 +909,8 @@ function parseXml(xml: string): XmlElementNode {
       name: tagName,
       attributes,
       children: [],
+      start: cursor,
+      end: tagEnd + 1,
     };
 
     stack[stack.length - 1]?.children.push(element);