@docx4j/core-ts 0.1.0 → 0.1.1

package/dist/model/properties/PropertyResolver.mjs

@@ -0,0 +1,524 @@
+import { deepCopy } from '@docx4j/generated-objects-ts';
+import { Docx4JException } from '../../opc/exceptions.mjs';
+import { log } from './log.mjs';
+import { NumberingDefinitions } from '../listnumbering/definitions.mjs';
+import { applyPPrBase, applyRPr, applyStyle, applyStyleLevel, applyTblPr, hasDirectFormattingPPr, hasDirectFormattingRPr, isCyclic, } from './styleUtil.mjs';
+/** The cache key for "no style" (a styles part with no default paragraph style). */
+const NO_STYLE = '';
+/** 108 twips (0.08in): the left and right cell margin of Word's built-in Normal Table. */
+export const WORD_DEFAULT_CELL_MARGIN_TWIPS = 108;
+const HEADING_NAME = /^heading ([1-9])$/i;
+const HEADING_STYLE = 'Heading';
+/**
+ * The outline level (1-9) of a built-in heading style, from its `w:name` ("heading 1" ...
+ * "heading 9"), or -1. Word identifies built-in styles by name, so this holds in every locale;
+ * {@link PropertyResolver.getLvlFromHeadingStyle} keys on the English style id.
+ */
+export function headingLevelByName(style) {
+    var _a;
+    const name = (_a = style === null || style === void 0 ? void 0 : style.name) === null || _a === void 0 ? void 0 : _a.val;
+    if (name === undefined)
+        return -1;
+    const match = HEADING_NAME.exec(name.trim());
+    return match ? Number(match[1]) : -1;
+}
+export class PropertyResolver {
+    constructor(provider, 
+    /** Set when the styles tree the resolver holds is not the styles part's own. */
+    stylesArePrivate = () => false) {
+        this.provider = provider;
+        this.stylesArePrivate = stylesArePrivate;
+        this.documentDefaultPPr = { TYPE_NAME: 'org_docx4j_wml.PPr' };
+        this.documentDefaultRPr = { TYPE_NAME: 'org_docx4j_wml.RPr' };
+        /** All styles in the styles part, keyed by style id (docx4j's `liveStyles`). */
+        this.liveStyles = new Map();
+        /** How many styles the part held when `liveStyles` was last scanned; a miss rescans only when that has changed. */
+        this.scannedStyleCount = -1;
+        /** A style's `w:basedOn` chain merged root-first, WITHOUT the document defaults, per style id. */
+        this.chainPPrCache = new Map();
+        this.chainRPrCache = new Map();
+        /** The document defaults with the chain applied over them: what the style overloads return. */
+        this.effectivePPrByStyle = new Map();
+        this.effectiveRPrByStyle = new Map();
+        /** Missing styles are logged once each per resolver. */
+        this.missingLogged = new Set();
+        this.source = provider();
+        this.init();
+    }
+    /**
+     * Builds a resolver over a package's styles and numbering parts (docx4j's constructor,
+     * which can do this synchronously because JAXB is).
+     *
+     * The parts are read with `readContents()`, which does **not** mark them unmarshalled, so a
+     * document whose styles nobody has edited still saves byte for byte. Once something else
+     * unmarshals the part - the comment styles, a caller's `getContents()` - `refresh()` picks
+     * up that live tree instead of the private copy.
+     */
+    static async create(pkg) {
+        if (typeof pkg.getMainDocumentPart !== 'function') {
+            const source = pkg;
+            return new PropertyResolver(() => source);
+        }
+        let main;
+        try {
+            main = pkg.getMainDocumentPart();
+        }
+        catch (e) {
+            throw new Docx4JException('A PropertyResolver needs a main document part', { cause: e });
+        }
+        const stylesPart = main.styleDefinitionsPart;
+        const numberingPart = main.numberingDefinitionsPart;
+        const privateStyles = stylesPart === undefined ? undefined : await stylesPart.readContents();
+        const privateNumbering = numberingPart === undefined ? undefined : await numberingPart.readContents();
+        return new PropertyResolver(() => ({
+            styles: (stylesPart === null || stylesPart === void 0 ? void 0 : stylesPart.isUnmarshalled) === true ? stylesPart.contents : privateStyles,
+            numbering: (numberingPart === null || numberingPart === void 0 ? void 0 : numberingPart.isUnmarshalled) === true ? numberingPart.contents : privateNumbering,
+        }), () => stylesPart !== undefined && !stylesPart.isUnmarshalled);
+    }
+    /** Builds a resolver over object trees directly (a test, or parts already in hand). */
+    static fromSource(source) {
+        return new PropertyResolver(() => source);
+    }
+    // ------------------------------------------------------------------ init
+    init() {
+        var _a, _b, _c, _d, _e, _f;
+        const styles = this.source.styles;
+        this.liveStyles.clear();
+        this.scannedStyleCount = -1;
+        this.defaultParagraphStyleId = undefined;
+        this.defaultCharacterStyleId = undefined;
+        this.defaultTableStyleId = undefined;
+        if (styles !== undefined) {
+            this.scanStyles();
+            for (const style of (_a = styles.style) !== null && _a !== void 0 ? _a : []) {
+                if (style._default !== true || style.styleId === undefined)
+                    continue;
+                if (style.type === 'paragraph')
+                    (_b = this.defaultParagraphStyleId) !== null && _b !== void 0 ? _b : (this.defaultParagraphStyleId = style.styleId);
+                else if (style.type === 'character')
+                    (_c = this.defaultCharacterStyleId) !== null && _c !== void 0 ? _c : (this.defaultCharacterStyleId = style.styleId);
+                else if (style.type === 'table')
+                    (_d = this.defaultTableStyleId) !== null && _d !== void 0 ? _d : (this.defaultTableStyleId = style.styleId);
+            }
+        }
+        if (this.defaultParagraphStyleId === undefined)
+            log.warn('No default paragraph style!!');
+        // private copies: the resolver's defaults are its own, so nothing below writes into the
+        // styles part (until CR-015 phase 3 the w:sz 20 default went into the part, and a docx
+        // saved after an export carried it)
+        const docDefaults = styles === null || styles === void 0 ? void 0 : styles.docDefaults;
+        this.documentDefaultPPr = ((_e = docDefaults === null || docDefaults === void 0 ? void 0 : docDefaults.pPrDefault) === null || _e === void 0 ? void 0 : _e.pPr) === undefined
+            ? { TYPE_NAME: 'org_docx4j_wml.PPr' } : deepCopy(docDefaults.pPrDefault.pPr);
+        this.documentDefaultRPr = ((_f = docDefaults === null || docDefaults === void 0 ? void 0 : docDefaults.rPrDefault) === null || _f === void 0 ? void 0 : _f.rPr) === undefined
+            ? { TYPE_NAME: 'org_docx4j_wml.RPr' } : deepCopy(docDefaults.rPrDefault.rPr);
+        if (this.documentDefaultRPr.sz === undefined) {
+            // Word's default made explicit: 10pt where nothing states a size (measured, CR-015 probe
+            // styles-no-size-anywhere: identical to an explicit 10pt run)
+            this.documentDefaultRPr.sz = { TYPE_NAME: 'org_docx4j_wml.HpsMeasure', val: 20 };
+        }
+        this.numberingDefinitions = this.source.numbering === undefined
+            ? undefined
+            : new NumberingDefinitions(this.source.numbering, (styleId) => this.getLiveStyle(styleId));
+    }
+    /** (Re)read the styles part into `liveStyles`. A style with no id is skipped. */
+    scanStyles() {
+        var _a, _b;
+        const list = (_b = (_a = this.source.styles) === null || _a === void 0 ? void 0 : _a.style) !== null && _b !== void 0 ? _b : [];
+        for (const style of list) {
+            if (style.styleId === undefined)
+                continue;
+            this.liveStyles.set(style.styleId, style);
+        }
+        this.scannedStyleCount = list.length;
+    }
+    /**
+     * The style with this id, rescanning the styles part on a miss - and only when the list's
+     * size has changed - so that a style *added* to the part after this resolver was built is
+     * still found. A style *modified* or *removed* needs {@link refresh}.
+     */
+    getLiveStyle(styleId) {
+        var _a, _b, _c;
+        if (styleId === undefined)
+            return undefined;
+        let style = this.liveStyles.get(styleId);
+        if (style === undefined && ((_c = (_b = (_a = this.source.styles) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) !== this.scannedStyleCount) {
+            this.scanStyles();
+            style = this.liveStyles.get(styleId);
+        }
+        return style;
+    }
+    logMissing(styleId) {
+        if (this.missingLogged.has(styleId))
+            return;
+        this.missingLogged.add(styleId);
+        log.warn(`Style definition not found: ${styleId} (logged once)`);
+    }
+    /**
+     * Discard cached state and re-read the styles part. A style merely *added* is picked up
+     * automatically; call this when a style has been modified or removed, or the styles part's
+     * contents replaced. The content API calls it where it creates a style.
+     */
+    refresh() {
+        this.chainPPrCache.clear();
+        this.chainRPrCache.clear();
+        this.effectivePPrByStyle.clear();
+        this.effectiveRPrByStyle.clear();
+        this.missingLogged.clear();
+        this.source = this.provider();
+        this.init();
+    }
+    // ------------------------------------------------------------------ defaults
+    getDocumentDefaultPPr() {
+        return this.documentDefaultPPr;
+    }
+    getDocumentDefaultRPr() {
+        return this.documentDefaultRPr;
+    }
+    /** The style id of the `w:default="1"` paragraph style, or undefined when the part declares none. */
+    getDefaultParagraphStyleId() {
+        return this.defaultParagraphStyleId;
+    }
+    /** The default paragraph style's effective `w:pPr`, as `getEffectivePPr(styleId)` gives it. */
+    getResolvedDefaultParagraphStyle() {
+        return this.getEffectivePPr(this.defaultParagraphStyleId);
+    }
+    /** The style with this id, or undefined (docx4j `getStyle`). */
+    getStyle(styleId) {
+        return this.getLiveStyle(styleId);
+    }
+    /**
+     * The list definitions of the numbering part this resolver read (CR-001 Phase B step 3), or
+     * undefined where the package has none. The resolver builds them because the paragraph merge
+     * folds a numbering level's `w:ind` into every layer (`NumberingDefinitionsPart.getInd`);
+     * `NumberingDefinitionsPart.definitions` hands out this same object, so the counting and the
+     * indents read one set of definitions.
+     */
+    getNumberingDefinitions() {
+        return this.numberingDefinitions;
+    }
+    // ------------------------------------------------------------------ the chains
+    /**
+     * The style and the styles it is based on, root first (the base of the chain at index 0, the
+     * style itself last); empty for an unknown id. A cycle, or a chain deeper than 32, ends the
+     * walk where it is detected (and throws `CyclicStylesException` when
+     * `throwOnCyclicStyles(true)` is set).
+     */
+    ancestry(styleId) {
+        var _a;
+        const leafFirst = [];
+        const seen = [];
+        let id = styleId;
+        while (id !== undefined) {
+            if (isCyclic(id, seen))
+                break;
+            seen.push(id);
+            const style = this.getLiveStyle(id);
+            if (style === undefined) {
+                // "DocDefaults" is StyleTree's virtual style for the document defaults, which this
+                // resolver applies itself; anything else is a reference to nothing
+                if (id !== 'DocDefaults')
+                    this.logMissing(id);
+                break;
+            }
+            leafFirst.push(style);
+            id = (_a = style.basedOn) === null || _a === void 0 ? void 0 : _a.val;
+        }
+        return leafFirst.reverse();
+    }
+    /**
+     * A paragraph style's `w:basedOn` chain merged root-first, WITHOUT the document defaults:
+     * what the style contributes on its own. A live, cached object: copy before changing.
+     */
+    getChainPPr(styleId) {
+        if (styleId === undefined)
+            return { TYPE_NAME: 'org_docx4j_wml.PPr' };
+        const cached = this.chainPPrCache.get(styleId);
+        if (cached !== undefined)
+            return cached;
+        const chain = { TYPE_NAME: 'org_docx4j_wml.PPr' };
+        for (const style of this.ancestry(styleId)) {
+            this.applyPPrLayer(this.headingLayer(style), chain);
+        }
+        this.chainPPrCache.set(styleId, chain);
+        return chain;
+    }
+    /**
+     * A style's `w:basedOn` chain merged root-first, WITHOUT the document defaults: for a
+     * character style, what it contributes over the paragraph's run properties. A live, cached
+     * object: copy before changing.
+     */
+    getChainRPr(styleId) {
+        if (styleId === undefined)
+            return { TYPE_NAME: 'org_docx4j_wml.RPr' };
+        const cached = this.chainRPrCache.get(styleId);
+        if (cached !== undefined)
+            return cached;
+        const chain = { TYPE_NAME: 'org_docx4j_wml.RPr' };
+        for (const style of this.ancestry(styleId)) {
+            applyRPr(style.rPr, chain);
+        }
+        this.chainRPrCache.set(styleId, chain);
+        return chain;
+    }
+    /**
+     * A style's own `w:pPr` as a layer of its chain. The built-in heading styles have a fixed
+     * outline level, which Word takes from the style's built-in NAME ("heading 1" ...
+     * "heading 9", the same in every locale; the style id is localised: "Überschrift1",
+     * "Titre1"), whatever `w:outlineLvl` the style declares: where they differ the layer is a
+     * copy with the level from the name, and the styles part is not touched.
+     */
+    headingLayer(style) {
+        const layer = style.pPr;
+        const headingLevel = headingLevelByName(style);
+        if (headingLevel > 0 && layer !== undefined
+            && layer.outlineLvl !== undefined && layer.outlineLvl.val !== undefined
+            && layer.outlineLvl.val !== headingLevel - 1) {
+            const copy = deepCopy(layer);
+            copy.outlineLvl.val = headingLevel - 1;
+            return copy;
+        }
+        return layer;
+    }
+    applyPPrLayer(source, destination) {
+        if (source === undefined)
+            return;
+        applyPPrBase(source, destination, this.numberingDefinitions);
+        destination.rPr = applyRPr(source.rPr, destination.rPr, () => ({ TYPE_NAME: 'org_docx4j_wml.ParaRPr' }));
+    }
+    /** The paragraph's style: its `w:pStyle` where that names a style that exists, else the default paragraph style. */
+    paragraphStyleOf(pPr) {
+        if (pPr === undefined || pPr.pStyle === undefined)
+            return this.defaultParagraphStyleId;
+        const styleId = pPr.pStyle.val;
+        if (styleId === undefined)
+            return this.defaultParagraphStyleId;
+        return this.existingParagraphStyle(styleId);
+    }
+    /** `styleId` if it names a style that exists, else the default paragraph style's id (logged once). */
+    existingParagraphStyle(styleId) {
+        if (styleId === undefined)
+            return this.defaultParagraphStyleId;
+        if (this.getLiveStyle(styleId) === undefined) {
+            this.logMissing(styleId);
+            return this.defaultParagraphStyleId;
+        }
+        return styleId;
+    }
+    getEffectivePPr(arg) {
+        if (arg === undefined || typeof arg === 'string')
+            return this.effectivePPrOfStyle(arg);
+        const resolved = this.effectivePPrOfStyle(this.paragraphStyleOf(arg));
+        if (!hasDirectFormattingPPr(arg))
+            return resolved;
+        const effective = deepCopy(resolved);
+        this.applyPPrLayer(arg, effective);
+        return effective;
+    }
+    effectivePPrOfStyle(styleId) {
+        const existing = this.existingParagraphStyle(styleId);
+        const key = existing !== null && existing !== void 0 ? existing : NO_STYLE;
+        const cached = this.effectivePPrByStyle.get(key);
+        if (cached !== undefined)
+            return cached;
+        const resolved = deepCopy(this.documentDefaultPPr);
+        this.applyPPrLayer(this.getChainPPr(existing), resolved);
+        this.effectivePPrByStyle.set(key, resolved);
+        return resolved;
+    }
+    getEffectiveRPr(arg, pPr) {
+        if (typeof arg === 'string')
+            return this.effectiveRPrOfStyle(arg);
+        const effective = deepCopy(this.documentDefaultRPr);
+        applyRPr(this.getChainRPr(this.paragraphStyleOf(pPr)), effective);
+        this.applyCharacterStyleAndDirect(arg, effective);
+        return effective;
+    }
+    effectiveRPrOfStyle(styleId) {
+        const cached = this.effectiveRPrByStyle.get(styleId);
+        if (cached !== undefined)
+            return cached;
+        if (this.getLiveStyle(styleId) === undefined) {
+            this.logMissing(styleId);
+            return undefined;
+        }
+        const resolved = deepCopy(this.documentDefaultRPr);
+        applyRPr(this.getChainRPr(styleId), resolved);
+        this.effectiveRPrByStyle.set(styleId, resolved);
+        return resolved;
+    }
+    /**
+     * The character style's chain, then the direct formatting.
+     *
+     * The character style is a **level** of the style hierarchy over the paragraph's, so its
+     * toggle properties are XORed with what is beneath rather than overriding it (ECMA-376-1
+     * §17.7.3). The direct formatting after it is not a level: an explicit value there is used
+     * as it stands.
+     */
+    applyCharacterStyleAndDirect(rPr, effective) {
+        var _a;
+        const runStyleId = (_a = rPr === null || rPr === void 0 ? void 0 : rPr.rStyle) === null || _a === void 0 ? void 0 : _a.val;
+        if (runStyleId !== undefined) {
+            if (this.getLiveStyle(runStyleId) === undefined) {
+                this.logMissing(runStyleId);
+            }
+            else {
+                applyStyleLevel(this.getChainRPr(runStyleId), effective, this.documentDefaultRPr);
+            }
+        }
+        if (hasDirectFormattingRPr(rPr))
+            applyRPr(rPr, effective);
+    }
+    /**
+     * The run properties of the paragraph mark: document defaults, the paragraph style's run
+     * properties, then the `w:pPr`'s own `w:rPr`. What sizes an empty paragraph, and what a list
+     * label starts from.
+     */
+    getEffectiveParagraphMarkRPr(pPr) {
+        const effective = deepCopy(this.documentDefaultRPr);
+        applyRPr(this.getChainRPr(this.paragraphStyleOf(pPr)), effective);
+        if ((pPr === null || pPr === void 0 ? void 0 : pPr.rPr) !== undefined)
+            applyRPr(pPr.rPr, effective);
+        return effective;
+    }
+    /** Whether the run states any formatting of its own (docx4j's deprecated `hasDirectRPrFormatting`). */
+    hasDirectRPrFormatting(rPr) {
+        return hasDirectFormattingRPr(rPr);
+    }
+    // ------------------------------------------------------------------ tables
+    /**
+     * 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.
+     *
+     * A new `Style` each call, with a non-null `w:tblPr`.
+     */
+    getEffectiveTableStyle(tblPr) {
+        var _a, _b;
+        const styleId = (_a = tblPr === null || tblPr === void 0 ? void 0 : tblPr.tblStyle) === null || _a === void 0 ? void 0 : _a.val;
+        const chain = styleId === undefined ? [] : this.ancestry(styleId);
+        const builtIn = chain.length === 0
+            || (this.defaultTableStyleId !== undefined && chain.some((s) => s.styleId === this.defaultTableStyleId));
+        const result = builtIn ? this.builtInTableNormal() : emptyTableStyle();
+        for (const layer of chain) {
+            // the built-in stands in for the document's definition of the default table style
+            if (this.defaultTableStyleId !== undefined && layer.styleId === this.defaultTableStyleId)
+                continue;
+            applyStyle(layer, result);
+        }
+        if (tblPr !== undefined) {
+            result.tblPr = applyTblPr(tblPr, result.tblPr);
+        }
+        (_b = result.tblPr) !== null && _b !== void 0 ? _b : (result.tblPr = { TYPE_NAME: 'org_docx4j_wml.CTTblPrBase' });
+        return result;
+    }
+    /**
+     * 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).
+     */
+    reachesDefaultTableStyle(tblPr) {
+        var _a;
+        const styleId = (_a = tblPr === null || tblPr === void 0 ? void 0 : tblPr.tblStyle) === null || _a === void 0 ? void 0 : _a.val;
+        const chain = styleId === undefined ? [] : this.ancestry(styleId);
+        return chain.length === 0
+            || (this.defaultTableStyleId !== undefined && chain.some((s) => s.styleId === this.defaultTableStyleId));
+    }
+    /** Word's built-in Normal Table, as a style: what it applies whatever the document's own definition says. */
+    builtInTableNormal() {
+        var _a;
+        const style = emptyTableStyle();
+        style.styleId = (_a = this.defaultTableStyleId) !== null && _a !== void 0 ? _a : 'TableNormal';
+        style.name = { TYPE_NAME: 'org_docx4j_wml.Style.Name', val: 'Normal Table' };
+        const tblPr = style.tblPr;
+        tblPr.tblInd = twips(0);
+        tblPr.tblCellMar = {
+            TYPE_NAME: 'org_docx4j_wml.CTTblCellMar',
+            top: twips(0),
+            left: twips(WORD_DEFAULT_CELL_MARGIN_TWIPS),
+            bottom: twips(0),
+            right: twips(WORD_DEFAULT_CELL_MARGIN_TWIPS),
+        };
+        return style;
+    }
+    // ------------------------------------------------------------------ headings and known styles
+    /**
+     * The level of a heading style from its **id** ("Heading2" -> 2), or -1. docx4j keeps this
+     * because callers pass a style id; {@link headingLevelByName} is the rule Word applies, and
+     * is what resolution uses.
+     */
+    getLvlFromHeadingStyle(styleId) {
+        if (!styleId.startsWith(HEADING_STYLE))
+            return -1;
+        const rest = styleId.slice(HEADING_STYLE.length).trim();
+        if (!/^\d+$/.test(rest))
+            return -1;
+        return Number(rest);
+    }
+    /**
+     * Make a style available for use in the document, adding it to the styles part - and,
+     * recursively, whatever it is `w:basedOn` and whatever it is linked to. Given a style id,
+     * the style must be one this package knows (there is no KnownStyles.xml here yet; a style id
+     * that is not already live and not supplied as an object returns false).
+     */
+    activateStyle(style) {
+        if (typeof style !== 'string' && this.stylesArePrivate()) {
+            throw new Docx4JException('activateStyle writes into the styles part: await styleDefinitionsPart.getContents() and refresh() the resolver first');
+        }
+        if (typeof style === 'string') {
+            if (this.getLiveStyle(style) !== undefined)
+                return true;
+            log.warn(`Unknown style: ${style}`);
+            return false;
+        }
+        return this.activate(style, true);
+    }
+    activate(style, replace) {
+        var _a, _b, _c;
+        if (style.styleId === undefined)
+            return false;
+        const styles = this.source.styles;
+        if (styles === undefined)
+            return false;
+        const list = ((_a = styles.style) !== null && _a !== void 0 ? _a : (styles.style = []));
+        const existing = this.getLiveStyle(style.styleId);
+        if (existing !== undefined) {
+            if (!replace)
+                return false;
+            const index = list.indexOf(existing);
+            if (index >= 0)
+                list.splice(index, 1);
+        }
+        list.push(style);
+        this.liveStyles.set(style.styleId, style);
+        this.scannedStyleCount = list.length;
+        // resolution of this style (and of anything based on it) has to be recomputed
+        this.chainPPrCache.clear();
+        this.chainRPrCache.clear();
+        this.effectivePPrByStyle.clear();
+        this.effectiveRPrByStyle.clear();
+        let ok = true;
+        const basedOn = (_b = style.basedOn) === null || _b === void 0 ? void 0 : _b.val;
+        if (basedOn !== undefined)
+            ok = this.activateStyle(basedOn);
+        const link = (_c = style.link) === null || _c === void 0 ? void 0 : _c.val;
+        if (link !== undefined)
+            ok = this.activateStyle(link) && ok;
+        return ok;
+    }
+}
+function twips(w) {
+    return { TYPE_NAME: 'org_docx4j_wml.TblWidth', type: 'dxa', w };
+}
+function emptyTableStyle() {
+    return {
+        TYPE_NAME: 'org_docx4j_wml.Style',
+        type: 'table',
+        tblPr: { TYPE_NAME: 'org_docx4j_wml.CTTblPrBase' },
+    };
+}