@docx4j/core-ts 0.6.0 → 0.7.0

package/dist/opc/repair/breaks.mjs

@@ -0,0 +1,288 @@
+// A w:br outside a w:r, read as Word 365 reads it (CR-021, the port of docx4j CR-073; the rules are
+// docx4j's mc-preprocessor.xslt at 95c6b42d3, its section 8). Word opens a w:br directly in a w:p, a
+// w:hyperlink or another element that holds runs, one inside a w:t or a w:instrText, and one directly
+// in w:body, with no repair, and reads each as a break at that point, all the text kept. The object
+// model has no place for one there: inside a text element the runtime refuses the whole part ("Element
+// text content may not contain START_ELEMENT"), and elsewhere it is a misplaced child (CR-016), unseen
+// by the readers and refused at save. docx4j's load survey found one in 206,351 of 3.7 million
+// documents, 89% of them a web-to-docx generator's blank line, <w:p><w:br/></w:p>.
+//
+// The pass runs over a WordprocessingML part's DOM before anything else does (`XmlPart`, ahead of the
+// package's hook, and `insertOoxml`'s fragment route; CR-021 D1):
+// 1. a w:br in a run container gets a w:r of its own, with the paragraph mark's run properties while no
+//    run precedes it in its paragraph, none after one;
+// 2. a w:t, w:instrText, w:delText or w:delInstrText holding elements becomes its stretches of text and
+//    its breaks, in order, in the same run, a w:t nested in it giving its text, any other w: element and
+//    one in a namespace Word doesn't know going with all it holds (Word check 76, CR-021 section 11; docx4j gives its text);
+// 3. a w:br directly in w:body goes into the next paragraph as its first run, with that mark's
+//    properties, else becomes a paragraph of its own.
+// Each rule is decided on the tree as read, as the stylesheet's templates are, before anything moves.
+// A clean part pays one walk over its DOM, which allocates nothing (CR-021 section 2: 0.4% of a load).
+import { childElements } from '../../xml/dom.mjs';
+import { UNDERSTOOD_NAMESPACES } from '../mce/understood.mjs';
+import { skippedElement } from '../skipped.mjs';
+const W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const XML_NS = 'http://www.w3.org/XML/1998/namespace';
+/** The run containers rule 1 takes a w:br from; named, since a math run (`m:r`) holds a w:br legally. */
+const RUN_CONTAINERS = new Set(['p', 'hyperlink', 'smartTag', 'customXml', 'fldSimple', 'ins', 'del', 'moveFrom', 'moveTo', 'sdtContent', 'dir', 'bdo']);
+/**
+ * The paragraph-or-block ancestors: rule 1 takes a w:br only where the nearest is a w:p, so a block-level
+ * w:sdtContent or w:customXml is not taken for an inline one.
+ */
+const BLOCKS = new Set(['p', 'body', 'tc', 'txbxContent', 'hdr', 'ftr', 'footnote', 'endnote', 'comment', 'docPartBody']);
+/** The text elements rule 2 splits. */
+const TEXTS = new Set(['t', 'instrText', 'delText', 'delInstrText']);
+/** What only a paragraph mark's run properties hold, left out of a run's. */
+const MARK_ONLY = new Set(['ins', 'del', 'moveFrom', 'moveTo', 'rPrChange']);
+/**
+ * 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 function repairBreaksOutsideRuns(doc, partName) {
+    var _a, _b;
+    const root = doc.documentElement;
+    if (!root || root.namespaceURI !== W)
+        return [];
+    let breaks;
+    let texts;
+    let textElements = 0;
+    for (let n = root; n !== null;) {
+        if (n.nodeType === 1) {
+            const e = n;
+            if (e.namespaceURI === W) {
+                const local = e.localName;
+                if (local === 'br') {
+                    const parent = e.parentNode;
+                    if (parent.namespaceURI === W && (RUN_CONTAINERS.has(parent.localName) || parent.localName === 'body'))
+                        (breaks !== null && breaks !== void 0 ? breaks : (breaks = [])).push(e);
+                }
+                else if (TEXTS.has(local) && holdsElement(e)) {
+                    textElements++;
+                    if (!insideText(e))
+                        (texts !== null && texts !== void 0 ? texts : (texts = [])).push(e);
+                }
+            }
+            if (e.firstChild !== null) {
+                n = e.firstChild;
+                continue;
+            }
+        }
+        while (n !== root && n.nextSibling === null)
+            n = n.parentNode;
+        n = n === root ? null : n.nextSibling;
+    }
+    if (breaks === undefined && texts === undefined)
+        return [];
+    // decided on the tree as read; a break inside a text element is rule 2's
+    const inRuns = [];
+    const inBody = [];
+    for (const br of breaks !== null && breaks !== void 0 ? breaks : []) {
+        if (insideText(br))
+            continue;
+        if (br.parentNode.localName === 'body') {
+            const next = nextBlock(br);
+            const p = next !== undefined && takesBodyBreaks(next) ? next : undefined;
+            inBody.push({ br, p, rPr: p && markRunProperties(p) });
+            continue;
+        }
+        const p = paragraphOf(br);
+        if (p !== undefined)
+            inRuns.push({ br, rPr: runPrecedes(br, p) ? undefined : markRunProperties(p) });
+    }
+    // (3) first, each paragraph's place for its breaks fixed before any goes in: after its w:pPr, in order
+    const places = new Map();
+    for (const { br, p, rPr } of inBody) {
+        const r = create(br, 'r');
+        if (rPr)
+            r.appendChild(rPr);
+        if (p === undefined) {
+            const own = create(br, 'p');
+            br.parentNode.insertBefore(own, br);
+            own.appendChild(r);
+        }
+        else {
+            if (!places.has(p)) {
+                const pPr = childElements(p).find((c) => c.namespaceURI === W && c.localName === 'pPr');
+                places.set(p, pPr ? pPr.nextSibling : p.firstChild);
+            }
+            p.insertBefore(r, (_a = places.get(p)) !== null && _a !== void 0 ? _a : null);
+        }
+        r.appendChild(bare(br));
+    }
+    // (1)
+    for (const { br, rPr } of inRuns) {
+        const r = create(br, 'r');
+        if (rPr)
+            r.appendChild(rPr);
+        br.parentNode.insertBefore(r, br);
+        r.appendChild(bare(br));
+    }
+    // (2)
+    const skipped = [];
+    for (const t of texts !== null && texts !== void 0 ? texts : [])
+        splitText(t, skipped, partName);
+    const outside = (_b = breaks === null || breaks === void 0 ? void 0 : breaks.length) !== null && _b !== void 0 ? _b : 0;
+    return [{
+            code: 'br.outside_run',
+            partName,
+            breaks: outside,
+            textElements,
+            message: `${partName !== null && partName !== void 0 ? partName : 'a part'}: w:br outside a w:r: ${outside} outside a run, ${textElements} text elements holding elements; read as Word reads them`,
+        }, ...skipped];
+}
+function holdsElement(e) {
+    for (let c = e.firstChild; c !== null; c = c.nextSibling)
+        if (c.nodeType === 1)
+            return true;
+    return false;
+}
+function insideText(node) {
+    for (let a = node.parentNode; a !== null && a.nodeType === 1; a = a.parentNode) {
+        if (a.namespaceURI === W && TEXTS.has(a.localName))
+            return true;
+    }
+    return false;
+}
+/** The break's paragraph, where its nearest paragraph-or-block ancestor is one. */
+function paragraphOf(br) {
+    for (let a = br.parentNode; a !== null && a.nodeType === 1; a = a.parentNode) {
+        const e = a;
+        if (e.namespaceURI === W && BLOCKS.has(e.localName))
+            return e.localName === 'p' ? e : undefined;
+    }
+    return undefined;
+}
+/** True where a run precedes the break in its paragraph: on its path from the paragraph, an earlier sibling is or holds one. */
+function runPrecedes(br, p) {
+    for (let n = br; n !== p; n = n.parentNode) {
+        for (let s = n.previousSibling; s !== null; s = s.previousSibling) {
+            if (s.nodeType !== 1)
+                continue;
+            const e = s;
+            if ((e.namespaceURI === W && e.localName === 'r') || e.getElementsByTagNameNS(W, 'r').length > 0)
+                return true;
+        }
+    }
+    return false;
+}
+/** The paragraph mark's run properties as a run's, a copy: without what only a mark has; undefined where none is left. */
+function markRunProperties(p) {
+    let rPr;
+    for (const pPr of childElements(p)) {
+        if (pPr.namespaceURI !== W || pPr.localName !== 'pPr')
+            continue;
+        for (const markPr of childElements(pPr)) {
+            if (markPr.namespaceURI !== W || markPr.localName !== 'rPr')
+                continue;
+            for (const property of childElements(markPr)) {
+                if (property.namespaceURI === W && MARK_ONLY.has(property.localName))
+                    continue;
+                (rPr !== null && rPr !== void 0 ? rPr : (rPr = create(p, 'rPr'))).appendChild(property.cloneNode(true));
+            }
+        }
+    }
+    return rPr;
+}
+/** The first element after a body-level break that is not one. */
+function nextBlock(br) {
+    for (let s = br.nextSibling; s !== null; s = s.nextSibling) {
+        if (s.nodeType !== 1)
+            continue;
+        const e = s;
+        if (!(e.namespaceURI === W && e.localName === 'br'))
+            return e;
+    }
+    return undefined;
+}
+/**
+ * A w:p the body's breaks before it go into. Not one docx4j splits by its nested-paragraph rule (a w:p in a w:hyperlink
+ * or a w:r), which this package doesn't port: there, as in docx4j, each break is a paragraph of its own.
+ */
+function takesBodyBreaks(e) {
+    if (e.namespaceURI !== W || e.localName !== 'p')
+        return false;
+    for (const c of childElements(e)) {
+        if (c.namespaceURI !== W || (c.localName !== 'hyperlink' && c.localName !== 'r'))
+            continue;
+        for (const d of childElements(c)) {
+            if (d.namespaceURI !== W)
+                continue;
+            if (d.localName === 'p')
+                return false;
+            if (d.localName === 'r' && childElements(d).some((x) => x.namespaceURI === W && x.localName === 'p'))
+                return false;
+        }
+    }
+    return true;
+}
+/** The break as the stylesheet writes it: its attributes, no content. */
+function bare(br) {
+    while (br.firstChild !== null)
+        br.removeChild(br.firstChild);
+    return br;
+}
+/** A WordprocessingML element under the prefix the part gives `like`, which is in that namespace. */
+function create(like, local) {
+    return like.ownerDocument.createElementNS(W, like.prefix ? `${like.prefix}:${local}` : local);
+}
+/**
+ * Rule 2: the text element's stretches of text, each under its name, and its w:brs, in order, in its place. A
+ * stretch is XPath's text node (adjacent text and CDATA together), its `xml:space` the nearest ancestor's, and kept
+ * only where that preserves it or it holds more than whitespace. Any other element gives its text only as `givesItsText` says.
+ */
+function splitText(t, skipped, partName) {
+    const out = [];
+    const visit = (holder) => {
+        for (let c = holder.firstChild; c !== null;) {
+            if (c.nodeType === 3 || c.nodeType === 4) {
+                let text = '';
+                for (; c !== null && (c.nodeType === 3 || c.nodeType === 4); c = c.nextSibling)
+                    text += c.data;
+                const space = spaceOf(holder);
+                if (space === 'preserve' || /[^ \t\r\n]/.test(text)) {
+                    const piece = create(t, t.localName);
+                    if (space !== '')
+                        piece.setAttributeNS(XML_NS, 'xml:space', space);
+                    piece.appendChild(t.ownerDocument.createTextNode(text));
+                    out.push(piece);
+                }
+                continue;
+            }
+            if (c.nodeType === 1) {
+                const e = c;
+                if (e.namespaceURI === W && e.localName === 'br')
+                    out.push(bare(e));
+                else if (givesItsText(e))
+                    visit(e);
+                else
+                    skipped.push(skippedElement(e, partName)); // the runtime never sees it (CR-025 D9)
+            }
+            c = c.nextSibling;
+        }
+    };
+    visit(t);
+    const parent = t.parentNode;
+    for (const piece of out)
+        parent.insertBefore(piece, t);
+    parent.removeChild(t);
+}
+/**
+ * Whether an element in a text element gives its text (CR-021 section 11). As Word 365 reads it, a nested text element does, and
+ * any other w: element and one in a namespace Word doesn't know go with all they hold (check 76's `76n`, `76u`, `76w`, `76z`). Word
+ * refuses an element in no namespace (`76x`, `76y`), so docx4j's reading stands there; a namespace Word knows is unmeasured.
+ */
+function givesItsText(e) {
+    const namespace = e.namespaceURI;
+    if (namespace === W)
+        return TEXTS.has(e.localName);
+    return !namespace || UNDERSTOOD_NAMESPACES.has(namespace);
+}
+function spaceOf(holder) {
+    var _a;
+    for (let a = holder; a !== null && a.nodeType === 1; a = a.parentNode) {
+        if (a.hasAttributeNS(XML_NS, 'space'))
+            return (_a = a.getAttributeNS(XML_NS, 'space')) !== null && _a !== void 0 ? _a : '';
+    }
+    return '';
+}

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

