@stll/folio-core 0.45.0 → 0.47.0

package/dist/prosemirror/extensions/marks/InlineWrapperExtension.js

@@ -0,0 +1,77 @@
+import { expectInlineWrapperMarkAttrs } from "../../attrs/index.js";
+import { INLINE_WRAPPER_STACK_ATTRIBUTE, parseInlineWrapperStack, serializeInlineWrapperStack } from "../../inlineWrapperStack.js";
+import { createMarkExtension } from "../create.js";
+import { panic } from "better-result";
+//#region src/prosemirror/extensions/marks/InlineWrapperExtension.ts
+/**
+* Inline wrapper mark — the transparent wrappers a leaf sits inside.
+*
+* One mark for every wrapper kind rather than one mark per kind: ProseMirror's
+* mark set is unordered across types, so two marks could not say which wrapper
+* is inside which. The nesting lives in the `stack` attr, outermost first, and
+* the mark excludes itself (ProseMirror's default) because a second one would
+* be a second answer to the same question.
+*
+* `inclusive: false` so typing at the end of a wrapped span does not silently
+* extend the wrapper over text the author wrote outside it.
+*/
+const INLINE_WRAPPER_MARK_NAME = "inlineWrapper";
+/** What a tagged layer's element name is spelled as on the rendered span. */
+const TAGGED_ELEMENT_ATTRIBUTES = {
+	smartTag: "data-smart-tag-element",
+	customXml: "data-custom-xml-element"
+};
+/**
+* How one layer is spelled in HTML.
+*
+* `w:bdo` is `unicode-bidi: bidi-override`, which HTML gives an element of its
+* own; `w:dir` is `unicode-bidi: embed`, which a `dir`-carrying span states.
+* A smart tag and a custom-XML wrapper say nothing about layout, so they are a
+* passthrough `<span>` that names the tagged element for a stylesheet or a
+* host that wants to show it; the stack attribute is what carries them back.
+*/
+const layerElement = (layer, attributes) => {
+	switch (layer.kind) {
+		case "bidi":
+			if (layer.direction !== void 0) attributes["dir"] = layer.direction;
+			return [
+				layer.control === "override" ? "bdo" : "span",
+				attributes,
+				0
+			];
+		case "smartTag":
+		case "customXml":
+			attributes[TAGGED_ELEMENT_ATTRIBUTES[layer.kind]] = layer.element;
+			return [
+				"span",
+				attributes,
+				0
+			];
+		default: panic(`Unspelled inline wrapper layer: ${JSON.stringify(layer)}`);
+	}
+};
+const InlineWrapperExtension = createMarkExtension({
+	name: INLINE_WRAPPER_MARK_NAME,
+	schemaMarkName: INLINE_WRAPPER_MARK_NAME,
+	markSpec: {
+		attrs: { 
+		/** Outermost first. `null` is no wrapper, which is the absence of the mark. */
+stack: { default: null } },
+		inclusive: false,
+		parseDOM: [{
+			tag: `[${INLINE_WRAPPER_STACK_ATTRIBUTE}]`,
+			getAttrs(dom) {
+				const stack = parseInlineWrapperStack(dom.getAttribute(INLINE_WRAPPER_STACK_ATTRIBUTE));
+				return stack === null ? false : { stack };
+			}
+		}],
+		toDOM(mark) {
+			const { stack } = expectInlineWrapperMarkAttrs(mark);
+			const innermost = stack.at(-1);
+			if (innermost === void 0) panic("An inline wrapper mark carries at least one layer");
+			return layerElement(innermost, { [INLINE_WRAPPER_STACK_ATTRIBUTE]: serializeInlineWrapperStack(stack) });
+		}
+	}
+});
+//#endregion
+export { INLINE_WRAPPER_MARK_NAME, InlineWrapperExtension };

package/dist/prosemirror/extensions/marks/RunIdentityExtension.d.ts

