@stll/folio-core 0.45.0 → 0.47.0

package/dist/prosemirror/emptyRangeAnchor.d.ts

@@ -0,0 +1,53 @@
+import { ParagraphContent } from "../types/content.js";
+//#region src/prosemirror/emptyRangeAnchor.d.ts
+/** A marker that opens a range the editor otherwise projects as a mark. */
+type RangeStartType = Extract<ParagraphContent["type"], `${string}RangeStart`>;
+/**
+ * Which end closes which start.
+ *
+ * Both sides are derived from the model's own content union rather than
+ * listed, so a `…RangeStart` added to `ParagraphContent` fails this
+ * `satisfies` until somebody has said what closes it.
+ */
+declare const RANGE_END_FOR_START: {
+  readonly commentRangeStart: "commentRangeEnd";
+  readonly moveFromRangeStart: "moveFromRangeEnd";
+  readonly moveToRangeStart: "moveToRangeEnd";
+};
+/**
+ * The `rangeAnchor` node's attributes: a start and the end that closes it,
+ * with nothing between them.
+ *
+ * Distributing over the start types pairs each start with exactly its own end,
+ * so a comment start holding a move end is not a value this type has.
+ */
+type RangeAnchorAttrs = { [Start in RangeStartType]: {
+  start: Extract<ParagraphContent, {
+    type: Start;
+  }>;
+  end: Extract<ParagraphContent, {
+    type: (typeof RANGE_END_FOR_START)[Start];
+  }>;
+}; }[RangeStartType];
+/** Whether this content is one of the six range markers, either half. */
+declare const isRangeMarker: (content: ParagraphContent) => boolean;
+type EmptyRangePlan = {
+  /** The anchor to emit in place of the marker at this index. */
+  anchorAt: ReadonlyMap<number, RangeAnchorAttrs>;
+  /** An index whose marker an anchor at an earlier index already holds. */
+  closedAt: ReadonlySet<number>;
+};
+/**
+ * The empty ranges in one inline sequence, by the index each one's start sits
+ * at.
+ *
+ * The window a pair may close within is a maximal run of range markers and
+ * nothing else, which is what "spans no content" means once the transparent
+ * wrappers are lifted. Nesting inside such a run is not meaningful — neither
+ * order covers anything — so the pairs are taken nearest first and each anchor
+ * stays at its own start's index. A start whose end is outside the run is a
+ * range over content and keeps the mark path; so does an end with no start.
+ */
+declare const planEmptyRanges: (content: readonly ParagraphContent[]) => EmptyRangePlan;
+//#endregion
+export { EmptyRangePlan, RANGE_END_FOR_START, RangeAnchorAttrs, isRangeMarker, planEmptyRanges };

package/dist/prosemirror/emptyRangeAnchor.js

@@ -0,0 +1,158 @@
+import { panic } from "better-result";
+//#region src/prosemirror/emptyRangeAnchor.ts
+/**
+* A comment or tracked-move range that spans no content, carried across the
+* editor projection as one zero-width atom.
+*
+* A reviewer who comments at an insertion point rather than over a selection
+* gets `w:commentRangeStart` immediately followed by `w:commentRangeEnd`, and
+* then the `w:commentReference` run. The editor spells a comment as a `comment`
+* mark over the inline content its range covers, and a range over nothing has
+* no leaf to mark, so the projection dropped both markers. The comment still
+* listed — the reference survives as its own atom — but its anchor position was
+* gone, and the save wrote a reference with no range at all. A tracked move
+* whose range spans nothing loses its `w:name` the same way, and with it the
+* only thing binding the move's source to its destination.
+*
+* The pair is one thing rather than two, so it is one node. Two adjacent
+* boundary nodes, which is what the bookmark precedent would suggest, would
+* leave a position between them for a caret to sit in; typing there would turn
+* a point comment into a range the reviewer never drew.
+*
+* What the node holds is the model's own markers, not a copy of their fields:
+* an attribute added to `CT_MoveBookmark` is carried without being named here.
+*
+* A range that spans a bookmark boundary, a comment reference or captured
+* markup is not in this class and needs no anchor: each of those is an inline
+* node that carries a mark, so the mark path already keeps the range. Only a
+* range with nothing whatever between its two markers has no carrier.
+*/
+/**
+* Which end closes which start.
+*
+* Both sides are derived from the model's own content union rather than
+* listed, so a `…RangeStart` added to `ParagraphContent` fails this
+* `satisfies` until somebody has said what closes it.
+*/
+const RANGE_END_FOR_START = {
+	commentRangeStart: "commentRangeEnd",
+	moveFromRangeStart: "moveFromRangeEnd",
+	moveToRangeStart: "moveToRangeEnd"
+};
+const RANGE_MARKER_TYPES = /* @__PURE__ */ new Set([...Object.keys(RANGE_END_FOR_START), ...Object.values(RANGE_END_FOR_START)]);
+/** Whether this content is one of the six range markers, either half. */
+const isRangeMarker = (content) => RANGE_MARKER_TYPES.has(content.type);
+const isRangeStart = (content) => content.type in RANGE_END_FOR_START;
+const isRangeEnd = (content) => content.type === "commentRangeEnd" || content.type === "moveFromRangeEnd" || content.type === "moveToRangeEnd";
+const NO_EMPTY_RANGES = {
+	anchorAt: /* @__PURE__ */ new Map(),
+	closedAt: /* @__PURE__ */ new Set()
+};
+/**
+* The empty ranges in one inline sequence, by the index each one's start sits
+* at.
+*
+* The window a pair may close within is a maximal run of range markers and
+* nothing else, which is what "spans no content" means once the transparent
+* wrappers are lifted. Nesting inside such a run is not meaningful — neither
+* order covers anything — so the pairs are taken nearest first and each anchor
+* stays at its own start's index. A start whose end is outside the run is a
+* range over content and keeps the mark path; so does an end with no start.
+*/
+const planEmptyRanges = (content) => {
+	const anchorAt = /* @__PURE__ */ new Map();
+	const closedAt = /* @__PURE__ */ new Set();
+	let index = 0;
+	while (index < content.length) {
+		const item = content[index];
+		if (item === void 0 || !isRangeMarker(item)) {
+			index += 1;
+			continue;
+		}
+		let runEnd = index;
+		while (runEnd < content.length) {
+			const candidate = content[runEnd];
+			if (candidate === void 0 || !isRangeMarker(candidate)) break;
+			runEnd += 1;
+		}
+		pairWithinRun({
+			content,
+			from: index,
+			to: runEnd,
+			anchorAt,
+			closedAt
+		});
+		index = runEnd;
+	}
+	if (anchorAt.size === 0) return NO_EMPTY_RANGES;
+	return {
+		anchorAt,
+		closedAt
+	};
+};
+/**
+* The two markers as one anchor, or `null` when the closer does not close this
+* start.
+*
+* The branches restate no pairing: `RangeAnchorAttrs` is derived from
+* {@link RANGE_END_FOR_START}, so a branch that named the wrong end would not
+* be assignable, and a start type the model gains fails the exhaustiveness
+* check below.
+*/
+const pairedAnchor = (opener, closer) => {
+	switch (opener.type) {
+		case "commentRangeStart": return closer.type === "commentRangeEnd" && closer.id === opener.id ? {
+			start: opener,
+			end: closer
+		} : null;
+		case "moveFromRangeStart": return closer.type === "moveFromRangeEnd" && closer.id === opener.id ? {
+			start: opener,
+			end: closer
+		} : null;
+		case "moveToRangeStart": return closer.type === "moveToRangeEnd" && closer.id === opener.id ? {
+			start: opener,
+			end: closer
+		} : null;
+		default: panic(`Unsupported range start: ${JSON.stringify(opener)}`);
+	}
+};
+const pairWithinRun = ({ content, from, to, anchorAt, closedAt }) => {
+	const endIndexesByTypeAndId = /* @__PURE__ */ new Map();
+	for (let end = from; end < to; end += 1) {
+		const closer = content[end];
+		if (closer === void 0 || !isRangeEnd(closer)) continue;
+		const key = rangeKey(closer.type, closer.id);
+		const indexes = endIndexesByTypeAndId.get(key);
+		if (indexes === void 0) {
+			endIndexesByTypeAndId.set(key, [end]);
+			continue;
+		}
+		indexes.push(end);
+	}
+	const nextEndByTypeAndId = /* @__PURE__ */ new Map();
+	for (let start = from; start < to; start += 1) {
+		const opener = content[start];
+		if (opener === void 0 || closedAt.has(start) || !isRangeStart(opener)) continue;
+		const key = rangeKey(RANGE_END_FOR_START[opener.type], opener.id);
+		const indexes = endIndexesByTypeAndId.get(key);
+		if (indexes === void 0) continue;
+		let nextEnd = nextEndByTypeAndId.get(key) ?? 0;
+		while (nextEnd < indexes.length && (indexes[nextEnd] ?? -1) <= start) nextEnd += 1;
+		const end = indexes[nextEnd];
+		if (end === void 0) {
+			nextEndByTypeAndId.set(key, nextEnd);
+			continue;
+		}
+		nextEndByTypeAndId.set(key, nextEnd + 1);
+		const closer = content[end];
+		if (closer === void 0) continue;
+		const anchor = pairedAnchor(opener, closer);
+		if (anchor === null) continue;
+		anchorAt.set(start, anchor);
+		closedAt.add(start);
+		closedAt.add(end);
+	}
+};
+const rangeKey = (type, id) => `${type}:${id}`;
+//#endregion
+export { RANGE_END_FOR_START, isRangeMarker, planEmptyRanges };

package/dist/prosemirror/extensions/StarterKit.js

@@ -17,41 +17,22 @@ import { ParagraphChangeTrackerExtension } from "./features/ParagraphChangeTrack
 import { PasteCleanupExtension } from "./features/PasteCleanupExtension.js";
 import { PasteStyleInlinerExtension } from "./features/PasteStyleInlinerExtension.js";
 import { SelectionTrackerExtension } from "./features/SelectionTrackerExtension.js";
-import { AllCapsExtension } from "./marks/AllCapsExtension.js";
-import { BoldExtension } from "./marks/BoldExtension.js";
-import { CharacterSpacingExtension } from "./marks/CharacterSpacingExtension.js";
-import { CharacterStyleExtension } from "./marks/CharacterStyleExtension.js";
-import { CommentExtension } from "./marks/CommentExtension.js";
-import { FontFamilyExtension } from "./marks/FontFamilyExtension.js";
-import { FontSizeExtension } from "./marks/FontSizeExtension.js";
-import { FootnoteRefExtension } from "./marks/FootnoteRefExtension.js";
-import { HiddenTextExtension } from "./marks/HiddenTextExtension.js";
-import { HighlightExtension } from "./marks/HighlightExtension.js";
-import { HyperlinkExtension } from "./marks/HyperlinkExtension.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 { RunShadingExtension } from "./marks/RunShadingExtension.js";
-import { SmallCapsExtension } from "./marks/SmallCapsExtension.js";
-import { StrikeExtension } from "./marks/StrikeExtension.js";
-import { SubscriptExtension } from "./marks/SubscriptExtension.js";
-import { SuperscriptExtension } from "./marks/SuperscriptExtension.js";
-import { TextColorExtension } from "./marks/TextColorExtension.js";
-import { TextEffectExtension } from "./marks/TextEffectExtension.js";
-import { EmbossExtension, EmphasisMarkExtension, ImprintExtension, TextOutlineExtension, TextShadowExtension } from "./marks/TextEffectsExtensions.js";
-import { DeletionExtension, InsertionExtension, RunPropertyChangeExtension } from "./marks/TrackedChangeExtensions.js";
-import { UnderlineExtension } from "./marks/UnderlineExtension.js";
+import { MARK_EXTENSIONS, MARK_NESTING_ORDER } from "./markRegistry.js";
+import { BlockBookmarkBoundaryExtension } from "./nodes/BlockBookmarkBoundaryExtension.js";
 import { BlockSdtExtension } from "./nodes/BlockSdtExtension.js";
 import { BookmarkBoundaryExtension } from "./nodes/BookmarkBoundaryExtension.js";
+import { CommentReferenceExtension } from "./nodes/CommentReferenceExtension.js";
 import { FieldExtension, StructuredFieldExtension } from "./nodes/FieldExtension.js";
 import { HardBreakExtension } from "./nodes/HardBreakExtension.js";
 import { HorizontalRuleExtension } from "./nodes/HorizontalRuleExtension.js";
 import { ImageExtension } from "./nodes/ImageExtension.js";
 import { MathExtension } from "./nodes/MathExtension.js";
+import { MoveRangeBoundaryExtension } from "./nodes/MoveRangeBoundaryExtension.js";
 import { PageBreakExtension } from "./nodes/PageBreakExtension.js";
 import { PageBreakRunExtension } from "./nodes/PageBreakRunExtension.js";
+import { PreservedBlockExtension } from "./nodes/PreservedBlockExtension.js";
+import { PreservedXmlExtension } from "./nodes/PreservedXmlExtension.js";
+import { RangeAnchorExtension } from "./nodes/RangeAnchorExtension.js";
 import { RenderedPageBreakExtension } from "./nodes/RenderedPageBreakExtension.js";
 import { SdtExtension } from "./nodes/SdtExtension.js";
 import { ShapeExtension } from "./nodes/ShapeExtension.js";
@@ -82,42 +63,16 @@ function createStarterKit(options = {}) {
 		...options.historyDepth !== void 0 ? { depth: options.historyDepth } : {},
 		...options.historyNewGroupDelay !== void 0 ? { newGroupDelay: options.historyNewGroupDelay } : {}
 	}));
-	add("bold", BoldExtension());
-	add("italic", ItalicExtension());
-	add("underline", UnderlineExtension());
-	add("strike", StrikeExtension());
-	add("textColor", TextColorExtension());
-	add("runShading", RunShadingExtension());
-	add("highlight", HighlightExtension());
-	add("fontSize", FontSizeExtension());
-	add("fontFamily", FontFamilyExtension());
-	add("language", LanguageExtension());
-	add("superscript", SuperscriptExtension());
-	add("subscript", SubscriptExtension());
-	add("hyperlink", HyperlinkExtension());
-	add("allCaps", AllCapsExtension());
-	add("smallCaps", SmallCapsExtension());
-	add("footnoteRef", FootnoteRefExtension());
-	add("characterSpacing", CharacterSpacingExtension());
-	add("emboss", EmbossExtension());
-	add("imprint", ImprintExtension());
-	add("hidden", HiddenTextExtension());
-	add("textShadow", TextShadowExtension());
-	add("emphasisMark", EmphasisMarkExtension());
-	add("textOutline", TextOutlineExtension());
-	add("rtl", RtlExtension());
-	add("textEffect", TextEffectExtension());
-	add("runFormattingOverride", RunFormattingOverrideExtension());
-	add("characterStyle", CharacterStyleExtension());
-	add("pageBreakRunOwner", PageBreakRunOwnerExtension());
-	add("comment", CommentExtension());
-	add("insertion", InsertionExtension());
-	add("deletion", DeletionExtension());
-	add("runPropertyChange", RunPropertyChangeExtension());
+	for (const name of MARK_NESTING_ORDER) add(name, MARK_EXTENSIONS[name]());
 	add("bookmarkBoundary", BookmarkBoundaryExtension({ getInternalClipboardToken }));
+	add("blockBookmarkBoundary", BlockBookmarkBoundaryExtension());
+	add("commentReference", CommentReferenceExtension({ getInternalClipboardToken }));
+	add("moveRangeBoundary", MoveRangeBoundaryExtension({ getInternalClipboardToken }));
+	add("rangeAnchor", RangeAnchorExtension({ getInternalClipboardToken }));
 	add("hardBreak", HardBreakExtension());
 	add("tab", TabExtension());
 	add("symbol", SymbolExtension());
+	add("preservedXml", PreservedXmlExtension());
 	add("image", ImageExtension());
 	add("textBox", TextBoxExtension());
 	add("textBoxAnchor", TextBoxAnchorExtension({ getInternalClipboardToken }));
@@ -134,6 +89,7 @@ function createStarterKit(options = {}) {
 	add("field", StructuredFieldExtension({ getInternalClipboardToken }));
 	add("sdt", SdtExtension());
 	add("blockSdt", BlockSdtExtension());
+	add("preservedBlock", PreservedBlockExtension());
 	add("math", MathExtension());
 	if (!disabled.has("table")) extensions.push(...createTableExtensions());
 	add("pasteCleanup", PasteCleanupExtension({ getInternalClipboardToken }));

package/dist/prosemirror/extensions/core/DocExtension.js

@@ -13,7 +13,7 @@ const DocExtension = createNodeExtension({
 			_finalSectionStart: { default: null },
 			_adjustLineHeightInTable: { default: false }
 		},
-		content: "(paragraph | horizontalRule | pageBreak | table | textBox | blockSdt)+"
+		content: "(paragraph | horizontalRule | pageBreak | table | textBox | blockSdt | preservedBlock | blockBookmarkBoundary)+"
 	}
 });
 //#endregion

package/dist/prosemirror/extensions/core/ParagraphExtension.js

@@ -6,12 +6,15 @@ import { collectHeadings } from "../../../utils/headingCollector.js";
 import { tableOfContentsStyleLevel } from "../../../utils/tableOfContentsStyle.js";
 import { expectParagraphAttrs } from "../../attrs/index.js";
 import { autospacingMatchesBase } from "../../autospacingBase.js";
+import { removeSectionBreakAtSelection, setSectionBreakType } from "../../commands/sectionBreak.js";
 import { directParagraphAlignment } from "../../paragraphAlignment.js";
 import { directionIsRtl } from "../../paragraphDirection.js";
 import { withDirectParagraphSpacing } from "../../paragraphSpacing.js";
 import { getDocumentBuiltInStyles } from "../../plugins/documentStyles.js";
