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

package/dist/utils/headerFooter.js

@@ -0,0 +1,257 @@
+//#region src/utils/headerFooter.ts
+const EMPTY_RESOLUTION = {
+	headerContent: null,
+	footerContent: null,
+	firstPageHeaderContent: null,
+	firstPageFooterContent: null,
+	hasTitlePg: false,
+	activeHeaderRId: null,
+	activeFooterRId: null,
+	activeFirstHeaderRId: null,
+	activeFirstFooterRId: null
+};
+/**
+* Resolve the header/footer content (and the active relationship ids) for a
+* parsed package. Returns the empty resolution when no package is loaded.
+*/
+const resolveHeaderFooterContent = (pkg) => {
+	if (!pkg) return EMPTY_RESOLUTION;
+	const finalProps = pkg.document.finalSectionProperties;
+	const sections = pkg.document.sections;
+	const headers = pkg.headers;
+	const footers = pkg.footers;
+	const allSectionProps = [];
+	if (sections) for (const s of sections) allSectionProps.push(s.properties);
+	else if (finalProps) allSectionProps.push(finalProps);
+	let header = null;
+	let footer = null;
+	let firstHeader = null;
+	let firstFooter = null;
+	let titlePg = false;
+	let resolvedHeaderRId = null;
+	let resolvedFooterRId = null;
+	let resolvedFirstHeaderRId = null;
+	let resolvedFirstFooterRId = null;
+	if (headers) {
+		let primaryHeaderFromTitleSection = null;
+		let primaryHeaderRId = null;
+		let lastHeader = null;
+		let lastHeaderRId = null;
+		for (const sp of allSectionProps) {
+			if (!sp.headerReferences) continue;
+			const defaultRef = sp.headerReferences.find((r) => r.type === "default");
+			if (!defaultRef?.rId) continue;
+			const candidate = headers.get(defaultRef.rId);
+			if (!candidate) continue;
+			lastHeader = candidate;
+			lastHeaderRId = defaultRef.rId;
+			if (sp.titlePg === true && sp.headerReferences.some((r) => r.type === "first") && !primaryHeaderFromTitleSection) {
+				primaryHeaderFromTitleSection = candidate;
+				primaryHeaderRId = defaultRef.rId;
+			}
+		}
+		header = primaryHeaderFromTitleSection ?? lastHeader ?? header;
+		resolvedHeaderRId = primaryHeaderRId ?? lastHeaderRId;
+	}
+	if (footers) {
+		let primaryFooterFromTitleSection = null;
+		let primaryFooterRId = null;
+		let lastFooter = null;
+		let lastFooterRId = null;
+		for (const sp of allSectionProps) {
+			if (!sp.footerReferences) continue;
+			const defaultRef = sp.footerReferences.find((r) => r.type === "default");
+			if (!defaultRef?.rId) continue;
+			const candidate = footers.get(defaultRef.rId);
+			if (!candidate) continue;
+			lastFooter = candidate;
+			lastFooterRId = defaultRef.rId;
+			if (sp.titlePg === true && sp.footerReferences.some((r) => r.type === "first") && !primaryFooterFromTitleSection) {
+				primaryFooterFromTitleSection = candidate;
+				primaryFooterRId = defaultRef.rId;
+			}
+		}
+		footer = primaryFooterFromTitleSection ?? lastFooter ?? footer;
+		resolvedFooterRId = primaryFooterRId ?? lastFooterRId;
+	}
+	for (const sp of allSectionProps) if (sp.titlePg) {
+		titlePg = true;
+		if (headers && sp.headerReferences) {
+			const firstRef = sp.headerReferences.find((r) => r.type === "first");
+			if (firstRef?.rId) {
+				firstHeader = headers.get(firstRef.rId) ?? null;
+				resolvedFirstHeaderRId = firstRef.rId;
+			}
+		}
+		if (footers && sp.footerReferences) {
+			const firstRef = sp.footerReferences.find((r) => r.type === "first");
+			if (firstRef?.rId) {
+				firstFooter = footers.get(firstRef.rId) ?? null;
+				resolvedFirstFooterRId = firstRef.rId;
+			}
+		}
+		break;
+	}
+	if (!titlePg && headers) {
+		const firstRef = (finalProps?.headerReferences)?.find((r) => r.type === "first");
+		if (firstRef?.rId) {
+			firstHeader = headers.get(firstRef.rId) ?? null;
+			resolvedFirstHeaderRId = firstRef.rId;
+		}
+	}
+	if (!titlePg && footers) {
+		const firstRef = (finalProps?.footerReferences)?.find((r) => r.type === "first");
+		if (firstRef?.rId) {
+			firstFooter = footers.get(firstRef.rId) ?? null;
+			resolvedFirstFooterRId = firstRef.rId;
+		}
+	}
+	if (!titlePg) {
+		if (!header && firstHeader) {
+			header = firstHeader;
+			resolvedHeaderRId = resolvedFirstHeaderRId;
+		}
+		if (!footer && firstFooter) {
+			footer = firstFooter;
+			resolvedFooterRId = resolvedFirstFooterRId;
+		}
+	}
+	return {
+		headerContent: header,
+		footerContent: footer,
+		firstPageHeaderContent: firstHeader,
+		firstPageFooterContent: firstFooter,
+		hasTitlePg: titlePg,
+		activeHeaderRId: resolvedHeaderRId,
+		activeFooterRId: resolvedFooterRId,
+		activeFirstHeaderRId: resolvedFirstHeaderRId,
+		activeFirstFooterRId: resolvedFirstFooterRId
+	};
+};
+/**
+* The section properties that drive the rendered chrome, with `titlePg` merged
+* in when title-page mode was inferred from header/footer references.
+*/
+const resolveEffectiveSectionProperties = (documentBody, hasTitlePg) => {
+	const base = (documentBody?.sections?.find((section) => section.content.length > 0))?.properties ?? documentBody?.finalSectionProperties;
+	if (!hasTitlePg || base?.titlePg) return base;
+	return base ? {
+		...base,
+		titlePg: true
+	} : base;
+};
+/** Pick the relationship id for the slot a save/remove targets. */
+const pickActiveHeaderFooterRId = (resolution, position, isFirstPage) => {
+	if (isFirstPage) return position === "header" ? resolution.activeFirstHeaderRId : resolution.activeFirstFooterRId;
+	return position === "header" ? resolution.activeHeaderRId : resolution.activeFooterRId;
+};
+/**
+* Build a Document with a fresh empty header/footer for the given slot, wired
+* into `finalSectionProperties` via a new reference. Returns null when the
+* document has no final section properties to attach the reference to.
+*/
+const createEmptyHeaderFooter = (document, position, isFirstPage) => {
+	const pkg = document.package;
+	const sectionProps = pkg.document.finalSectionProperties;
+	if (!sectionProps) return null;
+	const hdrFtrType = isFirstPage ? "first" : "default";
+	const rId = `rId_new_${position}_${hdrFtrType}`;
+	const emptyHf = {
+		type: position,
+		hdrFtrType,
+		content: [{
+			type: "paragraph",
+			content: []
+		}]
+	};
+	const mapKey = position === "header" ? "headers" : "footers";
+	const newMap = new Map(pkg[mapKey]);
+	newMap.set(rId, emptyHf);
+	const refKey = position === "header" ? "headerReferences" : "footerReferences";
+	const existingRefs = sectionProps[refKey] ?? [];
+	const newRef = {
+		type: hdrFtrType,
+		rId
+	};
+	return {
+		...document,
+		package: {
+			...pkg,
+			[mapKey]: newMap,
+			document: {
+				...pkg.document,
+				finalSectionProperties: {
+					...sectionProps,
+					[refKey]: [...existingRefs, newRef]
+				}
+			}
+		}
+	};
+};
+/**
+* Serialise edited header/footer content into a new Document. A brand-new
+* HeaderFooter inside a brand-new Map keeps every earlier history entry's
+* Document untouched so undo can step back to the pre-edit state. Returns null
+* when the target header/footer cannot be found.
+*/
+const saveHeaderFooterContent = ({ document, position, isFirstPage, activeRId, blocks }) => {
+	const pkg = document.package;
+	const mapKey = position === "header" ? "headers" : "footers";
+	const map = pkg[mapKey];
+	const existing = map?.get(activeRId);
+	if (!map || !existing) return null;
+	const updated = {
+		...existing,
+		type: position,
+		hdrFtrType: isFirstPage ? "first" : "default",
+		content: blocks
+	};
+	const newMap = new Map(map);
+	newMap.set(activeRId, updated);
+	return {
+		...document,
+		package: {
+			...pkg,
+			[mapKey]: newMap
+		}
+	};
+};
+/**
+* Remove a header/footer and drop its reference from every section that points
+* at it, returning the new Document.
+*/
+const removeHeaderFooter = ({ document, position, activeRId }) => {
+	const pkg = document.package;
+	const refKey = position === "header" ? "headerReferences" : "footerReferences";
+	const mapKey = position === "header" ? "headers" : "footers";
+	const newMap = new Map(pkg[mapKey]);
+	newMap.delete(activeRId);
+	const stripRef = (sp) => {
+		const refs = sp[refKey];
+		if (!refs?.some((r) => r.rId === activeRId)) return sp;
+		return {
+			...sp,
+			[refKey]: refs.filter((r) => r.rId !== activeRId)
+		};
+	};
+	const oldDoc = pkg.document;
+	const newSections = oldDoc.sections?.map((s) => ({
+		...s,
+		properties: stripRef(s.properties)
+	}));
+	const newFinalProps = oldDoc.finalSectionProperties ? stripRef(oldDoc.finalSectionProperties) : oldDoc.finalSectionProperties;
+	return {
+		...document,
+		package: {
+			...pkg,
+			[mapKey]: newMap,
+			document: {
+				...oldDoc,
+				...newSections !== void 0 ? { sections: newSections } : {},
+				...newFinalProps !== void 0 ? { finalSectionProperties: newFinalProps } : {}
+			}
+		}
+	};
+};
+//#endregion
+export { createEmptyHeaderFooter, pickActiveHeaderFooterRId, removeHeaderFooter, resolveEffectiveSectionProperties, resolveHeaderFooterContent, saveHeaderFooterContent };

