@stll/folio-core 0.46.0 → 0.47.1

package/dist/prosemirror/extensions/features/pasteCleanup.js

@@ -2,6 +2,7 @@ import { htmlCommentEnd } from "../../../utils/htmlComments.js";
 import { stripXmlDeclarations } from "../../../utils/stripXmlDeclarations.js";
 import { readBookmarkBoundaryAttrs } from "../../bookmarkBoundaryAttrs.js";
 import { findInvalidBookmarkBoundaryIds } from "../../bookmarkBoundaryIntegrity.js";
+import { readMoveRangeBoundaryAttrs } from "../../moveRangeBoundaryAttrs.js";
 import { Fragment, Slice } from "prosemirror-model";
 //#region src/prosemirror/extensions/features/pasteCleanup.ts
 /**
@@ -124,6 +125,8 @@ const MAX_EMPTY_SPAN_PASSES = 5;
 const INTERNAL_CLIPBOARD_ATTR_PATTERN = /\s+data-docx-internal-clipboard(?:="([^"]*)"|='([^']*)'|=([^\s>]+))?/gi;
 const TEXTBOX_ANCHOR_ATTR = /\s+data-docx-textbox-anchor(?:="[^"]*"|='[^']*')?/gi;
 const BOOKMARK_BOUNDARY_ATTR = /\s+data-docx-bookmark-(?:boundary|id|name|col-first|col-last)(?:="[^"]*"|='[^']*'|=[^\s>]+)?/gi;
+const RANGE_ANCHOR_ATTR = /\s+data-docx-range-anchor(?:="[^"]*"|='[^']*'|=[^\s>]+)?/gi;
+const MOVE_RANGE_BOUNDARY_ATTR = /\s+data-docx-move-range-boundary(?:="[^"]*"|='[^']*'|=[^\s>]+)?/gi;
 const STRUCTURED_FIELD_ATTR = /\s+data-field-structured(?:="[^"]*"|='[^']*'|=[^\s>]+)?/gi;
 /**
 * Treat reconstruction attributes as internal only when the HTML carries the
@@ -144,6 +147,10 @@ function stripForeignBookmarkBoundaries(html, internal) {
 	if (internal) return html;
 	return html.replace(BOOKMARK_BOUNDARY_ATTR, "");
 }
+function stripForeignRangeCarriers(html, internal) {
+	if (internal) return html;
+	return html.replace(RANGE_ANCHOR_ATTR, "").replace(MOVE_RANGE_BOUNDARY_ATTR, "");
+}
 function stripForeignStructuredFields(html, internal) {
 	if (internal) return html;
 	return html.replace(STRUCTURED_FIELD_ATTR, "");
@@ -158,7 +165,7 @@ function stripEmptySpans(html, preserveInternalAtoms) {
 	let current = html;
 	for (let pass = 0; pass < MAX_EMPTY_SPAN_PASSES; pass++) {
 		const next = current.replace(EMPTY_SPAN, (span) => {
-			if (preserveInternalAtoms && /\bdata-docx-(?:bookmark-boundary|textbox-anchor)\s*=/i.test(span)) return span;
+			if (preserveInternalAtoms && /\bdata-docx-(?:bookmark-boundary|textbox-anchor|range-anchor|move-range-boundary)\s*=/i.test(span)) return span;
 			return "";
 		});
 		if (next === current) break;
@@ -179,6 +186,7 @@ function cleanPastedHtml(html, options = {}) {
 		cleaned = stripEmptySpans(cleaned, internal);
 		cleaned = stripForeignTextBoxAnchors(cleaned, internal);
 		cleaned = stripForeignBookmarkBoundaries(cleaned, internal);
+		cleaned = stripForeignRangeCarriers(cleaned, internal);
 		cleaned = stripForeignStructuredFields(cleaned, internal);
 		cleaned = cleaned.replace(INTERNAL_CLIPBOARD_ATTR_PATTERN, "");
 		return cleaned.trim();
@@ -218,5 +226,51 @@ function removeUnpairedBookmarkBoundaries(slice) {
 	};
 	return new Slice(filterFragment(slice.content), slice.openStart, slice.openEnd);
 }
+const moveRangeKey = (marker) => {
+	return `${marker.type.startsWith("moveFrom") ? "moveFrom" : "moveTo"}:${marker.id}`;
+};
+const moveRangeBoundaryType = (marker) => marker.type.endsWith("Start") ? "start" : "end";
+/** Remove incomplete, duplicate, or reversed tracked-move pairs at copied slice edges. */
+function removeUnpairedMoveRangeBoundaries(slice) {
+	const summaries = /* @__PURE__ */ new Map();
+	const malformedNodes = /* @__PURE__ */ new Set();
+	let boundaryIndex = 0;
+	slice.content.descendants((node) => {
+		if (node.type.name !== "moveRangeBoundary") return true;
+		const result = readMoveRangeBoundaryAttrs(node);
+		if (!result.ok) {
+			malformedNodes.add(node);
+			return false;
+		}
+		const key = moveRangeKey(result.value);
+		const summary = summaries.get(key) ?? {
+			startPositions: [],
+			endPositions: []
+		};
+		summary[moveRangeBoundaryType(result.value) === "start" ? "startPositions" : "endPositions"].push(boundaryIndex);
+		summaries.set(key, summary);
+		boundaryIndex += 1;
+		return false;
+	});
+	const invalidKeys = /* @__PURE__ */ new Set();
+	for (const [key, { startPositions, endPositions }] of summaries) {
+		const start = startPositions.at(0);
+		const end = endPositions.at(0);
+		if (startPositions.length !== 1 || endPositions.length !== 1 || start === void 0 || end === void 0 || start >= end) invalidKeys.add(key);
+	}
+	const filterFragment = (fragment) => {
+		const children = [];
+		fragment.forEach((node) => {
+			if (node.type.name === "moveRangeBoundary") {
+				const result = readMoveRangeBoundaryAttrs(node);
+				if (result.ok && !malformedNodes.has(node) && !invalidKeys.has(moveRangeKey(result.value))) children.push(node);
+				return;
+			}
+			children.push(node.childCount === 0 ? node : node.copy(filterFragment(node.content)));
+		});
+		return Fragment.fromArray(children);
+	};
+	return new Slice(filterFragment(slice.content), slice.openStart, slice.openEnd);
+}
 //#endregion
