@docx4j/core-ts 0.3.1 → 0.4.0

package/dist/model/customxml/pictures.mjs

@@ -0,0 +1,186 @@
+import { find } from '../content/tree.mjs';
+import { addImage, addImagePart, writableWidthEmu } from '../content/InlinePicture.mjs';
+import { ImagePart } from '../../parts/BinaryPart.mjs';
+import { base64Decode, base64Encode } from '../../xml/dom.mjs';
+import { enclosingCellOf } from '../properties/table.mjs';
+import { tagParamsOf, selectEntryNode, PICTURE_HANDLER } from './opendope.mjs';
+const EMU_PER_TWIP = 635;
+const BLIP = 'org_docx4j_dml.CTBlip';
+/** Whether a control is bound to a picture through its tag (`od:Handler=picture` with an `od:xpath`). */
+export function isPictureHandlerBound(control) {
+    const params = tagParamsOf(control.tag);
+    return params.get('od:Handler') === PICTURE_HANDLER && params.has('od:xpath');
+}
+/** The tag's `width` parameter, read as `PictureWidth` says. */
+export function pictureWidthOf(params) {
+    const width = params.get('width');
+    if (width === undefined)
+        return { kind: 'keep' };
+    const twips = /^\d+$/.test(width.trim()) ? Number(width) : 0;
+    return twips > 0 ? { kind: 'twips', twips } : { kind: 'auto' };
+}
+/** The node's value as base64: a data URL's prefix dropped, whitespace left to the lenient decoder. */
+function base64Of(value) {
+    return value.replace(/^\s*data:[^,]*,/, '').trim();
+}
+function messageOf(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+/** The first `a:blip` anywhere in the control's content, whose `r:embed` is the image. */
+function firstBlipOf(control) {
+    var _a;
+    for (const blip of find((_a = control.sdt.sdtContent) !== null && _a !== void 0 ? _a : {}, BLIP))
+        return blip;
+    return undefined;
+}
+/** A width stated in twips (`dxa`, or no type), else undefined. */
+function twipsOf(width) {
+    return width && typeof width.w === 'number' && width.w >= 0 && (width.type === undefined || width.type === 'dxa') ? width.w : undefined;
+}
+/**
+ * Word's default cell margins, 108 twips left and right (the `Normal Table` style's
+ * `w:tblCellMar`, which every table inherits), taken where neither the cell nor the table states
+ * one; a table style stating other margins is not read.
+ */
+const DEFAULT_CELL_MARGIN_TWIPS = 108;
+/** The cell's left and right margins together, in twips: `w:tcMar`, else the table's `w:tblCellMar`, else Word's defaults. */
+function cellMarginsTwips(tc, tbl) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const own = (_a = tc.tcPr) === null || _a === void 0 ? void 0 : _a.tcMar;
+    const table = (_b = tbl.tblPr) === null || _b === void 0 ? void 0 : _b.tblCellMar;
+    const left = (_e = (_c = twipsOf(own === null || own === void 0 ? void 0 : own.left)) !== null && _c !== void 0 ? _c : twipsOf((_d = table === null || table === void 0 ? void 0 : table.left) !== null && _d !== void 0 ? _d : table === null || table === void 0 ? void 0 : table.start)) !== null && _e !== void 0 ? _e : DEFAULT_CELL_MARGIN_TWIPS;
+    const right = (_h = (_f = twipsOf(own === null || own === void 0 ? void 0 : own.right)) !== null && _f !== void 0 ? _f : twipsOf((_g = table === null || table === void 0 ? void 0 : table.right) !== null && _g !== void 0 ? _g : table === null || table === void 0 ? void 0 : table.end)) !== null && _h !== void 0 ? _h : DEFAULT_CELL_MARGIN_TWIPS;
+    return left + right;
+}
+/**
+ * The width a new picture must fit, in EMU: the cell's `w:tcW` less its margins when the control
+ * is in a table cell and the width is stated in twips (a percentage or `auto` falls to the page),
+ * else the page's text width; narrowed to `width=N`. Undefined where nothing states a width (a
+ * header's body has no `w:sectPr`): the natural size then.
+ */
+function maxWidthEmu(control, width) {
+    var _a;
+    const cell = enclosingCellOf(control.element.value);
+    const tcW = cell ? twipsOf((_a = cell.tc.tcPr) === null || _a === void 0 ? void 0 : _a.tcW) : undefined;
+    const inner = cell && tcW !== undefined ? tcW - cellMarginsTwips(cell.tc, cell.tbl) : undefined;
+    const cellEmu = inner !== undefined && inner > 0 ? inner * EMU_PER_TWIP : undefined;
+    const text = cellEmu !== null && cellEmu !== void 0 ? cellEmu : writableWidthEmu(control.parentBody.container);
+    if (width.kind === 'twips') {
+        const wanted = width.twips * EMU_PER_TWIP;
+        return text === undefined ? wanted : Math.min(wanted, text);
+    }
+    return text;
+}
+/**
+ * Binds one control to a value: base64 image data (a data URL accepted). With `keep`, the first
+ * `a:blip`'s `r:embed` is pointed at a new image part and the drawing is left as it is; a picture
+ * control holding no picture gets a new inline one at its natural size instead (docx4j's pre-v3
+ * fallback), a tag-bound control holding none is left and noted. Otherwise the control's content
+ * becomes one run holding a new inline picture, sized as `PictureWidth` says, in the first
+ * paragraph of a block-level control (its properties kept) or as a run-level control's content.
+ * An empty value, a value that is not an image this package reads (PNG, JPEG, GIF, BMP; SVG where
+ * the drawing is kept, since it has no pixel size to place a new picture at), and a body with no
+ * part each leave the control as it was, with a note. The image part the control showed before
+ * stays in the package, as docx4j leaves it.
+ */
+export function bindPicture(control, value, width, label) {
+    const base64 = base64Of(value);
+    if (base64 === '')
+        return { done: false, note: `${label}: the node is empty; the control is left as it is` };
+    const source = control.parentBody.part;
+    if (!source)
+        return { done: false, note: `${label}: the control's body has no part to hold an image` };
+    if (width.kind === 'keep') {
+        const blip = firstBlipOf(control);
+        if (blip) {
+            try {
+                blip.embed = addImagePart(source, base64).relId;
+            }
+            catch (e) {
+                return { done: false, note: `${label}: not an image this package reads (${messageOf(e)})` };
+            }
+            control.isShowingPlaceholder = false;
+            return { done: true };
+        }
+        if (control.type !== 'Picture')
+            return { done: false, note: `${label}: the control holds no a:blip to point at the image (od:Handler=picture without width keeps the drawing)` };
+        width = { kind: 'auto' };
+    }
+    let run;
+    try {
+        run = addImage(source, base64, control.parentBody.container, maxWidthEmu(control, width)).run;
+    }
+    catch (e) {
+        return { done: false, note: `${label}: not an image this package reads (${messageOf(e)})` };
+    }
+    control.setBoundContent([run]);
+    return { done: true };
+}
+/** Binds one tag-bound control (shape b): the entry's node, the tag's width. */
+export function applyPictureHandlerTo(control, parts) {
+    var _a;
+    const params = tagParamsOf(control.tag);
+    const entryId = (_a = params.get('od:xpath')) !== null && _a !== void 0 ? _a : '';
+    const selected = selectEntryNode(entryId, parts);
+    if ('note' in selected)
+        return { done: false, note: selected.note };
+    return bindPicture(control, selected.node.text, pictureWidthOf(params), `od:xpath=${entryId}`);
+}
+/** The picture pass over the tag-bound controls, after the text bindings: counted into the result, what was left said in its notes. */
+export function applyPictureHandlersTo(controls, parts, result) {
+    var _a;
+    for (const control of controls) {
+        if (!isPictureHandlerBound(control))
+            continue;
+        result.bound++;
+        const outcome = applyPictureHandlerTo(control, parts);
+        if (outcome.done)
+            result.updated++;
+        else
+            result.skipped++;
+        if (outcome.note)
+            ((_a = result.notes) !== null && _a !== void 0 ? _a : (result.notes = [])).push(outcome.note);
+    }
+}
+/**
+ * The reverse direction for a mapped picture control (docx4j's `UpdateXmlFromDocumentSurface`
+ * skips pictures; Word 15 writes the picture back, check 38): the bytes of the image part the
+ * first `a:blip` embeds, as base64, into the node. Nothing is written when the node already holds
+ * those bytes (compared decoded, so Word's line-wrapped base64 counts as the same), when the
+ * control shows no picture, or when the blip's part is not an image part. Asynchronous, since a
+ * part's bytes may still be in the container.
+ */
+export async function updateFromPictureControl(control) {
+    var _a;
+    const mapping = control.xmlMapping;
+    if (!mapping.isMapped || control.type !== 'Picture')
+        return false;
+    const node = mapping.customXmlNode;
+    if (!node)
+        return false;
+    const blip = firstBlipOf(control);
+    const source = control.parentBody.part;
+    if (!(blip === null || blip === void 0 ? void 0 : blip.embed) || !source)
+        return false;
+    const part = (_a = source.relationshipsPart) === null || _a === void 0 ? void 0 : _a.getPart(blip.embed);
+    if (!(part instanceof ImagePart))
+        return false;
+    const bytes = await part.getBytes();
+    const held = base64Decode(node.text);
+    if (held.length === bytes.length && held.every((b, i) => b === bytes[i]))
+        return false;
+    node.text = base64Encode(bytes);
+    return true;
+}
+/** `updateFromContentControls`' picture pass: the mapped picture controls, counted into the result. */
+export async function updateFromPictureControls(controls, result) {
+    for (const control of controls) {
+        if (control.type !== 'Picture' || !control.xmlMapping.isMapped)
+            continue;
+        result.bound++;
+        if (await updateFromPictureControl(control))
+            result.updated++;
+        else
+            result.skipped++;
+    }
+}

package/dist/model/customxml/xhtml.d.mts

@@ -0,0 +1,42 @@
+import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
+import type { PropertyResolver } from '../properties/index.mjs';
+import type { ContentControl } from '../content/ContentControl.mjs';
+import type { CustomXmlPartLookup } from './XmlMapping.mjs';
+import type { BindingResult } from './bindings.mjs';
+/** What the XHTML pass needs of the package. */
+export interface XhtmlHost {
+    numbering: {
+        newList(options?: {
+            bullet?: boolean;
+        }): Promise<string>;
+        restart(numId: string): string;
+    };
+    styles: {
+        ensure(ids: readonly string[]): Promise<string[]>;
+    };
+    requireStyles(ids: Iterable<string>): void;
+    getPropertyResolver(): Promise<PropertyResolver>;
+    getMainDocumentPart(): {
+        styleDefinitionsPart?: {
+            readContents(): Promise<wml.Styles>;
+        } | undefined;
+    };
+}
+export interface XhtmlBindingOptions {
+    /** The HTML parser: a browser's `DOMParser` by default; jsdom's or linkedom's in Node. */
+    parser?: (html: string) => Document;
+}
+/** Whether a control is bound to XHTML through its tag. */
+export declare function isXhtmlBound(control: ContentControl): boolean;
+/**
+ * Binds one XHTML control. Returns what was done, or a note saying why not: no entry, no part, no
+ * node, no parser in this runtime. The content the markup gave that the control cannot hold is in
+ * `dropped` (a run-level control's blocks after the first, and what the converter dropped).
+ */
+export declare function applyXhtmlBindingTo(control: ContentControl, parts: CustomXmlPartLookup, host: XhtmlHost, options?: XhtmlBindingOptions): Promise<{
+    done: boolean;
+    note?: string;
+    dropped?: Record<string, number>;
+}>;
+/** The XHTML pass over the controls, after the text bindings: counted into the result, what was left said in its notes. */
+export declare function applyXhtmlBindingsTo(controls: ContentControl[], parts: CustomXmlPartLookup, host: XhtmlHost, result: BindingResult, options?: XhtmlBindingOptions): Promise<void>;

