@stll/folio-core 0.45.0 → 0.47.0

package/dist/prosemirror/attrs/index.js

@@ -1,20 +1,20 @@
+import { isSerializablePreservedAttribute } from "../../docx/attributeRemainder.js";
+import { DRAWING_ANCHOR_FLAG_KEYS } from "../../docx/drawingAnchor.js";
 import { GRAPHIC_FRAME_LOCK_KEYS } from "../../docx/graphicFrameLocks.js";
 import { allowsDirectDrawingEdit, isDrawingRawXmlMode } from "../../docx/imageRawXml.js";
-import { EMPHASIS_MARK_VALUES, FIELD_TYPE_VALUES, FONT_HINT_VALUES, FONT_THEME_VALUES, HIGHLIGHT_COLOR_VALUES, IMAGE_HORIZONTAL_ALIGNMENT_VALUES, IMAGE_HORIZONTAL_RELATIVE_TO_VALUES, IMAGE_VERTICAL_ALIGNMENT_VALUES, IMAGE_VERTICAL_RELATIVE_TO_VALUES, IMAGE_WRAP_TEXT_VALUES, IMAGE_WRAP_TYPE_VALUES, LINE_SPACING_RULE_VALUES, NUMBER_FORMAT_VALUES, OUTLINE_STYLE_ATTR_VALUES, PARAGRAPH_ALIGNMENT_VALUES, POSITIONAL_TAB_ALIGNMENT_VALUES, POSITIONAL_TAB_LEADER_VALUES, POSITIONAL_TAB_RELATIVE_TO_VALUES, SDT_LOCK_VALUES, SDT_TYPE_VALUES, SHADING_PATTERN_VALUES, TABLE_CELL_TEXT_DIRECTION_VALUES, TABLE_CELL_VERTICAL_ALIGNMENT_VALUES, TABLE_JUSTIFICATION_VALUES, TABLE_ROW_HEIGHT_RULE_VALUES, TABLE_WIDTH_TYPE_VALUES, TAB_LEADER_VALUES, TAB_STOP_ALIGNMENT_VALUES, TEXT_EFFECT_VALUES, THEME_COLOR_SLOT_VALUES, UNDERLINE_STYLE_VALUES } from "../../types/documentEnumValues.js";
+import { COUNTER_FORMAT_VALUES, EMPHASIS_MARK_VALUES, FIELD_TYPE_VALUES, FONT_HINT_VALUES, FONT_THEME_VALUES, HIGHLIGHT_COLOR_VALUES, IMAGE_HORIZONTAL_ALIGNMENT_VALUES, IMAGE_HORIZONTAL_RELATIVE_TO_VALUES, IMAGE_VERTICAL_ALIGNMENT_VALUES, IMAGE_VERTICAL_RELATIVE_TO_VALUES, IMAGE_WRAP_TEXT_VALUES, IMAGE_WRAP_TYPE_VALUES, LINE_SPACING_RULE_VALUES, OUTLINE_STYLE_ATTR_VALUES, PARAGRAPH_ALIGNMENT_VALUES, POSITIONAL_TAB_ALIGNMENT_VALUES, POSITIONAL_TAB_LEADER_VALUES, POSITIONAL_TAB_RELATIVE_TO_VALUES, SDT_LOCK_VALUES, SDT_TYPE_VALUES, SHADING_PATTERN_VALUES, TABLE_CELL_VERTICAL_ALIGNMENT_VALUES, TABLE_JUSTIFICATION_VALUES, TABLE_ROW_HEIGHT_RULE_VALUES, TABLE_WIDTH_TYPE_VALUES, TAB_LEADER_VALUES, TAB_STOP_ALIGNMENT_VALUES, TEXT_DIRECTION_VALUES, TEXT_EFFECT_VALUES, UNDERLINE_STYLE_VALUES } from "../../types/documentEnumValues.js";
 import { canonicalJson } from "../../utils/canonicalJson.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
+import { paragraphNumberingFromAttrValue } from "../numberingAttr.js";
+import { outlineLevelFromAttrValue } from "../outlineLevelAttr.js";
 import { isParagraphDirection } from "../paragraphDirection.js";
 import { COMPLEX_SCRIPT_RUN_PROPERTY_KEYS, RUN_FORMATTING_BOOLEAN_PROPERTIES, RUN_FORMATTING_VALUE_PROPERTIES, TRACKED_CHANGE_PROVENANCE_VALUES } from "../schema/marks.js";
-import { TEXT_BOX_TEXT_BODY_CONTENT_STATE_TYPES } from "../schema/nodes.js";
+import { PRESERVED_XML_LEVELS, TEXT_BOX_TEXT_BODY_CONTENT_STATE_TYPES } from "../schema/nodes.js";
 import { panic } from "better-result";
-import { DRAWING_RAW_XML_MODES, isOoxmlSymbolCharacter } from "@stll/docx-core/model";
+import { DRAWING_RAW_XML_MODES, THEME_COLORS, isOoxmlSymbolCharacter } from "@stll/docx-core/model";
+import { isSafePreservedChildXml, isWithinPreservedMarkupBudget } from "@stll/docx-core/schema";
 //#region src/prosemirror/attrs/index.ts
