@docx4j/core-ts 0.5.0 → 0.7.0

package/dist/opc/repair/unknownElements.mjs

@@ -0,0 +1,180 @@
+// An element Word doesn't know, read as Word 365 reads it (CR-026 section 3.7, D7 to D12; WD REQ-308 to REQ-316; check 76). The pass
+// runs on the DOM ahead of CR-021's and of the runtime, which drops what it isn't given a place for. An unknown w: element in a
+// content host loses its tags and keeps what it holds. A run in one in a paragraph's w:pPr goes to the head of the paragraph. A w:p
+// in one, last in a w:p with a run before it, ends that paragraph. Everything else is left for the runtime to skip and report.
+import { childElements } from '../../xml/dom.mjs';
+import { dropped, skippedElement, skippedText } from '../skipped.mjs';
+import { UNDERSTOOD_NAMESPACES } from '../mce/understood.mjs';
+import { W, MC, isUnknown, isW, hostOf } from './hosts.mjs';
+function outermostUnknown(root) {
+    const found = [];
+    const visit = (e) => {
+        for (const c of childElements(e)) {
+            if (isUnknown(c))
+                found.push(c);
+            else
+                visit(c);
+        }
+    };
+    visit(root);
+    return found;
+}
+/** What `e` holds with any unknown element in it taken away, in order. */
+function heldElements(e) {
+    return childElements(e).flatMap((c) => (isUnknown(c) ? heldElements(c) : [c]));
+}
+/** What the pass takes is Word's own reading, and Word's save holds the same: written without it, never refused (CR-025 section 10). */
+const READ_THROUGH = dropped('REQ-308');
+function reportAll(e, skipped, partName) {
+    skipped.push(skippedElement(e, partName, undefined, READ_THROUGH));
+    for (const c of childElements(e))
+        if (isUnknown(c))
+            reportAll(c, skipped, partName);
+}
+function reportText(e, skipped, partName) {
+    for (let c = e.firstChild; c !== null; c = c.nextSibling) {
+        if ((c.nodeType === 3 || c.nodeType === 4) && /[^ \t\r\n]/.test(c.data))
+            skipped.push(skippedText(c.data, c, partName));
+        if (c.nodeType === 1 && isUnknown(c))
+            reportText(c, skipped, partName);
+    }
+}
+/** `e`'s tags gone and what it holds in its place, any text with them: text in no run goes (REQ-314). */
+function unwrap(e) {
+    const parent = e.parentNode;
+    for (const held of heldElements(e))
+        parent.insertBefore(held, e);
+    parent.removeChild(e);
+}
+const insideAParagraph = (host) => {
+    for (let n = host; n !== null && n.nodeType === 1; n = n.parentNode)
+        if (isW(n, 'p'))
+            return true;
+    return false;
+};
+/**
+ * REQ-316, D11: a w:p in the element, last in its w:p, with a run before it, ends that paragraph, the held w:p's mark taking the
+ * host's place. The host takes the held w:p's properties if it has any, a further held w:p stands alone, and what's left of the host
+ * is an empty paragraph with the host's properties (`76t43`, `76t56`, `76t58`, `76t68`, `76t69`). Word refuses every other place.
+ */
+function endHost(e, host, held) {
+    const doc = host.ownerDocument;
+    const pPrOf = (p) => childElements(p).find((c) => isW(c, 'pPr'));
+    const [first, ...further] = held;
+    const hostPPr = pPrOf(host);
+    const firstPPr = pPrOf(first);
+    host.removeChild(e);
+    for (let c = first.firstChild; c !== null;) {
+        const next = c.nextSibling;
+        if (c !== firstPPr)
+            host.appendChild(c);
+        c = next;
+    }
+    if (firstPPr) {
+        if (hostPPr)
+            host.removeChild(hostPPr);
+        host.insertBefore(firstPPr, host.firstChild);
+    }
+    const parent = host.parentNode;
+    const after = host.nextSibling;
+    for (const p of further)
+        parent.insertBefore(p, after);
+    const rest = doc.createElementNS(W, host.prefix ? `${host.prefix}:p` : 'p');
+    if (hostPPr)
+        rest.appendChild(firstPPr ? hostPPr : hostPPr.cloneNode(true));
+    parent.insertBefore(rest, after);
+}
+/** The paragraph a w:pPr, or a w:sectPr in one, belongs to, through a w:pPrChange (`76t40`, `76t50`). */
+function paragraphOfProperties(parent) {
+    var _a;
+    let n = parent;
+    const sectPr = isW(n, 'sectPr') ? n : undefined;
+    if (sectPr)
+        n = sectPr.parentNode;
+    if (!n || !isW(n, 'pPr'))
+        return undefined;
+    n = n.parentNode;
+    if (n && isW(n, 'pPrChange')) {
+        n = (_a = n.parentNode) === null || _a === void 0 ? void 0 : _a.parentNode;
+    }
+    return n && isW(n, 'p') ? { paragraph: n, sectPr } : undefined;
+}
+/** REQ-311, D8 to D10: runs in the element go to the head of the paragraph, in order; a property goes with the element. */
+function runsToHead(e, at, heads, skipped, partName) {
+    var _a;
+    const runs = childElements(e).filter((c) => isW(c, 'r'));
+    if (runs.length === 0)
+        return;
+    const { paragraph, sectPr } = at;
+    const stays = childElements(e).some((c) => !isW(c, 'r'));
+    if (!stays)
+        skipped.push(skippedElement(e, partName, undefined, dropped('76t27')));
+    if (!heads.has(paragraph)) {
+        const pPr = childElements(paragraph).find((c) => isW(c, 'pPr'));
+        heads.set(paragraph, pPr ? pPr.nextSibling : paragraph.firstChild);
+    }
+    const head = (_a = heads.get(paragraph)) !== null && _a !== void 0 ? _a : null;
+    for (const r of runs)
+        paragraph.insertBefore(r, head);
+    if (!stays)
+        e.parentNode.removeChild(e);
+    if (sectPr) {
+        skipped.push(skippedElement(sectPr, partName, undefined, dropped('76t50')));
+        sectPr.parentNode.removeChild(sectPr);
+    }
+}
+/** Reads a part's unknown w: elements as Word does, reporting each it takes. What it leaves, the runtime skips and reports. */
+export function readThroughUnknownElements(doc, partName) {
+    const root = doc.documentElement;
+    if (!root || root.namespaceURI !== W)
+        return [];
+    const found = outermostUnknown(root);
+    if (found.length === 0)
+        return [];
+    const skipped = [];
+    const heads = new Map();
+    for (const e of found) {
+        const parent = e.parentNode;
+        const host = hostOf(parent);
+        if (!host) {
+            const at = paragraphOfProperties(parent);
+            if (at)
+                runsToHead(e, at, heads, skipped, partName);
+            continue;
+        }
+        const held = heldElements(e);
+        if (held.some((c) => isW(c, 'p')) && insideAParagraph(host)) {
+            const inHost = childElements(host);
+            const last = inHost[inHost.length - 1] === e;
+            const runBefore = inHost.slice(0, -1).some((c) => isW(c, 'r'));
+            if (!isW(host, 'p') || parent !== host || !last || !runBefore || !held.every((c) => isW(c, 'p')))
+                continue; // Word refuses, or nothing measures it
+            reportAll(e, skipped, partName);
+            endHost(e, host, held);
+            continue;
+        }
+        reportAll(e, skipped, partName);
+        reportText(e, skipped, partName);
+        unwrap(e);
+    }
+    return skipped;
+}
+/**
+ * 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 function unknownElementsIn(doc) {
+    const out = [];
+    const visit = (e) => {
+        for (const c of childElements(e)) {
+            const foreign = e.namespaceURI === W && c.namespaceURI !== null && c.namespaceURI !== W && c.namespaceURI !== MC && !UNDERSTOOD_NAMESPACES.has(c.namespaceURI);
+            if (isUnknown(c) || foreign)
+                out.push(c);
+            else
+                visit(c);
+        }
+    };
+    if (doc.documentElement)
+        visit(doc.documentElement);
+    return out;
+}

package/dist/opc/repair/wmlNames.generated.d.mts

@@ -0,0 +1,2 @@
+/** Every element name the WordprocessingML schema declares: 605. */
+export declare const WML_ELEMENT_NAMES: ReadonlySet<string>;