package/dist/utils/headingCollector.d.ts

@@ -0,0 +1,22 @@
+import { Node } from "prosemirror-model";
+
+//#region src/utils/headingCollector.d.ts
+/**
+ * Information about a heading found in the document.
+ */
+type HeadingInfo = {
+  /** The text content of the heading */text: string; /** Outline level (0 = Heading 1, 1 = Heading 2, etc.) */
+  level: number; /** ProseMirror document position of the paragraph node */
+  pmPos: number; /** 1-indexed page number, filled in by the editor once layout is known. */
+  pageNumber?: number | null;
+};
+/**
+ * Collect all headings from a ProseMirror document.
+ *
+ * Detection logic:
+ * 1. Check `outlineLevel` attr (set by OOXML parsing or style resolution)
+ * 2. Fallback to `styleId` matching /^[Hh]eading(\d)$/
+ */
+declare function collectHeadings(doc: Node): HeadingInfo[];
+//#endregion
+export { HeadingInfo, collectHeadings };

package/dist/utils/headingCollector.js

@@ -0,0 +1,36 @@
+//#region src/utils/headingCollector.ts
+/**
+* Collect all headings from a ProseMirror document.
+*
+* Detection logic:
+* 1. Check `outlineLevel` attr (set by OOXML parsing or style resolution)
+* 2. Fallback to `styleId` matching /^[Hh]eading(\d)$/
+*/
+function collectHeadings(doc) {
+	const headings = [];
+	doc.descendants((node, pos) => {
+		if (node.type.name === "paragraph") {
+			const level = node.attrs["outlineLevel"];
+			const styleId = node.attrs["styleId"];
+			let effectiveLevel = level;
+			if (effectiveLevel === null && styleId) {
+				const match = /^[Hh]eading(?<level>\d)$/u.exec(styleId);
+				if (match) effectiveLevel = Number.parseInt(match.groups["level"], 10) - 1;
+			}
+			if (effectiveLevel !== null && effectiveLevel >= 0 && effectiveLevel <= 8) {
+				let text = "";
+				node.forEach((child) => {
+					if (child.isText) text += child.text || "";
+				});
+				if (text.trim()) headings.push({
+					text: text.trim(),
+					level: effectiveLevel,
+					pmPos: pos
+				});
+			}
+		}
+	});
+	return headings;
+}
+//#endregion
+export { collectHeadings };