+import { mintSectionProperties, parseSectionBreakType, sectionBreakTypeOf } from "../../sectionCarrier.js";
 import { listAttrsFromResolvedStyle, paragraphAttrsFromResolvedStyle } from "../../styles/resolvedStyleAttrs.js";
 import { createNodeExtension } from "../create.js";
+import { headingOutlineLevel, paragraphNumberingLevel, paragraphNumberingReferenceId } from "@stll/docx-core/model";
 import { Fragment } from "prosemirror-model";
 //#region src/prosemirror/extensions/core/ParagraphExtension.ts
 /**
@@ -24,7 +27,7 @@ import { Fragment } from "prosemirror-model";
 function paragraphAttrsToDOMStyle(attrs) {
 	const rawIndentLeft = Reflect.get(attrs, "indentLeft");
 	let indentLeft = typeof rawIndentLeft === "number" ? rawIndentLeft : void 0;
-	if (attrs.numPr?.numId && (rawIndentLeft === null || rawIndentLeft === void 0)) indentLeft = ((attrs.numPr.ilvl ?? 0) + 1) * 720;
+	if (paragraphNumberingReferenceId(attrs.numPr) !== void 0 && (rawIndentLeft === null || rawIndentLeft === void 0)) indentLeft = ((paragraphNumberingLevel(attrs.numPr) ?? 0) + 1) * 720;
 	const style = paragraphToStyle({
 		...attrs.alignment !== void 0 ? { alignment: attrs.alignment } : {},
 		...attrs.spaceBefore !== void 0 ? { spaceBefore: attrs.spaceBefore } : {},
@@ -60,8 +63,8 @@ function numFmtToClass(numFmt) {
 	}
 }
 function getListClass(numPr, listIsBullet, listNumFmt) {
-	if (!numPr?.numId) return "";
-	const level = numPr.ilvl ?? 0;
+	if (paragraphNumberingReferenceId(numPr) === void 0) return "";
+	const level = paragraphNumberingLevel(numPr) ?? 0;
 	if (listIsBullet) return `docx-list-bullet docx-list-level-${level}`;
 	return `docx-list-numbered ${numFmtToClass(listNumFmt)} docx-list-level-${level}`;
 }
@@ -92,11 +95,11 @@ function cssLengthToTwips(value) {
 */
 function cssTextAlignToAlignment(value) {
 	switch (value.trim().toLowerCase()) {
-		case "left":
-		case "start": return "left";
+		case "left": return "left";
+		case "start": return "start";
 		case "center": return "center";
-		case "right":
-		case "end": return "right";
+		case "right": return "right";
+		case "end": return "end";
 		case "justify": return "both";
 		default: return;
 	}
@@ -244,7 +247,6 @@ const paragraphNodeSpec = {
 		runInWithNext: { default: null },
 		defaultTextFormatting: { default: null },
 		_tableRunFormatting: { default: void 0 },
-		sectionBreakType: { default: null },
 		direction: { default: null },
 		outlineLevel: { default: null },
 		bookmarks: { default: null },
@@ -254,6 +256,7 @@ const paragraphNodeSpec = {
 		_autospacingBase: { default: null },
 		_sectionProperties: { default: null },
 		_propertyChanges: { default: null },
+		_preservedAttributes: { default: null },
 		pPrMark: { default: null },
 		_suggestedInsert: { default: null }
 	},
@@ -268,14 +271,14 @@ const paragraphNodeSpec = {
 			const alignmentFromStyle = parseParagraphAlignment(element.dataset["alignmentFromStyle"]);
 			const styleId = element.dataset["styleId"];
 			const tableOfContentsLevel = Number(element.dataset["tableOfContentsLevel"]);
-			const sectionBreakType = element.dataset["sectionBreak"];
+			const sectionBreakType = parseSectionBreakType(element.dataset["sectionBreak"]);
 			const attrs = {
 				...paraId ? { paraId } : {},
 				...alignment ? { alignment } : {},
 				...alignmentFromStyle ? { alignmentFromStyle } : {},
 				...styleId ? { styleId } : {},
 				...Number.isSafeInteger(tableOfContentsLevel) && tableOfContentsLevel > 0 ? { _tableOfContentsLevel: tableOfContentsLevel } : {},
-				...sectionBreakType ? { sectionBreakType } : {}
+				...sectionBreakType ? { _sectionProperties: mintSectionProperties(sectionBreakType) } : {}
 			};
 			const styleAttrs = extractParagraphAttrsFromStyle(element);
 			const mergedAlignment = attrs.alignment || styleAttrs.alignment;
@@ -303,11 +306,12 @@ const paragraphNodeSpec = {
 		getAttrs(dom) {
 			const level = Number.parseInt(tag.charAt(1), 10);
 			const styleAttrs = extractParagraphAttrsFromStyle(dom);
+			const outlineLevel = headingOutlineLevel(level - 1);
 			return {
 				...styleAttrs,
 				...styleAttrs.alignment ? { _originalFormatting: { alignment: styleAttrs.alignment } } : {},
 				styleId: `Heading${level}`,
-				outlineLevel: level - 1
+				...outlineLevel === void 0 ? {} : { outlineLevel }
 			};
 		}
 	}))],
