@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

package/dist/layout-painter/renderWatermark.js

@@ -0,0 +1,61 @@
+import { resolveFontFamily } from "../utils/fontResolver.js";
+//#region src/layout-painter/renderWatermark.ts
+const WATERMARK_CLASS = "layout-page-watermark";
+/**
+* Build the watermark overlay element for a page. Returns `null` when
+* the watermark is a picture without a resolved `imageSrc` (the
+* relationship-id resolver lives outside the painter; without a src
+* there's nothing visible to draw).
+*/
+function renderWatermarkLayer(watermark, page, doc, options = {}) {
+	if (watermark.kind === "picture" && !options.imageSrc) return null;
+	const layer = doc.createElement("div");
+	layer.className = WATERMARK_CLASS;
+	layer.style.position = "absolute";
+	layer.style.top = "0";
+	layer.style.left = "0";
+	layer.style.width = `${page.size.w}px`;
+	layer.style.height = `${page.size.h}px`;
+	layer.style.zIndex = "0";
+	layer.style.pointerEvents = "none";
+	layer.style.overflow = "hidden";
+	layer.style.display = "flex";
+	layer.style.alignItems = "center";
+	layer.style.justifyContent = "center";
+	if (watermark.kind === "text") layer.append(renderTextWatermark(watermark, doc));
+	else {
+		const imageSrc = options.imageSrc;
+		if (!imageSrc) return null;
+		layer.append(renderPictureWatermark(watermark, imageSrc, doc));
+	}
+	return layer;
+}
+function renderTextWatermark(watermark, doc) {
+	const el = doc.createElement("div");
+	el.textContent = watermark.text;
+	el.style.fontFamily = resolveFontFamily(watermark.font ?? "Calibri").cssFallback;
+	el.style.fontSize = "144px";
+	el.style.fontWeight = "bold";
+	el.style.whiteSpace = "nowrap";
+	const color = watermark.color && watermark.color !== "auto" ? `#${watermark.color}` : "#C0C0C0";
+	el.style.color = color;
+	el.style.opacity = String(watermark.opacity ?? .5);
+	const rotation = watermark.diagonal === false ? 0 : -45;
+	el.style.transform = `rotate(${rotation}deg)`;
+	el.style.transformOrigin = "center center";
+	return el;
+}
+function renderPictureWatermark(watermark, imageSrc, doc) {
+	const img = doc.createElement("img");
+	img.src = imageSrc;
+	img.alt = "";
+	img.setAttribute("aria-hidden", "true");
+	const scalePct = (watermark.scale ?? 1) * 100;
+	img.style.maxWidth = `${scalePct}%`;
+	img.style.maxHeight = `${scalePct}%`;
+	img.style.opacity = watermark.washout === false ? "1" : "0.4";
+	img.style.objectFit = "contain";
+	return img;
+}
+//#endregion
+export { renderWatermarkLayer };

package/dist/layout-painter/sdtBoundary.d.ts

@@ -0,0 +1,6 @@
+import { SdtGroup } from "../layout-engine/types.js";
+
+//#region src/layout-painter/sdtBoundary.d.ts
+declare function applySdtDataAttrs(el: HTMLElement, sdtGroups: readonly SdtGroup[] | undefined): void;
+//#endregion
+export { applySdtDataAttrs };

package/dist/layout-painter/sdtBoundary.js

@@ -0,0 +1,28 @@
+//#region src/layout-painter/sdtBoundary.ts
+function applySdtDataAttrs(el, sdtGroups) {
+	if (!sdtGroups || sdtGroups.length === 0) return;
+	el.dataset["sdtBoundary"] = "true";
+	const innermost = sdtGroups.at(-1);
+	if (innermost) {
+		el.dataset["sdtId"] = innermost.id;
+		el.dataset["sdtPmPos"] = String(innermost.pmPos);
+		el.dataset["sdtType"] = innermost.sdtType;
+		if (innermost.position) el.dataset["sdtPosition"] = innermost.position;
+		if (innermost.alias) el.dataset["sdtAlias"] = innermost.alias;
+		if (innermost.tag) el.dataset["sdtTag"] = innermost.tag;
+		if (innermost.sdtId !== void 0) el.dataset["sdtOoxmlId"] = String(innermost.sdtId);
+		if (innermost.lock) el.dataset["sdtLock"] = innermost.lock;
+		if (innermost.showingPlaceholder) el.dataset["sdtShowingPlaceholder"] = "true";
+		if (innermost.checked !== void 0) el.dataset["sdtChecked"] = String(innermost.checked);
+		if (innermost.dateFormat) el.dataset["sdtDateFormat"] = innermost.dateFormat;
+		if (innermost.listItemsJson) el.dataset["sdtListItems"] = innermost.listItemsJson;
+	}
+	el.dataset["sdtStack"] = JSON.stringify(sdtGroups.map((g) => ({
+		id: g.id,
+		sdtType: g.sdtType,
+		tag: g.tag ?? null,
+		alias: g.alias ?? null
+	})));
+}
+//#endregion
+export { applySdtDataAttrs };

