@stll/folio-core 0.10.0 → 0.11.0

package/dist/controller/collaborationModules.d.ts

@@ -0,0 +1,7 @@
+import { CollaborationModules } from "./hiddenEditorManager.js";
+
+//#region src/controller/collaborationModules.d.ts
+/** Lazily load and cache the optional collaboration runtime shared by adapters. */
+declare const loadCollaborationModules: () => Promise<CollaborationModules>;
+//#endregion
+export { loadCollaborationModules };

package/dist/controller/collaborationModules.js

@@ -0,0 +1,15 @@
+//#region src/controller/collaborationModules.ts
+let collaborationModulesPromise = null;
+/** Lazily load and cache the optional collaboration runtime shared by adapters. */
+const loadCollaborationModules = () => {
+	collaborationModulesPromise ??= Promise.all([import("y-prosemirror"), import("yjs")]).then(([yProseMirror, yjs]) => ({
+		yProseMirror,
+		yjs
+	})).catch((error) => {
+		collaborationModulesPromise = null;
+		throw error;
+	});
+	return collaborationModulesPromise;
+};
+//#endregion
+export { loadCollaborationModules };

package/dist/controller/folioEditor.d.ts

@@ -1,6 +1,6 @@
 import { Layout } from "../layout-engine/types.js";
-import { FolioEditorEmitter } from "./folioEditorEvents.js";
 import { HiddenEditorApi } from "./hiddenEditorApi.js";
+import { FolioEditorEmitter } from "./folioEditorEvents.js";
 import { LayoutRunOptions } from "./layoutScheduler.js";
 import { EditorState } from "prosemirror-state";
 

package/dist/controller/headerFooterEditorManager.d.ts

@@ -0,0 +1,41 @@
+import { document_d_exports } from "../types/document.js";
+import { EditorView } from "prosemirror-view";
+
+//#region src/controller/headerFooterEditorManager.d.ts
+type HeaderFooterPartKind = "header" | "footer";
+type HeaderFooterPartKey = {
+  kind: HeaderFooterPartKind;
+  rId: string;
+};
+type HeaderFooterEditorTransaction = {
+  docChanged: boolean;
+  kind: HeaderFooterPartKind;
+  rId: string;
+  selectionChanged: boolean;
+  view: EditorView;
+};
+type HeaderFooterEditorManagerDeps = {
+  getDocument: () => document_d_exports.Document | null;
+  getHost: () => HTMLElement | null;
+  getStyles: () => document_d_exports.StyleDefinitions | null | undefined;
+  getTheme: () => document_d_exports.Theme | null | undefined;
+  onTransaction?: ((transaction: HeaderFooterEditorTransaction) => void) | undefined;
+};
+type HeaderFooterEditorManager = {
+  destroy: () => void;
+  getView: (rId: string) => EditorView | null;
+  listSlots: () => HeaderFooterPartKey[];
+  snapshotDocument: (document: document_d_exports.Document) => document_d_exports.Document;
+  sync: () => void;
+};
+declare const enumerateHeaderFooterParts: ({
+  headers,
+  footers
+}: {
+  headers: Map<string, document_d_exports.HeaderFooter> | undefined;
+  footers: Map<string, document_d_exports.HeaderFooter> | undefined;
+}) => HeaderFooterPartKey[];
+declare const enumerateDocumentHeaderFooterParts: (document: document_d_exports.Document | null) => HeaderFooterPartKey[];
+declare const createHeaderFooterEditorManager: (deps: HeaderFooterEditorManagerDeps) => HeaderFooterEditorManager;
+//#endregion
+export { HeaderFooterEditorManager, HeaderFooterEditorManagerDeps, HeaderFooterEditorTransaction, HeaderFooterPartKey, HeaderFooterPartKind, createHeaderFooterEditorManager, enumerateDocumentHeaderFooterParts, enumerateHeaderFooterParts };

package/dist/controller/headerFooterEditorManager.js

