@stll/folio-core 0.61.0 → 0.63.0

package/dist/prosemirror/keptRangeBoundaries.js

@@ -0,0 +1,381 @@
+import { expectBookmarkBoundaryAttrs } from "./bookmarkBoundaryAttrs.js";
+import { expectCommentRangeBoundaryAttrs } from "./commentRangeBoundaryAttrs.js";
+import { expectCommentReferenceAttrs } from "./commentReferenceAttrs.js";
+import "./commentReferenceIntegrity.js";
+import { copyOriginBoundaryAfterRemovingAddedAncestors, copyOriginBoundaryAfterResolution } from "./copyOriginResolution.js";
+import { planEmptyRanges } from "./emptyRangeAnchor.js";
+import { BLOCK_BOOKMARK_BOUNDARY_NODE_NAME } from "./extensions/nodes/BlockBookmarkBoundaryExtension.js";
+import { BLOCK_MOVE_RANGE_BOUNDARY_NODE_NAME } from "./extensions/nodes/BlockMoveRangeBoundaryExtension.js";
+import { BOOKMARK_BOUNDARY_NODE_NAME } from "./extensions/nodes/BookmarkBoundaryExtension.js";
+import { COMMENT_RANGE_BOUNDARY_NODE_NAME } from "./extensions/nodes/CommentRangeBoundaryExtension.js";
+import { MOVE_RANGE_BOUNDARY_NODE_NAME } from "./extensions/nodes/MoveRangeBoundaryExtension.js";
+import { RANGE_ANCHOR_NODE_NAME } from "./extensions/nodes/RangeAnchorExtension.js";
+import { expectMoveRangeBoundaryAttrs } from "./moveRangeBoundaryAttrs.js";
+import { expectRangeAnchorAttrs } from "./rangeAnchorAttrs.js";
+import { retainedTrackedRevisionMark, trackedRevisionPathOf } from "./trackedRevisionPath.js";
+import { paragraphRemains, planWellFormedRanges } from "@stll/docx-core/ops";
+//#region src/prosemirror/keptRangeBoundaries.ts
+/** The marks that say a node is in a revision: its wrappers, in the engine. */
+const REVISION_MARK_NAMES = /* @__PURE__ */ new Set(["insertion", "deletion"]);
+const bookmarkItems = (node) => {
+	const attrs = expectBookmarkBoundaryAttrs(node);
+	return attrs.type === "start" ? [{
+		type: "bookmarkStart",
+		id: attrs.id,
+		name: attrs.name,
+		...attrs.copyOriginAncestors === void 0 ? {} : { copyOriginAncestors: attrs.copyOriginAncestors }
+	}] : [{
+		type: "bookmarkEnd",
+		id: attrs.id,
+		...attrs.copyOriginAncestors === void 0 ? {} : { copyOriginAncestors: attrs.copyOriginAncestors }
+	}];
+};
+/** The boundaries each node carries, in document order. A missing kind fails to type-check. */
+const BOUNDARY_ITEMS = {
+	[BOOKMARK_BOUNDARY_NODE_NAME]: bookmarkItems,
+	[BLOCK_BOOKMARK_BOUNDARY_NODE_NAME]: bookmarkItems,
+	[MOVE_RANGE_BOUNDARY_NODE_NAME]: (node) => [expectMoveRangeBoundaryAttrs(node)],
+	[BLOCK_MOVE_RANGE_BOUNDARY_NODE_NAME]: (node) => [expectMoveRangeBoundaryAttrs(node)],
+	[RANGE_ANCHOR_NODE_NAME]: (node) => {
+		const { start, end } = expectRangeAnchorAttrs(node);
+		return [start, end];
+	},
+	[COMMENT_RANGE_BOUNDARY_NODE_NAME]: (node) => [expectCommentRangeBoundaryAttrs(node).marker]
+};
+const isBoundaryNodeName = (name) => Object.hasOwn(BOUNDARY_ITEMS, name);
+/** The range boundaries `node` carries; none for any other node. */
+const rangeBoundaryItemsOf = (node) => isBoundaryNodeName(node.type.name) ? BOUNDARY_ITEMS[node.type.name](node) : [];
+const isComment = (item) => item.type === "commentRangeStart" || item.type === "commentRangeEnd";
+/**
+* Whether resolving away the content around `node` keeps it in place: it
+* carries range boundaries and none is a comment's, which goes with the
+* comment.
+*/
+const keepsRangeBoundary = (node) => {
+	const items = rangeBoundaryItemsOf(node);
+	return items.length > 0 && !items.some(isComment);
+};
+/** Each boundary's range family and side, as the engine pairs them. */
+const BOUNDARY_SIDES = {
+	bookmarkStart: {
+		family: "bookmark",
+		side: "start"
+	},
+	bookmarkEnd: {
+		family: "bookmark",
+		side: "end"
+	},
+	commentRangeStart: {
+		family: "comment",
+		side: "start"
+	},
+	commentRangeEnd: {
+		family: "comment",
+		side: "end"
+	},
+	moveFromRangeStart: {
+		family: "moveFrom",
+		side: "start"
+	},
+	moveFromRangeEnd: {
+		family: "moveFrom",
+		side: "end"
+	},
+	moveToRangeStart: {
+		family: "moveTo",
+		side: "start"
+	},
+	moveToRangeEnd: {
+		family: "moveTo",
+		side: "end"
+	}
+};
+const occurrenceOf = (item, kept, keptFrom) => {
+	const { family, side } = BOUNDARY_SIDES[item.type];
+	return {
+		boundary: `${item.type}:${item.id}`,
+		range: `${family}:${item.id}`,
+		side,
+		kept,
+		...kept && keptFrom !== void 0 ? { keptFrom } : {}
+	};
+};
+/**
+* The date of the revision each kept boundary was kept from, the empty string
+* when it has none: the engine's tie-break between a kept start and end out
+* of order, so the editor moves the same one.
+*/
+const keptRevisionDates = /* @__PURE__ */ new WeakMap();
+/** The date of the outermost revision `selection` removes `node` with. */
+const removingRevisionDate = (node, selection) => {
+	for (const mark of node.marks) {
+		if (!REVISION_MARK_NAMES.has(mark.type.name)) continue;
+		const layer = trackedRevisionPathOf(mark).find((candidate) => selection.resolves(candidate.revisionId) && revisionLayerRemovesContent(candidate, selection.mode));
+		if (layer !== void 0) return layer.date ?? "";
+	}
+	return "";
+};
+const boundariesIn = (doc, kept) => {
+	const found = [];
+	doc.descendants((node, position) => {
+		for (const item of rangeBoundaryItemsOf(node)) found.push({
+			position,
+			node,
+			item,
+			occurrence: occurrenceOf(item, kept.has(node), keptRevisionDates.get(node))
+		});
+		return true;
+	});
+	return found;
+};
+const isBookmark = (item) => item.type === "bookmarkStart" || item.type === "bookmarkEnd";
+/**
+* The one half a move's point range keeps, as a node of its own on `marks`:
+* the only boundary the repair makes, since one node holds both halves of a
+* point range. A comment's point range goes with its comment, and a bookmark
+* is never one.
+*/
+const pointRangeHalf = (node, half, marks) => {
+	if (isComment(half) || isBookmark(half)) return void 0;
+	return node.type.schema.nodes[MOVE_RANGE_BOUNDARY_NODE_NAME]?.create({ marker: half }, null, marks);
+};
+/** One boundary as a node of its own, inline or between blocks. */
+const boundaryNode = (item, schema, inline) => {
+	if (item.type === "bookmarkStart" || item.type === "bookmarkEnd") {
+		const attrs = item.type === "bookmarkStart" ? {
+			type: "start",
+			id: item.id,
+			name: item.name,
+			...item.copyOriginAncestors === void 0 ? {} : { copyOriginAncestors: item.copyOriginAncestors }
+		} : {
+			type: "end",
+			id: item.id,
+			...item.copyOriginAncestors === void 0 ? {} : { copyOriginAncestors: item.copyOriginAncestors }
+		};
+		return schema.nodes[inline ? BOOKMARK_BOUNDARY_NODE_NAME : BLOCK_BOOKMARK_BOUNDARY_NODE_NAME]?.create(attrs);
+	}
+	if (isComment(item)) return void 0;
+	return schema.nodes[inline ? MOVE_RANGE_BOUNDARY_NODE_NAME : BLOCK_MOVE_RANGE_BOUNDARY_NODE_NAME]?.create({ marker: item });
+};
+/** Range boundary nodes, as the nodes that stand for them between blocks. */
+const blockBoundariesOf = (nodes) => nodes.flatMap((node) => rangeBoundaryItemsOf(node).flatMap((item) => {
+	const block = boundaryNode(item, node.type.schema, false);
+	return block === void 0 ? [] : [block];
+}));
+/** Whether `node` holds a comment's anchor, which only a paragraph holds. */
+const carriesCommentAnchor = (node) => node.type.name === "commentReference" || rangeBoundaryItemsOf(node).some(isComment);
+/** Whether `node` is a range boundary standing between blocks. */
+const isBlockBoundaryNode = (node) => node != null && !node.isInline && rangeBoundaryItemsOf(node).length > 0;
+/**
+* The inline form of range boundaries between blocks whose paragraph break
+* goes, so they stand between the joined paragraphs' content; `null` when
+* one of `blocks` is not such a boundary.
+*/
+const inlineBoundariesOf = (blocks) => {
+	const inline = [];
+	for (const block of blocks) {
+		if (!isBlockBoundaryNode(block)) return null;
+		for (const item of rangeBoundaryItemsOf(block)) {
+			const node = boundaryNode(item, block.type.schema, true);
+			if (node === void 0) return null;
+			inline.push(node);
+		}
+	}
+	return inline;
+};
+/**
+* What `paragraph` leaves where it was when it goes whole, by the engine's
+* own rule (`paragraphRemains`): before a table, its bookmark and move range
+* boundaries as block nodes in its place (`blocks`), unless a comment needs
+* the paragraph before it, which takes every carrier in source order
+* (`comments`); ending its
+* container, every node carrying a boundary (`inline`), for the paragraph
+* before it.
+*/
+const paragraphRemainsOf = (paragraph) => {
+	const items = [];
+	const inline = [];
+	paragraph.descendants((node) => {
+		const carried = rangeBoundaryItemsOf(node);
+		const remains = carried.length > 0 ? copyOriginBoundaryAfterRemovingAddedAncestors(node) : node;
+		if ((carried.length > 0 || node.type.name === "commentReference") && remains !== null) inline.push(remains);
+		if (remains !== null) items.push(...rangeBoundaryItemsOf(remains));
+		if (node.type.name === "commentReference") items.push({
+			type: "commentReference",
+			id: expectCommentReferenceAttrs(node).commentId
+		});
+		return true;
+	});
+	const remains = paragraphRemains(items);
+	if (remains.placement === "previous") return {
+		blocks: [],
+		comments: inline,
+		inline
+	};
+	return {
+		blocks: remains.blocks.flatMap((item) => {
+			const block = boundaryNode(item, paragraph.type.schema, false);
+			return block === void 0 ? [] : [block];
+		}),
+		comments: [],
+		inline
+	};
+};
+/** The revision marks of `anchor`, with the other marks of `node`. */
+const marksBeside = (node, anchor) => [...node.marks.filter((mark) => !REVISION_MARK_NAMES.has(mark.type.name)), ...anchor.marks.filter((mark) => REVISION_MARK_NAMES.has(mark.type.name))];
+/**
+* The kept boundary `moving` names, moved beside the other end of its range,
+* `anchor`: the same node, its attributes and its own marks, inside the
+* revisions `anchor` stands in, as the engine moves a boundary in among its
+* anchor's wrappers.
+*/
+const movedBeside = (moving, anchor) => rangeBoundaryItemsOf(moving.node).length === 1 ? moving.node.mark(marksBeside(moving.node, anchor)) : pointRangeHalf(moving.node, moving.item, marksBeside(moving.node, anchor));
+/**
+* Make every range a rejection kept boundaries of well-formed, by the
+* engine's own plan (`planWellFormedRanges`): `kept` holds the nodes
+* {@link removeResolvedSubtree} kept, found in `tr.doc` as themselves. The plan
+* runs once over every boundary in document order and names each by its
+* place in that list, as the engine names its own, so applying it never
+* reads a position the repair itself moved.
+*/
+const normalizeKeptRangeBoundaries = (tr, kept) => {
+	if (kept.size > 0) wellFormKeptRangeBoundaries(tr, kept);
+	collapseEmptyMoveRanges(tr);
+};
+/**
+* A move range whose start and end a resolution left side by side, with
+* nothing between, as one point anchor: the node a reopened package reads
+* that empty range as, so the resolved document has the same shape live and
+* after a save. Only a start directly followed by its own end collapses; the
+* order of any other markers stays as the engine leaves it.
+*/
+const collapseEmptyMoveRanges = (tr) => {
+	const anchorType = tr.doc.type.schema.nodes[RANGE_ANCHOR_NODE_NAME];
+	if (anchorType === void 0) return;
+	const pairs = [];
+	tr.doc.descendants((node, position) => {
+		if (!node.isTextblock) return true;
+		let previous;
+		node.forEach((child, offset) => {
+			const childPosition = position + 1 + offset;
+			if (previous !== void 0 && child.type.name === "moveRangeBoundary" && previous.node.type.name === "moveRangeBoundary") {
+				const start = expectMoveRangeBoundaryAttrs(previous.node);
+				const end = expectMoveRangeBoundaryAttrs(child);
+				if (start.id === end.id && (start.type === "moveFromRangeStart" && end.type === "moveFromRangeEnd" || start.type === "moveToRangeStart" && end.type === "moveToRangeEnd")) {
+					pairs.push({
+						position: previous.position,
+						start: previous.node,
+						end: child
+					});
+					previous = void 0;
+					return;
+				}
+			}
+			previous = {
+				node: child,
+				position: childPosition
+			};
+		});
+		return false;
+	});
+	for (const { position, start, end } of pairs.toReversed()) {
+		const anchored = planEmptyRanges([expectMoveRangeBoundaryAttrs(start), expectMoveRangeBoundaryAttrs(end)]).anchorAt.get(0);
+		if (anchored === void 0) continue;
+		tr.replaceWith(position, position + start.nodeSize + end.nodeSize, anchorType.create(anchored, null, start.marks));
+	}
+};
+const wellFormKeptRangeBoundaries = (tr, kept) => {
+	const found = boundariesIn(tr.doc, kept);
+	const plan = planWellFormedRanges(found.map(({ occurrence }) => occurrence));
+	const leaving = new Set(plan.dropped);
+	for (const { moving } of plan.moved) leaving.add(moving);
+	const edits = [];
+	const byNode = /* @__PURE__ */ new Map();
+	for (const [index, { position }] of found.entries()) byNode.set(position, [...byNode.get(position) ?? [], index]);
+	for (const [position, indices] of byNode) {
+		const staying = indices.filter((index) => !leaving.has(index));
+		const node = found[indices[0] ?? -1]?.node;
+		if (node === void 0 || staying.length === indices.length) continue;
+		const half = staying.length === 1 ? found[staying[0] ?? -1] : void 0;
+		edits.push(half === void 0 ? {
+			kind: "delete",
+			position,
+			node
+		} : {
+			kind: "narrow",
+			position,
+			node,
+			half: half.item
+		});
+	}
+	for (const { moving: movingIndex, anchor: anchorIndex, side } of plan.moved) {
+		const moving = found[movingIndex];
+		const anchor = found[anchorIndex];
+		const moved = moving === void 0 || anchor === void 0 ? void 0 : movedBeside(moving, anchor.node);
+		if (anchor !== void 0 && moved !== void 0) edits.push({
+			kind: "move",
+			position: side === "after" ? anchor.position + anchor.node.nodeSize : anchor.position,
+			node: moved
+		});
+	}
+	const order = (edit) => edit.kind === "move" ? 1 : 0;
+	for (const edit of edits.toSorted((left, right) => right.position - left.position || order(left) - order(right))) if (edit.kind === "move") tr.insert(edit.position, edit.node);
+	else if (edit.kind === "delete") tr.delete(edit.position, edit.position + edit.node.nodeSize);
+	else {
+		const half = pointRangeHalf(edit.node, edit.half, edit.node.marks);
+		if (half === void 0) tr.delete(edit.position, edit.position + edit.node.nodeSize);
+		else tr.replaceWith(edit.position, edit.position + edit.node.nodeSize, half);
+	}
+};
+/** Whether resolving `layer` by `mode` takes its content out. */
+const revisionLayerRemovesContent = (layer, mode) => mode === "accept" ? layer.type === "deletion" || layer.type === "moveFrom" : layer.type === "insertion" || layer.type === "moveTo";
+const layerKey = (layer) => `${layer.type}:${layer.revisionId}`;
+/**
+* The revision marks a boundary carries where `removed` stood: of each of
+* its revision marks, the layers outside the outermost one this resolution
+* takes content out by, less those it resolves. A revision nested inside
+* removed content goes with that content, as the engine's wrappers do.
+*/
+const landingMarks = (removed, selection) => removed.marks.flatMap((mark) => {
+	if (!REVISION_MARK_NAMES.has(mark.type.name)) return [];
+	const path = trackedRevisionPathOf(mark);
+	const cut = path.findIndex((layer) => selection.resolves(layer.revisionId) && revisionLayerRemovesContent(layer, selection.mode));
+	const standing = new Set((cut === -1 ? path : path.slice(0, cut)).filter((layer) => !selection.resolves(layer.revisionId)).map(layerKey));
+	if (standing.size === path.length) return [mark];
+	const landing = retainedTrackedRevisionMark(mark, (layer) => standing.has(layerKey(layer)));
+	return landing === null ? [] : [landing];
+});
+/**
+* Marks that say which content a range covers. A kept boundary is no content,
+* so it carries none: a comment whose content went goes with it, as in the
+* engine, whose comment anchors are boundaries of their own.
+*/
+const COVERAGE_MARK_NAMES = /* @__PURE__ */ new Set(["comment"]);
+/**
+* Remove `node` and everything in it. Rejecting keeps every range boundary
+* within it, at any depth, as the engine's `removedContentBoundaries` does;
+* accepting keeps none, as a direct deletion does. A kept boundary keeps its
+* own other marks and carries the revisions of where `node` stood
+* ({@link landingMarks}), never one from inside the removed content. Each
+* kept node is a new node, so the range repair can tell it from a boundary
+* that was already standing.
+*/
+const removeResolvedSubtree = (node, selection) => {
+	const kept = [];
+	const landing = landingMarks(node, selection);
+	const visit = (candidate) => {
+		if (keepsRangeBoundary(candidate)) {
+			const withResolvedCopyOrigin = copyOriginBoundaryAfterResolution(candidate, selection);
+			if (withResolvedCopyOrigin === null) return;
+			const keptNode = withResolvedCopyOrigin.type.create(withResolvedCopyOrigin.attrs, null, [...candidate.marks.filter((mark) => !REVISION_MARK_NAMES.has(mark.type.name) && !COVERAGE_MARK_NAMES.has(mark.type.name)), ...landing]);
+			keptRevisionDates.set(keptNode, removingRevisionDate(candidate.marks.some((mark) => REVISION_MARK_NAMES.has(mark.type.name)) ? candidate : node, selection));
+			kept.push(keptNode);
+			return;
+		}
+		candidate.forEach(visit);
+	};
+	if (selection.mode === "reject") visit(node);
+	return { kept };
+};
+//#endregion
+export { blockBoundariesOf, carriesCommentAnchor, inlineBoundariesOf, isBlockBoundaryNode, normalizeKeptRangeBoundaries, paragraphRemainsOf, rangeBoundaryItemsOf, removeResolvedSubtree, revisionLayerRemovesContent };

package/dist/prosemirror/listAutoformatMarkers.d.ts

@@ -4,7 +4,7 @@ import { ListRequest } from "./listNumbering.js";
  * A marker plus the space that triggers the conversion. The text before the
  * caret must be exactly this, so a marker typed mid-paragraph never matches.
  */
-declare const LIST_MARKER_PATTERN: RegExp;
+export declare const LIST_MARKER_PATTERN: RegExp;
 /**
  * The lists `text` (the paragraph's text up to and including the typed space)
  * may ask for, most likely first, or `null` when it is not a marker.
@@ -14,6 +14,5 @@ declare const LIST_MARKER_PATTERN: RegExp;
  * letters. The caller prefers whichever interpretation a neighbouring list
  * already has, and otherwise takes the first.
  */
-declare const listRequestsForMarker: (text: string) => ListRequest[] | null;
-//#endregion
-export { LIST_MARKER_PATTERN, listRequestsForMarker };
+export declare const listRequestsForMarker: (text: string) => ListRequest[] | null;
+//#endregion

package/dist/prosemirror/listInstanceReferences.d.ts

@@ -2,11 +2,10 @@ import { document_d_exports } from "../types/document.js";
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/listInstanceReferences.d.ts
 /** The instances one paragraph names, live or as a tracked change's previous state. */
-declare const paragraphListReferences: (node: Node) => number[];
+export declare const paragraphListReferences: (node: Node) => number[];
 /**
  * `definitions` plus every instance `doc` references and only its paragraphs
  * define: what the package's numbering part has to hold for `doc` to save.
  */
-declare const completeNumberingForDoc: (definitions: document_d_exports.NumberingDefinitions | undefined, doc: Node) => document_d_exports.NumberingDefinitions | undefined;
-//#endregion
-export { completeNumberingForDoc, paragraphListReferences };
+export declare const completeNumberingForDoc: (definitions: document_d_exports.NumberingDefinitions | undefined, doc: Node) => document_d_exports.NumberingDefinitions | undefined;
+//#endregion

package/dist/prosemirror/listInstanceReferences.js

@@ -15,7 +15,7 @@ const collectReference = (attrs, sink) => {
 		numPrFromStyle: attrs.numPrFromStyle
 	}));
 	if (numbering === void 0 || sink.isDefined(numbering.numId)) return;
-	if (!hasListRendering(attrs)) return;
+	if (attrs.listMarkerHidden === true || !hasListRendering(attrs)) return;
 	sink.references.push({
 		numId: numbering.numId,
 		ilvl: numbering.ilvl,

package/dist/prosemirror/listLabels.d.ts

@@ -1,7 +1,9 @@
 import { document_d_exports } from "../types/document.js";
 import { ParagraphNumberingSources } from "./numberingAttr.js";
 import { ParagraphAttrs } from "./schema/nodes.js";
+import { NumberingMap } from "../docx/numberingParser.js";
 import { ListCounterStreams } from "./listMarker.js";
+import { ResolvedParagraphNumbering } from "@stll/docx-core/model";
 //#region src/prosemirror/listLabels.d.ts
 /**
  * The attrs the counter reads for a paragraph of the document model, as
@@ -9,17 +11,25 @@ import { ListCounterStreams } from "./listMarker.js";
  * attrs no label depends on: a reader that walks the model (Markdown) counts
  * every list paragraph through here.
  */
-declare const listLabelAttrsFromRendering: (rendering: document_d_exports.ListRendering | undefined, { numPr, numPrFromStyle }: ParagraphNumberingSources) => ParagraphAttrs;
+export declare const listLabelAttrsFromRendering: (rendering: document_d_exports.ListRendering | undefined, { numPr, numPrFromStyle }: ParagraphNumberingSources) => ParagraphAttrs;
+type VisibleListLabel = {
+  kind: "none" | "markerless" | "marker";
+  label: string | undefined;
+  /** The revision-selected reference whose marker was counted for display. */
+  numbering: Extract<ResolvedParagraphNumbering, {
+    kind: "reference";
+  }> | undefined;
+};
 /**
  * Advances past one paragraph and answers the label it shows, or `undefined`
- * when it shows none.
+ * when it shows none, with the numbering that label is counted in.
  */
-type ListLabelCounter = (attrs: Readonly<ParagraphAttrs>) => string | undefined;
+export type ListLabelCounter = (attrs: Readonly<ParagraphAttrs>, standaloneRendering?: document_d_exports.ListRendering) => VisibleListLabel;
 /**
  * A counter over paragraph attrs in document order. Call it for every
  * paragraph, numbered or not: whether a list continues depends on what stands
  * between its items.
  */
-declare const createListLabelCounter: (streams?: ListCounterStreams) => ListLabelCounter;
+export declare const createListLabelCounter: (numberingOrStreams?: NumberingMap | ListCounterStreams | null, suppliedStreams?: ListCounterStreams) => ListLabelCounter;
 //#endregion
-export { ListLabelCounter, createListLabelCounter, listLabelAttrsFromRendering };
+export {};

package/dist/prosemirror/listLabels.js

@@ -1,7 +1,9 @@
 import { bulletMarkerFontName, convertBulletToUnicode } from "../docx/bulletMarkers.js";
-import { advanceVisibleListMarker, createListCounterState } from "./listMarker.js";
-import { hasListRendering } from "./listRenderingAttrs.js";
-import { paragraphNumberingAttr } from "./numberingAttr.js";
+import { CLEARED_LIST_RENDERING_ATTRS, advanceVisibleListMarker, createListCounterState } from "./listMarker.js";
+import { listRenderingAttrPatch, listRenderingFromAttrs } from "./listRenderingAttrs.js";
+import { effectiveParagraphNumberingReference, paragraphNumberingAttr, paragraphNumberingSourcesFromBoundary } from "./numberingAttr.js";
+import { resolveParagraphList } from "./paragraphList.js";
+import { panic } from "better-result";
 //#region src/prosemirror/listLabels.ts
 /**
 * The number or bullet a paragraph shows beside its text, as a reader reports
@@ -31,6 +33,17 @@ const staticMarker = (attrs) => {
 	if (!marker) return;
 	return (attrs.listIsBullet ? convertBulletToUnicode(marker, bulletMarkerFontName(attrs.listMarkerFormatting)) : marker).trim() || void 0;
 };
+const visibleLabel = (counterAttrs, marker) => {
+	if (counterAttrs.listMarkerHidden === true) return void 0;
+	const counted = marker?.trim();
+	if (counted) return `${counted}${foldedFieldSuffix(counterAttrs)}`;
+	if (counterAttrs.listMarker === "" || counterAttrs.listMarkerTemplate === "") return "";
+	return staticMarker(counterAttrs);
+};
+const projectedListRendering = (attrs, numId) => attrs.listMarker != null || attrs.listMarkerTemplate != null || attrs.listIsBullet === true || attrs.listNumFmt != null ? listRenderingFromAttrs({
+	attrs,
+	numId
+}) : void 0;
 /**
 * The attrs the counter reads for a paragraph of the document model, as
 * `toProseDoc` projects them (`listRenderingAttrPatch`), without the layout
@@ -43,8 +56,8 @@ const listLabelAttrsFromRendering = (rendering, { numPr, numPrFromStyle }) => {
 		...numPrFromStyle === void 0 ? {} : { numPrFromStyle: paragraphNumberingAttr(numPrFromStyle) }
 	};
 	if (rendering === void 0) return attrs;
-	if (rendering.marker) attrs.listMarker = rendering.marker;
-	if (rendering.markerTemplate) attrs.listMarkerTemplate = rendering.markerTemplate;
+	if (rendering.marker !== void 0) attrs.listMarker = rendering.marker;
+	if (rendering.markerTemplate !== void 0) attrs.listMarkerTemplate = rendering.markerTemplate;
 	if (rendering.isBullet) attrs.listIsBullet = true;
 	if (rendering.isLegal) attrs.listIsLegal = true;
 	if (rendering.numFmt) attrs.listNumFmt = rendering.numFmt;
@@ -62,17 +75,89 @@ const listLabelAttrsFromRendering = (rendering, { numPr, numPrFromStyle }) => {
 * paragraph, numbered or not: whether a list continues depends on what stands
 * between its items.
 */
-const createListLabelCounter = (streams = {
-	final: createListCounterState(),
-	original: createListCounterState()
-}) => (attrs) => {
-	const visible = advanceVisibleListMarker(attrs, streams);
-	const rendered = hasListRendering(visible.counterAttrs);
-	const marker = visible.marker;
-	if (visible.counterAttrs.listMarkerHidden === true || !rendered) return void 0;
-	const counted = marker?.trim();
-	if (counted) return `${counted}${foldedFieldSuffix(visible.counterAttrs)}`;
-	return staticMarker(visible.counterAttrs);
+const createListLabelCounter = (numberingOrStreams = null, suppliedStreams) => {
+	const numbering = numberingOrStreams && "definitions" in numberingOrStreams ? numberingOrStreams : null;
+	const readsProjectedStreams = numberingOrStreams !== null && !("definitions" in numberingOrStreams);
+	const streams = suppliedStreams ?? (numberingOrStreams && !("definitions" in numberingOrStreams) ? numberingOrStreams : {
+		final: createListCounterState(),
+		original: createListCounterState()
+	});
+	return (attrs, standaloneRendering) => {
+		const sources = paragraphNumberingSourcesFromBoundary({
+			numPr: attrs.numPr,
+			numPrFromStyle: attrs.numPrFromStyle
+		});
+		const effective = effectiveParagraphNumberingReference(sources);
+		const projectedRendering = standaloneRendering ?? projectedListRendering(attrs, effective?.numId ?? 1);
+		const list = resolveParagraphList(sources, numbering, projectedRendering);
+		const counterInput = { ...attrs };
+		Object.assign(counterInput, CLEARED_LIST_RENDERING_ATTRS);
+		const contentDerived = {
+			listImplicitChildLevelAdvances: attrs.listImplicitChildLevelAdvances,
+			listMarkerSecondSlotOffsetTwips: attrs.listMarkerSecondSlotOffsetTwips,
+			listFoldedMarkerSuffix: attrs.listFoldedMarkerSuffix
+		};
+		if (list.kind === "marker") Object.assign(counterInput, listRenderingAttrPatch(list.rendering));
+		else if (list.kind === "markerless" && list.rendering !== void 0) Object.assign(counterInput, listRenderingAttrPatch(list.rendering));
+		else if (list.kind === "markerless" && projectedRendering?.markerHidden === true) Object.assign(counterInput, listRenderingAttrPatch(projectedRendering));
+		Object.assign(counterInput, Object.fromEntries(Object.entries(contentDerived).filter(([, value]) => value !== void 0)));
+		if (counterInput._propertyChanges) counterInput._propertyChanges = counterInput._propertyChanges.map((change) => {
+			const previous = change.previousFormatting;
+			if (!previous) return change;
+			const previousSources = paragraphNumberingSourcesFromBoundary({
+				numPr: previous.numPr,
+				numPrFromStyle: previous.numPrFromStyle
+			});
+			const previousReference = effectiveParagraphNumberingReference(previousSources);
+			const previousProjected = projectedListRendering(previous, previousReference?.numId ?? 1);
+			const previousList = resolveParagraphList(previousSources, numbering, previousProjected);
+			const previousFormatting = { ...previous };
+			Object.assign(previousFormatting, CLEARED_LIST_RENDERING_ATTRS);
+			if (previousList.kind === "marker" || previousList.kind === "markerless" && previousList.rendering !== void 0) {
+				const rendering = previousList.rendering;
+				if (rendering) Object.assign(previousFormatting, listRenderingAttrPatch(rendering));
+			} else if (previousProjected?.markerHidden === true) Object.assign(previousFormatting, listRenderingAttrPatch(previousProjected));
+			return {
+				...change,
+				previousFormatting
+			};
+		});
+		const { counterAttrs, marker } = advanceVisibleListMarker(counterInput, streams);
+		const projectedLabel = visibleLabel(counterAttrs, marker);
+		if (readsProjectedStreams && projectedLabel !== void 0) return {
+			kind: "marker",
+			label: projectedLabel,
+			numbering: effective
+		};
+		const countedSources = paragraphNumberingSourcesFromBoundary({
+			numPr: counterAttrs.numPr,
+			numPrFromStyle: counterAttrs.numPrFromStyle
+		});
+		const countedNumbering = effectiveParagraphNumberingReference(countedSources);
+		const revisionSelectedRendering = counterInput._propertyChanges?.length && counterAttrs !== counterInput && numbering === null ? listRenderingFromAttrs({
+			attrs: counterAttrs,
+			numId: countedNumbering?.numId ?? 1
+		}) : void 0;
+		const countedList = resolveParagraphList(countedSources, numbering, revisionSelectedRendering ?? projectedRendering);
+		switch (countedList.kind) {
+			case "none": return {
+				kind: "none",
+				label: void 0,
+				numbering: void 0
+			};
+			case "markerless": return {
+				kind: "markerless",
+				label: void 0,
+				numbering: countedList.source === "authored" ? countedList.reference : void 0
+			};
+			case "marker": return {
+				kind: "marker",
+				label: projectedLabel,
+				numbering: countedList.source === "authored" ? countedList.reference : void 0
+			};
+			default: return panic(`Unhandled paragraph list ${JSON.stringify(countedList)}`);
+		}
+	};
 };
 //#endregion
 export { createListLabelCounter, listLabelAttrsFromRendering };