@docx4j/core-ts 0.4.0 → 0.6.0

package/dist/model/properties/PropertyResolver.mjs

@@ -1,9 +1,12 @@
 import { deepCopy } from '@docx4j/generated-objects-ts';
-import { Docx4JException } from '../../opc/exceptions.mjs';
+import { Docx4JException, PartUnmarshalException } from '../../opc/exceptions.mjs';
 import { log } from './log.mjs';
 import { NumberingDefinitions } from '../listnumbering/definitions.mjs';
 import { applyPPr, applyPPrBase, applyRPr, applyStyle, applyStyleLevel, applyTblPr, applyToggles, hasDirectFormattingPPr, hasDirectFormattingRPr, isCyclic, isEmptyStyle, } from './styleUtil.mjs';
 import { TableContext, enclosingCellOf } from './table.mjs';
+import { ThemeColors } from '../color/ThemeColors.mjs';
+import { WordColors } from '../color/WordColors.mjs';
+import { themeOfSettings } from '../fonts/defaultTheme.mjs';
 /** The cache key for "no style" (a styles part with no default paragraph style). */
 const NO_STYLE = '';
 /** An empty table style: what a table with no style to apply contributes. Shared, never changed. */
@@ -75,6 +78,26 @@ export function headingLevelByName(style) {
     const match = HEADING_NAME.exec(name.trim());
     return match ? Number(match[1]) : -1;
 }
+/**
+ * A styles or numbering part the resolver can't do without: when it can't be read, nothing in the
+ * document can be given its formatting, so the document is refused (Jason, 2026-10-17), and the
+ * error says so before it says what was wrong where. A `PartUnmarshalException` stays one, with its
+ * part, location, line and column, so a caller showing the fault reads the same fields as for any
+ * part.
+ */
+async function readOrRefuse(part, role) {
+    try {
+        return await part.readContents();
+    }
+    catch (e) {
+        const why = role === 'styles' ? "every paragraph's formatting depends on it" : "its lists' numbers and indents depend on it";
+        const lead = `The document cannot be opened: its ${role} part could not be read, and ${why}.`;
+        if (e instanceof PartUnmarshalException) {
+            throw new PartUnmarshalException(`${lead} ${e.message}`, e.partName, { cause: e, location: e.location, line: e.line, column: e.column });
+        }
+        throw new Docx4JException(`${lead} ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+    }
+}
 export class PropertyResolver {
     constructor(provider, 
     /** Set when the styles tree the resolver holds is not the styles part's own. */
@@ -90,6 +113,8 @@ export class PropertyResolver {
         /** A style's `w:basedOn` chain merged root-first, WITHOUT the document defaults, per style id. */
         this.chainPPrCache = new Map();
         this.chainRPrCache = new Map();
+        /** A character style's chain as it applies to a run, where it differs from its chain: see {@link characterLevel}. */
+        this.characterLevelCache = new Map();
         /** The document defaults with the chain applied over them: what the style overloads return. */
         this.effectivePPrByStyle = new Map();
         this.effectiveRPrByStyle = new Map();
@@ -104,6 +129,14 @@ export class PropertyResolver {
         this.composedRPrCache = new CompositionCache();
         /** See {@link appliesTableStyleSizeJcException}; read once per `refresh()`. */
         this.tableStyleSizeJcException = true;
+        /**
+         * Whether the document's own `w:docDefaults` state a size, rather than the 10pt the resolver
+         * makes explicit where they do not: the size exception takes the document defaults' size only
+         * where they state one. Read once per `refresh()`.
+         */
+        this.docDefaultsStateSize = false;
+        /** Whether a paragraph style and a character style hide a run, by paragraph style then character style (`isVanishedByStyles`). */
+        this.vanishCache = new Map();
         /** Missing styles are logged once each per resolver. */
         this.missingLogged = new Set();
         this.source = provider();
@@ -132,8 +165,8 @@ export class PropertyResolver {
         }
         const stylesPart = main.styleDefinitionsPart;
         const numberingPart = main.numberingDefinitionsPart;
-        const privateStyles = stylesPart === undefined ? undefined : await stylesPart.readContents();
-        const privateNumbering = numberingPart === undefined ? undefined : await numberingPart.readContents();
+        const privateStyles = stylesPart === undefined ? undefined : await readOrRefuse(stylesPart, 'styles');
+        const privateNumbering = numberingPart === undefined ? undefined : await readOrRefuse(numberingPart, 'numbering');
         // the settings are read for two compatibility values (CR-007), privately, as the others are
         const settingsPart = main.documentSettingsPart;
         let privateSettings;
@@ -143,10 +176,24 @@ export class PropertyResolver {
         catch (e) {
             log.warn(`The settings part could not be read; taking compatibility mode ${DEFAULT_COMPATIBILITY_MODE}: ${String(e)}`);
         }
+        // the theme, for its colours (CR-008), privately too; where there is none, or it can't be read, the bundled theme
+        // the package names, parsed now so that getThemeColors() needn't wait
+        const themePart = main.themePart;
+        let privateTheme;
+        try {
+            privateTheme = themePart === undefined ? undefined : await themePart.readContents();
+        }
+        catch (e) {
+            log.warn(`The theme part could not be read; its colours are the default theme's: ${String(e)}`);
+        }
+        const defaultTheme = themeOfSettings(pkg.fonts);
+        await ThemeColors.loadDefaultTheme(defaultTheme);
         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,
             settings: (settingsPart === null || settingsPart === void 0 ? void 0 : settingsPart.isUnmarshalled) === true ? settingsPart.contents : privateSettings,
+            theme: (themePart === null || themePart === void 0 ? void 0 : themePart.isUnmarshalled) === true ? themePart.contents : privateTheme,
+            defaultTheme,
         }), () => stylesPart !== undefined && !stylesPart.isUnmarshalled);
     }
     /** Builds a resolver over object trees directly (a test, or parts already in hand). */
