@docx4j/core-ts 0.3.0 → 0.3.2

package/dist/model/content/tracking.mjs

@@ -1,8 +1,9 @@
 import { deepCopy, deepCopyAsSync } from '@docx4j/generated-objects-ts';
-import { createCTTrackChange, createCTRPrChange, createCTRPrChangeRPr, createCTPPrChange, createDelText, createPPr, createParaRPr, createTrPr, } from '@docx4j/generated-objects-ts/factory/org_docx4j_wml';
+import * as el from '@docx4j/generated-objects-ts/el/org_docx4j_wml';
+import { createCTTrackChange, createCTRPrChange, createCTRPrChangeRPr, createCTPPrChange, createCTMarkup, createDelText, createPPr, createParaRPr, createTrPr, } from '@docx4j/generated-objects-ts/factory/org_docx4j_wml';
 import { rPrToElements, rPrFromElements } from '@docx4j/generated-objects-ts/builders/wml';
 import { Docx4JException } from '../../opc/exceptions.mjs';
-import { W_NS, linkParents, walk, typeNameOf, revisionKindOf } from './tree.mjs';
+import { W_NS, linkParents, walk, typeNameOf, revisionKindOf, childrenOf, rowsOf, cellsOf } from './tree.mjs';
 /**
  * `w:id` on these is the one annotation id space (ECMA-376 17.13.5.4): revisions, bookmarks,
  * comment range marks and permissions share it. `w:comment/@w:id` (docx4j `Comments.Comment`,
@@ -104,24 +105,33 @@ export function canonical(value) {
     });
 }
 /**
- * Makes sure the part's root lists `w16du` in `mc:Ignorable`, appending it when absent, so that
- * `w16du:dateUtc` may be written in it; the facade then declares the prefix. This is docx4j's
- * pattern - the writer of the content adds its prefix (`Paginate.declareW14Ignorable`) - and Jason's
- * decision (CR-002 section 29); objects CR-008 would do it for every writer. False when there is no
- * unmarshalled root to put it on. Every part a `Body` is over (document, header, footer, notes,
- * comments) has a root that binds `mc:Ignorable`.
+ * Makes sure the part's root lists a prefix in `mc:Ignorable`, appending it when absent, so that
+ * content in that prefix's namespace may be written in it; the facade then declares the prefix.
+ * This is docx4j's pattern - the writer of the content adds its prefix
+ * (`Paginate.declareW14Ignorable`) - and Jason's decision (CR-002 section 29). Since objects 0.3.1
+ * (its CR-008) the marshaller does it for every writer as well; these calls stay as the writer's
+ * own statement. False when there is no unmarshalled root to put it on. Every part a
+ * `Body` is over (document, header, footer, notes, comments) has a root that binds `mc:Ignorable`.
+ *
+ * The prefix must be the facade's conventional one for its namespace (`w15`, `w16du`): an
+ * application that does not know the namespace (Word 2010 and `w15`) opens the part only when the
+ * prefix is ignorable, as Word's own files declare it (CR-002 section 40).
  */
