@portone/docx-editor 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # @portone/docx-editor
 
+## 0.4.0
+
+### Minor Changes
+
+- [#102](https://github.com/portone-io/docx-editor/pull/102) [`4258530`](https://github.com/portone-io/docx-editor/commit/4258530aaf391ba546a282f73dff7b45f7063829) Thanks [@Deea222](https://github.com/Deea222)! - Draw the table styles and list numbering a document defines, and let a document that never held a list take one.
+  
+  A table style is now displayed part by part: the header row, the closing row, the first and last column, the corners and the banded rows take the shading, the lines and the text formatting the style dresses them with (`w:tblStylePr`), and `w:tblLook` decides which of those parts a table takes.
+  The bands are as many rows or columns wide as the style says (`w:tblStyleRowBandSize`, `w:tblStyleColBandSize`), and the header row and the closing row are not banded with the rest.
+  Text already in a cell follows its new position after a row edit, and the conditional-formatting markup a document arrived with goes back out untouched.
+  
+  A list that takes its numbers from a numbering style now draws them.
+  Such a list holds no numbers of its own: it names a style (`w:numStyleLink`), the style names a list, and that list's definition is where the numbers are, which is how Word writes a list built from its gallery.
+  Alongside decimal, bullets, upper and lower letters and lower Roman numerals, a list may now count in upper Roman numerals, decimal numbers with a leading zero, Ganada, Korean digits and the Chinese counting system; a format past those is still shown with decimal numbers.
+  Each level is drawn the way it asks to be: where its counting starts over (`w:lvlRestart`), whether the numbers in its text are all spelled as decimals (`w:isLgl`), what stands between its number and the paragraph text (`w:suff`), and where the number sits in the room kept for it (`w:lvlJc`).
+  A marker is also drawn in the character formatting its own level writes down (`lvl/rPr`), so bold, italic, color, size and typeface reach the number and never the text of the paragraph it stands in front of.
+  All of this is read; the numbering part goes back out exactly as it arrived.
+  
+  A new list no longer needs the document to have arrived with a numbering part.
+  The export writes `word/numbering.xml`, relates it from the main part and declares it in the content types, so a document that never held a list can take one; the list commands, which used to report that they did not apply in such a document, now do.
+  If an existing numbering relationship points to a missing part, the new definition is written at that location so the document can find the list when it is reopened.
+  
+  A new or pasted list is exported with the definition it was started with, rather than a format inferred from its numbering IDs, and undo restores that registration along with the edit.
+  A list whose definition is missing or unsupported is refused as `unsupported-content`, and a package with no `[Content_Types].xml` for the new numbering part to be declared in is refused as `missing-content-types`; `exportProblems` reports either ahead of the write.
+  List and abstract definition IDs stay distinct in a document already using the largest safely representable integer, and a value that cannot be written faithfully is rejected rather than silently changed or discarded.
+  
+  An ECMA-376 Strict package is refused with the new `unsupported-conformance` code, and a document whose main part root does not bind `w` to Transitional WordprocessingML is refused as `unsupported-content`.
+  Word saves neither by default, and both used to open far enough to fail later and obscurely: a Strict package as `missing-part`, and a document under another prefix as a `malformed-xml` about bookmarks on its first edit.
+  A write needing a prefix already bound to a different namespace is refused instead of silently giving new markup the wrong meaning, and a new hyperlink relationship attribute is checked for a declaration that shadows the root binding.
+  The comment and hyperlink writers now have the part's root declare the prefix they write under rather than declaring it on every element written, and editing an existing numbering or comment extension part that uses another prefix adds the writer's declaration at the root, so an untouched document still exports byte for byte and the exported XML stays readable.
+  
+  `DocxImportErrorCode` gains `unsupported-conformance`.
+  `DocxExportErrorCode` loses `missing-numbering-part`, since nothing can reach it any more, and that is a compile error for a `switch` over the code written to be exhaustive; drop the branch.
+  `missing-content-types` now also covers the numbering part a new list is defined in.
+  On `./core`, `Numbering` gains `added`, and the new `NewList` and `NewListLevel` types describe the definitions the editor registered.
+  Level maps are read-only, and a registered definition carries a restart, legal numbering and a suffix, while marker run formatting and custom tab stops stay outside what can be registered.
+
+### Patch Changes
+
+- [#101](https://github.com/portone-io/docx-editor/pull/101) [`1b6c723`](https://github.com/portone-io/docx-editor/commit/1b6c723982eed9c10656d57aca1d496e6baad5ec) Thanks [@Deea222](https://github.com/Deea222)! - Stop drawing the page number on the corner of each page.
+  
+  The page guides laid a small grey number inside the top right corner of every page, over the paper the text sits on.
+  It is gone, and the guides now draw the gaps between pages and the header and footer stories alone.
+  A document that prints its own page number through a `PAGE` field in a header or footer is unaffected: that number is the document's, not the editor's.
+  
+  The `docx-editor-page-badge` class the number carried is no longer emitted, so a rule of your own written against it in the published stylesheet no longer matches anything.
+
 ## 0.3.0
 
 ### Minor Changes

package/dist/DocxEditor.js

@@ -115,6 +115,7 @@ var IMPORT_REJECTION_REASON = {
   "missing-part": "This document is missing the part that holds its body.",
   "missing-body": "This document has no body.",
   "malformed-xml": "The XML inside this document cannot be read.",
+  "unsupported-conformance": "This document is saved in a format this editor cannot open. Save it as a Word document and try again.",
   "unsupported-content": "This document holds content that could not be kept as it is."
 };
 function ImportRejection({ error }) {

package/dist/core.d.ts

@@ -27,7 +27,7 @@ export type { DocxSession } from "./docx/session";
 export { documentNumbering, documentPartPath } from "./docx/session";
 export type { CellFormat, CellVerticalAlign, DocumentDefaults, HighlightName, LineSpacing, NumberingRef, ParagraphAlign, ParagraphFormat, RowFormat, RowHeight, RunFormat, TableFormat, TableWidth, TableWidthType, UnderlineKind, VerticalAlign, } from "./model/format";
 export { toCellFormat, toParagraphFormat, toRowFormat, toRunFormat, toTableFormat, toTableWidth, } from "./model/format";
-export type { LevelIndent, NumberFormat, Numbering, NumberingLevel, NumberingList, NumberingOptions, } from "./numbering/parseNumbering";
+export type { LevelAlign, LevelIndent, LevelSuffix, NewList, NewListLevel, NumberFormat, Numbering, NumberingLevel, NumberingList, NumberingOptions, NumberingStyleLinks, ReadLevelRun, } from "./numbering/parseNumbering";
 export { parseNumbering } from "./numbering/parseNumbering";
 export type { DocxExportErrorCode, DocxImportErrorCode, } from "./ooxml/errors";
 export { DocxExportError, DocxImportError } from "./ooxml/errors";

package/dist/docx/comments/writing.js

@@ -1,5 +1,5 @@
 // src/docx/comments/writing.ts
-import { elementXml, xmlnsAttr } from "../../ooxml/element.js";
+import { elementXml } from "../../ooxml/element.js";
 import { NAMESPACES, wName, xmlnsDecl } from "../../ooxml/names.js";
 import {
   ensureRootDeclarations,
@@ -74,10 +74,13 @@ function extensionsXml(references, comments, originallyReferenced) {
   if (comments.extendedXml === null) {
     return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w15:commentsEx ${xmlnsDecl("w15")}>${pieces.join("")}</w15:commentsEx>`;
   }
-  return splicePart(comments.extendedXml, {
-    root: EXTENSIONS_ROOT,
-    replaceChildren: pieces.join("")
-  });
+  return ensureRootDeclarations(
+    splicePart(comments.extendedXml, {
+      root: EXTENSIONS_ROOT,
+      replaceChildren: pieces.join("")
+    }),
+    { namespaces: { w15: NAMESPACES.w15 } }
+  );
 }
 var COMMENTS_ROOT = "comments";
 var EXTENSIONS_ROOT = "commentsEx";
@@ -117,7 +120,6 @@ function renderedComment(comment, arrivedKeyed, arrived) {
     ) : comment.commentXml;
   }
   const attrs = [
-    xmlnsAttr("w"),
     [wName("id"), comment.id],
     comment.author === null ? null : [wName("author"), comment.author],
     comment.date === null ? null : [wName("date"), comment.date],
@@ -131,8 +133,9 @@ function renderedComment(comment, arrivedKeyed, arrived) {
     [body]
   );
 }
+var COMMENT_MARKUP = { namespaces: { w: NAMESPACES.w } };
 var THREAD_MARKUP = {
-  namespaces: { w14: NAMESPACES.w14, mc: NAMESPACES.mc },
+  namespaces: { w: NAMESPACES.w, w14: NAMESPACES.w14, mc: NAMESPACES.mc },
   ignorable: ["w14"]
 };
 function currentCommentBodies(references) {
@@ -196,7 +199,10 @@ function commentsXml(references, comments, originallyReferenced) {
     root: COMMENTS_ROOT,
     replaceChildren: pieces.join("")
   });
-  return hasThreadMetadata ? ensureRootDeclarations(rewritten, THREAD_MARKUP) : rewritten;
+  return ensureRootDeclarations(
+    rewritten,
+    hasThreadMetadata ? THREAD_MARKUP : COMMENT_MARKUP
+  );
 }
 function planCommentParts(doc, session, context) {
   const bodyChanged = commentsChanged(doc, session);

package/dist/docx/exportDocx.js

@@ -1,8 +1,12 @@
 // src/docx/exportDocx.ts
 import { DocxExportError } from "../ooxml/errors.js";
+import {
+  ensureRootDeclarations
+} from "../ooxml/partSplice.js";
 import {
   encodeUtf8,
   parseXml,
+  R_NS,
   W_NS,
   withXmlParser
 } from "../ooxml/xml.js";
@@ -48,7 +52,7 @@ function buildDocumentXml(doc, session, refs) {
 function localAttribute(el, name) {
   return Array.from(el.attributes).find((attribute) => attribute.localName === name)?.value ?? null;
 }
-function assertBookmarkPairs(documentXml) {
+function assertMainPart(documentXml, wroteLinks) {
   let root;
   try {
     root = parseXml(documentXml).documentElement;
@@ -63,6 +67,15 @@ function assertBookmarkPairs(documentXml) {
   const used = /* @__PURE__ */ new Set();
   for (const element of root.getElementsByTagName("*")) {
     if (element.namespaceURI !== W_NS) continue;
+    if (wroteLinks && element.localName === "hyperlink") {
+      const id2 = element.getAttributeNode("r:id");
+      if (id2 && id2.namespaceURI !== R_NS) {
+        throw new DocxExportError(
+          "unsupported-content",
+          "a hyperlink's r:id is shadowed by a different relationship namespace"
+        );
+      }
+    }
     if (element.localName !== "bookmarkStart" && element.localName !== "bookmarkEnd") {
       continue;
     }
@@ -97,6 +110,7 @@ function assertBookmarkPairs(documentXml) {
     );
   }
 }
+var LINK_MARKUP = { namespaces: { r: R_NS } };
 var PART_PLANNERS = [
   numberingPlanner,
   commentsPlanner
@@ -135,12 +149,14 @@ function writeDocx(doc, store, notes, planners) {
     contentTypes: contentTypeWriter(store.parts)
   };
   const media = planImageMedia(doc, store, context);
-  const documentXml = buildDocumentXml(doc, store, {
+  const links = hyperlinkRefs(context.relationships);
+  const body = buildDocumentXml(doc, store, {
     images: media?.refs ?? NO_IMAGE_REFS,
-    links: hyperlinkRefs(context.relationships),
+    links,
     notes
   });
-  assertBookmarkPairs(documentXml);
+  const documentXml = links.addedRelId() ? ensureRootDeclarations(body, LINK_MARKUP) : body;
+  assertMainPart(documentXml, links.addedRelId());
   const parts = runPartPlanners(planners, doc, store, context, media?.parts);
   const rels = context.relationships.part(store.parts.get(relsPath));
   if (rels) parts.set(relsPath, rels);

package/dist/docx/formatting/attrs.d.ts

@@ -4,8 +4,8 @@
  * and the clipboard reader all take them from here, so a paragraph is drawn the same whichever of
  * them last touched it.
  */
-import type { Mark } from "prosemirror-model";
-import type { ParagraphFormat, RunFormat } from "../../model/format";
+import { type Mark, type Node as PMNode } from "prosemirror-model";
+import { type ParagraphFormat, type RunFormat } from "../../model/format";
 import type { FormattingContext } from "./context";
 import { type ParagraphPlacement, type ResolvedParagraph } from "./resolve";
 /** The two derived paragraph attrs (`format` and `styleRun` in `schema`) */
@@ -25,3 +25,21 @@ export declare function paragraphAttrsFor(pPr: string | null, context: Formattin
  * An inline that is not text and carries no mark is left as it is.
  */
 export declare function runMarkUnder(mark: Mark | null, isText: boolean, paragraph: ResolvedParagraph, context: FormattingContext): Mark | null;
+/**
+ * The paragraph with the values the hierarchy gives it, and the text inside it wearing the run
+ * mark that goes with them.
+ *
+ * The style's run values are also laid on the paragraph itself, so that text carrying no run of
+ * its own - typed in the editor - is drawn in them (`styleRun` in `schema`).
+ * Where the paragraph stands in a table cell, `placement` is the part of the table it belongs to,
+ * which the table style dresses on top of everything else it lays down.
+ */
+export declare function styledParagraph(node: PMNode, context: FormattingContext, placement?: ParagraphPlacement | null): PMNode;
+/** Table display inputs, refreshed from the same style context as the paragraphs inside it. */
+export declare function tableStyleAttrs(tblPr: Element | null, context: FormattingContext): {
+    format: import("../..").TableFormat | null;
+    styleInside: import("../tableFormatting").InsideBorders | null;
+    styleCellMargins: import("../tableFormatting").CellMargins | null;
+    styleConditions: Readonly<Partial<Record<"band1Horz" | "band1Vert" | "band2Horz" | "band2Vert" | "firstCol" | "firstRow" | "lastCol" | "lastRow" | "neCell" | "nwCell" | "seCell" | "swCell" | "wholeTable", import("../tableFormatting").CellStyleFormat>>> | null;
+    styleBands: import("../tableFormatting").BandSizes | null;
+};

package/dist/docx/formatting/attrs.js

@@ -1,9 +1,26 @@
 // src/docx/formatting/attrs.ts
+import { Fragment } from "prosemirror-model";
+import {
+  toBandSizes,
+  toCellMargins,
+  toInsideBorders,
+  toTableStyleConditions
+} from "../../model/format.js";
 import { docxSchema } from "../../schema/index.js";
+import {
+  cellConditionsOf,
+  layerBandSizes,
+  NO_BAND_SIZES,
+  readBandSizes,
+  readTableFormat,
+  tblStyleIdOf
+} from "../tableFormatting.js";
 import {
   resolveParagraph,
-  resolveRun
+  resolveRun,
+  tableStyleFor
 } from "./resolve.js";
+import { layerTableFormat } from "./styles.js";
 function paragraphAttrsOf(paragraph) {
   return { format: paragraph.format, styleRun: paragraph.styleRun };
 }
@@ -24,8 +41,46 @@ function runMarkUnder(mark, isText, paragraph, context) {
   const format = resolveRun(null, paragraph, context);
   return format === null ? null : docxSchema.marks.run.create({ rPr: null, rAttrs: null, format });
 }
+function styledParagraph(node, context, placement = null) {
+  const pPr = node.attrs.pPr;
+  const paragraph = resolveParagraph(
+    typeof pPr === "string" ? pPr : null,
+    context,
+    placement
+  );
+  const inline = node.children.map((child) => {
+    const mark = runMarkUnder(
+      child.marks.find((entry) => entry.type === docxSchema.marks.run) ?? null,
+      child.isText,
+      paragraph,
+      context
+    );
+    return mark ? child.mark(mark.addToSet(child.marks)) : child;
+  });
+  return node.type.create(
+    { ...node.attrs, ...paragraphAttrsOf(paragraph) },
+    Fragment.fromArray(inline),
+    node.marks
+  );
+}
+function tableStyleAttrs(tblPr, context) {
+  const style = tableStyleFor(tblStyleIdOf(tblPr), context);
+  return {
+    format: layerTableFormat(style?.table ?? {}, readTableFormat(tblPr)),
+    styleInside: toInsideBorders(style?.tableInside),
+    styleCellMargins: toCellMargins(style?.tableCellMargins),
+    styleConditions: toTableStyleConditions(
+      cellConditionsOf(style?.tableConditions ?? {})
+    ),
+    styleBands: toBandSizes(
+      layerBandSizes(style?.tableBands ?? NO_BAND_SIZES, readBandSizes(tblPr))
+    )
+  };
+}
 export {
   paragraphAttrsFor,
   paragraphAttrsOf,
-  runMarkUnder
+  runMarkUnder,
+  styledParagraph,
+  tableStyleAttrs
 };

package/dist/docx/formatting/context.d.ts

@@ -1,5 +1,5 @@
 import type { RunFormat } from "../../model/format";
-import { type Numbering } from "../../numbering/parseNumbering";
+import { type Numbering, type NumberingOptions } from "../../numbering/parseNumbering";
 import { type CompatSettings } from "../documentSettings";
 import { type ThemeFonts } from "../theme";
 import { type StyleTable } from "./styles";
@@ -27,5 +27,13 @@ export interface FormattingContext {
     compat: CompatSettings;
 }
 export declare const NO_FORMATTING: FormattingContext;
+/**
+ * How a document's numbering part is read against the rest of what the document lays down.
+ *
+ * The numbering folder cannot reach styles.xml, so the links a definition follows are handed to it
+ * from here, and the two callers that read a numbering part - opening a document and asking an
+ * open one for its lists - resolve the same links.
+ */
+export declare function numberingOptionsFor(styles: StyleTable, themeFonts: ThemeFonts): NumberingOptions;
 /** The context an opened document resolves against. A document without a styles part lays down nothing */
-export declare function formattingContextOf(styles: Document | null, numbering: Numbering, themeFonts: ThemeFonts, compat?: CompatSettings): FormattingContext;
+export declare function formattingContextOf(styles: Document | null, numberingXml: string | null, themeFonts: ThemeFonts, compat?: CompatSettings): FormattingContext;

package/dist/docx/formatting/context.js

@@ -1,14 +1,20 @@
 // src/docx/formatting/context.ts
 import {
-  EMPTY_NUMBERING
+  EMPTY_NUMBERING,
+  parseNumbering
 } from "../../numbering/parseNumbering.js";
 import { NO_COMPAT } from "../documentSettings.js";
 import { NO_THEME_FONTS } from "../theme.js";
-import { readDefaultParagraphFormat, readRunDefaults } from "./direct.js";
+import {
+  readDefaultParagraphFormat,
+  readRunDefaults,
+  readRunFormat
+} from "./direct.js";
 import {
   defaultParagraphStyleIdOf,
   defaultTableStyleIdOf,
   NO_STYLES,
+  numberingStyleLinks,
   readStyles
 } from "./styles.js";
 var NO_FORMATTING = {
@@ -21,12 +27,23 @@ var NO_FORMATTING = {
   themeFonts: NO_THEME_FONTS,
   compat: NO_COMPAT
 };
-function formattingContextOf(styles, numbering, themeFonts, compat = NO_COMPAT) {
+function numberingOptionsFor(styles, themeFonts) {
+  return {
+    links: numberingStyleLinks(styles),
+    readRun: (rPr) => readRunFormat(rPr, themeFonts)
+  };
+}
+function formattingContextOf(styles, numberingXml, themeFonts, compat = NO_COMPAT) {
+  const table = styles === null ? NO_STYLES : readStyles(styles, themeFonts);
+  const numbering = parseNumbering(
+    numberingXml,
+    numberingOptionsFor(table, themeFonts)
+  );
   if (styles === null) {
     return { ...NO_FORMATTING, numbering, themeFonts, compat };
   }
   return {
-    styles: readStyles(styles, themeFonts),
+    styles: table,
     defaultParagraphStyleId: defaultParagraphStyleIdOf(styles),
     defaultTableStyleId: defaultTableStyleIdOf(styles),
     paragraphDefaults: readDefaultParagraphFormat(styles),
@@ -38,5 +55,6 @@ function formattingContextOf(styles, numbering, themeFonts, compat = NO_COMPAT)
 }
 export {
   NO_FORMATTING,
-  formattingContextOf
+  formattingContextOf,
+  numberingOptionsFor
 };

package/dist/docx/formatting/resolve.d.ts

@@ -9,13 +9,12 @@ import { type ParagraphFormat, type RunFormat } from "../../model/format";
 import type { TabStop } from "../../model/tabStops";
 import type { TableStyleOverrideType } from "../tableFormatting";
 import type { FormattingContext } from "./context";
+import { type StyleFormat } from "./styles";
 /** Where a paragraph sits when it is inside a table cell. null for body text */
 export interface ParagraphPlacement {
+    /** What the table's `w:tblStyle` names. null for a table naming none, which wears the default one */
     tableStyleId: string | null;
-    /**
-     * The conditional formats the cell takes, lowest first. Not read yet: a table style
-     * contributes the values it lays down for the whole table alone
-     */
+    /** The parts of the table the cell belongs to, lowest first (`docx/tableFormatting/conditions`) */
     conditions: readonly TableStyleOverrideType[];
 }
 /**
@@ -38,6 +37,13 @@ export interface ResolvedParagraph {
     /** The stops `format.tabStops` holds, each with the layer that laid it down */
     tabStops: readonly LayeredTabStop[];
 }
+/**
+ * The table style an object wearing this one is dressed by.
+ *
+ * A table that points at no style, or at one that is not defined, falls back on the document's
+ * default table style, which is what OOXML applies to an object with no style of its own.
+ */
+export declare function tableStyleFor(styleId: string | null, context: FormattingContext): StyleFormat | undefined;
 export declare function resolveParagraph(pPr: string | null, context: FormattingContext, placement?: ParagraphPlacement | null): ResolvedParagraph;
 /** `format` on a run mark: paragraph.styleRun < character style < the run's own rPr */
 export declare function resolveRun(rPr: string | null, paragraph: ResolvedParagraph, context: FormattingContext): RunFormat | null;

package/dist/docx/formatting/resolve.js

@@ -2,6 +2,7 @@
 import {
   toParagraphFormat
 } from "../../model/format.js";
+import { listFor } from "../../numbering/listTemplate.js";
 import {
   levelIndentPt
 } from "../../numbering/parseNumbering.js";
@@ -14,9 +15,17 @@ import {
 function directLayer(pPr) {
   return pPr === null ? {} : readParagraphFormat(parsePropsXml(pPr)) ?? {};
 }
-function tableStyleOf(placement, context) {
-  const id = placement?.tableStyleId ?? null;
-  return id === null ? void 0 : context.styles.get(id);
+function tableStyleFor(styleId, context) {
+  const named = styleId === null ? void 0 : context.styles.get(styleId);
+  const fallback = context.defaultTableStyleId === null ? void 0 : context.styles.get(context.defaultTableStyleId);
+  return named ?? fallback;
+}
+function conditionsOf(style, placement) {
+  if (!style || !placement) return [];
+  return placement.conditions.flatMap((type) => {
+    const format = style.tableConditions[type];
+    return format ? [format] : [];
+  });
 }
 function numberingLevelOf(layers, context) {
   const ref = layers.reduce(
@@ -24,7 +33,7 @@ function numberingLevelOf(layers, context) {
     void 0
   );
   if (!ref) return void 0;
-  return context.numbering.lists.get(ref.numId)?.levels.get(ref.ilvl);
+  return listFor(context.numbering, ref.numId)?.levels.get(ref.ilvl);
 }
 function numberingLayer(level) {
   return level?.tabStops ? { tabStops: level.tabStops } : {};
@@ -66,16 +75,23 @@ function orNull(values) {
   return Object.keys(values).length === 0 ? null : values;
 }
 function resolveParagraph(pPr, context, placement = null) {
-  const tableStyle = tableStyleOf(placement, context);
+  const tableStyle = placement === null ? void 0 : tableStyleFor(placement.tableStyleId, context);
+  const conditions = conditionsOf(tableStyle, placement);
   const style = paragraphStyleFormat(
     pPr,
     context.styles,
     context.defaultParagraphStyleId
   );
   const direct = directLayer(pPr);
+  const table = [
+    { values: tableStyle?.paragraph ?? {}, stops: "style" },
+    ...conditions.map(
+      (condition) => ({ values: condition.paragraph, stops: "style" })
+    )
+  ];
   const explicit = [
     { values: context.paragraphDefaults, stops: "style" },
-    { values: tableStyle?.paragraph ?? {}, stops: "style" },
+    ...table,
     { values: style?.paragraph ?? {}, stops: "style" },
     { values: direct, stops: "direct" }
   ];
@@ -83,10 +99,11 @@ function resolveParagraph(pPr, context, placement = null) {
     explicit.map((layer) => layer.values),
     context
   );
+  const belowNumbering = 1 + table.length;
   const layers = [
-    ...explicit.slice(0, 2),
+    ...explicit.slice(0, belowNumbering),
     { values: numberingLayer(level), stops: "numbering" },
-    ...explicit.slice(2)
+    ...explicit.slice(belowNumbering)
   ];
   const values = layers.reduce(
     (base, layer) => layerValues(base, layer.values),
@@ -107,8 +124,10 @@ function resolveParagraph(pPr, context, placement = null) {
     ...displayDefaults
   } = context.runDefaults;
   const styleRun = {
-    ...displayDefaults,
-    ...tableStyle?.run,
+    ...conditions.reduce(
+      (run, condition) => ({ ...run, ...condition.run }),
+      { ...displayDefaults, ...tableStyle?.run }
+    ),
     ...style?.run
   };
   return {
@@ -136,5 +155,6 @@ function inheritedRunFormat(rPr, paragraph, context) {
 export {
   inheritedRunFormat,
   resolveParagraph,
-  resolveRun
+  resolveRun,
+  tableStyleFor
 };

package/dist/docx/formatting/styles.d.ts

@@ -1,9 +1,16 @@
 /** Reads and layers styles.xml values used by the display model. */
-import { type CellMargins, type InsideBorders, type ParagraphFormat, type RunFormat, type TableFormat } from "../../model/format";
+import { type BandSizes, type CellMargins, type InsideBorders, type ParagraphFormat, type RunFormat, type TableFormat, type TableStyleOverrideType } from "../../model/format";
+import type { NumberingStyleLinks } from "../../numbering/parseNumbering";
+import { type ConditionalTableFormat } from "../tableFormatting";
 import { type ThemeFonts } from "../theme";
 import { type ParagraphFormatLayer } from "./tabStops";
+/** The kind of object a style dresses (`w:style/@w:type`, ST_StyleType) */
+export type StyleType = "paragraph" | "character" | "table" | "numbering";
+/** What a table style dresses each part of a table with, by the part it covers */
+export type TableStyleConditionFormats = Readonly<Partial<Record<TableStyleOverrideType, ConditionalTableFormat>>>;
 /** The display values one style passes down to paragraphs, to text, and to tables */
 export interface StyleFormat {
+    type: StyleType;
     paragraph: ParagraphFormatLayer;
     run: RunFormat;
     table: TableFormat;
@@ -11,6 +18,14 @@ export interface StyleFormat {
     tableInside: InsideBorders;
     /** The cell margins the style laid down. A side it says nothing about is null */
     tableCellMargins: CellMargins;
+    /** How many rows and columns one band of this table style is made of */
+    tableBands: BandSizes;
+    /**
+     * The conditional formats it wrote (`w:tblStylePr`). Each part is layered down the `basedOn`
+     * chain on its own, so a style that redresses the header row alone leaves the parts the styles
+     * it is based on dressed standing.
+     */
+    tableConditions: TableStyleConditionFormats;
 }
 /** A table looked up by style name. The `basedOn` chain has already been layered into the values */
 export type StyleTable = ReadonlyMap<string, StyleFormat>;
@@ -19,10 +34,18 @@ export declare const NO_STYLES: StyleTable;
  * Reads the style chain from styles.xml into effective values for display.
  *
  * A style name is unique across all kinds (paragraph, character, table), so we take them in
- * without telling the kinds apart.
+ * without telling the kinds apart, and each one remembers the kind it is.
  * The names a paragraph points at are only ever paragraph styles, so the other kinds are never looked up.
  */
 export declare function readStyles(styles: Document, themeFonts?: ThemeFonts): StyleTable;
+/**
+ * The list each numbering style names.
+ *
+ * A numbering style carries its list in the `w:numPr` of its paragraph properties, and that is the
+ * only way a numbering definition deferring to a style (`w:numStyleLink`) finds the levels it
+ * draws. A style naming no list, or naming the empty list `w:numId` 0, links to nothing.
+ */
+export declare function numberingStyleLinks(styles: StyleTable): NumberingStyleLinks;
 /**
  * The default table style, which for most documents is where a plain table gets its cell margins
  * and its lines from