package/dist/model/customxml/xhtml.mjs

@@ -0,0 +1,162 @@
+import { deepCopy } from '@docx4j/generated-objects-ts';
+import { Namespaces } from '../../parts/Namespaces.mjs';
+import { typeNameOf, linkParents, childrenOf } from '../content/tree.mjs';
+import { contentOf } from '../content/ooxml.mjs';
+import { convertHtml, styleLookupOf } from '../../html/convert.mjs';
+import { blocksToXml, needsOf, HYPERLINK_STYLE } from '../../html/elements.mjs';
+import { tagParamsOf, xpathsEntriesOf, XHTML_CONTENT_TYPE } from './opendope.mjs';
+/** Whether a control is bound to XHTML through its tag. */
+export function isXhtmlBound(control) {
+    const params = tagParamsOf(control.tag);
+    return params.get('od:ContentType') === XHTML_CONTENT_TYPE && params.has('od:xpath');
+}
+async function lookupFor(host) {
+    var _a, _b, _c;
+    const entries = [];
+    const part = host.getMainDocumentPart().styleDefinitionsPart;
+    if (part) {
+        const styles = await part.readContents();
+        for (const s of (_a = styles.style) !== null && _a !== void 0 ? _a : []) {
+            if (!s.styleId)
+                continue;
+            if (s.type !== undefined && s.type !== 'paragraph' && s.type !== 'character')
+                continue;
+            if (s.hidden !== undefined && s.hidden.val !== false)
+                continue;
+            entries.push({ id: s.styleId, name: (_c = (_b = s.name) === null || _b === void 0 ? void 0 : _b.val) !== null && _c !== void 0 ? _c : s.styleId });
+        }
+    }
+    const resolver = await host.getPropertyResolver();
+    return styleLookupOf(entries, resolver.getStyle('TableGrid') ? ['TableGrid'] : []);
+}
+/** The object behind an element: a parsed fragment's elements are wrapped (`{ name, value }`), the tree's own may not be. */
+function innerOf(element) {
+    const e = element;
+    return e.name !== undefined && e.value !== undefined && typeof e.value === 'object' ? e.value : element;
+}
+/** The control's run properties onto every run the markup left without any (a hyperlink's runs included). */
+function applyRunProperties(elements, rPr) {
+    if (!rPr)
+        return;
+    const visit = (items) => {
+        if (!items)
+            return;
+        for (const item of items) {
+            const name = typeNameOf(item);
+            const inner = innerOf(item);
+            if (name === 'org_docx4j_wml.R') {
+                const run = inner;
+                if (!run.rPr)
+                    run.rPr = deepCopy(rPr);
+            }
+            else if (name !== undefined) {
+                visit(childrenOf(inner));
+            }
+        }
+    };
+    visit(elements);
+}
+function inlineContentOf(paragraph) {
+    var _a;
+    const content = (_a = childrenOf(innerOf(paragraph))) !== null && _a !== void 0 ? _a : [];
+    return content.filter((item) => { const n = typeNameOf(item); return n === 'org_docx4j_wml.R' || n === 'org_docx4j_wml.P.Hyperlink'; });
+}
+/**
+ * Binds one XHTML control. Returns what was done, or a note saying why not: no entry, no part, no
+ * node, no parser in this runtime. The content the markup gave that the control cannot hold is in
+ * `dropped` (a run-level control's blocks after the first, and what the converter dropped).
+ */
+export async function applyXhtmlBindingTo(control, parts, host, options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _j;
+    const params = tagParamsOf(control.tag);
+    const entryId = params.get('od:xpath');
+    const entry = xpathsEntriesOf(parts).get(entryId);
+    if (!entry)
+        return { done: false, note: `od:xpath=${entryId}: no such entry in the XPaths part` };
+    const part = (_a = parts.getItem(entry.storeItemID)) !== null && _a !== void 0 ? _a : parts.items.find((p) => p.id.replace(/[{}]/g, '').toLowerCase() === entry.storeItemID.replace(/[{}]/g, '').toLowerCase());
+    if (!part)
+        return { done: false, note: `od:xpath=${entryId}: no custom XML part ${entry.storeItemID}` };
+    const node = part.selectSingleNode(entry.xpath, entry.prefixMappings);
+    if (!node)
+        return { done: false, note: `od:xpath=${entryId}: ${entry.xpath} selects nothing` };
+    const parser = (_b = options.parser) !== null && _b !== void 0 ? _b : (typeof DOMParser === 'function' ? (h) => new DOMParser().parseFromString(h, 'text/html') : undefined);
+    if (!parser)
+        return { done: false, note: `od:xpath=${entryId}: XHTML needs an HTML parser (applyBindings({ html: { parser } }))` };
+    const converted = convertHtml(node.text, await lookupFor(host), { parser });
+    const dropped = { ...converted.report.dropped };
+    const { blocks } = converted;
+    // What the document must give first: the styles the markup names, a definition per list, a relationship per link.
+    if (converted.report.stylesWanted.length > 0) {
+        try {
+            await host.styles.ensure(converted.report.stylesWanted);
+        }
+        catch {
+            dropped['styles the defaults lack'] = ((_c = dropped['styles the defaults lack']) !== null && _c !== void 0 ? _c : 0) + converted.report.stylesWanted.length;
+        }
+    }
+    const needs = needsOf(blocks);
+    const lists = new Map();
+    let firstNumbered;
+    for (const { key, bullet } of needs.lists) {
+        if (bullet)
+            lists.set(key, await host.numbering.newList({ bullet: true }));
+        else if (firstNumbered === undefined) {
+            firstNumbered = await host.numbering.newList({ bullet: false });
+            lists.set(key, firstNumbered);
+        }
+        else
+            lists.set(key, host.numbering.restart(firstNumbered));
+    }
+    const links = new Map();
+    const rels = needs.links.length > 0 ? (_d = control.parentBody.part) === null || _d === void 0 ? void 0 : _d.getRelationshipsPart(true) : undefined;
+    if (rels) {
+        for (const address of needs.links)
+            links.set(address, rels.addExternalRelationship(Namespaces.HYPERLINK, address).id);
+        host.requireStyles([HYPERLINK_STYLE]);
+    }
+    else if (needs.links.length > 0)
+        dropped['links'] = ((_e = dropped['links']) !== null && _e !== void 0 ? _e : 0) + needs.links.length;
+    const elements = await contentOf(blocksToXml(blocks, { numId: (key) => lists.get(key), relId: (address) => links.get(address) }));
+    applyRunProperties(elements, control.runProperties);
+    const sdt = control.sdt;
+    (_f = sdt.sdtContent) !== null && _f !== void 0 ? _f : (sdt.sdtContent = {});
+    const content = ((_g = (_j = sdt.sdtContent).content) !== null && _g !== void 0 ? _g : (_j.content = []));
+    if (control.form === 'Run') {
+        // A run-level control holds inline content: the first paragraph's, the rest reported.
+        const first = elements.find((e) => typeNameOf(e) === 'org_docx4j_wml.P');
+        const inlines = first ? inlineContentOf(first) : [];
+        const rest = elements.length - (first ? 1 : 0);
+        if (rest > 0)
+            dropped['blocks after the first, in a run-level control'] = ((_h = dropped['blocks after the first, in a run-level control']) !== null && _h !== void 0 ? _h : 0) + rest;
+        content.length = 0;
+        content.push(...inlines);
+        linkParents(content, sdt.sdtContent);
+    }
+    else {
+        content.length = 0;
+        content.push(...elements);
+        linkParents(content, sdt.sdtContent);
+    }
+    control.isShowingPlaceholder = false;
+    return Object.keys(dropped).length > 0 ? { done: true, dropped } : { done: true };
+}
+/** The XHTML pass over the controls, after the text bindings: counted into the result, what was left said in its notes. */
+export async function applyXhtmlBindingsTo(controls, parts, host, result, options = {}) {
+    var _a, _b;
+    for (const control of controls) {
+        if (!isXhtmlBound(control))
+            continue;
+        result.bound++;
+        const outcome = await applyXhtmlBindingTo(control, parts, host, options);
+        if (outcome.done)
+            result.updated++;
+        else
+            result.skipped++;
+        if (outcome.note)
+            ((_a = result.notes) !== null && _a !== void 0 ? _a : (result.notes = [])).push(outcome.note);
+        if (outcome.dropped)
+            for (const [kind, n] of Object.entries(outcome.dropped))
+                ((_b = result.notes) !== null && _b !== void 0 ? _b : (result.notes = [])).push(`${control.tag}: dropped ${kind} (${n})`);
+    }
+}

