@portone/docx-editor 0.2.1 → 0.4.0

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

@@ -0,0 +1,47 @@
+/**
+ * Keeps every display value of the document current: the ones an edit moved, after that edit, and
+ * every one at once when the document snapshot the values are resolved against is replaced.
+ *
+ * The derivers are registered here and run through the one walk `schema/displayDerivation`
+ * defines. What a node maps back to is settled here as well, from the mapping of the transactions
+ * that changed the document: a node whose content survived those transactions is the node that
+ * stood where its opening maps back to, and one whose content did not is new. A node rewritten
+ * where it stands (`setNodeMarkup`) therefore still maps back to itself, which is what lets a
+ * table resized or a paragraph re-aligned be told from a table or a paragraph put in.
+ *
+ * The transaction this appends carries the display-only pass (`schema/guards`), since it changes
+ * nothing a lock or a protection answers for, and goes to the history as part of the edit it
+ * follows, so that one undo takes the edit and its values back together. The re-derivation after
+ * a snapshot change follows no edit and goes to the history not at all: the values follow the
+ * snapshot, and undoing whatever replaced the snapshot derives them again.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { Plugin } from "prosemirror-state";
+import { type DisplayDeriver } from "../../schema/displayDerivation";
+import { type EditorDocument } from "../editorDocument";
+/** What a deriver of this editor resolves against */
+export interface DerivationContext {
+    readonly document: EditorDocument;
+    /**
+     * Where the composition the browser holds open stands, which a deriver leaves alone: rewriting
+     * the node it stands in redraws it, and a redraw under an open composition is what the browser
+     * answers by taking the composition down. Null while nothing is being composed, and while every
+     * value is being worked out again from nothing, when nothing may be left standing.
+     */
+    readonly composingAt: number | null;
+}
+export type DocumentDeriver = DisplayDeriver<DerivationContext>;
+export declare const DISPLAY_DERIVERS: readonly DocumentDeriver[];
+/**
+ * The document with every display value worked out against this snapshot, which is what a state
+ * is built over: the values a document arrived with were worked out against whatever opened it.
+ */
+export declare function withDerivedDisplay(doc: PMNode, document: EditorDocument, derivers?: readonly DocumentDeriver[]): PMNode;
+/**
+ * Derives the display values again after every change: for the nodes an edit moved, and for every
+ * node when the snapshot was replaced.
+ *
+ * An appended transaction is handed nothing but states, so the view an open composition is read
+ * from is the one the plugin is given when it mounts.
+ */
+export declare function displayDerivation(derivers?: readonly DocumentDeriver[]): Plugin;

package/dist/editor/plugins/displayDerivation.js

@@ -0,0 +1,78 @@
+// src/editor/plugins/displayDerivation.ts
+import { Plugin } from "prosemirror-state";
+import { Mapping, Transform } from "prosemirror-transform";
+import {
+  deriveDisplay,
+  displayOnly
+} from "../../schema/displayDerivation.js";
+import { documentOf } from "../editorDocument.js";
+import { paragraphDisplay } from "./paragraphDisplay.js";
+import { tableDisplay } from "./tableDisplay.js";
+var DISPLAY_DERIVERS = [
+  tableDisplay,
+  paragraphDisplay
+];
+var nothingBefore = () => null;
+function withDerivedDisplay(doc, document, derivers = DISPLAY_DERIVERS) {
+  const transform = new Transform(doc);
+  deriveDisplay(
+    transform,
+    { document, composingAt: null },
+    derivers,
+    nothingBefore
+  );
+  return transform.doc;
+}
+function previousIn(before, transactions) {
+  const mapping = new Mapping();
+  for (const transaction of transactions) {
+    mapping.appendMapping(transaction.mapping);
+  }
+  const back = mapping.invert();
+  return (node, pos) => {
+    const inside = node.isLeaf ? pos : pos + 1;
+    if (back.mapResult(inside, 1).deleted) return null;
+    const was = before.nodeAt(back.map(pos, 1));
+    return was !== null && was.type === node.type ? was : null;
+  };
+}
+function composingAt(view, state) {
+  return view?.composing === true ? state.selection.from : null;
+}
+function displayDerivation(derivers = DISPLAY_DERIVERS) {
+  let live = null;
+  return new Plugin({
+    view(view) {
+      live = view;
+      return {
+        destroy() {
+          live = null;
+        }
+      };
+    },
+    appendTransaction(transactions, oldState, newState) {
+      const document = documentOf(newState);
+      const replaced = document !== documentOf(oldState);
+      if (!replaced && !transactions.some((transaction) => transaction.docChanged)) {
+        return null;
+      }
+      const tr = newState.tr.setMeta(displayOnly, true);
+      if (replaced) tr.setMeta("addToHistory", false);
+      deriveDisplay(
+        tr,
+        {
+          document,
+          composingAt: replaced ? null : composingAt(live, newState)
+        },
+        derivers,
+        replaced ? nothingBefore : previousIn(oldState.doc, transactions)
+      );
+      return tr.docChanged ? tr : null;
+    }
+  });
+}
+export {
+  DISPLAY_DERIVERS,
+  displayDerivation,
+  withDerivedDisplay
+};

package/dist/editor/plugins/imagePaste.js

@@ -2,14 +2,13 @@
 import { isHistoryTransaction } from "prosemirror-history";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
-import { replacementShut } from "../../schema/locks.js";
-import { editsShut } from "../../schema/protectionState.js";
+import { editShut, selectionIntents } from "../../schema/guards.js";
 import {
   hasResolvableClipboardImages,
   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");
@@ -88,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);
@@ -223,7 +225,9 @@ function imagePaste() {
     props: {
       decorations: (state) => imagePasteKey.getState(state)?.decorations,
       handlePaste(view, event) {
-        if (editsShut(view.state) || replacementShut(view.state.selection, view.state.doc)) {
+        if (selectionIntents(view.state.selection, "replace").some(
+          (intent) => editShut(view.state, intent)
+        )) {
           return false;
         }
         if (view.state.selection.ranges.length > 1) return false;

package/dist/editor/plugins/keymap.js

@@ -5,6 +5,7 @@ import { keydownHandler } from "prosemirror-keymap";
 import { Plugin } from "prosemirror-state";
 import { goToNextCell } from "prosemirror-tables";
 import { canSplit } from "prosemirror-transform";
+import { splitParagraphAttrs } from "../../docx/cloning.js";
 import { toParagraphFormat } from "../../model/format.js";
 import { docxSchema } from "../../schema/index.js";
 import { insertLineBreak, insertPageBreak } from "../commands/breakCommands.js";
@@ -42,13 +43,27 @@ var splitParagraph = (state, dispatch) => {
   const tr = state.tr;
   if (!state.selection.empty) tr.deleteSelection();
   const at = tr.mapping.map(state.selection.$from.pos);
-  const parent = tr.doc.resolve(at).parent;
+  const $at = tr.doc.resolve(at);
+  const parent = $at.parent;
   if (parent.type !== docxSchema.nodes.paragraph) return false;
-  const types = [{ type: docxSchema.nodes.paragraph, attrs: parent.attrs }];
+  const { before, after } = splitParagraphAttrs(parent);
+  const types = [{ type: docxSchema.nodes.paragraph, attrs: after }];
   if (!canSplit(tr.doc, at, 1, types)) return false;
-  if (dispatch) dispatch(tr.split(at, 1, types).scrollIntoView());
+  if (dispatch) {
+    const beforePos = $at.before();
+    tr.split(at, 1, types);
+    if (!keptEveryAttr(parent, before)) {
+      tr.setNodeMarkup(beforePos, null, before);
+    }
+    dispatch(tr.scrollIntoView());
+  }
   return true;
 };
+function keptEveryAttr(paragraph, attrs) {
+  return Object.keys(paragraph.attrs).every(
+    (name) => attrs[name] === paragraph.attrs[name]
+  );
+}
 var preserveTableFollowingParagraph = (state) => {
   const { $from } = state.selection;
   if (!state.selection.empty || $from.depth !== 1 || $from.parent.type !== docxSchema.nodes.paragraph || $from.parent.content.size !== 0 || $from.parentOffset !== 0) {

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

@@ -1,11 +1,13 @@
 /**
  * Draws list markers and inherited indentation as decorations so display-only values never create
- * new OOXML on export. The plugin also exposes numbering definitions to list commands.
+ * new OOXML on export. The definitions the markers are drawn from belong to the document
+ * snapshot, and the readers list commands ask stand here beside the drawing.
  */
 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;
@@ -18,25 +20,23 @@ 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[];
 export declare function markerDecorations(doc: PMNode, numbering: Numbering): DecorationSet;
-/** What the plugin holds: the document's list definitions and the numbers to draw right now */
-interface NumberingState {
-    numbering: Numbering;
-    /** Whether the document has a place (numbering.xml) to write the definition of a new list */
-    canStartNewList: boolean;
-    decorations: DecorationSet;
-}
 /** This document's list definitions. Empty when the editor does not know them */
 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;
-export declare function numberingMarkers(numbering?: Numbering, canStartNewList?: boolean): Plugin<NumberingState>;
-export {};
+/** Draws the numbers this document's lists put in front of their paragraphs */
+export declare function numberingMarkers(): Plugin<DecorationSet>;

package/dist/editor/plugins/numberingDecorations.js

@@ -1,12 +1,12 @@
 // src/editor/plugins/numberingDecorations.ts
 import { Plugin, PluginKey } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
-import { toParagraphFormat } from "../../model/format.js";
-import { computeMarkers } from "../../numbering/markers.js";
 import {
-  EMPTY_NUMBERING
-} from "../../numbering/parseNumbering.js";
+  toParagraphFormat
+} from "../../model/format.js";
+import { computeMarkers } from "../../numbering/markers.js";
 import { editorAttributes, editorCssVariables } from "../../styles/classNames.js";
+import { documentOf } from "../editorDocument.js";
 var FALLBACK_MARKER_WIDTH_PT = 18;
 function paragraphSpots(doc) {
   const spots = [];
@@ -47,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`);
   }
@@ -76,28 +115,20 @@ function markerDecorations(doc, numbering) {
 }
 var numberingKey = new PluginKey("docxEditorNumbering");
 function documentNumbering(state) {
-  return numberingKey.getState(state)?.numbering ?? EMPTY_NUMBERING;
+  return documentOf(state).formatting.numbering;
 }
 function canStartNewList(state) {
-  return numberingKey.getState(state)?.canStartNewList ?? true;
+  return documentOf(state).canStartNewList;
 }
-function numberingMarkers(numbering = EMPTY_NUMBERING, canStartNewList2 = true) {
+function numberingMarkers() {
   return new Plugin({
     key: numberingKey,
     state: {
-      init: (_config, state) => ({
-        numbering,
-        canStartNewList: canStartNewList2,
-        decorations: markerDecorations(state.doc, numbering)
-      }),
-      apply: (tr, current) => tr.docChanged ? {
-        numbering,
-        canStartNewList: canStartNewList2,
-        decorations: markerDecorations(tr.doc, numbering)
-      } : current
+      init: (_config, state) => markerDecorations(state.doc, documentOf(state).formatting.numbering),
+      apply: (tr, current, _old, state) => tr.docChanged ? markerDecorations(tr.doc, documentOf(state).formatting.numbering) : current
     },
     props: {
-      decorations: (state) => numberingKey.getState(state)?.decorations
+      decorations: (state) => numberingKey.getState(state)
     }
   });
 }

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

@@ -0,0 +1,7 @@
+/**
+ * The values a paragraph draws with, read out of the document's styles along the same path the
+ * import takes (`docx/formatting`), so that a paragraph an edit built, one it re-aligned and one
+ * the file arrived with all carry the same values for the same properties.
+ */
+import type { DocumentDeriver } from "./displayDerivation";
+export declare const paragraphDisplay: DocumentDeriver;

package/dist/editor/plugins/paragraphDisplay.js

@@ -0,0 +1,57 @@
+// src/editor/plugins/paragraphDisplay.ts
+import {
+  paragraphAttrsOf,
+  resolveParagraph,
+  resolveRun
+} 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;
+}
+function stands(node, previous) {
+  return previous !== null && previous.attrs.pPr === node.attrs.pPr && !carriesNothing(node);
+}
+function holdsComposition(node, pos, composing) {
+  return composing !== null && composing >= pos && composing <= pos + node.nodeSize;
+}
+var paragraphDisplay = {
+  name: "paragraph",
+  nodeTypes: ["paragraph"],
+  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,
+      placement
+    );
+    const derived = [
+      { pos, attrs: paragraphAttrsOf(paragraph) }
+    ];
+    node.forEach((child, offset) => {
+      const mark = docxSchema.marks.run.isInSet(child.marks);
+      if (!mark) return;
+      const rPr = mark.attrs.rPr;
+      derived.push({
+        pos: pos + 1 + offset,
+        mark: { type: mark.type, to: pos + 1 + offset + child.nodeSize },
+        attrs: {
+          format: resolveRun(
+            typeof rPr === "string" ? rPr : null,
+            paragraph,
+            formatting
+          )
+        }
+      });
+    });
+    return derived;
+  }
+};
+export {
+  paragraphDisplay
+};

package/dist/editor/plugins/tabLayout.js

@@ -1,12 +1,12 @@
 // src/editor/plugins/tabLayout.ts
 import { Plugin } from "prosemirror-state";
 import { DEFAULT_TAB_STOP_PT } from "../../docx/documentSettings.js";
+import { PX_PER_PT } from "../../docx/pageGeometry.js";
 import { toParagraphFormat } from "../../model/format.js";
 import { docxSchema } from "../../schema/index.js";
 import { editorClassNames, editorCssVariables } from "../../styles/classNames.js";
 import { documentDefaultTabStopPt } from "../documentStyles.js";
 import { setTabWidths, tabWidths } from "./tabDecorations.js";
-var PX_PER_PT = 96 / 72;
 var POSITION_EPSILON_PT = 0.01;
 var WIDTH_EPSILON_PX = 0.1;
 var NATURAL_WIDTH_PX = 1e5;

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

@@ -0,0 +1,6 @@
+/**
+ * The lines a table's cells draw because of where they sit in the grid (`table/gridBorders`),
+ * derived again once the grid or the border inputs of the table moved.
+ */
+import type { DocumentDeriver } from "./displayDerivation";
+export declare const tableDisplay: DocumentDeriver;

package/dist/editor/plugins/tableDisplay.js

@@ -0,0 +1,30 @@
+// 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) {
+    if (previous !== null && sameFormattingInputs(previous, table)) return [];
+    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 {
+  tableDisplay
+};

package/dist/index.d.ts

@@ -15,6 +15,8 @@ export { EditorView } from "prosemirror-view";
 export type { DocxEditorHandle, DocxEditorMode, DocxEditorProps, } from "./DocxEditor";
 export { DocxEditor } from "./DocxEditor";
 export type { DocxBytes, DocxSource } from "./docx/importDocx";
+/** What the handle and a `blocked` download report: each reason the document cannot be written, under the code `DocxExportError` would throw it with */
+export type { ExportProblem } from "./docx/invariants";
 export type { DownloadDocxOptions, DownloadDocxResult, } from "./download";
 export { downloadDocx } from "./download";
 export type { CommentAuthor } from "./editor/commands/commentCommands";

package/dist/model/format.d.ts

@@ -11,7 +11,7 @@
  * declaration, the checks that let through only the shapes the read functions produce
  * live here alongside them.
  */
-import type { TabStop } from "./tabStops";
+import { type TabStop } from "./tabStops";
 declare const ALIGNS: readonly ["left", "center", "right", "justify"];
 export type ParagraphAlign = (typeof ALIGNS)[number];
 declare const VERTICAL_ALIGNS: readonly ["superscript", "subscript"];
@@ -103,6 +103,11 @@ export interface ParagraphFormat {
      * page boundary guides
      */
     pageBreakBefore?: true;
+    /**
+     * Set when the document asks for this paragraph to stand on the same page as the start of the
+     * block after it (`w:keepNext`). Read by the page boundary guides
+     */
+    keepNext?: boolean;
     /** A CSS border in the form `1pt solid #000000` */
     borderTop?: string;
     borderBottom?: string;
@@ -110,15 +115,26 @@ export interface ParagraphFormat {
     borderRight?: string;
     background?: string;
 }
-/** The character formatting to render on screen */
+/**
+ * The character formatting to render on screen.
+ *
+ * A toggle the run switches off outright (`w:val="0"`) is false rather than absent: absent means
+ * the run says nothing and what the style laid down stands, false is the run beating that style.
+ */
 export interface RunFormat {
-    bold?: true;
-    italic?: true;
-    /** The underline kind. Absent entirely when there is no underline */
-    underline?: UnderlineKind;
-    strike?: true;
-    smallCaps?: true;
+    bold?: boolean;
+    italic?: boolean;
+    /** The underline kind, or `none` for an underline switched off outright. Absent when the run says nothing */
+    underline?: UnderlineKind | "none";
+    strike?: boolean;
+    /** Two lines through the text (`w:dstrike`). Read from the document and not drawn or edited yet */
+    doubleStrike?: boolean;
+    smallCaps?: boolean;
+    /** Every letter drawn as a capital (`w:caps`). Read from the document and not drawn or edited yet */
+    caps?: boolean;
     fontSizePt?: number;
+    /** The room added between characters (`w:spacing`), below zero where they are drawn closer. Read from the document and not drawn or edited yet */
+    characterSpacingPt?: number;
     /** A CSS font name list in the form `"맑은 고딕","Malgun Gothic"` */
     fontFamily?: string;
     color?: string;
@@ -133,6 +149,12 @@ export interface RunFormat {
      */
     lang?: string;
 }
+/**
+ * Every key of `RunFormat`, in the order a run's properties are read. The run property table
+ * (`docx/formatting/runProperties`) walks this list, which lives here because `model` imports
+ * nothing above it.
+ */
+export declare const RUN_FORMAT_KEYS: readonly ["bold", "italic", "strike", "doubleStrike", "smallCaps", "caps", "underline", "fontSizePt", "characterSpacingPt", "fontFamily", "color", "highlight", "background", "verticalAlign", "lang"];
 /**
  * The table formatting to render on screen. The inner lines between cells are folded
  * into the cell formatting
@@ -166,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
@@ -229,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;
 /**