-const SECTION_BREAK_TYPES = [
-	"nextPage",
-	"continuous",
-	"oddPage",
-	"evenPage"
-];
+const PRESERVED_XML_LEVEL_VALUES = new Set(Object.values(PRESERVED_XML_LEVELS));
 const IMAGE_DISPLAY_MODES = [
 	"inline",
 	"float",
@@ -141,11 +141,14 @@ const SECTION_VERTICAL_ALIGNMENTS = [
 	"both",
 	"bottom"
 ];
+const OMITTED_GRID_SLOT_VALUES = ["before", "after"];
 const paragraphAttrsCache = /* @__PURE__ */ new WeakMap();
 const hardBreakAttrsCache = /* @__PURE__ */ new WeakMap();
 const pageBreakRunAttrsCache = /* @__PURE__ */ new WeakMap();
 const tabAttrsCache = /* @__PURE__ */ new WeakMap();
 const symbolAttrsCache = /* @__PURE__ */ new WeakMap();
+const preservedXmlAttrsCache = /* @__PURE__ */ new WeakMap();
+const preservedBlockAttrsCache = /* @__PURE__ */ new WeakMap();
 const tableAttrsCache = /* @__PURE__ */ new WeakMap();
 const tableRowAttrsCache = /* @__PURE__ */ new WeakMap();
 const tableCellAttrsCache = /* @__PURE__ */ new WeakMap();
@@ -171,7 +174,8 @@ const footnoteRefAttrsCache = /* @__PURE__ */ new WeakMap();
 const commentAttrsCache = /* @__PURE__ */ new WeakMap();
 const trackedChangeAttrsCache = /* @__PURE__ */ new WeakMap();
 const runPropertyChangeAttrsCache = /* @__PURE__ */ new WeakMap();
-const pageBreakRunOwnerAttrsCache = /* @__PURE__ */ new WeakMap();
+const runIdentityAttrsCache = /* @__PURE__ */ new WeakMap();
+const inlineWrapperAttrsCache = /* @__PURE__ */ new WeakMap();
 const runFormattingOverrideAttrsCache = /* @__PURE__ */ new WeakMap();
 const hyperlinkAttrsCache = /* @__PURE__ */ new WeakMap();
 const readParagraphAttrs = (node) => {
@@ -199,7 +203,7 @@ const readParagraphAttrs = (node) => {
 	optionalNumber(attrs, "indentRight", "paragraph.attrs.indentRight", issues);
 	optionalNumber(attrs, "indentFirstLine", "paragraph.attrs.indentFirstLine", issues);
 	optionalBoolean(attrs, "hangingIndent", "paragraph.attrs.hangingIndent", issues);
-	optionalNumber(attrs, "outlineLevel", "paragraph.attrs.outlineLevel", issues);
+	optionalOutlineLevel(attrs, "outlineLevel", "paragraph.attrs.outlineLevel", issues);
 	optionalString(attrs, "listNumFmt", "paragraph.attrs.listNumFmt", issues);
 	optionalBoolean(attrs, "listIsBullet", "paragraph.attrs.listIsBullet", issues);
 	optionalBoolean(attrs, "listIsLegal", "paragraph.attrs.listIsLegal", issues);
@@ -231,7 +235,6 @@ const readParagraphAttrs = (node) => {
 		path: "paragraph.attrs.direction",
 		message: "Expected a ParagraphDirection."
 	});
-	optionalOneOf(attrs, "sectionBreakType", "paragraph.attrs.sectionBreakType", issues, SECTION_BREAK_TYPES);
 	optionalStringArray(attrs, "listLevelNumFmts", "paragraph.attrs.listLevelNumFmts", issues);
 	optionalNumberArray(attrs, "listLevelStarts", "paragraph.attrs.listLevelStarts", issues);
 	optionalNumber(attrs, "listAbstractNumId", "paragraph.attrs.listAbstractNumId", issues);
@@ -250,13 +253,15 @@ const readParagraphAttrs = (node) => {
 	optionalRecord(attrs, "spacingFromImplicitDefaultStyle", "paragraph.attrs.spacingFromImplicitDefaultStyle", issues);
 	optionalTextFormatting(attrs, "defaultTextFormatting", "paragraph.attrs.defaultTextFormatting", issues);
 	optionalTextFormatting(attrs, "_tableRunFormatting", "paragraph.attrs._tableRunFormatting", issues);
-	optionalRecord(attrs, "numPr", "paragraph.attrs.numPr", issues);
-	validateNumPr(attrs["numPr"], issues);
+	optionalParagraphNumbering(attrs, "numPr", "paragraph.attrs.numPr", issues);
+	optionalParagraphNumbering(attrs, "numPrFromStyle", "paragraph.attrs.numPrFromStyle", issues);
+	optionalNestedRecord(attrs, "_originalFormatting", "paragraph.attrs._originalFormatting", issues, validateParagraphFormatting);
 	optionalBookmarkArray(attrs["bookmarks"], issues);
 	optionalEmptyHyperlinkArray(attrs["_emptyHyperlinks"], issues);
 	optionalAutospacingBase(attrs, "paragraph.attrs._autospacingBase", issues);
 	optionalSectionProperties(attrs, "_sectionProperties", "paragraph.attrs._sectionProperties", issues);
 	optionalPropertyChanges(attrs, "_propertyChanges", "paragraph.attrs._propertyChanges", issues, ["paragraphPropertyChange"]);
+	optionalPreservedAttributes(attrs, "_preservedAttributes", "paragraph.attrs._preservedAttributes", issues);
 	return attrsResult(attrs, issues);
 };
 const expectParagraphAttrs = (node) => expectCachedNodeAttrs(node, paragraphAttrsCache, readParagraphAttrs, "paragraph attrs");
@@ -304,6 +309,27 @@ const readSymbolAttrs = (node) => {
 	return attrsResult(attrs, issues);
 };
 const expectSymbolAttrs = (node) => expectCachedNodeAttrs(node, symbolAttrsCache, readSymbolAttrs, "symbol attrs");
+const readPreservedXmlAttrs = (node) => {
+	const attrs = attrsRecord(node.attrs);
+	const issues = [];
+	expectNodeType(node, "preservedXml", issues);
+	requiredString(attrs, "xml", "preservedXml.attrs.xml", issues);
+	requiredString(attrs, "text", "preservedXml.attrs.text", issues);
+	if (!PRESERVED_XML_LEVEL_VALUES.has(attrs["level"])) issues.push({
+		path: "preservedXml.attrs.level",
+		message: `Expected one of ${[...PRESERVED_XML_LEVEL_VALUES].join(", ")}.`
+	});
+	return attrsResult(attrs, issues);
+};
+const expectPreservedXmlAttrs = (node) => expectCachedNodeAttrs(node, preservedXmlAttrsCache, readPreservedXmlAttrs, "preservedXml attrs");
+const readPreservedBlockAttrs = (node) => {
+	const attrs = attrsRecord(node.attrs);
+	const issues = [];
+	expectNodeType(node, "preservedBlock", issues);
+	requiredString(attrs, "xml", "preservedBlock.attrs.xml", issues);
+	return attrsResult(attrs, issues);
+};
+const expectPreservedBlockAttrs = (node) => expectCachedNodeAttrs(node, preservedBlockAttrsCache, readPreservedBlockAttrs, "preservedBlock attrs");
 const readTableAttrs = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
@@ -327,6 +353,8 @@ const readTableAttrs = (node) => {
 	optionalOneOf(attrs, "_resolvedJustification", "table.attrs._resolvedJustification", issues, TABLE_JUSTIFICATION_VALUES);
 	optionalBoolean(attrs, "_resolvedBidi", "table.attrs._resolvedBidi", issues);
 	optionalRecord(attrs, "_originalFormatting", "table.attrs._originalFormatting", issues);
+	optionalPositionedBookmarks(attrs, "table.attrs._bookmarks", issues);
+	optionalTablePreservedMarkup(attrs, "_preserved", "table.attrs._preserved", issues);
 	return attrsResult(attrs, issues);
 };
 const expectTableAttrs = (node) => expectCachedNodeAttrs(node, tableAttrsCache, readTableAttrs, "table attrs");
@@ -340,12 +368,17 @@ const readTableRowAttrs = (node) => {
 	optionalBoolean(attrs, "hidden", "tableRow.attrs.hidden", issues);
 	optionalOneOf(attrs, "_resolvedJustification", "tableRow.attrs._resolvedJustification", issues, TABLE_JUSTIFICATION_VALUES);
 	optionalRecord(attrs, "_originalFormatting", "tableRow.attrs._originalFormatting", issues);
+	optionalRecord(attrs, "_tablePropertyExceptions", "tableRow.attrs._tablePropertyExceptions", issues);
 	optionalTableRowRevision(attrs, "trIns", issues);
 	optionalTableRowRevision(attrs, "trDel", issues);
 	if (attrs["trIns"] != null && attrs["trDel"] != null) issues.push({
 		path: "tableRow.attrs",
 		message: "Expected at most one structural revision marker."
 	});
+	optionalPreservedAttributes(attrs, "_preservedAttributes", "tableRow.attrs._preservedAttributes", issues);
+	optionalPositionedBookmarks(attrs, "tableRow.attrs._bookmarks", issues);
+	optionalContentControls(attrs, "tableRow.attrs.contentControls", issues);
+	optionalTablePreservedMarkup(attrs, "_preserved", "tableRow.attrs._preserved", issues);
 	return attrsResult(attrs, issues);
 };
 const expectTableRowAttrs = (node) => expectCachedNodeAttrs(node, tableRowAttrsCache, readTableRowAttrs, "table row attrs");
@@ -355,13 +388,15 @@ const readTableCellAttrs = (node) => {
 	expectNodeTypeOneOf(node, ["tableCell", "tableHeader"], issues);
 	requiredNumber(attrs, "colspan", "tableCell.attrs.colspan", issues);
 	requiredNumber(attrs, "rowspan", "tableCell.attrs.rowspan", issues);
+	optionalOneOf(attrs, "_omittedGridSlot", "tableCell.attrs._omittedGridSlot", issues, OMITTED_GRID_SLOT_VALUES);
 	optionalNumberArray(attrs, "colwidth", "tableCell.attrs.colwidth", issues, { allowNull: true });
 	optionalNumber(attrs, "width", "tableCell.attrs.width", issues);
 	optionalOneOf(attrs, "widthType", "tableCell.attrs.widthType", issues, TABLE_WIDTH_TYPE_VALUES);
+	optionalAuthoredWidth(attrs, issues);
 	optionalOneOf(attrs, "verticalAlign", "tableCell.attrs.verticalAlign", issues, TABLE_CELL_VERTICAL_ALIGNMENT_VALUES);
 	optionalString(attrs, "backgroundColor", "tableCell.attrs.backgroundColor", issues);
 	optionalString(attrs, "_resolvedBackgroundColor", "tableCell.attrs._resolvedBackgroundColor", issues);
-	optionalOneOf(attrs, "textDirection", "tableCell.attrs.textDirection", issues, TABLE_CELL_TEXT_DIRECTION_VALUES);
+	optionalOneOf(attrs, "textDirection", "tableCell.attrs.textDirection", issues, TEXT_DIRECTION_VALUES);
 	optionalBoolean(attrs, "noWrap", "tableCell.attrs.noWrap", issues);
 	optionalBoolean(attrs, "hideMark", "tableCell.attrs.hideMark", issues);
 	optionalBorderMap(attrs, "borders", "tableCell.attrs.borders", issues, [
@@ -375,6 +410,7 @@ const readTableCellAttrs = (node) => {
 	optionalInsetMap(attrs, "margins", "tableCell.attrs.margins", issues);
 	optionalRecord(attrs, "_originalFormatting", "tableCell.attrs._originalFormatting", issues);
 	optionalTableCellRevision(attrs, issues);
+	optionalContentControls(attrs, "tableCell.attrs.contentControls", issues);
 	optionalBoolean(attrs, "_preserveVMergeRestart", "tableCell.attrs._preserveVMergeRestart", issues);
 	return attrsResult(attrs, issues);
 };
@@ -394,11 +430,16 @@ const readImageAttrs = (node) => {
 	optionalOneOf(attrs, "displayMode", "image.attrs.displayMode", issues, IMAGE_DISPLAY_MODES);
 	optionalOneOf(attrs, "cssFloat", "image.attrs.cssFloat", issues, IMAGE_CSS_FLOATS);
 	optionalString(attrs, "transform", "image.attrs.transform", issues);
+	optionalNumber(attrs, "docxRotation", "image.attrs.docxRotation", issues);
+	optionalBoolean(attrs, "docxFlipH", "image.attrs.docxFlipH", issues);
+	optionalBoolean(attrs, "docxFlipV", "image.attrs.docxFlipV", issues);
 	optionalNumber(attrs, "distTop", "image.attrs.distTop", issues);
 	optionalNumber(attrs, "distBottom", "image.attrs.distBottom", issues);
 	optionalNumber(attrs, "distLeft", "image.attrs.distLeft", issues);
 	optionalNumber(attrs, "distRight", "image.attrs.distRight", issues);
 	optionalNumber(attrs, "opacity", "image.attrs.opacity", issues);
+	optionalNumber(attrs, "brightness", "image.attrs.brightness", issues);
+	optionalNumber(attrs, "contrast", "image.attrs.contrast", issues);
 	optionalNumber(attrs, "cropTop", "image.attrs.cropTop", issues);
 	optionalNumber(attrs, "cropRight", "image.attrs.cropRight", issues);
 	optionalNumber(attrs, "cropBottom", "image.attrs.cropBottom", issues);
@@ -408,7 +449,10 @@ const readImageAttrs = (node) => {
 	optionalNumber(attrs, "paddingBottom", "image.attrs.paddingBottom", issues);
 	optionalNumber(attrs, "paddingLeft", "image.attrs.paddingLeft", issues);
 	optionalImagePosition(attrs, "position", "image.attrs.position", issues);
-	optionalBoolean(attrs, "layoutInCell", "image.attrs.layoutInCell", issues);
+	optionalDrawingAnchor(attrs, "anchor", "image.attrs.anchor", issues);
+	optionalWrapDistanceSlots(attrs, "wrapDistanceSlots", "image.attrs.wrapDistanceSlots", issues);
+	optionalEffectExtentSlots(attrs, "wrapEffectExtentSlots", "image.attrs.wrapEffectExtentSlots", issues);
+	optionalWrapPolygon(attrs, "wrapPolygon", "image.attrs.wrapPolygon", issues);
 	optionalBoolean(attrs, "decorative", "image.attrs.decorative", issues);
 	optionalBoolean(attrs, "hidden", "image.attrs.hidden", issues);
 	optionalStringArray(attrs, "docPrExtensions", "image.attrs.docPrExtensions", issues);
@@ -420,6 +464,9 @@ const readImageAttrs = (node) => {
 	optionalOneOf(attrs, "wrapText", "image.attrs.wrapText", issues, IMAGE_WRAP_TEXT_VALUES);
 	optionalString(attrs, "hlinkHref", "image.attrs.hlinkHref", issues);
 	optionalString(attrs, "hlinkRId", "image.attrs.hlinkRId", issues);
+	optionalDocPrLink(attrs, "hlinkClickSource", "image.attrs.hlinkClickSource", issues);
+	optionalString(attrs, "hlinkHoverXml", "image.attrs.hlinkHoverXml", issues);
+	optionalString(attrs, "docPrId", "image.attrs.docPrId", issues);
 	optionalString(attrs, "_docxRawXml", "image.attrs._docxRawXml", issues);
 	optionalOneOf(attrs, "_docxRawXmlMode", "image.attrs._docxRawXmlMode", issues, Object.values(DRAWING_RAW_XML_MODES));
 	optionalString(attrs, "_docxRawImageFingerprint", "image.attrs._docxRawImageFingerprint", issues);
@@ -482,8 +529,9 @@ const readBlockSdtAttrs = (node) => {
 	optionalString(attrs, "dropdownLastValue", "blockSdt.attrs.dropdownLastValue", issues);
 	optionalBoolean(attrs, "checked", "blockSdt.attrs.checked", issues);
 	optionalBoolean(attrs, "_originallyEmpty", "blockSdt.attrs._originallyEmpty", issues);
-	optionalString(attrs, "rawPropertiesXml", "blockSdt.attrs.rawPropertiesXml", issues);
+	optionalPreservedMarkup(attrs, "_preserved", "blockSdt.attrs._preserved", issues);
 	optionalString(attrs, "rawEndPropertiesXml", "blockSdt.attrs.rawEndPropertiesXml", issues);
+	optionalSdtEndProperties(attrs, "blockSdt.attrs.endProperties", issues);
 	optionalString(attrs, "rawSdtChildrenBeforeContent", "blockSdt.attrs.rawSdtChildrenBeforeContent", issues);
 	optionalString(attrs, "rawSdtChildrenAfterContent", "blockSdt.attrs.rawSdtChildrenAfterContent", issues);
 	return attrsResult(attrs, issues);
@@ -517,6 +565,9 @@ const readShapeAttrs = (node) => {
 	optionalShapeLineEnd(attrs, "outlineHeadEnd", "shape.attrs.outlineHeadEnd", issues);
 	optionalShapeLineEnd(attrs, "outlineTailEnd", "shape.attrs.outlineTailEnd", issues);
 	optionalString(attrs, "transform", "shape.attrs.transform", issues);
+	optionalNumber(attrs, "docxRotation", "shape.attrs.docxRotation", issues);
+	optionalBoolean(attrs, "docxFlipH", "shape.attrs.docxFlipH", issues);
+	optionalBoolean(attrs, "docxFlipV", "shape.attrs.docxFlipV", issues);
 	optionalOneOf(attrs, "displayMode", "shape.attrs.displayMode", issues, IMAGE_DISPLAY_MODES);
 	optionalOneOf(attrs, "cssFloat", "shape.attrs.cssFloat", issues, IMAGE_CSS_FLOATS);
 	optionalOneOf(attrs, "wrapType", "shape.attrs.wrapType", issues, IMAGE_WRAP_TYPE_VALUES);
@@ -526,6 +577,10 @@ const readShapeAttrs = (node) => {
 	optionalNumber(attrs, "distLeft", "shape.attrs.distLeft", issues);
 	optionalNumber(attrs, "distRight", "shape.attrs.distRight", issues);
 	optionalImagePosition(attrs, "position", "shape.attrs.position", issues);
+	optionalDrawingAnchor(attrs, "anchor", "shape.attrs.anchor", issues);
+	optionalWrapDistanceSlots(attrs, "wrapDistanceSlots", "shape.attrs.wrapDistanceSlots", issues);
+	optionalEffectExtentSlots(attrs, "wrapEffectExtentSlots", "shape.attrs.wrapEffectExtentSlots", issues);
+	optionalWrapPolygon(attrs, "wrapPolygon", "shape.attrs.wrapPolygon", issues);
 	optionalString(attrs, "shadowColor", "shape.attrs.shadowColor", issues);
 	optionalNumber(attrs, "shadowBlur", "shape.attrs.shadowBlur", issues);
 	optionalNumber(attrs, "shadowOffsetX", "shape.attrs.shadowOffsetX", issues);
@@ -554,6 +609,9 @@ const readTextBoxAttrs = (node) => {
 	optionalString(attrs, "outlineColor", "textBox.attrs.outlineColor", issues);
 	optionalOneOf(attrs, "outlineStyle", "textBox.attrs.outlineStyle", issues, OUTLINE_STYLE_ATTR_VALUES);
 	optionalTextBoxTransform(attrs, "transform", "textBox.attrs.transform", issues);
+	optionalNumber(attrs, "docxRotation", "textBox.attrs.docxRotation", issues);
+	optionalBoolean(attrs, "docxFlipH", "textBox.attrs.docxFlipH", issues);
+	optionalBoolean(attrs, "docxFlipV", "textBox.attrs.docxFlipV", issues);
 	optionalNumber(attrs, "marginTop", "textBox.attrs.marginTop", issues);
 	optionalNumber(attrs, "marginBottom", "textBox.attrs.marginBottom", issues);
 	optionalNumber(attrs, "marginLeft", "textBox.attrs.marginLeft", issues);
@@ -568,12 +626,17 @@ const readTextBoxAttrs = (node) => {
 	optionalNumber(attrs, "distLeft", "textBox.attrs.distLeft", issues);
 	optionalNumber(attrs, "distRight", "textBox.attrs.distRight", issues);
 	optionalImagePosition(attrs, "position", "textBox.attrs.position", issues);
+	optionalDrawingAnchor(attrs, "anchor", "textBox.attrs.anchor", issues);
+	optionalWrapDistanceSlots(attrs, "wrapDistanceSlots", "textBox.attrs.wrapDistanceSlots", issues);
+	optionalEffectExtentSlots(attrs, "wrapEffectExtentSlots", "textBox.attrs.wrapEffectExtentSlots", issues);
+	optionalWrapPolygon(attrs, "wrapPolygon", "textBox.attrs.wrapPolygon", issues);
 	optionalOneOf(attrs, "_docxPlacement", "textBox.attrs._docxPlacement", issues, TEXT_BOX_DOCX_PLACEMENTS);
 	optionalString(attrs, "_docxGroupId", "textBox.attrs._docxGroupId", issues);
 	optionalString(attrs, "_docxAnchorId", "textBox.attrs._docxAnchorId", issues);
 	requiredTextBoxBodyContentState(attrs, issues);
 	optionalTextBoxTrackedChange(attrs, issues);
 	optionalTextBoxInlineSdts(attrs, issues);
+	optionalPreservedAttributes(attrs, "_preservedAttributes", "textBox.attrs._preservedAttributes", issues);
 	return attrsResult(attrs, issues);
 };
 const expectTextBoxAttrs = (node) => expectCachedNodeAttrs(node, textBoxAttrsCache, readTextBoxAttrs, "text box attrs");
@@ -727,6 +790,7 @@ const readTrackedChangeMarkAttrs = (mark) => {
 	optionalOneOf(attrs, "moveKind", `${mark.type.name}.attrs.moveKind`, issues, TRACKED_CHANGE_MOVE_KINDS);
 	optionalOneOf(attrs, "provenance", `${mark.type.name}.attrs.provenance`, issues, TRACKED_CHANGE_PROVENANCE_VALUES);
 	optionalString(attrs, "suggestionId", `${mark.type.name}.attrs.suggestionId`, issues);
+	optionalBoolean(attrs, "_historicalFormatting", `${mark.type.name}.attrs._historicalFormatting`, issues);
 	return attrsResult(attrs, issues);
 };
 const expectTrackedChangeMarkAttrs = (mark) => expectCachedMarkAttrs(mark, trackedChangeAttrsCache, readTrackedChangeMarkAttrs, "tracked change attrs");
@@ -740,18 +804,141 @@ const readRunPropertyChangeMarkAttrs = (mark) => {
 	return attrsResult(attrs, issues);
 };
 const expectRunPropertyChangeMarkAttrs = (mark) => expectCachedMarkAttrs(mark, runPropertyChangeAttrsCache, readRunPropertyChangeMarkAttrs, "run property change attrs");
-const readPageBreakRunOwnerMarkAttrs = (mark) => {
+/**
+* The identity mark's payload, field by field.
+*
+* Every field is read strictly because the mark reaches this build from three
+* places it does not control: a paste, a collaboration snapshot written by
+* another build, and a host that edited the document through the public API.
+* A remainder entry that is not a resolved name and a string value would be
+* written straight back into a `w:r` start tag.
+*/
+const readRunIdentityMarkAttrs = (mark) => {
 	const attrs = attrsRecord(mark.attrs);
 	const issues = [];
-	expectMarkType(mark, "pageBreakRunOwner", issues);
+	expectMarkType(mark, "runIdentity", issues);
 	const id = attrs["id"];
 	if (typeof id !== "number" || !Number.isSafeInteger(id) || id < 0) issues.push({
-		path: "pageBreakRunOwner.attrs.id",
+		path: "runIdentity.attrs.id",
 		message: "Expected a non-negative safe integer."
 	});
+	optionalPreservedAttributes(attrs, "preservedAttributes", "runIdentity.attrs.preservedAttributes", issues);
+	optionalPreservedMarkup(attrs, "preserved", "runIdentity.attrs.preserved", issues);
+	return attrsResult(attrs, issues);
+};
+const expectRunIdentityMarkAttrs = (mark) => expectCachedMarkAttrs(mark, runIdentityAttrsCache, readRunIdentityMarkAttrs, "run identity attrs");
+const BIDI_LAYER_CONTROLS = ["embedding", "override"];
+const BIDI_LAYER_DIRECTIONS = ["ltr", "rtl"];
+const BIDI_LAYER_KEYS = /* @__PURE__ */ new Set([
+	"kind",
+	"control",
+	"direction"
+]);
+const TAGGED_LAYER_KEYS = /* @__PURE__ */ new Set([
+	"kind",
+	"element",
+	"uri",
+	"propertiesXml"
+]);
+/**
+* `w:smartTag` and the run-level `w:customXml` declare the same three slots.
+*
+* `element` is required by both content models. `uri` and `propertiesXml` are
+* optional and must be absent rather than `null`: the model spells an absent
+* field as absent, and a `null` stored on the layer would reach the serializer
+* as a `w:uri=""` the source never wrote.
+*/
+const taggedLayerValidator = (label) => (layer, path, issues) => {
+	requiredString(layer, "element", `${path}.element`, issues);
+	for (const key of ["uri", "propertiesXml"]) if (layer[key] !== void 0 && typeof layer[key] !== "string") issues.push({
+		path: `${path}.${key}`,
+		message: "Expected a string."
+	});
+	for (const key of Object.keys(layer)) if (!TAGGED_LAYER_KEYS.has(key)) issues.push({
+		path: `${path}.${key}`,
+		message: `Unexpected ${label} wrapper property.`
+	});
+};
+/**
+* One validator per wrapper kind, total over the kinds the model declares: a
+* kind added without a field-by-field check does not compile, and a layer that
+* states a field its kind does not carry (a smart tag with a bidi `control`)
+* is rejected rather than stored and written back.
+*/
+const INLINE_WRAPPER_LAYER_VALIDATORS = {
+	bidi: (layer, path, issues) => {
+		requiredOneOf(layer, "control", `${path}.control`, issues, BIDI_LAYER_CONTROLS);
+		optionalOneOf(layer, "direction", `${path}.direction`, issues, BIDI_LAYER_DIRECTIONS);
+		for (const key of Object.keys(layer)) if (!BIDI_LAYER_KEYS.has(key)) issues.push({
+			path: `${path}.${key}`,
+			message: "Unexpected bidi wrapper property."
+		});
+	},
+	smartTag: taggedLayerValidator("smart tag"),
+	customXml: taggedLayerValidator("custom XML")
+};
+const inlineWrapperLayerValidator = (kind) => {
+	return typeof kind === "string" ? INLINE_WRAPPER_LAYER_VALIDATORS[kind] : void 0;
+};
+const validateInlineWrapperStack = (value, path, issues) => {
+	if (!Array.isArray(value)) {
+		issues.push({
+			path,
+			message: "Expected an array of inline wrapper layers."
+		});
+		return;
+	}
+	if (value.length === 0) {
+		issues.push({
+			path,
+			message: "Expected at least one inline wrapper layer."
+		});
+		return;
+	}
+	for (const [index, layer] of value.entries()) {
+		const layerPath = `${path}[${index}]`;
+		if (!isRecord(layer)) {
+			issues.push({
+				path: layerPath,
+				message: "Expected an inline wrapper layer object."
+			});
+			continue;
+		}
+		const validator = inlineWrapperLayerValidator(layer["kind"]);
+		if (!validator) {
+			issues.push({
+				path: `${layerPath}.kind`,
+				message: `Expected one of ${Object.keys(INLINE_WRAPPER_LAYER_VALIDATORS).join(", ")}.`
+			});
+			continue;
+		}
+		validator(layer, layerPath, issues);
+	}
+};
+/**
+* A wrapper stack read from outside the editor — the DOM on paste, a stored
+* snapshot — validated layer by layer.
+*/
+const readInlineWrapperStack = (value, path = "inlineWrapper.attrs.stack") => {
+	const issues = [];
+	validateInlineWrapperStack(value, path, issues);
+	if (issues.length > 0) return {
+		ok: false,
+		issues
+	};
+	return {
+		ok: true,
+		value
+	};
+};
+const readInlineWrapperMarkAttrs = (mark) => {
+	const attrs = attrsRecord(mark.attrs);
+	const issues = [];
+	expectMarkType(mark, "inlineWrapper", issues);
+	validateInlineWrapperStack(attrs["stack"], "inlineWrapper.attrs.stack", issues);
 	return attrsResult(attrs, issues);
 };
-const expectPageBreakRunOwnerMarkAttrs = (mark) => expectCachedMarkAttrs(mark, pageBreakRunOwnerAttrsCache, readPageBreakRunOwnerMarkAttrs, "page break run owner attrs");
+const expectInlineWrapperMarkAttrs = (mark) => expectCachedMarkAttrs(mark, inlineWrapperAttrsCache, readInlineWrapperMarkAttrs, "inline wrapper attrs");
 const readRunFormattingOverrideMarkAttrs = (mark) => {
 	const attrs = attrsRecord(mark.attrs);
 	const issues = [];
@@ -870,7 +1057,30 @@ const mergeImageAttrs = (node, patch) => {
 const mergeParagraphAttrs = (node, patch) => mergeNodeAttrs(node, readParagraphAttrs, "paragraph attrs", patch);
 const mergeTableAttrs = (node, patch) => mergeNodeAttrs(node, readTableAttrs, "table attrs", patch);
 const mergeTableRowAttrs = (node, patch) => mergeNodeAttrs(node, readTableRowAttrs, "table row attrs", patch);
-const mergeTableCellAttrs = (node, patch) => mergeNodeAttrs(node, readTableCellAttrs, "table cell attrs", patch);
+/**
+* A command that moves a cell's width states one.
+*
+* `width` is also where the table's resolved grid width lands for a cell that
+* declares no `w:tcW`, so the save leg reads `_authoredWidth` instead. Deriving
+* it here rather than at each command keeps the two from drifting: a command
+* cannot set a width without recording that the cell now states it, and one
+* that clears the width clears the record with it.
+*/
+const mergeTableCellAttrs = (node, patch) => {
+	const merged = mergeNodeAttrs(node, readTableCellAttrs, "table cell attrs", patch);
+	if (!("width" in patch) && !("widthType" in patch)) return merged;
+	if (merged.width === void 0) {
+		const { _authoredWidth: _cleared, ...withoutStatedWidth } = merged;
+		return withoutStatedWidth;
+	}
+	return {
+		...merged,
+		_authoredWidth: {
+			value: merged.width,
+			type: merged.widthType ?? "dxa"
+		}
+	};
+};
 const attrsRecord = (attrs) => {
 	if (isRecord(attrs)) return attrs;
 	return {};
@@ -1139,7 +1349,7 @@ const optionalTextColor = (attrs, key, path, issues) => {
 };
 const optionalTextColorFields = (attrs, path, issues) => {
 	optionalString(attrs, "rgb", `${path}.rgb`, issues);
-	optionalOneOf(attrs, "themeColor", `${path}.themeColor`, issues, THEME_COLOR_SLOT_VALUES);
+	optionalOneOf(attrs, "themeColor", `${path}.themeColor`, issues, THEME_COLORS);
 	optionalString(attrs, "themeTint", `${path}.themeTint`, issues);
 	optionalString(attrs, "themeShade", `${path}.themeShade`, issues);
 };
@@ -1163,6 +1373,36 @@ const optionalBoolean = (attrs, key, path, issues) => {
 		message: "Expected a boolean."
 	});
 };
+/**
+* `outlineLevel` is a union, and a bare number is the shape a pre-union
+* snapshot carries. Rejecting it is what keeps that snapshot from being read
+* as if it were this one: ProseMirror's `computeAttrs` copies a stored value
+* into the node without validating, so an unrecognised shape would otherwise
+* reach every consumer as an outline level none of them can read and all of
+* them ignore.
+*/
+const optionalOutlineLevel = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (outlineLevelFromAttrValue(value) === null) issues.push({
+		path,
+		message: "Expected { kind: \"bodyText\" } or { kind: \"heading\", level: 0-8 }."
+	});
+};
+/**
+* Strict, field by field, per arm. An object with no known `kind` is refused
+* rather than read as the arm it is not: the pre-union shape (the two
+* `<w:numPr>` slots) is exactly such an object, ProseMirror copies a stored
+* attr into the node without validating, and every consumer switches on `kind`.
+*/
+const optionalParagraphNumbering = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (paragraphNumberingFromAttrValue(value) === null) issues.push({
+		path,
+		message: "Expected { kind: \"none\" }, { kind: \"reference\", numId: 1+, ilvl?: 0+ } or { kind: \"levelOnly\", ilvl: 0+ }."
+	});
+};
 const optionalRecord = (attrs, key, path, issues) => {
 	const value = attrs[key];
 	if (value !== void 0 && value !== null && !isRecord(value)) issues.push({
@@ -1170,6 +1410,21 @@ const optionalRecord = (attrs, key, path, issues) => {
 		message: "Expected an object."
 	});
 };
+/** `TableCellAttrs._authoredWidth`: a measurement, or absent. */
+const optionalAuthoredWidth = (attrs, issues) => {
+	const value = attrs["_authoredWidth"];
+	if (value === void 0 || value === null) return;
+	const path = "tableCell.attrs._authoredWidth";
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	requiredNumber(value, "value", `${path}.value`, issues);
+	requiredOneOf(value, "type", `${path}.type`, issues, TABLE_WIDTH_TYPE_VALUES);
+};
 const optionalTableRowRevision = (attrs, key, issues) => {
 	const value = attrs[key];
 	if (value === void 0 || value === null) return;
@@ -1303,8 +1558,197 @@ const validateSdtAttrsRecord = (attrs, path, issues) => {
 	optionalSdtListItems(attrs, "listItems", `${path}.listItems`, issues);
 	optionalString(attrs, "dropdownLastValue", `${path}.dropdownLastValue`, issues);
 	optionalBoolean(attrs, "checked", `${path}.checked`, issues);
-	optionalString(attrs, "rawPropertiesXml", `${path}.rawPropertiesXml`, issues);
+	optionalPreservedMarkup(attrs, "_preserved", `${path}._preserved`, issues);
 	optionalString(attrs, "rawEndPropertiesXml", `${path}.rawEndPropertiesXml`, issues);
+	optionalSdtEndProperties(attrs, `${path}.endProperties`, issues);
+};
+/**
+* The attribute remainder an authored element's record carries.
+*
+* Every entry is a resolved name and a string value; nothing here is a
+* spelling, which is why the namespace is a URI and optional rather than a
+* prefix. See `docx/attributeRemainder.ts`.
+*/
+/**
+* The stack of row- or cell-level content controls a table node carries.
+*
+* Only `sdtType` is required: the rest of `SdtProperties` is an optional
+* projection over a `w:sdtPr` whose bytes the record also carries, and a
+* reader that demanded more would reject a control folio itself built.
+*/
+const optionalContentControls = (attrs, path, issues) => {
+	const value = attrs["contentControls"];
+	if (value === void 0 || value === null) return;
+	if (!Array.isArray(value)) {
+		issues.push({
+			path,
+			message: "Expected an array."
+		});
+		return;
+	}
+	for (const [index, entry] of value.entries()) {
+		const entryPath = `${path}[${index}]`;
+		if (!isRecord(entry)) {
+			issues.push({
+				path: entryPath,
+				message: "Expected an object."
+			});
+			continue;
+		}
+		requiredString(entry, "sdtType", `${entryPath}.sdtType`, issues);
+	}
+};
+/** A table sink entry may itself sit inside a row- or cell-level control. */
+const optionalTablePreservedMarkup = (attrs, key, path, issues) => {
+	optionalPreservedMarkup(attrs, key, path, issues);
+	const value = attrs[key];
+	if (!isRecord(value) || !Array.isArray(value["children"])) return;
+	for (const [index, child] of value["children"].entries()) {
+		if (!isRecord(child)) continue;
+		optionalContentControls(child, `${path}.children[${index}].contentControls`, issues);
+	}
+};
+/**
+* `w:sdtEndPr` as a record: an object whose presence is the element's, with
+* optional run properties inside. `optionalTextFormatting` owns the shape of
+* those, so the reader stays one line rather than a second copy of `w:rPr`.
+*/
+const optionalSdtEndProperties = (attrs, path, issues) => {
+	const value = attrs["endProperties"];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	optionalTextFormatting(value, "runProperties", `${path}.runProperties`, issues);
+};
+const optionalPreservedAttributes = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!Array.isArray(value)) {
+		issues.push({
+			path,
+			message: "Expected an array."
+		});
+		return;
+	}
+	for (const [index, entry] of value.entries()) {
+		const entryPath = `${path}[${index}]`;
+		if (!isRecord(entry)) {
+			issues.push({
+				path: entryPath,
+				message: "Expected an object."
+			});
+			continue;
+		}
+		requiredString(entry, "name", `${entryPath}.name`, issues);
+		requiredString(entry, "value", `${entryPath}.value`, issues);
+		optionalString(entry, "namespace", `${entryPath}.namespace`, issues);
+		const name = entry["name"];
+		const namespace = entry["namespace"];
+		if (typeof name === "string" && (namespace === void 0 || typeof namespace === "string") && !isSerializablePreservedAttribute({
+			name,
+			...namespace === void 0 ? {} : { namespace }
+		})) issues.push({
+			path: `${entryPath}.name`,
+			message: "Expected an XML local name in a namespace the serializer binds."
+		});
+	}
+};
+const optionalPreservedMarkup = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	const children = value["children"];
+	if (children === void 0 || children === null) return;
+	if (!Array.isArray(children)) {
+		issues.push({
+			path: `${path}.children`,
+			message: "Expected an array."
+		});
+		return;
+	}
+	if (!isWithinPreservedMarkupBudget(children)) {
+		issues.push({
+			path: `${path}.children`,
+			message: "Preserved XML exceeds its aggregate count or character budget."
+		});
+		return;
+	}
+	for (const [index, entry] of children.entries()) {
+		const entryPath = `${path}.children[${index}]`;
+		if (!isRecord(entry)) {
+			issues.push({
+				path: entryPath,
+				message: "Expected an object."
+			});
+			continue;
+		}
+		requiredNumber(entry, "index", `${entryPath}.index`, issues);
+		requiredString(entry, "xml", `${entryPath}.xml`, issues);
+		const xml = entry["xml"];
+		if (typeof xml === "string" && !isSafePreservedChildXml(xml)) issues.push({
+			path: `${entryPath}.xml`,
+			message: "Expected one bounded, well-formed XML element."
+		});
+	}
+};
+/**
+* Bookmark markers a table or a row held beside its own children.
+*
+* Each entry is a position among those children and the marker that stood
+* there. The marker itself is the same shape the boundary node carries, so it
+* is validated the same way: an id, and a name when it is a start.
+*/
+const optionalPositionedBookmarks = (attrs, path, issues) => {
+	const value = attrs["_bookmarks"];
+	if (value === void 0 || value === null) return;
+	if (!Array.isArray(value)) {
+		issues.push({
+			path,
+			message: "Expected an array."
+		});
+		return;
+	}
+	for (const [index, entry] of value.entries()) {
+		const entryPath = `${path}[${index}]`;
+		if (!isRecord(entry)) {
+			issues.push({
+				path: entryPath,
+				message: "Expected an object."
+			});
+			continue;
+		}
+		requiredNumber(entry, "index", `${entryPath}.index`, issues);
+		const marker = entry["marker"];
+		if (!isRecord(marker)) {
+			issues.push({
+				path: `${entryPath}.marker`,
+				message: "Expected an object."
+			});
+			continue;
+		}
+		const type = marker["type"];
+		if (type !== "bookmarkStart" && type !== "bookmarkEnd") {
+			issues.push({
+				path: `${entryPath}.marker.type`,
+				message: "Expected \"bookmarkStart\" or \"bookmarkEnd\"."
+			});
+			continue;
+		}
+		requiredNumber(marker, "id", `${entryPath}.marker.id`, issues);
+		if (type === "bookmarkStart") requiredString(marker, "name", `${entryPath}.marker.name`, issues);
+		optionalContentControls(entry, `${entryPath}.contentControls`, issues);
+	}
 };
 const optionalAutospacingBase = (attrs, path, issues) => {
 	const value = attrs["_autospacingBase"];
@@ -1346,6 +1790,7 @@ const validateBorderSpec = (value, path, issues) => {
 	optionalBoolean(value, "shadow", `${path}.shadow`, issues);
 	optionalBoolean(value, "frame", `${path}.frame`, issues);
 	optionalColorValue(value, "color", `${path}.color`, issues);
+	optionalPreservedAttributes(value, "preservedAttributes", `${path}.preservedAttributes`, issues);
 };
 const optionalColorValue = (attrs, key, path, issues) => {
 	const value = attrs[key];
@@ -1359,7 +1804,7 @@ const optionalColorValue = (attrs, key, path, issues) => {
 	}
 	optionalString(value, "rgb", `${path}.rgb`, issues);
 	optionalBoolean(value, "auto", `${path}.auto`, issues);
-	optionalOneOf(value, "themeColor", `${path}.themeColor`, issues, THEME_COLOR_SLOT_VALUES);
+	optionalOneOf(value, "themeColor", `${path}.themeColor`, issues, THEME_COLORS);
 	optionalString(value, "themeTint", `${path}.themeTint`, issues);
 	optionalString(value, "themeShade", `${path}.themeShade`, issues);
 };
@@ -1376,6 +1821,7 @@ const optionalShading = (attrs, key, path, issues) => {
 	optionalColorValue(value, "color", `${path}.color`, issues);
 	optionalColorValue(value, "fill", `${path}.fill`, issues);
 	optionalOneOf(value, "pattern", `${path}.pattern`, issues, SHADING_PATTERN_VALUES);
+	optionalPreservedAttributes(value, "preservedAttributes", `${path}.preservedAttributes`, issues);
 };
 const optionalTabStops = (attrs, key, path, issues) => {
 	const value = attrs[key];
@@ -1399,6 +1845,7 @@ const optionalTabStops = (attrs, key, path, issues) => {
 		requiredNumber(item, "position", `${itemPath}.position`, issues);
 		requiredOneOf(item, "alignment", `${itemPath}.alignment`, issues, TAB_STOP_ALIGNMENT_VALUES);
 		optionalOneOf(item, "leader", `${itemPath}.leader`, issues, TAB_LEADER_VALUES);
+		optionalPreservedAttributes(item, "preservedAttributes", `${itemPath}.preservedAttributes`, issues);
 	}
 };
 const optionalTextFormatting = (attrs, key, path, issues) => {
@@ -1637,8 +2084,7 @@ const PARAGRAPH_FORMATTING_NUMBER_KEYS = [
 	"lineSpacing",
 	"indentLeft",
 	"indentRight",
-	"indentFirstLine",
-	"outlineLevel"
+	"indentFirstLine"
 ];
 const validateParagraphFormatting = (value, path, issues) => {
 	optionalOneOf(value, "alignment", `${path}.alignment`, issues, PARAGRAPH_ALIGNMENT_VALUES);
@@ -1651,6 +2097,7 @@ const validateParagraphFormatting = (value, path, issues) => {
 		"listMarkerAllCaps"
 	]) optionalBoolean(value, key, `${path}.${key}`, issues);
 	for (const key of PARAGRAPH_FORMATTING_NUMBER_KEYS) optionalNumber(value, key, `${path}.${key}`, issues);
+	optionalOutlineLevel(value, "outlineLevel", `${path}.outlineLevel`, issues);
 	for (const key of [
 		"listImplicitChildLevelAdvances",
 		"listMarkerSecondSlotOffsetTwips",
@@ -1660,7 +2107,7 @@ const validateParagraphFormatting = (value, path, issues) => {
 	optionalOneOf(value, "lineSpacingRule", `${path}.lineSpacingRule`, issues, LINE_SPACING_RULE_VALUES);
 	optionalString(value, "styleId", `${path}.styleId`, issues);
 	optionalString(value, "numberingChangeXml", `${path}.numberingChangeXml`, issues);
-	optionalOneOf(value, "listNumFmt", `${path}.listNumFmt`, issues, NUMBER_FORMAT_VALUES);
+	optionalOneOf(value, "listNumFmt", `${path}.listNumFmt`, issues, COUNTER_FORMAT_VALUES);
 	optionalString(value, "listMarker", `${path}.listMarker`, issues);
 	optionalString(value, "listMarkerTemplate", `${path}.listMarkerTemplate`, issues);
 	optionalTextFormatting(value, "listMarkerFormatting", `${path}.listMarkerFormatting`, issues);
@@ -1674,22 +2121,10 @@ const validateParagraphFormatting = (value, path, issues) => {
 		"space",
 		"nothing"
 	]);
-	optionalOneOfArray(value, "listLevelNumFmts", `${path}.listLevelNumFmts`, issues, NUMBER_FORMAT_VALUES);
+	optionalOneOfArray(value, "listLevelNumFmts", `${path}.listLevelNumFmts`, issues, COUNTER_FORMAT_VALUES);
 	optionalNumberArray(value, "listLevelStarts", `${path}.listLevelStarts`, issues);
 	optionalAutospacingBase(value, `${path}._autospacingBase`, issues);
-	for (const key of ["numPr", "numPrFromStyle"]) {
-		const nested = value[key];
-		if (nested === void 0 || nested === null) continue;
-		if (!isRecord(nested)) {
-			issues.push({
-				path: `${path}.${key}`,
-				message: "Expected an object."
-			});
-			continue;
-		}
-		optionalNumber(nested, "numId", `${path}.${key}.numId`, issues);
-		optionalNumber(nested, "ilvl", `${path}.${key}.ilvl`, issues);
-	}
+	for (const key of ["numPr", "numPrFromStyle"]) optionalParagraphNumbering(value, key, `${path}.${key}`, issues);
 	const direction = value["direction"];
 	if (direction !== void 0 && direction !== null && !isParagraphDirection(direction)) issues.push({
 		path: `${path}.direction`,
@@ -1722,6 +2157,8 @@ const validateParagraphFormatting = (value, path, issues) => {
 	]);
 	optionalShading(value, "shading", `${path}.shading`, issues);
 	optionalTabStops(value, "tabs", `${path}.tabs`, issues);
+	optionalPreservedMarkup(value, "preserved", `${path}.preserved`, issues);
+	for (const key of ["indentPreservedAttributes", "spacingPreservedAttributes"]) optionalPreservedAttributes(value, key, `${path}.${key}`, issues);
 	optionalNestedRecord(value, "runProperties", `${path}.runProperties`, issues, validateTextFormatting);
 	const frame = value["frame"];
 	if (frame !== void 0 && frame !== null) if (!isRecord(frame)) issues.push({
@@ -1776,6 +2213,7 @@ const validateParagraphFormatting = (value, path, issues) => {
 			"x",
 			"y"
 		]) optionalNumber(frame, key, `${path}.frame.${key}`, issues);
+		optionalPreservedAttributes(frame, "preservedAttributes", `${path}.frame.preservedAttributes`, issues);
 	}
 };
 const validatePropertyChangeInfo = (value, path, issues) => {
@@ -1834,6 +2272,20 @@ const WRAP_DISTANCE_ATTRS = [
 	"distLeft",
 	"distRight"
 ];
+/** The inset keys the model names them by, which the slot records are keyed on. */
+const WRAP_DISTANCE_MODEL_KEYS = [
+	"distT",
+	"distB",
+	"distL",
+	"distR"
+];
+/** The `wp:effectExtent` sides the model names them by, keyed as the slots are. */
+const EFFECT_EXTENT_MODEL_KEYS = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
 const TEXT_BOX_MARGIN_ATTRS = [
 	"marginTop",
 	"marginBottom",
@@ -1865,6 +2317,150 @@ const optionalImageFrameLocks = (attrs, key, path, issues) => {
 	}
 	for (const lock of GRAPHIC_FRAME_LOCK_KEYS) optionalBoolean(value, lock, `${path}.${lock}`, issues);
 };
+/**
+* `wp:anchor`'s own attributes, carried through the editor as one record.
+*
+* The walk is over {@link DRAWING_ANCHOR_FLAG_KEYS}, which the serializer's own
+* total map produces, so a flag added to the model is validated here without a
+* second list to keep in step.
+*/
+const optionalDrawingAnchor = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	for (const flag of DRAWING_ANCHOR_FLAG_KEYS) optionalBoolean(value, flag, `${path}.${flag}`, issues);
+	optionalNumber(value, "relativeHeight", `${path}.relativeHeight`, issues);
+	const simplePosition = value["simplePosition"];
+	if (simplePosition === void 0 || simplePosition === null) return;
+	if (!isRecord(simplePosition)) {
+		issues.push({
+			path: `${path}.simplePosition`,
+			message: "Expected an object."
+		});
+		return;
+	}
+	optionalNumber(simplePosition, "x", `${path}.simplePosition.x`, issues);
+	optionalNumber(simplePosition, "y", `${path}.simplePosition.y`, issues);
+};
+/** The EMU insets one of the two elements that can carry them stated. */
+const readWrapDistances = (slots, key, path, issues) => {
+	const value = slots[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	for (const inset of WRAP_DISTANCE_MODEL_KEYS) optionalNumber(value, inset, `${path}.${inset}`, issues);
+};
+/**
+* Which element stated each wrap inset, carried so a rebuild writes it back
+* there. The insets themselves reach the editor twice over — in pixels, and in
+* EMU on the authored carrier — and neither says which element they came from.
+*/
+const optionalWrapDistanceSlots = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	readWrapDistances(value, "drawing", `${path}.drawing`, issues);
+	readWrapDistances(value, "wrapChild", `${path}.wrapChild`, issues);
+};
+/** The EMU sides one of the two elements that can carry a reservation stated. */
+const readEffectExtent = (slots, key, path, issues) => {
+	const value = slots[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	for (const side of EFFECT_EXTENT_MODEL_KEYS) optionalNumber(value, side, `${path}.${side}`, issues);
+};
+/**
+* Which element stated a `wp:effectExtent`, carried so a rebuild writes each
+* back there. The drawing's reaches the editor a second time as `padding*`;
+* the wrap child's has no other carrier at all.
+*/
+const optionalEffectExtentSlots = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	readEffectExtent(value, "drawing", `${path}.drawing`, issues);
+	readEffectExtent(value, "wrapChild", `${path}.wrapChild`, issues);
+};
+/** A `CT_Point2D` on a wrap polygon: both coordinates, in the path's own units. */
+const readWrapPolygonPoint = (value, path, issues) => {
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	requiredNumber(value, "x", `${path}.x`, issues);
+	requiredNumber(value, "y", `${path}.y`, issues);
+};
+/** `wp:wrapPolygon` as authored, in the path's own units rather than EMU. */
+const optionalWrapPolygon = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	optionalBoolean(value, "edited", `${path}.edited`, issues);
+	readWrapPolygonPoint(value["start"], `${path}.start`, issues);
+	const lineTo = value["lineTo"];
+	if (!Array.isArray(lineTo)) {
+		issues.push({
+			path: `${path}.lineTo`,
+			message: "Expected an array."
+		});
+		return;
+	}
+	lineTo.forEach((point, index) => {
+		readWrapPolygonPoint(point, `${path}.lineTo[${index}]`, issues);
+	});
+};
+/** `a:hlinkClick` as captured: its own bytes, plus the target it named. */
+const optionalDocPrLink = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	requiredString(value, "xml", `${path}.xml`, issues);
+	optionalString(value, "rId", `${path}.rId`, issues);
+};
 const optionalImagePosition = (attrs, key, path, issues) => {
 	const value = attrs[key];
 	if (value === void 0 || value === null) return;
@@ -1951,11 +2547,6 @@ const optionalOneOfArray = (attrs, key, path, issues, allowed) => {
 		message: `Expected one of ${allowed.join(", ")}.`
 	});
 };
-const validateNumPr = (value, issues) => {
-	if (value === void 0 || value === null || !isRecord(value)) return;
-	validateNonNegativeInteger(value["numId"], "paragraph.attrs.numPr.numId", issues);
-	validateNonNegativeInteger(value["ilvl"], "paragraph.attrs.numPr.ilvl", issues);
-};
 const validateNonNegativeInteger = (value, path, issues) => {
 	if (value === void 0 || value === null) return;
 	if (typeof value !== "number") {
@@ -2024,4 +2615,4 @@ const optionalEmptyHyperlinkArray = (value, issues) => {
 	}
 };
 //#endregion
-export { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectPageBreakRunOwnerMarkAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readPageBreakRunOwnerMarkAttrs, readParagraphAttrs, readRunFormattingOverrideMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };
+export { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };