@stll/folio-core 0.52.0 → 0.53.0

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,6 @@
 import { RunStyleResolver } from "./runStyleFormatting.js";
-import { Transaction } from "prosemirror-state";
 import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/rebaseParagraphRunFormatting.d.ts
 type RebaseParagraphRunFormattingOptions = {
   nextAttrs: Record<string, unknown>;

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;

package/dist/prosemirror/replacedAnnotations.d.ts

@@ -48,6 +48,38 @@ type AnnotatedReplacement = {
 };
 /** `marks` with the carried marks added, each type's exclusions respected. */
 declare const addCarriedMarks: (marks: readonly Mark[], carried: readonly Mark[]) => readonly Mark[];
+/**
+ * The mark sets of a run of text a TRACKED edit inserts at `at` (one set per
+ * piece, in order), with the comments that keep every comment one stretch.
+ *
+ * A tracked replacement keeps the replaced text (as a deletion), and that text
+ * keeps its comments, so a comment carried or inherited onto the insertion
+ * only CONTINUES its range: it stays when, through the run, it reaches the
+ * content directly before or after `at`, and goes otherwise. Between two
+ * pieces that have a comment (the neighbours included), every piece takes
+ * it, or the run would split it in two.
+ */
+declare const commentsForTrackedInsertion: (doc: Node, at: number, pieces: readonly (readonly Mark[])[]) => (readonly Mark[])[];
+/**
+ * Where, within the text a tracked replacement removes (`from` to `to`), each
+ * piece of its new text goes, one position per piece and never decreasing.
+ *
+ * The redline reads the removed text first and the new text after it, so by
+ * default every piece goes at `to`. A piece given a comment goes where that
+ * comment's stretch of removed text ends instead, next to it; the pieces
+ * before it that have no comment go where that stretch begins, and the ones
+ * after it follow it. So each comment stays one stretch, holding the removed
+ * text it held and exactly the new text given it.
+ */
+declare const placeTrackedInsertion: (doc: Node, from: number, to: number, pieces: readonly (readonly Mark[])[]) => number[];
+/**
+ * The comments content inserted at the block boundary `at` must carry: those
+ * covering the content on both sides of it. A comment range is two points in
+ * document order, so what lands between them is covered whether the range
+ * crosses paragraphs, empty paragraphs or a table edge, and the saved package
+ * reopens exactly so. A merge's separator lands on such a boundary too.
+ */
+declare const commentsAcrossBlockBoundary: (doc: Node, at: number) => Mark[];
 /** `content` with the surveyed marks on it and the surveyed anchors around it. */
 declare const annotatedReplacement: ({ annotations: { carried, leading, trailing }, content }: AnnotatedReplacementOptions) => AnnotatedReplacement;
 /**
@@ -56,4 +88,4 @@ declare const annotatedReplacement: ({ annotations: { carried, leading, trailing
  */
 declare const inheritedReplacementMarks: (doc: Node, from: number, to: number) => readonly Mark[];
 //#endregion
-export { NON_INCLUSIVE_MARK_DISPOSITION, ReplacedAnnotations, addCarriedMarks, annotatedReplacement, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, surveyReplacedAnnotations };
+export { NON_INCLUSIVE_MARK_DISPOSITION, ReplacedAnnotations, addCarriedMarks, annotatedReplacement, commentsAcrossBlockBoundary, commentsForTrackedInsertion, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, surveyReplacedAnnotations };

package/dist/prosemirror/replacedAnnotations.js

@@ -4,6 +4,7 @@ import { MOVE_RANGE_BOUNDARY_NODE_NAME } from "./extensions/nodes/MoveRangeBound
 import { RANGE_ANCHOR_NODE_NAME } from "./extensions/nodes/RangeAnchorExtension.js";
 import { TEXT_BOX_ANCHOR_NODE_NAME } from "./extensions/nodes/TextBoxAnchorExtension.js";
 import { readMoveRangeBoundaryAttrs } from "./moveRangeBoundaryAttrs.js";
+import { isZeroWidthAnchor } from "./zeroWidthAnchors.js";
 import { Fragment, Mark } from "prosemirror-model";
 //#region src/prosemirror/replacedAnnotations.ts
 /**
@@ -152,6 +153,174 @@ const addCarriedMarks = (marks, carried) => {
 	for (const mark of carried) next = mark.addToSet(next);
 	return next;
 };
+/**
+* Invariant: a comment mark covers ONE contiguous stretch of a paragraph. A
+* save writes one range start and one range end per comment, so a comment on
+* two stretches reopens covering the text between them as well.
+*
+* Text an edit inserts is where that breaks: it lands next to the text of a
+* comment, or inside it. These pick the comments inserted text takes so that
+* every comment stays one stretch.
+*/
+/**
+* The first (`1`) or last (`-1`) inline content inside `node` that is not a
+* zero-width anchor, descending through every container.
+*/
+const innermostEdge = (node, direction) => {
+	if (node.isInline) return isZeroWidthAnchor(node) ? null : node;
+	for (let index = direction === 1 ? 0 : node.childCount - 1; index >= 0 && index < node.childCount; index += direction) {
+		const found = innermostEdge(node.child(index), direction);
+		if (found) return found;
+	}
+	return null;
+};
+/**
+* The inline content nearest the block boundary `at` on one side, in document
+* order: past empty paragraphs, and into and out of tables, the way a saved
+* range's two points read it.
+*/
+const contentBesideBoundary = (doc, at, direction) => {
+	const $at = doc.resolve(at);
+	for (let depth = $at.depth; depth >= 0; depth--) {
+		const parent = $at.node(depth);
+		const index = $at.index(depth);
+		let child = index + direction;
+		if (depth === $at.depth) child = direction === 1 ? index : index - 1;
+		for (; child >= 0 && child < parent.childCount; child += direction) {
+			const found = innermostEdge(parent.child(child), direction);
+			if (found) return found;
+		}
+	}
+	return null;
+};
+/**
+* The content either side of `at` in its paragraph, past zero-width anchors
+* (a comment's own reference sits between its text and what follows).
+*/
+const neighboursAt = (doc, at) => {
+	const $at = doc.resolve(at);
+	const parent = $at.parent;
+	const neighbour = (direction) => {
+		const adjacent = direction === -1 ? $at.nodeBefore : $at.nodeAfter;
+		if (!adjacent || !isZeroWidthAnchor(adjacent)) return adjacent;
+		for (let index = direction === -1 ? $at.index() - 2 : $at.index() + 1; index >= 0 && index < parent.childCount; index += direction) {
+			const child = parent.child(index);
+			if (!isZeroWidthAnchor(child)) return child;
+		}
+		return null;
+	};
+	return {
+		before: neighbour(-1),
+		after: neighbour(1)
+	};
+};
+/** The comments on both `before` and `after`: text between them must carry them. */
+const commentsAround = (before, after) => before && after ? before.marks.filter((mark) => mark.type.name === "comment" && mark.isInSet(after.marks)) : [];
+/**
+* The mark sets of a run of text a TRACKED edit inserts at `at` (one set per
+* piece, in order), with the comments that keep every comment one stretch.
+*
+* A tracked replacement keeps the replaced text (as a deletion), and that text
+* keeps its comments, so a comment carried or inherited onto the insertion
+* only CONTINUES its range: it stays when, through the run, it reaches the
+* content directly before or after `at`, and goes otherwise. Between two
+* pieces that have a comment (the neighbours included), every piece takes
+* it, or the run would split it in two.
+*/
+const commentsForTrackedInsertion = (doc, at, pieces) => {
+	const { before, after } = neighboursAt(doc, at);
+	const sets = [
+		before?.marks ?? [],
+		...pieces,
+		after?.marks ?? []
+	];
+	const comments = [];
+	for (const set of sets) for (const mark of set) if (mark.type.name === "comment" && !mark.isInSet(comments)) comments.push(mark);
+	const result = pieces.map((set) => set.filter((mark) => mark.type.name !== "comment"));
+	for (const comment of comments) {
+		const covered = sets.flatMap((set, index) => comment.isInSet(set) ? [index] : []);
+		const first = covered[0];
+		const last = covered.at(-1);
+		if (first !== 0 && last !== sets.length - 1) continue;
+		for (let index = Math.max(first, 1); index <= Math.min(last, pieces.length); index++) result[index - 1] = comment.addToSet([...result[index - 1]]);
+	}
+	return result;
+};
+/**
+* Where, within the text a tracked replacement removes (`from` to `to`), each
+* piece of its new text goes, one position per piece and never decreasing.
+*
+* The redline reads the removed text first and the new text after it, so by
+* default every piece goes at `to`. A piece given a comment goes where that
+* comment's stretch of removed text ends instead, next to it; the pieces
+* before it that have no comment go where that stretch begins, and the ones
+* after it follow it. So each comment stays one stretch, holding the removed
+* text it held and exactly the new text given it.
+*/
+const placeTrackedInsertion = (doc, from, to, pieces) => {
+	const stretches = /* @__PURE__ */ new Map();
+	doc.nodesBetween(from, to, (node, position) => {
+		if (!node.isText) return true;
+		for (const mark of node.marks) {
+			if (mark.type.name !== "comment") continue;
+			const known = [...stretches.keys()].find((other) => other.eq(mark)) ?? mark;
+			const start = Math.max(position, from);
+			const end = Math.min(position + node.nodeSize, to);
+			const stretch = stretches.get(known);
+			stretches.set(known, stretch ? {
+				start: stretch.start,
+				end
+			} : {
+				start,
+				end
+			});
+		}
+		return false;
+	});
+	const stretchOf = (set) => {
+		const own = [...stretches].filter(([mark]) => mark.isInSet(set));
+		if (own.length === 0) return;
+		const start = Math.min(...own.map(([, stretch]) => stretch.start));
+		const ascending = (left, right) => left - right;
+		const candidates = [...own.map(([, stretch]) => stretch.end).toSorted(ascending), ...own.map(([, stretch]) => stretch.start).toSorted(ascending)];
+		for (const position of candidates) {
+			const { before, after } = neighboursAt(doc, position);
+			if (own.every(([mark]) => Boolean(before && mark.isInSet(before.marks)) || Boolean(after && mark.isInSet(after.marks)))) return {
+				start,
+				end: position
+			};
+		}
+		return {
+			start,
+			end: Math.min(...own.map(([, stretch]) => stretch.end))
+		};
+	};
+	const anchored = pieces.map(stretchOf);
+	const positions = [];
+	let previous = from;
+	for (const [index, stretch] of anchored.entries()) {
+		let position;
+		if (stretch) position = stretch.end;
+		else {
+			const next = anchored.slice(index + 1).find((candidate) => candidate !== void 0);
+			const placedBefore = anchored.slice(0, index).some((candidate) => candidate !== void 0);
+			position = next && !placedBefore ? next.start : to;
+			if (placedBefore && next) position = previous;
+		}
+		position = Math.max(position, previous);
+		positions.push(position);
+		previous = position;
+	}
+	return positions;
+};
+/**
+* The comments content inserted at the block boundary `at` must carry: those
+* covering the content on both sides of it. A comment range is two points in
+* document order, so what lands between them is covered whether the range
+* crosses paragraphs, empty paragraphs or a table edge, and the saved package
+* reopens exactly so. A merge's separator lands on such a boundary too.
+*/
+const commentsAcrossBlockBoundary = (doc, at) => commentsAround(contentBesideBoundary(doc, at, -1), contentBesideBoundary(doc, at, 1));
 const withCarriedMarks = (node, carried) => node.mark(addCarriedMarks(node.marks, carried));
 /** `content` with the surveyed marks on it and the surveyed anchors around it. */
 const annotatedReplacement = ({ annotations: { carried, leading, trailing }, content }) => {
@@ -180,4 +349,4 @@ const inheritedReplacementMarks = (doc, from, to) => {
 	return (to === from ? $from.marks() : $from.marksAcross(doc.resolve(to))) ?? Mark.none;
 };
 //#endregion
-export { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, surveyReplacedAnnotations };
+export { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, commentsAcrossBlockBoundary, commentsForTrackedInsertion, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, surveyReplacedAnnotations };

package/dist/prosemirror/runFormattingInlineCarriers.d.ts

@@ -1,5 +1,5 @@
-import { Transaction } from "prosemirror-state";
 import { Mark, Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/runFormattingInlineCarriers.d.ts
 type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run" | "page-break-carrier" | "preserved-xml-run" | "structured-field" | "symbol-run" | "tab-run" | "text-run";
 /**

package/dist/prosemirror/schema/index.d.ts

@@ -1,5 +1,5 @@
 import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, InlineWrapperAttrs, InlineWrapperKind, InlineWrapperLayer, LanguageAttrs, RunFormattingOverrideAttrs, RunIdentityMarkAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, TrackedRevisionAncestor, UnderlineAttrs } from "./marks.js";
-import { BlockSdtAttrs, BookmarkBoundaryAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, PreservedBlockAttrs, PreservedXmlAttrs, PreservedXmlLevel, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "./nodes.js";
+import { BlockCustomXmlAttrs, BlockSdtAttrs, BookmarkBoundaryAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, PreservedBlockAttrs, PreservedXmlAttrs, PreservedXmlLevel, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "./nodes.js";
 import { ExtensionManager } from "../extensions/ExtensionManager.js";
 //#region src/prosemirror/schema/index.d.ts
 declare const singletonManager: ExtensionManager;
@@ -11,4 +11,4 @@ type DocxSchema = typeof schema;
 type DocxNode = ReturnType<typeof schema.node>;
 type DocxMark = ReturnType<typeof schema.mark>;
 //#endregion
-export { type BlockSdtAttrs, type BookmarkBoundaryAttrs, type CharacterSpacingAttrs, type CharacterStyleAttrs, type CommentAttrs, DocxMark, DocxNode, DocxSchema, type EmphasisMarkAttrs, type FieldAttrs, type FontFamilyAttrs, type FontSizeAttrs, type FootnoteRefAttrs, type HardBreakAttrs, type HighlightAttrs, type HyperlinkAttrs, type ImageAttrs, type ImagePositionAttrs, type InlineWrapperAttrs, type InlineWrapperKind, type InlineWrapperLayer, type LanguageAttrs, type MathAttrs, type PageBreakRunAttrs, type ParagraphAttrs, type ParagraphPropertyChangeAttrs, type PreservedBlockAttrs, type PreservedXmlAttrs, type PreservedXmlLevel, type RunFormattingOverrideAttrs, type RunIdentityMarkAttrs, type RunPropertyChangeMarkAttrs, type RunShadingAttrs, type SdtAttrs, type ShapeAttrs, type StrikeAttrs, type SymbolAttrs, type TabAttrs, type TableAttrs, type TableCellAttrs, type TableRowAttrs, type TextBoxAttrs, type TextColorAttrs, type TextEffectAttrs, type TrackedChangeMarkAttrs, type TrackedRevisionAncestor, type UnderlineAttrs, schema, singletonManager };
+export { type BlockCustomXmlAttrs, type BlockSdtAttrs, type BookmarkBoundaryAttrs, type CharacterSpacingAttrs, type CharacterStyleAttrs, type CommentAttrs, DocxMark, DocxNode, DocxSchema, type EmphasisMarkAttrs, type FieldAttrs, type FontFamilyAttrs, type FontSizeAttrs, type FootnoteRefAttrs, type HardBreakAttrs, type HighlightAttrs, type HyperlinkAttrs, type ImageAttrs, type ImagePositionAttrs, type InlineWrapperAttrs, type InlineWrapperKind, type InlineWrapperLayer, type LanguageAttrs, type MathAttrs, type PageBreakRunAttrs, type ParagraphAttrs, type ParagraphPropertyChangeAttrs, type PreservedBlockAttrs, type PreservedXmlAttrs, type PreservedXmlLevel, type RunFormattingOverrideAttrs, type RunIdentityMarkAttrs, type RunPropertyChangeMarkAttrs, type RunShadingAttrs, type SdtAttrs, type ShapeAttrs, type StrikeAttrs, type SymbolAttrs, type TabAttrs, type TableAttrs, type TableCellAttrs, type TableRowAttrs, type TextBoxAttrs, type TextColorAttrs, type TextEffectAttrs, type TrackedChangeMarkAttrs, type TrackedRevisionAncestor, type UnderlineAttrs, schema, singletonManager };

package/dist/prosemirror/schema/index.js

@@ -53,6 +53,9 @@ const requiredCommands = completeCommandNames([
 	"increaseListLevel",
 	"decreaseListLevel",
 	"removeList",
+	"restartNumbering",
+	"continueNumbering",
+	"setNumberingValue",
 	"setSpaceBefore",
 	"setSpaceAfter",
 	"applyStyle",

package/dist/prosemirror/schema/nodes.d.ts

@@ -56,6 +56,8 @@ type PreservedXmlAttrs = {
 type PreservedBlockAttrs = {
   /** Replayable markup, as `captureVerbatimXml` wrote it. */
   xml: string;
+  /** Plain text safely extracted from a related w:altChunk part, when available. */
+  readerText?: string;
 };
 type BookmarkBoundaryAttrs = {
   type: "start";
@@ -118,6 +120,13 @@ type ParagraphAttrs = {
    * `paragraphNumberingAttr`, so a model value cannot land here unconverted.
    */
   numPr?: ParagraphNumberingAttr;
+  /** Clipboard-only hint, replaced with a numbered paragraph before insertion. */
+  _pastedHtmlList?: {
+    group: number;
+    level: number;
+    kind: "bullet" | "numbered";
+    start?: number;
+  };
   /**
    * The style-sourced numPr value when `numPr` came from the paragraph
    * style rather than direct formatting. While `numPr` still equals this,
@@ -526,7 +535,7 @@ type ImageAttrs = {
 /**
  * Field node attributes
  */
-type FieldAttrs = {
+type CommonFieldAttrs = {
   /** Field type: PAGE, NUMPAGES, DATE, MERGEFIELD, etc. */
   fieldType: document_d_exports.FieldType;
   /** Full field instruction (e.g. "PAGE \\* MERGEFORMAT") */
@@ -535,20 +544,30 @@ type FieldAttrs = {
   displayText: string;
   /** Imported cache that proved numbered REF resolution for this field. */
   _numberedRefBaseline?: string;
-  /** Whether the field came from w:fldSimple or a complex fldChar range */
-  fieldKind: "simple" | "complex";
   /** Field is locked */
   fldLock?: boolean;
   /** Field is dirty and should be recalculated by the host application */
   dirty?: boolean;
-  /**
-   * `displayText` is a rendering fallback folio synthesized (e.g. a legacy
-   * `FORMCHECKBOX` with no cached result run), not authored content. A save
-   * omits it from the field's result so an unedited field keeps its
-   * original, resultless bytes. See `ComplexField.fieldResultIsFallback`.
-   */
-  fieldResultIsFallback?: boolean;
+  /** Authored empty result runs, which have no visible ProseMirror children. */
+  _docxEmptyResultRuns?: document_d_exports.Run[];
 };
+type FieldAttrs = CommonFieldAttrs & ({
+  fieldKind: "simple";
+  fieldResultIsFallback?: never;
+  formFieldDataXml?: never;
+  _docxFieldCode?: never;
+} | {
+  fieldKind: "complex";
+  /** Synthesized display text that must not become an authored result run. */
+  fieldResultIsFallback?: boolean;
+  /** Captured `w:ffData` on a complex field's begin character. */
+  formFieldDataXml?: string;
+  /** Source code runs; valid only while the instruction still matches. */
+  _docxFieldCode?: {
+    instruction: string;
+    runs: document_d_exports.Run[];
+  };
+});
 /**
  * Math equation node attributes
  */
@@ -649,6 +668,12 @@ type BlockSdtAttrs = {
   /** Verbatim XML for sdt siblings after sdtContent (range markers). */
   rawSdtChildrenAfterContent?: string;
 };
+/** Verbatim shell retained around editable block custom XML content. */
+type BlockCustomXmlAttrs = {
+  openingXml: string;
+  closingXml: string;
+  _originallyEmpty: boolean;
+};
 /**
  * The `mc:AlternateContent` a shape or text box was read from, with a
  * fingerprint of the node it was attached to. `fromProseDoc` hands the element
@@ -992,6 +1017,8 @@ type TableAttrs = {
    * none and a copy does not inherit one.
    */
   _preserved?: document_d_exports.TablePreservedMarkup;
+  /** Transparent table-level custom-XML wrappers, outermost first. */
+  carrierStack?: document_d_exports.TableContentCarrier[];
   /**
    * Marks this whole table as a *suggested* insertion (AI proposal). The table
    * is dropped from serialized DOCX until accepted; because OOXML has no tracked
@@ -1054,6 +1081,8 @@ type TableRowAttrs = {
    * name the same control. See `TableRow.contentControls`.
    */
   contentControls?: document_d_exports.SdtProperties[];
+  /** Transparent row-level custom-XML wrappers, outermost first. */
+  carrierStack?: document_d_exports.TableContentCarrier[];
   /**
    * Markup the authored `w:tr` carried beside its cells, with the cell count
    * that places it back between the same two cells. Follows the record the
@@ -1219,10 +1248,12 @@ type TableCellAttrs = {
    * outermost first. The row's twin, one level down.
    */
   contentControls?: document_d_exports.SdtProperties[];
+  /** Transparent row-level custom-XML wrappers, outermost first. */
+  carrierStack?: document_d_exports.TableContentCarrier[];
   /** Preserve a DOCX vMerge restart even when PM cannot model it as a rowspan. */
   _preserveVMergeRestart?: boolean;
   /** Original DOCX vMerge continuation cells skipped into this PM rowspan. */
   _docxVMergeContinuationCells?: unknown;
 };
 //#endregion
-export { AlternateContentAttrs, AuthoredEmuAttrs, BlockSdtAttrs, BookmarkBoundaryAttrs, CommentReferenceAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PRESERVED_XML_LEVELS, PageBreakRunAttrs, ParagraphAttrs, ParagraphAttrsPatch, ParagraphPropertyChangeAttrs, PreservedBlockAttrs, PreservedXmlAttrs, PreservedXmlLevel, SdtAttrs, ShapeAttrs, SuggestedStructuralMarker, SymbolAttrs, TEXT_BOX_TEXT_BODY_CONTENT_STATE_TYPES, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAnchorAttrs, TextBoxAttrs, TextBoxTextBodyContentState };
+export { AlternateContentAttrs, AuthoredEmuAttrs, BlockCustomXmlAttrs, BlockSdtAttrs, BookmarkBoundaryAttrs, CommentReferenceAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PRESERVED_XML_LEVELS, PageBreakRunAttrs, ParagraphAttrs, ParagraphAttrsPatch, ParagraphPropertyChangeAttrs, PreservedBlockAttrs, PreservedXmlAttrs, PreservedXmlLevel, SdtAttrs, ShapeAttrs, SuggestedStructuralMarker, SymbolAttrs, TEXT_BOX_TEXT_BODY_CONTENT_STATE_TYPES, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAnchorAttrs, TextBoxAttrs, TextBoxTextBodyContentState };

package/dist/prosemirror/sectionMarkEdits.d.ts

@@ -0,0 +1,20 @@
+import { document_d_exports } from "../types/document.js";
+import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+//#region src/prosemirror/sectionMarkEdits.d.ts
+type SectionMarkEdits = {
+  /** Section records whose paragraph mark a replacement deleted. */
+  deletedMarks: ReadonlySet<document_d_exports.SectionProperties>;
+  /**
+   * Paragraphs of the final document, by position, and the section record
+   * each must hold because of the mark it now ends with.
+   */
+  carriers: readonly {
+    position: number;
+    record: document_d_exports.SectionProperties | null;
+  }[];
+};
+/** Read `transactions`, applied in order and ending at `finalDoc`. */
+declare const sectionMarkEditsOf: (transactions: readonly Transaction[], finalDoc: Node) => SectionMarkEdits;
+//#endregion
+export { SectionMarkEdits, sectionMarkEditsOf };