@@ -0,0 +1,26 @@
+import { MarkExtension } from "../types.js";
+//#region src/prosemirror/extensions/marks/RunIdentityExtension.d.ts
+/**
+ * Editor-side identity for one authored `w:r`, and the payload that element
+ * carried which no formatting mark holds.
+ *
+ * Ordinary formatting marks cannot tell two adjacent source runs with
+ * identical properties apart, so the save leg would fold them into one and
+ * discard whichever record it did not keep. This mark is what keeps them
+ * apart: it is in `getMarksKey`, so a change of identity is a run boundary,
+ * and `joinsOwnedSourceRun` rejoins the leaves a page break cut out of one
+ * authored run.
+ *
+ * `inclusive: false` settles the edges. The interior is settled by the strip
+ * below: ProseMirror's stored marks at a position inside a span include every
+ * mark of the preceding character, so text typed inside an authored run would
+ * otherwise ride that run's `w:rsidR` — a claim about which editing session
+ * wrote it. folio cannot register a session (`settings.xml`'s `w:rsids` is
+ * copied through on every repack, and no save path mints one), so it must
+ * never write a session id it did not read. Typed text becomes its own run
+ * with no attributes instead, and `w:rsidRDefault` on the parent `w:p`
+ * supplies the session the format itself says such a run belongs to.
+ */
+declare const RunIdentityExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { RunIdentityExtension };

package/dist/prosemirror/extensions/marks/RunIdentityExtension.js