package/dist/opc/repair/wmlNames.generated.mjs

@@ -0,0 +1,80 @@
+// Generated by scripts/generate-wml-names.mjs from docx4j's wml.xsd (sha256 191a5132795cdf83). Do not edit.
+/** Every element name the WordprocessingML schema declares: 605. */
+export const WML_ELEMENT_NAMES = new Set([
+    'abstractNum', 'abstractNumId', 'active', 'activeRecord', 'activeWritingStyle', 'addressFieldName', 'adjustLineHeightInTable', 'adjustRightInd',
+    'alias', 'aliases', 'alignBordersAndEdges', 'alignTablesRowByRow', 'allowPNG', 'allowSpaceOfSameStyleInTable', 'altChunk', 'altChunkPr',
+    'altName', 'alwaysMergeEmptyNamespace', 'alwaysShowPlaceholderText', 'annotationRef', 'applyBreakingRules', 'attachedSchema', 'attachedTemplate', 'attr',
+    'autoCaption', 'autoCaptions', 'autoFormatOverride', 'autoHyphenation', 'autoRedefine', 'autoSpaceDE', 'autoSpaceDN', 'autoSpaceLikeWord95',
+    'autofitToFirstFixedWidthCell', 'b', 'bCs', 'background', 'balanceSingleByteDoubleByteWidth', 'bar', 'basedOn', 'bdo',
+    'bdr', 'behavior', 'behaviors', 'between', 'bibliography', 'bidi', 'bidiVisual', 'blockQuote',
+    'body', 'bodyDiv', 'bookFoldPrinting', 'bookFoldPrintingSheets', 'bookFoldRevPrinting', 'bookmarkEnd', 'bookmarkStart', 'bordersDoNotSurroundFooter',
+    'bordersDoNotSurroundHeader', 'bottom', 'br', 'cachedColBalance', 'calcOnExit', 'calendar', 'cantSplit', 'caps',
+    'caption', 'captions', 'category', 'cellDel', 'cellIns', 'cellMerge', 'characterSpacingControl', 'charset',
+    'checkBox', 'checkErrors', 'checked', 'citation', 'clickAndTypeStyle', 'clrSchemeMapping', 'cnfStyle', 'col',
+    'colDelim', 'color', 'cols', 'column', 'comboBox', 'comment', 'commentRangeEnd', 'commentRangeStart',
+    'commentReference', 'comments', 'compat', 'compatSetting', 'connectString', 'consecutiveHyphenLimit', 'contextualSpacing', 'continuationSeparator',
+    'control', 'convMailMergeEsc', 'cr', 'cs', 'customXml', 'customXmlDelRangeEnd', 'customXmlDelRangeStart', 'customXmlInsRangeEnd',
+    'customXmlInsRangeStart', 'customXmlMoveFromRangeEnd', 'customXmlMoveFromRangeStart', 'customXmlMoveToRangeEnd', 'customXmlMoveToRangeStart', 'customXmlPr', 'dataBinding', 'dataSource',
+    'dataType', 'date', 'dateFormat', 'dayLong', 'dayShort', 'ddList', 'decimalSymbol', 'default',
+    'defaultTabStop', 'defaultTableStyle', 'del', 'delInstrText', 'delText', 'description', 'destination', 'dir',
+    'dirty', 'displayBackgroundShape', 'displayHangulFixedWidth', 'displayHorizontalDrawingGridEvery', 'displayVerticalDrawingGridEvery', 'div', 'divBdr', 'divId',
+    'divs', 'divsChild', 'doNotAutoCompressPictures', 'doNotAutofitConstrainedTables', 'doNotBreakConstrainedForcedTable', 'doNotBreakWrappedTables', 'doNotDemarcateInvalidXml', 'doNotDisplayPageBoundaries',
+    'doNotEmbedSmartTags', 'doNotExpandShiftReturn', 'doNotHyphenateCaps', 'doNotIncludeSubdocsInStats', 'doNotLeaveBackslashAlone', 'doNotOrganizeInFolder', 'doNotRelyOnCSS', 'doNotSaveAsSingleFile',
+    'doNotShadeFormData', 'doNotSnapToGridInCell', 'doNotSuppressBlankLines', 'doNotSuppressIndentation', 'doNotSuppressParagraphBorders', 'doNotTrackFormatting', 'doNotTrackMoves', 'doNotUseEastAsianBreakRules',
+    'doNotUseHTMLParagraphAutoSpacing', 'doNotUseIndentAsNumberingTabStop', 'doNotUseLongFileNames', 'doNotUseMarginsForDrawingGridOrigin', 'doNotValidateAgainstSchema', 'doNotVertAlignCellWithSp', 'doNotVertAlignInTxbx', 'doNotWrapTextWithPunct',
+    'docDefaults', 'docGrid', 'docPart', 'docPartBody', 'docPartCategory', 'docPartGallery', 'docPartList', 'docPartObj',
+    'docPartPr', 'docPartUnique', 'docParts', 'docVar', 'docVars', 'document', 'documentProtection', 'documentType',
+    'drawing', 'drawingGridHorizontalOrigin', 'drawingGridHorizontalSpacing', 'drawingGridVerticalOrigin', 'drawingGridVerticalSpacing', 'dropDownList', 'dstrike', 'dynamicAddress',
+    'eastAsianLayout', 'effect', 'em', 'embedBold', 'embedBoldItalic', 'embedItalic', 'embedRegular', 'embedSystemFonts',
+    'embedTrueTypeFonts', 'emboss', 'enabled', 'encoding', 'end', 'endnote', 'endnotePr', 'endnoteRef',
+    'endnoteReference', 'endnotes', 'entryMacro', 'equation', 'evenAndOddHeaders', 'exitMacro', 'fHdr', 'family',
+    'ffData', 'fieldMapData', 'fitText', 'flatBorders', 'fldChar', 'fldData', 'fldSimple', 'font',
+    'fonts', 'footerReference', 'footnote', 'footnoteLayoutLikeWW8', 'footnotePr', 'footnoteRef', 'footnoteReference', 'footnotes',
+    'forceUpgrade', 'forgetLastTabAlignment', 'formProt', 'format', 'formsDesign', 'frame', 'frameLayout', 'framePr',
+    'frameset', 'framesetSplitbar', 'ftr', 'gallery', 'glossaryDocument', 'gridAfter', 'gridBefore', 'gridCol',
+    'gridSpan', 'group', 'growAutofit', 'guid', 'gutterAtTop', 'hMerge', 'hdr', 'hdrShapeDefaults',
+    'headerReference', 'headerSource', 'helpText', 'hidden', 'hideGrammaticalErrors', 'hideMark', 'hideSpellingErrors', 'highlight',
+    'hps', 'hpsBaseText', 'hpsRaise', 'hyperlink', 'hyphenationZone', 'i', 'iCs', 'id',
+    'ignoreMixedContent', 'ilvl', 'imprint', 'ind', 'ins', 'insideH', 'insideV', 'instrText',
+    'isLgl', 'jc', 'keepLines', 'keepNext', 'kern', 'kinsoku', 'lang', 'lastRenderedPageBreak',
+    'latentStyles', 'layoutRawTableWidth', 'layoutTableRowsApart', 'left', 'legacy', 'lid', 'lineWrapLikeWord6', 'link',
+    'linkStyles', 'linkToQuery', 'linkedToFile', 'listEntry', 'listItem', 'listSeparator', 'lnNumType', 'lock',
+    'locked', 'lsdException', 'lvl', 'lvlJc', 'lvlOverride', 'lvlPicBulletId', 'lvlRestart', 'lvlText',
+    'mailAsAttachment', 'mailMerge', 'mailSubject', 'mainDocumentType', 'mappedName', 'marBottom', 'marH', 'marLeft',
+    'marRight', 'marTop', 'marW', 'matchSrc', 'maxLength', 'mirrorIndents', 'mirrorMargins', 'monthLong',
+    'monthShort', 'moveFrom', 'moveFromRangeEnd', 'moveFromRangeStart', 'moveTo', 'moveToRangeEnd', 'moveToRangeStart', 'movie',
+    'multiLevelType', 'mwSmallCaps', 'name', 'next', 'noBorder', 'noBreakHyphen', 'noColumnBalance', 'noEndnote',
+    'noExtraLineSpacing', 'noLeading', 'noLineBreaksAfter', 'noLineBreaksBefore', 'noProof', 'noPunctuationKerning', 'noResizeAllowed', 'noSpaceRaiseLower',
+    'noTabHangInd', 'noWrap', 'notTrueType', 'nsid', 'num', 'numFmt', 'numId', 'numIdMacAtCleanup',
+    'numPicBullet', 'numPr', 'numRestart', 'numStart', 'numStyleLink', 'numbering', 'numberingChange', 'oMath',
+    'object', 'odso', 'optimizeForBrowser', 'outline', 'outlineLvl', 'overflowPunct', 'p', 'pBdr',
+    'pPr', 'pPrChange', 'pPrDefault', 'pStyle', 'pageBreakBefore', 'panose1', 'paperSrc', 'permEnd',
+    'permStart', 'personal', 'personalCompose', 'personalReply', 'pgBorders', 'pgMar', 'pgNum', 'pgNumType',
+    'pgSz', 'pict', 'picture', 'pitch', 'pixelsPerInch', 'placeholder', 'pos', 'position',
+    'printBodyTextBeforeHeader', 'printColBlack', 'printFormsData', 'printFractionalCharacterWidth', 'printPostScriptOverText', 'printTwoOnOne', 'printerSettings', 'proofErr',
+    'proofState', 'ptab', 'qFormat', 'query', 'r', 'rFonts', 'rPr', 'rPrChange',
+    'rPrDefault', 'rStyle', 'readModeInkLockDown', 'recipientData', 'recipients', 'relyOnVML', 'removeDateAndTime', 'removePersonalInformation',
+    'result', 'revisionView', 'richText', 'right', 'rsid', 'rsidRoot', 'rsids', 'rt',
+    'rtl', 'rtlGutter', 'ruby', 'rubyAlign', 'rubyBase', 'rubyPr', 'saveFormsData', 'saveInvalidXml',
+    'savePreviewPicture', 'saveSmartTagsAsXml', 'saveSubsetFonts', 'saveThroughXslt', 'saveXmlDataOnly', 'scrollbar', 'sdt', 'sdtContent',
+    'sdtEndPr', 'sdtPr', 'sectPr', 'sectPrChange', 'selectFldWithFirstOrLastChar', 'semiHidden', 'separator', 'settings',
+    'shadow', 'shapeDefaults', 'shapeLayoutLikeWW8', 'shd', 'showBreaksInFrames', 'showEnvelope', 'showXMLTags', 'showingPlcHdr',
+    'sig', 'size', 'sizeAuto', 'smallCaps', 'smartTag', 'smartTagPr', 'smartTagType', 'snapToGrid',
+    'softHyphen', 'sourceFileName', 'spaceForUL', 'spacing', 'spacingInWholePoints', 'specVanish', 'splitPgBreakAndParaMark', 'src',
+    'start', 'startOverride', 'statusText', 'storeMappedDataAs', 'strictFirstAndLastChars', 'strike', 'style', 'styleLink',
+    'styleLockQFSet', 'styleLockTheme', 'stylePaneFormatFilter', 'stylePaneSortMethod', 'styles', 'subDoc', 'subFontBySize', 'suff',
+    'summaryLength', 'suppressAutoHyphens', 'suppressBottomSpacing', 'suppressLineNumbers', 'suppressOverlap', 'suppressSpBfAfterPgBrk', 'suppressSpacingAtTopOfPage', 'suppressTopSpacing',
+    'suppressTopSpacingWP', 'swapBordersFacingPages', 'sym', 'sz', 'szCs', 't', 'tab', 'table',
+    'tabs', 'tag', 'targetScreenSz', 'tbl', 'tblBorders', 'tblCaption', 'tblCellMar', 'tblCellSpacing',
+    'tblDescription', 'tblGrid', 'tblGridChange', 'tblHeader', 'tblInd', 'tblLayout', 'tblLook', 'tblOverlap',
+    'tblPr', 'tblPrChange', 'tblPrEx', 'tblPrExChange', 'tblStyle', 'tblStyleColBandSize', 'tblStylePr', 'tblStyleRowBandSize',
+    'tblW', 'tblpPr', 'tc', 'tcBorders', 'tcFitText', 'tcMar', 'tcPr', 'tcPrChange',
+    'tcW', 'temporary', 'text', 'textAlignment', 'textDirection', 'textInput', 'textboxTightWrap', 'themeFontLang',
+    'titlePg', 'tl2br', 'tmpl', 'top', 'topLinePunct', 'tr', 'tr2bl', 'trHeight',
+    'trPr', 'trPrChange', 'trackRevisions', 'truncateFontHeightsLikeWP6', 'txbxContent', 'type', 'types', 'u',
+    'udl', 'uiCompat97To2003', 'uiPriority', 'ulTrailSpace', 'underlineTabInNumList', 'unhideWhenUsed', 'uniqueTag', 'updateFields',
+    'useAltKinsokuLineBreakRules', 'useAnsiKerningPairs', 'useFELayout', 'useNormalStyleForList', 'usePrinterMetrics', 'useSingleBorderforContiguousCells', 'useWord2002TableStyleRules', 'useWord97LineBreakRules',
+    'useXSLTWhenSaving', 'vAlign', 'vMerge', 'vanish', 'vertAlign', 'view', 'viewMergedData', 'w',
+    'wAfter', 'wBefore', 'webHidden', 'webSettings', 'widowControl', 'wordWrap', 'wpJustification', 'wpSpaceWidth',
+    'wrapTrailSpaces', 'writeProtection', 'yearLong', 'yearShort', 'zoom',
+]);