-export { cleanPastedHtml, removeUnpairedBookmarkBoundaries };
+export { cleanPastedHtml, removeUnpairedBookmarkBoundaries, removeUnpairedMoveRangeBoundaries };

package/dist/prosemirror/extensions/features/pastedHeadingStyles.js

@@ -1,5 +1,6 @@
-import { isHeadingOutlineLevel } from "../../../docx/builtInStyles.js";
+import { readOutlineLevelAttr } from "../../outlineLevelAttr.js";
 import { getDocumentBuiltInStyles, getDocumentStyleResolver } from "../../plugins/documentStyles.js";
+import { headingLevelOf } from "@stll/docx-core/model";
 import { Fragment, Slice } from "prosemirror-model";
 //#region src/prosemirror/extensions/features/pastedHeadingStyles.ts
 /**
@@ -39,11 +40,11 @@ const nearestHeadingStyleId = (outlineLevel, styles) => {
 const retargetedStyleId = (node, view) => {
 	const styleId = node.attrs["styleId"];
 	if (typeof styleId !== "string") return;
-	const outlineLevel = node.attrs["outlineLevel"];
-	if (typeof outlineLevel !== "number" || !isHeadingOutlineLevel(outlineLevel)) return;
+	const headingLevel = headingLevelOf(readOutlineLevelAttr(node.attrs["outlineLevel"]));
+	if (headingLevel === void 0) return;
 	const resolver = getDocumentStyleResolver(view.state);
 	if (resolver === null || resolver.getStyle(styleId) !== void 0) return;
-	const target = nearestHeadingStyleId(outlineLevel, getDocumentBuiltInStyles(view.state));
+	const target = nearestHeadingStyleId(headingLevel, getDocumentBuiltInStyles(view.state));
 	return target === styleId ? void 0 : target;
 };
 const retargetFragment = (fragment, view) => {

package/dist/prosemirror/extensions/markRegistry.d.ts

@@ -28,7 +28,7 @@ declare const MARK_EXTENSIONS: {
   readonly textEffect: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
   readonly runFormattingOverride: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
   readonly characterStyle: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
-  readonly pageBreakRunOwner: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+  readonly runIdentity: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
   readonly comment: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
   readonly insertion: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
   readonly deletion: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
@@ -37,5 +37,29 @@ declare const MARK_EXTENSIONS: {
 };
 /** A mark the editor schema declares. */
 type SchemaMarkName = keyof typeof MARK_EXTENSIONS;