@@ -0,0 +1,134 @@
+import { expectRunIdentityMarkAttrs } from "../../attrs/index.js";
+import { RUN_IDENTITY_ATTRIBUTE, RUN_IDENTITY_MARK_NAME, runIdentityAttrs } from "../../runIdentity.js";
+import { createMarkExtension } from "../create.js";
+import { Plugin, PluginKey } from "prosemirror-state";
+//#region src/prosemirror/extensions/marks/RunIdentityExtension.ts
+/**
+* Editor-side identity for one authored `w:r`, and the payload that element
+* carried which no formatting mark holds.
+*
+* Ordinary formatting marks cannot tell two adjacent source runs with
+* identical properties apart, so the save leg would fold them into one and
+* discard whichever record it did not keep. This mark is what keeps them
+* apart: it is in `getMarksKey`, so a change of identity is a run boundary,
+* and `joinsOwnedSourceRun` rejoins the leaves a page break cut out of one
+* authored run.
+*
+* `inclusive: false` settles the edges. The interior is settled by the strip
+* below: ProseMirror's stored marks at a position inside a span include every
+* mark of the preceding character, so text typed inside an authored run would
+* otherwise ride that run's `w:rsidR` — a claim about which editing session
+* wrote it. folio cannot register a session (`settings.xml`'s `w:rsids` is
+* copied through on every repack, and no save path mints one), so it must
+* never write a session id it did not read. Typed text becomes its own run
+* with no attributes instead, and `w:rsidRDefault` on the parent `w:p`
+* supplies the session the format itself says such a run belongs to.
+*/
+const CANONICAL_RUN_IDENTITY_ID = /^(?:0|[1-9]\d*)$/u;
+const runIdentityStripKey = new PluginKey("runIdentityStrip");
+/**
+* Every range `transactions` inserted, in the document they produced.
+*
+* A step map reports each replacement as an old span and the new span it
+* became; a new span longer than nothing is content the step put there, which
+* is exactly the text that may not claim an authored run. Each range is then
+* carried through the steps that followed it — the rest of its own
+* transaction, then every later one — so a batch applied together reports
+* positions in the document this hook is looking at rather than in an
+* intermediate one.
+*/
+const insertedRanges = (transactions) => {
+	const ranges = [];
+	for (const [transactionIndex, transaction] of transactions.entries()) {
+		const later = transactions.slice(transactionIndex + 1);
+		const carryForward = (pos, bias) => {
+			let mapped = pos;
+			for (const next of later) mapped = next.mapping.map(mapped, bias);
+			return mapped;
+		};
+		transaction.mapping.maps.forEach((stepMap, stepIndex) => {
+			const rest = transaction.mapping.slice(stepIndex + 1);
+			stepMap.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
+				if (newEnd <= newStart) return;
+				ranges.push({
+					from: carryForward(rest.map(newStart, -1), -1),
+					to: carryForward(rest.map(newEnd, 1), 1)
+				});
+			});
+		});
+	}
+	return ranges;
+};
+/**
+* Remove `runIdentity` from what a transaction inserted.
+*
+* Runs after the edit rather than in front of it because an insertion's marks
+* are decided by ProseMirror from the text around it, and there is no hook
+* that sees every route to that decision: typing, paste, a command and a
+* collaborative apply all arrive here and nowhere else in common.
+*/
+const createRunIdentityStripPlugin = () => new Plugin({
+	key: runIdentityStripKey,
+	appendTransaction(transactions, _oldState, newState) {
+		if (!transactions.some((transaction) => transaction.docChanged)) return null;
+		const markType = newState.schema.marks[RUN_IDENTITY_MARK_NAME];
+		if (markType === void 0) return null;
+		const ranges = insertedRanges(transactions);
+		if (ranges.length === 0) return null;
+		const tr = newState.tr;
+		const stripRange = ({ from, to }) => {
+			const clampedTo = Math.min(to, newState.doc.content.size);
+			const clampedFrom = Math.min(from, clampedTo);
+			if (clampedFrom === clampedTo) return false;
+			let rangeStripped = false;
+			newState.doc.nodesBetween(clampedFrom, clampedTo, (node, pos) => {
+				if (!node.isInline || !markType.isInSet(node.marks)) return true;
+				tr.removeMark(Math.max(pos, clampedFrom), Math.min(pos + node.nodeSize, clampedTo), markType);
+				rangeStripped = true;
+				return true;
+			});
+			return rangeStripped;
+		};
+		let stripped = false;
+		for (const range of ranges) stripped = stripRange(range) || stripped;
+		if (!stripped) return null;
+		tr.setMeta("addToHistory", false);
+		tr.setMeta(runIdentityStripKey, "stripped");
+		if (newState.storedMarks !== null) tr.setStoredMarks(newState.storedMarks.filter((mark) => mark.type !== markType));
+		return tr;
+	}
+});
+const RunIdentityExtension = createMarkExtension({
+	name: RUN_IDENTITY_MARK_NAME,
+	schemaMarkName: RUN_IDENTITY_MARK_NAME,
+	markSpec: {
+		attrs: {
+			id: {},
+			preservedAttributes: { default: null },
+			preserved: { default: null }
+		},
+		inclusive: false,
+		parseDOM: [{
+			tag: `span[${RUN_IDENTITY_ATTRIBUTE}]`,
+			getAttrs(dom) {
+				const rawId = dom.dataset["docxRunIdentity"];
+				if (rawId === void 0 || !CANONICAL_RUN_IDENTITY_ID.test(rawId)) return false;
+				const id = Number(rawId);
+				return Number.isSafeInteger(id) ? runIdentityAttrs(id) : false;
+			}
+		}],
+		toDOM(mark) {
+			const { id } = expectRunIdentityMarkAttrs(mark);
+			return [
+				"span",
+				{ [RUN_IDENTITY_ATTRIBUTE]: String(id) },
+				0
+			];
+		}
+	},
+	onSchemaReady() {
+		return { plugins: [createRunIdentityStripPlugin()] };
+	}
+});
+//#endregion
+export { RunIdentityExtension };

package/dist/prosemirror/extensions/marks/TrackedChangeExtensions.js