package/dist/opc/skipped.d.mts

@@ -0,0 +1,50 @@
+/**
+ * What a save does with an item when the part holding it has changed (CR-025 section 10, D14): `dropped`, written without it
+ * as Word 365's own save writes it, listed on `lastSave.dropped` and never refused; or `lost`, which Word's save keeps, or
+ * which Word won't open, or which nobody has measured, refused unless `checkLossOnSave` is off (D15).
+ */
+export type OnSave = 'dropped' | 'lost';
+/** One element, attribute or stretch of text a read dropped. */
+export interface ContentSkippedWarning {
+    code: 'part.skipped';
+    partName: string | undefined;
+    kind: 'element' | 'attribute' | 'text';
+    /** As the part writes it, `ext:opaque`; for text, its first 80 characters. */
+    name: string;
+    /** The element holding it, `w:sdtPr`. */
+    parentName: string;
+    /** That element's class, `org_docx4j_wml.SdtPr`. Absent for what CR-021's pass removes, which no class has met. */
+    parentClass?: string;
+    /** From the part's root, `/w:document/w:body/w:sdt/w:sdtPr/ext:opaque`; an attribute's last step is `@ext:a`, text's `text()`. */
+    path: string;
+    /** Its namespace is listed in `mc:Ignorable` where it stands. Always false for text. */
+    ignorable: boolean;
+    /** Its namespace URI, `null` for none and for text (CR-025 section 10). */
+    namespace: string | null;
+    /** What a save of the changed part does with it (CR-025 section 10.3): written without it, or refused. */
+    onSave: OnSave;
+    /** The Word file or statement that decides `onSave` (`'76i'`, `'REQ-314'`); absent for a lost item nobody measured. */
+    measured?: string;
+    /** Where the parser gives one, as `target.misplaced`: an attribute's is its element's. */
+    line?: number;
+    column?: number;
+    message: string;
+}
+export interface SaveClass {
+    readonly onSave: OnSave;
+    readonly measured?: string;
+}
+/** Written without, as Word's own save writes it; `measured` the Word file or statement. */
+export declare const dropped: (measured: string) => SaveClass;
+/** An element and all it holds. */
+export declare function skippedElement(element: Element, partName: string | undefined, parentClass?: string, saveClass?: SaveClass): ContentSkippedWarning;
+/** For a pass that goes beyond what Word was measured on: lost, whatever its shape (CR-025 D15). */
+export declare const UNMEASURED: SaveClass;
+/** An attribute of `owner`, named as the runtime reports it. */
+export declare function skippedAttribute(name: {
+    namespaceURI?: string;
+    localPart: string;
+    prefix?: string;
+}, owner: Element, partName: string | undefined, parentClass?: string): ContentSkippedWarning;
+/** A stretch of text, as a text or CDATA node. */
+export declare function skippedText(text: string, node: Node, partName: string | undefined, parentClass?: string): ContentSkippedWarning;

