@docx4j/core-ts 0.1.0 → 0.1.1

package/dist/model/properties/catalogue.mjs

@@ -0,0 +1,860 @@
+// ---------------------------------------------------------------- copying
+/**
+ * A structural copy of a leaf value, without its `PARENT` link: what the merges store, so
+ * that nothing in an effective `w:pPr` or `w:rPr` is a styles-part object.
+ */
+export function copyLeaf(value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => copyLeaf(item));
+    const out = {};
+    for (const key of Object.keys(value)) {
+        if (key === 'PARENT')
+            continue;
+        out[key] = copyLeaf(value[key]);
+    }
+    return out;
+}
+// ---------------------------------------------------------------- emptiness of scalars
+/** docx4j `StyleUtil.isEmpty(String)`: null or the empty string. */
+function emptyString(value) {
+    return value === undefined || value === '';
+}
+/** docx4j `StyleUtil.isEmpty(STThemeColor)`: null or `none`. */
+function emptyThemeColor(value) {
+    return value === undefined || value === 'none';
+}
+/** docx4j `StyleUtil.apply(String, String)` and friends: the source where it states one. */
+function attr(source, destination) {
+    return source === undefined ? destination : source;
+}
+/** docx4j `StyleUtil.apply(STThemeColor, STThemeColor)`: `none` does not override. */
+function themeColor(source, destination) {
+    return emptyThemeColor(source) ? destination : source;
+}
+/** A merge with no per-attribute rule: a copy of the source where it has one, else the inherited. */
+export function mergeReplace(source, destination) {
+    return source === undefined ? destination : copyLeaf(source);
+}
+/** Never carried: docx4j's `apply` for the owning element does not mention this member. */
+function notCarried(_source, destination) {
+    return destination;
+}
+/** Never empty in itself: `undefined` only. */
+function isNull(value) {
+    return value === undefined;
+}
+// ---------------------------------------------------------------- leaf emptiness
+/** `<w:b/>` and `<w:b w:val="0"/>` both count: an explicit false is applied. */
+export function isEmptyBool(value) {
+    return value === undefined;
+}
+/** A `BooleanDefaultTrue`'s value: absent `w:val` means true (docx4j `isVal()`). */
+export function isTrue(value) {
+    return value !== undefined && value.val !== false;
+}
+function isEmptyVal(value) {
+    return value === undefined || value.val === undefined;
+}
+function isEmptyStringVal(value) {
+    return value === undefined || emptyString(value.val);
+}
+export function isEmptyRStyle(value) {
+    return isEmptyStringVal(value);
+}
+/** docx4j `isEmpty(RFonts)`: insensitive to a `w:hint` (which `apply` still carries). */
+export function isEmptyRFonts(value) {
+    return value === undefined
+        || (emptyString(value.ascii) && value.asciiTheme === undefined
+            && emptyString(value.cs) && value.cstheme === undefined
+            && emptyString(value.eastAsia) && value.eastAsiaTheme === undefined
+            && emptyString(value.hAnsi) && value.hAnsiTheme === undefined);
+}
+export function isEmptyColor(value) {
+    return value === undefined || emptyString(value.val);
+}
+export function isEmptyU(value) {
+    return value === undefined || (value.val === undefined && emptyString(value.color));
+}
+export function isEmptyHighlight(value) {
+    return value === undefined || emptyString(value.val);
+}
+/** @since CR-015 phase 1: a style stating only `w:lang` used to count as empty and was never applied. */
+export function isEmptyLang(value) {
+    return value === undefined || (emptyString(value.val) && emptyString(value.eastAsia) && emptyString(value.bidi));
+}
+export function isEmptyShd(value) {
+    return value === undefined
+        || (emptyString(value.color) && emptyString(value.themeTint) && emptyString(value.themeShade)
+            && emptyString(value.fill) && emptyString(value.themeFillTint) && emptyString(value.themeFillShade)
+            && value.themeColor === undefined && value.themeFill === undefined && value.val === undefined);
+}
+export function isEmptyBorder(value) {
+    return value === undefined
+        || (emptyString(value.color) && value.space === undefined && value.sz === undefined
+            && value.themeColor === undefined && emptyString(value.themeShade) && emptyString(value.themeTint)
+            && value.val === undefined);
+}
+export function isEmptyPBdr(value) {
+    return value === undefined
+        || (isEmptyBorder(value.top) && isEmptyBorder(value.left) && isEmptyBorder(value.bottom)
+            && isEmptyBorder(value.right) && isEmptyBorder(value.between) && isEmptyBorder(value.bar));
+}
+/**
+ * docx4j `isEmpty(Ind)`: `w:start`/`w:end` (the strict-conformance spellings) count too
+ * (17.0.5); dropping them lost them in style resolution.
+ */
+export function isEmptyInd(value) {
+    return value === undefined
+        || (value.firstLine === undefined && value.firstLineChars === undefined
+            && value.hanging === undefined && value.hangingChars === undefined
+            && value.left === undefined && value.leftChars === undefined
+            && value.right === undefined && value.rightChars === undefined
+            && value.start === undefined && value.startChars === undefined
+            && value.end === undefined && value.endChars === undefined);
+}
+/** An explicit `w:beforeAutospacing`/`w:afterAutospacing` of either value is a statement too. */
+export function isEmptySpacing(value) {
+    return value === undefined
+        || (value.after === undefined && value.afterLines === undefined
+            && value.before === undefined && value.beforeLines === undefined
+            && value.line === undefined && value.lineRule === undefined
+            && value.beforeAutospacing === undefined && value.afterAutospacing === undefined);
+}
+function isEmptyTabStop(value) {
+    return value === undefined || (value.pos === undefined && value.val === undefined && value.leader === undefined);
+}
+export function isEmptyTabs(value) {
+    if (value === undefined || value.tab === undefined || value.tab.length === 0)
+        return true;
+    return !value.tab.some((stop) => !isEmptyTabStop(stop));
+}
+/**
+ * A `w:numPr` is empty only when it states neither `w:numId` nor `w:ilvl`: each inherits on
+ * its own (CR-015 probe styles-numpr-ilvl-only).
+ */
+export function isEmptyNumPr(value) {
+    return value === undefined
+        || ((value.numId === undefined || value.numId.val === undefined)
+            && (value.ilvl === undefined || value.ilvl.val === undefined));
+}
+/** `w:anchorLock` defaults to true, so only an explicit `w:anchorLock="0"` makes a frame non-empty by itself. */
+export function isEmptyFramePr(value) {
+    var _a;
+    return value === undefined
+        || (value.dropCap === undefined && value.lines === undefined && value.w === undefined
+            && value.h === undefined && value.vSpace === undefined && value.hSpace === undefined
+            && value.wrap === undefined && value.hAnchor === undefined && value.vAnchor === undefined
+            && value.x === undefined && value.xAlign === undefined
+            && value.y === undefined && value.yAlign === undefined && value.hRule === undefined
+            && ((_a = value.anchorLock) !== null && _a !== void 0 ? _a : true));
+}
+function isEmptyTblWidth(value) {
+    // @w:type is ignored, as docx4j does
+    return value === undefined || value.w === undefined;
+}
+function isEmptyTblCellMar(value) {
+    // w:start/w:end are not read, as docx4j's isEmpty/apply pair does not read them
+    return value === undefined
+        || (isEmptyTblWidth(value.bottom) && isEmptyTblWidth(value.left)
+            && isEmptyTblWidth(value.right) && isEmptyTblWidth(value.top));
+}
+function isEmptyTblBorders(value) {
+    return value === undefined
+        || (isEmptyBorder(value.bottom) && isEmptyBorder(value.left) && isEmptyBorder(value.right)
+            && isEmptyBorder(value.top) && isEmptyBorder(value.insideH) && isEmptyBorder(value.insideV));
+}
+function isEmptyTcBorders(value) {
+    return value === undefined
+        || (isEmptyBorder(value.bottom) && isEmptyBorder(value.left) && isEmptyBorder(value.right)
+            && isEmptyBorder(value.top) && isEmptyBorder(value.insideH) && isEmptyBorder(value.insideV)
+            && isEmptyBorder(value.tl2Br) && isEmptyBorder(value.tr2Bl));
+}
+function isEmptyTcMar(value) {
+    return value === undefined
+        || (isEmptyTblWidth(value.bottom) && isEmptyTblWidth(value.left)
+            && isEmptyTblWidth(value.right) && isEmptyTblWidth(value.top));
+}
+function isEmptyTblLook(value) {
+    return value === undefined
+        || (value.firstColumn === undefined && value.firstRow === undefined
+            && value.lastColumn === undefined && value.lastRow === undefined
+            && value.noHBand === undefined && value.noVBand === undefined && value.val === undefined);
+}
+function isEmptyTblPPr(value) {
+    return value === undefined
+        || (value.leftFromText === undefined && value.rightFromText === undefined
+            && value.topFromText === undefined && value.bottomFromText === undefined
+            && value.vertAnchor === undefined && value.horzAnchor === undefined
+            && value.tblpXSpec === undefined && value.tblpX === undefined
+            && value.tblpYSpec === undefined && value.tblpY === undefined);
+}
+function isEmptyCnf(value) {
+    return isEmptyStringVal(value);
+}
+// ---------------------------------------------------------------- leaf merges
+/** docx4j `apply(BooleanDefaultTrue, BooleanDefaultTrue)`: a copy of the source where it states one. */
+export function mergeBool(source, destination) {
+    return source === undefined ? destination : copyLeaf(source);
+}
+/** A leaf whose only content is `w:val`, taken whole when the source states it. */
+function mergeVal(isEmptyOf) {
+    return (source, destination) => {
+        if (source === undefined || isEmptyOf(source))
+            return destination;
+        const out = (destination !== null && destination !== void 0 ? destination : {});
+        out.val = source.val;
+        return out;
+    };
+}
+export const mergeRStyle = mergeVal(isEmptyRStyle);
+export const mergeHighlight = mergeVal(isEmptyHighlight);
+export const mergeEm = mergeVal(isEmptyVal);
+export const mergeVertAlign = mergeVal(isEmptyVal);
+export const mergeEffect = mergeVal(isEmptyVal);
+export const mergeHps = mergeVal(isEmptyVal);
+export const mergeSignedHps = mergeVal(isEmptyVal);
+export const mergeSignedTwips = mergeVal(isEmptyVal);
+export const mergeTextScale = mergeVal(isEmptyVal);
+export const mergeJc = mergeVal(isEmptyVal);
+export const mergeOutlineLvl = mergeVal(isEmptyVal);
+export const mergeTextAlignment = mergeVal(isEmptyVal);
+export const mergeTextDirection = mergeVal(isEmptyVal);
+export const mergeTextboxTightWrap = mergeVal(isEmptyVal);
+export const mergeCnf = mergeVal(isEmptyCnf);
+export const mergePStyle = mergeVal(isEmptyStringVal);
+const mergeTblStyle = mergeVal(isEmptyStringVal);
+const mergeRowBandSize = mergeVal(isEmptyVal);
+const mergeColBandSize = mergeVal(isEmptyVal);
+const mergeTblOverlap = mergeVal(isEmptyVal);
+const mergeVAlign = mergeVal(isEmptyVal);
+const mergeGridSpan = mergeVal(isEmptyVal);
+const mergeHMerge = mergeVal(isEmptyStringVal);
+const mergeVMerge = mergeVal(isEmptyStringVal);
+const mergeTblLayout = (source, destination) => {
+    if (source === undefined || source.type === undefined)
+        return destination;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    out.type = source.type;
+    return out;
+};
+/**
+ * `w:rFonts`: a theme reference trumps an explicit face within one element, and a source with
+ * only a `w:hint` still says something. A null source leaves the destination alone (until
+ * CR-015 phase 1 it was given an empty `w:rFonts`, so every merged `w:rPr` read as directly
+ * formatted).
+ */
+export const mergeRFonts = (source, destination) => {
+    if (source === undefined)
+        return destination;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    if (isEmptyRFonts(source)) {
+        if (source.hint !== undefined)
+            out.hint = source.hint;
+        // else: keep the (possibly empty) element, which RunFontSelector relies on
+        return out;
+    }
+    if (source.ascii !== undefined) {
+        out.ascii = source.ascii;
+        delete out.asciiTheme;
+    }
+    if (source.cs !== undefined) {
+        out.cs = source.cs;
+        delete out.cstheme;
+    }
+    if (source.eastAsia !== undefined) {
+        out.eastAsia = source.eastAsia;
+        delete out.eastAsiaTheme;
+    }
+    if (source.hAnsi !== undefined) {
+        out.hAnsi = source.hAnsi;
+        delete out.hAnsiTheme;
+    }
+    if (source.asciiTheme !== undefined) {
+        out.asciiTheme = source.asciiTheme;
+        delete out.ascii;
+    }
+    if (source.cstheme !== undefined) {
+        out.cstheme = source.cstheme;
+        delete out.cs;
+    }
+    if (source.eastAsiaTheme !== undefined) {
+        out.eastAsiaTheme = source.eastAsiaTheme;
+        delete out.eastAsia;
+    }
+    if (source.hAnsiTheme !== undefined) {
+        out.hAnsiTheme = source.hAnsiTheme;
+        delete out.hAnsi;
+    }
+    if (source.hint !== undefined)
+        out.hint = source.hint;
+    return out;
+};
+export const mergeColor = (source, destination) => {
+    if (isEmptyColor(source))
+        return destination;
+    const s = source;
+    const out = (destination !== null && destination !== void 0 ? destination : {});
+    out.themeColor = themeColor(s.themeColor, out.themeColor);
+    out.themeShade = attr(s.themeShade, out.themeShade);
+    out.themeTint = attr(s.themeTint, out.themeTint);
+    out.val = attr(s.val, out.val);
+    return out;
+};
+/** `w:val` and the colour attributes each inherit on their own (CR-015 phase 1). */
+export const mergeU = (source, destination) => {
+    if (isEmptyU(source))
+        return destination;
+    const s = source;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    out.val = attr(s.val, out.val);
+    out.color = attr(s.color, out.color);
+    out.themeColor = themeColor(s.themeColor, out.themeColor);
+    out.themeTint = attr(s.themeTint, out.themeTint);
+    out.themeShade = attr(s.themeShade, out.themeShade);
+    return out;
+};
+/** `w:val`, `w:eastAsia` and `w:bidi` each name the language of one script range and each inherits. */
+export const mergeLang = (source, destination) => {
+    if (isEmptyLang(source))
+        return destination;
+    const s = source;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    out.val = attr(s.val, out.val);
+    out.eastAsia = attr(s.eastAsia, out.eastAsia);
+    out.bidi = attr(s.bidi, out.bidi);
+    return out;
+};
+export const mergeShd = (source, destination) => {
+    if (isEmptyShd(source))
+        return destination;
+    const s = source;
+    const out = (destination !== null && destination !== void 0 ? destination : {});
+    out.color = attr(s.color, out.color);
+    out.fill = attr(s.fill, out.fill);
+    out.val = attr(s.val, out.val);
+    out.themeTint = attr(s.themeTint, out.themeTint);
+    out.themeShade = attr(s.themeShade, out.themeShade);
+    out.themeFillTint = attr(s.themeFillTint, out.themeFillTint);
+    out.themeFillShade = attr(s.themeFillShade, out.themeFillShade);
+    // the enums only when the source states them (until CR-015 a null source cleared them)
+    out.themeColor = themeColor(s.themeColor, out.themeColor);
+    out.themeFill = themeColor(s.themeFill, out.themeFill);
+    return out;
+};
+export const mergeBorder = (source, destination) => {
+    if (isEmptyBorder(source))
+        return destination;
+    const s = source;
+    const out = (destination !== null && destination !== void 0 ? destination : {});
+    out.color = attr(s.color, out.color);
+    out.space = attr(s.space, out.space);
+    out.sz = attr(s.sz, out.sz);
+    out.themeColor = themeColor(s.themeColor, out.themeColor);
+    out.themeShade = attr(s.themeShade, out.themeShade);
+    out.themeTint = attr(s.themeTint, out.themeTint);
+    out.val = attr(s.val, out.val);
+    return out;
+};
+export const mergePBdr = (source, destination) => {
+    if (isEmptyPBdr(source))
+        return destination;
+    const s = source;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    out.top = mergeBorder(s.top, out.top);
+    out.left = mergeBorder(s.left, out.left);
+    out.bottom = mergeBorder(s.bottom, out.bottom);
+    out.right = mergeBorder(s.right, out.right);
+    out.between = mergeBorder(s.between, out.between);
+    out.bar = mergeBorder(s.bar, out.bar);
+    return out;
+};
+/** `w:numId` and `w:ilvl` each inherit on their own; see {@link isEmptyNumPr}. */
+export const mergeNumPr = (source, destination) => {
+    if (isEmptyNumPr(source))
+        return destination;
+    const s = source;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    if (s.numId !== undefined && s.numId.val !== undefined)
+        out.numId = copyLeaf(s.numId);
+    if (s.ilvl !== undefined && s.ilvl.val !== undefined)
+        out.ilvl = copyLeaf(s.ilvl);
+    return out;
+};
+/**
+ * `w:ind`: `w:firstLine` and `w:hanging` are two spellings of one property (ECMA-376
+ * 17.3.1.12), so whichever of the two the more specific `w:ind` states replaces both; the
+ * rest inherit per attribute.
+ */
+export const mergeInd = (source, destination) => {
+    if (isEmptyInd(source))
+        return destination;
+    const s = source;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    const sourceFirstLine = s.firstLine !== undefined || s.firstLineChars !== undefined;
+    const sourceHanging = s.hanging !== undefined || s.hangingChars !== undefined;
+    if (sourceFirstLine && !sourceHanging) {
+        delete out.hanging;
+        delete out.hangingChars;
+    }
+    else if (sourceHanging && !sourceFirstLine) {
+        delete out.firstLine;
+        delete out.firstLineChars;
+    }
+    out.firstLine = attr(s.firstLine, out.firstLine);
+    out.firstLineChars = attr(s.firstLineChars, out.firstLineChars);
+    out.hanging = attr(s.hanging, out.hanging);
+    out.hangingChars = attr(s.hangingChars, out.hangingChars);
+    out.left = attr(s.left, out.left);
+    out.leftChars = attr(s.leftChars, out.leftChars);
+    out.right = attr(s.right, out.right);
+    out.rightChars = attr(s.rightChars, out.rightChars);
+    out.start = attr(s.start, out.start);
+    out.startChars = attr(s.startChars, out.startChars);
+    out.end = attr(s.end, out.end);
+    out.endChars = attr(s.endChars, out.endChars);
+    return out;
+};
+/**
+ * `w:spacing`: the autospacing attributes survive the merge, and `w:lineRule` qualifies
+ * `w:line` - a source stating `w:line` states a rule too (auto when it names none), and a
+ * source stating no `w:line` leaves both inherited (CR-015 probe styles-linerule).
+ */
+export const mergeSpacing = (source, destination) => {
+    var _a;
+    if (source === undefined)
+        return destination;
+    let out = destination;
+    if (source.beforeAutospacing !== undefined || source.afterAutospacing !== undefined) {
+        out !== null && out !== void 0 ? out : (out = {});
+        if (source.beforeAutospacing !== undefined)
+            out.beforeAutospacing = source.beforeAutospacing;
+        if (source.afterAutospacing !== undefined)
+            out.afterAutospacing = source.afterAutospacing;
+    }
+    if (!isEmptySpacing(source)) {
+        out !== null && out !== void 0 ? out : (out = {});
+        out.after = attr(source.after, out.after);
+        out.afterLines = attr(source.afterLines, out.afterLines);
+        out.before = attr(source.before, out.before);
+        out.beforeLines = attr(source.beforeLines, out.beforeLines);
+        if (source.line !== undefined) {
+            out.line = source.line;
+            out.lineRule = (_a = source.lineRule) !== null && _a !== void 0 ? _a : 'auto';
+        }
+        else if (source.lineRule !== undefined) {
+            out.lineRule = source.lineRule;
+        }
+    }
+    return out;
+};
+/**
+ * `w:tabs`: the custom tab stops are the union of those declared and those inherited, a stop
+ * at the same position replaces the inherited one, and `w:val="clear"` only removes
+ * (ECMA-376 17.3.1.38, 17.3.1.37). Word holds them in ascending position order.
+ */
+export const mergeTabs = (source, destination) => {
+    var _a;
+    if (isEmptyTabs(source))
+        return destination;
+    const out = destination !== null && destination !== void 0 ? destination : { tab: [] };
+    (_a = out.tab) !== null && _a !== void 0 ? _a : (out.tab = []);
+    for (const stop of source.tab) {
+        const pos = stop.pos;
+        if (pos !== undefined) {
+            for (let i = out.tab.length - 1; i >= 0; i--) {
+                if (out.tab[i].pos === pos)
+                    out.tab.splice(i, 1);
+            }
+        }
+        if (stop.val === 'clear')
+            continue;
+        out.tab.push({ leader: stop.leader, pos, val: stop.val });
+    }
+    out.tab.sort((a, b) => {
+        if (a.pos === undefined)
+            return b.pos === undefined ? 0 : -1;
+        if (b.pos === undefined)
+            return 1;
+        return a.pos - b.pos;
+    });
+    return out;
+};
+/**
+ * `w:framePr`'s attributes each inherit on their own: a paragraph whose direct `w:framePr`
+ * gives only `w:x`/`w:y` keeps the anchors its style states. `w:anchorLock` defaults to true,
+ * and docx4j's merge writes that default out explicitly.
+ */
+export const mergeFramePr = (source, destination) => {
+    var _a;
+    if (isEmptyFramePr(source))
+        return destination;
+    const s = source;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    out.dropCap = attr(s.dropCap, out.dropCap);
+    out.lines = attr(s.lines, out.lines);
+    out.w = attr(s.w, out.w);
+    out.h = attr(s.h, out.h);
+    out.vSpace = attr(s.vSpace, out.vSpace);
+    out.hSpace = attr(s.hSpace, out.hSpace);
+    out.wrap = attr(s.wrap, out.wrap);
+    out.hAnchor = attr(s.hAnchor, out.hAnchor);
+    out.vAnchor = attr(s.vAnchor, out.vAnchor);
+    out.x = attr(s.x, out.x);
+    out.xAlign = attr(s.xAlign, out.xAlign);
+    out.y = attr(s.y, out.y);
+    out.yAlign = attr(s.yAlign, out.yAlign);
+    out.hRule = attr(s.hRule, out.hRule);
+    // docx4j reads this through isAnchorLock(), which answers true when the attribute is absent
+    out.anchorLock = (_a = s.anchorLock) !== null && _a !== void 0 ? _a : true;
+    return out;
+};
+const mergeTblWidth = (source, destination) => {
+    if (source === undefined || source.w === undefined)
+        return destination;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    out.w = source.w;
+    // "if @w:type is omitted, its value shall be assumed to be dxa"
+    out.type = source.type;
+    return out;
+};
+const mergeTblCellMar = (source, destination) => {
+    if (isEmptyTblCellMar(source))
+        return destination;
+    const s = source;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    out.bottom = mergeTblWidth(s.bottom, out.bottom);
+    out.left = mergeTblWidth(s.left, out.left);
+    out.right = mergeTblWidth(s.right, out.right);
+    out.top = mergeTblWidth(s.top, out.top);
+    return out;
+};
+const mergeTblBorders = (source, destination) => {
+    if (isEmptyTblBorders(source))
+        return destination;
+    const s = source;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    out.bottom = mergeBorder(s.bottom, out.bottom);
+    out.left = mergeBorder(s.left, out.left);
+    out.right = mergeBorder(s.right, out.right);
+    out.top = mergeBorder(s.top, out.top);
+    out.insideH = mergeBorder(s.insideH, out.insideH);
+    out.insideV = mergeBorder(s.insideV, out.insideV);
+    return out;
+};
+const mergeTcBorders = (source, destination) => {
+    if (isEmptyTcBorders(source))
+        return destination;
+    const s = source;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    out.bottom = mergeBorder(s.bottom, out.bottom);
+    out.left = mergeBorder(s.left, out.left);
+    out.right = mergeBorder(s.right, out.right);
+    out.top = mergeBorder(s.top, out.top);
+    out.insideH = mergeBorder(s.insideH, out.insideH);
+    out.insideV = mergeBorder(s.insideV, out.insideV);
+    out.tl2Br = mergeBorder(s.tl2Br, out.tl2Br);
+    out.tr2Bl = mergeBorder(s.tr2Bl, out.tr2Bl);
+    return out;
+};
+const mergeTcMar = (source, destination) => {
+    if (isEmptyTcMar(source))
+        return destination;
+    const s = source;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    out.bottom = mergeTblWidth(s.bottom, out.bottom);
+    out.left = mergeTblWidth(s.left, out.left);
+    out.right = mergeTblWidth(s.right, out.right);
+    out.top = mergeTblWidth(s.top, out.top);
+    return out;
+};
+const mergeTblLook = (source, destination) => {
+    if (isEmptyTblLook(source))
+        return destination;
+    const s = source;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    out.firstColumn = attr(s.firstColumn, out.firstColumn);
+    out.firstRow = attr(s.firstRow, out.firstRow);
+    out.lastColumn = attr(s.lastColumn, out.lastColumn);
+    out.lastRow = attr(s.lastRow, out.lastRow);
+    out.noHBand = attr(s.noHBand, out.noHBand);
+    out.noVBand = attr(s.noVBand, out.noVBand);
+    out.val = attr(s.val, out.val);
+    return out;
+};
+/**
+ * `w:tblpPr`: the anchors and the `*Spec` enums only when the source states them - a
+ * `w:tblpPr` stating only `w:tblpX` keeps its inherited anchors in Word.
+ */
+const mergeTblPPr = (source, destination) => {
+    if (isEmptyTblPPr(source))
+        return destination;
+    const s = source;
+    const out = destination !== null && destination !== void 0 ? destination : {};
+    out.leftFromText = attr(s.leftFromText, out.leftFromText);
+    out.rightFromText = attr(s.rightFromText, out.rightFromText);
+    out.topFromText = attr(s.topFromText, out.topFromText);
+    out.bottomFromText = attr(s.bottomFromText, out.bottomFromText);
+    if (s.vertAnchor !== undefined)
+        out.vertAnchor = s.vertAnchor;
+    if (s.horzAnchor !== undefined)
+        out.horzAnchor = s.horzAnchor;
+    if (s.tblpXSpec !== undefined)
+        out.tblpXSpec = s.tblpXSpec;
+    out.tblpX = attr(s.tblpX, out.tblpX);
+    if (s.tblpYSpec !== undefined)
+        out.tblpYSpec = s.tblpYSpec;
+    out.tblpY = attr(s.tblpY, out.tblpY);
+    return out;
+};
+/**
+ * One entry. The accessors are by member name, which is the same on `RPr` and `ParaRPr`
+ * (docx4j needs an accessor pair per class there; here the two generated interfaces have the
+ * same members, so one pair serves both).
+ */
+function prop(name, merge, isEmpty, copyOf, options) {
+    var _a, _b;
+    return {
+        name,
+        isFormatting: (_a = options === null || options === void 0 ? void 0 : options.formatting) !== null && _a !== void 0 ? _a : true,
+        countsEmpty: (_b = options === null || options === void 0 ? void 0 : options.countsEmpty) !== null && _b !== void 0 ? _b : true,
+        get: (owner) => owner[name],
+        set: (owner, value) => {
+            const record = owner;
+            if (value === undefined)
+                delete record[name];
+            else
+                record[name] = value;
+        },
+        merge,
+        isEmpty,
+        copyOf,
+    };
+}
+/** A `BooleanDefaultTrue` member. */
+function bool(name, options) {
+    return prop(name, mergeBool, isEmptyBool, copyLeaf, options);
+}
+/** A w14 member (Office 2010 text effects and OpenType features): replaced whole. */
+function w14(name) {
+    return prop(name, mergeReplace, isNull, copyLeaf);
+}
+/**
+ * The members of `w:rPr` (17.3.2) and of the paragraph mark's `w:pPr/w:rPr`, in schema order,
+ * plus the w14 extensions the generated interfaces carry. Not listed: `w:rPrChange` and the
+ * paragraph mark's `w:ins`/`w:del`/`w:moveFrom`/`w:moveTo`, which record revisions and are
+ * never inherited.
+ */
+export const RUN = [
+    prop('rStyle', mergeRStyle, isEmptyRStyle, copyLeaf, { formatting: false }),
+    prop('rFonts', mergeRFonts, isEmptyRFonts, copyLeaf),
+    bool('b'),
+    bool('bCs'),
+    bool('i'),
+    bool('iCs'),
+    bool('caps'),
+    bool('smallCaps'),
+    bool('strike'),
+    bool('dstrike'),
+    bool('outline'),
+    bool('shadow'),
+    bool('emboss'),
+    bool('imprint'),
+    bool('noProof'),
+    bool('snapToGrid'),
+    bool('vanish'),
+    bool('webHidden'),
+    prop('color', mergeColor, isEmptyColor, copyLeaf),
+    prop('spacing', mergeSignedTwips, isEmptyVal, copyLeaf),
+    prop('w', mergeTextScale, isEmptyVal, copyLeaf),
+    prop('kern', mergeHps, isEmptyVal, copyLeaf),
+    prop('position', mergeSignedHps, isEmptyVal, copyLeaf),
+    prop('sz', mergeHps, isEmptyVal, copyLeaf),
+    prop('szCs', mergeHps, isEmptyVal, copyLeaf),
+    prop('highlight', mergeHighlight, isEmptyHighlight, copyLeaf),
+    prop('u', mergeU, isEmptyU, copyLeaf),
+    prop('effect', mergeEffect, isEmptyVal, copyLeaf),
+    prop('bdr', mergeBorder, isEmptyBorder, copyLeaf),
+    prop('shd', mergeShd, isEmptyShd, copyLeaf),
+    prop('fitText', mergeReplace, isNull, copyLeaf),
+    prop('vertAlign', mergeVertAlign, isEmptyVal, copyLeaf),
+    bool('rtl'),
+    bool('cs'),
+    prop('em', mergeEm, isEmptyVal, copyLeaf),
+    prop('lang', mergeLang, isEmptyLang, copyLeaf),
+    prop('eastAsianLayout', mergeReplace, isNull, copyLeaf),
+    bool('specVanish'),
+    bool('oMath'),
+    // w14 (Office 2010 text effects and OpenType features)
+    w14('glow'),
+    w14('shadow14'),
+    w14('reflection'),
+    w14('textOutline'),
+    w14('textFill'),
+    w14('scene3D'),
+    w14('props3D'),
+    w14('ligatures'),
+    w14('numForm'),
+    w14('numSpacing'),
+    w14('stylisticSets'),
+    w14('cntxtAlts'),
+];
+/** Members of `w:rPr` and `w:pPr/w:rPr` that are not in {@link RUN} (revision records). */
+export const RUN_EXCLUDED = ['rPrChange', 'ins', 'del', 'moveFrom', 'moveTo'];
+/**
+ * The names of the **toggle properties** of `w:rPr`, in the order ECMA-376-1 §17.7.3 lists
+ * them. Twelve, and no more: `w:dstrike`, `w:noProof`, `w:snapToGrid`, `w:webHidden`,
+ * `w:rtl`, `w:cs`, `w:specVanish` and `w:oMath` are Boolean but are not toggles.
+ */
+export const TOGGLE_NAMES = new Set([
+    'b', 'bCs', 'caps', 'emboss', 'i', 'iCs', 'imprint', 'outline',
+    'shadow', 'smallCaps', 'strike', 'vanish',
+]);
+/** {@link TOGGLE_NAMES} as members of {@link RUN}. */
+export const TOGGLES = [...TOGGLE_NAMES].map((name) => {
+    const found = RUN.find((p) => p.name === name);
+    if (!found)
+        throw new Error(`no w:rPr member named ${name}`);
+    return found;
+});
+/** The `w:ind` member's name: the paragraph merge applies it last, after the numbering level's. */
+export const IND = 'ind';
+/**
+ * The members of `w:pPr` shared with a style's `w:pPr` (`PPrBase`, 17.3.1), in schema order.
+ * Not formatting: `w:pStyle` (the style reference), `w:divId` (an HTML import artefact),
+ * `w:cnfStyle` (Word's cache of the table conditions that apply) and `w14:collapsed` (the
+ * outline view's state). A `w:pPr`'s own `w:rPr` (the paragraph mark) and `w:sectPr` are
+ * outside `PPrBase` and outside this list.
+ */
+export const PARAGRAPH = [
+    prop('pStyle', mergePStyle, isEmptyStringVal, copyLeaf, { formatting: false }),
+    bool('keepNext'),
+    bool('keepLines'),
+    bool('pageBreakBefore'),
+    prop('framePr', mergeFramePr, isEmptyFramePr, copyLeaf),
+    bool('widowControl'),
+    prop('numPr', mergeNumPr, isEmptyNumPr, copyLeaf),
+    bool('suppressLineNumbers'),
+    prop('pBdr', mergePBdr, isEmptyPBdr, copyLeaf),
+    prop('shd', mergeShd, isEmptyShd, copyLeaf),
+    prop('tabs', mergeTabs, isEmptyTabs, copyLeaf),
+    bool('suppressAutoHyphens'),
+    bool('kinsoku'),
+    bool('wordWrap'),
+    bool('overflowPunct'),
+    bool('topLinePunct'),
+    bool('autoSpaceDE'),
+    bool('autoSpaceDN'),
+    bool('bidi'),
+    bool('adjustRightInd'),
+    bool('snapToGrid'),
+    prop('spacing', mergeSpacing, isEmptySpacing, copyLeaf),
+    prop(IND, mergeInd, isEmptyInd, copyLeaf),
+    bool('contextualSpacing'),
+    bool('mirrorIndents'),
+    bool('suppressOverlap'),
+    prop('jc', mergeJc, isEmptyVal, copyLeaf),
+    prop('textDirection', mergeTextDirection, isEmptyVal, copyLeaf),
+    prop('textAlignment', mergeTextAlignment, isEmptyVal, copyLeaf),
+    prop('textboxTightWrap', mergeTextboxTightWrap, isEmptyVal, copyLeaf),
+    prop('outlineLvl', mergeOutlineLvl, isEmptyVal, copyLeaf),
+    prop('divId', mergeReplace, isNull, copyLeaf, { formatting: false }),
+    prop('cnfStyle', mergeCnf, isEmptyCnf, copyLeaf, { formatting: false }),
+    bool('collapsed', { formatting: false }),
+];
+/** Members of `w:pPr` that are not in {@link PARAGRAPH}: the mark, the section, the revision. */
+export const PARAGRAPH_EXCLUDED = ['rPr', 'sectPr', 'pPrChange'];
+/**
+ * The members of `w:tblPr` (`CTTblPrBase`, 17.4.60), in schema order.
+ *
+ * Three quirks of docx4j's hand-written pair are reproduced and flagged: `w:bidiVisual` is
+ * applied but not counted by `isEmpty`, and `w:tblCaption` and `w:tblDescription` are neither
+ * applied nor counted (they are a table's accessibility text, not formatting a style carries).
+ */
+export const TABLE = [
+    prop('tblStyle', mergeTblStyle, isEmptyStringVal, copyLeaf, { formatting: false }),
+    prop('tblpPr', mergeTblPPr, isEmptyTblPPr, copyLeaf),
+    prop('tblOverlap', mergeTblOverlap, isEmptyVal, copyLeaf),
+    bool('bidiVisual', { countsEmpty: false }),
+    prop('tblStyleRowBandSize', mergeRowBandSize, isEmptyVal, copyLeaf),
+    prop('tblStyleColBandSize', mergeColBandSize, isEmptyVal, copyLeaf),
+    prop('tblW', mergeTblWidth, isEmptyTblWidth, copyLeaf),
+    prop('jc', mergeJc, isEmptyVal, copyLeaf),
+    prop('tblCellSpacing', mergeTblWidth, isEmptyTblWidth, copyLeaf),
+    prop('tblInd', mergeTblWidth, isEmptyTblWidth, copyLeaf),
+    prop('tblBorders', mergeTblBorders, isEmptyTblBorders, copyLeaf),
+    prop('shd', mergeShd, isEmptyShd, copyLeaf),
+    prop('tblLayout', mergeTblLayout, (v) => v === undefined || v.type === undefined, copyLeaf),
+    prop('tblCellMar', mergeTblCellMar, isEmptyTblCellMar, copyLeaf),
+    prop('tblLook', mergeTblLook, isEmptyTblLook, copyLeaf),
+    prop('tblCaption', notCarried, isNull, copyLeaf, { countsEmpty: false }),
+    prop('tblDescription', notCarried, isNull, copyLeaf, { countsEmpty: false }),
+];
+export const TABLE_EXCLUDED = ['tblPrChange'];
+/**
+ * The members of `w:tcPr` (`TcPr`, 17.4.68), in schema order. `w:cellIns`, `w:cellDel`,
+ * `w:cellMerge` and `w:tcPrChange` record revisions and are excluded.
+ */
+export const CELL = [
+    prop('cnfStyle', mergeCnf, isEmptyCnf, copyLeaf, { formatting: false }),
+    prop('tcW', mergeTblWidth, isEmptyTblWidth, copyLeaf),
+    prop('gridSpan', mergeGridSpan, isEmptyVal, copyLeaf),
+    prop('hMerge', mergeHMerge, isEmptyStringVal, copyLeaf),
+    prop('vMerge', mergeVMerge, isEmptyStringVal, copyLeaf),
+    prop('tcBorders', mergeTcBorders, isEmptyTcBorders, copyLeaf),
+    prop('shd', mergeShd, isEmptyShd, copyLeaf),
+    bool('noWrap'),
+    prop('tcMar', mergeTcMar, isEmptyTcMar, copyLeaf),
+    prop('textDirection', mergeTextDirection, isEmptyVal, copyLeaf),
+    bool('tcFitText'),
+    prop('vAlign', mergeVAlign, isEmptyVal, copyLeaf),
+    bool('hideMark'),
+];
+export const CELL_EXCLUDED = ['cellIns', 'cellDel', 'cellMerge', 'tcPrChange'];
+// ---------------------------------------------------------------- generic operations
+/** The member of that name, or undefined. */
+export function namedProperty(catalogue, name) {
+    return catalogue.find((p) => p.name === name);
+}
+/** Whether every member of `owner` is empty. */
+export function isEmptyOf(catalogue, owner) {
+    if (owner === undefined || owner === null)
+        return true;
+    for (const p of catalogue) {
+        if (!p.countsEmpty)
+            continue;
+        if (!p.isEmpty(p.get(owner)))
+            return false;
+    }
+    return true;
+}
+/** Whether any formatting member is present (an element that is there, even with no attributes, counts: it was stated). */
+export function hasDirectFormattingOf(catalogue, owner) {
+    if (owner === undefined || owner === null)
+        return false;
+    for (const p of catalogue) {
+        if (p.isFormatting && p.get(owner) !== undefined)
+            return true;
+    }
+    return false;
+}
+/** Apply every member of `source` over `destination`, in place, except those named. */
+export function applyCatalogue(catalogue, source, destination, except) {
+    for (const p of catalogue) {
+        if (except === null || except === void 0 ? void 0 : except.has(p.name))
+            continue;
+        applyProperty(p, source, destination);
+    }
+}
+/** Apply one member of `source` over `destination`. */
+export function applyProperty(p, source, destination) {
+    p.set(destination, p.merge(p.get(source), p.get(destination)));
+}
+/** Unset in `destination` every member that `source` states. */
+export function unsetCatalogue(catalogue, source, destination) {
+    for (const p of catalogue) {
+        if (p.get(source) !== undefined)
+            p.set(destination, undefined);
+    }
+}