@stll/folio-core 0.52.0 → 0.53.0

package/dist/markdown/renderParagraph.d.ts

@@ -6,5 +6,17 @@ import { RenderContext } from "./types.js";
  * caller joins blocks.
  */
 declare function renderParagraph(ctx: RenderContext, pkg: document_d_exports.DocxPackage | undefined, para: document_d_exports.Paragraph): string;
+/** A rendered paragraph, and whether it is a Markdown list item. */
+type RenderedParagraph = {
+  markdown: string;
+  isListItem: boolean;
+};
+/**
+ * Render a paragraph. A list item is a paragraph that shows a marker, which is
+ * when the list counter gives it a label: a numbered heading renders as a
+ * heading, and a level that hides its marker (`w:vanish`) or that its list
+ * does not define as prose, as every other reader reads them.
+ */
+declare function renderParagraphBlock(ctx: RenderContext, pkg: document_d_exports.DocxPackage | undefined, para: document_d_exports.Paragraph): RenderedParagraph;
 //#endregion
-export { renderParagraph };
+export { RenderedParagraph, renderParagraph, renderParagraphBlock };

package/dist/markdown/renderParagraph.js

@@ -1,5 +1,5 @@
 import { isQuoteStyle, resolveHeadingLevel } from "../docx/builtInStyles.js";