package/dist/opc/skipped.mjs

@@ -0,0 +1,140 @@
+// What a read drops, as a part's warning (CR-025). `part.skipped` is python's code, agreed through its CR-033 Q9, and
+// `kind`, `path` and `line` its `SkippedNode`'s. The runtime reports what it drops through three callbacks, which
+// `XmlPart.unmarshal` alone passes: objects CR-007 keeps them per call, since a drop is sometimes the mechanism
+// (`recordPPrChange`'s deep copy). CR-021's pass removes what it removes before the runtime sees it, so it reports its own.
+import { UNDERSTOOD_NAMESPACES } from './mce/understood.mjs';
+import { W, hostOf, isUnknown, isW } from './repair/hosts.mjs';
+const MC = 'http://schemas.openxmlformats.org/markup-compatibility/2006';
+const position = (node) => {
+    const { lineNumber, columnNumber } = node;
+    return { ...(typeof lineNumber === 'number' ? { line: lineNumber } : {}), ...(typeof columnNumber === 'number' ? { column: columnNumber } : {}) };
+};
+function pathOf(element) {
+    const steps = [];
+    for (let n = element; n !== null && n.nodeType === 1; n = n.parentNode)
+        steps.unshift(n.nodeName);
+    return `/${steps.join('/')}`;
+}
+/**
+ * Whether `mc:Ignorable` lists the namespace, there or on an ancestor, each prefix read where the attribute stands. A prefix
+ * that no longer resolves counts by its name, since `mcePreprocess` takes a branch out of the `mc:Choice` declaring it, but not
+ * where the item's own prefix still resolves to it: then it was declared only below the list, which doesn't put it in scope
+ * there, and the list names nothing (WD REQ-323, `ui-05`).
+ */
+function isIgnorable(namespace, prefix, from) {
+    if (!namespace)
+        return false;
+    for (let n = from; n !== null && n.nodeType === 1; n = n.parentNode) {
+        const element = n;
+        const listed = element.getAttributeNS(MC, 'Ignorable');
+        if (!listed)
+            continue;
+        for (const candidate of listed.trim().split(/\s+/)) {
+            const uri = element.lookupNamespaceURI(candidate);
+            if (uri === namespace || (!uri && candidate === prefix && from.lookupNamespaceURI(prefix) !== namespace))
+                return true;
+        }
+    }
+    return false;
+}
+/** Written without, as Word's own save writes it; `measured` the Word file or statement. */
+export const dropped = (measured) => ({ onSave: 'dropped', measured });
+const lost = (measured) => (measured === undefined ? { onSave: 'lost' } : { onSave: 'lost', measured });
+const isElement = (n) => n !== null && n.nodeType === 1;
+/** Check 76's file for an element in a namespace Word doesn't understand, by its host: ignorable (`76a` ...) and not (`76e` ...). */
+const FOREIGN_IGNORABLE = { sdtPr: '76a', p: '76b', r: '76c', tc: '76d', b: '76l', t: '76m' };
+const FOREIGN_REFUSED = { p: '76e', sdtPr: '76o', pPr: '76p', r: '76q', tc: '76r', b: '76s', t: '76v' };
+/** The property hosts where a run held by an unknown `w:` element makes Word refuse the file (CR-026 section 3.7). */
+const RUN_REFUSED = { rPr: '76t28', sdtPr: '76t46', trPr: '76t47', tcPr: '76t48', tblPr: '76t49' };
+/**
+ * An element's class (CR-025 section 10.3's table, D15): by the Word file that measured its shape, a shape nobody measured lost.
+ * `el` is the element as the read met it, in its parent.
+ */
+function elementClass(el, ignorable) {
+    var _a;
+    const parent = el.parentNode;
+    if (!isElement(parent))
+        return lost('REQ-320'); // a part's root: what an unexpected root held, which has no reading to copy
+    const ns = el.namespaceURI;
+    if (!ns)
+        return lost('76x'); // in no namespace: Word won't open the file (76x, 76y)
+    const host = parent.namespaceURI === W ? parent.localName : undefined;
+    if (ns === W) {
+        if (isUnknown(el)) {
+            // an unknown w: element. CR-026's pass reads one through where Word does and gives its items that class itself; one it
+            // leaves in a content host is a shape Word refuses or nobody measured (76t53, 76t54, 76t57, 76t59), left to the runtime
+            if (isUnknown(parent) || hostOf(parent))
+                return lost();
+            if (host === 't')
+                return dropped('76u'); // CR-021's pass takes it with what it holds, as Word's save does
+            if (host === 'pPr')
+                return dropped('76g');
+            if (host !== undefined && RUN_REFUSED[host] !== undefined) {
+                if (el.getElementsByTagNameNS(W, 'r').length > 0)
+                    return lost(RUN_REFUSED[host]);
+                return host === 'rPr' ? dropped('76t6') : lost();
+            }
+            if (host === 'sectPr' && isElement(parent.parentNode) && isW(parent.parentNode, 'pPr'))
+                return dropped('76t50');
+            return lost();
+        }
+        // a known w: element out of place
+        if (el.localName === 'document')
+            return lost('nd-10'); // a w:document in a w:document: Word won't open the file
+        if (el.localName === 'sectPr' && isUnknown(parent))
+            return dropped('mr-11');
+        if (el.localName === 'sectPr' && host === 'pPr')
+            return dropped('76t50');
+        if (el.localName === 'tab' && host === 't')
+            return dropped('76z');
+        return lost();
+    }
+    if (UNDERSTOOD_NAMESPACES.has(ns))
+        return lost(); // Word understands it and its save keeps it (python's 1b)
+    // a namespace Word doesn't understand: ignorable, Word ignores it wherever it stands (ISO/IEC 29500-3) and its save drops it
+    if (ignorable)
+        return dropped((_a = (host !== undefined ? FOREIGN_IGNORABLE[host] : undefined)) !== null && _a !== void 0 ? _a : 'mc:Ignorable');
+    return lost(host !== undefined ? FOREIGN_REFUSED[host] : undefined);
+}
+/** An attribute's class: an unknown `w:` one, or one in a namespace Word doesn't understand, ignorable or not, Word's save drops (76h to 76j). */
+function attributeClass(ns, ignorable) {
+    if (ns === W)
+        return dropped('76j');
+    if (!ns || UNDERSTOOD_NAMESPACES.has(ns))
+        return lost();
+    return dropped(ignorable ? '76h' : '76i');
+}
+/** Text's class: held by an unknown `w:` element it's absent in Word's reading (REQ-314); in a run, Word's save drops it (`72m`). */
+function textClass(parent) {
+    if (isUnknown(parent))
+        return dropped('REQ-314');
+    if (isW(parent, 'r'))
+        return dropped('72m');
+    return lost();
+}
+function warning(kind, name, parent, path, ignorable, located, partName, parentClass, namespace, saveClass) {
+    return {
+        code: 'part.skipped', partName, kind, name, parentName: parent.nodeName,
+        ...(parentClass !== undefined ? { parentClass } : {}),
+        path, ignorable, namespace, ...saveClass, ...position(located),
+        message: `${partName !== null && partName !== void 0 ? partName : 'a part'}: ${path}: the read dropped this ${kind}, which the model has no place for`,
+    };
+}
+/** An element and all it holds. */
+export function skippedElement(element, partName, parentClass, saveClass) {
+    const ignorable = isIgnorable(element.namespaceURI, element.prefix, element);
+    return warning('element', element.nodeName, element.parentNode, pathOf(element), ignorable, element, partName, parentClass, element.namespaceURI || null, saveClass !== null && saveClass !== void 0 ? saveClass : elementClass(element, ignorable));
+}
+/** For a pass that goes beyond what Word was measured on: lost, whatever its shape (CR-025 D15). */
+export const UNMEASURED = Object.freeze({ onSave: 'lost' });
+/** An attribute of `owner`, named as the runtime reports it. */
+export function skippedAttribute(name, owner, partName, parentClass) {
+    const shown = name.prefix ? `${name.prefix}:${name.localPart}` : name.localPart;
+    const ignorable = isIgnorable(name.namespaceURI, name.prefix, owner);
+    return warning('attribute', shown, owner, `${pathOf(owner)}/@${shown}`, ignorable, owner, partName, parentClass, name.namespaceURI || null, attributeClass(name.namespaceURI, ignorable));
+}
+/** A stretch of text, as a text or CDATA node. */
+export function skippedText(text, node, partName, parentClass) {
+    const parent = node.parentNode;
+    return warning('text', text.length > 80 ? text.slice(0, 80) : text, parent, `${pathOf(parent)}/text()`, false, node, partName, parentClass, null, textClass(parent));
+}