-function declareDateUtc(part) {
+export function declareIgnorable(part, prefix) {
     var _a;
     const contents = part === null || part === void 0 ? void 0 : part.contents;
     if (!contents || typeof contents !== 'object')
         return false;
     const root = (contents.value && typeof contents.value === 'object' ? contents.value : contents);
-    const prefixes = ((_a = root.ignorable) !== null && _a !== void 0 ? _a : '').split(/\s+/).filter((prefix) => prefix.length > 0);
-    if (!prefixes.includes('w16du'))
-        root.ignorable = [...prefixes, 'w16du'].join(' ');
+    const prefixes = ((_a = root.ignorable) !== null && _a !== void 0 ? _a : '').split(/\s+/).filter((p) => p.length > 0);
+    if (!prefixes.includes(prefix))
+        root.ignorable = [...prefixes, prefix].join(' ');
     return true;
 }
+/** `w16du` in the part's `mc:Ignorable`, so that `w16du:dateUtc` may be written in it. */
+function declareDateUtc(part) {
+    return declareIgnorable(part, 'w16du');
+}
 function element(localPart, value) {
     return { name: { namespaceURI: W_NS, localPart }, value };
 }
@@ -294,49 +304,166 @@ export class ChangeTracker {
     }
 }
 /**
- * A whole paragraph inserted: the mark is marked inserted and every run of it goes into a
- * `w:ins`. Word, splitting a paragraph, marks the *first* paragraph's mark instead and leaves
- * the new one the original mark; marking the new paragraph's own mark is the same document once
+ * A whole paragraph inserted: the mark is marked inserted (unless it already is) and every run of it
+ * goes into a `w:ins` - the runs in its hyperlinks, inline content controls, fields and smart tags as
+ * well (`wrapNewRuns`). Word, splitting a paragraph, marks the *first* paragraph's mark instead and
+ * leaves the new one the original mark; marking the new paragraph's own mark is the same document once
  * accepted or rejected and keeps the edit to the element that was added (CR-002 section 13).
  */
 export function trackInsertedParagraph(tracker, p) {
-    tracker.markParagraphInserted(p);
+    var _a, _b;
+    if (!((_b = (_a = p.pPr) === null || _a === void 0 ? void 0 : _a.rPr) === null || _b === void 0 ? void 0 : _b.ins))
+        tracker.markParagraphInserted(p);
     wrapNewRuns(tracker, p);
 }
-/** Every top-level run of the paragraph that is not already in a revision, wrapped in one `w:ins` per group. */
+/**
+ * Every run of the paragraph not already in a revision, wrapped in one `w:ins` per group of touching
+ * runs - at the top level and inside the run-level holders, where Word's form decides (`test/README.md`
+ * check 30, CR-002 section 37 item 7): in a hyperlink or a simple field the `w:ins` goes inside, since
+ * neither can be in one (`CT_RunTrackChange` holds `EG_ContentRunContent` only); a smart tag goes
+ * *into* the `w:ins` with the runs beside it, its own runs plain; an inline content control or custom
+ * XML element keeps the `w:ins` inside and is itself marked inserted (`markHolderInserted`). Before,
+ * only the top level was wrapped, so that rejecting an inserted paragraph left a link's text behind
+ * (the editor's finding on 0.3.0, CR-002 section 37 item 4).
+ */
 export function wrapNewRuns(tracker, p) {
-    const content = p.content;
-    if (!content)
+    wrapInsertedRuns(tracker, p.content, p);
+}
+/** True for what goes into a `w:ins` beside the runs: a run, or a smart tag (Word's form, check 30). */
+function wrapsAsRun(item) {
+    const tn = typeNameOf(item);
+    return (tn === 'org_docx4j_wml.R' || tn === 'org_docx4j_wml.CTSmartTagRun') && revisionKindOf(item) === undefined;
+}
+/**
+ * `wrapNewRuns` over run-level items that are about to go into a paragraph (`Paragraph.insertItemsAt`):
+ * the runs among them, and those in their holders, wrapped in `w:ins`; a content control or custom
+ * XML element among them marked inserted. `parent` is what the items' array belongs to.
+ */
+export function wrapInsertedRuns(tracker, items, parent) {
+    var _a, _b;
+    if (!items)
         return;
-    for (let i = 0; i < content.length; i++) {
-        if (typeNameOf(content[i]) !== 'org_docx4j_wml.R' || revisionKindOf(content[i]) !== undefined)
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (revisionKindOf(item) !== undefined)
+            continue; // already a revision
+        if (wrapsAsRun(item)) {
+            let j = i;
+            while (j < items.length && wrapsAsRun(items[j]))
+                j++;
+            const runs = items.splice(i, j - i);
+            const ins = tracker.ins(runs);
+            items.splice(i, 0, ins);
+            linkParents(ins, parent);
+            continue;
+        }
+        const value = item.value;
+        if (typeof value !== 'object' || value === null)
+            continue;
+        const holder = (_a = value.sdtContent) !== null && _a !== void 0 ? _a : value;
+        if (HOLDER_TYPES.has((_b = typeNameOf(item)) !== null && _b !== void 0 ? _b : '')) {
+            const before = items.length;
+            markHolderInserted(tracker, item, items, () => wrapInsertedRuns(tracker, childrenOf(value), holder));
+            i += items.length - before;
             continue;
-        let j = i;
-        while (j < content.length && typeNameOf(content[j]) === 'org_docx4j_wml.R' && revisionKindOf(content[j]) === undefined)
-            j++;
-        const runs = content.splice(i, j - i);
-        const ins = tracker.ins(runs);
-        content.splice(i, 0, ins);
-        linkParents(ins, p);
+        }
+        wrapInsertedRuns(tracker, childrenOf(value), holder);
     }
 }
