@portone/docx-editor 0.3.0 → 0.4.0

package/dist/editor/externalClipboard.js

@@ -5,12 +5,24 @@ import {
   Slice
 } from "prosemirror-model";
 import { Plugin } from "prosemirror-state";
-import { paragraphAttrsFor, styleIdOf } from "../docx/formatting.js";
+import {
+  paragraphAttrsFor,
+  styleIdOf
+} from "../docx/formatting.js";
 import {
   withListNumbering,
   withParagraphStyle
 } from "../docx/paraProps.js";
-import { MAX_ILVL, nextNumId } from "../numbering/listTemplate.js";
+import {
+  listsWorn,
+  NEW_LISTS_ATTR,
+  newListsValue
+} from "../numbering/listRegistry.js";
+import {
+  allocateList,
+  MAX_ILVL,
+  templateList
+} from "../numbering/listTemplate.js";
 import { docxSchema, isPageBreak } from "../schema/index.js";
 import { editorClassNames } from "../styles/classNames.js";
 import { PASTED_IMAGE_ATTRIBUTE } from "./clipboard/images.js";
@@ -21,14 +33,11 @@ import {
   safeHref,
   withInlineStyle
 } from "./clipboard/inlineFormatting.js";
-import { listRefOf } from "./commands/listCommands.js";
+import { numIdsIn } from "./commands/listCommands.js";
 import { documentFormatting, documentParagraphStyles } from "./documentStyles.js";
 import { insertPlainText } from "./plainText.js";
 import { moveCaretToDrop } from "./plugins/dropCaret.js";
-import {
-  canStartNewList,
-  documentNumbering
-} from "./plugins/numberingDecorations.js";
+import { canStartNewList } from "./plugins/numberingDecorations.js";
 var BLOCK_TAGS = /* @__PURE__ */ new Set([
   "ADDRESS",
   "ARTICLE",
@@ -256,29 +265,17 @@ function listParagraphProps(list) {
     indent: { kind: "keep" }
   });
 }