@@ -0,0 +1,182 @@
+import { clearHeaderFooterVerbatimXml } from "../docx/headerFooterVerbatim.js";
+import { proseDocToBlocks } from "../prosemirror/conversion/fromProseDoc.js";
+import { ExtensionManager } from "../prosemirror/extensions/ExtensionManager.js";
+import { ensureBaseDirectionInState } from "../prosemirror/extensions/features/AutoBidiDetectionExtension.js";
+import { createDocumentStylesPlugin } from "../prosemirror/plugins/documentStyles.js";
+import { ensureParaIdsInState } from "../prosemirror/extensions/features/ParaIdAllocatorExtension.js";
+import { createStarterKit } from "../prosemirror/extensions/StarterKit.js";
+import { schema } from "../prosemirror/schema/index.js";
+import { headerFooterToProseDoc } from "../prosemirror/conversion/toProseDoc.js";
+import { EditorState } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+//#region src/controller/headerFooterEditorManager.ts
+/**
+* Framework-neutral lifecycle owner for persistent header/footer EditorViews.
+*
+* Each distinct relationship id owns one off-screen ProseMirror view. Painted
+* header/footer instances that share that relationship therefore share live
+* editor state, and adapters only decide when to synchronize or destroy the
+* manager.
+*/
+const buildInitialState = (headerFooter, styles, theme, manager) => {
+	const proseDocOptions = {};
+	if (styles) proseDocOptions.styles = styles;
+	if (theme !== void 0) proseDocOptions.theme = theme;
+	const document = headerFooterToProseDoc(headerFooter.content, proseDocOptions);
+	return ensureBaseDirectionInState(ensureParaIdsInState(EditorState.create({
+		doc: document,
+		schema,
+		plugins: [...manager.getPlugins(), createDocumentStylesPlugin(styles)]
+	})));
+};
+const enumerateHeaderFooterParts = ({ headers, footers }) => {
+	const parts = [];
+	if (headers) for (const rId of headers.keys()) parts.push({
+		kind: "header",
+		rId
+	});
+	if (footers) {
+		for (const rId of footers.keys()) if (!headers?.has(rId)) parts.push({
+			kind: "footer",
+			rId
+		});
+	}
+	return parts;
+};
+const enumerateDocumentHeaderFooterParts = (document) => {
+	if (!document?.package) return [];
+	return enumerateHeaderFooterParts({
+		headers: document.package.headers,
+		footers: document.package.footers
+	});
+};
+const resolveHeaderFooter = (document, { kind, rId }) => {
+	return (kind === "header" ? document?.package.headers : document?.package.footers)?.get(rId) ?? null;
+};
+const createHeaderFooterEditorManager = (deps) => {
+	const mounted = /* @__PURE__ */ new Map();
+	const destroyMounted = (part) => {
+		part.view.destroy();
+		part.manager.destroy();
+		part.mountNode.remove();
+	};
+	const destroy = () => {
+		for (const part of mounted.values()) destroyMounted(part);
+		mounted.clear();
+	};
+	const sync = () => {
+		const host = deps.getHost();
+		if (!host) return;
+		const document = deps.getDocument();
+		const styles = deps.getStyles();
+		const theme = deps.getTheme();
+		const wanted = new Map(enumerateDocumentHeaderFooterParts(document).map((part) => [part.rId, part]));
+		for (const [rId, part] of mounted) {
+			if (wanted.has(rId)) continue;
+			destroyMounted(part);
+			mounted.delete(rId);
+		}
+		for (const part of wanted.values()) {
+			const headerFooter = resolveHeaderFooter(document, part);
+			if (!headerFooter) continue;
+			const existing = mounted.get(part.rId);
+			if (existing) {
+				if (existing.mountNode.parentElement !== host) host.append(existing.mountNode);
+				const contentIsCurrent = existing.appliedHeaderFooter === headerFooter && existing.appliedContent === headerFooter.content;
+				const contextIsCurrent = existing.appliedStyles === styles && existing.appliedTheme === theme;
+				if (contentIsCurrent && contextIsCurrent) continue;
+				existing.view.updateState(buildInitialState(headerFooter, styles, theme, existing.manager));
+				existing.appliedHeaderFooter = headerFooter;
+				existing.appliedContent = headerFooter.content;
+				existing.appliedStyles = styles;
+				existing.appliedTheme = theme;
+				existing.dirty = false;
+				continue;
+			}
+			const manager = new ExtensionManager(createStarterKit());
+			manager.buildSchema();
+			manager.initializeRuntime();
+			const mountNode = host.ownerDocument.createElement("div");
+			mountNode.dataset["hfRId"] = part.rId;
+			mountNode.dataset["hfKind"] = part.kind;
+			host.append(mountNode);
+			const view = new EditorView(mountNode, {
+				state: buildInitialState(headerFooter, styles, theme, manager),
+				dispatchTransaction(transaction) {
+					const nextState = view.state.apply(transaction);
+					view.updateState(nextState);
+					const mountedPart = mounted.get(part.rId);
+					if (mountedPart && transaction.docChanged) mountedPart.dirty = true;
+					deps.onTransaction?.({
+						docChanged: transaction.docChanged,
+						kind: part.kind,
+						rId: part.rId,
+						selectionChanged: transaction.selectionSet,
+						view
+					});
+				}
+			});
+			mounted.set(part.rId, {
+				appliedContent: headerFooter.content,
+				appliedHeaderFooter: headerFooter,
+				appliedStyles: styles,
+				appliedTheme: theme,
+				dirty: false,
+				kind: part.kind,
+				manager,
+				mountNode,
+				rId: part.rId,
+				view
+			});
+		}
+	};
+	return {
+		destroy,
+		getView: (rId) => mounted.get(rId)?.view ?? null,
+		listSlots: () => [...mounted.values()].map(({ kind, rId }) => ({
+			kind,
+			rId
+		})),
+		snapshotDocument: (document) => {
+			let headers = document.package.headers;
+			let footers = document.package.footers;
+			let headersChanged = false;
+			let footersChanged = false;
+			for (const { dirty, kind, rId, view } of mounted.values()) {
+				if (!dirty) continue;
+				const source = kind === "header" ? headers : footers;
+				const existing = source?.get(rId);
+				if (!source || !existing) continue;
+				const updated = {
+					...existing,
+					content: proseDocToBlocks(view.state.doc)
+				};
+				clearHeaderFooterVerbatimXml(updated);
+				if (kind === "header") {
+					if (!headersChanged) {
+						headers = new Map(headers);
+						headersChanged = true;
+					}
+					headers?.set(rId, updated);
+				} else {
+					if (!footersChanged) {
+						footers = new Map(footers);
+						footersChanged = true;
+					}
+					footers?.set(rId, updated);
+				}
+			}
+			if (!headersChanged && !footersChanged) return document;
+			const packageWithSnapshots = { ...document.package };
+			if (headersChanged && headers) packageWithSnapshots.headers = headers;
+			if (footersChanged && footers) packageWithSnapshots.footers = footers;
+			return {
+				...document,
+				package: packageWithSnapshots
+			};
+		},
+		sync
+	};
+};
+//#endregion
+export { createHeaderFooterEditorManager, enumerateDocumentHeaderFooterParts, enumerateHeaderFooterParts };

package/dist/controller/hiddenEditorManager.d.ts

@@ -1,7 +1,7 @@
 import { document_d_exports } from "../types/document.js";
-import { HiddenEditorApi } from "./hiddenEditorApi.js";
 import { HiddenEditorStateReason } from "../layout-engine/layoutInstrumentation.js";
 import { ExtensionManager } from "../prosemirror/extensions/ExtensionManager.js";
+import { HiddenEditorApi } from "./hiddenEditorApi.js";
 import { EditorState, Plugin, Transaction } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 import * as YProseMirror from "y-prosemirror";

package/dist/managers/FindReplaceManager.d.ts

@@ -37,6 +37,14 @@ declare class FindReplaceManager<TMatch extends FindMatchPosition> {
     match: TMatch;
     index: number;
   } | null;
+  /**
+   * Move the cursor to an explicit match index. Returns the selected match, or
+   * null when there is no active result or the index is out of bounds.
+   */
+  goTo(index: number): {
+    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.

package/dist/managers/FindReplaceManager.js

@@ -61,6 +61,24 @@ var FindReplaceManager = class {
 		} : null;
 	}
 	/**
+	* Move the cursor to an explicit match index. Returns the selected match, or
+	* null when there is no active result or the index is out of bounds.
+	*/
+	goTo(index) {
+		const result = this.result;
+		if (!result || index < 0 || index >= result.matches.length) return null;
+		const match = result.matches.at(index);
+		if (!match) return null;
+		this.result = {
+			...result,
+			currentIndex: index
+		};
+		return {
+			match,
+			index
+		};
+	}
+	/**
 	* Replace the current match's text. Returns the new document, or null when
 	* there is no current match or the replace fails.
 	*/

package/dist/managers/TableSelectionManager.d.ts