@@ -189,6 +236,7 @@ export class PropertyResolver {
             ? { 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);
+        this.docDefaultsStateSize = this.documentDefaultRPr.sz !== undefined;
         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)
@@ -239,13 +287,52 @@ export class PropertyResolver {
     refresh() {
         this.chainPPrCache.clear();
         this.chainRPrCache.clear();
+        this.characterLevelCache.clear();
         this.effectivePPrByStyle.clear();
         this.effectiveRPrByStyle.clear();
+        this.vanishCache.clear();
         this.clearTableCaches();
         this.missingLogged.clear();
+        this.themeColors = undefined;
         this.source = this.provider();
         this.init();
     }
+    /**
+     * The document's theme colours: its theme part (or the bundled theme `pkg.fonts.defaultTheme` names where it has
+     * none) and the settings' `w:clrSchemeMapping`. Read once per `refresh()`. A resolver made `fromSource` with no
+     * theme parses the bundled one, which needs the objects package's context built (`ThemeColors.loadDefaultTheme()`).
+     */
+    getThemeColors() {
+        var _a, _b;
+        (_a = this.themeColors) !== null && _a !== void 0 ? _a : (this.themeColors = ThemeColors.ofTheme(this.source.theme, this.source.defaultTheme)
+            .withWordMapping((_b = this.source.settings) === null || _b === void 0 ? void 0 : _b.clrSchemeMapping));
+        return this.themeColors;
+    }
+    /**
+     * The colour Word draws for a run's `w:color`: its theme reference where it has one (the value beside it is a
+     * cache), else its value.
+     *
+     * @returns undefined for automatic: the caller's default (black text, as a rule)
+     */
+    resolveColor(color) {
+        return WordColors.of(color, this.getThemeColors());
+    }
+    /** A border's colour, as {@link resolveColor}; undefined for automatic. docx4j `resolveColor(CTBorder)`. */
+    resolveBorderColor(border) {
+        return WordColors.ofBorder(border, this.getThemeColors());
+    }
+    /** An underline's colour, as {@link resolveColor}; undefined for automatic (the text's). docx4j `resolveColor(U)`. */
+    resolveUnderlineColor(u) {
+        return WordColors.ofUnderline(u, this.getThemeColors());
+    }
+    /** A shading's fill (`w:fill`, `w:themeFill`); undefined for automatic. */
+    resolveFill(shd) {
+        return WordColors.fill(shd, this.getThemeColors());
+    }
+    /** A shading's pattern colour (`w:color`, `w:themeColor`); undefined for automatic. */
+    resolvePatternColor(shd) {
+        return WordColors.pattern(shd, this.getThemeColors());
+    }
     // ------------------------------------------------------------------ defaults
     getDocumentDefaultPPr() {
         return this.documentDefaultPPr;
@@ -265,6 +352,16 @@ export class PropertyResolver {
     getStyle(styleId) {
         return this.getLiveStyle(styleId);
     }
+    /**
+     * The styles part's `w:style` elements in document order, from the tree this resolver reads (its
+     * private copy, or the part's own once that is unmarshalled); empty where there is no styles part.
+     * docx4j reads `StyleDefinitionsPart.getJaxbElement().getStyle()` where order matters
+     * (`Emulator.levelStyleId`: the first paragraph style in styles.xml carrying a level owns it).
+     */
+    getStylesInOrder() {
+        var _a, _b;
+        return (_b = (_a = this.source.styles) === null || _a === void 0 ? void 0 : _a.style) !== null && _b !== void 0 ? _b : [];
+    }
     /**
      * 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
@@ -339,6 +436,24 @@ export class PropertyResolver {
         this.chainRPrCache.set(styleId, chain);
         return chain;
     }
+    /**
+     * A character style's chain as a level over a run or a paragraph mark: {@link getChainRPr} without its highlight,
+     * since Word draws no highlight from a character style (docx4j CR-060 section 13, round 6: alone, with bold, or
+     * through `w:basedOn`; its save writes `w:highlight="none"` on such a run). A paragraph style's highlight and a
+     * run's own are drawn. docx4j `characterLevel` (1d1b824a9). Cached; live: copy before changing.
+     */
+    characterLevel(styleId) {
+        const chain = this.getChainRPr(styleId);
+        if (chain.highlight === undefined)
+            return chain;
+        let level = this.characterLevelCache.get(styleId);
+        if (level === undefined) {
+            level = deepCopy(chain);
+            delete level.highlight;
+            this.characterLevelCache.set(styleId, level);
+        }
+        return level;
+    }
     /**
      * 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" ...
@@ -384,7 +499,7 @@ export class PropertyResolver {
         return styleId;
     }
     getEffectivePPr(arg, cellContext) {
-        if (cellContext !== undefined && cellContext.formatsText && typeof arg !== 'string') {
+        if (this.composes(cellContext) && typeof arg !== 'string') {
             const composed = this.composedPPr(this.paragraphStyleOf(arg), cellContext);
             if (!hasDirectFormattingPPr(arg))
                 return composed;
@@ -415,7 +530,7 @@ export class PropertyResolver {
     getEffectiveRPr(arg, pPr, cellContext) {
         if (typeof arg === 'string')
             return this.effectiveRPrOfStyle(arg);
-        if (cellContext !== undefined && cellContext.formatsText) {
+        if (this.composes(cellContext)) {
             const inTable = deepCopy(this.composedRPr(this.paragraphStyleOf(pPr), cellContext));
             this.applyCharacterStyleAndDirect(arg, inTable);
             return inTable;
@@ -425,6 +540,30 @@ export class PropertyResolver {
         this.applyCharacterStyleAndDirect(arg, effective);
         return effective;
     }
+    /**
+     * Whether a run with no `w:vanish` of its own is hidden by its styles: the effective `w:vanish` of its
+     * paragraph style (undefined: the default paragraph style) and its character style, the table style left
+     * out, as the text model's hidden rule has it (REQ-507). What `Paragraph.text` leaves out, as Office JS
+     * does (CR-012 phase 4, check 48b case 20). Cached per pair; a pair naming a style the part lacks is
+     * not cached, so that adding the style is seen.
+     */
+    isVanishedByStyles(paragraphStyleId, runStyleId) {
+        let byRunStyle = this.vanishCache.get(paragraphStyleId);
+        const cached = byRunStyle === null || byRunStyle === void 0 ? void 0 : byRunStyle.get(runStyleId);
+        if (cached !== undefined)
+            return cached;
+        const rPr = runStyleId === undefined ? undefined : { TYPE_NAME: 'org_docx4j_wml.RPr', rStyle: { TYPE_NAME: 'org_docx4j_wml.RStyle', val: runStyleId } };
+        const pPr = paragraphStyleId === undefined ? undefined : { TYPE_NAME: 'org_docx4j_wml.PPr', pStyle: { TYPE_NAME: 'org_docx4j_wml.PPrBase.PStyle', val: paragraphStyleId } };
+        const vanish = this.getEffectiveRPr(rPr, pPr).vanish;
+        const hidden = vanish !== undefined && vanish !== null && vanish.val !== false;
+        if ((paragraphStyleId === undefined || this.getLiveStyle(paragraphStyleId) !== undefined)
+            && (runStyleId === undefined || this.getLiveStyle(runStyleId) !== undefined)) {
+            if (!byRunStyle)
+                this.vanishCache.set(paragraphStyleId, byRunStyle = new Map());
+            byRunStyle.set(runStyleId, hidden);
+        }
+        return hidden;
+    }
     effectiveRPrOfStyle(styleId) {
         const cached = this.effectiveRPrByStyle.get(styleId);
         if (cached !== undefined)
@@ -454,7 +593,7 @@ export class PropertyResolver {
                 this.logMissing(runStyleId);
             }
             else {
-                applyStyleLevel(this.getChainRPr(runStyleId), effective, this.documentDefaultRPr);
+                applyStyleLevel(this.characterLevel(runStyleId), effective, this.documentDefaultRPr);
             }
         }
         if (hasDirectFormattingRPr(rPr))
@@ -462,23 +601,43 @@ export class PropertyResolver {
     }
     /**
      * 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.
+     * properties, the mark's character style, then the `w:pPr`'s own `w:rPr`. What sizes an empty
+     * paragraph, and what a list label starts from.
      */
     getEffectiveParagraphMarkRPr(pPr, cellContext) {
-        if (cellContext !== undefined && cellContext.formatsText) {
+        if (this.composes(cellContext)) {
             // in a table cell: the table level beneath the paragraph style's (CR-007)
             const inTable = deepCopy(this.composedRPr(this.paragraphStyleOf(pPr), cellContext));
             if ((pPr === null || pPr === void 0 ? void 0 : pPr.rPr) !== undefined)
-                applyRPr(pPr.rPr, inTable);
+                this.applyMarkRPr(pPr.rPr, inTable);
             return inTable;
         }
         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);
+            this.applyMarkRPr(pPr.rPr, effective);
         return effective;
     }
+    /**
+     * The paragraph mark's character style (`w:pPr/w:rPr/w:rStyle`) as a level over what is
+     * beneath it, then the mark's direct formatting: the order {@link applyCharacterStyleAndDirect}
+     * gives a run. docx4j `applyMarkRPr`, since 17.3.2 (fb2a764f7: until then the mark's
+     * `w:rStyle` was copied as an attribute and never resolved, so an empty paragraph whose mark
+     * names a 9pt character style was sized at its paragraph style's 12pt).
+     */
+    applyMarkRPr(mark, effective) {
+        var _a;
+        const runStyleId = (_a = mark.rStyle) === null || _a === void 0 ? void 0 : _a.val;
+        if (runStyleId !== undefined) {
+            if (this.getLiveStyle(runStyleId) === undefined) {
+                this.logMissing(runStyleId);
+            }
+            else {
+                applyStyleLevel(this.characterLevel(runStyleId), effective, this.documentDefaultRPr);
+            }
+        }
+        applyRPr(mark, effective);
+    }
     /** Whether the run states any formatting of its own (docx4j's deprecated `hasDirectRPrFormatting`). */
     hasDirectRPrFormatting(rPr) {
         return hasDirectFormattingRPr(rPr);
@@ -609,6 +768,15 @@ export class PropertyResolver {
         const found = enclosingCellOf(p);
         return found === undefined ? undefined : this.tableContext(found.tbl).forParagraph(found.tr, found.tc, p.pPr);
     }
+    /**
+     * Whether a paragraph in this context is composed over its table level: where the table style
+     * gives it text formatting, or, under [MS-DOCX]'s size exception, where the style formats text
+     * anywhere ({@link CellContext.styleFormatsText}). docx4j `composes` (900b6a212, 17.3.2).
+     */
+    composes(cellContext) {
+        return cellContext !== undefined && (cellContext.formatsText
+            || (this.tableStyleSizeJcException && cellContext.styleFormatsText));
+    }
     clearTableCaches() {
         this.tableStyleChains.clear();
         this.composedPPrCache.clear();
@@ -663,18 +831,29 @@ export class PropertyResolver {
         // the table and the paragraph style are two levels of the hierarchy: the twelve toggles
         // combine across them rather than the paragraph's overriding (17.7.3)
         applyToggles(paragraphLevel, tableLevel, this.documentDefaultRPr, composed);
-        if (this.tableStyleSizeJcException && (tableOnly === null || tableOnly === void 0 ? void 0 : tableOnly.sz) !== undefined
+        // The size the table level gives is its own where the table style states one, else the
+        // document defaults' where they state one: Word applies the exception wherever the table
+        // style formats text at all, not only where it states a size (docx4j 900b6a212, measured on
+        // its table-style-size-trigger probes: in mode 12, with docDefaults 11pt and Normal 12pt, a
+        // table style with only a w:pPr, only an rPr colour, or only a firstRow format sets its
+        // table's paragraphs at 11pt; with none of these, at Normal's 12pt).  But where neither the
+        // table style nor the docDefaults state a size, Normal keeps its 12pt, not the 10pt Word
+        // falls back to (docx4j's corpus documents 10244 and 12723).
+        const tableStatesSize = (tableOnly === null || tableOnly === void 0 ? void 0 : tableOnly.sz) !== undefined;
+        if (this.tableStyleSizeJcException && ctx.styleFormatsText && tableLevel.sz !== undefined
+            && (tableStatesSize || this.docDefaultsStateSize)
             && this.paragraphStyleGivesWay(styleId, true)) {
-            composed.sz = deepCopy(tableOnly.sz);
+            composed.sz = deepCopy(tableLevel.sz);
         }
         this.composedRPrCache.set(styleId, ctx.key, composed);
         return composed;
     }
     /**
-     * [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.
+     * [MS-DOCX]'s exception, for a paragraph in a table whose style formats text (for the size: the
+     * style need not state one, since docx4j 17.3.2) or states 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.
      */
     paragraphStyleGivesWay(styleId, size) {
         var _a, _b, _c, _d;
@@ -763,6 +942,7 @@ export class PropertyResolver {
         // resolution of this style (and of anything based on it) has to be recomputed
         this.chainPPrCache.clear();
         this.chainRPrCache.clear();
+        this.characterLevelCache.clear();
         this.effectivePPrByStyle.clear();
         this.effectiveRPrByStyle.clear();
         this.clearTableCaches();

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

@@ -39,8 +39,24 @@ export declare function isTrue(value: wml.BooleanDefaultTrue | undefined): boole
 export declare function isEmptyRStyle(value: wml.RStyle | undefined): boolean;
 /** docx4j `isEmpty(RFonts)`: insensitive to a `w:hint` (which `apply` still carries). */
 export declare function isEmptyRFonts(value: wml.RFonts | undefined): boolean;
+/**
+ * A `w:color` stating only a theme colour is not empty: it is inherited, where until docx4j CR-034
+ * (2e381ef26) it was dropped. A value Word reads as absent (`F00`, `bogus`, `Auto`) is empty, so a style's
+ * colour beneath still shows, and only exactly `auto` overrides it (docx4j CR-060, {@link WordColors.stated};
+ * CR-015 section 2, rules 4 and 5).
+ */
 export declare function isEmptyColor(value: wml.Color | undefined): boolean;
+/**
+ * The underline's colour attributes count, the theme ones too (docx4j CR-034, 2e381ef26); a colour Word reads as
+ * absent doesn't (docx4j CR-060, {@link WordColors.stated}).
+ */
 export declare function isEmptyU(value: wml.U | undefined): boolean;
+/** Whether a `w:highlight` value is one of `ST_HighlightColor`'s, compared case-exactly, as Word does (docx4j `WordRepairs.isHighlightColor`). */
+export declare function isHighlightColor(val: string | undefined): boolean;
+/**
+ * A value outside `ST_HighlightColor` (`YELLOW`, `bogus`), or none, is empty: Word's repair drops it, so a style's
+ * highlight beneath still shows (docx4j CR-060, its `StyleUtil.isEmpty(Highlight)`).
+ */
 export declare function isEmptyHighlight(value: wml.Highlight | undefined): boolean;
 /** @since CR-015 phase 1: a style stating only `w:lang` used to count as empty and was never applied. */
 export declare function isEmptyLang(value: wml.CTLanguage | undefined): boolean;
@@ -60,7 +76,10 @@ export declare function isEmptyTabs(value: wml.Tabs | undefined): boolean;
  * its own (CR-015 probe styles-numpr-ilvl-only).
  */
 export declare function isEmptyNumPr(value: wml.PPrBase.NumPr | undefined): boolean;
-/** `w:anchorLock` defaults to true, so only an explicit `w:anchorLock="0"` makes a frame non-empty by itself. */
+/**
+ * Empty only with `w:anchorLock` absent too, as docx4j 82c64bf14 reads it (its CR-059: until then
+ * `isAnchorLock()`, which the schema's old `default="true"` made true for an absent attribute).
+ */
 export declare function isEmptyFramePr(value: wml.CTFramePr | undefined): boolean;
 /** docx4j `apply(BooleanDefaultTrue, BooleanDefaultTrue)`: a copy of the source where it states one. */
 export declare function mergeBool(source: wml.BooleanDefaultTrue | undefined, destination: wml.BooleanDefaultTrue | undefined): wml.BooleanDefaultTrue | undefined;
@@ -87,8 +106,17 @@ export declare const mergePStyle: Merge<wml.PPrBase.PStyle>;
  * formatted).
  */
 export declare const mergeRFonts: Merge<wml.RFonts>;
+/**
+ * A colour inherits as one (docx4j CR-034, 2e381ef26): where the source states a value or a theme
+ * reference, its value, theme colour, tint and shade replace the destination's together. Word
+ * draws a theme reference over the value written beside it, so taken one by one, a run's
+ * `w:val="FF0000"` under a style's `w:themeColor="accent1"` would keep the style's reference and
+ * draw accent1, where Word draws red. A tint or shade stated alone still inherits on its own. The
+ * same holds for the colours of `w:u`, `w:shd` (its pattern colour and its fill) and the borders.
+ * (Attribute by attribute until then, CR-015 phase 1.)
+ */
 export declare const mergeColor: Merge<wml.Color>;
-/** `w:val` and the colour attributes each inherit on their own (CR-015 phase 1). */
+/** `w:val` and the colour inherit on their own (CR-015 phase 1), the colour as one ({@link mergeColor}). */
 export declare const mergeU: Merge<wml.U>;
 /** `w:val`, `w:eastAsia` and `w:bidi` each name the language of one script range and each inherits. */
 export declare const mergeLang: Merge<wml.CTLanguage>;
@@ -117,8 +145,8 @@ export declare const mergeSpacing: Merge<wml.PPrBase.Spacing>;
 export declare const mergeTabs: Merge<wml.Tabs>;
 /**
  * `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.
+ * gives only `w:x`/`w:y` keeps the anchors its style states, `w:anchorLock` among them (docx4j
+ * 82c64bf14 merges it as stated; until then its merge wrote `isAnchorLock()`'s default out).
  */
 export declare const mergeFramePr: Merge<wml.CTFramePr>;
 /**