@@ -100,7 +100,8 @@ const DeletionExtension = createMarkExtension({
 			moveKind: { default: null },
 			initials: { default: null },
 			provenance: { default: "user" },
-			suggestionId: { default: null }
+			suggestionId: { default: null },
+			_historicalFormatting: { default: null }
 		},
 		inclusive: false,
 		parseDOM: [{

package/dist/prosemirror/extensions/marks/UnderlineExtension.js

@@ -1,3 +1,4 @@
+import { PLAIN_UNDERLINE, underlineDecorationCss, underlineStyleFromCssDecoration } from "../../../utils/formatToStyle.js";
 import { expectUnderlineMarkAttrs } from "../../attrs/index.js";
 import { createMarkExtension } from "../create.js";
 import { setMark, toggleUnderlineMark } from "./markUtils.js";
@@ -6,39 +7,32 @@ import { panic } from "better-result";
 /**
 * Underline Mark Extension
 */
+/** `w:u w:val="none"`: the token that cancels an inherited underline. */
+const NO_UNDERLINE = "none";
 const UnderlineExtension = createMarkExtension({
 	name: "underline",
 	schemaMarkName: "underline",
 	markSpec: {
 		attrs: {
-			style: { default: "single" },
+			style: { default: PLAIN_UNDERLINE },
 			color: { default: null }
 		},
 		parseDOM: [{ tag: "u" }, {
 			style: "text-decoration",
 			getAttrs: (value) => {
-				if (value.includes("underline")) return {};
-				return value.includes("none") ? { style: "none" } : false;
+				if (value.includes("underline")) return { style: underlineStyleFromCssDecoration(value) };
+				return value.includes(NO_UNDERLINE) ? { style: NO_UNDERLINE } : false;
 			}
 		}],
 		toDOM(mark) {
-			const attrs = expectUnderlineMarkAttrs(mark);
-			const style = attrs.style;
-			const colorRgb = attrs.color?.rgb;
-			const cssStyle = [`text-decoration: ${style === "none" ? "none" : "underline"}`];
-			if (style && style !== "single" && style !== "none") {
-				const cssDecorationStyle = {
-					double: "double",
-					dotted: "dotted",
-					dash: "dashed",
-					wave: "wavy"
-				}[style];
-				if (cssDecorationStyle) cssStyle.push(`text-decoration-style: ${cssDecorationStyle}`);
-			}
-			if (colorRgb) cssStyle.push(`text-decoration-color: #${colorRgb}`);
+			const { style = PLAIN_UNDERLINE, color } = expectUnderlineMarkAttrs(mark);
+			const { decorationStyle, decorationThickness } = underlineDecorationCss(style);
+			const declarations = [`text-decoration: ${decorationStyle === void 0 ? NO_UNDERLINE : `underline ${decorationStyle}`}`];
+			if (decorationThickness !== void 0) declarations.push(`text-decoration-thickness: ${decorationThickness}`);
+			if (color?.rgb) declarations.push(`text-decoration-color: #${color.rgb}`);
 			return [
 				"span",
-				{ style: cssStyle.join("; ") },
+				{ style: declarations.join("; ") },
 				0
 			];
 		}

package/dist/prosemirror/extensions/marks/markUtils.d.ts

@@ -3,6 +3,7 @@ import { Command, EditorState } from "prosemirror-state";
 import { Mark, MarkType, Schema } from "prosemirror-model";
 //#region src/prosemirror/extensions/marks/markUtils.d.ts
 type MarkAttrs = Record<string, unknown>;
+declare function marksToTextFormatting(marks: readonly Mark[]): document_d_exports.TextFormatting;
 declare function setMark(markType: MarkType, attrs: MarkAttrs): Command;
 type PairedToggleProperty = "bold" | "italic";
 /** UI toggle whose direct-formatting contract explicitly targets both script families. */
@@ -46,4 +47,4 @@ declare function createSetMarkCommand(markType: MarkType, attrs?: Record<string,
  */
 declare function createRemoveMarkCommand(markType: MarkType): Command;
 //#endregion
-export { AuthoredRunFormattingCarrier, clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleMarkForAllScripts, toggleUnderlineMark };
+export { AuthoredRunFormattingCarrier, clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, marksToTextFormatting, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleMarkForAllScripts, toggleUnderlineMark };

package/dist/prosemirror/extensions/marks/markUtils.js

@@ -1,12 +1,13 @@
 import { FONT_THEME_VALUES } from "../../../types/documentEnumValues.js";
 import { mergeFontFamily } from "../../../utils/fontFamilyMerge.js";
 import { normalizeHorizontalScalePercent } from "../../../utils/horizontalScale.js";
-import { expectFontFamilyMarkAttrs, expectRunFormattingOverrideMarkAttrs } from "../../attrs/index.js";
-import { shadingToRunShadingAttrs } from "../../conversion/runShadingMark.js";
+import { expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectEmphasisMarkAttrs, expectFontFamilyMarkAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectStrikeMarkAttrs, expectTextEffectMarkAttrs } from "../../attrs/index.js";
+import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "../../conversion/runShadingMark.js";
 import { selectRunFormattingCarrierRepresentations } from "../../runFormattingInlineCarriers.js";
 import { hasRunFormattingOverrideAttrs } from "../../runFormattingProvenance.js";
 import { COMPLEX_SCRIPT_RUN_PROPERTY_KEYS } from "../../schema/marks.js";
 import { applyRunFormattingOverrideMark, buildRunFormattingOverrideAttrs } from "./RunFormattingOverrideExtension.js";
+import { readThemeColor } from "@stll/docx-core/model";
 import { toggleMark } from "prosemirror-commands";
 //#region src/prosemirror/extensions/marks/markUtils.ts
 const isFontTheme = (value) => value !== void 0 && FONT_THEME_VALUES.some((theme) => theme === value);
@@ -37,11 +38,12 @@ function marksToTextFormatting(marks) {
 			};
 			break;
 		case "strike":
-			formatting.strike = true;
+			if (expectStrikeMarkAttrs(mark).double) formatting.doubleStrike = true;
+			else formatting.strike = true;
 			break;
 		case "textColor": {
 			const colorRgb = mark.attrs["rgb"] !== null && mark.attrs["rgb"] !== void 0 ? String(mark.attrs["rgb"]) : void 0;
-			const colorTheme = mark.attrs["themeColor"] !== null && mark.attrs["themeColor"] !== void 0 ? String(mark.attrs["themeColor"]) : void 0;
+			const colorTheme = mark.attrs["themeColor"] !== null && mark.attrs["themeColor"] !== void 0 ? readThemeColor(String(mark.attrs["themeColor"])) : void 0;
 			const colorTint = mark.attrs["themeTint"] !== null && mark.attrs["themeTint"] !== void 0 ? String(mark.attrs["themeTint"]) : void 0;
 			const colorShade = mark.attrs["themeShade"] !== null && mark.attrs["themeShade"] !== void 0 ? String(mark.attrs["themeShade"]) : void 0;
 			formatting.color = {
@@ -55,6 +57,9 @@ function marksToTextFormatting(marks) {
 		case "highlight":
 			formatting.highlight = String(mark.attrs["color"]);
 			break;
+		case "runShading":
+			formatting.shading = runShadingAttrsToShading(expectRunShadingMarkAttrs(mark));
+			break;
 		case "fontSize":
 			formatting.fontSize = Number(mark.attrs["size"]);
 			break;
@@ -78,12 +83,51 @@ function marksToTextFormatting(marks) {
 		case "subscript":
 			formatting.vertAlign = "subscript";
 			break;
+		case "allCaps":
+			formatting.allCaps = true;
+			break;
+		case "smallCaps":
+			formatting.smallCaps = true;
+			break;
+		case "characterSpacing": {
+			const attrs = expectCharacterSpacingMarkAttrs(mark);
+			if (attrs.spacing !== void 0) formatting.spacing = attrs.spacing;
+			if (attrs.position !== void 0) formatting.position = attrs.position;
+			const scale = normalizeHorizontalScalePercent(attrs.scale);
+			if (scale !== void 0) formatting.scale = scale;
+			if (attrs.kerning !== void 0) formatting.kerning = attrs.kerning;
+			break;
+		}
+		case "emboss":
+			formatting.emboss = true;
+			break;
+		case "imprint":
+			formatting.imprint = true;
+			break;
+		case "hidden":
+			formatting.hidden = true;
+			break;
+		case "textShadow":
+			formatting.shadow = true;
+			break;
+		case "emphasisMark":
+			formatting.emphasisMark = expectEmphasisMarkAttrs(mark).type || "dot";
+			break;
+		case "textOutline":
+			formatting.outline = true;
+			break;
 		case "rtl":
 			formatting.rtl = true;
 			break;
+		case "textEffect":
+			formatting.effect = expectTextEffectMarkAttrs(mark).effect;
+			break;
 		case "runFormattingOverride":
 			applyRunFormattingOverrideMark(formatting, mark);
 			break;
+		case "characterStyle":
+			formatting.styleId = expectCharacterStyleMarkAttrs(mark).styleId;
+			break;
 		default: break;
 	}
 	return formatting;
@@ -486,4 +530,4 @@ function createRemoveMarkCommand(markType) {
 	return removeMark(markType);
 }
 //#endregion
-export { clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleMarkForAllScripts, toggleUnderlineMark };
+export { clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, marksToTextFormatting, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleMarkForAllScripts, toggleUnderlineMark };

package/dist/prosemirror/extensions/nodes/BlockBookmarkBoundaryExtension.d.ts

@@ -0,0 +1,29 @@
+import { NodeExtension } from "../types.js";
+//#region src/prosemirror/extensions/nodes/BlockBookmarkBoundaryExtension.d.ts
+/**
+ * A bookmark boundary that stands between two blocks.
+ *
+ * The block-level twin of `bookmarkBoundary`. `CT_Body`, `CT_Tc` and
+ * `CT_SdtContentBlock` declare `w:bookmarkStart`/`w:bookmarkEnd` beside their
+ * paragraphs and tables, and Word writes them there whenever the selection was
+ * whole blocks: `_GoBack` after an edit, a table-of-contents range around the
+ * headings it lists. ProseMirror decides inline or block per node type, so the
+ * inline atom cannot also sit here and this is its own node — with the same
+ * attributes, read by the same reader, so the two levels cannot describe a
+ * bookmark differently.
+ *
+ * **Position is structure, not an attribute**, for the reason
+ * `PreservedBlockExtension` gives: the node sits between the same two blocks it
+ * sat between in the source and ProseMirror's own mapping keeps it there, so an
+ * edit inside the range cannot change what the range covers.
+ *
+ * Pairing is owned one level up. A bookmark may open at block level and close
+ * inside a paragraph, which is the commoner shape in real documents, so the
+ * integrity pass in `BookmarkBoundaryExtension` reads both node types together;
+ * a rule enforced here would see half of each such pair and delete it.
+ */
+/** The node name, for callers asking what a block container holds. */
+declare const BLOCK_BOOKMARK_BOUNDARY_NODE_NAME = "blockBookmarkBoundary";
+declare const BlockBookmarkBoundaryExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion
+export { BLOCK_BOOKMARK_BOUNDARY_NODE_NAME, BlockBookmarkBoundaryExtension };

package/dist/prosemirror/extensions/nodes/BlockBookmarkBoundaryExtension.js

@@ -0,0 +1,46 @@
+import { createNodeExtension } from "../create.js";
+import { bookmarkBoundaryAttrSpec, bookmarkBoundaryDomAttributes, parseBookmarkBoundaryDom } from "./bookmarkBoundaryDom.js";
+//#region src/prosemirror/extensions/nodes/BlockBookmarkBoundaryExtension.ts
+/**
+* A bookmark boundary that stands between two blocks.
+*
+* The block-level twin of `bookmarkBoundary`. `CT_Body`, `CT_Tc` and
+* `CT_SdtContentBlock` declare `w:bookmarkStart`/`w:bookmarkEnd` beside their
+* paragraphs and tables, and Word writes them there whenever the selection was
+* whole blocks: `_GoBack` after an edit, a table-of-contents range around the
+* headings it lists. ProseMirror decides inline or block per node type, so the
+* inline atom cannot also sit here and this is its own node — with the same
+* attributes, read by the same reader, so the two levels cannot describe a
+* bookmark differently.
+*
+* **Position is structure, not an attribute**, for the reason
+* `PreservedBlockExtension` gives: the node sits between the same two blocks it
+* sat between in the source and ProseMirror's own mapping keeps it there, so an
+* edit inside the range cannot change what the range covers.
+*
+* Pairing is owned one level up. A bookmark may open at block level and close
+* inside a paragraph, which is the commoner shape in real documents, so the
+* integrity pass in `BookmarkBoundaryExtension` reads both node types together;
+* a rule enforced here would see half of each such pair and delete it.
+*/
+/** The node name, for callers asking what a block container holds. */
+const BLOCK_BOOKMARK_BOUNDARY_NODE_NAME = "blockBookmarkBoundary";
+const BlockBookmarkBoundaryExtension = createNodeExtension({
+	name: BLOCK_BOOKMARK_BOUNDARY_NODE_NAME,
+	schemaNodeName: BLOCK_BOOKMARK_BOUNDARY_NODE_NAME,
+	nodeSpec: {
+		group: "block",
+		atom: true,
+		selectable: false,
+		attrs: bookmarkBoundaryAttrSpec,
+		parseDOM: [{
+			tag: "div[data-docx-bookmark-boundary]",
+			getAttrs: parseBookmarkBoundaryDom
+		}],
+		toDOM(node) {
+			return ["div", bookmarkBoundaryDomAttributes(node)];
+		}
+	}
+});
+//#endregion
+export { BLOCK_BOOKMARK_BOUNDARY_NODE_NAME, BlockBookmarkBoundaryExtension };

package/dist/prosemirror/extensions/nodes/BlockSdtExtension.d.ts

@@ -12,9 +12,10 @@ import { NodeExtension } from "../types.js";
  * - `sdtType` / `alias` / `tag` / `lock` / `placeholder` /
  *   `showingPlaceholder` / `dateFormat` / `listItems` / `checked` — modeled
  *   projection of `w:sdtPr`; drives addressing and widget UX.
- * - `rawPropertiesXml` / `rawEndPropertiesXml` — verbatim original strings
- *   so unmodeled OOXML features (`w:dataBinding`, `w15:repeatingSection`,
- *   etc.) round-trip without being enumerated here.
+ * - `_preserved` — the `w:sdtPr` children folio does not model, at their
+ *   schema ordinal, so `w:dataBinding`, `w15:repeatingSection` and the
+ *   control-kind element round-trip without being enumerated here.
+ * - `rawEndPropertiesXml` — the verbatim `<w:sdtEndPr>`.
  */
 declare const BlockSdtExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
 //#endregion

package/dist/prosemirror/extensions/nodes/BlockSdtExtension.js

@@ -1,3 +1,4 @@
+import { onOffFromDataset } from "../../conversion/sdtAttrs.js";
 import { createNodeExtension } from "../create.js";
 //#region src/prosemirror/extensions/nodes/BlockSdtExtension.ts
 /**
@@ -12,9 +13,10 @@ import { createNodeExtension } from "../create.js";
 * - `sdtType` / `alias` / `tag` / `lock` / `placeholder` /
 *   `showingPlaceholder` / `dateFormat` / `listItems` / `checked` — modeled
 *   projection of `w:sdtPr`; drives addressing and widget UX.
-* - `rawPropertiesXml` / `rawEndPropertiesXml` — verbatim original strings
-*   so unmodeled OOXML features (`w:dataBinding`, `w15:repeatingSection`,
-*   etc.) round-trip without being enumerated here.
+* - `_preserved` — the `w:sdtPr` children folio does not model, at their
+*   schema ordinal, so `w:dataBinding`, `w15:repeatingSection` and the
+*   control-kind element round-trip without being enumerated here.
+* - `rawEndPropertiesXml` — the verbatim `<w:sdtEndPr>`.
 */
 const BlockSdtExtension = createNodeExtension({
 	name: "blockSdt",
@@ -31,7 +33,8 @@ const BlockSdtExtension = createNodeExtension({
 			id: { default: null },
 			lock: { default: null },
 			placeholder: { default: null },
-			showingPlaceholder: { default: false },
+			/** `w:showingPlcHdr`: `null` when the control states nothing. */
+			showingPlaceholder: { default: null },
 			dateFormat: { default: null },
 			/** ISO 8601 bound date value (`w:date@w:fullDate`). */
 			dateValueISO: { default: null },
@@ -52,9 +55,14 @@ const BlockSdtExtension = createNodeExtension({
 			* `<w:sdtContent><w:p/></w:sdtContent>` empty-paragraph content too.
 			*/
 			_originallyEmpty: { default: false },
-			rawPropertiesXml: { default: null },
+			_preserved: { default: null },
 			rawEndPropertiesXml: { default: null },
 			/**
+			* `w:sdtEndPr` as a record, so a control the editor rebuilds still
+			* writes its end mark once the captured bytes are gone.
+			*/
+			endProperties: { default: null },
+			/**
 			* Verbatim XML for direct sdt siblings of sdtContent (range markers
 			* per MS-OE376 §2.5.2.30). Two slots so position is preserved.
 			*/
@@ -65,10 +73,6 @@ const BlockSdtExtension = createNodeExtension({
 			tag: "div.docx-block-sdt",
 			getAttrs(dom) {
 				if (!(dom instanceof HTMLElement)) return false;
-				const checkedRaw = dom.dataset["checked"];
-				let checked = null;
-				if (checkedRaw === "true") checked = true;
-				else if (checkedRaw === "false") checked = false;
 				const idRaw = dom.dataset["sdtId"];
 				const id = idRaw ? Number.parseInt(idRaw, 10) : null;
 				return {
@@ -78,15 +82,16 @@ const BlockSdtExtension = createNodeExtension({
 					id: id !== null && !Number.isNaN(id) ? id : null,
 					lock: dom.dataset["lock"] ?? null,
 					placeholder: dom.dataset["placeholder"] ?? null,
-					showingPlaceholder: dom.dataset["showingPlaceholder"] === "true",
+					showingPlaceholder: onOffFromDataset(dom.dataset["showingPlaceholder"]),
 					dateFormat: dom.dataset["dateFormat"] ?? null,
 					dateValueISO: dom.dataset["dateValueIso"] ?? null,
 					listItems: dom.dataset["listItems"] ?? null,
 					dropdownLastValue: dom.dataset["dropdownLastValue"] ?? null,
-					checked,
+					checked: onOffFromDataset(dom.dataset["checked"]),
 					_originallyEmpty: dom.dataset["originallyEmpty"] === "true",
-					rawPropertiesXml: null,
+					_preserved: null,
 					rawEndPropertiesXml: null,
+					endProperties: null,
 					rawSdtChildrenBeforeContent: null,
 					rawSdtChildrenAfterContent: null
 				};
@@ -103,7 +108,7 @@ const BlockSdtExtension = createNodeExtension({
 			if (attrs["id"] !== null && attrs["id"] !== void 0) data["data-sdt-id"] = String(attrs["id"]);
 			if (attrs["lock"]) data["data-lock"] = String(attrs["lock"]);
 			if (attrs["placeholder"]) data["data-placeholder"] = String(attrs["placeholder"]);
-			if (attrs["showingPlaceholder"]) data["data-showing-placeholder"] = "true";
+			if (attrs["showingPlaceholder"] !== null && attrs["showingPlaceholder"] !== void 0) data["data-showing-placeholder"] = String(attrs["showingPlaceholder"]);
 			if (attrs["dateFormat"]) data["data-date-format"] = String(attrs["dateFormat"]);
 			if (attrs["dateValueISO"]) data["data-date-value-iso"] = String(attrs["dateValueISO"]);
 			if (attrs["listItems"]) data["data-list-items"] = String(attrs["listItems"]);