@@ -0,0 +1,12 @@
+export declare const W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+export declare const M = "http://schemas.openxmlformats.org/officeDocument/2006/math";
+export declare const MC = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+/** The twenty hosts check 76 measured. */
+export declare const HOSTS: ReadonlySet<string>;
+/** The same names under parents that make them something else, none measured: no host there (WD REQ-308's NOTE). */
+export declare const NOT_A_HOST_UNDER: Readonly<Record<string, readonly (readonly [string, string])[]>>;
+export declare const isW: (e: Element, local: string) => boolean;
+export declare const isUnknown: (e: Element) => boolean;
+export declare const isBranch: (e: Element) => boolean;
+/** The content host `parent` is, through a kept branch (`76t44`, `76t45`); undefined for anything else, another namespace's element above all (`76k`). */
+export declare function hostOf(parent: Element): Element | undefined;

package/dist/opc/repair/hosts.mjs

@@ -0,0 +1,33 @@
+// The content hosts an unknown w: element is read through in (CR-026 section 3.7), apart from the pass, so that CR-025 section 10's
+// classes can name them without importing the pass, which imports the report.
+import { WML_ELEMENT_NAMES } from './wmlNames.generated.mjs';
+export const W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+export const M = 'http://schemas.openxmlformats.org/officeDocument/2006/math';
+export const MC = 'http://schemas.openxmlformats.org/markup-compatibility/2006';
+/** The twenty hosts check 76 measured. */
+export const HOSTS = new Set(['p', 'body', 'tc', 'r', 'tbl', 'tr', 'sdtContent', 'hyperlink', 'ins', 'del', 'moveFrom', 'moveTo',
+    'hdr', 'ftr', 'comment', 'fldSimple', 'smartTag', 'customXml', 'footnote', 'endnote']);
+/** The same names under parents that make them something else, none measured: no host there (WD REQ-308's NOTE). */
+export const NOT_A_HOST_UNDER = {
+    ins: [[W, 'numPr'], [W, 'rPr'], [W, 'trPr'], [M, 'r'], [M, 'ctrlPr']],
+    del: [[W, 'rPr'], [W, 'trPr'], [M, 'r'], [M, 'ctrlPr']],
+    moveFrom: [[W, 'rPr']],
+    moveTo: [[W, 'rPr']],
+    footnote: [[W, 'footnotePr']],
+    endnote: [[W, 'endnotePr']],
+};
+export const isW = (e, local) => e.namespaceURI === W && e.localName === local;
+export const isUnknown = (e) => e.namespaceURI === W && !WML_ELEMENT_NAMES.has(e.localName);
+export const isBranch = (e) => e.namespaceURI === MC && (e.localName === 'Choice' || e.localName === 'Fallback' || e.localName === 'AlternateContent');
+/** The content host `parent` is, through a kept branch (`76t44`, `76t45`); undefined for anything else, another namespace's element above all (`76k`). */
+export function hostOf(parent) {
+    var _a;
+    let host = parent;
+    while (isBranch(host))
+        host = host.parentNode;
+    if (host.namespaceURI !== W || !HOSTS.has(host.localName))
+        return undefined;
+    const above = host.parentNode;
+    const excluded = (_a = NOT_A_HOST_UNDER[host.localName]) === null || _a === void 0 ? void 0 : _a.some(([ns, local]) => (above === null || above === void 0 ? void 0 : above.namespaceURI) === ns && above.localName === local);
+    return excluded ? undefined : host;
+}

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