@@ -327,8 +331,9 @@ const paragraphNodeSpec = {
 		if (typeof attrs._tableOfContentsLevel === "number") domAttrs["data-table-of-contents-level"] = String(attrs._tableOfContentsLevel);
 		if (attrs.listMarker) domAttrs["data-list-marker"] = attrs.listMarker;
 		if (directionIsRtl(attrs.direction)) domAttrs["dir"] = "rtl";
-		if (attrs.sectionBreakType) {
-			domAttrs["data-section-break"] = attrs.sectionBreakType;
+		const sectionBreakType = sectionBreakTypeOf(attrs._sectionProperties);
+		if (sectionBreakType) {
+			domAttrs["data-section-break"] = sectionBreakType;
 			domAttrs["class"] = `${domAttrs["class"] ? `${domAttrs["class"]} ` : ""}docx-section-break`;
 		}
 		return [
@@ -603,8 +608,8 @@ const ParagraphExtension = createNodeExtension({
 				styleId: null,
 				_tableOfContentsLevel: null
 			}),
-			insertSectionBreak: (breakType) => setParagraphAttr("sectionBreakType", breakType),
-			removeSectionBreak: () => setParagraphAttr("sectionBreakType", null),
+			insertSectionBreak: (breakType) => setSectionBreakType(breakType),
+			removeSectionBreak: () => removeSectionBreakAtSelection,
 			generateTOC: ({ title }) => (state, dispatch) => {
 				const builtInStyles = getDocumentBuiltInStyles(state);
 				const headings = collectHeadings(state.doc, builtInStyles);
@@ -664,7 +669,7 @@ const ParagraphExtension = createNodeExtension({
 						instruction: `PAGEREF ${entry.name} \\h`,
 						displayText: "1",
 						fieldKind: "complex",
-						fldLock: false,
+						fldLock: null,
 						dirty: true
 					}));
 					tocNodes.push(s.node("paragraph", {

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

@@ -1,8 +1,12 @@
-import { mergeFontFamily } from "../../../utils/fontFamilyMerge.js";
+import { mergeTextFormatting } from "../../../utils/textFormattingMerge.js";
+import { expectCharacterStyleMarkAttrs, expectRunFormattingOverrideMarkAttrs } from "../../attrs/index.js";
+import { keepSectionBreaksOnSurvivingMarks } from "../../commands/sectionBreak.js";
 import { getDocumentStyleResolver } from "../../plugins/documentStyles.js";
+import { RUN_FORMATTING_MARK_NAMES } from "../../runFormattingMarkNames.js";
+import { authoredRunFormattingFromAttrs } from "../../runFormattingProvenance.js";
 import { paragraphAttrsFromResolvedStyle } from "../../styles/resolvedStyleAttrs.js";
 import { createExtension } from "../create.js";
-import { textFormattingToMarks } from "../marks/markUtils.js";
+import { marksToTextFormatting, textFormattingToMarks } from "../marks/markUtils.js";
 import { Priority } from "../types.js";
 import { baseKeymap, deleteSelection, joinBackward, joinForward, selectAll, selectParentNode, splitBlock } from "prosemirror-commands";
 //#region src/prosemirror/extensions/features/BaseKeymapExtension.ts
@@ -44,7 +48,7 @@ const clearIndentOnBackspace = (state, dispatch) => {
 };
 /**
 * Custom Enter handler: splits the block, inherits style-related attrs,
-* clears paragraph borders, and preserves font marks on the new paragraph.
+* clears paragraph borders, and preserves run formatting on the new paragraph.
 *
 * splitBlock creates a new paragraph with default attrs (all null),
 * so we must manually copy style-related attrs from the source paragraph.
@@ -61,12 +65,31 @@ const INHERITED_PARA_ATTRS = [
 	"spaceBefore",
 	"contextualSpacing"
 ];
-/** Mark types that represent style-inherited formatting (font, size, color). */
+/** Style formatting needed when the caret has no marks of its own. */
 const STYLE_MARK_NAMES = /* @__PURE__ */ new Set([
 	"fontFamily",
 	"fontSize",
 	"textColor"
 ]);
+const directFormattingFromMarks = (marks) => {
+	const override = marks.find(({ type }) => type.name === "runFormattingOverride");
+	const directFormatting = override ? authoredRunFormattingFromAttrs(expectRunFormattingOverrideMarkAttrs(override)) : void 0;
+	const characterStyle = marks.find(({ type }) => type.name === "characterStyle");
+	if (!characterStyle) return directFormatting;
+	return {
+		...directFormatting,
+		styleId: expectCharacterStyleMarkAttrs(characterStyle).styleId
+	};
+};
+const marksForParagraphFormatting = (formatting, directFormatting, schema) => {
+	const marks = textFormattingToMarks(formatting, schema, {
+		authoredCarrier: "preserve",
+		directFormatting,
+		overrideFormatting: directFormatting
+	});
+	if (formatting.styleId) marks.push(schema.mark("characterStyle", { styleId: formatting.styleId }));
+	return marks;
+};
 /**
 * If `sourcePara`'s style defines a `w:next`, replace the empty `newPara`
 * with that style's resolved attrs and seed stored marks from its run
@@ -94,7 +117,8 @@ function applyNextParagraphStyle(tr, sourcePara, newPara, resolver) {
 const splitBlockClearBorders = (state, dispatch, view) => {
 	const { $from: preSplitFrom } = state.selection;
 	const sourcePara = preSplitFrom.parent.type.name === "paragraph" ? preSplitFrom.parent : null;
-	const styleMarks = (state.storedMarks || preSplitFrom.marks()).filter((m) => STYLE_MARK_NAMES.has(m.type.name));
+	const caretFormattingMarks = (state.storedMarks || preSplitFrom.marks()).filter((mark) => RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
+	const resolver = getDocumentStyleResolver(state);
 	const splitResult = { tr: null };
 	if (!splitBlock(state, dispatch ? (tr) => {
 		splitResult.tr = tr;
@@ -104,8 +128,18 @@ const splitBlockClearBorders = (state, dispatch, view) => {
 		const { $from } = tr.selection;
 		const newPara = $from.parent;
 		if (newPara.type.name === "paragraph") {
-			const resolver = getDocumentStyleResolver(state);
 			if (resolver !== null && sourcePara !== null && newPara.content.size === 0 && applyNextParagraphStyle(tr, sourcePara, newPara, resolver)) {
+				const directFormatting = directFormattingFromMarks(caretFormattingMarks);
+				if (directFormatting && Object.keys(directFormatting).length > 0) {
+					const nextParagraph = tr.selection.$from.parent;
+					const nextStyleFormatting = nextParagraph.attrs["defaultTextFormatting"];
+					const defaultTextFormatting = mergeTextFormatting(nextStyleFormatting, directFormatting) ?? directFormatting;
+					tr.setNodeMarkup(tr.selection.$from.before(), void 0, {
+						...nextParagraph.attrs,
+						defaultTextFormatting
+					});
+					tr.setStoredMarks(marksForParagraphFormatting(defaultTextFormatting, directFormatting, state.schema));
+				}
 				dispatch(tr.scrollIntoView());
 				return true;
 			}
@@ -124,33 +158,18 @@ const splitBlockClearBorders = (state, dispatch, view) => {
 			}
 			if (attrsChanged) tr.setNodeMarkup($from.before(), void 0, newAttrs);
 			if (newPara.textContent.length === 0) {
-				let effectiveMarks = styleMarks;
+				let effectiveMarks = caretFormattingMarks;
 				if (effectiveMarks.length === 0 && sourcePara) {
 					const dtf = sourcePara.attrs["defaultTextFormatting"];
 					if (dtf) effectiveMarks = textFormattingToMarks(dtf, state.schema).filter((m) => STYLE_MARK_NAMES.has(m.type.name));
 				}
 				if (effectiveMarks.length > 0) {
-					const dtf = { ...newAttrs["defaultTextFormatting"] };
-					let dtfChanged = false;
-					for (const m of effectiveMarks) {
-						if (m.type.name === "fontSize" && m.attrs["size"] !== dtf.fontSize) {
-							dtf.fontSize = m.attrs["size"];
-							dtfChanged = true;
-						}
-						if (m.type.name === "fontFamily") {
-							const ascii = m.attrs["ascii"];
-							if (ascii && (!dtf.fontFamily || dtf.fontFamily.ascii !== ascii)) {
-								const nextFontFamily = { ascii };
-								const hAnsi = m.attrs["hAnsi"];
-								if (hAnsi !== void 0) nextFontFamily.hAnsi = hAnsi;
-								dtf.fontFamily = mergeFontFamily(dtf.fontFamily, nextFontFamily);
-								dtfChanged = true;
-							}
-						}
-					}
-					if (dtfChanged) tr.setNodeMarkup($from.before(), void 0, {
+					const previousFormatting = newAttrs["defaultTextFormatting"];
+					const markFormatting = marksToTextFormatting(effectiveMarks);
+					const defaultTextFormatting = mergeTextFormatting(previousFormatting, markFormatting) ?? markFormatting;
+					tr.setNodeMarkup($from.before(), void 0, {
 						...newAttrs,
-						defaultTextFormatting: dtf
+						defaultTextFormatting
 					});
 					tr.setStoredMarks(effectiveMarks);
 				}
@@ -167,8 +186,8 @@ const BaseKeymapExtension = createExtension({
 		return { keyboardShortcuts: {
 			...baseKeymap,
 			Enter: splitBlockClearBorders,
-			Backspace: chainCommands(deleteSelection, clearIndentOnBackspace, joinBackward),
-			Delete: chainCommands(deleteSelection, joinForward),
+			Backspace: keepSectionBreaksOnSurvivingMarks(chainCommands(deleteSelection, clearIndentOnBackspace, joinBackward)),
+			Delete: keepSectionBreaksOnSurvivingMarks(chainCommands(deleteSelection, joinForward)),
 			"Mod-a": selectAll,
 			Escape: selectParentNode
 		} };

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

@@ -11,8 +11,9 @@ const emptyParagraphFormatKey = new PluginKey("emptyParagraphFormat");
 * must be one `textFormattingToMarks` can turn into a mark, or the gate would
 * open for work that produces nothing.
 */
+const FONT_ONLY_DEFAULTS = /* @__PURE__ */ new Set(["fontFamily", "fontSize"]);
 function hasNonFontDefaults(dtf) {
-	return !!(dtf.bold || dtf.italic || dtf.underline || dtf.strike || dtf.doubleStrike || dtf.color || dtf.highlight || dtf.vertAlign || dtf.rtl);
+	return Object.entries(dtf).some(([property, value]) => value !== void 0 && !FONT_ONLY_DEFAULTS.has(property));
 }
 function createEmptyParagraphFormatPlugin(schema) {
 	return new Plugin({
@@ -27,6 +28,7 @@ function createEmptyParagraphFormatPlugin(schema) {
 			const dtf = para.attrs["defaultTextFormatting"];
 			if (!dtf || !hasNonFontDefaults(dtf)) return null;
 			const marks = textFormattingToMarks(dtf, schema);
+			if (dtf.styleId) marks.push(schema.mark("characterStyle", { styleId: dtf.styleId }));
 			if (marks.length === 0) return null;
 			const tr = newState.tr.setStoredMarks(marks);
 			tr.setMeta("addToHistory", false);

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

@@ -1,4 +1,5 @@
-import { getClipboardImageFiles } from "../../../utils/clipboard.js";
+import { FOLIO_INSERTED_PICTURE_FRAME_LOCKS } from "../../../docx/graphicFrameLocks.js";
+import { getStandaloneClipboardImageFiles } from "../../../utils/clipboard.js";
 import { isSafeImageFile } from "../../../utils/imageValidation.js";
 import { sanitizeImageSrc } from "../../../utils/sanitizeImageSrc.js";
 import { createExtension } from "../create.js";
@@ -73,7 +74,8 @@ async function insertImageFiles(view, files) {
 			height,
 			rId: `rId_img_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
 			wrapType: "inline",
-			displayMode: "inline"
+			displayMode: "inline",
+			frameLocks: FOLIO_INSERTED_PICTURE_FRAME_LOCKS
 		});
 		const tr = view.state.tr.insert(insertPos, imageNode);
 		insertPos += imageNode.nodeSize;
@@ -86,7 +88,7 @@ const ImagePasteExtension = createExtension({
 	name: "imagePaste",
 	onSchemaReady(_ctx) {
 		return { plugins: [new Plugin({ props: { handleDOMEvents: { paste(view, event) {
-			const imageFiles = getClipboardImageFiles(event.clipboardData);
+			const imageFiles = getStandaloneClipboardImageFiles(event.clipboardData);
 			if (imageFiles.length === 0) return false;
 			if (!view.state.schema.nodes["image"]) return false;
 			event.preventDefault();