-import { resolveListTemplate } from "../prosemirror/listMarker.js";
+import { listLabelAttrsFromRendering } from "../prosemirror/listLabels.js";
 import { renderParagraphInline } from "./renderRuns.js";
 //#region src/markdown/renderParagraph.ts
 /**
@@ -9,6 +9,8 @@ import { renderParagraphInline } from "./renderRuns.js";
 * `IntenseQuote` styles become blockquotes. Ported from eigenpal/docx-editor
 * PR #595.
 *
+* A numbered heading keeps its number after the hashes (`## 1. Scope`).
+*
 * Which paragraphs those are is `builtInStyles`' decision, not this file's: the
 * id `Nadpis1` and the id `Heading1` are the same heading, and `ClauseHeading1`
 * is not one at all.
@@ -20,19 +22,59 @@ const MAX_MARKDOWN_HEADING_LEVEL = 6;
 * caller joins blocks.
 */
 function renderParagraph(ctx, pkg, para) {
+	return renderParagraphBlock(ctx, pkg, para).markdown;
+}
+/**
+* Render a paragraph. A list item is a paragraph that shows a marker, which is
+* when the list counter gives it a label: a numbered heading renders as a
+* heading, and a level that hides its marker (`w:vanish`) or that its list
+* does not define as prose, as every other reader reads them.
+*/
+function renderParagraphBlock(ctx, pkg, para) {
+	const label = ctx.nextListLabel(listLabelAttrs(para));
 	const inline = renderParagraphInline(ctx, pkg, para.content, para.paraId);
 	const styleId = para.formatting?.styleId;
-	const headingLevel = resolveHeadingLevel({
-		outlineLevel: para.formatting?.outlineLevel,
-		styleId
-	}, ctx.builtInStyles);
+	const headingLevel = markdownHeadingLevel(ctx, para);
 	if (headingLevel !== void 0) {
-		if (!inline) return "";
-		return `${"#".repeat(Math.min(MAX_MARKDOWN_HEADING_LEVEL, headingLevel + 1))} ${inline}`;
+		if (!inline) return {
+			markdown: "",
+			isListItem: false
+		};
+		const hashes = "#".repeat(Math.min(MAX_MARKDOWN_HEADING_LEVEL, headingLevel + 1));
+		return {
+			markdown: label ? `${hashes} ${label} ${inline}` : `${hashes} ${inline}`,
+			isListItem: false
+		};
 	}
-	if (para.listRendering && !para.listRendering.markerHidden) return renderListItem(ctx, para.listRendering, inline);
-	if (isQuoteStyle(styleId, ctx.builtInStyles)) return inline.split("\n").map((line) => `> ${line}`).join("\n");
-	return escapeLeadingBlockMarker(inline);
+	if (para.listRendering && label !== void 0) return {
+		markdown: renderListItem(ctx, para.listRendering, label, inline),
+		isListItem: true
+	};
+	if (isQuoteStyle(styleId, ctx.builtInStyles)) return {
+		markdown: inline.split("\n").map((line) => `> ${line}`).join("\n"),
+		isListItem: false
+	};
+	return {
+		markdown: escapeLeadingBlockMarker(inline),
+		isListItem: false
+	};
+}
+/** The paragraph's 0-based heading level, as `builtInStyles` classifies it. */
+function markdownHeadingLevel(ctx, para) {
+	return resolveHeadingLevel({
+		outlineLevel: para.formatting?.outlineLevel,
+		styleId: para.formatting?.styleId
+	}, ctx.builtInStyles);
+}
+const UNNUMBERED = Object.freeze({});
+/**
+* The attrs the page's list counter reads, projected from the paragraph the
+* way the editor projects them (`toProseDoc`). A paragraph without a list
+* rendering counts as unnumbered.
+*/
+function listLabelAttrs(para) {
+	const list = para.listRendering;
+	return list ? listLabelAttrsFromRendering(list, para.formatting?.numPrFromStyle) : UNNUMBERED;
 }
 /**
 * A plain paragraph whose visible text begins with markdown block syntax (e.g.
@@ -43,36 +85,41 @@ function renderParagraph(ctx, pkg, para) {
 function escapeLeadingBlockMarker(text) {
 	return text.replace(/^(?<ws>[ \t]*)(?<marker>[#>])/gmu, "$<ws>\\$<marker>").replace(/^(?<ws>[ \t]*)(?<marker>[-+*])(?<after>[ \t])/gmu, "$<ws>\\$<marker>$<after>").replace(/^(?<ws>[ \t]*)(?<num>\d{1,9})(?<marker>[.)])(?<after>[ \t])/gmu, "$<ws>$<num>\\$<marker>$<after>");
 }
-function renderListItem(ctx, list, inline) {
-	const indent = "  ".repeat(list.level);
-	if (list.isBullet) return `${indent}- ${inline}`.trimEnd();
-	return `${indent}${list.marker.includes("%") ? resolveTemplateMarker(ctx, list) : list.marker.trim()} ${inline}`.trimEnd();
+/**
+* A markdown list marker's width when no ancestor at that level has rendered
+* yet (e.g. a DOCX paragraph numbered at a level its list skipped over). Two
+* spaces is the old fixed-indent behaviour, kept as a fallback rather than a
+* guess of zero.
+*/
+const DEFAULT_LIST_INDENT_WIDTH = 2;
+/**
+* The indent a level's item needs: the combined marker width of every
+* shallower level's most recently rendered item (see
+* `RenderContext.listIndentWidths`), so a child sits inside its parent's
+* content column per CommonMark's list-nesting rule, not a fixed guess.
+*/
+function listIndentWidth(ctx, level) {
+	let width = 0;
+	for (let ancestor = 0; ancestor < level; ancestor++) width += ctx.listIndentWidths[ancestor] ?? DEFAULT_LIST_INDENT_WIDTH;
+	return width;
 }
 /**
-* Resolve a `lvlText`-style marker template ("%1.") against live counters, the
-* same way the layout engine paints it. Editor-emitted documents carry
-* templates rather than baked numbers, so the serializer must count items in
-* document order; counters live on the context (`listCounters`) so they span
-* the whole render, including list items inside tables and block SDTs.
+* A list item line with the label the page shows (`1.`, `a)`, `i.`), counted
+* in document order across the whole render, list items inside tables and
+* block SDTs included. A bullet is Markdown's `-`.
+*
+* The indent before the marker is not a fixed two spaces: CommonMark keeps a
+* child nested under its parent only when it starts at or past the column
+* where the parent item's content begins, which is the width of the parent's
+* marker plus its one trailing space (`1. ` is 3 columns, `10. ` is 4, `- ` is
+* 2). `ctx.listIndentWidths` is updated with this item's own marker width so
+* a following, deeper item can indent correctly under it.
 */