package/dist/utils/hexId.d.ts

@@ -0,0 +1,33 @@
+//#region src/utils/hexId.d.ts
+/**
+ * Lifted from
+ * https://github.com/eigenpal/docx-editor/blob/main/packages/core/src/utils/hexId.ts
+ * (Apache-2.0). Keep the bound and the comments in sync upstream.
+ */
+/**
+ * Strictest OOXML `ST_LongHexNumber` upper bound (exclusive) across the
+ * fields this helper feeds: `w14:paraId` / `w14:textId` / comment
+ * `paraId` (`< 0x80000000`) and `w16cid:commentId/@durableId`
+ * (`< 0x7FFFFFFF`). Generated ids must stay strictly below this value
+ * to survive both Word ("Document Recovery — Table Properties") and
+ * strict OOXML validators.
+ */
+declare const MAX_HEX_ID_EXCLUSIVE = 2147483647;
+/**
+ * Random 8-char uppercase hex id, matching Microsoft's `w14:paraId`
+ * extension format (also reused for comment `paraId` / `durableId`).
+ *
+ * Range is `[0, MAX_HEX_ID_EXCLUSIVE)` = `[0, 0x7FFFFFFE]`.
+ *
+ * Uses `Math.random()` rather than `crypto.randomUUID()` so the
+ * generator works in non-secure contexts (file://, web workers).
+ */
+declare const generateHexId: () => string;
+/**
+ * Deterministic 8-char uppercase hex id (FNV-1a over `seed`), `< 0x7FFFFFFF`.
+ * Re-deriving from the same seed mints the same id, so content/position-derived
+ * ids (block paraIds, comment thread keys) are stable across saves.
+ */
+declare const deterministicHexId: (seed: string) => string;
+//#endregion
+export { MAX_HEX_ID_EXCLUSIVE, deterministicHexId, generateHexId };

