@portone/docx-editor 0.1.0

package/dist/docx/serializeTable.js

@@ -0,0 +1,134 @@
+// src/docx/serializeTable.ts
+import {
+  spanCount,
+  toGridCols,
+  toTableWidth,
+  widthNumber
+} from "../model/format.js";
+import { DocxExportError } from "../ooxml/errors.js";
+import { NO_EXPORT_REFS } from "./exportRefs.js";
+import {
+  parseProps,
+  renderProps,
+  setPropsChild,
+  TBL_PR_ORDER,
+  TC_PR_ORDER
+} from "./propsXml.js";
+import {
+  openTag,
+  preservedXml,
+  serializeParagraph
+} from "./serializeParagraph.js";
+function propsOf(xml, tag) {
+  if (typeof xml !== "string") return { tag, attrs: null, children: [] };
+  const parsed = parseProps(xml);
+  if (!parsed) {
+    throw new DocxExportError("malformed-xml", `${tag} cannot be rewritten`);
+  }
+  return parsed;
+}
+function widthXml(name, width) {
+  return `<w:${name} w:w="${widthNumber(width) ?? 0}" w:type="${width.type}"/>`;
+}
+function withWidth(props, name, width, order) {
+  if (!width) return props;
+  return {
+    ...props,
+    children: setPropsChild(props.children, name, widthXml(name, width), order)
+  };
+}
+function tablePropsXml(table) {
+  const props = propsOf(table.attrs.tblPr, "w:tblPr");
+  const width = toTableWidth(table.attrs.tblW);
+  return renderProps(withWidth(props, "tblW", width, TBL_PR_ORDER));
+}
+function tableGridXml(table) {
+  const gridCols = toGridCols(table.attrs.gridCols);
+  if (gridCols.length === 0) return "";
+  const cols = gridCols.map((w) => `<w:gridCol w:w="${w}"/>`).join("");
+  return `<w:tblGrid>${cols}</w:tblGrid>`;
+}
+function cellPropsXml(cell, role) {
+  const props = propsOf(cell.attrs.tcPr, "w:tcPr");
+  const colspan = spanCount(cell.attrs.colspan);
+  const rowspan = spanCount(cell.attrs.rowspan);
+  const gridSpan = colspan > 1 ? `<w:gridSpan w:val="${colspan}"/>` : null;
+  const vMerge = role === "continue" ? "<w:vMerge/>" : rowspan > 1 ? '<w:vMerge w:val="restart"/>' : null;
+  let children = setPropsChild(
+    props.children,
+    "gridSpan",
+    gridSpan,
+    TC_PR_ORDER
+  );
+  children = setPropsChild(children, "vMerge", vMerge, TC_PR_ORDER);
+  const width = toTableWidth(cell.attrs.tcW);
+  return renderProps(
+    withWidth({ ...props, children }, "tcW", width, TC_PR_ORDER)
+  );
+}
+function cellBlockXml(block, refs) {
+  if (block.type.name === "paragraph") return serializeParagraph(block, refs);
+  if (block.type.name === "rawBlock") return preservedXml(block);
+  if (block.type.name === "table") return serializeTable(block, refs);
+  throw new DocxExportError(
+    "unsupported-content",
+    `block that cannot go inside a table cell: ${block.type.name}`
+  );
+}
+function wrapInSdt(xml, cell, role) {
+  const prefix = cell.attrs.sdtPrefix;
+  if (role !== "start" || typeof prefix !== "string") return xml;
+  return `${prefix}<w:sdtContent>${xml}</w:sdtContent></w:sdt>`;
+}
+function cellXml(cell, role, refs) {
+  const body = role === "continue" ? "<w:p/>" : cell.children.map((block) => cellBlockXml(block, refs)).join("");
+  const xml = openTag("w:tc", cell.attrs.tcAttrs) + cellPropsXml(cell, role) + body + "</w:tc>";
+  return wrapInSdt(xml, cell, role);
+}
+function placeRow(row, covering) {
+  const placed = [];
+  let column = 0;
+  let next = 0;
+  for (; ; ) {
+    const cover = covering.find(
+      (entry) => entry.column === column && entry.rowsLeft > 0
+    );
+    if (cover) {
+      placed.push({ cell: cover.cell, role: "continue" });
+      cover.rowsLeft -= 1;
+      column += cover.colspan;
+      continue;
+    }
+    if (next >= row.childCount) break;
+    const cell = row.child(next);
+    next += 1;
+    const colspan = spanCount(cell.attrs.colspan);
+    const rowspan = spanCount(cell.attrs.rowspan);
+    placed.push({ cell, role: "start" });
+    if (rowspan > 1) {
+      covering.push({ column, colspan, cell, rowsLeft: rowspan - 1 });
+    }
+    column += colspan;
+  }
+  return placed;
+}
+function rowXml(row, covering, refs) {
+  const cells = placeRow(row, covering).map((placed) => cellXml(placed.cell, placed.role, refs)).join("");
+  const tblPrEx = row.attrs.tblPrEx;
+  const trPr = row.attrs.trPr;
+  return openTag("w:tr", row.attrs.trAttrs) + (typeof tblPrEx === "string" ? tblPrEx : "") + (typeof trPr === "string" ? trPr : "") + cells + "</w:tr>";
+}
+function serializeTable(table, refs = NO_EXPORT_REFS) {
+  const covering = [];
+  const rows = table.children.map((row) => rowXml(row, covering, refs)).join("");
+  if (covering.some((entry) => entry.rowsLeft > 0)) {
+    throw new DocxExportError(
+      "invalid-table",
+      "a vertical merge in the table reaches past the last row"
+    );
+  }
+  return openTag("w:tbl", table.attrs.tblAttrs) + tablePropsXml(table) + tableGridXml(table) + rows + "</w:tbl>";
+}
+export {
+  serializeTable
+};