@@ -0,0 +1,19 @@
+import { type ContentSkippedWarning } from '../skipped.mjs';
+/**
+ * `part.unexpected_root` (WD REQ-320): a main document part whose root Word opens and shows nothing of, such as `w:hdr`,
+ * `w:styles` or an element in a namespace its `mc:Ignorable` names. It reads as an empty document, and a write through `Body` is
+ * refused (CR-028 D10). `root` is the root's qualified name, as the file spells it. The root is also a `part.skipped`, so a save
+ * copies the part as written while it is unchanged, and CR-025's gate refuses one that changed.
+ */
+export interface UnexpectedRootWarning {
+    code: 'part.unexpected_root';
+    partName: string;
+    root: string;
+    message: string;
+}
+/**
+ * Reads the root of a main document part's DOM: a root Word reads becomes a `w:document` holding a `w:body`, a root Word refuses
+ * throws `PartUnmarshalException`, and any other gives an empty document with `part.unexpected_root`. A `w:document` and an
+ * `mc:AlternateContent` are left alone. Returns the warnings: what a read root dropped, as `part.skipped`, or the unexpected root.
+ */
+export declare function readMainPartRoot(doc: Document, partName: string): (UnexpectedRootWarning | ContentSkippedWarning)[];

package/dist/opc/repair/mainRoot.mjs