package/dist/managers/ContextMenuManager.d.ts

@@ -0,0 +1,28 @@
+import { Subscribable } from "./Subscribable.js";
+import { ContextMenuAnchor, ContextMenuSnapshot } from "./types.js";
+import { EditorState } from "prosemirror-state";
+
+//#region src/managers/ContextMenuManager.d.ts
+type OpenContextMenuOptions = {
+  /** Live editor state, or null when the editor view is not mounted. */state: EditorState | null;
+  /**
+   * For the PagedEditor child callback path, which already knows from a
+   * layout-overlay selection whether the user highlighted text. When omitted,
+   * `hasSelection` is derived from the ProseMirror selection.
+   */
+  hasSelectionOverride?: boolean | undefined; /** Whether the cursor sits inside a tracked change (detected by the adapter). */
+  cursorInTrackedChange: boolean;
+};
+declare class ContextMenuManager extends Subscribable<ContextMenuSnapshot> {
+  constructor();
+  /** Open the menu at `anchor`, deriving menu flags from the editor state. */
+  openMenu(anchor: ContextMenuAnchor, {
+    state,
+    hasSelectionOverride,
+    cursorInTrackedChange
+  }: OpenContextMenuOptions): void;
+  /** Close the menu. */
+  closeMenu(): void;
+}
+//#endregion
+export { ContextMenuManager, OpenContextMenuOptions };

package/dist/managers/ContextMenuManager.js

@@ -0,0 +1,48 @@
+import { isInTable as isInTableCell } from "../prosemirror/extensions/nodes/TableExtension.js";
+import { Subscribable } from "./Subscribable.js";
+//#region src/managers/ContextMenuManager.ts
+const CLOSED_STATE = {
+	isOpen: false,
+	position: {
+		x: 0,
+		y: 0
+	},
+	hasSelection: false,
+	selectionRange: {
+		from: 0,
+		to: 0
+	},
+	cursorInTable: false,
+	cursorInTrackedChange: false
+};
+var ContextMenuManager = class extends Subscribable {
+	constructor() {
+		super(CLOSED_STATE);
+	}
+	/** Open the menu at `anchor`, deriving menu flags from the editor state. */
+	openMenu(anchor, { state, hasSelectionOverride, cursorInTrackedChange }) {
+		const selection = state?.selection ?? {
+			from: 0,
+			to: 0
+		};
+		const hasSelection = hasSelectionOverride ?? selection.from !== selection.to;
+		const cursorInTable = state ? isInTableCell(state) : false;
+		this.setSnapshot({
+			isOpen: true,
+			position: anchor,
+			hasSelection,
+			selectionRange: {
+				from: selection.from,
+				to: selection.to
+			},
+			cursorInTable,
+			cursorInTrackedChange
+		});
+	}
+	/** Close the menu. */
+	closeMenu() {
+		this.setSnapshot(CLOSED_STATE);
+	}
+};
+//#endregion
+export { ContextMenuManager };

package/dist/managers/DocumentLoaderManager.d.ts