package/dist/utils/hexId.js

@@ -0,0 +1,37 @@
+//#region src/utils/hexId.ts
+/**
+* Lifted from
+* https://github.com/eigenpal/docx-editor/blob/main/packages/core/src/utils/hexId.ts
+* (Apache-2.0). Keep the bound and the comments in sync upstream.
+*/
+/**
+* Strictest OOXML `ST_LongHexNumber` upper bound (exclusive) across the
+* fields this helper feeds: `w14:paraId` / `w14:textId` / comment
+* `paraId` (`< 0x80000000`) and `w16cid:commentId/@durableId`
+* (`< 0x7FFFFFFF`). Generated ids must stay strictly below this value
+* to survive both Word ("Document Recovery — Table Properties") and
+* strict OOXML validators.
+*/
+const MAX_HEX_ID_EXCLUSIVE = 2147483647;
+/**
+* Random 8-char uppercase hex id, matching Microsoft's `w14:paraId`
+* extension format (also reused for comment `paraId` / `durableId`).
+*
+* Range is `[0, MAX_HEX_ID_EXCLUSIVE)` = `[0, 0x7FFFFFFE]`.
+*
+* Uses `Math.random()` rather than `crypto.randomUUID()` so the
+* generator works in non-secure contexts (file://, web workers).
+*/
+const generateHexId = () => Math.floor(Math.random() * MAX_HEX_ID_EXCLUSIVE).toString(16).toUpperCase().padStart(8, "0");
+/**
+* Deterministic 8-char uppercase hex id (FNV-1a over `seed`), `< 0x7FFFFFFF`.
+* Re-deriving from the same seed mints the same id, so content/position-derived
+* ids (block paraIds, comment thread keys) are stable across saves.
+*/
+const deterministicHexId = (seed) => {
+	let hash = 2166136261;
+	for (const character of seed) hash = Math.imul(hash ^ (character.codePointAt(0) ?? 0), 16777619) >>> 0;
+	return (hash % MAX_HEX_ID_EXCLUSIVE).toString(16).toUpperCase().padStart(8, "0");
+};
+//#endregion
+export { MAX_HEX_ID_EXCLUSIVE, deterministicHexId, generateHexId };