-/** A whole table inserted: every row is marked inserted and every paragraph in it is an insertion. */
+/** A whole table inserted: every row is marked inserted and everything in its cells is an insertion (`trackInsertedBlocks`). */
 export function trackInsertedTable(tracker, tbl) {
-    var _a, _b, _c;
-    for (const row of ((_a = tbl.content) !== null && _a !== void 0 ? _a : [])) {
-        if (typeNameOf(row) !== 'org_docx4j_wml.Tr')
-            continue;
-        const tr = row.value;
-        tracker.markRowInserted(tr);
-        for (const cell of ((_b = tr.content) !== null && _b !== void 0 ? _b : [])) {
-            if (typeNameOf(cell) !== 'org_docx4j_wml.Tc')
-                continue;
-            for (const block of ((_c = cell.value.content) !== null && _c !== void 0 ? _c : [])) {
-                if (typeNameOf(block) === 'org_docx4j_wml.P')
-                    trackInsertedParagraph(tracker, block.value);
-            }
-        }
+    var _a;
+    for (const row of rowsOf(tbl)) {
+        const tr = row.element.value;
+        if (!((_a = tr.trPr) === null || _a === void 0 ? void 0 : _a.ins))
+            tracker.markRowInserted(tr);
+        for (const cell of cellsOf(tr))
+            trackInsertedBlocks(tracker, childrenOf(cell.element.value));
+    }
+}
+/**
+ * Block content inserted, whatever it holds: a paragraph (`trackInsertedParagraph`), a table
+ * (`trackInsertedTable`: rows inside row-level content controls, nested tables in its cells), and a
+ * block-level content control's or custom XML element's content, recursively, the element itself
+ * marked inserted (`markHolderInserted`; `owner` is the array holding `block`, which takes the
+ * markers). What `Body.insertElement` and `Table.addRows` track new content by (CR-002 section 37).
+ */
+export function trackInsertedBlock(tracker, block, owner) {
+    const tn = typeNameOf(block);
+    if (tn === 'org_docx4j_wml.P')
+        trackInsertedParagraph(tracker, block.value);
+    else if (tn === 'org_docx4j_wml.Tbl')
+        trackInsertedTable(tracker, block.value);
+    else if (typeof block.value !== 'object' || block.value === null)
+        return;
+    else if (HOLDER_TYPES.has(tn !== null && tn !== void 0 ? tn : ''))
+        markHolderInserted(tracker, block, owner, () => trackInsertedBlocks(tracker, childrenOf(block.value)));
+    else
+        trackInsertedBlocks(tracker, childrenOf(block.value));
+}
+/** `trackInsertedBlock` over every item of a list, which is their owner. */
+export function trackInsertedBlocks(tracker, items) {
+    if (!items)
+        return;
+    for (let i = 0; i < items.length; i++) {
+        const before = items.length;
+        trackInsertedBlock(tracker, items[i], items);
+        i += items.length - before; // past the markers just put in
+    }
+}
+/**
+ * The elements Word marks inserted as a whole with `w:customXmlInsRangeStart` / `End`: a content
+ * control or a custom XML element (check 30 measured the control at run and block level; a smart tag
+ * goes into the `w:ins` instead, and a hyperlink or field has no form of its own). Row- and cell-level
+ * ones are listed for the reader: `trackInsertedTable` walks through them to the rows and cells, and
+ * does not mark them.
+ */
+export const HOLDER_TYPES = new Set([
+    'org_docx4j_wml.SdtRun', 'org_docx4j_wml.SdtBlock', 'org_docx4j_wml.CTSdtRow', 'org_docx4j_wml.CTSdtCell',
+    'org_docx4j_wml.CTCustomXmlRun', 'org_docx4j_wml.CTCustomXmlBlock', 'org_docx4j_wml.CTCustomXmlRow', 'org_docx4j_wml.CTCustomXmlCell',
+]);
+/** The list a holder's content is in (`w:sdtContent`'s for a control, its own for custom XML), created when absent. */
+export function holderItemsOf(value) {
+    var _a, _b;
+    var _c;
+    const v = value;
+    if (v.sdtContent)
+        return ((_a = (_c = v.sdtContent).content) !== null && _a !== void 0 ? _a : (_c.content = []));
+    if ('element' in v)
+        return ((_b = v.content) !== null && _b !== void 0 ? _b : (v.content = [])); // w:customXml carries w:element
+    return undefined;
+}
+/**
+ * A content control or custom XML element inserted under tracking, as Word writes it (check 30): a
+ * `w:customXmlInsRangeStart` before the element with its `w:customXmlInsRangeEnd` first inside its
+ * content, and a second start last inside with its end after the element. Rejecting takes the element
+ * away and leaves its content where it stood (`TrackedChange`'s `holder` target); without the markers
+ * an element holding only an insertion reads as one that was there before and was typed into, which
+ * rejecting keeps (check 30, existing-control-typed). `inside` tracks the content between the two
+ * pairs, so that the ids run in document order as Word's do.
+ */
+export function markHolderInserted(tracker, holder, owner, inside) {
+    var _a;
+    const at = owner.indexOf(holder);
+    const items = holderItemsOf(holder.value);
+    if (at < 0 || !items) {
+        inside();
+        return;
     }
+    const value = holder.value;
+    const first = tracker.markup();
+    const outerStart = el.customXmlInsRangeStart(createCTTrackChange(first));
+    const innerEnd = el.customXmlInsRangeEnd(createCTMarkup({ id: first.id }));
+    owner.splice(at, 0, outerStart);
+    items.unshift(innerEnd);
+    inside();
+    const second = tracker.markup();
+    const innerStart = el.customXmlInsRangeStart(createCTTrackChange(second));
+    const outerEnd = el.customXmlInsRangeEnd(createCTMarkup({ id: second.id }));
+    items.push(innerStart);
+    owner.splice(owner.indexOf(holder) + 1, 0, outerEnd);
+    linkParents([outerStart, outerEnd], value.PARENT);
+    linkParents([innerEnd, innerStart], (_a = value.sdtContent) !== null && _a !== void 0 ? _a : value);
 }
 /** The paragraph mark's run properties (`w:pPr/w:rPr`), created when absent. */
 export function paraRPrOf(p) {

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

@@ -8,7 +8,9 @@ export interface CustomXmlPartLookup {
 }
 /**
  * A subset of Office JS `Word.XmlMapping`: the content control's data binding. `isMapped` is
- * whether the control has a `w:dataBinding`; `customXmlNode` evaluates the XPath now, so it needs
+ * whether the control has a `w:dataBinding` (or, on a rich text control or a repeating section,
+ * the `w15:dataBinding` Word writes there, which is what `setMapping` writes on one: CR-002
+ * section 40); `customXmlNode` evaluates the XPath now, so it needs
  * the XPath engine to be warm (`await pkg.customXmlParts.load()` once, CR-002 section 3.6).
  */
 export declare class XmlMapping {
@@ -33,13 +35,27 @@ export declare class XmlMapping {
      * Binds the control to what the XPath selects, as Word's own mapping does: the part is the one
      * given, else the one the control is already bound to, else the first custom XML part (the
      * built-in property stores last) in which the XPath selects a node. Returns false and changes
-     * nothing when nothing is selected, which is what Word reports.
+     * nothing when nothing is selected, which is what Word reports. **The node's value then goes into
+     * the control**, whatever text it held: Office JS's `setMapping` on a plain text control holding
+     * "quick brown", on an empty one and on one already holding the value, and Word's XML Mapping
+     * Pane mapping an existing control, each showed the node's "Ann" and left the part unchanged
+     * (`test/README.md` check 34, 2026-10-03; CR-002 section 39). Before, only the binding was
+     * written and the values stayed apart until `applyBindings`.
      */
     setMapping(xpath: string, prefixMappings?: string, part?: CustomXmlPart): boolean;
-    /** Binds to a node: its canonical XPath and the prefixes that path needs, as Word writes them. */
+    /** Binds to a node: its canonical XPath and the prefixes that path needs, as Word writes them; the node's value goes into the control (check 34). */
     setMappingByNode(node: CustomXmlNode): boolean;
-    /** Removes the binding (`w:dataBinding`); the control keeps the content it shows. */
+    /** Removes the binding (`w:dataBinding` and `w15:dataBinding`); the control keeps the content it shows. */
     delete(): void;
+    /**
+     * Whether the control's binding is `w15:dataBinding`, as Word 2013 and later write it: on a rich
+     * text control (one with `w:richText`, or with no kind element at all) and on a repeating
+     * section. `w:dataBinding` on a rich text control makes it a plain text control to Word 15 and
+     * Word 2010 alike - shown from its node on open, given `<w:text/>` on saving, an edit written
+     * back as text (`test/README.md` check 35, 1f; CR-002 section 40).
+     */
+    get usesW15(): boolean;
+    /** Writes the binding in the element the control's kind takes, replacing one in the other namespace where it stood. */
     private write;
     /** The parts to try, the customer's data before Word's property stores. */
     private candidates;

package/dist/model/customxml/XmlMapping.mjs

@@ -1,11 +1,16 @@
 import * as el from '@docx4j/generated-objects-ts/el/org_docx4j_wml';
+import * as w15el from '@docx4j/generated-objects-ts/el/org_docx4j_w15';
 import { sdtProperty } from '@docx4j/generated-objects-ts/builders/wml';
 import { canonicalXPathOf } from './xpath.mjs';
+import { applyBindingTo } from './bindings.mjs';
 /** The Word 2012 (w15) namespace; not imported from `ContentControl`, which imports this module. */
 const W15_NS = 'http://schemas.microsoft.com/office/word/2012/wordml';
+const W_NS = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 /**
  * A subset of Office JS `Word.XmlMapping`: the content control's data binding. `isMapped` is
- * whether the control has a `w:dataBinding`; `customXmlNode` evaluates the XPath now, so it needs
+ * whether the control has a `w:dataBinding` (or, on a rich text control or a repeating section,
+ * the `w15:dataBinding` Word writes there, which is what `setMapping` writes on one: CR-002
+ * section 40); `customXmlNode` evaluates the XPath now, so it needs
  * the XPath engine to be warm (`await pkg.customXmlParts.load()` once, CR-002 section 3.6).
  */
 export class XmlMapping {
@@ -58,7 +63,12 @@ export class XmlMapping {
      * Binds the control to what the XPath selects, as Word's own mapping does: the part is the one
      * given, else the one the control is already bound to, else the first custom XML part (the
      * built-in property stores last) in which the XPath selects a node. Returns false and changes
-     * nothing when nothing is selected, which is what Word reports.
+     * nothing when nothing is selected, which is what Word reports. **The node's value then goes into
+     * the control**, whatever text it held: Office JS's `setMapping` on a plain text control holding
+     * "quick brown", on an empty one and on one already holding the value, and Word's XML Mapping
+     * Pane mapping an existing control, each showed the node's "Ann" and left the part unchanged
+     * (`test/README.md` check 34, 2026-10-03; CR-002 section 39). Before, only the binding was
+     * written and the values stayed apart until `applyBindings`.
      */
     setMapping(xpath, prefixMappings, part) {
         const candidates = part ? [part] : this.candidates();
@@ -67,25 +77,53 @@ export class XmlMapping {
             if (!node)
                 continue;
             this.write(xpath, prefixMappings !== null && prefixMappings !== void 0 ? prefixMappings : '', candidate.id);
+            applyBindingTo(this.contentControl);
             return true;
         }
         return false;
     }
-    /** Binds to a node: its canonical XPath and the prefixes that path needs, as Word writes them. */
+    /** Binds to a node: its canonical XPath and the prefixes that path needs, as Word writes them; the node's value goes into the control (check 34). */
     setMappingByNode(node) {
         const { xpath, prefixMappings } = canonicalXPathOf(node.node);
         this.write(xpath, prefixMappings, node.ownerPart.id);
+        applyBindingTo(this.contentControl);
         return true;
     }
-    /** Removes the binding (`w:dataBinding`); the control keeps the content it shows. */
+    /** Removes the binding (`w:dataBinding` and `w15:dataBinding`); the control keeps the content it shows. */
     delete() {
-        this.contentControl.removeProperty('dataBinding');
+        this.contentControl.removeProperty('dataBinding', W_NS);
+        this.contentControl.removeProperty('dataBinding', W15_NS);
     }
+    /**
+     * Whether the control's binding is `w15:dataBinding`, as Word 2013 and later write it: on a rich
+     * text control (one with `w:richText`, or with no kind element at all) and on a repeating
+     * section. `w:dataBinding` on a rich text control makes it a plain text control to Word 15 and
+     * Word 2010 alike - shown from its node on open, given `<w:text/>` on saving, an edit written
+     * back as text (`test/README.md` check 35, 1f; CR-002 section 40).
+     */
+    get usesW15() {
+        const type = this.contentControl.type;
+        return type === 'RichText' || type === 'RepeatingSection';
+    }
+    /** Writes the binding in the element the control's kind takes, replacing one in the other namespace where it stood. */
     write(xpath, prefixMappings, storeItemID) {
+        var _a, _b;
         const binding = { TYPE_NAME: 'org_docx4j_wml.CTDataBinding', xpath, storeItemID };
         if (prefixMappings !== '')
             binding.prefixMappings = prefixMappings;
-        this.contentControl.putProperty(el.dataBinding(binding));
+        const w15 = this.usesW15;
+        const element = (w15 ? w15el.dataBinding(binding) : el.dataBinding(binding));
+        const items = (_a = this.contentControl.sdt.sdtPr) === null || _a === void 0 ? void 0 : _a.rPrOrAliasOrLock;
+        const other = w15 ? W_NS : W15_NS;
+        const at = (_b = items === null || items === void 0 ? void 0 : items.findIndex((i) => i.name.localPart === 'dataBinding' && i.name.namespaceURI === other)) !== null && _b !== void 0 ? _b : -1;
+        if (items && at >= 0) {
+            if (items.some((i) => i.name.localPart === 'dataBinding' && i.name.namespaceURI === element.name.namespaceURI))
+                items.splice(at, 1);
+            else
+                items[at] = element;
+        }
+        // putProperty also lists w15 in the part's mc:Ignorable when the element is a w15 one
+        this.contentControl.putProperty(element);
     }
     /** The parts to try, the customer's data before Word's property stores. */
     candidates() {

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

@@ -13,6 +13,13 @@ export interface BindingResult {
     /** Controls left alone: the part is missing, the XPath selects nothing, or the kind is not handled. */
     skipped: number;
 }
+/**
+ * Whether a node's value is a Flat OPC package: what Word writes into the node of a mapped rich
+ * text control when its content is edited, a whole `pkg:package` as escaped text (`test/README.md`
+ * check 35). It is content, never a control's text - Word 2010 shows it as raw XML in a plain text
+ * control bound to the same node - so neither direction moves it as text (CR-002 section 40).
+ */
+export declare function holdsFlatOpc(value: string): boolean;
 /** docx4j ValueInserterPlainTextImpl: the runs for a value, with the w:sdtPr run properties. */
 export declare function runsForValue(value: string, rPr: wml.RPr | undefined, multiLine: boolean): Element[];
 /**
@@ -24,8 +31,8 @@ export declare function runsForValue(value: string, rPr: wml.RPr | undefined, mu
 export declare function formatDate(pattern: string, date: Date, locale?: string): string;
 /**
  * Pushes the custom XML value into one control (docx4j BindingHandler's per-sdt work). Returns
- * false when nothing was written: no binding, no part, an XPath that selects nothing, or a kind
- * this phase does not handle (pictures, explicit rich text).
+ * false when nothing was written: no binding, no part, an XPath that selects nothing, a kind
+ * this phase does not handle (pictures, explicit rich text), or a node holding a Flat OPC package.
  */
 export declare function applyBindingTo(control: ContentControl): boolean;
 /** `applyBindings` over a list of controls. */

package/dist/model/customxml/bindings.mjs

@@ -4,6 +4,16 @@ import { sdtProperty } from '@docx4j/generated-objects-ts/builders/wml';
 /** The style Word gives placeholder text, and the text docx4j's placeholder.xml carries. */
 export const PLACEHOLDER_STYLE = 'PlaceholderText';
 export const PLACEHOLDER_TEXT = 'Click here to enter text.';
+/**
+ * Whether a node's value is a Flat OPC package: what Word writes into the node of a mapped rich
+ * text control when its content is edited, a whole `pkg:package` as escaped text (`test/README.md`
+ * check 35). It is content, never a control's text - Word 2010 shows it as raw XML in a plain text
+ * control bound to the same node - so neither direction moves it as text (CR-002 section 40).
+ */
+export function holdsFlatOpc(value) {
+    return /^\s*(<\?[^>]*\?>\s*)*<([\w.-]+:)?package[\s>]/.test(value)
+        && value.includes('http://schemas.microsoft.com/office/2006/xmlPackage');
+}
 function isTrue(value) {
     const v = value.trim().toLowerCase();
     return v === 'true' || v === '1' || v === 'on' || v === 'yes';
@@ -103,8 +113,8 @@ function dateOf(value) {
 }
 /**
  * Pushes the custom XML value into one control (docx4j BindingHandler's per-sdt work). Returns
- * false when nothing was written: no binding, no part, an XPath that selects nothing, or a kind
- * this phase does not handle (pictures, explicit rich text).
+ * false when nothing was written: no binding, no part, an XPath that selects nothing, a kind
+ * this phase does not handle (pictures, explicit rich text), or a node holding a Flat OPC package.
  */
 export function applyBindingTo(control) {
     var _a;
@@ -123,6 +133,9 @@ export function applyBindingTo(control) {
         return false;
     if (isContainer(control))
         return false;
+    // A Flat OPC package is a rich text control's content, not text: no control is filled with it.
+    if (holdsFlatOpc(value))
+        return false;
     if (control.type === 'CheckBox') {
         const checkbox = control.checkboxContentControl;
         if (!checkbox)
@@ -190,6 +203,9 @@ export function updateFromControl(control) {
     // A control showing its placeholder holds no value.
     if (control.isShowingPlaceholder)
         return false;
+    // The node holds a rich text control's content as Flat OPC: text is not written over it.
+    if (holdsFlatOpc(node.text))
+        return false;
     let value = control.text;
     if (control.type === 'CheckBox') {
         const checkbox = control.checkboxContentControl;

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

@@ -3,5 +3,5 @@ export { CustomXmlPart, CustomXmlNode, CustomXmlPrefixMappingCollection, type Cu
 export { CustomXmlPartCollection, type CustomXmlHost } from './CustomXmlPartCollection.mjs';
 export { XmlMapping, type CustomXmlPartLookup } from './XmlMapping.mjs';
 export { CheckboxContentControl, DatePickerContentControl, ListContentControl, ContentControlListItem, PictureContentControl, RepeatingSectionContentControl, GroupContentControl, checkboxRun, CHECKED_SYMBOL, UNCHECKED_SYMBOL, CHECKBOX_FONT, } from './kinds.mjs';
-export { applyBindingsTo, applyBindingTo, updateFromControls, updateFromControl, runsForValue, formatDate, PLACEHOLDER_STYLE, PLACEHOLDER_TEXT, type BindingResult } from './bindings.mjs';
+export { applyBindingsTo, applyBindingTo, updateFromControls, updateFromControl, runsForValue, formatDate, holdsFlatOpc, PLACEHOLDER_STYLE, PLACEHOLDER_TEXT, type BindingResult } from './bindings.mjs';
 export { controlIdScope, sdtKindFor, isRunLevel } from './insert.mjs';

package/dist/model/customxml/index.mjs

@@ -5,5 +5,5 @@ export { CustomXmlPart, CustomXmlNode, CustomXmlPrefixMappingCollection } from '
 export { CustomXmlPartCollection } from './CustomXmlPartCollection.mjs';
 export { XmlMapping } from './XmlMapping.mjs';
 export { CheckboxContentControl, DatePickerContentControl, ListContentControl, ContentControlListItem, PictureContentControl, RepeatingSectionContentControl, GroupContentControl, checkboxRun, CHECKED_SYMBOL, UNCHECKED_SYMBOL, CHECKBOX_FONT, } from './kinds.mjs';
-export { applyBindingsTo, applyBindingTo, updateFromControls, updateFromControl, runsForValue, formatDate, PLACEHOLDER_STYLE, PLACEHOLDER_TEXT } from './bindings.mjs';
+export { applyBindingsTo, applyBindingTo, updateFromControls, updateFromControl, runsForValue, formatDate, holdsFlatOpc, PLACEHOLDER_STYLE, PLACEHOLDER_TEXT } from './bindings.mjs';
 export { controlIdScope, sdtKindFor, isRunLevel } from './insert.mjs';

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

@@ -16,5 +16,15 @@ export declare function controlIdScope(body: {
     part?: XmlPart<unknown> | undefined;
     container: object;
 }): object;
+/**
+ * Lists `w15` in the `mc:Ignorable` of the body's part when the new control's `w:sdtPr` holds a
+ * `w15` element (a repeating section or its item): Word 2010 knows no `w15` and opens a part with
+ * one only when the prefix is ignorable (CR-002 section 40, `test/README.md` check 35).
+ */
+export declare function declareSdtExtensions(body: {
+    part?: XmlPart<unknown> | undefined;
+}, sdt: {
+    value?: unknown;
+}): void;
 /** True for a run-level item (what a Range wraps). */
 export declare function isRunLevel(element: Element): boolean;

package/dist/model/customxml/insert.mjs

@@ -1,4 +1,6 @@
 import { typeNameOf } from '../content/tree.mjs';
+import { declareIgnorable } from '../content/tracking.mjs';
+const W15_NS = 'http://schemas.microsoft.com/office/word/2012/wordml';
 /**
  * The kind the builders' `sdt` takes: Office JS's `Unknown` has no kind element, as `RichText`
  * has none (Word reports an untyped control as rich text).
@@ -15,6 +17,17 @@ export function controlIdScope(body) {
     const part = body.part;
     return (part === null || part === void 0 ? void 0 : part.isUnmarshalled) ? part.contents : body.container;
 }
+/**
+ * Lists `w15` in the `mc:Ignorable` of the body's part when the new control's `w:sdtPr` holds a
+ * `w15` element (a repeating section or its item): Word 2010 knows no `w15` and opens a part with
+ * one only when the prefix is ignorable (CR-002 section 40, `test/README.md` check 35).
+ */
+export function declareSdtExtensions(body, sdt) {
+    var _a, _b;
+    const items = (_b = (_a = sdt.value) === null || _a === void 0 ? void 0 : _a.sdtPr) === null || _b === void 0 ? void 0 : _b.rPrOrAliasOrLock;
+    if (items === null || items === void 0 ? void 0 : items.some((item) => { var _a; return ((_a = item.name) === null || _a === void 0 ? void 0 : _a.namespaceURI) === W15_NS; }))
+        declareIgnorable(body.part, 'w15');
+}
 /** True for a run-level item (what a Range wraps). */
 export function isRunLevel(element) {
     const tn = typeNameOf(element);

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);