@@ -0,0 +1,47 @@
+import { document_d_exports } from "../types/document.js";
+import { DocxCompatibility } from "../docx/compatibility.js";
+import { DocxInput } from "../utils/docxInput.js";
+
+//#region src/managers/DocumentLoaderManager.d.ts
+type DocumentLoadState = {
+  status: "loading";
+} | {
+  status: "ready";
+} | {
+  status: "error";
+  message: string;
+};
+/**
+ * Minimal structural view of the editor history the loader drives. Declared
+ * here so core does not depend on the React `useHistory` return type.
+ */
+type DocumentLoaderHistory = {
+  /** The current document, or null before any load. */readonly state: document_d_exports.Document | null; /** Reset history to a freshly loaded document. */
+  reset: (document: document_d_exports.Document) => void;
+};
+type DocumentLoaderCallbacks = {
+  /** Editor history to reset/seed with the loaded document. */history: DocumentLoaderHistory; /** Called when an unrecoverable parse error occurs. */
+  onError: ((error: Error) => void) | undefined; /** Called after parsing to report whether editing can preserve fidelity. */
+  onCompatibilityChange: ((compatibility: DocxCompatibility) => void) | undefined; /** Clears UI state coupled to the previous document at the start of a load. */
+  onReset: () => void; /** Sets the document loading slice of editor state. */
+  setDocumentLoadState: (state: DocumentLoadState) => void;
+};
+declare class DocumentLoaderManager {
+  private loadGeneration;
+  private callbacks;
+  constructor(callbacks: DocumentLoaderCallbacks);
+  /** Re-bind the host callbacks (the adapter refreshes these every render). */
+  setCallbacks(callbacks: DocumentLoaderCallbacks): void;
+  /** Reset color/UI state coupled to the previous document. */
+  resetForNewDocument(): void;
+  /** Load an already-parsed document. */
+  loadParsedDocument(doc: document_d_exports.Document): void;
+  /**
+   * Parse and load a raw DOCX buffer. A monotonic generation counter discards
+   * the result (and any error) when a newer load started while this one was in
+   * flight.
+   */
+  loadBuffer(buffer: DocxInput): Promise<void>;
+}
+//#endregion
+export { DocumentLoadState, DocumentLoaderCallbacks, DocumentLoaderHistory, DocumentLoaderManager };

package/dist/managers/DocumentLoaderManager.js

@@ -0,0 +1,69 @@
+import { resetAuthorColors } from "../utils/authorColors.js";
+import { loadFontsWithMapping } from "../utils/fontLoader.js";
+import { parseDocx } from "../docx/parser.js";
+import { inspectDocxCompatibility } from "../docx/compatibility.js";
+//#region src/managers/DocumentLoaderManager.ts
+/**
+* DocumentLoaderManager
+*
+* Framework-agnostic DOCX load/state orchestration, extracted from the React
+* `useDocumentLoader` hook. Owns the monotonic load-generation counter that
+* discards stale async loads and runs the parse → reset → history → fonts
+* sequence. The pure load-source resolution lives in `documentLoaderBehavior`.
+*
+* The adapter keeps only React concerns: the prop-change effects, the original
+* buffer ref, and the host callbacks (which it re-binds via `setCallbacks`).
+*/
+var DocumentLoaderManager = class {
+	loadGeneration = 0;
+	callbacks;
+	constructor(callbacks) {
+		this.callbacks = callbacks;
+	}
+	/** Re-bind the host callbacks (the adapter refreshes these every render). */
+	setCallbacks(callbacks) {
+		this.callbacks = callbacks;
+	}
+	/** Reset color/UI state coupled to the previous document. */
+	resetForNewDocument() {
+		resetAuthorColors();
+		this.callbacks.onReset();
+	}
+	/** Load an already-parsed document. */
+	loadParsedDocument(doc) {
+		const { history, onCompatibilityChange, setDocumentLoadState } = this.callbacks;
+		this.resetForNewDocument();
+		history.reset(doc);
+		onCompatibilityChange?.(inspectDocxCompatibility(doc));
+		setDocumentLoadState({ status: "ready" });
+		if (doc.requiredFonts && doc.requiredFonts.length > 0) loadFontsWithMapping(doc.requiredFonts).catch(() => void 0);
+	}
+	/**
+	* Parse and load a raw DOCX buffer. A monotonic generation counter discards
+	* the result (and any error) when a newer load started while this one was in
+	* flight.
+	*/
+	async loadBuffer(buffer) {
+		const { history, onError, setDocumentLoadState } = this.callbacks;
+		const generation = ++this.loadGeneration;
+		if (!(history.state !== null)) setDocumentLoadState({ status: "loading" });
+		try {
+			const doc = await parseDocx(buffer, {
+				detectVariables: false,
+				preloadFonts: false
+			});
+			if (this.loadGeneration !== generation) return;
+			this.loadParsedDocument(doc);
+		} catch (error) {
+			if (this.loadGeneration !== generation) return;
+			const message = error instanceof Error ? error.message : "Failed to parse document";
+			setDocumentLoadState({
+				status: "error",
+				message
+			});
+			onError?.(error instanceof Error ? error : new Error(message));
+		}
+	}
+};
+//#endregion
+export { DocumentLoaderManager };

package/dist/managers/EditorModeManager.d.ts

