@docx4j/core-ts 0.6.0 → 0.7.0

package/dist/opc/mce/preprocessor.mjs

@@ -1,5 +1,6 @@
-import { READ_UNDERSTOOD_NAMESPACES } from './understood.mjs';
+import { UNDERSTOOD_NAMESPACES } from './understood.mjs';
 export const MCE_NS = 'http://schemas.openxmlformats.org/markup-compatibility/2006';
+const W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 /**
  * The hosts whose mc:AlternateContent is kept whole on load, as `{namespace}localName`
  * (CR-010 phase 1): a chart's `c:chartSpace` and SpreadsheetML's `workbook`.
@@ -13,21 +14,25 @@ export const KEPT_HOSTS = new Set([
  * warnings are what resolving would report. Returns them.
  */
 export function mceKeep(doc, part) {
-    return preprocessAlternateContent(doc, { resolve: false, partName: part === null || part === void 0 ? void 0 : part.partName.name }).warnings;
+    return preprocessAlternateContent(doc, { resolve: false, partName: part === null || part === void 0 ? void 0 : part.partName.name, wordProcessing: isWordProcessing(part) }).warnings;
 }
-/** The resolving preprocessor (`mcePreprocess: true`), over `READ_UNDERSTOOD_NAMESPACES`. Returns the part's warnings. */
+/** The resolving preprocessor (`mcePreprocess: true`), over `UNDERSTOOD_NAMESPACES`. Returns the part's warnings. */
 export function mcePreprocess(doc, part) {
-    return preprocessAlternateContent(doc, { partName: part === null || part === void 0 ? void 0 : part.partName.name }).warnings;
+    return preprocessAlternateContent(doc, { partName: part === null || part === void 0 ? void 0 : part.partName.name, wordProcessing: isWordProcessing(part) }).warnings;
 }
 /** A preprocessor over a namespace set (or kept hosts) of your own. */
 export function createMcePreprocessor(options) {
-    return (doc, part) => preprocessAlternateContent(doc, { ...options, partName: part === null || part === void 0 ? void 0 : part.partName.name }).warnings;
+    return (doc, part) => preprocessAlternateContent(doc, { wordProcessing: isWordProcessing(part), ...options, partName: part === null || part === void 0 ? void 0 : part.partName.name }).warnings;
+}
+/** Whether a part is WordprocessingML's, by its content type (the transitional and macro-enabled forms); a bare node is taken as one. */
+function isWordProcessing(part) {
+    return part === undefined || /wordprocessingml|vnd\.ms-word/.test(part.contentType);
 }
 /**
- * Resolves every mc:AlternateContent under a node, outermost first, but those `KEPT_HOSTS` and the
- * nothing-selectable rule keep (see the file comment). Returns the number resolved.
+ * Resolves every mc:AlternateContent under a node, outermost first, but those the file comment keeps. Returns the number
+ * resolved, one nothing was selected from among them.
  */