package/dist/utils/imageValidation.d.ts

@@ -0,0 +1,5 @@
+//#region src/utils/imageValidation.d.ts
+declare function isAllowedImageMimeType(mimeType: string): boolean;
+declare function isSafeImageFile(file: File): Promise<boolean>;
+//#endregion
+export { isAllowedImageMimeType, isSafeImageFile };

package/dist/utils/imageValidation.js

@@ -0,0 +1,31 @@
+//#region src/utils/imageValidation.ts
+const MAX_INSERTED_IMAGE_BYTES = 10 * 1024 * 1024;
+const ALLOWED_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/bmp",
+	"image/webp",
+	"image/tiff"
+]);
+function isAllowedImageMimeType(mimeType) {
+	return ALLOWED_IMAGE_MIME_TYPES.has(mimeType);
+}
+async function isSafeImageFile(file) {
+	if (file.size <= 0 || file.size > MAX_INSERTED_IMAGE_BYTES) return false;
+	if (!isAllowedImageMimeType(file.type)) return false;
+	return matchesImageSignature(new Uint8Array(await file.slice(0, 12).arrayBuffer()), file.type);
+}
+function matchesImageSignature(bytes, mimeType) {
+	switch (mimeType) {
+		case "image/png": return bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
+		case "image/jpeg": return bytes[0] === 255 && bytes[1] === 216;
+		case "image/gif": return bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56;
+		case "image/bmp": return bytes[0] === 66 && bytes[1] === 77;
+		case "image/webp": return bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80;
+		case "image/tiff": return bytes[0] === 73 && bytes[1] === 73 && (bytes[2] === 42 || bytes[2] === 43) && bytes[3] === 0 || bytes[0] === 77 && bytes[1] === 77 && bytes[2] === 0 && (bytes[3] === 42 || bytes[3] === 43);
+		default: return false;
+	}
+}
+//#endregion
+export { isAllowedImageMimeType, isSafeImageFile };

package/dist/utils/paragraphFormattingMerge.d.ts

@@ -0,0 +1,14 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/utils/paragraphFormattingMerge.d.ts
+/**
+ * Merge paragraph properties for OOXML style cascade resolution.
+ *
+ * The source is the higher-priority layer. Most `w:pPr` properties replace an
+ * inherited value when present; nested child containers merge by child field;
+ * tabs replace as a complete ordered collection; paragraph mark `w:rPr` uses
+ * the run-formatting merge rules.
+ */
+declare function mergeParagraphFormatting(target: document_d_exports.ParagraphFormatting | undefined, source: document_d_exports.ParagraphFormatting | undefined): document_d_exports.ParagraphFormatting | undefined;
+//#endregion
+export { mergeParagraphFormatting };

package/dist/utils/paragraphFormattingMerge.js