@@ -0,0 +1,28 @@
+import { Subscribable } from "./Subscribable.js";
+
+//#region src/managers/EditorModeManager.d.ts
+/** Editor mode. Mirrors Google Docs editing/suggesting/viewing semantics. */
+type EditorMode = "editing" | "suggesting" | "viewing";
+/** How tracked changes render. Drives the display mode dropdown. */
+declare const DISPLAY_MODES: readonly ["all-markup", "simple-markup", "no-markup", "original"];
+type DisplayMode = (typeof DISPLAY_MODES)[number];
+/** EditorModeManager snapshot. */
+type EditorModeSnapshot = {
+  /** Uncontrolled internal editing mode (the host's controlled prop wins over this). */editingMode: EditorMode; /** Tracked-changes display mode (`all-markup` by default). */
+  displayMode: DisplayMode;
+};
+/** True when the host opts into read-only OR the mode is `"viewing"`. */
+declare const isReadOnlyMode: (editingMode: EditorMode, readOnlyProp: boolean) => boolean;
+/** True when the mode is `"suggesting"`. */
+declare const isTrackChangesMode: (editingMode: EditorMode) => boolean;
+/** The mode produced by toggling track changes between `"editing"` and `"suggesting"`. */
+declare const toggledTrackChangesMode: (editingMode: EditorMode) => EditorMode;
+declare class EditorModeManager extends Subscribable<EditorModeSnapshot> {
+  constructor(initialEditingMode: EditorMode);
+  /** Set the internal editing mode. */
+  setEditingMode(mode: EditorMode): void;
+  /** Set the tracked-changes display mode. */
+  setDisplayMode(mode: DisplayMode): void;
+}
+//#endregion
+export { DISPLAY_MODES, DisplayMode, EditorMode, EditorModeManager, EditorModeSnapshot, isReadOnlyMode, isTrackChangesMode, toggledTrackChangesMode };

package/dist/managers/EditorModeManager.js

@@ -0,0 +1,50 @@
+import { Subscribable } from "./Subscribable.js";
+//#region src/managers/EditorModeManager.ts
+/**
+* EditorModeManager
+*
+* Framework-agnostic store for the editor's mode state.
+* Extracted from the React `useEditorMode` hook.
+*
+* Holds the uncontrolled internal editing mode and the tracked-changes display
+* mode; the host adapter layers controlled-prop reconciliation on top. The
+* mode derivations (read-only, track-changes, toggle target) are pure helpers
+* so any adapter can compute them without the store.
+*/
+/** How tracked changes render. Drives the display mode dropdown. */
+const DISPLAY_MODES = [
+	"all-markup",
+	"simple-markup",
+	"no-markup",
+	"original"
+];
+/** True when the host opts into read-only OR the mode is `"viewing"`. */
+const isReadOnlyMode = (editingMode, readOnlyProp) => readOnlyProp || editingMode === "viewing";
+/** True when the mode is `"suggesting"`. */
+const isTrackChangesMode = (editingMode) => editingMode === "suggesting";
+/** The mode produced by toggling track changes between `"editing"` and `"suggesting"`. */
+const toggledTrackChangesMode = (editingMode) => isTrackChangesMode(editingMode) ? "editing" : "suggesting";
+var EditorModeManager = class extends Subscribable {
+	constructor(initialEditingMode) {
+		super({
+			editingMode: initialEditingMode,
+			displayMode: "all-markup"
+		});
+	}
+	/** Set the internal editing mode. */
+	setEditingMode(mode) {
+		this.setSnapshot({
+			...this.getSnapshot(),
+			editingMode: mode
+		});
+	}
+	/** Set the tracked-changes display mode. */
+	setDisplayMode(mode) {
+		this.setSnapshot({
+			...this.getSnapshot(),
+			displayMode: mode
+		});
+	}
+};
+//#endregion
+export { DISPLAY_MODES, EditorModeManager, isReadOnlyMode, isTrackChangesMode, toggledTrackChangesMode };

package/dist/managers/ErrorManager.d.ts

@@ -0,0 +1,26 @@
+import { Subscribable } from "./Subscribable.js";
+import { ErrorManagerSnapshot } from "./types.js";
+
+//#region src/managers/ErrorManager.d.ts
+declare class ErrorManager extends Subscribable<ErrorManagerSnapshot> {
+  private notifications;
+  private idCounter;
+  private readonly timers;
+  constructor();
+  /** Show an error notification (persistent, not auto-dismissed). */
+  showError(message: string, details?: string): string;
+  /** Show a warning notification (auto-dismissed after 5s). */
+  showWarning(message: string, details?: string): string;
+  /** Show an info notification (auto-dismissed after 5s). */
+  showInfo(message: string, details?: string): string;
+  /** Dismiss a notification by ID. */
+  dismiss(id: string): void;
+  /** Clear all notifications and cancel pending timers. */
+  clearAll(): void;
+  /** Destroy the manager and clean up all timers. */
+  destroy(): void;
+  private addNotification;
+  private emitSnapshot;
+}
+//#endregion
+export { ErrorManager };