+/**
+ * Outermost first: the order the editor registers marks in, which is the order
+ * it nests their DOM elements in.
+ *
+ * Five of these marks are containers on the save leg as well, and their
+ * relative order is that leg's rather than a choice made here.
+ * `extractParagraphContent` opens a comment range around everything a leaf
+ * produces (it flushes the open run and hyperlink and drops the tracked wrapper
+ * before pushing the marker: `fromProseDoc.ts:2359-2369`), then the revision
+ * wrapper (`fromProseDoc.ts:2530`), then the wrapper stack inside that revision
+ * (`nestInlineWrapperGroups`, `fromProseDoc.ts:2200`), then the hyperlink and
+ * the runs it holds (`fromProseDoc.ts:2567`). So the save writes
+ * `w:commentRangeStart … w:ins > w:bdo > w:hyperlink > w:r`, and the editor DOM
+ * nests `span.docx-comment > span.docx-insertion > bdo > a`.
+ * `markNestingOrder.test.ts` holds the two legs to each other.
+ *
+ * `runIdentity` is the fifth: `w:r` is the element it names, and it is the
+ * innermost element that leg emits.
+ *
+ * Every other mark is a run property or run content: it has no element of its
+ * own in OOXML, so the save leg ranks it against nothing and its place here is
+ * a presentation decision.
+ */
+declare const MARK_NESTING_ORDER: readonly ["bold", "italic", "underline", "strike", "textColor", "runShading", "highlight", "fontSize", "fontFamily", "language", "superscript", "subscript", "allCaps", "smallCaps", "footnoteRef", "characterSpacing", "emboss", "imprint", "hidden", "textShadow", "emphasisMark", "textOutline", "rtl", "textEffect", "runFormattingOverride", "characterStyle", "comment", "insertion", "deletion", "inlineWrapper", "hyperlink", "runPropertyChange", "runIdentity"];
 //#endregion
-export { MARK_EXTENSIONS, SchemaMarkName };
+export { MARK_EXTENSIONS, MARK_NESTING_ORDER, SchemaMarkName };

package/dist/prosemirror/extensions/markRegistry.js

@@ -12,9 +12,9 @@ import { HyperlinkExtension } from "./marks/HyperlinkExtension.js";
 import { InlineWrapperExtension } from "./marks/InlineWrapperExtension.js";
 import { ItalicExtension } from "./marks/ItalicExtension.js";
 import { LanguageExtension } from "./marks/LanguageExtension.js";
-import { PageBreakRunOwnerExtension } from "./marks/PageBreakRunOwnerExtension.js";
 import { RtlExtension } from "./marks/RtlExtension.js";
 import { RunFormattingOverrideExtension } from "./marks/RunFormattingOverrideExtension.js";
+import { RunIdentityExtension } from "./marks/RunIdentityExtension.js";
 import { RunShadingExtension } from "./marks/RunShadingExtension.js";
 import { SmallCapsExtension } from "./marks/SmallCapsExtension.js";
 import { StrikeExtension } from "./marks/StrikeExtension.js";
