@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/io/export/serialize-runtime-revisions.ts

@@ -0,0 +1,463 @@
+import type { RevisionRecord } from "../../review/store/revision-types.ts";
+import {
+  mapRevisionBoundaries,
+  type RevisionParagraphBoundary,
+} from "../ooxml/revision-boundaries.ts";
+
+interface XmlReplacement {
+  start: number;
+  end: number;
+  replacement: string;
+}
+
+export interface SerializedRuntimeRevisionsResult {
+  documentXml: string;
+  serializedRevisionIds: string[];
+  skippedRevisionIds: string[];
+}
+
+const STORY_WRAPPER_PREFIX =
+  `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>` +
+  `<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>`;
+const STORY_WRAPPER_SUFFIX = `</w:body></w:document>`;
+
+export function serializeRuntimeRevisionsIntoDocumentXml(
+  documentXml: string,
+  revisions: readonly RevisionRecord[],
+  boundaries: readonly RevisionParagraphBoundary[] = mapRevisionBoundaries(documentXml),
+): SerializedRuntimeRevisionsResult {
+  const replacements: XmlReplacement[] = [];
+  const serializedRevisionIds: string[] = [];
+  const skippedRevisionIds: string[] = [];
+  const paragraphMarkers = new Map<
+    number,
+    { boundary: RevisionParagraphBoundary; markers: string[]; revisionIds: string[] }
+  >();
+
+  for (const revision of revisions) {
+    if (revision.status !== "active" || revision.anchor.kind !== "range") {
+      continue;
+    }
+
+    if (revision.kind === "property-change") {
+      const propertyChangeReplacement = createPropertyChangeReplacement(documentXml, boundaries, revision);
+      if (!propertyChangeReplacement) {
+        skippedRevisionIds.push(revision.revisionId);
+        continue;
+      }
+      replacements.push(propertyChangeReplacement);
+      serializedRevisionIds.push(revision.revisionId);
+      continue;
+    }
+
+    if (revision.kind !== "insertion" && revision.kind !== "deletion") {
+      continue;
+    }
+
+    const form = revision.metadata.importedRevisionForm;
+    if (form === "paragraph-insertion" || form === "paragraph-deletion") {
+      const paragraphBoundary = findParagraphBoundaryForAnchor(boundaries, revision);
+      if (!paragraphBoundary) {
+        skippedRevisionIds.push(revision.revisionId);
+        continue;
+      }
+
+      const entry = paragraphMarkers.get(paragraphBoundary.paragraphIndex) ?? {
+        boundary: paragraphBoundary,
+        markers: [],
+        revisionIds: [],
+      };
+      entry.markers.push(createParagraphRevisionMarker(revision));
+      entry.revisionIds.push(revision.revisionId);
+      paragraphMarkers.set(paragraphBoundary.paragraphIndex, entry);
+      serializedRevisionIds.push(revision.revisionId);
+      continue;
+    }
+
+    const rangeReplacement = createRangeRevisionReplacement(documentXml, boundaries, revision);
+    if (!rangeReplacement) {
+      skippedRevisionIds.push(revision.revisionId);
+      continue;
+    }
+
+    replacements.push(rangeReplacement);
+    serializedRevisionIds.push(revision.revisionId);
+  }
+
+  for (const { boundary, markers, revisionIds } of paragraphMarkers.values()) {
+    const paragraphInsertion = createParagraphRevisionInsertion(
+      documentXml,
+      boundary,
+      markers,
+    );
+    if (!paragraphInsertion) {
+      skippedRevisionIds.push(...revisionIds);
+      continue;
+    }
+
+    replacements.push(paragraphInsertion);
+  }
+
+  return {
+    documentXml: applyReplacements(documentXml, replacements),
+    serializedRevisionIds,
+    skippedRevisionIds,
+  };
+}
+
+function createPropertyChangeReplacement(
+  documentXml: string,
+  boundaries: readonly RevisionParagraphBoundary[],
+  revision: RevisionRecord,
+): XmlReplacement | undefined {
+  const propertyChange = revision.metadata.propertyChangeData;
+  if (!propertyChange) {
+    return undefined;
+  }
+  if (propertyChange.xmlTag === "pPrChange") {
+    return createParagraphPropertyChangeReplacement(documentXml, boundaries, revision, propertyChange.beforeXml);
+  }
+  if (propertyChange.xmlTag === "rPrChange") {
+    return createRunPropertyChangeReplacement(documentXml, boundaries, revision, propertyChange.beforeXml);
+  }
+  return undefined;
+}
+
+function createParagraphPropertyChangeReplacement(
+  documentXml: string,
+  boundaries: readonly RevisionParagraphBoundary[],
+  revision: RevisionRecord,
+  beforeXml: string,
+): XmlReplacement | undefined {
+  if (revision.anchor.kind !== "range") {
+    return undefined;
+  }
+  const paragraphBoundary = findParagraphBoundaryForRange(
+    boundaries,
+    revision.anchor.range.from,
+    revision.anchor.range.to,
+  );
+  if (!paragraphBoundary) {
+    return undefined;
+  }
+  const insertionIndex = findClosingTagInsertionIndex(
+    documentXml,
+    paragraphBoundary.paragraphPropertiesStart,
+    paragraphBoundary.paragraphPropertiesEnd,
+    "w:pPr",
+  );
+  if (insertionIndex === undefined) {
+    return undefined;
+  }
+  return {
+    start: insertionIndex,
+    end: insertionIndex,
+    replacement: `<w:pPrChange${serializeRevisionAttributes(revision)}>${beforeXml}</w:pPrChange>`,
+  };
+}
+
+function createRunPropertyChangeReplacement(
+  documentXml: string,
+  boundaries: readonly RevisionParagraphBoundary[],
+  revision: RevisionRecord,
+  beforeXml: string,
+): XmlReplacement | undefined {
+  if (revision.anchor.kind !== "range") {
+    return undefined;
+  }
+  const paragraphBoundary = findParagraphBoundaryForRange(
+    boundaries,
+    revision.anchor.range.from,
+    revision.anchor.range.to,
+  );
+  if (!paragraphBoundary) {
+    return undefined;
+  }
+  const startIndex = paragraphBoundary.boundaries.get(revision.anchor.range.from);
+  const endIndex = paragraphBoundary.boundaries.get(revision.anchor.range.to);
+  if (startIndex === undefined || endIndex === undefined || endIndex < startIndex) {
+    return undefined;
+  }
+  const runXml = documentXml.slice(startIndex, endIndex);
+  if (!/^<w:r[\s>][\s\S]*<\/w:r>$/u.test(runXml)) {
+    return undefined;
+  }
+  const changeXml = `<w:rPrChange${serializeRevisionAttributes(revision)}>${beforeXml}</w:rPrChange>`;
+  let replacement: string;
+  if (/<w:rPr[\s>][\s\S]*<\/w:rPr>/u.test(runXml)) {
+    replacement = runXml.replace(/<\/w:rPr>/u, `${changeXml}</w:rPr>`);
+  } else {
+    replacement = runXml.replace(/^(<w:r[\s>][^>]*>)/u, `$1<w:rPr>${changeXml}</w:rPr>`);
+  }
+  if (replacement === runXml) {
+    return undefined;
+  }
+  return {
+    start: startIndex,
+    end: endIndex,
+    replacement,
+  };
+}
+
+export function serializeRuntimeRevisionsIntoStoryXml(
+  storyXml: string,
+  revisions: readonly RevisionRecord[],
+): SerializedRuntimeRevisionsResult {
+  if (revisions.length === 0) {
+    return {
+      documentXml: storyXml,
+      serializedRevisionIds: [],
+      skippedRevisionIds: [],
+    };
+  }
+
+  const xmlDeclMatch = storyXml.match(/^<\?xml[\s\S]*?\?>\s*/u);
+  const xmlDecl = xmlDeclMatch?.[0] ?? "";
+  const withoutDecl = xmlDeclMatch ? storyXml.slice(xmlDecl.length) : storyXml;
+  const rootMatch = withoutDecl.match(/^<([A-Za-z0-9:._-]+)([^>]*)>([\s\S]*)<\/\1>\s*$/u);
+  if (!rootMatch) {
+    return serializeRuntimeRevisionsIntoDocumentXml(storyXml, revisions);
+  }
+
+  const [, tagName, attrs = "", innerXml = ""] = rootMatch;
+  const wrapped = `${STORY_WRAPPER_PREFIX}${innerXml}${STORY_WRAPPER_SUFFIX}`;
+  const serialized = serializeRuntimeRevisionsIntoDocumentXml(wrapped, revisions);
+  return {
+    documentXml:
+      `${xmlDecl}<${tagName}${attrs}>` +
+      serialized.documentXml.slice(
+        STORY_WRAPPER_PREFIX.length,
+        serialized.documentXml.length - STORY_WRAPPER_SUFFIX.length,
+      ) +
+      `</${tagName}>`,
+    serializedRevisionIds: serialized.serializedRevisionIds,
+    skippedRevisionIds: serialized.skippedRevisionIds,
+  };
+}
+
+function createRangeRevisionReplacement(
+  documentXml: string,
+  boundaries: readonly RevisionParagraphBoundary[],
+  revision: RevisionRecord,
+): XmlReplacement | undefined {
+  const { anchor } = revision;
+  if (anchor.kind !== "range") {
+    return undefined;
+  }
+  const paragraphBoundary = findParagraphBoundaryForRange(boundaries, anchor.range.from, anchor.range.to);
+  if (!paragraphBoundary) {
+    return undefined;
+  }
+
+  const startIndex = paragraphBoundary.boundaries.get(anchor.range.from);
+  const endIndex = paragraphBoundary.boundaries.get(anchor.range.to);
+  if (startIndex === undefined || endIndex === undefined || endIndex < startIndex) {
+    return undefined;
+  }
+
+  const xml = documentXml.slice(startIndex, endIndex);
+  const { leadingMarkers, coreXml, trailingMarkers } = peelZeroWidthEdgeMarkers(xml);
+  if (coreXml.length === 0) {
+    return undefined;
+  }
+  const attributes = serializeRevisionAttributes(revision);
+  return {
+    start: startIndex,
+    end: endIndex,
+    replacement:
+      revision.kind === "insertion"
+        ? `${leadingMarkers}<w:ins${attributes}>${coreXml}</w:ins>${trailingMarkers}`
+        : `${leadingMarkers}<w:del${attributes}>${convertRunsToDeletedContent(coreXml)}</w:del>${trailingMarkers}`,
+  };
+}
+
+function createParagraphRevisionMarker(revision: RevisionRecord): string {
+  const markerName = revision.kind === "insertion" ? "w:ins" : "w:del";
+  return `<${markerName}${serializeRevisionAttributes(revision)}/>`;
+}
+
+function createParagraphRevisionInsertion(
+  documentXml: string,
+  paragraphBoundary: RevisionParagraphBoundary,
+  markers: readonly string[],
+): XmlReplacement | undefined {
+  const paragraphXml = documentXml.slice(
+    paragraphBoundary.paragraphStart,
+    paragraphBoundary.paragraphEnd,
+  );
+  const markerXml = markers.join("");
+  const paragraphRunPropertiesInsertionIndex = findClosingTagInsertionIndex(
+    documentXml,
+    paragraphBoundary.paragraphRunPropertiesStart,
+    paragraphBoundary.paragraphRunPropertiesEnd,
+    "w:rPr",
+  );
+  if (paragraphRunPropertiesInsertionIndex !== undefined) {
+    return {
+      start: paragraphRunPropertiesInsertionIndex,
+      end: paragraphRunPropertiesInsertionIndex,
+      replacement: markerXml,
+    };
+  }
+
+  const paragraphPropertiesInsertionIndex = findClosingTagInsertionIndex(
+    documentXml,
+    paragraphBoundary.paragraphPropertiesStart,
+    paragraphBoundary.paragraphPropertiesEnd,
+    "w:pPr",
+  );
+  if (paragraphPropertiesInsertionIndex !== undefined) {
+    return {
+      start: paragraphPropertiesInsertionIndex,
+      end: paragraphPropertiesInsertionIndex,
+      replacement: `<w:rPr>${markerXml}</w:rPr>`,
+    };
+  }
+
+  if (!/<w:p[\s>]/u.test(paragraphXml)) {
+    return undefined;
+  }
+
+  return {
+    start: paragraphBoundary.paragraphStartTagEnd,
+    end: paragraphBoundary.paragraphStartTagEnd,
+    replacement: `<w:pPr><w:rPr>${markerXml}</w:rPr></w:pPr>`,
+  };
+}
+
+function findParagraphBoundaryForRange(
+  boundaries: readonly RevisionParagraphBoundary[],
+  from: number,
+  to: number,
+): RevisionParagraphBoundary | undefined {
+  return boundaries.find(
+    (boundary) => from >= boundary.start && to <= boundary.end,
+  );
+}
+
+function findParagraphBoundaryForAnchor(
+  boundaries: readonly RevisionParagraphBoundary[],
+  revision: RevisionRecord,
+): RevisionParagraphBoundary | undefined {
+  const anchor = revision.anchor.kind === "range" ? revision.anchor.range.from : undefined;
+  if (anchor === undefined) {
+    return undefined;
+  }
+
+  return boundaries.find(
+    (boundary) =>
+      boundary.end === anchor ||
+      (anchor >= boundary.start && anchor <= boundary.end),
+  );
+}
+
+function serializeRevisionAttributes(revision: RevisionRecord): string {
+  const attributes = {
+    "w:id": revision.metadata.ooxmlRevisionId ?? sanitizeRevisionId(revision.revisionId),
+    "w:author": revision.authorId,
+    "w:date": revision.createdAt,
+  };
+
+  return Object.entries(attributes)
+    .filter(([, value]) => value && value.length > 0)
+    .map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`)
+    .join("");
+}
+
+function peelZeroWidthEdgeMarkers(xml: string): {
+  leadingMarkers: string;
+  coreXml: string;
+  trailingMarkers: string;
+} {
+  const markerPattern =
+    /^(?:\s|<(?:\w+:)?(?:bookmarkStart|bookmarkEnd|permStart|permEnd|commentRangeStart|commentRangeEnd|proofErr|lastRenderedPageBreak)\b[^>]*\/>)+$/u;
+  let coreXml = xml;
+  let leadingMarkers = "";
+  let trailingMarkers = "";
+
+  while (true) {
+    const match = coreXml.match(/^\s*(<(?:\w+:)?(?:bookmarkStart|bookmarkEnd|permStart|permEnd|commentRangeStart|commentRangeEnd|proofErr|lastRenderedPageBreak)\b[^>]*\/>)/u);
+    if (!match) {
+      break;
+    }
+    leadingMarkers += match[0];
+    coreXml = coreXml.slice(match[0].length);
+  }
+
+  while (true) {
+    const match = coreXml.match(/(<(?:\w+:)?(?:bookmarkStart|bookmarkEnd|permStart|permEnd|commentRangeStart|commentRangeEnd|proofErr|lastRenderedPageBreak)\b[^>]*\/>)\s*$/u);
+    if (!match) {
+      break;
+    }
+    trailingMarkers = match[0] + trailingMarkers;
+    coreXml = coreXml.slice(0, coreXml.length - match[0].length);
+  }
+
+  if (markerPattern.test(coreXml)) {
+    return {
+      leadingMarkers: xml,
+      coreXml: "",
+      trailingMarkers: "",
+    };
+  }
+
+  return {
+    leadingMarkers,
+    coreXml,
+    trailingMarkers,
+  };
+}
+
+function findClosingTagInsertionIndex(
+  documentXml: string,
+  start: number | undefined,
+  end: number | undefined,
+  tagName: string,
+): number | undefined {
+  if (start === undefined || end === undefined) {
+    return undefined;
+  }
+
+  const closingTag = `</${tagName}>`;
+  const closingIndex = documentXml.lastIndexOf(closingTag, end);
+  if (closingIndex < start) {
+    return undefined;
+  }
+
+  return closingIndex;
+}
+
+function sanitizeRevisionId(revisionId: string): string {
+  const numericTail = /(\d+)$/.exec(revisionId)?.[1];
+  return numericTail ?? revisionId.replace(/[^A-Za-z0-9._-]/g, "-");
+}
+
+function convertRunsToDeletedContent(xml: string): string {
+  return xml
+    .replace(/<(\/?)w:t\b/g, "<$1w:delText")
+    .replace(/<(\/?)w:instrText\b/g, "<$1w:delInstrText");
+}
+
+function applyReplacements(documentXml: string, replacements: readonly XmlReplacement[]): string {
+  const sorted = replacements
+    .slice()
+    .sort((left, right) => right.start - left.start || right.end - left.end);
+  let output = documentXml;
+
+  for (const replacement of sorted) {
+    output =
+      output.slice(0, replacement.start) +
+      replacement.replacement +
+      output.slice(replacement.end);
+  }
+
+  return output;
+}
+
+function escapeAttribute(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}

package/src/io/export/serialize-tables.ts

@@ -0,0 +1,174 @@
+import type {
+  ParsedBorderSpec,
+  ParsedCellMargins,
+  ParsedCellShading,
+  ParsedTable,
+  ParsedTableBorders,
+  ParsedTableCell,
+  ParsedTableCellBorders,
+  ParsedTableLook,
+  ParsedTableRow,
+  ParsedTableWidth,
+} from "../ooxml/parse-tables.ts";
+
+export function serializeTable(table: ParsedTable): string {
+  const propertiesXml = table.propertiesXml ?? buildTablePropertiesXml(table);
+  const gridXml =
+    table.gridColumns.length > 0
+      ? `<w:tblGrid>${table.gridColumns
+          .map((width) => `<w:gridCol w:w="${width}"/>`)
+          .join("")}</w:tblGrid>`
+      : "";
+  const rowsXml = table.rows.map(serializeRow).join("");
+
+  return `<w:tbl>${propertiesXml}${gridXml}${rowsXml}</w:tbl>`;
+}
+
+function serializeRow(row: ParsedTableRow): string {
+  const propertiesXml = row.propertiesXml ?? buildRowPropertiesXml(row);
+  return `<w:tr>${propertiesXml}${row.cells.map(serializeCell).join("")}</w:tr>`;
+}
+
+function serializeCell(cell: ParsedTableCell): string {
+  const propertiesXml = ensureCellProperties(cell);
+  const blocksXml = cell.blocksXml.length > 0 ? cell.blocksXml.join("") : "<w:p/>";
+  return `<w:tc>${propertiesXml}${blocksXml}</w:tc>`;
+}
+
+function buildTablePropertiesXml(table: ParsedTable): string {
+  const children: string[] = [];
+  if (table.styleId) {
+    children.push(`<w:tblStyle w:val="${table.styleId}"/>`);
+  }
+  if (table.width) {
+    children.push(serializeWidth("tblW", table.width));
+  }
+  if (table.alignment) {
+    children.push(`<w:jc w:val="${table.alignment}"/>`);
+  }
+  if (table.borders) {
+    const bordersXml = serializeTableBorders(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.length > 0 ? `<w:tblPr>${children.join("")}</w:tblPr>` : "";
+}
+
+function buildRowPropertiesXml(row: ParsedTableRow): string {
+  const children: string[] = [];
+  if (row.height !== undefined) {
+    const hRuleAttr = row.heightRule ? ` w:hRule="${row.heightRule}"` : "";
+    children.push(`<w:trHeight w:val="${row.height}"${hRuleAttr}/>`);
+  }
+  if (row.isHeader) {
+    children.push(`<w:tblHeader/>`);
+  }
+  return children.length > 0 ? `<w:trPr>${children.join("")}</w:trPr>` : "";
+}
+
+function ensureCellProperties(cell: ParsedTableCell): string {
+  if (cell.propertiesXml) {
+    return cell.propertiesXml;
+  }
+
+  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 = serializeCellBorders(cell.borders);
+    if (bordersXml) children.push(`<w:tcBorders>${bordersXml}</w:tcBorders>`);
+  }
+  if (cell.shading) {
+    children.push(serializeCellShading(cell.shading));
+  }
+  if (cell.verticalAlign) {
+    children.push(`<w:vAlign w:val="${cell.verticalAlign}"/>`);
+  }
+
+  return children.length > 0 ? `<w:tcPr>${children.join("")}</w:tcPr>` : "";
+}
+
+function serializeWidth(element: string, width: ParsedTableWidth): string {
+  return `<w:${element} w:w="${width.value}" w:type="${width.type}"/>`;
+}
+
+function serializeBorderSpec(element: string, spec: ParsedBorderSpec): string {
+  const attrs: string[] = [];
+  if (spec.value) attrs.push(`w:val="${spec.value}"`);
+  if (spec.size !== undefined) attrs.push(`w:sz="${spec.size}"`);
+  if (spec.space !== undefined) attrs.push(`w:space="${spec.space}"`);
+  if (spec.color) attrs.push(`w:color="${spec.color}"`);
+  const attrsStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+  return `<w:${element}${attrsStr}/>`;
+}
+
+function serializeTableBorders(borders: ParsedTableBorders): 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 serializeCellBorders(borders: ParsedTableCellBorders): 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 serializeTableLook(tblLook: ParsedTableLook): string {
+  const attrs: string[] = [];
+  if (tblLook.val) attrs.push(`w:val="${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: ParsedCellShading): string {
+  const attrs: string[] = [];
+  if (shading.val) attrs.push(`w:val="${shading.val}"`);
+  if (shading.color) attrs.push(`w:color="${shading.color}"`);
+  if (shading.fill) attrs.push(`w:fill="${shading.fill}"`);
+  const attrsStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+  return `<w:shd${attrsStr}/>`;
+}
+
+function serializeTableCellMargins(margins: ParsedCellMargins): 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("");
+}