package/dist/managers/ErrorManager.js

@@ -0,0 +1,85 @@
+import { Subscribable } from "./Subscribable.js";
+//#region src/managers/ErrorManager.ts
+/**
+* ErrorManager
+*
+* Framework-agnostic pub/sub error notification system.
+* Replaces React's `componentDidCatch` + context pattern for error notifications.
+*
+* Usage with React:
+* ```ts
+* const { notifications } = useSyncExternalStore(manager.subscribe, manager.getSnapshot);
+* ```
+*/
+var ErrorManager = class extends Subscribable {
+	notifications = [];
+	idCounter = 0;
+	timers = /* @__PURE__ */ new Set();
+	constructor() {
+		super({ notifications: [] });
+	}
+	/** Show an error notification (persistent, not auto-dismissed). */
+	showError(message, details) {
+		return this.addNotification(message, "error", details);
+	}
+	/** Show a warning notification (auto-dismissed after 5s). */
+	showWarning(message, details) {
+		return this.addNotification(message, "warning", details);
+	}
+	/** Show an info notification (auto-dismissed after 5s). */
+	showInfo(message, details) {
+		return this.addNotification(message, "info", details);
+	}
+	/** Dismiss a notification by ID. */
+	dismiss(id) {
+		this.notifications = this.notifications.map((n) => n.id === id ? {
+			...n,
+			dismissed: true
+		} : n);
+		this.emitSnapshot();
+		const timer = setTimeout(() => {
+			this.timers.delete(timer);
+			this.notifications = this.notifications.filter((n) => n.id !== id);
+			this.emitSnapshot();
+		}, 300);
+		this.timers.add(timer);
+	}
+	/** Clear all notifications and cancel pending timers. */
+	clearAll() {
+		this.notifications = [];
+		for (const timer of this.timers) clearTimeout(timer);
+		this.timers.clear();
+		this.emitSnapshot();
+	}
+	/** Destroy the manager and clean up all timers. */
+	destroy() {
+		for (const timer of this.timers) clearTimeout(timer);
+		this.timers.clear();
+		this.notifications = [];
+	}
+	addNotification(message, severity, details) {
+		const id = `error-${++this.idCounter}-${Date.now()}`;
+		const notification = {
+			id,
+			message,
+			severity,
+			...details !== void 0 ? { details } : {},
+			timestamp: Date.now()
+		};
+		this.notifications = [...this.notifications, notification];
+		this.emitSnapshot();
+		if (severity !== "error") {
+			const timer = setTimeout(() => {
+				this.timers.delete(timer);
+				this.dismiss(id);
+			}, 5e3);
+			this.timers.add(timer);
+		}
+		return id;
+	}
+	emitSnapshot() {
+		this.setSnapshot({ notifications: this.notifications });
+	}
+};
+//#endregion
+export { ErrorManager };

package/dist/managers/FindReplaceManager.d.ts

@@ -0,0 +1,54 @@
+import { document_d_exports } from "../types/document.js";
+import { FindMatchPosition } from "../prosemirror/findReplaceSelection.js";
+
+//#region src/managers/FindReplaceManager.d.ts
+type FindDirection = "next" | "previous";
+type FindReplaceResult<TMatch> = {
+  matches: TMatch[];
+  totalCount: number;
+  currentIndex: number;
+};
+type ReplaceAllOutcome = {
+  document: document_d_exports.Document;
+  replacedCount: number;
+};
+/**
+ * The cursor index after stepping `direction` over `totalCount` matches,
+ * wrapping at both ends. Returns 0 when there are no matches.
+ */
+declare const getAdjacentFindIndex: (currentIndex: number, totalCount: number, direction: FindDirection) => number;
+declare class FindReplaceManager<TMatch extends FindMatchPosition> {
+  private result;
+  /** The active find result, or null when there is no active search. */
+  getResult(): FindReplaceResult<TMatch> | null;
+  /** Discard the active search. */
+  clear(): void;
+  /**
+   * Store a fresh set of matches as the active result, with the cursor on the
+   * first match. The result is kept even when `matches` is empty so callers can
+   * surface a "no results" state.
+   */
+  setMatches(matches: TMatch[]): FindReplaceResult<TMatch>;
+  /**
+   * Step the cursor and return the now-current match with its index, or null
+   * when there are no matches to navigate.
+   */
+  navigate(direction: FindDirection): {
+    match: TMatch;
+    index: number;
+  } | null;
+  /**
+   * Replace the current match's text. Returns the new document, or null when
+   * there is no current match or the replace fails.
+   */
+  replaceCurrent(document: document_d_exports.Document, replaceText: string): document_d_exports.Document | null;
+  /**
+   * Replace every match. Matches are replaced from the end of the document
+   * backwards so earlier offsets stay valid as the text shifts. Clears the
+   * active result and returns the new document plus the match count, or null
+   * when there is nothing to replace.
+   */
+  replaceAll(document: document_d_exports.Document, matches: readonly TMatch[], replaceText: string): ReplaceAllOutcome | null;
+}
+//#endregion
+export { FindDirection, FindReplaceManager, FindReplaceResult, ReplaceAllOutcome, getAdjacentFindIndex };