@@ -27,14 +27,17 @@ import { DeletionExtension, InsertionExtension, RunPropertyChangeExtension } fro
 import { UnderlineExtension } from "./marks/UnderlineExtension.js";
 //#region src/prosemirror/extensions/markRegistry.ts
 /**
-* Every mark the editor schema declares, in registration order.
+* Every mark the editor schema declares, and the order they nest in.
 *
-* Registration order is DOM nesting order: a mark registered later is the
-* inner span. `StarterKit` builds the schema from this record and from nothing
-* else, so `SchemaMarkName` is the set of marks that exist rather than a list
-* beside it — a table that must decide something per mark (what the painter
-* does with it) can be checked total against this union, and a mark added
-* without that decision does not compile.
+* `StarterKit` builds the schema from this record and from nothing else, so
+* `SchemaMarkName` is the set of marks that exist rather than a list beside it
+* — a table that must decide something per mark (what the painter does with
+* it) can be checked total against this union, and a mark added without that
+* decision does not compile.
+*
+* The record answers which marks exist and how each is built; its key order
+* answers nothing. `MARK_NESTING_ORDER` is the registration order, and
+* registration order is DOM nesting order.
 */
 const MARK_EXTENSIONS = {
 	bold: BoldExtension,
@@ -64,12 +67,72 @@ const MARK_EXTENSIONS = {
 	textEffect: TextEffectExtension,
 	runFormattingOverride: RunFormattingOverrideExtension,
 	characterStyle: CharacterStyleExtension,
-	pageBreakRunOwner: PageBreakRunOwnerExtension,
+	runIdentity: RunIdentityExtension,
 	comment: CommentExtension,
 	insertion: InsertionExtension,
 	deletion: DeletionExtension,
 	runPropertyChange: RunPropertyChangeExtension,
 	inlineWrapper: InlineWrapperExtension
 };
+/** The order, rejected unless it names every mark; a repeat is the test's. */
+const markNestingOrder = (names) => names;
+/**
+* Outermost first: the order the editor registers marks in, which is the order
+* it nests their DOM elements in.
+*
+* Five of these marks are containers on the save leg as well, and their
+* relative order is that leg's rather than a choice made here.
+* `extractParagraphContent` opens a comment range around everything a leaf
+* produces (it flushes the open run and hyperlink and drops the tracked wrapper
+* before pushing the marker: `fromProseDoc.ts:2359-2369`), then the revision
+* wrapper (`fromProseDoc.ts:2530`), then the wrapper stack inside that revision
+* (`nestInlineWrapperGroups`, `fromProseDoc.ts:2200`), then the hyperlink and
+* the runs it holds (`fromProseDoc.ts:2567`). So the save writes
+* `w:commentRangeStart … w:ins > w:bdo > w:hyperlink > w:r`, and the editor DOM
+* nests `span.docx-comment > span.docx-insertion > bdo > a`.
+* `markNestingOrder.test.ts` holds the two legs to each other.
+*
+* `runIdentity` is the fifth: `w:r` is the element it names, and it is the
+* innermost element that leg emits.
+*
+* Every other mark is a run property or run content: it has no element of its
+* own in OOXML, so the save leg ranks it against nothing and its place here is
+* a presentation decision.
+*/
+const MARK_NESTING_ORDER = markNestingOrder([
+	"bold",
+	"italic",
+	"underline",
+	"strike",
+	"textColor",
+	"runShading",
+	"highlight",
+	"fontSize",
+	"fontFamily",
+	"language",
+	"superscript",
+	"subscript",
+	"allCaps",
+	"smallCaps",
+	"footnoteRef",
+	"characterSpacing",
+	"emboss",
+	"imprint",
+	"hidden",
+	"textShadow",
+	"emphasisMark",
+	"textOutline",
+	"rtl",
+	"textEffect",
+	"runFormattingOverride",
+	"characterStyle",
+	"comment",
+	"insertion",
+	"deletion",
+	"inlineWrapper",
+	"hyperlink",
+	"runPropertyChange",
+	"runIdentity"
+]);
 //#endregion
-export { MARK_EXTENSIONS };
+export { MARK_EXTENSIONS, MARK_NESTING_ORDER };

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

@@ -16,11 +16,19 @@ import { panic } from "better-result";
 * 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) {
@@ -31,9 +39,15 @@ const layerElement = (layer, attributes) => {
 				attributes,
 				0
 			];
-		default:
-			layer.kind;
-			panic(`Unspelled inline wrapper layer: ${JSON.stringify(layer)}`);
+		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({

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.js

@@ -7,6 +7,7 @@ import { selectRunFormattingCarrierRepresentations } from "../../runFormattingIn
 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);
@@ -42,7 +43,7 @@ function marksToTextFormatting(marks) {
 			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 = {

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