-function resolveTemplateMarker(ctx, list) {
-	const counters = ctx.listCounters.get(list.numId) ?? Array.from({ length: 9 }, () => 0);
-	const level = list.level;
-	const seenKey = `${list.numId}:${level}`;
-	if (!ctx.listSeenLevels.has(seenKey)) {
-		ctx.listSeenLevels.add(seenKey);
-		if (list.startOverride !== void 0) counters[level] = list.startOverride - 1;
-	}
-	counters[level] = (counters[level] ?? 0) + 1;
-	for (let i = level + 1; i < counters.length; i += 1) counters[i] = 0;
-	ctx.listCounters.set(list.numId, counters);
-	const levelFormats = list.levelNumFmts ?? (list.numFmt ? [list.numFmt] : void 0);
-	return resolveListTemplate({
-		template: list.marker,
-		counters,
-		levelFormats,
-		forceDecimal: list.isLegal
-	}).trim();
+function renderListItem(ctx, list, label, inline) {
+	const indent = " ".repeat(listIndentWidth(ctx, list.level));
+	const marker = list.isBullet ? "- " : `${label} `;
+	ctx.listIndentWidths[list.level] = marker.length;
+	return `${indent}${marker}${inline}`.trimEnd();
 }
 //#endregion
-export { renderParagraph };
+export { renderParagraph, renderParagraphBlock };

package/dist/markdown/renderRuns.js

@@ -4,7 +4,7 @@ import { decodeOoxmlSymbolCharacter } from "../utils/ooxmlSymbol.js";
 import { wrapComment, wrapDeletion, wrapInsertion, wrapMoveFrom, wrapMoveTo } from "./annotations.js";
 import { escapeAltText, escapeInline, escapeLinkUrl } from "./escape.js";
 import { registerImage } from "./images.js";
-import { pushWarning } from "./internals.js";
+import { numberNoteReference, pushWarning } from "./internals.js";
 //#region src/markdown/renderRuns.ts
 const MARK_DELIMS = {
 	bold: "**",
@@ -81,17 +81,10 @@ function renderRunContent(ctx, pkg, content, paraId) {
 			out += escapeInline(item.text);
 			break;
 		case "footnoteRef":
-		case "endnoteRef": {
+		case "endnoteRef":
 			if (ctx.opts.footnotes === "strip") break;
-			const markerNumber = ctx.footnoteRefs.length + 1;
-			ctx.footnoteRefs.push({
-				refId: item.id,
-				markerNumber,
-				kind: item.type === "endnoteRef" ? "endnote" : "footnote"
-			});
-			out += `[^${markerNumber}]`;
+			out += numberNoteReference(ctx, item.type === "endnoteRef" ? "endnote" : "footnote", item.id).marker;
 			break;
-		}
 		case "drawing": {
 			const ref = resolveRelationshipIdOfType(pkg?.relationships, item.image.rId, RELATIONSHIP_TYPES.image);
 			const media = ref.status === "resolved" ? pkg?.media?.get(ref.relationship.target) : void 0;

package/dist/markdown/renderTable.js

@@ -1,18 +1,25 @@
+import { ALT_CHUNK_READER_DIAGNOSTIC, isAltChunkMarkup } from "../docx/altChunk.js";
 import { getHyperlinkRuns } from "../docx/hyperlinkParser.js";
+import { OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC, isOpaqueNestedRowMarkup, opaqueRevisionCarrierName } from "../docx/opaqueCarrier.js";
 import { RELATIONSHIP_TYPES, resolveRelationshipIdOfType } from "../docx/relsParser.js";
 import { decodeOoxmlSymbolCharacter } from "../utils/ooxmlSymbol.js";
 import { escapeTableCell } from "./escape.js";
 import { registerImage } from "./images.js";
-import { pushWarning } from "./internals.js";
+import { numberNoteReference, pushWarning } from "./internals.js";
 import { renderParagraph } from "./renderParagraph.js";
 //#region src/markdown/renderTable.ts
 /** Render a `Table` as markdown. Picks GFM vs HTML based on cell features. */
 function renderTable(ctx, pkg, table) {
 	const { rows } = table;
-	if (!rows.length) return "";
-	if (needsHtmlFallback(rows)) return renderHtmlTable(ctx, pkg, rows, true);
-	return renderGfmTable(ctx, pkg, rows, true);
+	const diagnostics = [...preservedCarrierDiagnostics(table.preserved?.children), ...rows.flatMap((row) => preservedCarrierDiagnostics(row.preserved?.children))];
+	if (!rows.length) return diagnostics.join("\n");
+	return [needsHtmlFallback(rows) ? renderHtmlTable(ctx, pkg, rows, true) : renderGfmTable(ctx, pkg, rows, true), ...diagnostics].filter(Boolean).join("\n\n");
 }
+const preservedCarrierDiagnostics = (children) => (children ?? []).flatMap(({ xml }) => {
+	if (isAltChunkMarkup(xml)) return [ALT_CHUNK_READER_DIAGNOSTIC];
+	if (opaqueRevisionCarrierName(xml) !== void 0) return [OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC];
+	return isOpaqueNestedRowMarkup(xml) ? ["[Unsupported nested w:tr content]"] : [];
+});
 function needsHtmlFallback(rows) {
 	for (const row of rows) for (const cell of row.cells) {
 		if ((cell.formatting?.gridSpan ?? 1) > 1) return true;
@@ -64,10 +71,15 @@ function renderGfmCell(ctx, pkg, cell) {
 				break;
 			}
 			case "blockSdt":
+			case "blockCustomXml":
 				renderBlocks(item.content);
 				break;
-			case "table":
+			case "table": break;
 			case "preservedBlock":
+				if (isAltChunkMarkup(item.xml)) blocks.push(item.readerText === void 0 ? ALT_CHUNK_READER_DIAGNOSTIC : `${ALT_CHUNK_READER_DIAGNOSTIC}\n${item.readerText}`);
+				else if (opaqueRevisionCarrierName(item.xml) !== void 0) blocks.push(OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC);
+				else if (isOpaqueNestedRowMarkup(item.xml)) blocks.push("[Unsupported nested w:tr content]");
+				break;
 			case "bookmarkStart":
 			case "bookmarkEnd": break;
 			default: return item;
@@ -139,9 +151,14 @@ function renderHtmlCell(ctx, pkg, cell) {
 				break;
 			}
 			case "blockSdt":
+			case "blockCustomXml":
 				renderBlocks(item.content);
 				break;
 			case "preservedBlock":
+				if (isAltChunkMarkup(item.xml)) parts.push(item.readerText === void 0 ? ALT_CHUNK_READER_DIAGNOSTIC : `${ALT_CHUNK_READER_DIAGNOSTIC} ${item.readerText}`);
+				else if (opaqueRevisionCarrierName(item.xml) !== void 0) parts.push(OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC);
+				else if (isOpaqueNestedRowMarkup(item.xml)) parts.push("[Unsupported nested w:tr content]");
+				break;
 			case "bookmarkStart":
 			case "bookmarkEnd": break;
 			default: return item;
@@ -257,13 +274,8 @@ function renderHtmlRun(ctx, pkg, run, paraId) {
 		case "footnoteRef":
 		case "endnoteRef": {
 			if (ctx.opts.footnotes === "strip") break;
-			const markerNumber = ctx.footnoteRefs.length + 1;
-			ctx.footnoteRefs.push({
-				refId: item.id,
-				markerNumber,
-				kind: item.type === "endnoteRef" ? "endnote" : "footnote"
-			});
-			text += `<sup>[${markerNumber}]</sup>`;
+			const { token } = numberNoteReference(ctx, item.type === "endnoteRef" ? "endnote" : "footnote", item.id);
+			text += `<sup>[${token}]</sup>`;
 			break;
 		}
 		default: break;

package/dist/markdown/trailers.js

@@ -18,9 +18,9 @@ import { panic } from "better-result";
 function appendTrailers(ctx, doc, body) {
 	const sections = body.trim() ? [body] : [];
 	if (ctx.footnoteRefs.length > 0) {
-		const refs = ctx.footnoteRefs.map(({ refId, markerNumber, kind }) => {
+		const refs = ctx.footnoteRefs.map(({ refId, marker, kind }) => {
 			const note = kind === "endnote" ? doc.package.endnotes?.find((n) => n.id === refId) : doc.package.footnotes?.find((f) => f.id === refId);
-			return `[^${markerNumber}]: ${note ? noteText(ctx, doc, note) : ""}`;
+			return `${marker}: ${note ? noteText(ctx, doc, note) : ""}`;
 		});
 		sections.push(refs.join("\n"));
 	}

package/dist/markdown/types.d.ts

@@ -1,4 +1,6 @@
+import { NoteReferenceKind, NoteReferenceNumbering } from "../utils/noteReferenceLabels.js";
 import { BuiltInStyleIndex } from "../docx/builtInStyles.js";
+import { ListLabelCounter } from "../prosemirror/listLabels.js";
 //#region src/markdown/types.d.ts
 /**
  * Metadata describing a single image registration. Owned by the markdown
@@ -106,12 +108,18 @@ type RenderContext = {
   imagesByPath: Map<string, ImageRef>;
   /** Diagnostics accumulator. */
   warnings: string[];
-  /** Footnote/endnote refs collected during this render, in document order. */
+  /**
+   * Footnote/endnote refs collected during this render, one per note in the
+   * order it is first referenced. `marker` is what the body line shows
+   * (`[^1]`, `[^e1]`) and what the definition trailer repeats.
+   */
   footnoteRefs: {
     refId: number;
-    markerNumber: number;
-    kind: "footnote" | "endnote";
+    marker: string;
+    kind: NoteReferenceKind;
   }[];
+  /** Reading-order note numbering, shared with the AI text view. */
+  noteNumbering: NoteReferenceNumbering;
   /** Comment refs collected during this render (sidecar mode only). */
   commentRefs: {
     commentId: number;
@@ -124,12 +132,26 @@ type RenderContext = {
   }[];
   /** 1-based counter for default virtual paths. */
   imageCounter: number;
-  /** Live list counters per numId, for resolving `%N` marker templates. */
-  listCounters: Map<number, number[]>;
-  /** `numId:level` pairs already seen, so a start override applies once. */
-  listSeenLevels: Set<string>;
+  /**
+   * Advances past one paragraph, in document order, and answers the list
+   * label it shows: the page's own counter, so the numbers follow the
+   * document as it stands rather than the markers resolved when it was read.
+   */
+  nextListLabel: ListLabelCounter;
   /** The document's styles indexed by the built-in they are; classifies headings and quotes. */
   builtInStyles: BuiltInStyleIndex;
+  /**
+   * The rendered width (marker text + one trailing space) of the most
+   * recently emitted list item at each level, indexed by `ListRendering.level`.
+   * A nested item's indent is the sum of every shallower level's width here,
+   * not a fixed two spaces: CommonMark only keeps a child nested under its
+   * parent when the child starts at or past the column where the parent's
+   * content begins, and a marker like `10. ` or `1. ` is wider than `- `.
+   * Document order visits a parent before its children, so by the time a
+   * level-N item renders, levels `0..N-1` already hold the current ancestor
+   * chain's widths.
+   */
+  listIndentWidths: number[];
 };
 //#endregion
 export { ImageMeta, ImageRef, MarkdownOptions, MarkdownResult, RenderContext, ResolvedOptions };

package/dist/paged-layout/incrementalMeasure.d.ts

@@ -17,8 +17,7 @@ type IncrementalMeasureResult = {
   measures: Measure[];
   measuredBlockIndexes: number[];
 };
-declare function mergeDirtyRanges(first: DirtyRange | null, second: DirtyRange | null): DirtyRange | null;
 declare function findDirtyBlockIndexes(blocks: FlowBlock[], dirtyRange: DirtyRange): number[];
 declare function tryBuildIncrementalMeasures({ previousBlocks, previousMeasures, previousBlockWidths, nextBlocks, nextBlockWidths, dirtyRange, measureBlock }: IncrementalMeasureInput): IncrementalMeasureResult | null;
 //#endregion
-export { DirtyRange, IncrementalMeasureInput, IncrementalMeasureResult, findDirtyBlockIndexes, mergeDirtyRanges, tryBuildIncrementalMeasures };
+export { DirtyRange, IncrementalMeasureInput, IncrementalMeasureResult, findDirtyBlockIndexes, tryBuildIncrementalMeasures };

package/dist/paged-layout/incrementalMeasure.js

@@ -1,12 +1,4 @@
 //#region src/paged-layout/incrementalMeasure.ts
-function mergeDirtyRanges(first, second) {
-	if (!first) return second;
-	if (!second) return first;
-	return {
-		from: Math.min(first.from, second.from),
-		to: Math.max(first.to, second.to)
-	};
-}
 function findDirtyBlockIndexes(blocks, dirtyRange) {
 	const indexes = [];
 	const dirtyFrom = Math.min(dirtyRange.from, dirtyRange.to);
@@ -53,4 +45,4 @@ function isIncrementalMeasureEligibleBlock(block) {
 	});
 }
 //#endregion
-export { findDirtyBlockIndexes, mergeDirtyRanges, tryBuildIncrementalMeasures };
+export { findDirtyBlockIndexes, tryBuildIncrementalMeasures };

package/dist/paged-layout/transactionDirtyRange.d.ts

@@ -2,7 +2,5 @@ import { DirtyRange } from "./incrementalMeasure.js";
 import { Transaction } from "prosemirror-state";
 //#region src/paged-layout/transactionDirtyRange.d.ts
 declare function getTransactionDirtyRange(transaction: Transaction): DirtyRange | null;
-/** Collect every transaction in an applied batch in the final document's coordinates. */
-declare function getTransactionsDirtyRange(transactions: readonly Transaction[]): DirtyRange | null;
 //#endregion
-export { getTransactionDirtyRange, getTransactionsDirtyRange };
+export { getTransactionDirtyRange };

package/dist/paged-layout/transactionDirtyRange.js

@@ -1,49 +1,37 @@
-import { mergeDirtyRanges } from "./incrementalMeasure.js";
+import { sweepPositions } from "../prosemirror/positionSweep.js";
 import { AddMarkStep, RemoveMarkStep } from "prosemirror-transform";
 //#region src/paged-layout/transactionDirtyRange.ts
 function getTransactionDirtyRange(transaction) {
-	const dirtyRange = {
-		from: Number.POSITIVE_INFINITY,
-		to: Number.NEGATIVE_INFINITY
-	};
-	for (let stepIndex = 0; stepIndex < transaction.mapping.maps.length; stepIndex += 1) includeStepDirtyRange(transaction, stepIndex, dirtyRange);
-	if (!Number.isFinite(dirtyRange.from) || !Number.isFinite(dirtyRange.to)) return null;
-	return dirtyRange;
-}
-/** Collect every transaction in an applied batch in the final document's coordinates. */
-function getTransactionsDirtyRange(transactions) {
-	let combinedRange = null;
-	for (let index = 0; index < transactions.length; index += 1) {
-		const transaction = transactions[index];
-		if (!transaction) continue;
-		const range = getTransactionDirtyRange(transaction);
-		if (!range) continue;
-		let from = range.from;
-		let to = range.to;
-		for (const followingTransaction of transactions.slice(index + 1)) {
-			from = followingTransaction.mapping.map(from, -1);
-			to = followingTransaction.mapping.map(to, 1);
-		}
-		combinedRange = mergeDirtyRanges(combinedRange, {
-			from,
-			to
+	const queries = [];
+	const extend = (newStart, newEnd, from) => {
+		queries.push({
+			pos: newStart,
+			assoc: -1,
+			from
+		}, {
+			pos: newEnd,
+			assoc: 1,
+			from
 		});
+	};
+	for (let stepIndex = 0; stepIndex < transaction.mapping.maps.length; stepIndex += 1) {
+		const map = transaction.mapping.maps[stepIndex];
+		if (!map) continue;
+		map.forEach((_oldStart, _oldEnd, newStart, newEnd) => extend(newStart, newEnd, stepIndex + 1));
+		const step = transaction.steps[stepIndex];
+		if (step instanceof AddMarkStep || step instanceof RemoveMarkStep) extend(step.from, step.to, stepIndex + 1);
 	}
-	return combinedRange;
-}
-function includeStepDirtyRange(transaction, stepIndex, dirtyRange) {
-	const map = transaction.mapping.maps[stepIndex];
-	if (!map) return;
-	const followingMaps = transaction.mapping.slice(stepIndex + 1);
-	const extend = (newStart, newEnd) => {
-		const finalStart = followingMaps.map(newStart, -1);
-		const finalEnd = followingMaps.map(newEnd, 1);
-		dirtyRange.from = Math.min(dirtyRange.from, finalStart, finalEnd);
-		dirtyRange.to = Math.max(dirtyRange.to, finalStart, finalEnd);
+	if (queries.length === 0) return null;
+	let from = Number.POSITIVE_INFINITY;
+	let to = Number.NEGATIVE_INFINITY;
+	for (const { pos } of sweepPositions([transaction.mapping], queries)) {
+		from = Math.min(from, pos);
+		to = Math.max(to, pos);
+	}
+	return {
+		from,
+		to
 	};
-	map.forEach((_oldStart, _oldEnd, newStart, newEnd) => extend(newStart, newEnd));
-	const step = transaction.steps[stepIndex];
-	if (step instanceof AddMarkStep || step instanceof RemoveMarkStep) extend(step.from, step.to);
 }
 //#endregion
-export { getTransactionDirtyRange, getTransactionsDirtyRange };
+export { getTransactionDirtyRange };

package/dist/panel-layout.d.ts

@@ -0,0 +1,83 @@
+//#region src/panel-layout.d.ts
+/**
+ * One layout model for the editor's side panels: the page is centred between
+ * a start track (the document outline) and an end track (the comments).
+ *
+ * The editor measures the width it has once, and this module decides how
+ * each panel is presented. Every track the page shares the row with is
+ * counted here, so the page, the outline and the comments cannot overlap:
+ * a panel either gets a track of its own or becomes a drawer the user opens
+ * on purpose. A drawer takes no track.
+ *
+ * Space goes to the page first, then the outline rail, then the comments
+ * column, then the full outline column:
+ *
+ * - comments: a column when the page, the comments and the outline rail fit;
+ *   otherwise a drawer.
+ * - outline: a column when it fits beside the page and the comments column;
+ *   otherwise a rail of heading ticks when that fits; otherwise a drawer.
+ *
+ * The tier names the result: `wide` when every panel has its full column,
+ * `medium` when the outline is a rail, `narrow` when a panel is a drawer.
+ * The thresholds derive from the page width (at the current zoom) and the
+ * panel widths below, never from fixed breakpoints: a zoomed-out page or a
+ * landscape section moves them.
+ */
+/** Widths, in CSS pixels, every tier is derived from. */
+declare const PANEL_METRICS: {
+  /** The outline column in the `wide` tier, border included. */
+  readonly outlineColumnWidth: 256;
+  /** The outline rail in the `medium` tier, border included. */
+  readonly outlineRailWidth: 32;
+  /** A comment card column. */
+  readonly commentsWidth: 280;
+  /** Space between the page edge and the comment cards, and after them. */
+  readonly commentsGap: 12;
+  /** Canvas kept clear on either side of the page. */
+  readonly pageMargin: 20;
+  /** An outline or comments drawer, capped by the width it opens over. */
+  readonly drawerWidth: 304;
+};
+/** Width the comments take beside the page: gap, cards, gap. */
+declare const COMMENTS_TRACK_WIDTH: number;
+type PanelLayoutTier = "wide" | "medium" | "narrow";
+/** How the outline is shown: a column, a rail of ticks, a drawer, or not at all. */
+type OutlinePresentation = "none" | "column" | "rail" | "drawer";
+/** How the comments are shown: a column beside the page, a drawer, or not at all. */
+type CommentsPresentation = "hidden" | "column" | "drawer";
+type PanelLayoutInput = {
+  /** Width of the row the outline track and the scroll viewport share, scrollbar excluded. */
+  availableWidth: number;
+  /** Width of the widest page at the current zoom. */
+  pageWidth: number;
+  /** Whether the document has an outline to show. */
+  outline: "absent" | "available";
+  /** Whether the user (or the auto-open) wants the comments shown. */
+  comments: "closed" | "open";
+};
+type PanelLayout = {
+  tier: PanelLayoutTier;
+  outline: OutlinePresentation;
+  comments: CommentsPresentation;
+  /** Width of the outline track at the page's start (outside the scroll viewport). */
+  outlineTrackWidth: number;
+  /** Width reserved after the page inside the scroll viewport for the comments. */
+  commentsGutter: number;
+  /** Smallest available width for each tier, for the same page and panels. */
+  thresholds: {
+    wide: number;
+    medium: number;
+  };
+};
+/**
+ * The smallest available width for each tier with the comments wanted as
+ * given: `wide` fits every column, `medium` fits the outline rail and the
+ * comments column.
+ */
+declare const panelLayoutThresholds: ({ pageWidth, outline, comments }: Omit<PanelLayoutInput, "availableWidth">) => PanelLayout["thresholds"];
+/** Decide each panel's presentation for the width the editor has. */
+declare const computePanelLayout: (input: PanelLayoutInput) => PanelLayout;
+/** Which drawer is open over the page: at most one at a time. */
+type PanelOverlay = "none" | "outline" | "comments";
+//#endregion
+export { COMMENTS_TRACK_WIDTH, CommentsPresentation, OutlinePresentation, PANEL_METRICS, PanelLayout, PanelLayoutInput, PanelLayoutTier, PanelOverlay, computePanelLayout, panelLayoutThresholds };

package/dist/panel-layout.js

@@ -0,0 +1,96 @@
+//#region src/panel-layout.ts
+/**
+* One layout model for the editor's side panels: the page is centred between
+* a start track (the document outline) and an end track (the comments).
+*
+* The editor measures the width it has once, and this module decides how
+* each panel is presented. Every track the page shares the row with is
+* counted here, so the page, the outline and the comments cannot overlap:
+* a panel either gets a track of its own or becomes a drawer the user opens
+* on purpose. A drawer takes no track.
+*
+* Space goes to the page first, then the outline rail, then the comments
+* column, then the full outline column:
+*
+* - comments: a column when the page, the comments and the outline rail fit;
+*   otherwise a drawer.
+* - outline: a column when it fits beside the page and the comments column;
+*   otherwise a rail of heading ticks when that fits; otherwise a drawer.
+*
+* The tier names the result: `wide` when every panel has its full column,
+* `medium` when the outline is a rail, `narrow` when a panel is a drawer.
+* The thresholds derive from the page width (at the current zoom) and the
+* panel widths below, never from fixed breakpoints: a zoomed-out page or a
+* landscape section moves them.
+*/
+/** Widths, in CSS pixels, every tier is derived from. */
+const PANEL_METRICS = {
+	/** The outline column in the `wide` tier, border included. */
+	outlineColumnWidth: 256,
+	/** The outline rail in the `medium` tier, border included. */
+	outlineRailWidth: 32,
+	/** A comment card column. */
+	commentsWidth: 280,
+	/** Space between the page edge and the comment cards, and after them. */
+	commentsGap: 12,
+	/** Canvas kept clear on either side of the page. */
+	pageMargin: 20,
+	/** An outline or comments drawer, capped by the width it opens over. */
+	drawerWidth: 304
+};
+/** Width the comments take beside the page: gap, cards, gap. */
+const COMMENTS_TRACK_WIDTH = PANEL_METRICS.commentsWidth + 2 * PANEL_METRICS.commentsGap;
+const pageTrackWidth = (pageWidth) => pageWidth + 2 * PANEL_METRICS.pageMargin;
+/**
+* The smallest available width for each tier with the comments wanted as
+* given: `wide` fits every column, `medium` fits the outline rail and the
+* comments column.
+*/
+const panelLayoutThresholds = ({ pageWidth, outline, comments }) => {
+	const page = pageTrackWidth(pageWidth);
+	const commentsTrack = comments === "open" ? COMMENTS_TRACK_WIDTH : 0;
+	const hasOutline = outline === "available";
+	return {
+		wide: page + commentsTrack + (hasOutline ? PANEL_METRICS.outlineColumnWidth : 0),
+		medium: page + commentsTrack + (hasOutline ? PANEL_METRICS.outlineRailWidth : 0)
+	};
+};
+const OUTLINE_TRACK_WIDTH = {
+	none: 0,
+	column: PANEL_METRICS.outlineColumnWidth,
+	rail: PANEL_METRICS.outlineRailWidth,
+	drawer: 0
+};
+const tierFor = (outline, comments) => {
+	if (outline === "drawer" || comments === "drawer") return "narrow";
+	if (outline === "rail") return "medium";
+	return "wide";
+};
+/** Decide each panel's presentation for the width the editor has. */
+const computePanelLayout = (input) => {
+	const { availableWidth } = input;
+	const thresholds = panelLayoutThresholds(input);
+	const page = pageTrackWidth(input.pageWidth);
+	const comments = (() => {
+		if (input.comments === "closed") return "hidden";
+		return availableWidth >= thresholds.medium ? "column" : "drawer";
+	})();
+	const commentsGutter = comments === "column" ? COMMENTS_TRACK_WIDTH : 0;
+	const outline = (() => {
+		if (input.outline === "absent") return "none";
+		const beside = page + commentsGutter;
+		if (availableWidth >= thresholds.wide) return "column";
+		if (availableWidth >= beside + PANEL_METRICS.outlineRailWidth) return "rail";
+		return "drawer";
+	})();
+	return {
+		tier: tierFor(outline, comments),
+		outline,
+		comments,
+		outlineTrackWidth: OUTLINE_TRACK_WIDTH[outline],
+		commentsGutter,
+		thresholds
+	};
+};
+//#endregion
+export { COMMENTS_TRACK_WIDTH, PANEL_METRICS, computePanelLayout, panelLayoutThresholds };