package/dist/packages/OpcPackage.d.mts

@@ -4,12 +4,21 @@ import { ContentTypeManager } from '../opc/ContentTypeManager.mjs';
 import { type PartStore, type PartSink } from '../opc/PartStore.mjs';
 import { type FlatOpcSinkOptions } from '../opc/FlatOpcPartStore.mjs';
 import { type LoadOptions } from '../opc/Load.mjs';
+import { type SaveReport } from '../opc/Save.mjs';
+import { type DuplicateEntryWarning, type ExternalMainPartWarning, type MultipleMainPartsWarning, type RelationshipsNamespaceWarning } from '../opc/exceptions.mjs';
 import { Part, type RelationshipSource } from '../parts/Part.mjs';
 import { Parts } from '../parts/Parts.mjs';
 import { RelationshipsPart, type AddPartBehaviour } from '../parts/RelationshipsPart.mjs';
 import type { CustomXmlDataStoragePart } from '../parts/DefaultXmlPart.mjs';
 import { DocPropsCorePart, DocPropsExtendedPart, DocPropsCustomPart } from '../parts/docProps/index.mjs';
-import { type PartWarning } from '../opc/mce/preprocessor.mjs';
+import { type PartWarning, type MisplacedContentWarning } from '../opc/mce/preprocessor.mjs';
+/** A warning on `pkg.warnings`: the load's (a duplicated entry, CR-024; an `External` main relationship, CR-031) or a part's. */
+export type PackageWarning = DuplicateEntryWarning | MultipleMainPartsWarning | ExternalMainPartWarning | PartWarning;
+/**
+ * What a load repaired (WD REQ-207's `repaired`, CR-031): `'own'` where a repair of this package's own was made, `'word'` where
+ * only Word's were followed, else `'none'`.
+ */
+export type Repaired = 'none' | 'word' | 'own';
 /** Anything `OpcPackage.load` accepts: zip bytes, a flat OPC string, or a container. */
 export type PackageSource = Uint8Array | ArrayBuffer | string | PartStore;
 /**
@@ -27,10 +36,86 @@ export declare class OpcPackage implements RelationshipSource {
     /** Custom XML parts by the (lower-cased) itemID of their properties part. */
     readonly customXmlDataStorageParts: Map<string, CustomXmlDataStoragePart>;
     /** The options this package was loaded with. */
