@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-47MFDPH4.js

@@ -0,0 +1,419 @@
+import {
+  paragraphTextRun,
+  replaceParagraphContent
+} from "./chunk-GGOZXIGH.js";
+import {
+  cellCoordinates,
+  tableGridCount
+} from "./chunk-IR6ZKAUH.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  paragraphTextHistory,
+  runElementOpen
+} from "./chunk-YPVBU7QF.js";
+import {
+  SelectionError
+} from "./chunk-LQOKYG3O.js";
+import {
+  InvalidPackageError
+} from "./chunk-MWAAMNAM.js";
+import {
+  InvalidValueError
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/table-merge.ts
+function children(node, name) {
+  return node.children.filter((c) => c.namespace === node.namespace && c.localName === name);
+}
+function one(node, name, projected = (node2) => node2.children) {
+  const found = projected(node).filter((child) => child.namespace === node.namespace && child.localName === name);
+  if (found.length > 1) throw new InvalidPackageError("Duplicate table grid property.");
+  return found[0];
+}
+function attribute(node, name) {
+  return node.attributes.find((a) => a.namespace === node.namespace && a.localName === name)?.value;
+}
+function mergedTableGrid(table, budget, projected = (node) => node.children) {
+  const nativeChildren = (node, name) => projected(node).filter((child) => child.namespace === node.namespace && child.localName === name);
+  const oneNative = (node, name) => {
+    const found = nativeChildren(node, name);
+    if (found.length > 1) throw new InvalidPackageError("Duplicate table grid property.");
+    return found[0];
+  };
+  const grid = oneNative(table, "tblGrid"), rows = nativeChildren(table, "tr");
+  const columns = grid ? nativeChildren(grid, "gridCol") : [];
+  if (!columns.length || !rows.length) throw new InvalidPackageError("Expected a nonempty table grid.");
+  budget.table(rows.length, columns.length);
+  const owners = [], physical = [], slots = [];
+  let above = /* @__PURE__ */ new Map();
+  for (const [r, row] of rows.entries()) {
+    const props = oneNative(row, "trPr");
+    let cursor = tableGridCount(props && oneNative(props, "gridBefore"), 0);
+    const after = tableGridCount(props && oneNative(props, "gridAfter"), 0), next = /* @__PURE__ */ new Map();
+    physical.push([]);
+    slots.push([]);
+    for (const node of nativeChildren(row, "tc")) {
+      const props2 = oneNative(node, "tcPr"), span = tableGridCount(props2 && oneNative(props2, "gridSpan"), 1);
+      if (!span || cursor + span > columns.length) throw new InvalidPackageError("Cell exceeds the table grid.");
+      if (props2 && oneNative(props2, "hMerge")) throw new UnsupportedEditError("Legacy horizontal merge markers are ambiguous.");
+      const merge = props2 && oneNative(props2, "vMerge"), value = merge ? attribute(merge, "val") ?? "continue" : void 0;
+      if (value !== void 0 && !["continue", "restart"].includes(value)) throw new InvalidPackageError("Invalid vertical merge marker.");
+      let owner;
+      if (value === "continue") {
+        const prior = above.get(cursor);
+        if (!prior || prior.column !== cursor || prior.columnSpan !== span) throw new InvalidPackageError("Vertical continuation does not match its owner.");
+        owner = prior;
+        owner.rowSpan++;
+      } else {
+        owner = { node, row: r, column: cursor, rowSpan: 1, columnSpan: span, physical: [] };
+        owners.push(owner);
+      }
+      const entry = { node, row: r, column: cursor, span, owner };
+      owner.physical.push(entry);
+      physical[r].push(entry);
+      for (let c = cursor; c < cursor + span; c++) {
+        budget.charge("work", 1);
+        budget.charge("retainedBytes", 64);
+        slots[r][c] = owner;
+      }
+      if (merge) next.set(cursor, owner);
+      cursor += span;
+    }
+    if (cursor + after !== columns.length) throw new InvalidPackageError("Row disagrees with its logical table grid.");
+    above = next;
+  }
+  return { rows, columns, owners, physical, slots };
+}
+function closedStructure(table, grid, projected) {
+  if (projected(table).some((n) => n.namespace !== table.namespace || !["tblPr", "tblGrid", "tr"].includes(n.localName)) || grid.rows.some((row) => projected(row).some((n) => n.namespace !== table.namespace || !["trPr", "tc"].includes(n.localName))) || grid.slots.some((row) => Array.from({ length: grid.columns.length }, (_, i) => row[i]).some((cell) => !cell)))
+    throw new UnsupportedEditError("Merge edits require rectangular tables without omitted or wrapped cells.");
+}
+function tag(w, name, value) {
+  return `<m:${name} xmlns:m="${w}"${value === void 0 ? "" : ` m:val="${value}"`}/>`;
+}
+function fragment(xml, node) {
+  return runElementOpen(node) + xml.sourceXml(node, /* @__PURE__ */ new Map(), true) + `</${node.name}>`;
+}
+function blocks(xml, node) {
+  const props = one(node, "tcPr");
+  const patches = new Map(props ? [[props, ""]] : []);
+  for (const child of node.children) if (child !== props) patches.set(child, fragment(xml, child));
+  return xml.sourceXml(node, patches, true);
+}
+function empty(node) {
+  return node.children.every((n) => n.localName === "tcPr" && n.namespace === node.namespace || n.localName === "p" && n.namespace === node.namespace && n.children.length === 0 && n.attributes.every((a) => a.namespace === "http://www.w3.org/2000/xmlns/") && n.content.every((c) => c.kind === "text" && !c.text.trim())) && node.content.every((c) => c.kind === "element" || c.kind === "text" && !c.text.trim());
+}
+function cellMarkup(xml, node, span, merge, body, width2, projected, preserveCarriers = true) {
+  const props = one(node, "tcPr", projected);
+  const changes = /* @__PURE__ */ new Map();
+  for (const name of ["gridSpan", "vMerge", ...width2 === void 0 ? [] : ["tcW"]]) {
+    const old = props && one(props, name, projected);
+    if (old) changes.set(old, "");
+  }
+  const additions = (width2 === void 0 ? "" : `<m:tcW xmlns:m="${node.namespace}" m:w="${width2}" m:type="dxa"/>`) + (span > 1 ? tag(node.namespace, "gridSpan", String(span)) : "") + (merge ? tag(node.namespace, "vMerge", merge) : "");
+  const early = ["cnfStyle", "tcW"];
+  const next = props && projected(props).find((n) => !early.includes(n.localName) && !changes.has(n));
+  if (next) changes.set(next, additions + xml.sourceXml(next));
+  const nativeMarkup = (root) => {
+    const output = [], pending = [{ node: root, closing: false }];
+    while (pending.length) {
+      const frame = pending.pop(), n = frame.node;
+      if (frame.closing) {
+        output.push(`</${n.name}>`);
+        continue;
+      }
+      if (n.namespace !== node.namespace) continue;
+      output.push(runElementOpen({ ...n, attributes: n.attributes.filter((a) => [node.namespace, "http://www.w3.org/XML/1998/namespace", "http://www.w3.org/2000/xmlns/"].includes(a.namespace)) }));
+      pending.push({ node: n, closing: true });
+      for (const child of [...projected(n)].reverse()) pending.push({ node: child, closing: false });
+    }
+    return output.join("");
+  };
+  let inner;
+  if (preserveCarriers) inner = (props ? xml.sourceXml(props, changes, true) : "") + (next ? "" : additions);
+  else {
+    const native = props ? projected(props).filter((n) => !changes.has(n) || n === next) : [];
+    inner = native.map((n) => (n === next ? additions : "") + nativeMarkup(n)).join("") + (next ? "" : additions);
+  }
+  const properties = props && preserveCarriers ? runElementOpen(props) + inner + `</${props.name}>` : `<m:tcPr xmlns:m="${node.namespace}">${inner}</m:tcPr>`;
+  return runElementOpen(node) + properties + body + `</${node.name}>`;
+}
+function width(grid, start, span, row, projected, preferCells = false) {
+  const widths = grid.columns.slice(start, start + span).map((n) => Number(attribute(n, "w")));
+  const total = widths.reduce((a, b) => a + b, 0);
+  const gridWidth = widths.every((n) => Number.isSafeInteger(n) && n > 0) && Number.isSafeInteger(total) ? total : void 0;
+  if (!preferCells && gridWidth !== void 0) return gridWidth;
+  let sum = 0;
+  for (const cell of grid.physical[row].filter((p) => p.column < start + span && p.column + p.span > start)) {
+    const props = one(cell.node, "tcPr", projected), stored = props && one(props, "tcW", projected);
+    if (!stored || attribute(stored, "type") !== "dxa") return gridWidth;
+    const overlap = Math.min(start + span, cell.column + cell.span) - Math.max(start, cell.column);
+    const value = Number(attribute(stored, "w")) * overlap / cell.span;
+    if (!Number.isSafeInteger(value) || value < 0) return gridWidth;
+    sum += value;
+  }
+  return Number.isSafeInteger(sum) && sum >= 0 ? sum : gridWidth;
+}
+function editMergedTable(xml, table, selected, operation, options, budget, projected = (node) => node.children) {
+  const grid = mergedTableGrid(table, budget, projected);
+  closedStructure(table, grid, projected);
+  const patches = /* @__PURE__ */ new Map();
+  if (operation === "tables.rows.remove") {
+    const r = options.index - 1;
+    if (!grid.rows[r]) throw new SelectionError("missing-selection");
+    if (grid.rows.length === 1) throw new InvalidValueError("Removal must retain one row.");
+    const crossing = grid.owners.filter((o) => o.rowSpan > 1 && o.row <= r && o.row + o.rowSpan > r);
+    if (crossing.length && options.join !== "paragraphs") throw new InvalidValueError("Deleting through spans requires an explicit paragraphs join.");
+    if (crossing.length) {
+      const pending = [table];
+      while (pending.length) {
+        const node = pending.pop();
+        budget.charge("work", 1);
+        if (node.namespace === table.namespace && ["fldChar", "bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "permStart", "permEnd"].includes(node.localName))
+          throw new UnsupportedEditError("Deleting through spans cannot move range markers or complex fields.");
+        for (const child of node.children) pending.push(child);
+      }
+    }
+    for (const owner of crossing) {
+      const retained = owner.physical.filter((p) => p.row !== r), first = retained[0];
+      const content = owner.physical.filter((p) => p.node === owner.node || !empty(p.node)).map((p) => blocks(xml, p.node)).join("");
+      for (const p of retained) patches.set(p.node, cellMarkup(xml, p.node, owner.columnSpan, retained.length > 1 ? p === first ? "restart" : "continue" : void 0, p === first ? content : tag(table.namespace, "p"), width(grid, p.column, p.span, p.row, projected), projected));
+    }
+    const rowPatches2 = /* @__PURE__ */ new Map();
+    for (const row of grid.rows) {
+      const local = new Map([...patches].filter(([n]) => projected(row).includes(n)));
+      if (local.size) rowPatches2.set(row, xml.sourceXml(row, local));
+    }
+    rowPatches2.set(grid.rows[r], "");
+    return xml.sourceXml(table, rowPatches2);
+  }
+  let top, left, bottom, right;
+  if (operation === "tables.merge") {
+    if (selected !== table) throw new InvalidValueError("Merge requires a table anchor and explicit corners.");
+    const from = cellCoordinates(options.from), to = cellCoordinates(options.to);
+    top = from.row - 1;
+    left = from.column - 1;
+    bottom = to.row - 1;
+    right = to.column - 1;
+    if (top > bottom || left > right) throw new InvalidValueError("Merge corners must be top-left and bottom-right.");
+  } else {
+    const owner = grid.owners.find((o) => o.node === selected);
+    if (!owner) throw new InvalidValueError("Split requires a logical cell anchor.");
+    top = owner.row;
+    left = owner.column;
+    bottom = top + owner.rowSpan - 1;
+    right = left + owner.columnSpan - 1;
+    if (owner.rowSpan % options.rows !== 0 || owner.columnSpan % options.cols !== 0 || owner.rowSpan * owner.columnSpan === 1)
+      throw new InvalidValueError("Split dimensions must divide the existing merged grid slots.");
+  }
+  if (!grid.slots[top]?.[left] || !grid.slots[bottom]?.[right]) throw new SelectionError("missing-selection");
+  const owners = grid.owners.filter((o) => o.row <= bottom && o.row + o.rowSpan > top && o.column <= right && o.column + o.columnSpan > left);
+  if (owners.some((o) => o.row < top || o.column < left || o.row + o.rowSpan - 1 > bottom || o.column + o.columnSpan - 1 > right))
+    throw new SelectionError("ambiguous-selection");
+  const physical = grid.physical.flat().filter((p) => owners.includes(p.owner));
+  if (operation === "tables.merge") {
+    if (options.join === "reject" && physical.some((p) => !empty(p.node))) throw new InvalidValueError("Merge content requires paragraphs join.");
+    const body = physical.filter((p) => !empty(p.node)).map((p) => blocks(xml, p.node)).join("") || tag(table.namespace, "p");
+    for (let r = top; r <= bottom; r++) {
+      const local = physical.filter((p) => p.row === r);
+      for (const [i, p] of local.entries()) patches.set(p.node, i ? "" : cellMarkup(xml, p.node, right - left + 1, bottom > top ? r === top ? "restart" : "continue" : void 0, r === top ? body : tag(table.namespace, "p"), width(grid, left, right - left + 1, r, projected, true), projected));
+    }
+  } else {
+    const body = physical.filter((p) => p.node === selected || !empty(p.node)).map((p) => blocks(xml, p.node)).join("");
+    let distribution;
+    if (options.distribute === "paragraphs") {
+      const content = physical.filter((p) => p.node === selected || !empty(p.node));
+      if (content.some((p) => p.node.children.some((n) => n.localName !== "tcPr" && (n.namespace !== table.namespace || n.localName !== "p")) || p.node.content.some((c) => c.kind !== "element" && (c.kind !== "text" || c.text.trim())))) throw new UnsupportedEditError("Paragraph distribution requires only paragraph blocks.");
+      distribution = content.flatMap((p) => children(p.node, "p").map((n) => fragment(xml, n)));
+      if (distribution.length !== options.rows * options.cols) throw new InvalidValueError("Paragraph distribution requires one paragraph per resulting cell.");
+    }
+    for (const p of physical) {
+      let markup = "";
+      const rowStep = (bottom - top + 1) / options.rows, columnStep = (right - left + 1) / options.cols;
+      const first = (p.row - top) % rowStep === 0;
+      for (let c = left; c <= right; c += columnStep) {
+        const i = Math.floor((p.row - top) / rowStep) * options.cols + (c - left) / columnStep;
+        const content = first ? distribution ? distribution[i] : i === 0 ? body : tag(table.namespace, "p") : tag(table.namespace, "p");
+        markup += cellMarkup(xml, p.node, columnStep, rowStep > 1 ? first ? "restart" : "continue" : void 0, content, width(grid, c, columnStep, p.row, projected), projected, c === left);
+      }
+      patches.set(p.node, markup);
+    }
+  }
+  const rowPatches = /* @__PURE__ */ new Map();
+  for (const row of grid.rows) {
+    const local = new Map([...patches].filter(([n]) => projected(row).includes(n)));
+    if (local.size) rowPatches.set(row, xml.sourceXml(row, local));
+  }
+  return xml.sourceXml(table, rowPatches);
+}
+
+// packages/safe-bash-docx-engine/src/cell-content.ts
+function replaceCellContent(xml, cell, text, budget, raster, properties) {
+  const children2 = activeXmlChildren(xml, budget), active = children2(cell);
+  const containers = active.filter((node) => node.namespace === cell.namespace && node.localName === "tcPr");
+  if (containers.length > 1) throw new UnsupportedEditError("Whole cell text requires one owning property container.");
+  const storyNames = /* @__PURE__ */ new Set(["body", "hdr", "ftr", "footnote", "endnote", "comment", "txbxContent"]);
+  let story = xml.root, inSimpleField = false;
+  const pendingOwners = [{ node: xml.root, owner: xml.root, simple: false }];
+  while (pendingOwners.length) {
+    const frame = pendingOwners.pop(), node = frame.node;
+    let { owner, simple } = frame;
+    budget.charge("work", 1);
+    if (node.namespace === cell.namespace && storyNames.has(node.localName)) owner = node;
+    simple ||= node.namespace === cell.namespace && node.localName === "fldSimple";
+    if (node === cell) {
+      story = owner;
+      inSimpleField = simple;
+      break;
+    }
+    const active2 = children2(node);
+    for (let index = active2.length - 1; index >= 0; index--) pendingOwners.push({ node: active2[index], owner, simple });
+  }
+  let depth = 0;
+  const preceding = [story];
+  while (preceding.length) {
+    const node = preceding.pop();
+    budget.charge("work", 1);
+    if (node === cell) break;
+    if (node !== story && node.namespace === cell.namespace && storyNames.has(node.localName)) continue;
+    if (node.namespace === cell.namespace && node.localName === "fldChar") {
+      const kind = node.attributes.find((attribute2) => attribute2.namespace === cell.namespace && attribute2.localName === "fldCharType")?.value;
+      if (kind === "begin") depth++;
+      if (kind === "end") depth--;
+    }
+    const active2 = children2(node);
+    for (let index = active2.length - 1; index >= 0; index--) preceding.push(active2[index]);
+  }
+  if (depth > 0 || inSimpleField) throw new UnsupportedEditError("Cell text replacement cannot edit content inside a field range.");
+  const contents = [], blocks2 = [];
+  const markers = /* @__PURE__ */ new Set(["bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "proofErr", "permStart", "permEnd"]);
+  const propertyNames = (node) => node.localName === "tbl" ? ["tblPr", "tblGrid"] : node.localName === "tr" ? ["trPr"] : ["tcPr"];
+  const assertNative = (root) => {
+    const pending2 = [{ node: root, scopes: 1, blocks: true }];
+    while (pending2.length) {
+      const { node, scopes, blocks: blocks3 } = pending2.pop();
+      budget.charge("work", scopes);
+      if (!xml.compatibility.canEdit(node) || node.attributes.some((attribute2) => attribute2.namespace !== "http://www.w3.org/2000/xmlns/" && !xml.compatibility.canEdit(attribute2)))
+        throw new UnsupportedEditError("Whole cell text cannot discard opaque table ownership.");
+      const nativeBlocks = blocks3 && node.namespace === cell.namespace && ["tbl", "tr", "tc"].includes(node.localName);
+      const properties2 = propertyNames(node);
+      for (let index = node.children.length - 1; index >= 0; index--) {
+        const child = node.children[index], block = nativeBlocks && !(child.namespace === cell.namespace && properties2.includes(child.localName));
+        pending2.push({ node: child, scopes: scopes + (block && child.namespace === cell.namespace && child.localName === "tbl" ? 1 : 0), blocks: block });
+      }
+    }
+  };
+  const pending = [];
+  const collect = (root) => {
+    pending.push({ node: root, validated: false });
+    while (pending.length) {
+      const item = pending.pop();
+      if ("text" in item) {
+        contents.push(item.text);
+        continue;
+      }
+      const { node } = item;
+      if (item.property) {
+        const properties3 = [node];
+        while (properties3.length) {
+          const property = properties3.pop();
+          budget.charge("work", 1);
+          if (property.localName.endsWith("Change") || ["ins", "del", "cellIns", "cellDel", "cellMerge"].includes(property.localName))
+            throw new UnsupportedEditError("Whole cell text cannot discard review history.");
+          for (let index = property.children.length - 1; index >= 0; index--) properties3.push(property.children[index]);
+        }
+        continue;
+      }
+      budget.charge("work", 1);
+      if (node.namespace !== cell.namespace) throw new UnsupportedEditError("Whole cell text cannot discard opaque blocks.");
+      if (node.localName === "p") {
+        contents.push(node);
+        continue;
+      }
+      if (markers.has(node.localName)) {
+        contents.push(runElementOpen(node) + xml.sourceXml(node, /* @__PURE__ */ new Map(), true) + `</${node.name}>`);
+        continue;
+      }
+      if (!["tbl", "tr", "tc"].includes(node.localName)) throw new UnsupportedEditError("Whole cell text requires native paragraph or table blocks.");
+      if (node.localName === "tbl" && !item.validated) assertNative(node);
+      const validated = item.validated || node.localName === "tbl", properties2 = propertyNames(node);
+      for (let index = node.content.length - 1; index >= 0; index--) {
+        const child = node.content[index];
+        if (child.kind === "comment") {
+          pending.push({ text: "<!--" + child.text + "-->" });
+          continue;
+        }
+        if (child.kind === "processing-instruction") {
+          pending.push({ text: "<?" + child.target + (child.text ? " " + child.text : "") + "?>" });
+          continue;
+        }
+        if (child.kind !== "element") {
+          if (child.text.trim()) throw new UnsupportedEditError("Whole cell text cannot discard table scalars.");
+          continue;
+        }
+        pending.push({ node: child, validated, property: child.namespace === cell.namespace && properties2.includes(child.localName) });
+      }
+    }
+  };
+  for (const child of active) if (!containers.includes(child)) {
+    blocks2.push(child);
+    collect(child);
+  }
+  const history = paragraphTextHistory(xml.root, contents.filter((item) => typeof item !== "string"), children2, budget);
+  const patches = /* @__PURE__ */ new Map();
+  let paragraph = "";
+  let prefix = "", assigned = false;
+  for (const item of contents) {
+    if (typeof item === "string") {
+      if (!paragraph) prefix += item;
+      else {
+        const end = paragraph.lastIndexOf("</");
+        paragraph = paragraph.slice(0, end) + item + paragraph.slice(end);
+      }
+      continue;
+    }
+    const retained = replaceParagraphContent(xml, item, "", assigned ? "" : text, budget, raster, history);
+    assigned = true;
+    if (!paragraph) {
+      paragraph = retained;
+      const start = paragraph.indexOf(">") + 1;
+      paragraph = paragraph.slice(0, start) + prefix + paragraph.slice(start);
+    } else {
+      const fragment3 = new DocumentXmlEditor(new TextEncoder().encode(retained), {}, void 0, budget);
+      const scope = new Map(fragment3.root.children.map((child) => [
+        child,
+        runElementOpen(child) + fragment3.sourceXml(child, /* @__PURE__ */ new Map(), true) + `</${child.name}>`
+      ]));
+      const end = paragraph.lastIndexOf("</");
+      paragraph = paragraph.slice(0, end) + fragment3.sourceXml(fragment3.root, scope, true) + paragraph.slice(end);
+    }
+  }
+  if (!paragraph) paragraph = `<cc:p xmlns:cc="${cell.namespace}">${prefix}${paragraphTextRun(cell.namespace, text)}</cc:p>`;
+  else {
+    const fragment3 = new DocumentXmlEditor(new TextEncoder().encode(paragraph), {}, void 0, budget);
+    if (!activeXmlChildren(fragment3, budget)(fragment3.root).some((node) => node.namespace === cell.namespace && node.localName === "r")) {
+      const end = paragraph.lastIndexOf("</");
+      paragraph = paragraph.slice(0, end) + paragraphTextRun(cell.namespace, "") + paragraph.slice(end);
+    }
+  }
+  const fragment2 = new DocumentXmlEditor(new TextEncoder().encode(paragraph), {}, void 0, budget);
+  const projected = activeXmlChildren(fragment2, budget), runs = projected(fragment2.root).filter((node) => node.namespace === cell.namespace && node.localName === "r");
+  if (runs.some((run) => projected(run).some((node) => node.namespace === cell.namespace && node.localName === "commentReference"))) {
+    if (runs.some((run) => run.attributes.some((attribute2) => attribute2.namespace !== "http://www.w3.org/2000/xmlns/") || run.children.some((node) => node.namespace !== cell.namespace)))
+      throw new UnsupportedEditError("Cell text cannot relocate an opaque reference owner.");
+    const content = runs.flatMap((run) => run.children.filter((node) => node.localName !== "rPr")).map((node) => runElementOpen(node) + fragment2.sourceXml(node, /* @__PURE__ */ new Map(), true) + `</${node.name}>`).join("");
+    const merged = `<cc:r xmlns:cc="${cell.namespace}">${content}</cc:r>`;
+    paragraph = runElementOpen(fragment2.root) + fragment2.sourceXml(fragment2.root, new Map(runs.map((run, index) => [run, index ? "" : merged])), true) + `</${fragment2.root.name}>`;
+  }
+  blocks2.forEach((block, index) => patches.set(block, index ? "" : paragraph));
+  if (containers[0] && properties !== void 0) patches.set(containers[0], properties);
+  return runElementOpen(cell) + (containers.length ? "" : properties ?? "") + xml.sourceXml(cell, patches, true) + (blocks2.length ? "" : paragraph) + `</${cell.name}>`;
+}
+
+export {
+  mergedTableGrid,
+  editMergedTable,
+  replaceCellContent
+};