package/dist/docx/session.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The store that holds the original as it was the moment the document was opened
+ * and hands it back at export time.
+ *
+ * What leaves the package is `DocxSession`, a token with nothing readable on it: the store behind
+ * it holds the file's own XML, which nothing but the exporter can put back together, and a
+ * consumer reading a piece of it would be reading an internal shape. What a consumer legitimately
+ * needs is an accessor of its own here.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { DocumentDefaults } from "../model/format";
+import { type Numbering } from "../numbering/parseNumbering";
+import type { ImportedComments } from "./comments";
+import type { ParagraphFormatLayer, ParagraphStyleOption, StyleTable } from "./formatting";
+import type { HeadersFooters } from "./headersFooters";
+import type { PageGeometry } from "./pageGeometry";
+export interface ImportedBlock {
+    xml: string;
+    /** The node as it was the moment the document was opened. Compared against the current node to tell whether it was edited */
+    node: PMNode;
+}
+/**
+ * The session `importDocx` hands out and `exportDocx` takes back, untouched.
+ *
+ * It carries the parts of the package and the original XML pieces that go back out unchanged,
+ * which is how a document nobody edited exports part for part identical.
+ */
+export interface DocxSession {
+    readonly kind: "docxSession";
+}
+/** What the package's own layers read the open document off */
+export declare class SessionStore implements DocxSession {
+    readonly kind = "docxSession";
+    readonly parts: Map<string, Uint8Array>;
+    readonly mainPartPath: string;
+    readonly documentPrefix: string;
+    readonly documentSuffix: string;
+    readonly documentHadBom: boolean;
+    readonly blocks: ImportedBlock[];
+    /** The document default formatting read from styles.xml. Used for display only */
+    readonly defaults: DocumentDefaults;
+    /** The effective automatic tab interval read from settings.xml. Used for display only. */
+    readonly defaultTabStopPt: number;
+    /** The paragraph properties at the base of the OOXML formatting hierarchy. */
+    readonly paragraphDefaults: ParagraphFormatLayer;
+    /** The paper this document is written on, read from the first section. Used for display only: the `w:sectPr` itself goes back out in the preserved tail */
+    readonly geometry: PageGeometry;
+    /** The style chain from styles.xml. Used only to fold the style a paragraph points at into its displayed values */
+    readonly styles: StyleTable;
+    /** The paragraph styles this document defines, in the order styles.xml lists them. What the style picker offers */
+    readonly paragraphStyles: ParagraphStyleOption[];
+    /**
+     * The paragraph style every paragraph with no `w:pStyle` of its own wears (`w:default="1"`,
+     * usually Normal). null when the document marks none
+     */
+    readonly defaultParagraphStyleId: string | null;
+    /** The raw text of numbering.xml. Kept around so list numbers can be drawn on screen. null if there is none */
+    readonly numberingXml: string | null;
+    /** Where numbering.xml sits inside the zip. When a new list is exported it is rewritten at that spot. null if there is none */
+    readonly numberingPartPath: string | null;
+    /** The Comments part as opened, including comment elements retained for a byte-identical pass. */
+    readonly comments: ImportedComments;
+    /** Comment ids referenced by the original main story. A missing id after editing means deletion. */
+    readonly commentReferenceIds: ReadonlySet<string>;
+    /** First-section header and footer stories projected for the page preview. */
+    readonly headersFooters: HeadersFooters;
+    constructor(opened: Omit<SessionStore, "kind">);
+}
+/**
+ * The store behind a session token.
+ *
+ * Every function that takes a session from outside comes through here, so an object the package
+ * never handed out is turned down with a message rather than read field by field into nonsense.
+ */
+export declare function sessionOf(session: DocxSession): SessionStore;
+/** Where the body part sits inside the package, which is the one part an export rewrites */
+export declare function documentPartPath(session: DocxSession): string;
+/** The list definitions the document carries, which is what a paragraph's numbering points into */
+export declare function documentNumbering(session: DocxSession): Numbering;
+/** Finds which original block a node came from. undefined for a node newly created during editing */
+export declare function originalBlock(node: PMNode, session: SessionStore): ImportedBlock | undefined;