+    /**
+     * The names the container held more than one entry of, each read from its first entry under
+     * `LoadOptions.repair: 'word'` (WD REQ-206, CR-024); empty for a package loaded without one, or made here.
+     */
+    duplicateEntries: readonly DuplicateEntryWarning[];
+    /**
+     * Where the package relationships held more than one officeDocument relationship, read from the last under
+     * `LoadOptions.repair: 'word'` (WD REQ-206's statement, CR-024 section 9); undefined for a package with one, or made here.
+     */
+    multipleMainParts: MultipleMainPartsWarning | undefined;
+    /**
+     * Where the package relationships held an `External` officeDocument relationship beside an internal one, dropped under
+     * `LoadOptions.repair: 'all'` (WD REQ-206's NOTE, CR-031 section 2.2); undefined otherwise.
+     */
+    externalMainPart: ExternalMainPartWarning | undefined;
     loadOptions: LoadOptions;
     docPropsCorePart: DocPropsCorePart | undefined;
     docPropsExtendedPart: DocPropsExtendedPart | undefined;
     docPropsCustomPart: DocPropsCustomPart | undefined;
+    /**
+     * Whether a save writes run properties in their normal form (CR-015 D2; docx4j CR-061's
+     * `setNormaliseOnSave`): a colour Word accepts as upper-case `RRGGBB`, one it rejects left out (a text or
+     * underline colour) or `auto` (a fill's, a border's), a `w:highlight`, `w:vertAlign` or `w:em` Word repairs away
+     * left out; a revision's former properties too. Only what is written changes: the tree keeps what it read, and a
+     * part nobody unmarshalled is still copied byte for byte. Undefined defers to the objects package's process-wide
+     * `setNormaliseOnSave` (on unless set off); a package's own setting wins over it. False writes values as read.
+     * On/off values and `w:u`'s are settled when the part is read, so they are written the same either way.
+     */
+    normaliseOnSave: boolean | undefined;
+    /** What the last save did beyond writing the package: each value it normalised (CR-015 D8), each it wrote past what Word stores (CR-017 P3), each misplaced child it wrote under `checkContentOnSave = false` (CR-016). Undefined until one. */
+    lastSave: SaveReport | undefined;
+    /**
+     * Whether a save refuses a part holding a child its container never admits (CR-016 D2, docx4j CR-064's rules in the
+     * objects facade, its CR-017): a run straight in the body, a table in a paragraph, a cell beside a table's rows, a
+     * string in a run, a name and value that disagree. On by default: the save throws `MisplacedContentException` with
+     * every such child in the part, its path and docx4j's message naming the fix, and writes nothing, since Word 365
+     * refuses such a file or repairs it by dropping content (check 72). Off, the part is written as held and each is on
+     * `lastSave.misplaced`. Only a part being marshalled is checked (one unmarshalled, or given contents); a part copied
+     * from the source is never refused, so a document read and saved untouched never is. `checkContent()` is the same
+     * check on request. A misplaced child read from a file is a `target.misplaced` warning on its part (D7).
+     */
+    checkContentOnSave: boolean;
+    /**
+     * Whether a save refuses to lose what a read dropped (CR-025 sections 2.3 and 2.4, D8): a part holding `part.skipped` content
+     * that was changed throws `SaveLossException` and nothing is written. Off, the part is written without those items, each on
+     * `lastSave.lost`. A part read and not changed is copied either way, so nothing is lost there. Word's own save drops such
+     * content with no message (check 76), so off is Word's behaviour.
+     */
+    checkLossOnSave: boolean;
+    private dateTimeZone_;
+    /**
+     * The client's time zone for this package, an IANA id (`Australia/Sydney`), or undefined for the runtime's (CR-018; the
+     * portfolio's date rule of 2026-10-28, docx4j's `OpcPackage.setDateTimeZone`). Every instant the package holds is shown
+     * in it, and a `w:date` without `dateUtc` read in it: a new revision's or comment's stamp (Word's local wall-clock
+     * `w:date`), `TrackedChange.date` and `Comment.creationDate`, and date fields when they are evaluated (CR-012 phase 5).
+     * It is the client's for this package, not the document's, and reaches no saved file as such: a server reusing a
+     * loaded package sets it per request. Under Office JS the runtime's zone is already the client's. A bound date has no
+     * zone (CR-002 section 56) unless `boundDatesConvertedAsWord` asks for Word's conversion in this one. A zone the
+     * runtime does not know is refused with a `RangeError` at the set.
+     */
+    get dateTimeZone(): string | undefined;
+    set dateTimeZone(id: string | undefined);
+    /** The zone in force: `dateTimeZone`, else the runtime's. */
+    effectiveDateTimeZone(): string;
+    /**
+     * Show bound dates as Word displays them in the package's zone (CR-018, the date rule's point 3; docx4j's
+     * `setBoundDatesConvertedAsWord`): off by default, a bound date being the day its fields say wherever it is read
+     * (CR-002 section 56). On, a bound value carrying a `Z` or an offset is read as an instant and shown in
+     * `effectiveDateTimeZone()`, as Word reads the `Z` as UTC and shows the machine's local time (a day early west of
+     * UTC); a value with no marker, or a date alone, stays nominal. Setting `dateTimeZone` does not turn this on.
+     */
+    boundDatesConvertedAsWord: boolean;
+    /**
+     * Write the save's time into the core properties (CR-018, the date rule's point 6; docx4j's `docx4j.dcterms.write`):
+     * off by default, a save leaving `dcterms:created` and `dcterms:modified` as they are. On, each save sets
+     * `dcterms:modified` to now, UTC to the second (`2026-10-28T03:04:05Z`, the W3CDTF form Office writes), and
+     * `dcterms:created` too for a package created here that has none; a loaded package with no core properties part is
+     * left without one, as docx4j leaves it.
+     */
+    writeTimesOnSave: boolean;
     constructor();
     get package(): OpcPackage;
     /**
@@ -43,14 +128,35 @@ export declare class OpcPackage implements RelationshipSource {
     /** Adds a part as a target of the package (docProps, the main part). */
     addTargetPart(target: Part, mode?: AddPartBehaviour, proposedRelId?: string): Relationship;
     setPartShortcut(part: Part, relationshipType: string): boolean;