package/dist/model/fonts/RunFontSelector.d.mts

@@ -1,5 +1,6 @@
 import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
 import type { PropertyResolver } from '../properties/PropertyResolver.mjs';
+import type { CellContext } from '../properties/table.mjs';
 import { type ThemeFontLang, type ThemeSource } from './ThemeFonts.mjs';
 import { type DefaultTheme } from './defaultTheme.mjs';
 /** Word's built-in default where the document defaults name no font at all (docx4j CR-016
@@ -41,6 +42,11 @@ export interface RunFontSelectorSource {
 export interface SpansOptions {
     /** True where the caller has resolved the run's effective properties already. */
     rPrIsEffective?: boolean;
+    /**
+     * The paragraph's table context (`PropertyResolver.cellContextOf(p)`, or a tracker's), so a run
+     * in a table cell is resolved with its table style's formatting (CR-007; docx4j CR-030 phase 5).
+     */
+    cellContext?: CellContext | undefined;
 }
 /** `w:cs` and `w:rtl` are `ST_OnOff`: present without `w:val` means true, `w:val="0"` false. */
 export declare function isOn(value: wml.BooleanDefaultTrue | undefined): boolean;
@@ -149,8 +155,9 @@ export declare class RunFontSelector {
      * at least.
      *
      * @param rPrIsEffective true where the caller has resolved the run's properties already
+     * @param cellContext the paragraph's table context, where it is in a table cell (CR-007)
      */
-    documentFontFor(pPr: wml.PPr | undefined, rPr: wml.RPr | undefined, codePoint: number, rPrIsEffective?: boolean): string;
+    documentFontFor(pPr: wml.PPr | undefined, rPr: wml.RPr | undefined, codePoint: number, rPrIsEffective?: boolean, cellContext?: CellContext | undefined): string;
     /**
      * The run's text folded into maximal stretches of one document font.
      *

package/dist/model/fonts/RunFontSelector.mjs

@@ -173,10 +173,10 @@ export class RunFontSelector {
         return this.defaultFont;
     }
     /** The run's effective properties, never undefined. */
-    effectiveRPr(pPr, rPr, rPrIsEffective) {
+    effectiveRPr(pPr, rPr, rPrIsEffective, cellContext) {
         var _a;
         if (!rPrIsEffective && this.source.resolver !== undefined) {
-            return (_a = this.source.resolver.getEffectiveRPr(rPr, pPr)) !== null && _a !== void 0 ? _a : {};
+            return (_a = this.source.resolver.getEffectiveRPr(rPr, pPr, cellContext)) !== null && _a !== void 0 ? _a : {};
         }
         return rPr !== null && rPr !== void 0 ? rPr : {};
     }
@@ -259,10 +259,11 @@ export class RunFontSelector {
      * at least.
      *
      * @param rPrIsEffective true where the caller has resolved the run's properties already
+     * @param cellContext the paragraph's table context, where it is in a table cell (CR-007)
      */
-    documentFontFor(pPr, rPr, codePoint, rPrIsEffective = false) {
+    documentFontFor(pPr, rPr, codePoint, rPrIsEffective = false, cellContext) {
         var _a;
-        const effective = this.effectiveRPr(pPr, rPr, rPrIsEffective);
+        const effective = this.effectiveRPr(pPr, rPr, rPrIsEffective, cellContext);
         return (_a = this.fontOf(this.slotsOf(pPr, effective), codePoint)) !== null && _a !== void 0 ? _a : this.defaultFont;
     }
     /**
@@ -280,7 +281,7 @@ export class RunFontSelector {
         const spans = [];
         if (text === undefined || text === null || text.length === 0)
             return spans;
-        const effective = this.effectiveRPr(pPr, rPr, options.rPrIsEffective === true);
+        const effective = this.effectiveRPr(pPr, rPr, options.rPrIsEffective === true, options.cellContext);
         const bold = isOn(effective.b);
         const italic = isOn(effective.i);
         const cs = isOn(effective.cs);

package/dist/model/properties/PropertyResolver.d.mts

@@ -1,11 +1,17 @@
 import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
 import { NumberingDefinitions } from '../listnumbering/definitions.mjs';
+import { CellContext, TableContext } from './table.mjs';
 /** The parts the resolver reads. Structural, so this module imports no part class. */
 export interface ResolverSource {
     /** The styles part's `w:styles`, or undefined when the package has none. */
     styles?: wml.Styles;
     /** The numbering part's `w:numbering`, or undefined. */
     numbering?: wml.Numbering;
+    /**
+     * The settings part's `w:settings`, or undefined: read for the compatibility mode and
+     * `overrideTableStyleFontSizeAndJustification` (CR-007). A document with none is in mode 12.
+     */
+    settings?: wml.CTSettings;
 }
 /** As much of an `XmlPart<T>` as the resolver uses. */
 interface ReadablePart<T> {
@@ -18,6 +24,7 @@ interface PackageLike {
     getMainDocumentPart(): {
         styleDefinitionsPart?: ReadablePart<wml.Styles>;
         numberingDefinitionsPart?: ReadablePart<wml.Numbering>;
+        documentSettingsPart?: ReadablePart<wml.CTSettings>;
     };
 }
 /** 108 twips (0.08in): the left and right cell margin of Word's built-in Normal Table. */
@@ -44,6 +51,17 @@ export declare class PropertyResolver {
     /** The document defaults with the chain applied over them: what the style overloads return. */
     private readonly effectivePPrByStyle;
     private readonly effectiveRPrByStyle;
+    /** Each table style's `w:basedOn` chain merged, by id; styles only, so `refresh()` clears it. */
+    private readonly tableStyleChains;
+    /**
+     * A paragraph style composed over a table level, document defaults included; by (paragraph
+     * style, table level). What the overloads with a context start from, as
+     * `getEffectivePPr(styleId)` is what they start from without one.
+     */
+    private readonly composedPPrCache;
+    private readonly composedRPrCache;
+    /** See {@link appliesTableStyleSizeJcException}; read once per `refresh()`. */
+    private tableStyleSizeJcException;
     /** Missing styles are logged once each per resolver. */
     private readonly missingLogged;
     private numberingDefinitions;
@@ -142,6 +160,15 @@ export declare class PropertyResolver {
      * naming no style resolves as the default paragraph style does.
      */
     getEffectivePPr(styleId: string | undefined): wml.PPr;
+    /**
+     * The paragraph properties which apply to a paragraph in a table cell: as
+     * `getEffectivePPr(pPr)`, with the table style's contribution (its own `w:pPr`, then the
+     * conditional formats the paragraph is under) between the document defaults and the
+     * paragraph's style, and [MS-DOCX]'s justification exception where it applies. An undefined
+     * context - a paragraph in no table - resolves exactly as `getEffectivePPr(pPr)`. A live
+     * object where the paragraph has no direct formatting: copy it before changing it.
+     */
+    getEffectivePPr(pPr: wml.PPr | undefined, cellContext: CellContext | undefined): wml.PPr;
     private effectivePPrOfStyle;
     /**
      * The run properties which apply to a run, given its own `w:rPr` and the `w:pPr` of the
@@ -158,6 +185,14 @@ export declare class PropertyResolver {
      * what it contributes with nothing under it. Undefined when no such style exists.
      */
     getEffectiveRPr(styleId: string): wml.RPr | undefined;
+    /**
+     * The run properties which apply to a run in a table cell: as `getEffectiveRPr(rPr, pPr)`,
+     * with the table style's run properties (its own, then its conditional formats') as a level
+     * of the style hierarchy beneath the paragraph style's - the toggle properties combine across
+     * the two (ECMA-376-1 17.7.3) - and [MS-DOCX]'s size exception where it applies. An undefined
+     * context resolves exactly as `getEffectiveRPr(rPr, pPr)`. A new object each call.
+     */
+    getEffectiveRPr(rPr: wml.RPr | undefined, pPr: wml.PPr | undefined, cellContext: CellContext | undefined): wml.RPr;
     private effectiveRPrOfStyle;
     /**
      * The character style's chain, then the direct formatting.
@@ -173,29 +208,94 @@ export declare class PropertyResolver {
      * properties, then the `w:pPr`'s own `w:rPr`. What sizes an empty paragraph, and what a list
      * label starts from.
      */
-    getEffectiveParagraphMarkRPr(pPr: wml.PPr | undefined): wml.RPr;
+    getEffectiveParagraphMarkRPr(pPr: wml.PPr | undefined, cellContext?: CellContext | undefined): wml.RPr;
     /** Whether the run states any formatting of its own (docx4j's deprecated `hasDirectRPrFormatting`). */
     hasDirectRPrFormatting(rPr: wml.RPr | undefined): boolean;
     /**
      * The table style which applies, merged root-first down its `w:basedOn` chain, then the
      * table's own `w:tblPr` over it.
      *
-     * Word's built-in "Normal Table" (`w:tblInd` 0; cell margins 108 twips left and right, 0 top
-     * and bottom) underlies a table naming no style and a table whose chain reaches the
-     * document's default table style - and it is the built-in that applies, not the document's
-     * definition of that style (measured, CR-015 probe styles-table-default). So the default
-     * style's own layer is skipped in favour of the built-in, and a chain that does not reach it
-     * starts from nothing.
+     * Word goes by the style's **name** (measured, docx4j CR-030 probes T1, T2 and T7). A style
+     * named "Normal Table" is Word's built-in Normal Table (`w:tblInd` 0; cell margins 108 twips
+     * left and right, 0 top and bottom), whatever its own definition says and whether or not it is
+     * the document's default: the built-in stands in for it, and the walk up the chain ends there.
+     * Every other style applies as written, with nothing beneath it: a chain which reaches no style
+     * so named starts from nothing, and the document's default table style, where it is named
+     * otherwise, applies as written to a table naming no style. The built-in also stands in for a
+     * style which is missing, and where the document has no default table style. (Until CR-007 the
+     * built-in was decided by the default table style's *id*, as docx4j did until 17.3.1.)
      *
      * A new `Style` each call, with a non-null `w:tblPr`.
      */
     getEffectiveTableStyle(tblPr: wml.CTTblPrBase | undefined): wml.Style;
     /**
-     * Whether a table's style chain reaches the document's default table style - the flag
-     * {@link getEffectiveTableStyle} decides Word's built-in Normal Table by (a table naming no
-     * style counts as reaching it).
+     * Whether Word's built-in Normal Table underlies a table - the flag
+     * {@link getEffectiveTableStyle} decides by: the table's style chain (its own `w:tblStyle`,
+     * else the default table style) reaches a style *named* "Normal Table", or the style is
+     * missing, or there is none. Decided by name since CR-007; the method keeps docx4j's name
+     * from when it was decided by the default style's id.
      */
     reachesDefaultTableStyle(tblPr: wml.CTTblPrBase | undefined): boolean;
+    private builtInTableNormalUnderlies;
+    /**
+     * Whether [MS-DOCX]'s `overrideTableStyleFontSizeAndJustification` exception applies to this
+     * document: a default paragraph style's 12pt does not override the table style's size, nor its
+     * left justification the table style's, for paragraphs in tables. Measured with Word 365
+     * (docx4j CR-030 probes T5 and T6): it applies below compatibility mode 15 (a document stating
+     * no `compatibilityMode` is mode 12) where the setting is not on, and never in mode 15.
+     */
+    appliesTableStyleSizeJcException(): boolean;
+    /**
+     * The id of the table style a table resolves to: its own `w:tblStyle`, else the document's
+     * `w:default` table style, whatever its name; undefined where the table names none and the
+     * document has no default. (Whether that style contributes anything is
+     * {@link getTableStyleChain}'s question.)
+     */
+    getTableStyleIdOf(tblPr: wml.CTTblPrBase | undefined): string | undefined;
+    /**
+     * A table style's `w:basedOn` chain merged root-first, conditional formats merged per
+     * condition, as it gives the paragraphs of its tables their text formatting. Word goes by the
+     * style's *name*: a style named "Normal Table" is Word's built-in, which gives text nothing
+     * whatever its own definition says, so the walk up the chain ends below it; every other style
+     * applies as written, the default table style included.
+     *
+     * Cached per id, and shared: read it, do not change it. An empty style for undefined, for a
+     * missing style, and for a chain which is "Normal Table" all the way down.
+     */
+    getTableStyleChain(styleId: string | undefined): wml.Style;
+    /**
+     * The context of a table, for the paragraphs in it: build one per table and hold it while
+     * walking the table (the resolver keeps none, since it reads the table's content).
+     */
+    tableContext(tbl: wml.Tbl): TableContext;
+    /**
+     * The table context of one paragraph, found through its `PARENT` pointers: the nearest
+     * enclosing cell, its row and its table, through whatever lies between (`w:sdt`,
+     * `w:customXml`, `w:smartTag`). Undefined where the paragraph is in no table, where a story
+     * begins before a cell is reached (a text box, a footnote, endnote or comment, a header, a
+     * footer, the body), or where the pointers are not there (unmarshalled content, and content
+     * the content API inserted, has them: `linkParents`).
+     *
+     * Each call builds a {@link TableContext}, a walk of the table's rows. That is right for "what
+     * formatting does this paragraph have"; code resolving every paragraph of a document walks it
+     * with a `TableContextTracker` instead, since calling this for each paragraph of a large table
+     * is quadratic.
+     */
+    cellContextOf(p: wml.P): CellContext | undefined;
+    private clearTableCaches;
+    /** The table level's `w:pPr`: the style's own, then its conditional formats'; undefined if none. */
+    private tableLevelPPr;
+    /** The table level's `w:rPr`: the style's own, then its conditional formats'; undefined if none. */
+    private tableLevelRPr;
+    private composedPPr;
+    private composedRPr;
+    /**
+     * [MS-DOCX]'s exception, for a paragraph in a table whose style states a size (or a
+     * justification): the paragraph's style gives way to it if the style is the default paragraph
+     * style, or states no size (justification) of its own, and resolves to 12pt (left). A style of
+     * the paragraph's own which states one keeps it.
+     */
+    private paragraphStyleGivesWay;
     /** Word's built-in Normal Table, as a style: what it applies whatever the document's own definition says. */
     private builtInTableNormal;
     /**