@stll/folio-core 0.52.0 → 0.54.0

package/dist/prosemirror/plugins/templateDirectives.d.ts

@@ -1,6 +1,6 @@
 import { DocScanState } from "./createDocScanPlugin.js";
-import { EditorState, PluginKey } from "prosemirror-state";
 import { Node } from "prosemirror-model";
+import { EditorState, PluginKey } from "prosemirror-state";
 import { DirectiveKind } from "@stll/template-conditions";
 //#region src/prosemirror/plugins/templateDirectives.d.ts
 type DirectiveRange = {

package/dist/prosemirror/plugins/transactionInvariants.d.ts

@@ -0,0 +1,32 @@
+import { EditorState, Plugin, Transaction } from "prosemirror-state";
+//#region src/prosemirror/plugins/transactionInvariants.d.ts
+type TransactionInvariantFlags = {
+  /** Install the invariant plugin in every extension-manager runtime. */
+  enabled?: boolean;
+};
+declare global {
+  var __folioTransactionInvariants: TransactionInvariantFlags | undefined;
+}
+/** Whether new extension-manager runtimes install the invariant plugin. */
+declare const areTransactionInvariantsEnabled: () => boolean;
+type TransactionInvariantIssue = {
+  path: string;
+  message: string;
+  /** Position of the node the issue sits on, when the check knows it. */
+  pos?: number;
+};
+declare class TransactionInvariantError extends Error {
+  readonly issues: readonly TransactionInvariantIssue[];
+  readonly steps: readonly unknown[];
+  constructor(issues: readonly TransactionInvariantIssue[], transactions: readonly Transaction[]);
+}
+/** Every invariant the state breaks; empty when it is sound. */
+declare const checkEditorStateInvariants: (state: EditorState) => TransactionInvariantIssue[];
+/**
+ * Throw a {@link TransactionInvariantError} naming the offending steps when a
+ * document-changing transaction leaves the state with an issue it did not
+ * have before.
+ */
+declare const createTransactionInvariantPlugin: () => Plugin;
+//#endregion
+export { TransactionInvariantError, TransactionInvariantFlags, TransactionInvariantIssue, areTransactionInvariantsEnabled, checkEditorStateInvariants, createTransactionInvariantPlugin };

package/dist/prosemirror/plugins/transactionInvariants.js

@@ -0,0 +1,86 @@
+import { paragraphNumberingReferenceId } from "../../docx/numberingReference.js";
+import { validateProseMirrorDocument } from "../validation.js";
+import { getDocumentNumbering, hasDocumentNumbering } from "./documentNumbering.js";
+import { Plugin, PluginKey } from "prosemirror-state";
+//#region src/prosemirror/plugins/transactionInvariants.ts
+/** Whether new extension-manager runtimes install the invariant plugin. */
+const areTransactionInvariantsEnabled = () => globalThis.__folioTransactionInvariants?.enabled === true;
+const MAX_REPORTED_STEPS_LENGTH = 4e3;
+const describeSteps = (transactions) => {
+	const steps = transactions.flatMap((transaction) => transaction.steps.map((step) => step.toJSON()));
+	const json = JSON.stringify(steps);
+	return json.length > MAX_REPORTED_STEPS_LENGTH ? `${json.slice(0, MAX_REPORTED_STEPS_LENGTH)}… (${json.length} characters)` : json;
+};
+var TransactionInvariantError = class extends Error {
+	issues;
+	steps;
+	constructor(issues, transactions) {
+		super(`A transaction left the editor document invalid:\n${issues.map((issue) => `- ${issue.path}: ${issue.message}`).join("\n")}\nSteps: ${describeSteps(transactions)}`);
+		this.name = "TransactionInvariantError";
+		this.issues = issues;
+		this.steps = transactions.flatMap((transaction) => transaction.steps.map((step) => step.toJSON()));
+	}
+};
+const numberingReferenceIssues = (state) => {
+	if (!hasDocumentNumbering(state)) return [];
+	const numbering = getDocumentNumbering(state);
+	const issues = [];
+	state.doc.descendants((node, pos) => {
+		if (node.type.name !== "paragraph") return true;
+		const numId = paragraphNumberingReferenceId(node.attrs["numPr"]);
+		if (numId !== void 0 && !numbering?.hasNumbering(numId)) issues.push({
+			path: `paragraph at ${pos}.numPr.numId`,
+			message: `Numbering definition ${numId} is missing.`,
+			pos
+		});
+		return false;
+	});
+	return issues;
+};
+/** Every invariant the state breaks; empty when it is sound. */
+const checkEditorStateInvariants = (state) => [...validateProseMirrorDocument(state.doc).issues, ...numberingReferenceIssues(state)];
+/**
+* The issues `after` has that `before` did not. A document can arrive broken
+* (a malformed attribute the editor tolerates); only what a transaction adds
+* is the transaction's fault. An issue that names its node persists only on
+* that node, followed through the transactions' mappings, so moving a broken
+* reference from one paragraph to another still counts as new. Issues without
+* a position are matched by message, since their paths move with the edit.
+*/
+const introducedIssues = (before, after, transactions) => {
+	const mapPosition = (pos) => {
+		let mapped = pos;
+		for (const transaction of transactions) mapped = transaction.mapping.map(mapped, 1);
+		return mapped;
+	};
+	const persisting = /* @__PURE__ */ new Set();
+	const remaining = /* @__PURE__ */ new Map();
+	for (const issue of before) if (issue.pos === void 0) remaining.set(issue.message, (remaining.get(issue.message) ?? 0) + 1);
+	else persisting.add(`${mapPosition(issue.pos)}:${issue.message}`);
+	return after.filter((issue) => {
+		if (issue.pos !== void 0) return !persisting.has(`${issue.pos}:${issue.message}`);
+		const count = remaining.get(issue.message) ?? 0;
+		if (count === 0) return true;
+		remaining.set(issue.message, count - 1);
+		return false;
+	});
+};
+const transactionInvariantsKey = new PluginKey("transactionInvariants");
+/**
+* Throw a {@link TransactionInvariantError} naming the offending steps when a
+* document-changing transaction leaves the state with an issue it did not
+* have before.
+*/
+const createTransactionInvariantPlugin = () => new Plugin({
+	key: transactionInvariantsKey,
+	appendTransaction(transactions, oldState, newState) {
+		if (!transactions.some((transaction) => transaction.docChanged)) return null;
+		const issues = checkEditorStateInvariants(newState);
+		if (issues.length === 0) return null;
+		const introduced = introducedIssues(checkEditorStateInvariants(oldState), issues, transactions);
+		if (introduced.length > 0) throw new TransactionInvariantError(introduced, transactions);
+		return null;
+	}
+});
+//#endregion
+export { TransactionInvariantError, areTransactionInvariantsEnabled, checkEditorStateInvariants, createTransactionInvariantPlugin };

package/dist/prosemirror/positionSweep.d.ts

@@ -0,0 +1,24 @@
+import { Mapping } from "prosemirror-transform";
+//#region src/prosemirror/positionSweep.d.ts
+type PositionQuery = {
+  pos: number;
+  assoc: -1 | 1;
+  /**
+   * Index of the first step map to apply, counting across every mapping
+   * passed in order: the position is in the document that step read.
+   */
+  from: number;
+};
+type SweptPosition = {
+  pos: number;
+  deletedAcross: boolean;
+};
+/**
+ * Map every query through `mappings` (one per transaction, in order), each
+ * entering at its own step. O((positions + steps) x log positions) plus the
+ * positions a step's changed ranges actually cover, rather than
+ * O(positions x steps).
+ */
+declare const sweepPositions: (mappings: readonly Mapping[], queries: readonly PositionQuery[]) => SweptPosition[];
+//#endregion
+export { PositionQuery, SweptPosition, sweepPositions };

package/dist/prosemirror/positionSweep.js

@@ -0,0 +1,222 @@
+//#region src/prosemirror/positionSweep.ts
+/** Positions kept per chunk before it splits; small enough to splice cheaply. */
+const CHUNK_SIZE = 128;
+const cursorBefore = (left, right) => left.chunk < right.chunk || left.chunk === right.chunk && left.index < right.index;
+/** Positions sharing one `assoc`, sorted by their current value. */
+var Lane = class {
+	chunks = [];
+	assoc;
+	constructor(assoc) {
+		this.assoc = assoc;
+	}
+	get isEmpty() {
+		return this.chunks.length === 0;
+	}
+	/** Replace an empty lane's contents with `entries`, sorted by value. */
+	load(entries) {
+		for (let start = 0; start < entries.length; start += CHUNK_SIZE) {
+			const slice = entries.slice(start, start + CHUNK_SIZE);
+			this.chunks.push({
+				shift: 0,
+				values: slice.map(([value]) => value),
+				ids: slice.map(([, id]) => id)
+			});
+		}
+	}
+	insert(value, id) {
+		if (!this.chunks.at(-1)) {
+			this.chunks.push({
+				shift: 0,
+				values: [value],
+				ids: [id]
+			});
+			return;
+		}
+		const cursor = this.bound(value, true);
+		const chunkIndex = Math.min(cursor.chunk, this.chunks.length - 1);
+		const chunk = this.chunks[chunkIndex];
+		const index = cursor.chunk === chunkIndex ? cursor.index : chunk.values.length;
+		chunk.values.splice(index, 0, value - chunk.shift);
+		chunk.ids.splice(index, 0, id);
+		if (chunk.values.length > 2 * CHUNK_SIZE) this.chunks.splice(chunkIndex + 1, 0, {
+			shift: chunk.shift,
+			values: chunk.values.splice(CHUNK_SIZE),
+			ids: chunk.ids.splice(CHUNK_SIZE)
+		});
+	}
+	/**
+	* The first entry whose value is at least `value` (`strict`: greater than
+	* it), or the end of the lane.
+	*/
+	bound(value, strict) {
+		const passes = (candidate) => strict ? candidate > value : candidate >= value;
+		let low = 0;
+		let high = this.chunks.length;
+		while (low < high) {
+			const middle = low + high >>> 1;
+			const chunk = this.chunks[middle];
+			if (passes(chunk.values.at(-1) + chunk.shift)) high = middle;
+			else low = middle + 1;
+		}
+		const chunk = this.chunks[low];
+		if (!chunk) return {
+			chunk: this.chunks.length,
+			index: 0
+		};
+		let first = 0;
+		let last = chunk.values.length;
+		while (first < last) {
+			const middle = first + last >>> 1;
+			if (passes(chunk.values[middle] + chunk.shift)) last = middle;
+			else first = middle + 1;
+		}
+		return {
+			chunk: low,
+			index: first
+		};
+	}
+	/** Visit every entry from `start` up to, not including, `end`. */
+	forEachBetween(start, end, visit) {
+		for (let chunkIndex = start.chunk; chunkIndex <= end.chunk; chunkIndex++) {
+			const chunk = this.chunks[chunkIndex];
+			if (!chunk) return;
+			const first = chunkIndex === start.chunk ? start.index : 0;
+			const last = chunkIndex === end.chunk ? end.index : chunk.values.length;
+			for (let index = first; index < last; index++) visit(chunk, index);
+		}
+	}
+	/** Add `delta` to every entry from `start` to the end of the lane. */
+	shiftFrom(start, end, delta) {
+		if (delta === 0) return;
+		const stop = end ?? {
+			chunk: this.chunks.length,
+			index: 0
+		};
+		for (let chunkIndex = start.chunk; chunkIndex <= stop.chunk; chunkIndex++) {
+			const chunk = this.chunks[chunkIndex];
+			if (!chunk) return;
+			const first = chunkIndex === start.chunk ? start.index : 0;
+			const last = chunkIndex === stop.chunk ? stop.index : chunk.values.length;
+			if (first === 0 && last === chunk.values.length) {
+				chunk.shift += delta;
+				continue;
+			}
+			for (let index = first; index < last; index++) chunk.values[index] += delta;
+		}
+	}
+	apply(map, deletedAcross) {
+		if (this.chunks.length === 0) return;
+		const ranges = [];
+		let previousEnd = {
+			chunk: 0,
+			index: 0
+		};
+		map.forEach((oldStart, oldEnd, newStart, newEnd) => {
+			const lower = this.bound(oldStart, false);
+			const start = cursorBefore(lower, previousEnd) ? previousEnd : lower;
+			const end = this.bound(oldEnd, true);
+			ranges.push({
+				start,
+				end,
+				delta: newEnd - newStart - (oldEnd - oldStart)
+			});
+			previousEnd = end;
+		});
+		let cursor = {
+			chunk: 0,
+			index: 0
+		};
+		let delta = 0;
+		for (const range of ranges) {
+			this.shiftFrom(cursor, range.start, delta);
+			this.forEachBetween(range.start, range.end, (chunk, index) => {
+				const result = map.mapResult(chunk.values[index] + chunk.shift, this.assoc);
+				chunk.values[index] = result.pos - chunk.shift;
+				if (result.deletedAcross) deletedAcross[chunk.ids[index]] = true;
+			});
+			delta += range.delta;
+			cursor = range.end;
+		}
+		this.shiftFrom(cursor, null, delta);
+	}
+	collect(positions) {
+		for (const chunk of this.chunks) for (let index = 0; index < chunk.values.length; index++) positions[chunk.ids[index]] = chunk.values[index] + chunk.shift;
+	}
+};
+const hasMirrors = (mapping) => {
+	for (let index = mapping.from; index < mapping.to; index++) if (mapping.getMirror(index) !== void 0) return true;
+	return false;
+};
+/**
+* The per-step walk, kept for mappings that carry mirror pairs (collaborative
+* rebases): a mirrored map recovers a deleted position from its twin, which
+* only a walk through every map can see.
+*/
+const mapPerStep = (mappings, queries) => queries.map(({ pos, assoc, from }) => {
+	let mapped = pos;
+	let deletedAcross = false;
+	let offset = 0;
+	for (const mapping of mappings) {
+		const length = mapping.to - mapping.from;
+		if (from < offset + length) {
+			const result = mapping.slice(mapping.from + Math.max(0, from - offset), mapping.to).mapResult(mapped, assoc);
+			mapped = result.pos;
+			deletedAcross ||= result.deletedAcross;
+		}
+		offset += length;
+	}
+	return {
+		pos: mapped,
+		deletedAcross
+	};
+});
+/**
+* Map every query through `mappings` (one per transaction, in order), each
+* entering at its own step. O((positions + steps) x log positions) plus the
+* positions a step's changed ranges actually cover, rather than
+* O(positions x steps).
+*/
+const sweepPositions = (mappings, queries) => {
+	if (queries.length === 0) return [];
+	if (mappings.some(hasMirrors)) return mapPerStep(mappings, queries);
+	const maps = mappings.flatMap((mapping) => mapping.maps.slice(mapping.from, mapping.to));
+	const order = queries.map((query, id) => ({
+		id,
+		from: Math.min(Math.max(query.from, 0), maps.length)
+	})).sort((left, right) => left.from - right.from || left.id - right.id);
+	const backward = new Lane(-1);
+	const forward = new Lane(1);
+	const deletedAcross = queries.map(() => false);
+	let next = 0;
+	const enter = (step) => {
+		const entering = /* @__PURE__ */ new Map([[backward, []], [forward, []]]);
+		for (; next < order.length && order[next].from === step; next++) {
+			const { id } = order[next];
+			const query = queries[id];
+			entering.get(query.assoc < 0 ? backward : forward).push([query.pos, id]);
+		}
+		for (const [lane, entries] of entering) {
+			if (lane.isEmpty) {
+				lane.load(entries.sort((left, right) => left[0] - right[0]));
+				continue;
+			}
+			for (const [value, id] of entries) lane.insert(value, id);
+		}
+	};
+	for (let step = 0; step < maps.length; step++) {
+		if (next < order.length && order[next].from === step) enter(step);
+		const map = maps[step];
+		backward.apply(map, deletedAcross);
+		forward.apply(map, deletedAcross);
+	}
+	if (next < order.length) enter(maps.length);
+	const positions = queries.map(({ pos }) => pos);
+	backward.collect(positions);
+	forward.collect(positions);
+	return positions.map((pos, id) => ({
+		pos,
+		deletedAcross: deletedAcross[id] ?? false
+	}));
+};
+//#endregion
+export { sweepPositions };

package/dist/prosemirror/rebaseParagraphRunFormatting.d.ts

@@ -1,6 +1,7 @@
-import { RunStyleResolver } from "./runStyleFormatting.js";
-import { Transaction } from "prosemirror-state";
+import { ParagraphRunStyleContext, RunStyleResolver } from "./runStyleFormatting.js";
 import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+import { Transform } from "prosemirror-transform";
 //#region src/prosemirror/rebaseParagraphRunFormatting.d.ts
 type RebaseParagraphRunFormattingOptions = {
   nextAttrs: Record<string, unknown>;
@@ -9,10 +10,29 @@ type RebaseParagraphRunFormattingOptions = {
   styleResolver: RunStyleResolver;
   tr: Transaction;
 };
+type RebaseParagraphRunsOptions<T extends Transform> = {
+  /** The style context the runs' marks were resolved in. */
+  previousContext: ParagraphRunStyleContext;
+  paragraphPosition: number;
+  /** Content offsets inside the paragraph to rebase; all of it when omitted. */
+  range?: {
+    from: number;
+    to: number;
+  };
+  shouldRebase?: (node: Node) => boolean;
+  styleResolver: RunStyleResolver;
+  tr: T;
+};
+/**
+ * Re-resolve the inherited marks of runs resolved in `previousContext` in the
+ * paragraph's current style context: direct formatting stays direct, and what
+ * the old context lent the runs goes with it.
+ */
+declare const rebaseParagraphRuns: <T extends Transform>({ previousContext, paragraphPosition, range, shouldRebase, styleResolver, tr }: RebaseParagraphRunsOptions<T>) => T;
 /**
  * Change paragraph attrs and re-resolve inherited run marks in the new style
  * context without turning the old rendered style into direct run formatting.
  */
 declare const setParagraphAttrsWithRebasedRunFormatting: ({ nextAttrs, paragraphPosition, shouldRebase, styleResolver, tr }: RebaseParagraphRunFormattingOptions) => Transaction;
 //#endregion
-export { setParagraphAttrsWithRebasedRunFormatting };
+export { rebaseParagraphRuns, setParagraphAttrsWithRebasedRunFormatting };

package/dist/prosemirror/rebaseParagraphRunFormatting.js

@@ -1,3 +1,4 @@
+import { sameRunStyleContext } from "./rebaseParagraphRuns.js";
 import { expandRunFormattingCarrier } from "./runFormattingInlineCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
@@ -5,18 +6,23 @@ import { paragraphRunStyleContext } from "./runStyleFormatting.js";
 import { panic } from "better-result";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/rebaseParagraphRunFormatting.ts
-/**
-* Change paragraph attrs and re-resolve inherited run marks in the new style
-* context without turning the old rendered style into direct run formatting.
-*/
-const setParagraphAttrsWithRebasedRunFormatting = ({ nextAttrs, paragraphPosition, shouldRebase, styleResolver, tr }) => {
+const paragraphAt = (tr, paragraphPosition) => {
 	const paragraph = tr.doc.nodeAt(paragraphPosition);
 	if (!paragraph || paragraph.type.name !== "paragraph") return panic("Cannot rebase run formatting outside a paragraph", {
 		nodeType: paragraph?.type.name,
 		paragraphPosition
 	});
-	const previousContext = paragraphRunStyleContext(paragraph, styleResolver);
-	const nextContext = paragraphRunStyleContext(paragraph.type.create(nextAttrs, paragraph.content, paragraph.marks), styleResolver);
+	return paragraph;
+};
+/**
+* Re-resolve the inherited marks of runs resolved in `previousContext` in the
+* paragraph's current style context: direct formatting stays direct, and what
+* the old context lent the runs goes with it.
+*/
+const rebaseParagraphRuns = ({ previousContext, paragraphPosition, range, shouldRebase, styleResolver, tr }) => {
+	const paragraph = paragraphAt(tr, paragraphPosition);
+	const nextContext = paragraphRunStyleContext(paragraph, styleResolver);
+	if (sameRunStyleContext(previousContext, nextContext)) return tr;
 	const changes = [];
 	const collectRebasedRepresentation = ({ node, position }) => {
 		if (shouldRebase && !shouldRebase(node)) return;
@@ -31,23 +37,28 @@ const setParagraphAttrsWithRebasedRunFormatting = ({ nextAttrs, paragraphPositio
 			styleResolver
 		});
 		if (Mark.sameSet(node.marks, nextMarks)) return;
+		const start = paragraphPosition + 1;
+		const from = node.isText && range ? Math.max(position, start + range.from) : position;
+		const to = node.isText && range ? Math.min(position + node.nodeSize, start + range.to) : position + node.nodeSize;
+		if (to <= from) return;
 		changes.push({
 			attrs: node.attrs,
 			currentFormattingMarks: node.marks.filter(({ type }) => RUN_FORMATTING_MARK_NAMES.has(type.name)),
-			from: position,
+			from,
 			isText: node.isText,
 			marks: nextMarks,
-			to: position + node.nodeSize
+			to
 		});
 	};
-	paragraph.descendants((node, relativePosition) => {
+	const visit = (node, relativePosition) => {
 		if (!node.isInline) return true;
 		const carrier = expandRunFormattingCarrier(node, paragraphPosition + 1 + relativePosition);
 		if (!carrier) return !node.isAtom;
 		for (const representation of carrier.representations) collectRebasedRepresentation(representation);
 		return false;
-	});
-	tr = tr.setNodeMarkup(paragraphPosition, void 0, nextAttrs);
+	};
+	if (range === void 0) paragraph.descendants(visit);
+	else paragraph.nodesBetween(range.from, range.to, visit);
 	for (const { attrs, currentFormattingMarks, from, isText, marks, to } of changes) {
 		if (!isText) {
 			tr = tr.setNodeMarkup(from, void 0, attrs, marks);
@@ -58,5 +69,20 @@ const setParagraphAttrsWithRebasedRunFormatting = ({ nextAttrs, paragraphPositio
 	}
 	return tr;
 };
+/**
+* Change paragraph attrs and re-resolve inherited run marks in the new style
+* context without turning the old rendered style into direct run formatting.
+*/
+const setParagraphAttrsWithRebasedRunFormatting = ({ nextAttrs, paragraphPosition, shouldRebase, styleResolver, tr }) => {
+	const previousContext = paragraphRunStyleContext(paragraphAt(tr, paragraphPosition), styleResolver);
+	tr = tr.setNodeMarkup(paragraphPosition, void 0, nextAttrs);
+	return rebaseParagraphRuns({
+		previousContext,
+		paragraphPosition,
+		...shouldRebase ? { shouldRebase } : {},
+		styleResolver,
+		tr
+	});
+};
 //#endregion
-export { setParagraphAttrsWithRebasedRunFormatting };
+export { rebaseParagraphRuns, setParagraphAttrsWithRebasedRunFormatting };

package/dist/prosemirror/rebaseParagraphRuns.d.ts

@@ -0,0 +1,36 @@
+import { ParagraphRunStyleContext, RunStyleResolver } from "./runStyleFormatting.js";
+import { Fragment, Mark, Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+//#region src/prosemirror/rebaseParagraphRuns.d.ts
+/** Two contexts that lend runs the same formatting: rebasing between them changes nothing. */
+declare const sameRunStyleContext: (source: ParagraphRunStyleContext, target: ParagraphRunStyleContext) => boolean;
+type RebaseParagraphRunsOptions = {
+  tr: Transaction;
+  position: number;
+  previous: Node;
+  target?: Node;
+  styleResolver: RunStyleResolver | null;
+  range?: {
+    from: number;
+    to: number;
+  };
+  storedMarks?: readonly Mark[] | null;
+};
+/** Rebuild rendered marks after the paragraph's style cascade changes. */
+declare const rebaseParagraphRuns: ({ tr, position, previous, target, styleResolver, range, storedMarks: initialStoredMarks }: RebaseParagraphRunsOptions) => Transaction;
+type RebasedRunFormatting = {
+  before: Node;
+  after: Node;
+  position: number;
+};
+type RebaseParagraphRunContentOptions = {
+  paragraph: Node;
+  target: Node;
+  position: number;
+  styleResolver: RunStyleResolver | null;
+  onRebased: (resolution: RebasedRunFormatting) => void;
+};
+/** Rebase an immutable paragraph chunk once, before assembling a resolved join chain. */
+declare const rebaseParagraphRunContent: ({ paragraph, target, position, styleResolver, onRebased }: RebaseParagraphRunContentOptions) => Fragment;
+//#endregion
+export { rebaseParagraphRunContent, rebaseParagraphRuns, sameRunStyleContext };

package/dist/prosemirror/rebaseParagraphRuns.js

@@ -0,0 +1,99 @@
+import { recreateProseNodeWithParagraphPropertySource } from "../docx/paragraphPropertySource.js";
+import { formattingEquals } from "../docx/runConsolidator.js";
+import { applyMarksToRunFormattingRepresentation, selectRunFormattingCarrierRepresentations } from "./runFormattingInlineCarriers.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
+import { paragraphRunStyleContext } from "./runStyleFormatting.js";
+import { Mark } from "prosemirror-model";
+//#region src/prosemirror/rebaseParagraphRuns.ts
+/** Two contexts that lend runs the same formatting: rebasing between them changes nothing. */
+const sameRunStyleContext = (source, target) => source.paragraphMarkPrecedesStyle === target.paragraphMarkPrecedesStyle && formattingEquals(source.baseParagraphFormatting, target.baseParagraphFormatting) && formattingEquals(source.paragraphFormatting, target.paragraphFormatting) && formattingEquals(source.paragraphMarkFormatting, target.paragraphMarkFormatting);
+/** Rebuild rendered marks after the paragraph's style cascade changes. */
+const rebaseParagraphRuns = ({ tr, position, previous, target, styleResolver, range, storedMarks: initialStoredMarks }) => {
+	const paragraph = tr.doc.nodeAt(position);
+	if (!paragraph) return tr;
+	const storedMarks = initialStoredMarks ?? tr.storedMarks ?? tr.selection.$from.marks();
+	const sourceContext = paragraphRunStyleContext(previous, styleResolver);
+	const targetContext = paragraphRunStyleContext(target ?? paragraph, styleResolver);
+	const sameCascade = sameRunStyleContext(sourceContext, targetContext);
+	const representations = sameCascade ? [] : selectRunFormattingCarrierRepresentations({
+		doc: tr.doc,
+		from: range?.from ?? position + 1,
+		to: range?.to ?? position + paragraph.nodeSize - 1
+	});
+	for (const representation of representations) applyMarksToRunFormattingRepresentation({
+		tr,
+		representation,
+		marks: reconcileRunFormattingMarks({
+			authoredFormatting: readAuthoredRunFormatting({
+				context: sourceContext,
+				marks: representation.node.marks,
+				styleResolver
+			}),
+			context: targetContext,
+			node: representation.node,
+			styleResolver
+		})
+	});
+	if (target === void 0 && range === void 0 && tr.selection.empty && tr.selection.from > position && tr.selection.from < position + paragraph.nodeSize) {
+		const node = paragraph.type.schema.text(" ", storedMarks);
+		tr.setStoredMarks(sameCascade ? storedMarks : reconcileRunFormattingMarks({
+			authoredFormatting: readAuthoredRunFormatting({
+				context: sourceContext,
+				marks: node.marks,
+				styleResolver
+			}),
+			context: targetContext,
+			node,
+			styleResolver
+		}));
+	}
+	return tr;
+};
+/** Rebase an immutable paragraph chunk once, before assembling a resolved join chain. */
+const rebaseParagraphRunContent = ({ paragraph, target, position, styleResolver, onRebased }) => {
+	const sourceContext = paragraphRunStyleContext(paragraph, styleResolver);
+	const targetContext = paragraphRunStyleContext(target, styleResolver);
+	if (sameRunStyleContext(sourceContext, targetContext)) return paragraph.content;
+	const replacements = /* @__PURE__ */ new Map();
+	const representations = selectRunFormattingCarrierRepresentations({
+		doc: paragraph,
+		from: 0,
+		to: paragraph.content.size
+	});
+	for (const representation of representations) {
+		const marks = reconcileRunFormattingMarks({
+			authoredFormatting: readAuthoredRunFormatting({
+				context: sourceContext,
+				marks: representation.node.marks,
+				styleResolver
+			}),
+			context: targetContext,
+			node: representation.node,
+			styleResolver
+		});
+		if (Mark.sameSet(marks, representation.node.marks)) continue;
+		const rebased = representation.node.mark(marks);
+		replacements.set(representation.node, rebased);
+		onRebased({
+			before: representation.node,
+			after: rebased,
+			position: position + 1 + representation.position
+		});
+	}
+	if (replacements.size === 0) return paragraph.content;
+	const rebuild = (node) => {
+		const replacement = replacements.get(node) ?? node;
+		if (node.isLeaf) return replacement;
+		const children = [];
+		let changed = false;
+		replacement.forEach((child) => {
+			const next = rebuild(child);
+			children.push(next);
+			changed ||= next !== child;
+		});
+		return changed ? recreateProseNodeWithParagraphPropertySource(replacement, { content: children }) : replacement;
+	};
+	return rebuild(paragraph).content;
+};
+//#endregion
+export { rebaseParagraphRunContent, rebaseParagraphRuns, sameRunStyleContext };

package/dist/prosemirror/rejoinRunCarriers.d.ts

@@ -1,6 +1,6 @@
 import { ParagraphRunStyleContext, RunStyleResolver } from "./runStyleFormatting.js";
-import { Transaction } from "prosemirror-state";
 import { Mark, Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/rejoinRunCarriers.d.ts
 type ContinuedRunMarksOptions = {
   left: Node;