@portone/docx-editor 0.3.0 → 0.5.0

package/dist/docx/session.d.ts

@@ -10,10 +10,12 @@
 import type { Node as PMNode } from "prosemirror-model";
 import type { DocumentDefaults } from "../model/format";
 import { type Numbering, type NumberingOptions } from "../numbering/parseNumbering";
-import type { ImportedComments } from "./comments";
-import type { FormattingContext, ParagraphStyleOption } from "./formatting";
-import type { HeadersFooters } from "./headersFooters";
+import { type StoryKey } from "../schema/stories";
+import type { ImportedComments } from "./comments/reading";
+import { type FormattingContext, type ParagraphStyleOption } from "./formatting";
+import type { HeaderFooterStories } from "./headersFooters";
 import type { PageGeometry } from "./pageGeometry";
+import type { ImportedStory } from "./story";
 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 */
@@ -55,7 +57,7 @@ export declare class SessionStore implements DocxSession, SessionIdentity {
     readonly defaults: DocumentDefaults;
     /** The effective automatic tab interval read from settings.xml. Used for display only. */
     readonly defaultTabStopPt: number;
-    /** 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 */
+    /** The paper this document is written on, read from the first section. Used for display only: the `w:sectPr` itself goes back out as the text it arrived as */
     readonly geometry: PageGeometry;
     /** Everything the display values of a paragraph or a run are resolved against: the style chain, the defaults, the list definitions */
     readonly formatting: FormattingContext;
@@ -69,9 +71,24 @@ export declare class SessionStore implements DocxSession, SessionIdentity {
     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">);
+    /**
+     * What picking one section's headers and footers takes beyond the section itself: which story
+     * each header or footer relationship names, and the document-wide switch between odd and even.
+     * The stories themselves stand with every other one, so an edited header is read the same way.
+     */
+    readonly headerFooterStories: HeaderFooterStories;
+    /**
+     * The side stories the package arrived holding - a comment's body, a footnote's - each as the
+     * blocks it was written in. What the document currently says stands on the document node
+     * instead (`docx/story`), so the two compare the way a body block and its original do.
+     */
+    readonly stories: ReadonlyMap<StoryKey, ImportedStory>;
+    constructor(opened: Omit<SessionStore, "kind" | "blocksOf">);
+    /**
+     * The blocks of one story as it arrived, which is what a block key of that story indexes into.
+     * Empty for a story this document does not hold.
+     */
+    blocksOf(key: string): readonly ImportedBlock[];
 }
 /**
  * The store behind a session token.

package/dist/docx/session.js

@@ -2,6 +2,10 @@
 import {
   parseNumbering
 } from "../numbering/parseNumbering.js";
+import { asStoryKey } from "../schema/stories.js";
+import {
+  numberingOptionsFor
+} from "./formatting.js";
 var sessionsOpened = 0;
 function newSessionId() {
   sessionsOpened += 1;
@@ -21,7 +25,7 @@ var SessionStore = class {
   defaults;
   /** The effective automatic tab interval read from settings.xml. Used for display only. */
   defaultTabStopPt;
-  /** 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 */
+  /** The paper this document is written on, read from the first section. Used for display only: the `w:sectPr` itself goes back out as the text it arrived as */
   geometry;
   /** Everything the display values of a paragraph or a run are resolved against: the style chain, the defaults, the list definitions */
   formatting;
@@ -35,8 +39,18 @@ var SessionStore = class {
   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;
+  /**
+   * What picking one section's headers and footers takes beyond the section itself: which story
+   * each header or footer relationship names, and the document-wide switch between odd and even.
+   * The stories themselves stand with every other one, so an edited header is read the same way.
+   */
+  headerFooterStories;
+  /**
+   * The side stories the package arrived holding - a comment's body, a footnote's - each as the
+   * blocks it was written in. What the document currently says stands on the document node
+   * instead (`docx/story`), so the two compare the way a body block and its original do.
+   */
+  stories;
   constructor(opened) {
     this.sessionId = opened.sessionId;
     this.parts = opened.parts;
@@ -54,7 +68,17 @@ var SessionStore = class {
     this.numberingPartPath = opened.numberingPartPath;
     this.comments = opened.comments;
     this.commentReferenceIds = opened.commentReferenceIds;
-    this.headersFooters = opened.headersFooters;
+    this.headerFooterStories = opened.headerFooterStories;
+    this.stories = opened.stories;
+  }
+  /**
+   * The blocks of one story as it arrived, which is what a block key of that story indexes into.
+   * Empty for a story this document does not hold.
+   */
+  blocksOf(key) {
+    if (key === BODY_STORY_KEY) return this.blocks;
+    const story = asStoryKey(key);
+    return story === null ? [] : this.stories.get(story)?.blocks ?? [];
   }
 };
 function sessionOf(session) {
@@ -65,7 +89,14 @@ function documentPartPath(session) {
   return sessionOf(session).mainPartPath;
 }
 function documentNumbering(session, options) {
-  return parseNumbering(sessionOf(session).numberingXml, options);
+  const store = sessionOf(session);
+  return parseNumbering(store.numberingXml, {
+    ...numberingOptionsFor(
+      store.formatting.styles,
+      store.formatting.themeFonts
+    ),
+    ...options
+  });
 }
 var BODY_STORY_KEY = "body";
 function blockKey(session, storyKey, index) {
@@ -90,7 +121,7 @@ function originalBlock(node, session) {
   if (typeof srcId !== "string") return void 0;
   const key = splitBlockKey(srcId);
   if (key === null || key.sessionId !== session.sessionId) return void 0;
-  return key.storyKey === BODY_STORY_KEY ? session.blocks[key.index] : void 0;
+  return session.blocksOf(key.storyKey)[key.index];
 }
 export {
   BODY_STORY_KEY,

package/dist/docx/story.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Reads a side story - a comment's body, a footnote's - the way the body of the document is read.
+ *
+ * A story is a document of the same schema, built by the same block readers, sliced verbatim by
+ * the same scanner. That is what lets a comment keep its bold run, its paragraph style and its
+ * second paragraph through an edit: the editor no longer holds a body as the plain text it reads
+ * as, but as the blocks it was written in, and writes back the ones nobody touched exactly as they
+ * arrived (`./serializeStory`).
+ *
+ * The stories the package arrived holding live on the session; what the document currently says
+ * lives on the document node, under `doc.attrs.stories`, so an edit to one rides a transaction and
+ * lands in the history beside every other edit.
+ */
+import { type Node as PMNode } from "prosemirror-model";
+import { type StoryKey, type StoryKind, storyNodeOf } from "../schema/stories";
+import { type FormattingContext } from "./formatting";
+import { type ImportSources } from "./importParagraph";
+import { type ImportedBlock, type SessionIdentity } from "./session";
+export type { StoryJson, StoryKey, StoryKind } from "../schema/stories";
+export { asStoryKey, sameStory, storiesOf, storyKey, withoutCommentStories, } from "../schema/stories";
+/** The story this key names as a document node, and null where the document holds none */
+export declare const storyOf: typeof storyNodeOf;
+/** One story as the package arrived holding it: where it stands, and the blocks it was written in */
+export interface ImportedStory {
+    key: StoryKey;
+    kind: StoryKind;
+    id: string;
+    partPath: string;
+    /** The whole element as written, which is what a story nobody edited goes back out as */
+    xml: string;
+    /**
+     * The container's opening tag as written, e.g. `<w:comment w:id="4" w:author="A">`. A container
+     * that arrived self-closing is written out as a pair, since an edited story needs one
+     */
+    open: string;
+    /** Everything after the last block, the closing tag included */
+    close: string;
+    /** The blocks between them, sliced verbatim; a block's `srcId` indexes into this list */
+    blocks: readonly ImportedBlock[];
+    doc: PMNode;
+}
+/** Where a run of stories of one kind is written down, and what tells one of them from the next */
+export interface StoryPart {
+    kind: StoryKind;
+    partPath: string;
+    xml: string;
+    /** The local name of the element each story stands in, e.g. `comment` or `footnote` */
+    entryName: string;
+    /** The attribute naming which story an element is */
+    idAttr: string;
+}
+/** What reading a story takes beyond the text of it */
+export interface StoryDeps {
+    session: SessionIdentity;
+    /**
+     * The images and links of the part the story stands in. A story holds neither a comment nor a
+     * note of its own - WordprocessingML puts neither there - so those two are read empty.
+     */
+    sources: ImportSources;
+    formatting: FormattingContext;
+}
+/**
+ * Moves a single block into a node.
+ *
+ * A paragraph always opens editable (`./importParagraph`). What is left over is a table whose rows
+ * this reader could not take apart, a range marker standing between blocks, and a block this
+ * reader has no reader for at all; each stands as one placeholder naming the original fragment.
+ */
+export declare function buildBlock(el: Element, srcId: string, sources: ImportSources, context: FormattingContext): PMNode;
+/**
+ * Folds the style chain into the display values.
+ *
+ * These values are used for display only, so the original XML fragments are left untouched.
+ * A table is left alone: which part of it a cell belongs to is what its table style dresses the
+ * paragraphs inside by, and `buildTable` is where that is known.
+ */
+export declare function withStyleFormats(node: PMNode, context: FormattingContext): PMNode;
+/**
+ * One story as it stands in the part, with its blocks read and sliced.
+ *
+ * A container holding no block at all still opens editable, the way a body holding nothing but a
+ * section does: the placeholder paragraph names an empty original fragment, so a story nobody
+ * edited goes back out as the bytes it arrived as.
+ */
+export declare function readStory(place: {
+    kind: StoryKind;
+    id: string;
+    partPath: string;
+}, container: {
+    el: Element;
+    xml: string;
+}, deps: StoryDeps): ImportedStory;
+/** Every story one part holds, in the order the part writes them */
+export declare function readStories(part: StoryPart, deps: StoryDeps): readonly ImportedStory[];
+/** The stories of a document keyed the way the session holds them */
+export declare function storiesByKey(stories: Iterable<ImportedStory>): ReadonlyMap<StoryKey, ImportedStory>;
+/**
+ * What writing a story takes of a transaction: the document it stands on, and the one step that
+ * changes a document attr.
+ *
+ * A `Transaction` is what a caller passes, and it is named by shape rather than imported because
+ * `src/core.ts` must reach neither the editor nor `prosemirror-state` (`src/core.test.ts`), and
+ * this module is on the way there.
+ */
+interface StoryWriter {
+    readonly doc: PMNode;
+    setDocAttribute(attr: string, value: unknown): this;
+}
+/** The document with this story written into it, which is the one way a story changes */
+export declare function setStory<T extends StoryWriter>(tr: T, key: StoryKey, story: PMNode): T;
+/** The document with these stories taken out of it, which is what deleting what they say leaves */
+export declare function withoutStories<T extends StoryWriter>(tr: T, keys: Iterable<StoryKey>): T;
+/**
+ * A story holding this text, one paragraph broken by a line break wherever the text is.
+ *
+ * That is the shape a plain-text body has been written in since before there were stories, so a
+ * body written through `updateComment` goes out as the bytes it always did.
+ */
+export declare function storyFromText(text: string): PMNode;
+/**
+ * What one leaf of a story puts on screen.
+ *
+ * A break ends a line, and a fragment the editor keeps rather than models says what it stands for
+ * - the character a `w:noBreakHyphen` draws, the words inside a field - which is the same answer
+ * `docx/importPolicy` gave when a body was flattened on the way in. Everything reading a story as
+ * plain text - a comment body, a footnote body, a header preview - asks here rather than keeping a
+ * vocabulary of its own, so the three of them cannot disagree.
+ */
+export declare function storyLeafText(leaf: PMNode): string;
+/** What a story reads as on screen: its paragraphs joined by newlines, its breaks and tabs kept */
+export declare function storyText(story: PMNode | null): string;
+/**
+ * The story with the thread key on the last paragraph of it, which is where Word keeps it.
+ *
+ * The key is written into the paragraph's own attribute text rather than into a model attr,
+ * because that text is what the writer puts back and a `w14:paraId` is not a name this schema
+ * holds. A paragraph already carrying one keeps it: a key already written is what the thread
+ * state elsewhere is keyed by, so re-pointing it would orphan that state.
+ */
+export declare function withThreadKeyOn(story: PMNode, paraId: string): PMNode;

package/dist/docx/story.js

@@ -0,0 +1,237 @@
+// src/docx/story.ts
+import { Fragment } from "prosemirror-model";
+import { xmlnsAttr } from "../ooxml/element.js";
+import { DocxImportError } from "../ooxml/errors.js";
+import { NAMESPACES, qualify } from "../ooxml/names.js";
+import { attributeByLocalName, elementChildren, parseXml } from "../ooxml/xml.js";
+import { docxSchema } from "../schema/index.js";
+import { isPreservedNode } from "../schema/preservedFragments.js";
+import {
+  STORIES_ATTR,
+  storiesOf,
+  storyKey,
+  storyNodeOf
+} from "../schema/stories.js";
+import { styledParagraph } from "./formatting.js";
+import { buildParagraph } from "./importParagraph.js";
+import { buildPreservedBlock } from "./importPreserved.js";
+import { buildTable } from "./importTable.js";
+import { scanBlocksIn } from "./scan.js";
+import { blockKey } from "./session.js";
+import {
+  asStoryKey,
+  sameStory,
+  storiesOf as storiesOf2,
+  storyKey as storyKey2,
+  withoutCommentStories
+} from "../schema/stories.js";
+var storyOf = storyNodeOf;
+function buildBlock(el, srcId, sources, context) {
+  if (el.localName === "p") return buildParagraph(el, srcId, sources);
+  if (el.localName === "tbl") {
+    const table = buildTable(el, srcId, sources, context);
+    if (table) return table;
+  }
+  return buildPreservedBlock(el, srcId, "body");
+}
+function withStyleFormats(node, context) {
+  if (node.type === docxSchema.nodes.paragraph) {
+    return styledParagraph(node, context);
+  }
+  if (node.childCount === 0 || node.type === docxSchema.nodes.table) {
+    return node;
+  }
+  const children = node.children.map(
+    (child) => withStyleFormats(child, context)
+  );
+  if (children.every((child, i) => child === node.child(i))) return node;
+  return node.copy(Fragment.fromArray(children));
+}
+function malformed(what) {
+  throw new DocxImportError("malformed-xml", what);
+}
+var SELF_CLOSING = /\/>\s*$/;
+function scanElement(xml, el) {
+  const scan = scanBlocksIn(xml, (_tag, depth) => depth === 0);
+  if (scan !== null) return scan;
+  if (!SELF_CLOSING.test(xml) || el.children.length > 0) {
+    malformed(`no ${el.nodeName} element to read from`);
+  }
+  return {
+    prefix: xml.replace(SELF_CLOSING, ">"),
+    blocks: [],
+    suffix: `</${el.nodeName}>`
+  };
+}
+function scanContainer(xml, el) {
+  const scan = scanElement(xml, el);
+  const children = elementChildren(el);
+  if (children.length !== scan.blocks.length) {
+    malformed(
+      `the block count of ${el.nodeName} differs between the scan and the DOM`
+    );
+  }
+  children.forEach((child, at) => {
+    if (child.nodeName !== scan.blocks[at].name) {
+      malformed(
+        `story block names disagree: ${child.nodeName} vs ${scan.blocks[at].name}`
+      );
+    }
+  });
+  return { scan, children };
+}
+function readStory(place, container, deps) {
+  const key = storyKey(place.kind, place.id);
+  const { scan, children } = scanContainer(container.xml, container.el);
+  const nodes = children.map(
+    (child, at) => withStyleFormats(
+      buildBlock(
+        child,
+        blockKey(deps.session, key, at),
+        deps.sources,
+        deps.formatting
+      ),
+      deps.formatting
+    )
+  );
+  const blocks = nodes.map((node, at) => ({
+    xml: scan.blocks[at].xml,
+    node
+  }));
+  if (nodes.length === 0) {
+    const placeholder = withStyleFormats(
+      docxSchema.nodes.paragraph.create({
+        srcId: blockKey(deps.session, key, 0)
+      }),
+      deps.formatting
+    );
+    nodes.push(placeholder);
+    blocks.push({ xml: "", node: placeholder });
+  }
+  return {
+    key,
+    kind: place.kind,
+    id: place.id,
+    partPath: place.partPath,
+    xml: container.xml,
+    open: scan.prefix,
+    close: scan.suffix,
+    blocks,
+    doc: docxSchema.nodes.doc.create(null, nodes)
+  };
+}
+function readStories(part, deps) {
+  const root = parseXml(part.xml).documentElement;
+  const scan = scanElement(part.xml, root);
+  const children = elementChildren(root);
+  if (children.length !== scan.blocks.length) {
+    malformed(
+      `the entry count of ${part.partPath} differs between the scan and the DOM`
+    );
+  }
+  const stories = [];
+  const seen = /* @__PURE__ */ new Set();
+  children.forEach((el, at) => {
+    if (el.localName !== part.entryName) return;
+    const id = attributeByLocalName(el, part.idAttr);
+    if (id === null || seen.has(id)) return;
+    seen.add(id);
+    const xml = scan.blocks[at].xml;
+    stories.push(
+      readStory(
+        { kind: part.kind, id, partPath: part.partPath },
+        { el, xml: xml.slice(xml.indexOf("<")) },
+        deps
+      )
+    );
+  });
+  return stories;
+}
+function storiesByKey(stories) {
+  return new Map(Array.from(stories, (story) => [story.key, story]));
+}
+function setStory(tr, key, story) {
+  const json = story.toJSON();
+  return tr.setDocAttribute(STORIES_ATTR, {
+    ...storiesOf(tr.doc),
+    [key]: json
+  });
+}
+function withoutStories(tr, keys) {
+  const dropped = new Set(keys);
+  const stories = storiesOf(tr.doc);
+  const kept = Object.fromEntries(
+    Object.entries(stories).filter(([held]) => !dropped.has(held))
+  );
+  if (Object.keys(kept).length === Object.keys(stories).length) return tr;
+  return tr.setDocAttribute(STORIES_ATTR, kept);
+}
+function storyFromText(text) {
+  const pieces = [];
+  text.split("\n").forEach((line, at) => {
+    if (at > 0) pieces.push(docxSchema.nodes.hardBreak.create());
+    if (line.length > 0) pieces.push(docxSchema.text(line));
+  });
+  return docxSchema.nodes.doc.create(null, [
+    docxSchema.nodes.paragraph.create(null, pieces)
+  ]);
+}
+var EMBEDDED = /* @__PURE__ */ new Set([
+  "drawing",
+  "pict",
+  "object",
+  "AlternateContent"
+]);
+function storyLeafText(leaf) {
+  if (leaf.isText) return leaf.text ?? "";
+  if (leaf.type === docxSchema.nodes.hardBreak) return "\n";
+  if (!isPreservedNode(leaf)) return "";
+  const element = leaf.attrs.element;
+  if (typeof element === "string" && EMBEDDED.has(element)) return "";
+  if (leaf.attrs.display === "break") return "\n";
+  return typeof leaf.attrs.text === "string" ? leaf.attrs.text : "";
+}
+function storyText(story) {
+  if (story === null) return "";
+  return story.textBetween(0, story.content.size, "\n", storyLeafText);
+}
+function withThreadKeyOn(story, paraId) {
+  let at = -1;
+  story.forEach((block, _offset, index) => {
+    if (block.type === docxSchema.nodes.paragraph) at = index;
+  });
+  if (at === -1) return story;
+  const paragraph = story.child(at);
+  const written = paragraph.attrs.pAttrs;
+  const pAttrs = typeof written === "string" ? written : "";
+  if (/\bw14:paraId\s*=/.test(pAttrs)) return story;
+  const declared = /\bxmlns:w14\s*=/.test(pAttrs) ? "" : `${xmlnsAttr("w14")[0]}="${NAMESPACES.w14}" `;
+  const keyed = paragraph.type.create(
+    {
+      ...paragraph.attrs,
+      pAttrs: `${pAttrs === "" ? "" : `${pAttrs} `}${declared}${qualify("w14", "paraId")}="${paraId}"`
+    },
+    paragraph.content,
+    paragraph.marks
+  );
+  return story.copy(story.content.replaceChild(at, keyed));
+}
+export {
+  asStoryKey,
+  buildBlock,
+  readStories,
+  readStory,
+  sameStory,
+  setStory,
+  storiesByKey,
+  storiesOf2 as storiesOf,
+  storyFromText,
+  storyKey2 as storyKey,
+  storyLeafText,
+  storyOf,
+  storyText,
+  withStyleFormats,
+  withThreadKeyOn,
+  withoutCommentStories,
+  withoutStories
+};

package/dist/docx/storyProjection.js

@@ -9,7 +9,12 @@ function comparableStory(story, strip) {
   const blocks = [];
   try {
     story.doc.forEach((block) => {
-      blocks.push(serializeBlock(strip(block), story.session, NO_EXPORT_REFS));
+      blocks.push(
+        serializeBlock(strip(block), {
+          ...NO_EXPORT_REFS,
+          session: story.session
+        })
+      );
     });
   } catch (error) {
     if (error instanceof DocxExportError) return null;

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

@@ -0,0 +1,76 @@
+/**
+ * Which parts of a table one cell belongs to, and what its table style dresses those parts with.
+ *
+ * A table style says one thing for the header row, another for the first column, another for the
+ * banded rows (`w:tblStylePr`), and `w:tblLook` says which of those a table takes at all. Every
+ * caller that asks what a cell falls back on - the import, a table created fresh, the lines derived
+ * again after the grid moved, and a cell formatting edit - asks here, so a cell is dressed the same
+ * whichever of them asked.
+ *
+ * A conditional format writes the lines of the part it dresses rather than of every cell in it:
+ * its four sides are drawn where a cell lies on the edge of that part and its inside lines between
+ * the cells within it, which is the same rule the table's own lines are drawn by.
+ */
+import type { BandSizes, CellMargins, InsideBorders, TableFormat, TableStyleConditions, TableStyleOverrideType } from "../../model/format";
+import { type CellDefaults, type GridRect, type GridSize } from "./reading";
+/** Which parts of its table style a table takes (`w:tblLook`, §17.4.55) */
+export interface TableLook {
+    firstRow: boolean;
+    lastRow: boolean;
+    firstColumn: boolean;
+    lastColumn: boolean;
+    noHBand: boolean;
+    noVBand: boolean;
+}
+/**
+ * What a table writing no `w:tblLook` at all takes: the banded rows and columns, and neither the
+ * header row, the last row, nor the edge columns (§17.4.55). Switching the banding off is
+ * something a table has to say, which is why both band settings are worded as `no`.
+ */
+export declare const NO_LOOK: TableLook;
+/**
+ * Which parts of its table style this table takes.
+ *
+ * The six attributes are what a document writes today; where one of them is missing the legacy
+ * bitmask answers for it, so a document written either way reads the same.
+ */
+export declare function readTableLook(tblPr: Element | null): TableLook;
+/** One conditional format a cell takes, and the part of the grid it dresses */
+export interface CellCondition {
+    type: TableStyleOverrideType;
+    /** Its four lines are drawn on the edge of this block, and its inside lines within it */
+    region: GridRect;
+}
+/** Where a cell sits, and which parts of the table it therefore belongs to */
+export interface CellPlacement {
+    rect: GridRect;
+    grid: GridSize;
+    /** Lowest first, in the order §17.7.6 lays them over one another */
+    conditions: readonly CellCondition[];
+}
+/**
+ * The parts of the table this cell belongs to, lowest first.
+ *
+ * A cell sits in a row band by the row it starts in and in a column band by the column it starts
+ * in, and it is a corner only where the table takes both the row and the column that meet there.
+ */
+export declare function cellPlacement(rect: GridRect, grid: GridSize, look: TableLook, bands: BandSizes): CellPlacement;
+/** What a table lays down for its cells to draw. What its style laid down is not in the `tblPr`, so it comes along separately */
+export interface TableCellSources {
+    outer: TableFormat | null;
+    inside: InsideBorders;
+    margins: CellMargins;
+    /** The parts of its style the table takes */
+    look: TableLook;
+    bands: BandSizes;
+    /** What the style dresses each of those parts with */
+    conditions: TableStyleConditions;
+    /** The style the paragraphs inside the cells resolve against. null for a table wearing none */
+    styleId: string | null;
+}
+export declare const NO_CELL_SOURCES: TableCellSources;
+/**
+ * What the cell covering this block of the grid falls back on: the table's own lines and margins,
+ * with every conditional format its style dresses a part it belongs to with laid over them.
+ */
+export declare function cellDefaultsFor(rect: GridRect, grid: GridSize, sources: TableCellSources): CellDefaults;