package/dist/docx/session.js

@@ -0,0 +1,79 @@
+// src/docx/session.ts
+import { parseNumbering } from "../numbering/parseNumbering.js";
+var SessionStore = class {
+  kind = "docxSession";
+  parts;
+  mainPartPath;
+  documentPrefix;
+  documentSuffix;
+  documentHadBom;
+  blocks;
+  /** The document default formatting read from styles.xml. Used for display only */
+  defaults;
+  /** The effective automatic tab interval read from settings.xml. Used for display only. */
+  defaultTabStopPt;
+  /** The paragraph properties at the base of the OOXML formatting hierarchy. */
+  paragraphDefaults;
+  /** The paper this document is written on, read from the first section. Used for display only: the `w:sectPr` itself goes back out in the preserved tail */
+  geometry;
+  /** The style chain from styles.xml. Used only to fold the style a paragraph points at into its displayed values */
+  styles;
+  /** The paragraph styles this document defines, in the order styles.xml lists them. What the style picker offers */
+  paragraphStyles;
+  /**
+   * The paragraph style every paragraph with no `w:pStyle` of its own wears (`w:default="1"`,
+   * usually Normal). null when the document marks none
+   */
+  defaultParagraphStyleId;
+  /** The raw text of numbering.xml. Kept around so list numbers can be drawn on screen. null if there is none */
+  numberingXml;
+  /** Where numbering.xml sits inside the zip. When a new list is exported it is rewritten at that spot. null if there is none */
+  numberingPartPath;
+  /** The Comments part as opened, including comment elements retained for a byte-identical pass. */
+  comments;
+  /** Comment ids referenced by the original main story. A missing id after editing means deletion. */
+  commentReferenceIds;
+  /** First-section header and footer stories projected for the page preview. */
+  headersFooters;
+  constructor(opened) {
+    this.parts = opened.parts;
+    this.mainPartPath = opened.mainPartPath;
+    this.documentPrefix = opened.documentPrefix;
+    this.documentSuffix = opened.documentSuffix;
+    this.documentHadBom = opened.documentHadBom;
+    this.blocks = opened.blocks;
+    this.defaults = opened.defaults;
+    this.defaultTabStopPt = opened.defaultTabStopPt;
+    this.paragraphDefaults = opened.paragraphDefaults;
+    this.geometry = opened.geometry;
+    this.styles = opened.styles;
+    this.paragraphStyles = opened.paragraphStyles;
+    this.defaultParagraphStyleId = opened.defaultParagraphStyleId;
+    this.numberingXml = opened.numberingXml;
+    this.numberingPartPath = opened.numberingPartPath;
+    this.comments = opened.comments;
+    this.commentReferenceIds = opened.commentReferenceIds;
+    this.headersFooters = opened.headersFooters;
+  }
+};
+function sessionOf(session) {
+  if (session instanceof SessionStore) return session;
+  throw new Error("the session must be the one importDocx handed back");
+}
+function documentPartPath(session) {
+  return sessionOf(session).mainPartPath;
+}
+function documentNumbering(session) {
+  return parseNumbering(sessionOf(session).numberingXml);
+}
+function originalBlock(node, session) {
+  const srcId = node.attrs.srcId;
+  return typeof srcId === "number" ? session.blocks[srcId] : void 0;
+}
+export {
+  SessionStore,
+  documentNumbering,
+  documentPartPath,
+  originalBlock,
+  sessionOf
+};