package/dist/managers/FindReplaceManager.js

@@ -0,0 +1,104 @@
+import { replaceTextInDocument } from "../utils/replaceText.js";
+//#region src/managers/FindReplaceManager.ts
+/**
+* The cursor index after stepping `direction` over `totalCount` matches,
+* wrapping at both ends. Returns 0 when there are no matches.
+*/
+const getAdjacentFindIndex = (currentIndex, totalCount, direction) => {
+	if (totalCount <= 0) return 0;
+	if (direction === "previous") return currentIndex === 0 ? totalCount - 1 : currentIndex - 1;
+	return (currentIndex + 1) % totalCount;
+};
+const toReplaceRange = (match) => ({
+	start: {
+		paragraphIndex: match.paragraphIndex,
+		offset: match.startOffset
+	},
+	end: {
+		paragraphIndex: match.paragraphIndex,
+		offset: match.endOffset
+	}
+});
+var FindReplaceManager = class {
+	result = null;
+	/** The active find result, or null when there is no active search. */
+	getResult() {
+		return this.result;
+	}
+	/** Discard the active search. */
+	clear() {
+		this.result = null;
+	}
+	/**
+	* Store a fresh set of matches as the active result, with the cursor on the
+	* first match. The result is kept even when `matches` is empty so callers can
+	* surface a "no results" state.
+	*/
+	setMatches(matches) {
+		this.result = {
+			matches,
+			totalCount: matches.length,
+			currentIndex: 0
+		};
+		return this.result;
+	}
+	/**
+	* Step the cursor and return the now-current match with its index, or null
+	* when there are no matches to navigate.
+	*/
+	navigate(direction) {
+		const result = this.result;
+		if (!result || result.matches.length === 0) return null;
+		const index = getAdjacentFindIndex(result.currentIndex, result.matches.length, direction);
+		this.result = {
+			...result,
+			currentIndex: index
+		};
+		const match = result.matches[index];
+		return match ? {
+			match,
+			index
+		} : null;
+	}
+	/**
+	* Replace the current match's text. Returns the new document, or null when
+	* there is no current match or the replace fails.
+	*/
+	replaceCurrent(document, replaceText) {
+		const result = this.result;
+		if (!result || result.matches.length === 0) return null;
+		const match = result.matches[result.currentIndex];
+		if (!match) return null;
+		try {
+			return replaceTextInDocument(document, toReplaceRange(match), replaceText);
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Replace every match. Matches are replaced from the end of the document
+	* backwards so earlier offsets stay valid as the text shifts. Clears the
+	* active result and returns the new document plus the match count, or null
+	* when there is nothing to replace.
+	*/
+	replaceAll(document, matches, replaceText) {
+		if (matches.length === 0) return null;
+		const sortedMatches = [...matches].toSorted((a, b) => {
+			if (a.paragraphIndex !== b.paragraphIndex) return b.paragraphIndex - a.paragraphIndex;
+			return b.startOffset - a.startOffset;
+		});
+		let nextDocument = document;
+		for (const match of sortedMatches) try {
+			nextDocument = replaceTextInDocument(nextDocument, toReplaceRange(match), replaceText);
+		} catch {
+			continue;
+		}
+		this.result = null;
+		return {
+			document: nextDocument,
+			replacedCount: matches.length
+		};
+	}
+};
+//#endregion
+export { FindReplaceManager, getAdjacentFindIndex };