-function paragraphAttrs(state, list, paragraph) {
+function paragraphAttrs(formatting, list, paragraph) {
   const props = listParagraphProps(list) ?? paragraph;
-  return props ? {
-    pPr: props.pPr,
-    ...paragraphAttrsFor(props.pPr, documentFormatting(state))
-  } : null;
-}
-function usedNumIds(state) {
-  const used = new Set(documentNumbering(state).lists.keys());
-  state.doc.descendants((node) => {
-    if (node.type !== docxSchema.nodes.paragraph) return true;
-    const ref = listRefOf(node);
-    if (ref) used.add(ref.numId);
-    return false;
-  });
-  return used;
+  return props ? { pPr: props.pPr, ...paragraphAttrsFor(props.pPr, formatting) } : null;
 }
 var HtmlReader = class {
   constructor(state, preserveParagraphStyles, images) {
     this.state = state;
     this.preserveParagraphStyles = preserveParagraphStyles;
     this.images = images;
-    this.used = usedNumIds(state);
+    this.formatting = documentFormatting(state);
+    this.used = numIdsIn(state.doc);
     this.canCreateLists = canStartNewList(state);
   }
   state;
@@ -287,6 +284,16 @@ var HtmlReader = class {
   blocks = [];
   used;
   canCreateLists;
+  /**
+   * What the pasted paragraphs are resolved against: the document's context, holding the
+   * definition of each pasted list as it is read, so that an item is drawn against the list it
+   * is joining rather than against a list nothing yet defines.
+   */
+  formatting;
+  /** The definitions of every list started while editing, the pasted ones among them */
+  get newLists() {
+    return this.formatting.numbering.added;
+  }
   read(root) {
     this.readFlow(root, { style: {}, href: null, preserveWhitespace: false });
     return this.blocks;
@@ -318,7 +325,7 @@ var HtmlReader = class {
     }
     this.blocks.push(
       docxSchema.nodes.paragraph.create(
-        paragraphAttrs(this.state, list, paragraph),
+        paragraphAttrs(this.formatting, list, paragraph),
         content
       )
     );
@@ -354,11 +361,20 @@ var HtmlReader = class {
     }
     flush();
   }
+  /**
+   * The number a pasted list takes, registered with the definition that list is drawn and written
+   * with. A pasted list is started here just as the list button starts one.
+   */
   takeNumId(kind) {
     if (!this.canCreateLists) return null;
-    const id = nextNumId(this.used, kind);
-    this.used.add(id);
-    return id;
+    const started = allocateList(
+      this.formatting.numbering,
+      this.used,
+      templateList(kind)
+    );
+    this.formatting = { ...this.formatting, numbering: started.numbering };
+    this.used.add(started.numId);
+    return started.numId;
   }
   readList(list, context, level, inherited) {
     const kind = list.tagName === "UL" ? "bullet" : "numbered";
@@ -407,15 +423,28 @@ function richHtmlSlice(state, document, source, images = /* @__PURE__ */ new Map
   const template = document.createElement("template");
   template.innerHTML = source;
   const open = sliceDepth(template.content);
-  const blocks = new HtmlReader(state, open === 0, images).read(
-    template.content
+  const reader = new HtmlReader(state, open === 0, images);
+  const blocks = reader.read(template.content);
+  return blocks.length === 0 ? null : {
+    slice: new Slice(Fragment.fromArray([...blocks]), open, open),
+    newLists: reader.newLists
+  };
+}
+function withPastedContent(tr, content) {
+  return tr.setDocAttribute(
+    NEW_LISTS_ATTR,
+    newListsValue(listsWorn(content.newLists, numIdsIn(tr.doc)))
   );
-  return blocks.length === 0 ? null : new Slice(Fragment.fromArray([...blocks]), open, open);
 }
 function insertRichHtml(view, source) {
-  const slice = richHtmlSlice(view.state, view.dom.ownerDocument, source);
-  if (slice === null) return false;
-  view.dispatch(view.state.tr.replaceSelection(slice).scrollIntoView());
+  const content = richHtmlSlice(view.state, view.dom.ownerDocument, source);
+  if (content === null) return false;
+  view.dispatch(
+    withPastedContent(
+      view.state.tr.replaceSelection(content.slice),
+      content
+    ).scrollIntoView()
+  );
   return true;
 }
 function insertClipboardData(view, data) {
@@ -452,5 +481,6 @@ export {
   externalClipboard,
   insertClipboardData,
   insertRichHtml,
-  richHtmlSlice
+  richHtmlSlice,
+  withPastedContent
 };

package/dist/editor/paragraphEdits.d.ts

@@ -8,6 +8,7 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { EditorState, Transaction } from "prosemirror-state";
+import { type FormattingContext } from "../docx/formatting";
 import type { ParagraphProps } from "../docx/paraProps";
 export interface ParagraphSpot {
     pos: number;
@@ -33,5 +34,19 @@ export declare function editableParagraphs(state: EditorState): ParagraphSpot[];
 export declare function paragraphPPr(node: PMNode): string | null;
 /** How to edit a single paragraph. Null skips that paragraph */
 export type ParagraphSurgery = (node: PMNode) => ParagraphProps | null;
+/** What an edit does beyond swapping the fragments of the paragraphs it names */
+export interface ParagraphEditExtras {
+    /**
+     * The context the new display values are resolved against, which is the state's own unless the
+     * edit is itself changing it. An edit that starts a list hands in the context that already
+     * holds it, so the paragraph is drawn against the list it is joining in that same transaction.
+     */
+    formatting?: FormattingContext;
+    /**
+     * What else the edit records in the same transaction, such as the definition of the list the
+     * paragraphs are joining, so that undo takes the two back together.
+     */
+    alongside?: (tr: Transaction) => void;
+}
 /** Edits the selected paragraphs in a single transaction. Does nothing when there is nothing to edit */
-export declare function editParagraphs(state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, surgery: ParagraphSurgery): boolean;
+export declare function editParagraphs(state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, surgery: ParagraphSurgery, extras?: ParagraphEditExtras): boolean;

package/dist/editor/paragraphEdits.js

@@ -3,6 +3,7 @@ import { paragraphAttrsFor } from "../docx/formatting.js";
 import { docxSchema } from "../schema/index.js";
 import { editShut } from "../schema/guards.js";
 import { documentFormatting } from "./documentStyles.js";
+import { paragraphPlacementAt } from "./paragraphPlacement.js";
 function selectedParagraphs(state) {
   const spots = /* @__PURE__ */ new Map();
   for (const range of state.selection.ranges) {
@@ -23,25 +24,32 @@ function paragraphPPr(node) {
   const pPr = node.attrs.pPr;
   return typeof pPr === "string" ? pPr : null;
 }
-function writeChanges(state, changed) {
+function writeChanges(state, changed, extras) {
   const tr = state.tr;
-  const formatting = documentFormatting(state);
+  const formatting = extras.formatting ?? documentFormatting(state);
   for (const { spot, props } of changed) {
     tr.setNodeMarkup(tr.mapping.map(spot.pos), void 0, {
       ...spot.node.attrs,
       pPr: props.pPr,
-      ...paragraphAttrsFor(props.pPr, formatting)
+      ...paragraphAttrsFor(
+        props.pPr,
+        formatting,
+        paragraphPlacementAt(state.doc, spot.pos)
+      )
     });
   }
+  extras.alongside?.(tr);
   return tr;
 }
-function editParagraphs(state, dispatch, surgery) {
+function editParagraphs(state, dispatch, surgery, extras = {}) {
   const changed = editableParagraphs(state).flatMap((spot) => {
     const props = surgery(spot.node);
     return props ? [{ spot, props }] : [];
   });
   if (changed.length === 0) return false;
-  if (dispatch) dispatch(writeChanges(state, changed).scrollIntoView());
+  if (dispatch) {
+    dispatch(writeChanges(state, changed, extras).scrollIntoView());
+  }
   return true;
 }
 export {

package/dist/editor/paragraphPlacement.d.ts

@@ -0,0 +1,11 @@
+/** Finds the table-style conditions at an editor position for both reads and writes. */
+import type { Node as PMNode } from "prosemirror-model";
+import type { ParagraphPlacement } from "../docx/formatting";
+/**
+ * The part of a table the paragraph stands in, which its table style dresses it by. null for a
+ * paragraph of the body, and for one in a cell of a table this editor did not build.
+ *
+ * The cell is found by walking out of the paragraph rather than passed down, because the walk that
+ * runs the derivers goes over the blocks and hands each of them nothing but its own position.
+ */
+export declare function paragraphPlacementAt(doc: PMNode, pos: number): ParagraphPlacement | null;

package/dist/editor/paragraphPlacement.js

@@ -0,0 +1,18 @@
+// src/editor/paragraphPlacement.ts
+import { TableMap } from "prosemirror-tables";
+import { docxSchema } from "../schema/index.js";
+import { cellDefaultsAt, tableCellSources } from "../table/gridBorders.js";
+function paragraphPlacementAt(doc, pos) {
+  const $pos = doc.resolve(pos);
+  for (let depth = $pos.depth; depth >= 2; depth -= 1) {
+    if ($pos.node(depth).type !== docxSchema.nodes.tableCell) continue;
+    const table = $pos.node(depth - 2);
+    if (table.type !== docxSchema.nodes.table) return null;
+    const cell = $pos.before(depth) - $pos.start(depth - 2);
+    return cellDefaultsAt(TableMap.get(table), cell, tableCellSources(table)).placement;
+  }
+  return null;
+}
+export {
+  paragraphPlacementAt
+};

package/dist/editor/plugins/imagePaste.js

@@ -8,7 +8,7 @@ import {
   resolveClipboardImages
 } from "../clipboard/images.js";
 import { documentBodyHeightPx, documentBodyWidthPx } from "../documentStyles.js";
-import { richHtmlSlice } from "../externalClipboard.js";
+import { richHtmlSlice, withPastedContent } from "../externalClipboard.js";
 import { insertPlainTextAt } from "../plainText.js";
 var LOAD_TIMEOUT_MS = 15e3;
 var imagePasteKey = new PluginKey("docxImagePaste");
@@ -87,15 +87,18 @@ function imagePaste() {
     if (!range) return;
     removeMarker(task);
     if (task.view.isDestroyed) return;
-    const slice = resolved === null || resolved.images.size === 0 ? null : richHtmlSlice(
+    const content = resolved === null || resolved.images.size === 0 ? null : richHtmlSlice(
       task.view.state,
       task.view.dom.ownerDocument,
       resolved.source,
       resolved.images
     );
-    if (slice !== null) {
+    if (content !== null) {
       task.view.dispatch(
-        task.view.state.tr.replaceRange(range.from, range.to, slice).scrollIntoView()
+        withPastedContent(
+          task.view.state.tr.replaceRange(range.from, range.to, content.slice),
+          content
+        ).scrollIntoView()
       );
     } else {
       insertPlainTextAt(task.view, task.text, range.from, range.to);

package/dist/editor/plugins/numberingDecorations.d.ts

@@ -6,7 +6,8 @@
 import type { Node as PMNode } from "prosemirror-model";
 import { type EditorState, Plugin } from "prosemirror-state";
 import { DecorationSet } from "prosemirror-view";
-import type { Numbering } from "../../numbering/parseNumbering";
+import { type RunFormat } from "../../model/format";
+import type { LevelAlign, LevelSuffix, Numbering } from "../../numbering/parseNumbering";
 /** A number to draw on screen and the paragraph position it attaches to */
 export interface PlacedMarker {
     from: number;
@@ -19,6 +20,12 @@ export interface PlacedMarker {
     indentEndPt: number | null;
     /** The first-line indentation, under the same rule */
     textIndentPt: number | null;
+    /** What the level puts between the number and the text (`w:suff`) */
+    suffix: LevelSuffix;
+    /** Where the number sits inside the width kept for it (`w:lvlJc`) */
+    align: LevelAlign;
+    /** The formatting the level puts on the number alone (`lvl/rPr`) */
+    run: RunFormat | null;
 }
 /** Walks a document to find the paragraphs that get numbers and what those numbers are */
 export declare function paragraphMarkers(doc: PMNode, numbering: Numbering): PlacedMarker[];
@@ -27,9 +34,8 @@ export declare function markerDecorations(doc: PMNode, numbering: Numbering): De
 export declare function documentNumbering(state: EditorState): Numbering;
 /**
  * Whether a new list can be started in this document.
- * A document without numbering.xml has nowhere to write a new definition, so it would be
- * blocked at export time. In such a document the commands that start a list do not apply
- * in the first place.
+ * A document with nowhere to write a new definition would be blocked at export time, so in such
+ * a document the commands that start a list do not apply in the first place.
  */
 export declare function canStartNewList(state: EditorState): boolean;
 /** Draws the numbers this document's lists put in front of their paragraphs */

package/dist/editor/plugins/numberingDecorations.js

@@ -1,7 +1,9 @@
 // src/editor/plugins/numberingDecorations.ts
 import { Plugin, PluginKey } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
-import { toParagraphFormat } from "../../model/format.js";
+import {
+  toParagraphFormat
+} from "../../model/format.js";
 import { computeMarkers } from "../../numbering/markers.js";
 import { editorAttributes, editorCssVariables } from "../../styles/classNames.js";
 import { documentOf } from "../editorDocument.js";
@@ -45,13 +47,52 @@ function paragraphMarkers(doc, numbering) {
         from: spot.pos,
         to: spot.pos + spot.nodeSize,
         text: marker.text,
+        suffix: marker.suffix,
+        align: marker.align,
+        run: marker.run,
         ...markerPlacement(spot.format, marker.indent)
       }
     ];
   });
 }
+function markerSpacing(marker) {
+  if (marker.suffix === "tab") {
+    return [`${editorCssVariables.markerWidth}:${marker.widthPt}pt`];
+  }
+  return [
+    `${editorCssVariables.markerWidth}:0`,
+    `${editorCssVariables.markerGap}:0`
+  ];
+}
+function markerFormat(run) {
+  if (!run) return [];
+  const css = [];
+  if (run.bold !== void 0) {
+    css.push(
+      `${editorCssVariables.markerFontWeight}:${run.bold ? "bold" : "normal"}`
+    );
+  }
+  if (run.italic !== void 0) {
+    css.push(
+      `${editorCssVariables.markerFontStyle}:${run.italic ? "italic" : "normal"}`
+    );
+  }
+  if (run.color !== void 0) {
+    css.push(`${editorCssVariables.markerColor}:${run.color}`);
+  }
+  if (run.fontSizePt !== void 0) {
+    css.push(`${editorCssVariables.markerFontSize}:${run.fontSizePt}pt`);
+  }
+  if (run.fontFamily !== void 0) {
+    css.push(`${editorCssVariables.markerFontFamily}:${run.fontFamily}`);
+  }
+  return css;
+}
 function markerStyle(marker) {
-  const css = [`${editorCssVariables.markerWidth}:${marker.widthPt}pt`];
+  const css = [...markerSpacing(marker), ...markerFormat(marker.run)];
+  if (marker.align !== "left") {
+    css.push(`${editorCssVariables.markerAlign}:${marker.align}`);
+  }
   if (marker.indentStartPt !== null) {
     css.push(`margin-inline-start:${marker.indentStartPt}pt`);
   }

package/dist/editor/plugins/paragraphDisplay.js

@@ -6,6 +6,7 @@ import {
 } from "../../docx/formatting.js";
 import { docxSchema } from "../../schema/index.js";
 import { paragraphPPr } from "../paragraphEdits.js";
+import { paragraphPlacementAt } from "../paragraphPlacement.js";
 function carriesNothing(node) {
   return node.attrs.format === null && node.attrs.styleRun === null;
 }
@@ -18,12 +19,17 @@ function holdsComposition(node, pos, composing) {
 var paragraphDisplay = {
   name: "paragraph",
   nodeTypes: ["paragraph"],
-  derive(node, pos, _doc, context, previous) {
-    if (stands(node, previous) || holdsComposition(node, pos, context.composingAt)) {
+  derive(node, pos, doc, context, previous) {
+    const placement = paragraphPlacementAt(doc, pos);
+    if (placement === null && stands(node, previous) || holdsComposition(node, pos, context.composingAt)) {
       return [];
     }
     const formatting = context.document.formatting;
-    const paragraph = resolveParagraph(paragraphPPr(node), formatting);
+    const paragraph = resolveParagraph(
+      paragraphPPr(node),
+      formatting,
+      placement
+    );
     const derived = [
       { pos, attrs: paragraphAttrsOf(paragraph) }
     ];

package/dist/editor/plugins/tableDisplay.js

@@ -1,14 +1,28 @@
 // src/editor/plugins/tableDisplay.ts
+import { tableStyleAttrs } from "../../docx/formatting.js";
+import { parsePropsXml } from "../../ooxml/props.js";
 import { cellFixes, sameFormattingInputs } from "../../table/gridBorders.js";
 var tableDisplay = {
   name: "table",
   nodeTypes: ["table"],
-  derive(table, pos, _doc, _context, previous) {
+  derive(table, pos, _doc, context, previous) {
     if (previous !== null && sameFormattingInputs(previous, table)) return [];
-    return cellFixes(table).map((fix) => ({
-      pos: pos + 1 + fix.pos,
-      attrs: fix.attrs
-    }));
+    const tblPr = table.attrs.tblPr;
+    const attrs = {
+      ...table.attrs,
+      ...tableStyleAttrs(
+        typeof tblPr === "string" ? parsePropsXml(tblPr) : null,
+        context.document.formatting
+      )
+    };
+    const current = table.hasMarkup(table.type, attrs, table.marks) ? table : table.type.create(attrs, table.content, table.marks);
+    return [
+      { pos, attrs },
+      ...cellFixes(current).map((fix) => ({
+        pos: pos + 1 + fix.pos,
+        attrs: fix.attrs
+      }))
+    ];
   }
 };
 export {

package/dist/model/format.d.ts

@@ -188,6 +188,45 @@ export interface CellMargins {
     bottomPt: number | null;
     leftPt: number | null;
 }
+/**
+ * The parts of a table a table style formats conditionally (`w:tblStylePr/@w:type`,
+ * ST_TblStyleOverrideType), in the order ECMA-376 Part 1 §17.7.6 applies them: a format standing
+ * later in this list is laid over one standing earlier.
+ */
+export declare const TABLE_STYLE_CONDITIONS: readonly ["wholeTable", "band1Vert", "band2Vert", "band1Horz", "band2Horz", "firstRow", "lastRow", "firstCol", "lastCol", "nwCell", "neCell", "swCell", "seCell"];
+export type TableStyleOverrideType = (typeof TABLE_STYLE_CONDITIONS)[number];
+/**
+ * How many rows one row band and how many columns one column band are made of
+ * (`w:tblStyleRowBandSize`, `w:tblStyleColBandSize`). A style that says nothing leaves the side
+ * null, and its bands are then one row or one column wide.
+ */
+export interface BandSizes {
+    row: number | null;
+    col: number | null;
+}
+/** The lines one conditional format draws around the region it covers. A side it says nothing about is null */
+export interface CellStyleBorders {
+    top: string | null;
+    bottom: string | null;
+    left: string | null;
+    right: string | null;
+}
+/**
+ * What one conditional format of a table style lays down for the cells it covers.
+ *
+ * Its lines are those of the region: `borders` is drawn where a cell lies on the edge of the
+ * region and `inside` between the cells within it, the same way a table's own lines are drawn
+ * around and between its cells.
+ */
+export interface CellStyleFormat {
+    background: string | null;
+    borders: CellStyleBorders;
+    inside: InsideBorders;
+    margins: CellMargins;
+    verticalAlign: CellVerticalAlign | null;
+}
+/** The conditional formats a table style lays down for its cells, by the part of the table each covers */
+export type TableStyleConditions = Readonly<Partial<Record<TableStyleOverrideType, CellStyleFormat>>>;
 /**
  * How high a row stands, in points.
  * `atLeast` is a floor the row grows past when its text needs the room, and `exact` pins
@@ -251,6 +290,17 @@ export declare function toInsideBorders(value: unknown): InsideBorders | null;
  * there at all, so it is null.
  */
 export declare function toCellMargins(value: unknown): CellMargins | null;
+/**
+ * The band sizes a table style laid down, as they come back in from `data-style-bands`.
+ * A style that said nothing about either is the same as the attribute not being there at all.
+ */
+export declare function toBandSizes(value: unknown): BandSizes | null;
+/**
+ * The conditional formats a table style laid down for its cells, as they come back in from
+ * `data-style-conditions`. A part no table has is not one this editor draws, so it is dropped;
+ * a table whose style dresses no part at all is the same as the attribute not being there.
+ */
+export declare function toTableStyleConditions(value: unknown): TableStyleConditions | null;
 export declare function toRowFormat(value: unknown): RowFormat | null;
 export declare function toCellFormat(value: unknown): CellFormat | null;
 /**

package/dist/model/format.js

@@ -74,6 +74,21 @@ var RUN_FORMAT_KEYS = [
   "verticalAlign",
   "lang"
 ];
+var TABLE_STYLE_CONDITIONS = [
+  "wholeTable",
+  "band1Vert",
+  "band2Vert",
+  "band1Horz",
+  "band2Horz",
+  "firstRow",
+  "lastRow",
+  "firstCol",
+  "lastCol",
+  "nwCell",
+  "neCell",
+  "swCell",
+  "seCell"
+];
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -261,6 +276,53 @@ function toCellMargins(value) {
   ];
   return sides.every((side) => side === null) ? null : margins;
 }
+function toBandSizes(value) {
+  if (!isRecord(value)) return null;
+  const size = (side) => typeof side === "number" && Number.isInteger(side) && side > 0 ? side : null;
+  const bands = { row: size(value.row), col: size(value.col) };
+  return bands.row === null && bands.col === null ? null : bands;
+}
+function toCellStyleBorders(value) {
+  if (!isRecord(value)) {
+    return { top: null, bottom: null, left: null, right: null };
+  }
+  return {
+    top: matching(BORDER_CSS, value.top) ?? null,
+    bottom: matching(BORDER_CSS, value.bottom) ?? null,
+    left: matching(BORDER_CSS, value.left) ?? null,
+    right: matching(BORDER_CSS, value.right) ?? null
+  };
+}
+function toCellStyleFormat(value) {
+  if (!isRecord(value)) return null;
+  return {
+    background: matching(FILL, value.background) ?? null,
+    borders: toCellStyleBorders(value.borders),
+    inside: toInsideBorders(value.inside) ?? {
+      horizontal: null,
+      vertical: null
+    },
+    margins: toCellMargins(value.margins) ?? {
+      topPt: null,
+      rightPt: null,
+      bottomPt: null,
+      leftPt: null
+    },
+    verticalAlign: isCellVerticalAlign(value.verticalAlign) ? value.verticalAlign : null
+  };
+}
+function toTableStyleConditions(value) {
+  if (!isRecord(value)) return null;
+  const conditions = {};
+  let found = false;
+  for (const type of TABLE_STYLE_CONDITIONS) {
+    const format = toCellStyleFormat(value[type]);
+    if (format === null) continue;
+    conditions[type] = format;
+    found = true;
+  }
+  return found ? conditions : null;
+}
 function toRowHeight(value) {
   if (!isRecord(value) || typeof value.pt !== "number") return null;
   if (value.rule === "exact") return { rule: "exact", pt: value.pt };
@@ -300,9 +362,11 @@ function spanCount(value) {
 export {
   NO_FILL,
   RUN_FORMAT_KEYS,
+  TABLE_STYLE_CONDITIONS,
   isHighlightName,
   isUnderlineKind,
   spanCount,
+  toBandSizes,
   toCellFormat,
   toCellMargins,
   toColWidth,
@@ -312,6 +376,7 @@ export {
   toRowFormat,
   toRunFormat,
   toTableFormat,
+  toTableStyleConditions,
   toTableWidth,
   widthNumber,
   withWidthNumber

package/dist/numbering/listRegistry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The register of list definitions a document node carries.
+ *
+ * A list started while editing is registered with the definition it was started with, and the
+ * register rides on the document node itself: undo takes a registration back with the edit that
+ * made it, and the export writes out what was registered rather than working a definition out for
+ * itself. Only what `abstractNumXml` writes in full may be registered, and the value is read back
+ * through this file so that nothing else can end up in the register.
+ */
+import { type NewList } from "./parseNumbering";
+/** The lists registered on one document, by the number each was given */
+export type NewLists = ReadonlyMap<number, NewList>;
+export declare const NO_NEW_LISTS: NewLists;
+/** The document attr the register travels on */
+export declare const NEW_LISTS_ATTR = "newLists";
+/**
+ * What the document node carries for a register.
+ *
+ * The entries run in the order of the numbers they define so that the same register is always the
+ * same value, whichever order the lists were started in, and an empty register is the null a
+ * document that never started a list carries: a list left is then a list never started.
+ */
+export declare function newListsValue(lists: NewLists): unknown;
+/**
+ * The register a document node carries. Empty for a node carrying none, and for one carrying an
+ * entry that is not a list definition: a definition the writer cannot read back in full is a
+ * definition it must not write half of.
+ */
+export declare function newListsOf(value: unknown): NewLists;
+/**
+ * The register with the definitions of the lists nothing wears any more taken out.
+ *
+ * A number goes back into circulation with its definition, so leaving a list is exactly what
+ * joining it was not: pressing the list button twice gives back the document that was there
+ * before the first press.
+ */
+export declare function listsWorn(lists: NewLists, worn: ReadonlySet<number>): NewLists;