@@ -0,0 +1,68 @@
+import { mergeTextFormatting } from "./textFormattingMerge.js";
+//#region src/utils/paragraphFormattingMerge.ts
+const PARAGRAPH_REPLACE_KEYS = [
+	"alignment",
+	"bidi",
+	"spaceBefore",
+	"spaceAfter",
+	"lineSpacing",
+	"lineSpacingRule",
+	"beforeAutospacing",
+	"afterAutospacing",
+	"spacingExplicit",
+	"indentLeft",
+	"indentRight",
+	"indentFirstLine",
+	"hangingIndent",
+	"shading",
+	"keepNext",
+	"keepLines",
+	"widowControl",
+	"pageBreakBefore",
+	"contextualSpacing",
+	"outlineLevel",
+	"styleId",
+	"suppressLineNumbers",
+	"suppressAutoHyphens",
+	"runInWithNext"
+];
+const copyDefinedParagraphProperty = (target, source, key) => {
+	const value = source[key];
+	if (value !== void 0) target[key] = value;
+};
+/**
+* Merge paragraph properties for OOXML style cascade resolution.
+*
+* The source is the higher-priority layer. Most `w:pPr` properties replace an
+* inherited value when present; nested child containers merge by child field;
+* tabs replace as a complete ordered collection; paragraph mark `w:rPr` uses
+* the run-formatting merge rules.
+*/
+function mergeParagraphFormatting(target, source) {
+	if (!source) return target;
+	if (!target) {
+		const result = { ...source };
+		if (source.tabs !== void 0) result.tabs = [...source.tabs];
+		return result;
+	}
+	const result = { ...target };
+	for (const key of PARAGRAPH_REPLACE_KEYS) copyDefinedParagraphProperty(result, source, key);
+	const mergedRunProperties = mergeTextFormatting(result.runProperties, source.runProperties);
+	if (mergedRunProperties) result.runProperties = mergedRunProperties;
+	if (source.borders !== void 0) result.borders = {
+		...result.borders,
+		...source.borders
+	};
+	if (source.numPr !== void 0) result.numPr = {
+		...result.numPr,
+		...source.numPr
+	};
+	if (source.frame !== void 0) result.frame = {
+		...result.frame,
+		...source.frame
+	};
+	if (source.tabs !== void 0) result.tabs = [...source.tabs];
+	return result;
+}
+//#endregion
+export { mergeParagraphFormatting };

package/dist/utils/replaceText.d.ts

@@ -0,0 +1,17 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/utils/replaceText.d.ts
+type ReplaceRange = {
+  start: {
+    paragraphIndex: number;
+    offset: number;
+  };
+  end: {
+    paragraphIndex: number;
+    offset: number;
+  };
+};
+/** Replace text within a range in the document. Returns a new document. */
+declare function replaceTextInDocument(doc: document_d_exports.Document, range: ReplaceRange, text: string, formatting?: document_d_exports.TextFormatting): document_d_exports.Document;
+//#endregion
+export { replaceTextInDocument };

package/dist/utils/replaceText.js