-    /** The main part: the target of the officeDocument relationship. */
+    /** The main part: the target of the officeDocument relationship, an External one naming none. */
     getMainPart(): Part | undefined;
     /**
-     * The warnings of every part parsed so far (each XML part's `warnings`, CR-010 phase 1). A part
+     * The warnings of every part parsed so far (each XML part's `warnings`, CR-010 phase 1), after the
+     * load's own: a name the container holds twice, and more than one officeDocument relationship, read under
+     * `repair: 'word'` (CR-024), and an `External` main relationship dropped under `repair: 'all'` (CR-031). A part
      * is parsed when something reads it, so a reader that wants a whole package's warnings reads its
      * parts first; `unmarshalAll()` does, at the cost of re-marshalling every part on save.
      */
-    get warnings(): PartWarning[];
+    get warnings(): PackageWarning[];
+    /**
+     * Each relationships part a load under `repair: 'word'` read by local name, being in a wrong namespace (CR-031 section
+     * 2.3): the package's and its parts', in that order.
+     */
+    get relationshipsNamespaces(): RelationshipsNamespaceWarning[];
+    /**
+     * What the load repaired (WD REQ-207's `repaired`, CR-031 section 2.4), read from what it recorded, so it reports what the
+     * load did whatever the option: `'own'` for a repair of this package's own (an `External` main relationship dropped),
+     * `'word'` where only Word's were followed (a duplicated entry, several main relationships, a relationships part read by
+     * local name), else `'none'`.
+     */
+    get repaired(): Repaired;
+    /**
+     * Every child a part holds that its container never admits (CR-016 D6, the check on request): what a save would
+     * refuse for, over every typed XML part, each finding with its part, its path, the rule and docx4j's message naming
+     * the fix. Nothing is changed, and an untouched part stays untouched (read privately). `[]` for a package whose
+     * content is all in its place.
+     */
+    checkContent(): Promise<MisplacedContentWarning[]>;
     /** Unmarshals every XML part, so that `contents` is available synchronously everywhere. */
     unmarshalAll(): Promise<void>;
     /** Adds empty core properties if absent (docx4j addDocPropsCorePart). */