package/dist/docx/tableFormatting/editing.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Applies focused edits to a cell's preserved formatting XML. The fragment is never rebuilt:
+ * only the child and attributes named by the edit are changed, and unsupported formatting stays
+ * untouched.
+ */
+import type { CellFormat, CellMargins, CellVerticalAlign, RowFormat } from "../../model/format";
+import { type CellBorderDefaults } from "./reading";
+export interface CellProps {
+    /** The whole `<w:tcPr>...</w:tcPr>` XML. null for a cell with no formatting */
+    tcPr: string | null;
+    format: CellFormat | null;
+}
+export type CellSide = "top" | "bottom" | "left" | "right";
+export declare const ALL_CELL_SIDES: readonly CellSide[];
+/** The line a border preset writes. `none` states that this side draws nothing */
+export type CellBorderLine = "single" | "none";
+/** A job that changes one piece of cell formatting */
+export type CellFormatEdit = 
+/** The background fill (`w:shd`). A null color takes the fill away */
+{
+    kind: "background";
+    hex: string | null;
+}
+/** The line on the named sides (`w:tcBorders`). The other sides are left alone */
+ | {
+    kind: "borders";
+    line: CellBorderLine;
+    sides: readonly CellSide[];
+}
+/** The color of the sides that already draw a line. A null color resets them to `auto` */
+ | {
+    kind: "borderColor";
+    hex: string | null;
+}
+/** The vertical placement of content within the cell (`w:vAlign`). */
+ | {
+    kind: "verticalAlign";
+    align: CellVerticalAlign;
+}
+/** The directly formatted cell margins, in points. Omitted sides remain unchanged. */
+ | {
+    kind: "padding";
+    values: Partial<Record<CellSide, number>>;
+};
+/**
+ * The cell formatting XML and display values after one piece of formatting is changed.
+ *
+ * null when there is nothing to do: a fragment whose shape could not be made out, a value that
+ * cannot be written into the document, or a cell already in the state the job wants. In every one
+ * of those cases the cell keeps its original XML.
+ */
+export declare function editCellProps(tcPr: string | null, edit: CellFormatEdit, defaults?: CellBorderDefaults, margins?: CellMargins): CellProps | null;
+/**
+ * Whether the cell's own formatting draws a line on any side.
+ * A border color has nothing to act on when it does not, because the lines on screen are then the
+ * table's own, which belong to the table rather than to this cell.
+ */
+export declare function drawsOwnCellBorder(tcPr: string | null): boolean;
+export interface RowProps {
+    trPr: string;
+    format: RowFormat;
+}
+/** Writes a row height in points while retaining unrelated `w:trPr` content. */
+export declare function editRowHeight(trPr: string | null, heightPt: number): RowProps | null;

package/dist/docx/tableFormatting/editing.js