@@ -0,0 +1,161 @@
+//#region src/utils/replaceText.ts
+/** Replace text within a range in the document. Returns a new document. */
+function replaceTextInDocument(doc, range, text, formatting) {
+	const newDoc = structuredClone(doc);
+	const body = newDoc.package.document;
+	const { start, end } = range;
+	if (start.paragraphIndex === end.paragraphIndex) {
+		const paragraph = getParagraphByIndex(body, start.paragraphIndex);
+		if (!paragraph) return newDoc;
+		paragraph.content = deleteTextInParagraph(paragraph, start.offset, end.offset);
+		paragraph.content = insertTextAtOffset(paragraph, start.offset, text, formatting);
+	} else {
+		const startParagraph = getParagraphByIndex(body, start.paragraphIndex);
+		if (!startParagraph) return newDoc;
+		const startText = getParagraphText(startParagraph);
+		startParagraph.content = deleteTextInParagraph(startParagraph, start.offset, startText.length);
+		startParagraph.content = insertTextAtOffset(startParagraph, start.offset, text, formatting);
+		const paragraphsToRemove = [];
+		for (let i = start.paragraphIndex + 1; i <= end.paragraphIndex; i++) paragraphsToRemove.push(getTopLevelParagraphBlockIndex(body, i));
+		for (let i = paragraphsToRemove.length - 1; i >= 0; i--) {
+			const idx = paragraphsToRemove[i];
+			if (idx !== -1) body.content.splice(idx, 1);
+		}
+	}
+	return newDoc;
+}
+function getTopLevelParagraphBlockIndex(body, paragraphIndex) {
+	let pIdx = 0;
+	for (let i = 0; i < body.content.length; i++) if (body.content[i].type === "paragraph") {
+		if (pIdx === paragraphIndex) return i;
+		pIdx++;
+	}
+	return -1;
+}
+function getParagraphByIndex(body, paragraphIndex) {
+	let currentIndex = 0;
+	const walkBlocks = (blocks) => {
+		for (const block of blocks) {
+			if (block.type === "paragraph") {
+				if (currentIndex === paragraphIndex) return block;
+				currentIndex++;
+				continue;
+			}
+			if (block.type === "table") {
+				for (const row of block.rows) for (const cell of row.cells) {
+					const found = walkBlocks(cell.content);
+					if (found !== null) return found;
+				}
+				continue;
+			}
+			const found = walkBlocks(block.content);
+			if (found !== null) return found;
+		}
+		return null;
+	};
+	return walkBlocks(body.content);
+}
+function getParagraphText(paragraph) {
+	let text = "";
+	for (const item of paragraph.content) if (item.type === "run") {
+		for (const c of item.content) if (c.type === "text") text += c.text;
+	} else if (item.type === "hyperlink") for (const child of item.children) {
+		if (child.type !== "run") continue;
+		for (const c of child.content) if (c.type === "text") text += c.text;
+	}
+	return text;
+}
+function deleteTextInParagraph(paragraph, startOffset, endOffset) {
+	const result = [];
+	let currentOffset = 0;
+	for (const item of paragraph.content) if (item.type === "run") {
+		const newContent = [];
+		for (const content of item.content) if (content.type === "text") {
+			const textStart = currentOffset;
+			const textEnd = currentOffset + content.text.length;
+			if (textEnd <= startOffset || textStart >= endOffset) newContent.push(content);
+			else {
+				let newText = "";
+				if (textStart < startOffset) newText += content.text.slice(0, startOffset - textStart);
+				if (textEnd > endOffset) newText += content.text.slice(endOffset - textStart);
+				if (newText) newContent.push({
+					...content,
+					text: newText
+				});
+			}
+			currentOffset = textEnd;
+		} else newContent.push(content);
+		if (newContent.length > 0) result.push({
+			...item,
+			content: newContent
+		});
+	} else result.push(item);
+	return result;
+}
+function insertTextAtOffset(paragraph, offset, text, formatting) {
+	if (!text) return paragraph.content;
+	let currentOffset = 0;
+	for (const item of paragraph.content) if (item.type === "run") for (let ci = 0; ci < item.content.length; ci++) {
+		const content = item.content[ci];
+		if (content.type === "text") {
+			const textStart = currentOffset;
+			const textEnd = currentOffset + content.text.length;
+			if (offset >= textStart && offset <= textEnd) {
+				const relOffset = offset - textStart;
+				if (formatting) {
+					const before = content.text.slice(0, relOffset);
+					const after = content.text.slice(relOffset);
+					const newContent = [];
+					if (before) newContent.push({
+						type: "text",
+						text: before
+					});
+					const newRun = {
+						type: "text",
+						text
+					};
+					item.content.splice(ci, 1, ...newContent);
+					const insertRun = {
+						type: "run",
+						content: [newRun],
+						formatting
+					};
+					const afterItems = [];
+					if (after) afterItems.push({
+						type: "text",
+						text: after
+					});
+					const remaining = item.content.splice(ci + newContent.length);
+					const afterRun = {
+						type: "run",
+						content: [...remaining, ...afterItems],
+						...item.formatting !== void 0 ? { formatting: item.formatting } : {}
+					};
+					const idx = paragraph.content.indexOf(item);
+					paragraph.content.splice(idx + 1, 0, insertRun);
+					if (afterItems.length > 0 || remaining.length > 0) paragraph.content.splice(idx + 2, 0, afterRun);
+					return paragraph.content;
+				}
+				content.text = content.text.slice(0, relOffset) + text + content.text.slice(relOffset);
+				return paragraph.content;
+			}
+			currentOffset = textEnd;
+		}
+	}
+	const lastRun = paragraph.content.findLast((item) => item.type === "run");
+	if (lastRun) lastRun.content.push({
+		type: "text",
+		text
+	});
+	else paragraph.content.push({
+		type: "run",
+		content: [{
+			type: "text",
+			text
+		}],
+		formatting: formatting ?? {}
+	});
+	return paragraph.content;
+}
+//#endregion
+export { replaceTextInDocument };