@@ -0,0 +1,168 @@
+// A main document part whose root isn't w:document, read as WD REQ-318 to REQ-320 have it (CR-028 D10 and D11; docx4j CR-079,
+// python CR-039). Word reads some such roots as a document, refuses some, and opens the rest showing nothing. The pass runs on
+// the DOM ahead of CR-026's and of the runtime, so a root it reads reaches them as a w:document holding a w:body.
+// mc:AlternateContent as the root is REQ-317's, and left as it is.
+import { PartUnmarshalException } from '../exceptions.mjs';
+import { skippedElement, UNMEASURED } from '../skipped.mjs';
+import { UNDERSTOOD_NAMESPACES } from '../mce/understood.mjs';
+import { WML_ELEMENT_NAMES } from './wmlNames.generated.mjs';
+const W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const MC = 'http://schemas.openxmlformats.org/markup-compatibility/2006';
+const WORD_2003 = 'http://schemas.microsoft.com/office/word/2003/wordml';
+const XML_PACKAGE = 'http://schemas.microsoft.com/office/2006/xmlPackage';
+const XMLNS = 'http://www.w3.org/2000/xmlns/';
+/**
+ * Reads the root of a main document part's DOM: a root Word reads becomes a `w:document` holding a `w:body`, a root Word refuses
+ * throws `PartUnmarshalException`, and any other gives an empty document with `part.unexpected_root`. A `w:document` and an
+ * `mc:AlternateContent` are left alone. Returns the warnings: what a read root dropped, as `part.skipped`, or the unexpected root.
+ */
+export function readMainPartRoot(doc, partName) {
+    const root = doc.documentElement;
+    if (!root)
+        return [];
+    if (isW(root, 'document') || (root.namespaceURI === MC && root.localName === 'AlternateContent'))
+        return [];
+    if (refused(root)) {
+        throw new PartUnmarshalException(`${partName}: its root, ${root.nodeName}, is one Word refuses a document for (WD REQ-318)`, partName);
+    }
+    const body = bodyFrom(root, partName);
+    if (body) {
+        replaceRoot(doc, root, body.body);
+        return body.skipped;
+    }
+    const skipped = skippedElement(root, partName);
+    replaceRoot(doc, root, doc.createElementNS(W, 'w:body'));
+    return [{
+            code: 'part.unexpected_root',
+            partName,
+            root: root.nodeName,
+            message: `${partName}: its root, ${root.nodeName}, is one Word opens showing nothing of, so it reads as an empty document (WD REQ-320)`,
+        }, skipped];
+}
+/** WD REQ-318: a root Word refuses, by its name or by what it holds. */
+function refused(root) {
+    const ns = root.namespaceURI;
+    const local = root.localName;
+    if (ns === W && (local === 'footnotes' || local === 'endnotes' || local === 'tc' || local === 'txbxContent'))
+        return true;
+    if ((ns === WORD_2003 && local === 'wordDocument') || (ns === XML_PACKAGE && local === 'package'))
+        return true;
+    if (isW(root, 'sdtContent'))
+        return childrenOf(root).some((c) => isW(c, 'tr') || (isW(c, 'sdt') && sdtLevel(c) === 'row'));
+    if (ns === W && !WML_ELEMENT_NAMES.has(local)) {
+        return childrenOf(root).some((c) => isW(c, 'document') || isW(c, 'r') || (isW(c, 'sdt') && sdtLevel(c) === 'run'));
+    }
+    if (ns !== null && (ns === W || UNDERSTOOD_NAMESPACES.has(ns)))
+        return false;
+    return !ignorable(root) && childrenOf(root).some((c) => isW(c, 'document') || isW(c, 'p'));
+}
+/**
+ * WD REQ-319: the `w:body` a root Word reads stands for, made from what it holds, and what that dropped; undefined for a root
+ * Word doesn't read (REQ-320).
+ */
+function bodyFrom(root, partName) {
+    const doc = root.ownerDocument;
+    const wrap = (nodes) => {
+        const body = doc.createElementNS(W, 'w:body');
+        for (const n of nodes)
+            body.appendChild(n);
+        return body;
+    };
+    if (isW(root, 'body'))
+        return { body: root, skipped: [] };
+    if (isW(root, 'p') || (isW(root, 'sdt') && sdtLevel(root) === 'block'))
+        return { body: wrap([root]), skipped: [] };
+    if (isW(root, 'sdtContent'))
+        return { body: wrap(nodesOf(root)), skipped: [] };
+    if (root.namespaceURI !== W || WML_ELEMENT_NAMES.has(root.localName))
+        return undefined;
+    const children = childrenOf(root);
+    const held = children.find((c) => isW(c, 'body'));
+    if (held) {
+        // that body is the body, its w:sectPr read (mr-15); what stands beside it nothing measures, so it goes and is said to
+        const skipped = children.filter((c) => c !== held).map((c) => skippedElement(c, partName, undefined, UNMEASURED));
+        return { body: held, skipped };
+    }
+    if (children.length > 0 && !children.some(readsAsBody))
+        return undefined;
+    // a w:sectPr directly in it has no effect (mr-11), so it goes, said as CR-026 D10 says a w:sectPr it drops
+    const sections = children.filter((c) => isW(c, 'sectPr'));
+    const skipped = sections.map((c) => skippedElement(c, partName));
+    for (const s of sections)
+        root.removeChild(s);
+    return { body: wrap(nodesOf(root)), skipped };
+}
+/** What an unknown `w:` root holds that makes Word read it as a body (WD REQ-319). */
+function readsAsBody(c) {
+    if (isW(c, 'p') || isW(c, 'tbl') || (isW(c, 'sdt') && sdtLevel(c) === 'block'))
+        return true;
+    if (c.namespaceURI === MC && c.localName === 'AlternateContent')
+        return true;
+    return c.namespaceURI === W && !WML_ELEMENT_NAMES.has(c.localName);
+}
+/**
+ * Puts a `w:document` holding `body` where `root` stood. The root's namespace declarations are copied onto it, so a prefix only
+ * the root bound still resolves, and its `mc:` attributes moved there, so its `mc:Ignorable` still stands and a root kept as the
+ * body or its paragraph holds none the model has no place for. `body` may be the root, or hold it.
+ */
+function replaceRoot(doc, root, body) {
+    const document = doc.createElementNS(W, 'w:document');
+    const moved = [];
+    for (let i = 0; i < root.attributes.length; i++) {
+        const a = root.attributes.item(i);
+        if (a.namespaceURI === XMLNS || a.namespaceURI === MC)
+            document.setAttributeNS(a.namespaceURI, a.name, a.value);
+        if (a.namespaceURI === MC)
+            moved.push(a);
+    }
+    for (const a of moved)
+        root.removeAttributeNode(a);
+    if (root.parentNode === doc)
+        doc.removeChild(root);
+    if (body.parentNode && body.parentNode !== document)
+        body.parentNode.removeChild(body);
+    document.appendChild(body);
+    doc.appendChild(document);
+}
+/** The level a `w:sdt` stands at, by what its `w:sdtContent` holds first that says: an empty one is taken as a block. */
+function sdtLevel(sdt) {
+    const content = childrenOf(sdt).find((c) => isW(c, 'sdtContent'));
+    for (const c of content ? childrenOf(content) : []) {
+        if (isW(c, 'p') || isW(c, 'tbl') || isW(c, 'altChunk'))
+            return 'block';
+        if (isW(c, 'tr'))
+            return 'row';
+        if (isW(c, 'tc'))
+            return 'cell';
+        if (isW(c, 'r') || isW(c, 'hyperlink') || isW(c, 'fldSimple') || isW(c, 'smartTag') || isW(c, 'ins') || isW(c, 'del'))
+            return 'run';
+        if (isW(c, 'sdt'))
+            return sdtLevel(c);
+    }
+    return 'block';
+}
+/** Whether the root's own namespace is one its `mc:Ignorable` names. */
+function ignorable(root) {
+    var _a;
+    const ns = root.namespaceURI;
+    if (!ns)
+        return false;
+    const listed = (_a = root.getAttributeNS(MC, 'Ignorable')) !== null && _a !== void 0 ? _a : '';
+    return listed.trim().split(/\s+/).some((prefix) => prefix !== '' && root.lookupNamespaceURI(prefix) === ns);
+}
+function isW(el, local) {
+    return el.namespaceURI === W && el.localName === local;
+}
+function childrenOf(el) {
+    const out = [];
+    for (let c = el.firstChild; c; c = c.nextSibling)
+        if (c.nodeType === 1)
+            out.push(c);
+    return out;
+}
+function nodesOf(el) {
+    const out = [];
+    for (let c = el.firstChild; c; c = c.nextSibling)
+        out.push(c);
+    return out;
+}

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

@@ -0,0 +1,8 @@
+import { type ContentSkippedWarning } from '../skipped.mjs';
+/** Reads a part's unknown w: elements as Word does, reporting each it takes. What it leaves, the runtime skips and reports. */
+export declare function readThroughUnknownElements(doc: Document, partName?: string): ContentSkippedWarning[];
+/**
+ * The elements a caller's fragment holds that Word doesn't know, for `insertOoxml` to refuse (D12): an unknown w: element, and
+ * under a w: element one of a namespace the reader doesn't understand. What a w:t holds counts: CR-021's pass would remove it unreported.
+ */
+export declare function unknownElementsIn(doc: Document): Element[];