@@ -0,0 +1,318 @@
+// src/docx/tableFormatting/editing.ts
+import { normalizeHex, wAttr } from "../../ooxml/units.js";
+import { childByLocalName, escapeXml, localPart } from "../../ooxml/xml.js";
+import {
+  parseProps,
+  parsePropsXml,
+  propsChild,
+  renderProps,
+  setPropsChild,
+  TC_PR_ORDER,
+  TR_PR_ORDER
+} from "../propsXml.js";
+import {
+  NO_BORDER_DEFAULTS,
+  NO_CELL_MARGINS,
+  readCellProps,
+  readRowFormat
+} from "./reading.js";
+var ALL_CELL_SIDES = [
+  "top",
+  "bottom",
+  "left",
+  "right"
+];
+var TC_BORDERS_ORDER = [
+  "top",
+  "start",
+  "left",
+  "bottom",
+  "end",
+  "right",
+  "insideH",
+  "insideV",
+  "tl2br",
+  "tr2bl"
+];
+var SIDE_NAMES = {
+  top: ["top"],
+  bottom: ["bottom"],
+  left: ["left", "start"],
+  right: ["right", "end"]
+};
+var PRESET_BORDER_EIGHTHS = 4;
+var THEME_COLOR_ATTRS = ["themeColor", "themeTint", "themeShade"];
+var THEME_FILL_ATTRS = ["themeFill", "themeFillTint", "themeFillShade"];
+var EMPTY_TC_PR = { tag: "w:tcPr", attrs: null, children: [] };
+function attrsOf(el) {
+  return el ? Array.from(el.attributes).map((attr) => [attr.name, attr.value]) : [];
+}
+function withAttr(attrs, name, value, overridden = []) {
+  const kept = attrs.filter(([attr]) => !overridden.includes(localPart(attr)));
+  const at = kept.findIndex(([attr]) => localPart(attr) === name);
+  if (at === -1) return [...kept, [`w:${name}`, value]];
+  return kept.map(
+    (attr, index) => index === at ? [attr[0], value] : attr
+  );
+}
+function elementXml(tag, attrs) {
+  const text = attrs.map(([name, value]) => `${name}="${escapeXml(value)}"`).join(" ");
+  return `<${tag} ${text}/>`;
+}
+function drawsLine(side) {
+  if (!side) return false;
+  const val = wAttr(side, "val");
+  return val !== null && val !== "nil" && val !== "none";
+}
+function sideAttrs(current, edit, fallback = null) {
+  if (edit.kind === "color") {
+    if (!drawsLine(current)) {
+      if (current || !fallback || fallback === "none") return null;
+      return inheritedBorderAttrs(fallback, edit.hex);
+    }
+    return withAttr(
+      attrsOf(current),
+      "color",
+      edit.hex ?? "auto",
+      THEME_COLOR_ATTRS
+    );
+  }
+  if (edit.line === "none") {
+    return current ? withAttr(attrsOf(current), "val", "none") : [["w:val", "none"]];
+  }
+  if (!current) {
+    return [
+      ["w:val", "single"],
+      ["w:sz", `${PRESET_BORDER_EIGHTHS}`],
+      ["w:space", "0"],
+      ["w:color", "auto"]
+    ];
+  }
+  return withAttr(
+    withAttr(attrsOf(current), "val", "single"),
+    "sz",
+    `${PRESET_BORDER_EIGHTHS}`
+  );
+}
+var BORDER_VAL_BY_CSS_STYLE = {
+  solid: "single",
+  double: "double",
+  dashed: "dashed",
+  dotted: "dotted"
+};
+function inheritedBorderAttrs(border, hex) {
+  const matched = border.match(
+    /^(\d+(?:\.\d+)?)pt (solid|double|dashed|dotted) (#[0-9a-f]{6})$/i
+  );
+  if (!matched) return null;
+  const [, widthText, style, currentColor] = matched;
+  if (hex !== null && normalizeHex(currentColor) === hex) return null;
+  const eighths = Math.round(Number.parseFloat(widthText) * 8);
+  if (!Number.isSafeInteger(eighths) || eighths <= 0) return null;
+  return [
+    ["w:val", BORDER_VAL_BY_CSS_STYLE[style.toLowerCase()]],
+    ["w:sz", `${eighths}`],
+    ["w:space", "0"],
+    ["w:color", hex ?? "auto"]
+  ];
+}
+function sideNames(borders, side) {
+  const [primary, alternate] = SIDE_NAMES[side];
+  const usesAlternate = alternate !== void 0 && borders !== null && childByLocalName(borders, primary) === null && childByLocalName(borders, alternate) !== null;
+  if (usesAlternate) return { write: alternate, drop: null };
+  return { write: primary, drop: alternate ?? null };
+}
+function editedBorders(current, edit, defaults = NO_BORDER_DEFAULTS) {
+  const props = current === null ? { tag: "w:tcBorders", attrs: null, children: [] } : parseProps(current);
+  const borders = current === null ? null : parsePropsXml(current);
+  if (!props || current !== null && !borders) return null;
+  const sides = edit.kind === "line" ? edit.sides : ALL_CELL_SIDES;
+  const children = sides.reduce((kept, side) => {
+    const { write, drop } = sideNames(borders, side);
+    const currentSide = borders ? childByLocalName(borders, write) : null;
+    const attrs = sideAttrs(currentSide, edit, defaults[side]);
+    if (!attrs) return kept;
+    const tag = currentSide?.nodeName ?? `w:${write}`;
+    const written = setPropsChild(
+      kept,
+      write,
+      elementXml(tag, attrs),
+      TC_BORDERS_ORDER
+    );
+    return drop === null ? written : setPropsChild(written, drop, null, TC_BORDERS_ORDER);
+  }, props.children);
+  const xml = renderProps({ ...props, children });
+  return { xml: xml === "" ? null : xml };
+}
+function hasPattern(shd) {
+  const val = shd ? wAttr(shd, "val") : null;
+  return val !== null && val !== "clear" && val !== "nil";
+}
+function editedShading(current, fill) {
+  const tag = current?.nodeName ?? "w:shd";
+  if (fill === null) {
+    if (!hasPattern(current)) return null;
+    return elementXml(
+      tag,
+      withAttr(attrsOf(current), "fill", "auto", THEME_FILL_ATTRS)
+    );
+  }
+  if (!current) {
+    return elementXml(tag, [
+      ["w:val", "clear"],
+      ["w:color", "auto"],
+      ["w:fill", fill]
+    ]);
+  }
+  const painting = hasPattern(current) ? attrsOf(current) : withAttr(attrsOf(current), "val", "clear");
+  return elementXml(tag, withAttr(painting, "fill", fill, THEME_FILL_ATTRS));
+}
+function bordersChange(props, edit, defaults) {
+  const current = propsChild(props.children, "tcBorders")?.xml ?? null;
+  const edited = editedBorders(current, edit, defaults);
+  return edited === null ? null : { name: "tcBorders", xml: edited.xml };
+}
+var TC_MAR_ORDER = [
+  "top",
+  "start",
+  "left",
+  "bottom",
+  "end",
+  "right"
+];
+var MARGIN_SIDE_NAMES = {
+  top: ["top"],
+  right: ["end", "right"],
+  bottom: ["bottom"],
+  left: ["start", "left"]
+};
+function paddingChange(props, values) {
+  const current = propsChild(props.children, "tcMar")?.xml ?? null;
+  const margins = current === null ? null : parsePropsXml(current);
+  const parsed = current === null ? { tag: "w:tcMar", attrs: null, children: [] } : parseProps(current);
+  if (!parsed || current !== null && !margins) return null;
+  let children = parsed.children;
+  let wrote = false;
+  for (const side of ALL_CELL_SIDES) {
+    const points = values[side];
+    if (points === void 0) continue;
+    const twips = Math.round(points * 20);
+    if (!Number.isFinite(points) || points < 0 || !Number.isSafeInteger(twips)) {
+      return null;
+    }
+    const existing = margins ? MARGIN_SIDE_NAMES[side].map((name2) => childByLocalName(margins, name2)).find((element) => element !== null) ?? null : null;
+    const name = existing?.localName ?? side;
+    const attrs = withAttr(
+      withAttr(attrsOf(existing), "w", `${twips}`),
+      "type",
+      "dxa"
+    );
+    children = setPropsChild(
+      children,
+      name,
+      elementXml(existing?.nodeName ?? `w:${side}`, attrs),
+      TC_MAR_ORDER
+    );
+    wrote = true;
+  }
+  if (!wrote) return null;
+  return { name: "tcMar", xml: renderProps({ ...parsed, children }) };
+}
+function childChange(edit, props, defaults) {
+  switch (edit.kind) {
+    case "background": {
+      const fill = edit.hex === null ? null : normalizeHex(edit.hex);
+      if (edit.hex !== null && fill === null) return null;
+      const current = propsChild(props.children, "shd")?.xml ?? null;
+      const shd = current === null ? null : parsePropsXml(current);
+      if (current !== null && !shd) return null;
+      return { name: "shd", xml: editedShading(shd, fill) };
+    }
+    case "borders":
+      return bordersChange(
+        props,
+        {
+          kind: "line",
+          line: edit.line,
+          sides: edit.sides
+        },
+        defaults
+      );
+    case "borderColor": {
+      const hex = edit.hex === null ? null : normalizeHex(edit.hex);
+      if (edit.hex !== null && hex === null) return null;
+      return bordersChange(props, { kind: "color", hex }, defaults);
+    }
+    case "verticalAlign": {
+      const current = propsChild(props.children, "vAlign")?.xml ?? null;
+      const element = current === null ? null : parsePropsXml(current);
+      if (current !== null && !element) return null;
+      return {
+        name: "vAlign",
+        xml: elementXml(
+          element?.nodeName ?? "w:vAlign",
+          withAttr(attrsOf(element), "val", edit.align)
+        )
+      };
+    }
+    case "padding":
+      return paddingChange(props, edit.values);
+  }
+}
+function editCellProps(tcPr, edit, defaults = NO_BORDER_DEFAULTS, margins = NO_CELL_MARGINS) {
+  const props = tcPr === null ? EMPTY_TC_PR : parseProps(tcPr);
+  if (!props) return null;
+  const change = childChange(edit, props, defaults);
+  if (!change) return null;
+  const children = setPropsChild(
+    props.children,
+    change.name,
+    change.xml,
+    TC_PR_ORDER
+  );
+  const rendered = renderProps({ ...props, children });
+  const next = rendered === "" ? null : rendered;
+  if (next === tcPr) return null;
+  return { tcPr: next, format: readCellProps(next, defaults, margins) };
+}
+function drawsOwnCellBorder(tcPr) {
+  const el = tcPr === null ? null : parsePropsXml(tcPr);
+  const borders = el ? childByLocalName(el, "tcBorders") : null;
+  if (!borders) return false;
+  return ALL_CELL_SIDES.some(
+    (side) => SIDE_NAMES[side].some((name) => drawsLine(childByLocalName(borders, name)))
+  );
+}
+function editRowHeight(trPr, heightPt) {
+  const twips = Math.round(heightPt * 20);
+  if (!Number.isFinite(heightPt) || heightPt <= 0 || !Number.isSafeInteger(twips)) {
+    return null;
+  }
+  const props = trPr === null ? { tag: "w:trPr", attrs: null, children: [] } : parseProps(trPr);
+  if (!props) return null;
+  const current = propsChild(props.children, "trHeight")?.xml ?? null;
+  const element = current === null ? null : parsePropsXml(current);
+  if (current !== null && !element) return null;
+  const writtenRule = element ? wAttr(element, "hRule") : null;
+  const attrs = withAttr(attrsOf(element), "val", `${twips}`);
+  const nextAttrs = withAttr(
+    attrs,
+    "hRule",
+    writtenRule === "exact" ? "exact" : "atLeast"
+  );
+  const child = elementXml(element?.nodeName ?? "w:trHeight", nextAttrs);
+  const rendered = renderProps({
+    ...props,
+    children: setPropsChild(props.children, "trHeight", child, TR_PR_ORDER)
+  });
+  if (rendered === trPr) return null;
+  const parsed = parsePropsXml(rendered);
+  const format = parsed ? readRowFormat(parsed) : null;
+  return format ? { trPr: rendered, format } : null;
+}
+export {
+  ALL_CELL_SIDES,
+  drawsOwnCellBorder,
+  editCellProps,
+  editRowHeight
+};