-export function resolveAlternateContent(root, understood = READ_UNDERSTOOD_NAMESPACES) {
+export function resolveAlternateContent(root, understood = UNDERSTOOD_NAMESPACES) {
     return preprocessAlternateContent(root, { understood }).resolved;
 }
 /**
@@ -36,19 +41,28 @@ export function resolveAlternateContent(root, understood = READ_UNDERSTOOD_NAMES
  * and leaves the DOM as it was.
  */
 export function preprocessAlternateContent(root, options = {}) {
-    var _a, _b, _c;
-    const understood = (_a = options.understood) !== null && _a !== void 0 ? _a : READ_UNDERSTOOD_NAMESPACES;
+    var _a, _b, _c, _d;
+    const understood = (_a = options.understood) !== null && _a !== void 0 ? _a : UNDERSTOOD_NAMESPACES;
     const keptHosts = (_b = options.keptHosts) !== null && _b !== void 0 ? _b : KEPT_HOSTS;
     const resolve = (_c = options.resolve) !== null && _c !== void 0 ? _c : true;
+    const wordProcessing = (_d = options.wordProcessing) !== null && _d !== void 0 ? _d : true;
     const result = { resolved: 0, kept: 0, warnings: [] };
+    const undeclared = new Set();
+    // a list read where its element stood in the source: resolving moves a branch's content out of the mc:Choice that may declare
+    // its prefixes, as Excel's drawings declare a14 there and list it on an a:srgbClr inside
+    const asRead = new Map();
     const visit = (node) => {
-        var _a;
-        const hostKept = node.nodeType === 1 && keptHosts.has(`{${(_a = node.namespaceURI) !== null && _a !== void 0 ? _a : ''}}${node.localName}`);
+        var _a, _b, _c;
+        if (node.nodeType === 1)
+            for (const p of (_a = asRead.get(node)) !== null && _a !== void 0 ? _a : undeclaredIgnorable(node))
+                undeclared.add(p);
+        const hostKept = node.nodeType === 1 && keptHosts.has(`{${(_b = node.namespaceURI) !== null && _b !== void 0 ? _b : ''}}${node.localName}`);
         // A work list, not the live child list: resolving replaces a child with the branch's content,
         // which is visited in its turn (it may hold, or be, another mc:AlternateContent).
         const queue = [];
         for (let c = node.firstChild; c; c = c.nextSibling)
             queue.push(c);
+        let removed = false;
         for (let i = 0; i < queue.length; i++) {
             if (queue[i].nodeType !== 1)
                 continue;
@@ -60,33 +74,98 @@ export function preprocessAlternateContent(root, options = {}) {
             const { choices, fallback } = branchesOf(el);
             const chosen = choices.find((c) => choiceUnderstood(c, understood));
             const branch = chosen !== null && chosen !== void 0 ? chosen : fallback;
-            if (hostKept || (branch === undefined && choices.length > 0)) {
+            const nothing = branch === undefined && choices.length > 0;
+            if (hostKept || (nothing && !wordProcessing)) {
                 result.kept++;
                 continue;
             }
-            const warning = branchesDiffer(el, choices, fallback, branch, understood, options.partName);
+            const atRoot = ((_c = el.parentNode) === null || _c === void 0 ? void 0 : _c.nodeType) === 9;
+            const warning = nothing ? nothingSelected(el, choices, resolve && !atRoot, atRoot, options.partName) : branchesDiffer(el, choices, fallback, branch, understood, options.partName);
             if (warning)
                 result.warnings.push(warning);
-            if (!resolve) {
+            // a part's root is left whole, as a resolving load can't put a branch's content where the root stood beside it, and
+            // reading the branch as the part is WD REQ-317's, not built (CR-028 D10)
+            if (!resolve || atRoot) {
                 result.kept++;
                 if (branch)
                     visit(branch);
                 continue;
             }
             const moved = [];
+            if (branch)
+                readInPlace(branch, asRead);
             if (branch)
                 for (let c = branch.firstChild; c; c = c.nextSibling)
                     moved.push(c);
             for (const n of moved)
                 node.insertBefore(n, el);
             node.removeChild(el);
+            removed = true;
             queue.splice(i + 1, 0, ...moved);
             result.resolved++;
         }
+        if (removed)
+            keepACellsParagraph(node);
     };
     visit(root);
+    if (undeclared.size > 0)
+        result.warnings.push(undeclaredPrefix([...undeclared], options.partName));
     return result;
 }
+/** The prefixes an element's `mc:Ignorable` lists that have no declaration in scope on it, where it stands now (WD REQ-323). */
+function undeclaredIgnorable(el) {
+    const listed = el.getAttributeNS(MCE_NS, 'Ignorable');
+    if (!listed)
+        return [];
+    return listed.trim().split(/\s+/).filter((prefix) => prefix !== '' && !el.lookupNamespaceURI(prefix));
+}
+/**
+ * Before a branch's content is moved out, each list in it read where it stands, unless an outer branch's move already read it
+ * there. A list in a nested branch not taken is read too, and never visited, so never said.
+ */
+function readInPlace(branch, into) {
+    const all = branch.getElementsByTagName('*');
+    for (let i = 0; i < all.length; i++) {
+        const el = all.item(i);
+        if (!into.has(el) && el.hasAttributeNS(MCE_NS, 'Ignorable'))
+            into.set(el, undeclaredIgnorable(el));
+    }
+}
+function undeclaredPrefix(prefixes, partName) {
+    return {
+        code: 'mce.undeclared_prefix',
+        partName,
+        prefixes,
+        message: `${partName !== null && partName !== void 0 ? partName : 'a part'}: mc:Ignorable lists ${prefixes.join(' ')}, which no declaration in scope binds, so it names nothing and is read as though the list didn't hold it (WD REQ-323)`,
+    };
+}
+/**
+ * A `w:tc` left with no block gets the paragraph Word's repair gives a cell with none (CR-029 D4 and D9): single-spaced with no
+ * space after, `w:spacing w:after="0" w:line="240" w:lineRule="auto"`, whatever the document's defaults, its Normal style or a
+ * table style say (the `cell-paragraph` round). Word writes no spacing where the paragraph already reads so (`cp-02`); there the
+ * element changes nothing drawn. Word repairs such a cell on open (`te-01` to `te-03`), and opens this silently.
+ */
+function keepACellsParagraph(node) {
+    if (node.nodeType !== 1)
+        return;
+    const cell = node;
+    if (cell.namespaceURI !== W || cell.localName !== 'tc')
+        return;
+    for (let c = cell.firstChild; c; c = c.nextSibling) {
+        if (c.nodeType === 1 && c.localName !== 'tcPr')
+            return;
+    }
+    const doc = cell.ownerDocument;
+    const name = (local) => (cell.prefix ? `${cell.prefix}:${local}` : local);
+    const spacing = doc.createElementNS(W, name('spacing'));
+    for (const [attribute, value] of [['after', '0'], ['line', '240'], ['lineRule', 'auto']])
+        spacing.setAttributeNS(W, name(attribute), value);
+    const pPr = doc.createElementNS(W, name('pPr'));
+    pPr.appendChild(spacing);
+    const p = doc.createElementNS(W, name('p'));
+    p.appendChild(pPr);
+    cell.appendChild(p);
+}
 function isAlternateContent(el) {
     return el.namespaceURI === MCE_NS && el.localName === 'AlternateContent';
 }
@@ -126,25 +205,24 @@ const TEXT_NAMESPACES = new Set([
 ]);
 /**
  * The text a branch holds: its w:t, a:t and m:t, whitespace collapsed. A nested
- * mc:AlternateContent contributes the branch the same rule selects, or its first Choice when
- * nothing is selectable (the reading rule).
+ * mc:AlternateContent contributes the branch the same rule selects, and nothing where it selects nothing.
  */
 function textOfBranch(node, understood) {
     const out = [];
     const walk = (n) => {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         for (let c = n.firstChild; c; c = c.nextSibling) {
             if (c.nodeType !== 1)
                 continue;
             const el = c;
             if (isAlternateContent(el)) {
                 const { choices, fallback } = branchesOf(el);
-                const branch = (_b = (_a = choices.find((x) => choiceUnderstood(x, understood))) !== null && _a !== void 0 ? _a : fallback) !== null && _b !== void 0 ? _b : choices[0];
+                const branch = (_a = choices.find((x) => choiceUnderstood(x, understood))) !== null && _a !== void 0 ? _a : fallback;
                 if (branch)
                     walk(branch);
             }
-            else if (el.localName === 't' && TEXT_NAMESPACES.has((_c = el.namespaceURI) !== null && _c !== void 0 ? _c : ''))
-                out.push((_d = el.textContent) !== null && _d !== void 0 ? _d : '');
+            else if (el.localName === 't' && TEXT_NAMESPACES.has((_b = el.namespaceURI) !== null && _b !== void 0 ? _b : ''))
+                out.push((_c = el.textContent) !== null && _c !== void 0 ? _c : '');
             else
                 walk(el);
         }
@@ -156,6 +234,29 @@ function branchName(branch) {
     var _a;
     return branch.localName === 'Choice' ? `Choice(${((_a = branch.getAttribute('Requires')) !== null && _a !== void 0 ? _a : '').trim()})` : 'Fallback';
 }
+/** `mce.nothing_selected`'s record: the namespaces the Choices require, each once, in order (the objects package's `NothingSelected`). */
+function nothingSelected(ac, choices, removed, root, partName) {
+    var _a;
+    const namespaces = new Set();
+    for (const choice of choices) {
+        for (const prefix of ((_a = choice.getAttribute('Requires')) !== null && _a !== void 0 ? _a : '').trim().split(/\s+/)) {
+            const ns = prefix === '' ? null : choice.lookupNamespaceURI(prefix);
+            if (ns)
+                namespaces.add(ns);
+        }
+    }
+    const located = ac;
+    const where = typeof located.lineNumber === 'number' ? ` (line ${located.lineNumber}, column ${located.columnNumber})` : '';
+    return {
+        code: 'mce.nothing_selected',
+        partName,
+        ...(typeof located.lineNumber === 'number' ? { line: located.lineNumber, column: located.columnNumber } : {}),
+        namespaces: [...namespaces],
+        removed,
+        root,
+        message: `${partName !== null && partName !== void 0 ? partName : 'a part'}${where}: mc:AlternateContent selects nothing: no Choice is understood (${[...namespaces].join(', ') || 'no namespace bound'}) and it has no Fallback, so it reads as absent (REQ-305)`,
+    };
+}
 function branchesDiffer(ac, choices, fallback, selected, understood, partName) {
     const all = fallback ? [...choices, fallback] : choices;
     if (all.length < 2 || selected === undefined)

package/dist/opc/mce/understood.d.mts

@@ -1,35 +1,3 @@
-export declare const UNDERSTOOD_NAMESPACES: ReadonlySet<string>;
-/**
- * The conventional prefixes of `UNDERSTOOD_NAMESPACES` (`NAMESPACE_PREFIXES`), the object model's namespaces
- * expressed as prefixes (CR-010 section 11.5): the unmarshalled model does not keep the declarations in
- * force at the element, so the objects package's `mcBranchOf` compares prefixes, and its default set,
- * every prefix `NAMESPACE_PREFIXES` knows, is wider than what load understands. The readers match
- * against `READ_UNDERSTOOD_PREFIXES`, this and four more. An understood namespace with no conventional
- * prefix has no entry.
- */
-export declare const UNDERSTOOD_PREFIXES: ReadonlySet<string>;
-/**
- * The namespaces a reader of a kept mc:AlternateContent counts as understood beyond `UNDERSTOOD_NAMESPACES`
- * (CR-010 section 15): Word 365 takes a Choice requiring any of them (measured 2026-10-20), and docx4j's
- * published understood list (`understood-namespaces.txt`) has all four, among the 11 its JAXB contexts
- * bind and no generated module here does. The name is CR-010's, when only the readers counted them;
- * since CR-013 (D3) resolving does too (`READ_UNDERSTOOD_NAMESPACES`). Resolving turns the Choice it takes
- * into typed content, which no module types here, but what Word writes in these namespaces survives a
- * re-marshal: in every file seen it is attributes only (`w16du:dateUtc`, `w16sdtdh:storeItemChecksum`,
- * `x14ac:dyDescent` and `x14ac:knownFonts`; `w16sdtfl` is only declared), measured 2026-10-21.
- */
-export declare const READ_ONLY_UNDERSTOOD_NAMESPACES: ReadonlySet<string>;
-/**
- * What a reader of a kept mc:AlternateContent matches `mc:Choice/@Requires` against (`selectedBranchOf`,
- * docx4j's `McMode.READ`): `UNDERSTOOD_PREFIXES` and the conventional prefixes of
- * `READ_ONLY_UNDERSTOOD_NAMESPACES`. A Choice requiring only these is taken by the gate alone, as REQ-302
- * of the text extraction specification reads, whatever its content (CR-010 section 15).
- */
-export declare const READ_UNDERSTOOD_PREFIXES: ReadonlySet<string>;
-/**
- * What load selects by, as namespaces: `UNDERSTOOD_NAMESPACES` and `READ_ONLY_UNDERSTOOD_NAMESPACES`, the
- * readers' set (`READ_UNDERSTOOD_PREFIXES`) by URI. Resolving (`mcePreprocess: true`) takes the Choice it
- * names, and the default load's `mce.branches_differ` reports it as the selected branch, so a resolved load
- * takes the branch the readers of a kept load take, as Word 365 does (CR-013 D3).
- */
-export declare const READ_UNDERSTOOD_NAMESPACES: ReadonlySet<string>;
+import { UNDERSTOOD_NAMESPACES } from '@docx4j/generated-objects-ts/builders/wml';
+export { UNDERSTOOD_NAMESPACES };
+export declare const TRAVERSAL_NAMESPACES: ReadonlySet<string>;

package/dist/opc/mce/understood.mjs

@@ -1,16 +1,18 @@
-// What "understanding" an mc:Choice means here: the namespaces whose content survives a load and
-// a save. Word takes the first mc:Choice whose Requires prefixes it all understands (ECMA-376
-// Part 3, 10.2.1), and so does this preprocessor.
+// The two sets WD REQ-306 has an extractor publish (CR-029).
 //
-// It is the defaultElementNamespaceURI of every generated module of @docx4j/generated-objects-ts
-// (0.3.0), which `mce.test.mjs` asserts so that the next regeneration announces an addition, plus
-// three groups of hand-kept entries, each marked below: namespaces no module *defaults* to but which
-// the model binds anyway (attributes, or elements a module of another namespace declares), the
-// slicer namespaces of CR-004 phase B, whose content the model does not bind at all but carries
-// through as DOM, and the chartex namespaces Office gates a chart's frame with, which nothing in the
-// Choice uses (CR-009 section 8).
-import { NAMESPACE_PREFIXES } from '@docx4j/generated-objects-ts';
-export const UNDERSTOOD_NAMESPACES = new Set([
+// `UNDERSTOOD_NAMESPACES` decides every markup compatibility question in a word-processing package: which `mc:Choice`
+// a reader takes (REQ-302), whether an element selects nothing (REQ-305), and which namespace Word doesn't know
+// (`repairBreaksOutsideRuns`, `readThroughUnknownElements`). It is what Word 365 was measured to understand, docx4j's
+// published `understood-namespaces.txt` (114 URIs at `824565363`), and it comes from the objects package, whose
+// `mcBranchOf` reads it. It is silent on spreadsheets and presentations, where a namespace not measured counts as not understood.
+//
+// `TRAVERSAL_NAMESPACES` is what this package's readers can traverse, docx4j's `traversal-namespaces.txt`, and it decides
+// nothing about selection. Its first 107 are the namespaces whose content survives a load and a save: the
+// defaultElementNamespaceURI of every generated module of @docx4j/generated-objects-ts, which `mce.test.mjs` asserts so
+// that the next regeneration announces an addition, plus the hand-kept groups marked below. The last 11 are docx4j's.
+import { UNDERSTOOD_NAMESPACES } from '@docx4j/generated-objects-ts/builders/wml';
+export { UNDERSTOOD_NAMESPACES };
+export const TRAVERSAL_NAMESPACES = new Set([
     'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
     'http://schemas.openxmlformats.org/package/2006/relationships',
     'http://schemas.openxmlformats.org/markup-compatibility/2006',
@@ -122,7 +124,7 @@ export const UNDERSTOOD_NAMESPACES = new Set([
     // holds the one unbound element, and that wildcard is lax (docx4j 8e8f6ea83), so it loads as DOM
     // and re-marshals unchanged. Taking the Choice therefore keeps the slicer or timeline; leaving
     // it would take the Fallback, an "Excel 2010 or higher" placeholder box, and lose the slicer for
-    // good. A Choice is only worth taking when everything in it round-trips (docx4j CR-021 8.9).
+    // good.
     'http://schemas.microsoft.com/office/drawing/2010/slicer',
     'http://schemas.microsoft.com/office/drawing/2012/slicer',
     'http://schemas.microsoft.com/office/drawing/2012/timeslicer',
@@ -136,44 +138,16 @@ export const UNDERSTOOD_NAMESPACES = new Set([
     // here: no file seen gates a Choice with one.
     'http://schemas.microsoft.com/office/drawing/2015/9/8/chartex',
     'http://schemas.microsoft.com/office/drawing/2015/10/21/chartex',
+    // The 11 docx4j's JAXB contexts bind and no generated module here does, in its published order.
+    'http://schemas.microsoft.com/office/drawing/2016/11/diagram',
+    'http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash',
+    'http://schemas.microsoft.com/office/word/2023/wordml/word16du',
+    'http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock',
+    'http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac',
+    'http://schemas.microsoft.com/office/spreadsheetml/2015/revision2',
+    'http://schemas.microsoft.com/office/spreadsheetml/2016/revision3',
+    'http://schemas.microsoft.com/office/spreadsheetml/2016/revision6',
+    'http://schemas.microsoft.com/office/spreadsheetml/2016/revision9',
+    'http://schemas.microsoft.com/office/spreadsheetml/2016/revision10',
+    'http://schemas.microsoft.com/office/spreadsheetml/2017/revision16',
 ]);
-const prefixesOf = (namespaces) => [...namespaces].map((uri) => NAMESPACE_PREFIXES[uri]).filter((prefix) => prefix !== undefined && prefix !== '');
-/**
- * The conventional prefixes of `UNDERSTOOD_NAMESPACES` (`NAMESPACE_PREFIXES`), the object model's namespaces
- * expressed as prefixes (CR-010 section 11.5): the unmarshalled model does not keep the declarations in
- * force at the element, so the objects package's `mcBranchOf` compares prefixes, and its default set,
- * every prefix `NAMESPACE_PREFIXES` knows, is wider than what load understands. The readers match
- * against `READ_UNDERSTOOD_PREFIXES`, this and four more. An understood namespace with no conventional
- * prefix has no entry.
- */
-export const UNDERSTOOD_PREFIXES = new Set(prefixesOf(UNDERSTOOD_NAMESPACES));
-/**
- * The namespaces a reader of a kept mc:AlternateContent counts as understood beyond `UNDERSTOOD_NAMESPACES`
- * (CR-010 section 15): Word 365 takes a Choice requiring any of them (measured 2026-10-20), and docx4j's
- * published understood list (`understood-namespaces.txt`) has all four, among the 11 its JAXB contexts
- * bind and no generated module here does. The name is CR-010's, when only the readers counted them;
- * since CR-013 (D3) resolving does too (`READ_UNDERSTOOD_NAMESPACES`). Resolving turns the Choice it takes
- * into typed content, which no module types here, but what Word writes in these namespaces survives a
- * re-marshal: in every file seen it is attributes only (`w16du:dateUtc`, `w16sdtdh:storeItemChecksum`,
- * `x14ac:dyDescent` and `x14ac:knownFonts`; `w16sdtfl` is only declared), measured 2026-10-21.
- */
-export const READ_ONLY_UNDERSTOOD_NAMESPACES = new Set([
-    'http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash', // w16sdtdh
-    'http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock', // w16sdtfl
-    'http://schemas.microsoft.com/office/word/2023/wordml/word16du', // w16du
-    'http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac', // x14ac
-]);
-/**
- * What a reader of a kept mc:AlternateContent matches `mc:Choice/@Requires` against (`selectedBranchOf`,
- * docx4j's `McMode.READ`): `UNDERSTOOD_PREFIXES` and the conventional prefixes of
- * `READ_ONLY_UNDERSTOOD_NAMESPACES`. A Choice requiring only these is taken by the gate alone, as REQ-302
- * of the text extraction specification reads, whatever its content (CR-010 section 15).
- */
-export const READ_UNDERSTOOD_PREFIXES = new Set([...UNDERSTOOD_PREFIXES, ...prefixesOf(READ_ONLY_UNDERSTOOD_NAMESPACES)]);
-/**
- * What load selects by, as namespaces: `UNDERSTOOD_NAMESPACES` and `READ_ONLY_UNDERSTOOD_NAMESPACES`, the
- * readers' set (`READ_UNDERSTOOD_PREFIXES`) by URI. Resolving (`mcePreprocess: true`) takes the Choice it
- * names, and the default load's `mce.branches_differ` reports it as the selected branch, so a resolved load
- * takes the branch the readers of a kept load take, as Word 365 does (CR-013 D3).
- */
-export const READ_UNDERSTOOD_NAMESPACES = new Set([...UNDERSTOOD_NAMESPACES, ...READ_ONLY_UNDERSTOOD_NAMESPACES]);

package/dist/opc/repair/breaks.d.mts

@@ -0,0 +1,23 @@
+import { type ContentSkippedWarning } from '../skipped.mjs';
+/**
+ * A part holding a w:br outside a w:r, or a text element holding elements, read as Word reads them (CR-021 D2): one per
+ * part, as docx4j's one WARN a part. The code and the fields are docx4j-python's (`part_name`, `breaks`,
+ * `text_elements` there), settled through the portfolio session on 2026-11-03. The counts are the stylesheet's: every
+ * w:br whose parent is a run container or w:body, and every text element holding an element, at any depth.
+ */
+export interface BrOutsideRunWarning {
+    code: 'br.outside_run';
+    partName: string | undefined;
+    /** The w:brs found directly in a run container or in w:body. */
+    breaks: number;
+    /** The w:t, w:instrText, w:delText and w:delInstrText found holding elements. */
+    textElements: number;
+    /** docx4j's WARN, after the part: "w:br outside a w:r: 2 outside a run, 1 text elements holding elements; read as Word reads them". */
+    message: string;
+}
+/**
+ * Puts each w:br found outside a w:r in a run, as Word reads it, over a part's DOM (CR-021; docx4j CR-073's three
+ * rules, above). A part whose root is not WordprocessingML's is left alone. Returns the part's warning, or nothing
+ * where the part holds none.
+ */
+export declare function repairBreaksOutsideRuns(doc: Document, partName?: string): (BrOutsideRunWarning | ContentSkippedWarning)[];