@@ -52,6 +52,12 @@ type TableActionResult = {
 };
 declare class TableSelectionManager extends Subscribable<TableSelectionState> {
   constructor();
+  /**
+   * Track cell coordinates before a document model is available. This supports
+   * adapter pointer state without fabricating a table context; callers that
+   * need structural operations should use {@link selectCell} with a document.
+   */
+  selectCellCoordinates(coords: CellCoordinates): void;
   /**
    * Select a cell within `doc`. Resolves the table at `coords.tableIndex` and
    * derives the full {@link TableContext}. Returns the context, or `null` (and

package/dist/managers/TableSelectionManager.js

@@ -107,6 +107,20 @@ var TableSelectionManager = class extends Subscribable {
 		super(EMPTY_SELECTION);
 	}
 	/**
+	* Track cell coordinates before a document model is available. This supports
+	* adapter pointer state without fabricating a table context; callers that
+	* need structural operations should use {@link selectCell} with a document.
+	*/
+	selectCellCoordinates(coords) {
+		this.setSnapshot({
+			context: null,
+			table: null,
+			tableIndex: coords.tableIndex,
+			rowIndex: coords.rowIndex,
+			columnIndex: coords.columnIndex
+		});
+	}
+	/**
 	* Select a cell within `doc`. Resolves the table at `coords.tableIndex` and
 	* derives the full {@link TableContext}. Returns the context, or `null` (and
 	* clears the selection) when that table no longer exists.

package/dist/prosemirror/findReplaceSelection.d.ts

@@ -1,3 +1,4 @@
+import { FindOptions } from "../utils/findReplace.js";
 import { Node } from "prosemirror-model";
 
 //#region src/prosemirror/findReplaceSelection.d.ts
@@ -18,6 +19,10 @@ type FindMatchRange = {
   from: number;
   to: number;
 };
+type ProseMirrorFindMatch = FindMatchPosition & FindMatchRange & {
+  text: string;
+};
 declare function resolveFindMatchRange(doc: Node, match: FindMatchPosition): FindMatchRange | null;
+declare function findInProseMirrorDocument(doc: Node, searchText: string, options: FindOptions): ProseMirrorFindMatch[];
 //#endregion
-export { FindMatchPosition, FindMatchRange, resolveFindMatchRange };
+export { FindMatchPosition, FindMatchRange, ProseMirrorFindMatch, findInProseMirrorDocument, resolveFindMatchRange };

package/dist/prosemirror/findReplaceSelection.js

@@ -1,29 +1,55 @@
+import { findAllMatches } from "../utils/findReplace.js";
 //#region src/prosemirror/findReplaceSelection.ts
 function resolveFindMatchRange(doc, match) {
-	let paragraphIndex = 0;
 	let resolved = null;
-	const visitParagraph = (node, pos) => {
-		if (resolved) return false;
-		if (paragraphIndex !== match.paragraphIndex) {
-			paragraphIndex++;
-			return true;
-		}
+	forEachSearchParagraph(doc, (paragraph, paragraphPos, paragraphIndex) => {
+		if (paragraphIndex !== match.paragraphIndex) return true;
 		resolved = resolveTextRangeInParagraph({
-			paragraph: node,
-			paragraphPos: pos,
+			paragraph,
+			paragraphPos,
 			startOffset: match.startOffset,
 			endOffset: match.endOffset
 		});
 		return false;
-	};
+	});
+	return resolved;
+}
+function findInProseMirrorDocument(doc, searchText, options) {
+	if (!searchText) return [];
+	const matches = [];
+	forEachSearchParagraph(doc, (paragraph, paragraphPos, paragraphIndex) => {
+		const text = getSearchableParagraphText(paragraph);
+		for (const { start, end } of findAllMatches(text, searchText, options)) {
+			const range = resolveTextRangeInParagraph({
+				paragraph,
+				paragraphPos,
+				startOffset: start,
+				endOffset: end
+			});
+			if (range) matches.push({
+				paragraphIndex,
+				startOffset: start,
+				endOffset: end,
+				text: text.slice(start, end),
+				...range
+			});
+		}
+		return true;
+	});
+	return matches;
+}
+function forEachSearchParagraph(doc, visit) {
+	let paragraphIndex = 0;
 	const walkBlocks = (container, contentStart) => {
 		let offset = 0;
 		for (let childIndex = 0; childIndex < container.childCount; childIndex++) {
 			const child = container.child(childIndex);
 			const childPos = contentStart + offset;
 			if (child.type.name === "paragraph") {
-				if (!visitParagraph(child, childPos)) return false;
+				if (!visit(child, childPos, paragraphIndex)) return false;
+				paragraphIndex++;
 			} else if (child.type.name === "table" && !walkTable(child, childPos)) return false;
+			else if (child.type.name === "blockSdt" && !walkBlocks(child, childPos + 1)) return false;
 			offset += child.nodeSize;
 		}
 		return true;
@@ -53,7 +79,6 @@ function resolveFindMatchRange(doc, match) {
 		return true;
 	};
 	walkBlocks(doc, 0);
-	return resolved;
 }
 function resolveTextRangeInParagraph({ paragraph, paragraphPos, startOffset, endOffset }) {
 	let textOffset = 0;
@@ -83,5 +108,24 @@ function getSearchTextTokenLength(node) {
 	if (node.type.name === "tab" || node.type.name === "hardBreak") return 1;
 	return 0;
 }
+function getSearchableParagraphText(paragraph) {
+	let text = "";
+	paragraph.descendants((node) => {
+		if (node.isText) {
+			text += node.text ?? "";
+			return false;
+		}
+		if (node.type.name === "tab") {
+			text += "	";
+			return false;
+		}
+		if (node.type.name === "hardBreak") {
+			text += "\n";
+			return false;
+		}
+		return true;
+	});
+	return text;
+}
 //#endregion
-export { resolveFindMatchRange };
+export { findInProseMirrorDocument, resolveFindMatchRange };

package/dist/render-dom/BodySelectionOverlay.d.ts

@@ -0,0 +1,31 @@
+import { EditorState } from "prosemirror-state";
+
+//#region src/render-dom/BodySelectionOverlay.d.ts
+type BodySelectionOverlayResult = {
+  type: "text";
+} | {
+  type: "image";
+  element: HTMLElement;
+  pmPos: number;
+};
+type SyncBodySelectionOverlayOptions = {
+  pagesContainer: HTMLElement;
+  state: EditorState;
+  zoom: number;
+  zIndex?: number;
+  caretColor?: string;
+  selectionColor?: string;
+};
+declare class BodySelectionOverlay {
+  clear(pagesContainer: HTMLElement): void;
+  sync({
+    pagesContainer,
+    state,
+    zoom,
+    zIndex,
+    caretColor,
+    selectionColor
+  }: SyncBodySelectionOverlayOptions): BodySelectionOverlayResult;
+}
+//#endregion
+export { BodySelectionOverlay, BodySelectionOverlayResult, SyncBodySelectionOverlayOptions };

package/dist/render-dom/BodySelectionOverlay.js

@@ -0,0 +1,76 @@
+import { findBodyPmAnchor } from "../layout-bridge/dom/findBodyPmSpans.js";
+import { applyCellSelectionHighlight } from "../layout-bridge/cellSelectionHighlight.js";
+import { findImageElement } from "../layout-painter/imageLayout.js";
+import { getCaretPositionFromDom, getSelectionRectsFromDom } from "../layout-bridge/dom/clickToPositionDom.js";
+import { NodeSelection } from "prosemirror-state";
+//#region src/render-dom/BodySelectionOverlay.ts
+/**
+* Imperative body-selection painter shared by framework adapters. The editable
+* ProseMirror view is hidden, so its caret, range selection, and table-cell
+* selection must be projected onto the paginated DOM.
+*/
+const CARET_CLASS = "folio-body-selection-caret";
+const RANGE_CLASS = "folio-body-selection-rect";
+const OWNED_OVERLAY_SELECTOR = `.${CARET_CLASS}, .${RANGE_CLASS}`;
+const setOverlayBox = (element, rect, pagesContainer, zoom) => {
+	const divisor = zoom > 0 ? zoom : 1;
+	element.style.left = `${rect.x / divisor + pagesContainer.scrollLeft}px`;
+	element.style.top = `${rect.y / divisor + pagesContainer.scrollTop}px`;
+	element.style.width = `${rect.width / divisor}px`;
+	element.style.height = `${rect.height / divisor}px`;
+};
+var BodySelectionOverlay = class {
+	clear(pagesContainer) {
+		for (const element of pagesContainer.querySelectorAll(OWNED_OVERLAY_SELECTOR)) element.remove();
+	}
+	sync({ pagesContainer, state, zoom, zIndex = 10, caretColor = "var(--doc-caret, #000)", selectionColor = "var(--doc-selection, rgba(66, 133, 244, 0.3))" }) {
+		this.clear(pagesContainer);
+		applyCellSelectionHighlight(pagesContainer, state);
+		const { selection } = state;
+		if (selection instanceof NodeSelection && selection.node.type.name === "image") {
+			const anchor = findBodyPmAnchor(pagesContainer, selection.from);
+			const element = anchor ? findImageElement(anchor) : null;
+			if (element) return {
+				type: "image",
+				element,
+				pmPos: selection.from
+			};
+		}
+		if (selection.empty) {
+			const caret = getCaretPositionFromDom(pagesContainer, selection.from, pagesContainer.getBoundingClientRect());
+			if (!caret) return { type: "text" };
+			const element = pagesContainer.ownerDocument.createElement("div");
+			element.className = CARET_CLASS;
+			element.dataset["folioCaretRect"] = "";
+			element.style.position = "absolute";
+			element.style.background = caretColor;
+			element.style.pointerEvents = "none";
+			element.style.zIndex = String(zIndex);
+			element.style.animation = "folio-caret-blink 1060ms steps(1, end) infinite";
+			setOverlayBox(element, {
+				x: caret.x,
+				y: caret.y,
+				width: 2 * (zoom > 0 ? zoom : 1),
+				height: caret.height
+			}, pagesContainer, zoom);
+			pagesContainer.appendChild(element);
+			return { type: "text" };
+		}
+		const rects = getSelectionRectsFromDom(pagesContainer, selection.from, selection.to, pagesContainer.getBoundingClientRect());
+		for (const rect of rects) {
+			const element = pagesContainer.ownerDocument.createElement("div");
+			element.className = RANGE_CLASS;
+			element.dataset["folioSelectionRect"] = "";
+			element.dataset["pageIndex"] = String(rect.pageIndex);
+			element.style.position = "absolute";
+			element.style.background = selectionColor;
+			element.style.pointerEvents = "none";
+			element.style.zIndex = String(zIndex);
+			setOverlayBox(element, rect, pagesContainer, zoom);
+			pagesContainer.appendChild(element);
+		}
+		return { type: "text" };
+	}
+};
+//#endregion
+export { BodySelectionOverlay };

package/dist/render-dom/HeaderFooterSelectionOverlay.d.ts

@@ -0,0 +1,28 @@
+import { HfSlotKind } from "../layout-bridge/dom/findHfPmSpans.js";
+
+//#region src/render-dom/HeaderFooterSelectionOverlay.d.ts
+type HeaderFooterSelection = {
+  from: number;
+  kind: HfSlotKind;
+  pageNumber?: number;
+  rId: string;
+  to: number;
+};
+type HeaderFooterSelectionRect = {
+  height: number;
+  width: number;
+  x: number;
+  y: number;
+};
+type HeaderFooterSelectionGeometry = {
+  caret: Omit<HeaderFooterSelectionRect, "width"> | null;
+  ranges: HeaderFooterSelectionRect[];
+};
+/** Resolve a persistent header/footer PM selection against its painted DOM. */
+declare const resolveHeaderFooterSelectionGeometry: (pagesContainer: HTMLElement, selection: HeaderFooterSelection, zoom: number) => HeaderFooterSelectionGeometry;
+declare class HeaderFooterSelectionOverlay {
+  clear(pagesContainer: HTMLElement): void;
+  sync(pagesContainer: HTMLElement, selection: HeaderFooterSelection | null, zoom: number): void;
+}
+//#endregion
+export { HeaderFooterSelection, HeaderFooterSelectionGeometry, HeaderFooterSelectionOverlay, HeaderFooterSelectionRect, resolveHeaderFooterSelectionGeometry };

package/dist/render-dom/HeaderFooterSelectionOverlay.js

@@ -0,0 +1,121 @@
+import { findHfCaretSpan, findHfPmSpans } from "../layout-bridge/dom/findHfPmSpans.js";
+//#region src/render-dom/HeaderFooterSelectionOverlay.ts
+const CARET_CLASS = "folio-hf-selection-caret";
+const RANGE_CLASS = "folio-hf-selection-rect";
+const OWNED_SELECTOR = `.${CARET_CLASS}, .${RANGE_CLASS}`;
+const TEXT_NODE_TYPE = 3;
+const relativeRect = (rect, containerRect, zoom) => ({
+	x: (rect.left - containerRect.left) / zoom,
+	y: (rect.top - containerRect.top) / zoom,
+	width: rect.width / zoom,
+	height: rect.height / zoom
+});
+/** Resolve a persistent header/footer PM selection against its painted DOM. */
+const resolveHeaderFooterSelectionGeometry = (pagesContainer, selection, zoom) => {
+	const containerRect = pagesContainer.getBoundingClientRect();
+	const zoomDivisor = zoom === 0 ? 1 : zoom;
+	const pageScope = selection.pageNumber ? pagesContainer.querySelector(`.layout-page[data-page-number="${selection.pageNumber}"]`) ?? pagesContainer : pagesContainer;
+	if (selection.from === selection.to) {
+		const hit = findHfCaretSpan(pageScope, selection.kind, selection.rId, selection.from);
+		if (!hit) return {
+			caret: null,
+			ranges: []
+		};
+		const anchorRect = hit.element.getBoundingClientRect();
+		let left = hit.edge === "right" ? anchorRect.right : anchorRect.left;
+		let top = anchorRect.top;
+		let height = anchorRect.height || 16;
+		const pmStart = Number.parseInt(hit.element.dataset["pmStart"] ?? "", 10);
+		const pmEnd = Number.parseInt(hit.element.dataset["pmEnd"] ?? "", 10);
+		const textNode = hit.element.firstChild;
+		if (textNode?.nodeType === TEXT_NODE_TYPE && Number.isFinite(pmStart) && Number.isFinite(pmEnd)) {
+			const offset = Math.min(Math.max(0, selection.from - pmStart), textNode.textContent?.length ?? 0);
+			const range = hit.element.ownerDocument.createRange();
+			range.setStart(textNode, offset);
+			range.setEnd(textNode, offset);
+			const rangeRect = range.getBoundingClientRect();
+			if (rangeRect.height > 0 || rangeRect.width > 0 || rangeRect.left > 0) {
+				left = rangeRect.left;
+				top = rangeRect.top;
+				height = rangeRect.height || height;
+			}
+		}
+		return {
+			caret: {
+				x: (left - containerRect.left) / zoomDivisor,
+				y: (top - containerRect.top) / zoomDivisor,
+				height: height / zoomDivisor
+			},
+			ranges: []
+		};
+	}
+	const from = Math.min(selection.from, selection.to);
+	const to = Math.max(selection.from, selection.to);
+	const ranges = [];
+	for (const span of findHfPmSpans(pageScope, selection.kind, selection.rId)) {
+		const spanStart = Number.parseInt(span.dataset["pmStart"] ?? "", 10);
+		const spanEnd = Number.parseInt(span.dataset["pmEnd"] ?? "", 10);
+		if (!Number.isFinite(spanStart) || !Number.isFinite(spanEnd)) continue;
+		if (spanEnd <= from || spanStart >= to) continue;
+		const textNode = span.firstChild;
+		if (textNode?.nodeType === TEXT_NODE_TYPE) {
+			const length = textNode.textContent?.length ?? 0;
+			const startOffset = Math.max(0, from - spanStart);
+			const endOffset = Math.min(length, to - spanStart);
+			if (startOffset < endOffset) {
+				const range = span.ownerDocument.createRange();
+				range.setStart(textNode, startOffset);
+				range.setEnd(textNode, endOffset);
+				for (const rect of Array.from(range.getClientRects())) ranges.push(relativeRect(rect, containerRect, zoomDivisor));
+				continue;
+			}
+		}
+		ranges.push(relativeRect(span.getBoundingClientRect(), containerRect, zoomDivisor));
+	}
+	return {
+		caret: null,
+		ranges
+	};
+};
+const createOverlayElement = (pagesContainer, className) => {
+	const element = pagesContainer.ownerDocument.createElement("div");
+	element.className = className;
+	element.style.position = "absolute";
+	element.style.pointerEvents = "none";
+	return element;
+};
+var HeaderFooterSelectionOverlay = class {
+	clear(pagesContainer) {
+		for (const element of pagesContainer.querySelectorAll(OWNED_SELECTOR)) element.remove();
+	}
+	sync(pagesContainer, selection, zoom) {
+		this.clear(pagesContainer);
+		if (!selection) return;
+		const geometry = resolveHeaderFooterSelectionGeometry(pagesContainer, selection, zoom);
+		for (const rect of geometry.ranges) {
+			const element = createOverlayElement(pagesContainer, RANGE_CLASS);
+			element.dataset["testid"] = "hf-selection-rect";
+			element.style.left = `${rect.x}px`;
+			element.style.top = `${rect.y}px`;
+			element.style.width = `${rect.width}px`;
+			element.style.height = `${rect.height}px`;
+			element.style.background = "var(--doc-selection, rgba(66, 133, 244, 0.3))";
+			element.style.opacity = "0.35";
+			element.style.zIndex = "10";
+			pagesContainer.append(element);
+		}
+		if (!geometry.caret) return;
+		const caret = createOverlayElement(pagesContainer, CARET_CLASS);
+		caret.dataset["testid"] = "hf-caret";
+		caret.style.left = `${geometry.caret.x}px`;
+		caret.style.top = `${geometry.caret.y}px`;
+		caret.style.width = "2px";
+		caret.style.height = `${geometry.caret.height}px`;
+		caret.style.background = "var(--doc-canvas-text, #000)";
+		caret.style.zIndex = "11";
+		caret.style.animation = "folio-caret-blink 1060ms steps(1, end) infinite";
+		pagesContainer.append(caret);
+	}
+};
+//#endregion
+export { HeaderFooterSelectionOverlay, resolveHeaderFooterSelectionGeometry };

package/dist/render-dom/RemoteSelectionOverlay.d.ts

@@ -0,0 +1,30 @@
+import { HiddenProseMirrorRemoteSelection } from "../controller/hiddenEditorManager.js";
+import { RenderedDomContext, RenderedDomPoint, RenderedDomRect } from "./RenderedDomContext.js";
+
+//#region src/render-dom/RemoteSelectionOverlay.d.ts
+type SyncRemoteSelectionOverlayOptions = {
+  pagesContainer: HTMLElement;
+  selections: readonly HiddenProseMirrorRemoteSelection[];
+  zoom: number;
+  zIndex?: number;
+  renderedDomContext?: RenderedDomContext;
+};
+type RemoteSelectionOverlayGeometry = {
+  caret: RenderedDomPoint | null;
+  rects: RenderedDomRect[];
+  selection: HiddenProseMirrorRemoteSelection;
+};
+declare const resolveRemoteSelectionOverlayGeometry: (renderedDomContext: RenderedDomContext, selections: readonly HiddenProseMirrorRemoteSelection[]) => RemoteSelectionOverlayGeometry[];
+/** Paint collaborative cursors and selections over the rendered page DOM. */
+declare class RemoteSelectionOverlay {
+  clear(pagesContainer: HTMLElement): void;
+  sync({
+    pagesContainer,
+    selections,
+    zoom,
+    zIndex,
+    renderedDomContext
+  }: SyncRemoteSelectionOverlayOptions): void;
+}
+//#endregion
+export { RemoteSelectionOverlay, RemoteSelectionOverlayGeometry, SyncRemoteSelectionOverlayOptions, resolveRemoteSelectionOverlayGeometry };

package/dist/render-dom/RemoteSelectionOverlay.js

@@ -0,0 +1,67 @@
+import { createRenderedDomContext } from "./RenderedDomContext.js";
+//#region src/render-dom/RemoteSelectionOverlay.ts
+const CARET_CLASS = "folio-remote-selection-caret";
+const LABEL_CLASS = "folio-remote-selection-label";
+const RANGE_CLASS = "folio-remote-selection-rect";
+const OWNED_OVERLAY_SELECTOR = `.${CARET_CLASS}, .${LABEL_CLASS}, .${RANGE_CLASS}`;
+const resolveRemoteSelectionOverlayGeometry = (renderedDomContext, selections) => selections.map((selection) => ({
+	caret: renderedDomContext.getCoordinatesForPosition(selection.head),
+	rects: renderedDomContext.getRectsForRange(Math.min(selection.anchor, selection.head), Math.max(selection.anchor, selection.head)),
+	selection
+}));
+const setBox = (element, rect) => {
+	element.style.left = `${rect.x}px`;
+	element.style.top = `${rect.y}px`;
+	element.style.width = `${rect.width}px`;
+	element.style.height = `${rect.height}px`;
+};
+const createOverlayElement = (pagesContainer, className, zIndex) => {
+	const element = pagesContainer.ownerDocument.createElement("div");
+	element.className = className;
+	element.style.position = "absolute";
+	element.style.pointerEvents = "none";
+	element.style.zIndex = String(zIndex);
+	return element;
+};
+/** Paint collaborative cursors and selections over the rendered page DOM. */
+var RemoteSelectionOverlay = class {
+	clear(pagesContainer) {
+		for (const element of pagesContainer.querySelectorAll(OWNED_OVERLAY_SELECTOR)) element.remove();
+	}
+	sync({ pagesContainer, selections, zoom, zIndex = 20, renderedDomContext = createRenderedDomContext(pagesContainer, zoom) }) {
+		this.clear(pagesContainer);
+		for (const { caret, rects, selection } of resolveRemoteSelectionOverlayGeometry(renderedDomContext, selections)) {
+			for (const rect of rects) {
+				const element = createOverlayElement(pagesContainer, RANGE_CLASS, zIndex);
+				element.dataset["clientId"] = String(selection.clientId);
+				element.style.background = `color-mix(in srgb, ${selection.color} 24%, transparent)`;
+				setBox(element, rect);
+				pagesContainer.appendChild(element);
+			}
+			if (!caret) continue;
+			const caretElement = createOverlayElement(pagesContainer, CARET_CLASS, zIndex + 1);
+			caretElement.dataset["clientId"] = String(selection.clientId);
+			caretElement.style.background = selection.color;
+			setBox(caretElement, {
+				...caret,
+				width: 2
+			});
+			pagesContainer.appendChild(caretElement);
+			const label = createOverlayElement(pagesContainer, LABEL_CLASS, zIndex + 2);
+			label.dataset["clientId"] = String(selection.clientId);
+			label.textContent = selection.name;
+			label.style.background = selection.color;
+			label.style.color = "var(--background, #fff)";
+			label.style.fontSize = "10px";
+			label.style.lineHeight = "1";
+			label.style.padding = "2px 4px";
+			label.style.borderRadius = "2px";
+			label.style.left = `${caret.x}px`;
+			label.style.top = `${Math.max(0, caret.y - 18)}px`;
+			label.style.whiteSpace = "nowrap";
+			pagesContainer.appendChild(label);
+		}
+	}
+};
+//#endregion
+export { RemoteSelectionOverlay, resolveRemoteSelectionOverlayGeometry };

package/dist/render-dom/RenderedDomContext.d.ts

@@ -0,0 +1,40 @@
+//#region src/render-dom/RenderedDomContext.d.ts
+/**
+ * Framework-neutral mapping from ProseMirror positions to the DOM emitted by
+ * the layout painter. Framework adapters use this for decorations, anchored
+ * chrome, and plugin surfaces without duplicating range geometry.
+ */
+type RenderedDomPoint = {
+  x: number;
+  y: number;
+  height: number;
+};
+type RenderedDomRect = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+type RenderedDomContext = {
+  getCoordinatesForPosition(pmPos: number): RenderedDomPoint | null;
+  findElementsForRange(from: number, to: number): Element[];
+  getRectsForRange(from: number, to: number): RenderedDomRect[];
+  getContainerOffset(): {
+    x: number;
+    y: number;
+  };
+};
+declare class RenderedDomContextImpl implements RenderedDomContext {
+  #private;
+  constructor(pagesContainer: HTMLElement, zoom?: number);
+  getCoordinatesForPosition(pmPos: number): RenderedDomPoint | null;
+  findElementsForRange(from: number, to: number): Element[];
+  getRectsForRange(from: number, to: number): RenderedDomRect[];
+  getContainerOffset(): {
+    x: number;
+    y: number;
+  };
+}
+declare const createRenderedDomContext: (pagesContainer: HTMLElement, zoom?: number) => RenderedDomContext;
+//#endregion
+export { RenderedDomContext, RenderedDomContextImpl, RenderedDomPoint, RenderedDomRect, createRenderedDomContext };

package/dist/render-dom/RenderedDomContext.js

@@ -0,0 +1,126 @@
+import { findBodyEmptyRuns, findBodyPmSpans } from "../layout-bridge/dom/findBodyPmSpans.js";
+import { closestHtmlElement } from "../utils/domGuards.js";
+//#region src/render-dom/RenderedDomContext.ts
+/**
+* Framework-neutral mapping from ProseMirror positions to the DOM emitted by
+* the layout painter. Framework adapters use this for decorations, anchored
+* chrome, and plugin surfaces without duplicating range geometry.
+*/
+const isTextNode = (node) => node?.nodeType === Node.TEXT_NODE;
+const textNodeForSpan = (span) => {
+	const firstChild = span.firstChild;
+	if (isTextNode(firstChild)) return firstChild;
+	if (firstChild instanceof HTMLElement && firstChild.tagName === "A" && isTextNode(firstChild.firstChild)) return firstChild.firstChild;
+	return null;
+};
+const lineHeightFor = (element, zoom) => {
+	const line = closestHtmlElement(element, ".layout-line");
+	return line ? line.getBoundingClientRect().height / zoom : 16;
+};
+var RenderedDomContextImpl = class {
+	#pagesContainer;
+	#zoom;
+	constructor(pagesContainer, zoom = 1) {
+		this.#pagesContainer = pagesContainer;
+		this.#zoom = zoom > 0 ? zoom : 1;
+	}
+	getCoordinatesForPosition(pmPos) {
+		const containerRect = this.#pagesContainer.getBoundingClientRect();
+		for (const span of findBodyPmSpans(this.#pagesContainer)) {
+			const pmStart = Number(span.dataset["pmStart"]);
+			const pmEnd = Number(span.dataset["pmEnd"]);
+			if (!(span.classList.contains("layout-run-tab") ? pmPos >= pmStart && pmPos < pmEnd : pmPos >= pmStart && pmPos <= pmEnd)) continue;
+			const spanRect = span.getBoundingClientRect();
+			if (span.classList.contains("layout-run-tab")) return {
+				x: (spanRect.left - containerRect.left) / this.#zoom,
+				y: (spanRect.top - containerRect.top) / this.#zoom,
+				height: lineHeightFor(span, this.#zoom)
+			};
+			const textNode = textNodeForSpan(span);
+			if (!textNode) return {
+				x: (spanRect.left - containerRect.left) / this.#zoom,
+				y: (spanRect.top - containerRect.top) / this.#zoom,
+				height: lineHeightFor(span, this.#zoom)
+			};
+			const charIndex = Math.min(Math.max(0, pmPos - pmStart), textNode.length);
+			const range = span.ownerDocument.createRange();
+			range.setStart(textNode, charIndex);
+			range.setEnd(textNode, charIndex);
+			const rangeRect = range.getBoundingClientRect();
+			return {
+				x: (rangeRect.left - containerRect.left) / this.#zoom,
+				y: (rangeRect.top - containerRect.top) / this.#zoom,
+				height: lineHeightFor(span, this.#zoom)
+			};
+		}
+		for (const emptyRun of findBodyEmptyRuns(this.#pagesContainer)) {
+			const paragraph = closestHtmlElement(emptyRun, ".layout-paragraph");
+			if (!paragraph) continue;
+			const pmStart = Number(paragraph.dataset["pmStart"]);
+			const pmEnd = Number(paragraph.dataset["pmEnd"]);
+			if (pmPos < pmStart || pmPos > pmEnd) continue;
+			const rect = emptyRun.getBoundingClientRect();
+			return {
+				x: (rect.left - containerRect.left) / this.#zoom,
+				y: (rect.top - containerRect.top) / this.#zoom,
+				height: lineHeightFor(emptyRun, this.#zoom)
+			};
+		}
+		return null;
+	}
+	findElementsForRange(from, to) {
+		return findBodyPmSpans(this.#pagesContainer).filter((span) => {
+			const pmStart = Number(span.dataset["pmStart"]);
+			return Number(span.dataset["pmEnd"]) > from && pmStart < to;
+		});
+	}
+	getRectsForRange(from, to) {
+		const containerRect = this.#pagesContainer.getBoundingClientRect();
+		const rects = [];
+		for (const element of this.findElementsForRange(from, to)) {
+			if (!(element instanceof HTMLElement)) continue;
+			const pmStart = Number(element.dataset["pmStart"]);
+			if (element.classList.contains("layout-run-tab")) {
+				const rect = element.getBoundingClientRect();
+				rects.push({
+					x: (rect.left - containerRect.left) / this.#zoom,
+					y: (rect.top - containerRect.top) / this.#zoom,
+					width: rect.width / this.#zoom,
+					height: rect.height / this.#zoom
+				});
+				continue;
+			}
+			const textNode = textNodeForSpan(element);
+			if (!textNode) continue;
+			const startChar = Math.max(0, from - pmStart);
+			const endChar = Math.min(textNode.length, to - pmStart);
+			if (startChar >= endChar) continue;
+			const range = element.ownerDocument.createRange();
+			range.setStart(textNode, startChar);
+			range.setEnd(textNode, endChar);
+			for (const rect of Array.from(range.getClientRects())) rects.push({
+				x: (rect.left - containerRect.left) / this.#zoom,
+				y: (rect.top - containerRect.top) / this.#zoom,
+				width: rect.width / this.#zoom,
+				height: rect.height / this.#zoom
+			});
+		}
+		return rects;
+	}
+	getContainerOffset() {
+		const parent = this.#pagesContainer.parentElement;
+		if (!parent) return {
+			x: 0,
+			y: 0
+		};
+		const containerRect = this.#pagesContainer.getBoundingClientRect();
+		const parentRect = parent.getBoundingClientRect();
+		return {
+			x: (containerRect.left - parentRect.left) / this.#zoom,
+			y: (containerRect.top - parentRect.top) / this.#zoom
+		};
+	}
+};
+const createRenderedDomContext = (pagesContainer, zoom = 1) => new RenderedDomContextImpl(pagesContainer, zoom);
+//#endregion
+export { RenderedDomContextImpl, createRenderedDomContext };

package/dist/render-dom/resolveSidebarItemPositions.d.ts

@@ -0,0 +1,33 @@
+import { RenderedDomContext } from "./RenderedDomContext.js";
+
+//#region src/render-dom/resolveSidebarItemPositions.d.ts
+type RenderedSidebarItem = {
+  id: string;
+  anchorPos: number;
+  anchorKey?: string;
+  priority?: number;
+  fixedY?: number;
+  estimatedHeight?: number;
+};
+type ResolvedSidebarItemPosition<T extends RenderedSidebarItem = RenderedSidebarItem> = {
+  item: T;
+  y: number;
+};
+type ResolveSidebarItemPositionsOptions<T extends RenderedSidebarItem> = {
+  items: T[];
+  anchorPositions: Map<string, number>;
+  renderedDomContext: RenderedDomContext | null;
+  zoom: number;
+  cardHeights: Map<string, number>;
+  lastKnown: Map<string, number>;
+};
+declare const resolveSidebarItemPositions: <T extends RenderedSidebarItem>({
+  items,
+  anchorPositions,
+  renderedDomContext,
+  zoom,
+  cardHeights,
+  lastKnown
+}: ResolveSidebarItemPositionsOptions<T>) => ResolvedSidebarItemPosition<T>[];
+//#endregion
+export { RenderedSidebarItem, ResolveSidebarItemPositionsOptions, ResolvedSidebarItemPosition, resolveSidebarItemPositions };

package/dist/render-dom/resolveSidebarItemPositions.js

@@ -0,0 +1,45 @@
+//#region src/render-dom/resolveSidebarItemPositions.ts
+const MIN_CARD_GAP = 8;
+const resolveSidebarItemPositions = ({ items, anchorPositions, renderedDomContext, zoom, cardHeights, lastKnown }) => {
+	if (items.length === 0) return [];
+	const containerOffset = renderedDomContext?.getContainerOffset();
+	const positioned = [];
+	for (const item of items) {
+		let targetY;
+		if (item.fixedY !== void 0) targetY = item.fixedY * zoom;
+		if (targetY === void 0 && item.anchorKey !== void 0) {
+			const anchorY = anchorPositions.get(item.anchorKey);
+			if (anchorY !== void 0) targetY = anchorY * zoom;
+		}
+		if (targetY === void 0 && renderedDomContext && containerOffset) {
+			const rect = renderedDomContext.getRectsForRange(item.anchorPos, item.anchorPos + 1).at(0);
+			if (rect) targetY = (rect.y + containerOffset.y) * zoom;
+		}
+		if (targetY === void 0) targetY = lastKnown.get(item.id);
+		if (targetY === void 0) continue;
+		positioned.push({
+			item,
+			targetY
+		});
+		lastKnown.set(item.id, targetY);
+	}
+	positioned.sort((left, right) => {
+		const positionDifference = left.targetY - right.targetY;
+		if (positionDifference !== 0) return positionDifference;
+		return (left.item.priority ?? 0) - (right.item.priority ?? 0);
+	});
+	const resolved = [];
+	let previousBottom = 0;
+	for (const position of positioned) {
+		const height = cardHeights.get(position.item.id) ?? position.item.estimatedHeight ?? 80;
+		const y = Math.max(position.targetY, previousBottom + MIN_CARD_GAP);
+		resolved.push({
+			item: position.item,
+			y
+		});
+		previousBottom = y + height;
+	}
+	return resolved;
+};
+//#endregion
+export { resolveSidebarItemPositions };

package/dist/utils/findReplace.d.ts

@@ -0,0 +1,32 @@
+import { document_d_exports } from "../types/document.js";
+import { Paragraph } from "../types/content.js";
+
+//#region src/utils/findReplace.d.ts
+type FindMatch = {
+  paragraphIndex: number;
+  contentIndex: number;
+  startOffset: number;
+  endOffset: number;
+  text: string;
+};
+type FindOptions = {
+  matchCase: boolean;
+  matchWholeWord: boolean;
+  useRegex?: boolean;
+};
+type FindResult = {
+  matches: FindMatch[];
+  totalCount: number;
+  currentIndex: number;
+};
+declare const createDefaultFindOptions: () => FindOptions;
+declare const escapeRegexString: (value: string) => string;
+declare const createSearchPattern: (searchText: string, options: FindOptions) => RegExp | null;
+declare const findAllMatches: (content: string, searchText: string, options: FindOptions) => Array<{
+  start: number;
+  end: number;
+}>;
+declare const findInDocument: (document: document_d_exports.Document | null | undefined, searchText: string, options: FindOptions) => FindMatch[];
+declare const findInParagraph: (paragraph: Paragraph, searchText: string, options: FindOptions, paragraphIndex: number) => FindMatch[];
+//#endregion
+export { FindMatch, FindOptions, FindResult, createDefaultFindOptions, createSearchPattern, escapeRegexString, findAllMatches, findInDocument, findInParagraph };

package/dist/utils/findReplace.js

@@ -0,0 +1,118 @@
+//#region src/utils/findReplace.ts
+const createDefaultFindOptions = () => ({
+	matchCase: false,
+	matchWholeWord: false,
+	useRegex: false
+});
+const escapeRegexString = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+const createSearchPattern = (searchText, options) => {
+	if (!searchText) return null;
+	try {
+		const source = options.useRegex ? searchText : escapeRegexString(searchText);
+		const pattern = options.matchWholeWord ? `\\b${source}\\b` : source;
+		return new RegExp(pattern, options.matchCase ? "gu" : "giu");
+	} catch {
+		return null;
+	}
+};
+const findAllMatches = (content, searchText, options) => {
+	if (!content || !searchText) return [];
+	const searchFor = options.matchCase ? searchText : searchText.toLowerCase();
+	const source = escapeRegexString(searchFor);
+	const pattern = new RegExp(options.matchWholeWord ? `\\b${source}\\b` : source, options.matchCase ? "gu" : "giu");
+	const matches = [];
+	let match;
+	while ((match = pattern.exec(content)) !== null) {
+		matches.push({
+			start: match.index,
+			end: match.index + match[0].length
+		});
+		if (match[0].length === 0) pattern.lastIndex++;
+	}
+	return matches;
+};
+const findInDocument = (document, searchText, options) => {
+	if (!document || !searchText) return [];
+	const body = document.package.document;
+	if (!isRecord(body) || !Array.isArray(body.content)) return [];
+	const matches = [];
+	forEachParagraph(body.content, (paragraph, paragraphIndex) => {
+		matches.push(...findInParagraph(paragraph, searchText, options, paragraphIndex));
+	});
+	return matches;
+};
+const findInParagraph = (paragraph, searchText, options, paragraphIndex) => {
+	const paragraphText = getParagraphPlainText(paragraph);
+	if (!paragraphText) return [];
+	return findAllMatches(paragraphText, searchText, options).map(({ start, end }) => ({
+		paragraphIndex,
+		contentIndex: findContentIndexAtOffset(paragraph, start),
+		startOffset: start,
+		endOffset: end,
+		text: paragraphText.slice(start, end)
+	}));
+};
+const forEachParagraph = (blocks, visit) => {
+	let paragraphIndex = 0;
+	const walkBlocks = (items) => {
+		for (const block of items) {
+			if (isParagraph(block)) {
+				visit(block, paragraphIndex);
+				paragraphIndex++;
+				continue;
+			}
+			if (isTable(block)) {
+				walkTable(block);
+				continue;
+			}
+			if (isBlockSdt(block)) walkBlocks(block.content);
+		}
+	};
+	const walkTable = (table) => {
+		for (const row of table.rows) {
+			if (!isTableRow(row)) continue;
+			for (const cell of row.cells) if (isTableCell(cell)) walkBlocks(cell.content);
+		}
+	};
+	walkBlocks(blocks);
+};
+const getRunText = (run) => {
+	let text = "";
+	for (const item of run.content) if (item.type === "text") text += item.text;
+	else if (item.type === "tab") text += "	";
+	else if (item.type === "break" && item.breakType === "textWrapping") text += "\n";
+	return text;
+};
+const getHyperlinkText = (hyperlink) => {
+	let text = "";
+	for (const child of hyperlink.children) if (child.type === "run") text += getRunText(child);
+	return text;
+};
+const getParagraphContentText = (content) => {
+	if (content.type === "run") return getRunText(content);
+	if (content.type === "hyperlink") return getHyperlinkText(content);
+	if (content.type === "inlineSdt") return content.content.map(getParagraphContentText).join("");
+	if (content.type === "simpleField") return content.content.map((child) => child.type === "run" ? getRunText(child) : getHyperlinkText(child)).join("");
+	if (content.type === "complexField") return content.fieldResult.map(getRunText).join("");
+	return "";
+};
+const getParagraphPlainText = (paragraph) => paragraph.content.map(getParagraphContentText).join("");
+const findContentIndexAtOffset = (paragraph, offset) => {
+	let currentOffset = 0;
+	for (let contentIndex = 0; contentIndex < paragraph.content.length; contentIndex++) {
+		const item = paragraph.content[contentIndex];
+		if (!item) continue;
+		const itemLength = getParagraphContentText(item).length;
+		if (currentOffset + itemLength > offset) return contentIndex;
+		currentOffset += itemLength;
+	}
+	return Math.max(0, paragraph.content.length - 1);
+};
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isParagraph = (value) => isRecord(value) && value["type"] === "paragraph" && Array.isArray(value["content"]);
+const isTable = (value) => isRecord(value) && value["type"] === "table" && Array.isArray(value["rows"]);
+const isTableRow = (value) => isRecord(value) && Array.isArray(value["cells"]);
+const isTableCell = (value) => isRecord(value) && Array.isArray(value["content"]);
+const isBlockSdt = (value) => isRecord(value) && value["type"] === "blockSdt" && Array.isArray(value["content"]);
+//#endregion
+export { createDefaultFindOptions, createSearchPattern, escapeRegexString, findAllMatches, findInDocument, findInParagraph };

package/dist/utils/headerFooter.js

@@ -156,7 +156,18 @@ const createEmptyHeaderFooter = (document, position, isFirstPage) => {
 	const sectionProps = pkg.document.finalSectionProperties;
 	if (!sectionProps) return null;
 	const hdrFtrType = isFirstPage ? "first" : "default";
-	const rId = `rId_new_${position}_${hdrFtrType}`;
+	const baseRId = `rId_new_${position}_${hdrFtrType}`;
+	const usedRIds = /* @__PURE__ */ new Set([
+		...pkg.headers?.keys() ?? [],
+		...pkg.footers?.keys() ?? [],
+		...pkg.relationships?.keys() ?? []
+	]);
+	let rId = baseRId;
+	let rIdSuffix = 2;
+	while (usedRIds.has(rId)) {
+		rId = `${baseRId}_${rIdSuffix}`;
+		rIdSuffix++;
+	}
 	const emptyHf = {
 		type: position,
 		hdrFtrType,
@@ -174,11 +185,23 @@ const createEmptyHeaderFooter = (document, position, isFirstPage) => {
 		type: hdrFtrType,
 		rId
 	};
+	const usedTargets = /* @__PURE__ */ new Set();
+	for (const relationship of pkg.relationships?.values() ?? []) if (relationship.target) usedTargets.add(relationship.target);
+	let targetNumber = 1;
+	while (usedTargets.has(`${position}${targetNumber}.xml`)) targetNumber++;
+	const relationshipType = position === "header" ? "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header" : "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer";
+	const relationships = new Map(pkg.relationships);
+	relationships.set(rId, {
+		id: rId,
+		type: relationshipType,
+		target: `${position}${targetNumber}.xml`
+	});
 	return {
 		...document,
 		package: {
 			...pkg,
 			[mapKey]: newMap,
+			relationships,
 			document: {
 				...pkg.document,
 				finalSectionProperties: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Headless, framework-neutral core of folio: the OOXML (.docx) parser, document model, ProseMirror integration, and page-layout engine. No React.",
   "keywords": [
     "document-model",