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

package/dist/docx/xmlParser.js

@@ -0,0 +1,527 @@
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+import { OOXML_NS } from "@stll/docx-utils";
+//#region src/docx/xmlParser.ts
+/**
+* XML Parser Utilities for OOXML
+*
+* Provides helper functions for parsing Office Open XML (OOXML) content
+* with proper namespace handling.
+*
+* OOXML uses many namespaces:
+* - w:  WordprocessingML (main document content)
+* - a:  DrawingML (graphics)
+* - r:  Relationships
+* - wp: Word Drawing positioning
+* - wps: Word Drawing shapes
+* - wpc: Word Drawing canvas
+* - wpg: Word Drawing group
+* - m:  Math
+* - mc: Markup Compatibility
+* - v:  VML (legacy vector graphics)
+* - o:  Office (extensions)
+* - pic: Pictures
+*/
+const fxpParserOptions = {
+	preserveOrder: true,
+	ignoreAttributes: false,
+	attributeNamePrefix: "",
+	trimValues: false,
+	textNodeName: "#text",
+	parseTagValue: false,
+	parseAttributeValue: false,
+	ignoreDeclaration: true,
+	ignorePiTags: true,
+	processEntities: true,
+	htmlEntities: true
+};
+const fxpParserOptionsWithStopNodes = {
+	...fxpParserOptions,
+	stopNodes: ["*.w:binData"]
+};
+const fxpBuilderOptions = {
+	preserveOrder: true,
+	ignoreAttributes: false,
+	attributeNamePrefix: "",
+	textNodeName: "#text",
+	suppressEmptyNode: true
+};
+const fxpParser = new XMLParser(fxpParserOptions);
+const fxpParserWithStopNodes = new XMLParser(fxpParserOptionsWithStopNodes);
+const fxpBuilder = new XMLBuilder(fxpBuilderOptions);
+/** Text node key used by fast-xml-parser in preserveOrder mode. */
+const TEXT_KEY = "#text";
+/** Attribute group key used by fast-xml-parser in preserveOrder mode. */
+const ATTR_KEY = ":@";
+/**
+* Convert a fast-xml-parser preserveOrder node into an XmlElement.
+*
+* In preserveOrder mode every node is an object with exactly one "real" key
+* (the tag name or `#text`) whose value is the children array, plus an
+* optional `:@` key holding the attributes object.
+*/
+function fxpNodeToElement(node) {
+	if (TEXT_KEY in node) return {
+		type: "text",
+		text: node[TEXT_KEY]
+	};
+	const attrs = node[ATTR_KEY];
+	for (const key of Object.keys(node)) {
+		if (key === ATTR_KEY) continue;
+		const children = node[key];
+		const element = {
+			type: "element",
+			name: key
+		};
+		if (attrs && Object.keys(attrs).length > 0) element.attributes = attrs;
+		if (children.length > 0) element.elements = children.map(fxpNodeToElement);
+		return element;
+	}
+	return { type: "element" };
+}
+/**
+* Convert the top-level fast-xml-parser preserveOrder array into an
+* XmlElement that matches xml-js's non-compact root structure:
+* `{ elements: [...] }`.
+*/
+function fxpToRootElement(nodes) {
+	return { elements: nodes.map(fxpNodeToElement) };
+}
+/**
+* Convert an XmlElement back into the fast-xml-parser preserveOrder format
+* so we can feed it to XMLBuilder.
+*/
+function elementToFxpNode(el) {
+	if (el.type === "text") return { [TEXT_KEY]: el.text ?? "" };
+	const name = el.name ?? "";
+	const children = el.elements ? el.elements.map(elementToFxpNode) : [];
+	const node = { [name]: children };
+	if (el.attributes && Object.keys(el.attributes).length > 0) node[ATTR_KEY] = el.attributes;
+	return node;
+}
+/**
+* Common OOXML namespace URIs — re-exported from @stll/docx-utils.
+*/
+const NAMESPACES = OOXML_NS;
+/**
+* Parse XML string into element tree
+*
+* @param xml - XML string to parse
+* @returns Parsed element tree
+*/
+function parseXml(xml) {
+	return fxpToRootElement((xml.includes("binData") ? fxpParserWithStopNodes : fxpParser).parse(xml));
+}
+/**
+* Serialize an XmlElement back to an XML string
+*/
+function elementToXml(element) {
+	const fxpNode = elementToFxpNode(element);
+	return fxpBuilder.build([fxpNode]);
+}
+/**
+* Parse XML string to a more convenient format
+*/
+function parseXmlDocument(xml) {
+	try {
+		const parsed = parseXml(xml);
+		if (parsed.elements && parsed.elements.length > 0) return parsed.elements.find((e) => e.type === "element") ?? null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+/**
+* Get local name from a prefixed element name
+* e.g., "w:p" -> "p", "a:graphic" -> "graphic"
+*/
+function getLocalName(name) {
+	const colonIndex = name.indexOf(":");
+	return colonIndex !== -1 ? name.slice(colonIndex + 1) : name;
+}
+/**
+* Get namespace prefix from an element name
+* e.g., "w:p" -> "w", "a:graphic" -> "a"
+*/
+function getNamespacePrefix(name) {
+	const colonIndex = name.indexOf(":");
+	return colonIndex !== -1 ? name.slice(0, colonIndex) : null;
+}
+/**
+* Check if an element matches a given namespaced name
+*
+* @param element - Element to check
+* @param namespace - Namespace prefix (e.g., "w", "a")
+* @param localName - Local element name (e.g., "p", "r")
+*/
+function matchesName(element, namespace, localName) {
+	if (!element.name) return false;
+	const fullName = `${namespace}:${localName}`;
+	if (element.name === fullName) return true;
+	if (getLocalName(element.name) === localName) return true;
+	return false;
+}
+/**
+* Find first child element matching the given namespaced name
+*
+* @param parent - Parent element
+* @param namespace - Namespace prefix (e.g., "w")
+* @param localName - Local element name (e.g., "p")
+* @returns First matching child or null
+*/
+function findChild(parent, namespace, localName) {
+	if (!parent || !parent.elements) return null;
+	const fullName = `${namespace}:${localName}`;
+	for (const child of parent.elements) {
+		if (child.type !== "element") continue;
+		if (child.name === fullName) return child;
+		if (getLocalName(child.name || "") === localName) return child;
+	}
+	return null;
+}
+/**
+* Find all child elements matching the given namespaced name
+*
+* @param parent - Parent element
+* @param namespace - Namespace prefix
+* @param localName - Local element name
+* @returns Array of matching children
+*/
+function findChildren(parent, namespace, localName) {
+	if (!parent || !parent.elements) return [];
+	const fullName = `${namespace}:${localName}`;
+	const results = [];
+	for (const child of parent.elements) {
+		if (child.type !== "element") continue;
+		if (child.name === fullName || getLocalName(child.name || "") === localName) results.push(child);
+	}
+	return results;
+}
+/**
+* Find first child element by local name only (ignoring namespace)
+*
+* @param parent - Parent element
+* @param localName - Local element name
+* @returns First matching child or null
+*/
+function findChildByLocalName(parent, localName) {
+	if (!parent || !parent.elements) return null;
+	for (const child of parent.elements) {
+		if (child.type !== "element") continue;
+		if (getLocalName(child.name || "") === localName) return child;
+	}
+	return null;
+}
+/**
+* Find all child elements by local name only
+*
+* @param parent - Parent element
+* @param localName - Local element name
+* @returns Array of matching children
+*/
+function findChildrenByLocalName(parent, localName) {
+	if (!parent || !parent.elements) return [];
+	return parent.elements.filter((child) => child.type === "element" && getLocalName(child.name || "") === localName);
+}
+/**
+* Find first child element by full name (including namespace prefix)
+*
+* @param parent - Parent element
+* @param fullName - Full element name with namespace prefix (e.g., 'wp:extent')
+* @returns First matching child or null
+*/
+function findByFullName(parent, fullName) {
+	if (!parent || !parent.elements) return null;
+	for (const child of parent.elements) {
+		if (child.type !== "element") continue;
+		if (child.name === fullName) return child;
+	}
+	return null;
+}
+/**
+* Get all child elements (excludes text nodes, etc.)
+*
+* @param parent - Parent element
+* @returns Array of child elements
+*/
+function getChildElements(parent) {
+	if (!parent || !parent.elements) return [];
+	return parent.elements.filter((child) => child.type === "element");
+}
+/**
+* Get an attribute value from an element
+*
+* @param element - Element to get attribute from
+* @param namespace - Namespace prefix for the attribute (or null for no namespace)
+* @param name - Attribute name
+* @returns Attribute value or null if not found
+*
+* Lookup order when a namespace is provided:
+*   1. exact `${namespace}:${name}` match (`w:val`),
+*   2. bare `${name}` match (`val`),
+*   3. any-prefix local-name match (`x:val`, `w14:val`, …).
+*
+* The local-name fallback mirrors `findChild` and lets the parser tolerate
+* producers that rebind the WordprocessingML namespace to an alternative
+* prefix. Without it, attributes such as `x:val` on an `x:alias` element
+* would silently drop on round-trip even though the element itself is
+* recognised.
+*/
+function getAttribute(element, namespace, name) {
+	if (!element || !element.attributes) return null;
+	const attrs = element.attributes;
+	if (namespace) {
+		const prefixedName = `${namespace}:${name}`;
+		if (prefixedName in attrs) return attrs[prefixedName] ?? null;
+	}
+	if (name in attrs) return attrs[name] ?? null;
+	if (namespace) {
+		const suffix = `:${name}`;
+		for (const key of Object.keys(attrs)) if (key.endsWith(suffix)) return attrs[key] ?? null;
+	}
+	return null;
+}
+/**
+* Read an attribute by local name, trying the element's own prefix first,
+* then the canonical Word prefix, then unprefixed.
+*
+* OOXML lets a producer bind the WordprocessingML namespace under any
+* prefix the file's xmlns declarations choose, so a strict `w:val` /
+* `w:tag` lookup misses valid docs that use `ns0:` (or any other prefix
+* resolving to the same URI). This helper mirrors `parseBooleanElement`'s
+* tolerance for the attribute path — call it whenever you want to read
+* an OOXML attribute that conventionally lives in the `w:` namespace
+* but could appear under an alternate prefix bound to the same URI.
+*/
+function getAttributeAnyPrefix(element, localName) {
+	if (!element) return null;
+	const elementName = element.name ?? "";
+	const colonIdx = elementName.indexOf(":");
+	const elementPrefix = colonIdx > 0 ? elementName.slice(0, colonIdx) : null;
+	if (elementPrefix && elementPrefix !== "w") {
+		const fromPrefix = getAttribute(element, elementPrefix, localName);
+		if (fromPrefix !== null) return fromPrefix;
+	}
+	const canonical = getAttribute(element, "w", localName);
+	if (canonical !== null) return canonical;
+	const attrs = element.attributes;
+	if (attrs) {
+		const suffix = `:${localName}`;
+		for (const [key, value] of Object.entries(attrs)) if (key === localName || key.endsWith(suffix)) return value;
+	}
+	return null;
+}
+/**
+* Get an attribute value, trying multiple possible names
+*
+* @param element - Element to get attribute from
+* @param names - Array of possible attribute names (with or without namespace)
+* @returns First found attribute value or null
+*/
+function getAttributeAny(element, names) {
+	if (!element || !element.attributes) return null;
+	const attrs = element.attributes;
+	for (const name of names) if (name in attrs) return attrs[name] ?? null;
+	return null;
+}
+/**
+* Get all attributes from an element
+*
+* @param element - Element to get attributes from
+* @returns Record of attribute name -> value
+*/
+function getAttributes(element) {
+	if (!element || !element.attributes) return {};
+	return element.attributes;
+}
+/**
+* Get the text content of an element (concatenates all text nodes)
+*
+* @param element - Element to get text from
+* @returns Text content or empty string
+*/
+function getTextContent(element) {
+	if (!element) return "";
+	if ("text" in element && typeof element.text === "string") return element.text;
+	if (!element.elements) return "";
+	let text = "";
+	for (const child of element.elements) if (child.type === "text" && "text" in child) text += child.text ?? "";
+	else if (child.type === "element") text += getTextContent(child);
+	return text;
+}
+/**
+* Check if an element has a specific attribute with value "true" or "1"
+*
+* @param element - Element to check
+* @param namespace - Attribute namespace
+* @param name - Attribute name
+* @returns true if attribute exists and is truthy
+*/
+function hasFlag(element, namespace, name) {
+	const value = getAttribute(element, namespace, name);
+	if (value === null) return false;
+	if (value === "0" || value === "false" || value === "off") return false;
+	return true;
+}
+/**
+* Check if a child element exists (used for boolean flags in OOXML)
+*
+* @param parent - Parent element
+* @param namespace - Namespace prefix
+* @param localName - Local element name
+* @returns true if child element exists
+*/
+function hasChild(parent, namespace, localName) {
+	return findChild(parent, namespace, localName) !== null;
+}
+/**
+* Parse an OOXML color value
+*
+* @param element - Color element (e.g., w:color)
+* @returns Object with val, themeColor, themeTint, themeShade
+*/
+function parseColorElement(element) {
+	if (!element) return null;
+	const val = getAttribute(element, "w", "val");
+	const themeColor = getAttribute(element, "w", "themeColor");
+	const themeTint = getAttribute(element, "w", "themeTint");
+	const themeShade = getAttribute(element, "w", "themeShade");
+	return {
+		...val != null ? { val } : {},
+		...themeColor != null ? { themeColor } : {},
+		...themeTint != null ? { themeTint } : {},
+		...themeShade != null ? { themeShade } : {}
+	};
+}
+/**
+* Parse a numeric value from an attribute, with optional scale
+*
+* @param element - Element containing the attribute
+* @param namespace - Attribute namespace
+* @param name - Attribute name
+* @param scale - Optional scale factor (e.g., 20 for twips to points)
+* @returns Parsed number or undefined
+*/
+function parseNumericAttribute(element, namespace, name, scale = 1) {
+	const value = getAttribute(element, namespace, name);
+	if (value === null) return;
+	const num = Number.parseInt(value, 10);
+	if (Number.isNaN(num)) return;
+	return num * scale;
+}
+/**
+* Parse a boolean value from an attribute or element presence
+*
+* OOXML boolean conventions:
+* - Element presence with no val attribute = true
+* - w:val="true" or w:val="1" = true
+* - w:val="false" or w:val="0" = false
+*
+* @param element - Element to check
+* @param namespace - Namespace for val attribute
+* @returns boolean value
+*/
+function parseBooleanElement(element, namespace = "w") {
+	if (!element) return false;
+	let val = null;
+	const elementName = element.name ?? "";
+	const colonIdx = elementName.indexOf(":");
+	const elementPrefix = colonIdx > 0 ? elementName.slice(0, colonIdx) : null;
+	if (elementPrefix && elementPrefix !== namespace) val = getAttribute(element, elementPrefix, "val");
+	if (val === null) val = getAttribute(element, namespace, "val");
+	if (val === null && element.attributes) {
+		for (const [key, value] of Object.entries(element.attributes)) if (key === "val" || key.endsWith(":val")) {
+			val = value;
+			break;
+		}
+	}
+	if (val === null) return true;
+	if (val === "0" || val === "false" || val === "off") return false;
+	return true;
+}
+/**
+* Deep find - search recursively for an element
+*
+* @param root - Root element to search from
+* @param namespace - Namespace prefix
+* @param localName - Local element name
+* @returns First matching element found or null
+*/
+function findDeep(root, namespace, localName) {
+	if (!root) return null;
+	if (matchesName(root, namespace, localName)) return root;
+	if (root.elements) for (const child of root.elements) {
+		if (child.type !== "element") continue;
+		const found = findDeep(child, namespace, localName);
+		if (found) return found;
+	}
+	return null;
+}
+/**
+* Find all elements matching name, searching recursively
+*
+* @param root - Root element to search from
+* @param namespace - Namespace prefix
+* @param localName - Local element name
+* @returns Array of all matching elements
+*/
+function findAllDeep(root, namespace, localName) {
+	const results = [];
+	function search(element) {
+		if (!element) return;
+		if (matchesName(element, namespace, localName)) results.push(element);
+		if (element.elements) {
+			for (const child of element.elements) if (child.type === "element") search(child);
+		}
+	}
+	search(root);
+	return results;
+}
+/**
+* Collect every `xmlns` / `xmlns:*` declaration from an element's attributes.
+*
+* The serializer's hard-coded root namespaces only cover canonical prefixes
+* (`a`, `w`, `wp`, `v`, `o`, …); a DOCX that binds a namespace to a
+* non-canonical prefix would replay an unbound prefix when a captured subtree
+* is emitted on its own. Carrying the source declarations forward keeps the
+* raw replay self-contained regardless of the producer's prefix choice.
+*/
+function collectXmlnsDeclarations(element) {
+	const out = {};
+	const attrs = element.attributes;
+	if (!attrs) return out;
+	for (const [key, value] of Object.entries(attrs)) if ((key === "xmlns" || key.startsWith("xmlns:")) && value !== void 0) out[key] = String(value);
+	return out;
+}
+/**
+* Merge an element's own `xmlns` / `xmlns:*` declarations onto an inherited
+* in-scope set, returning the accumulated set. Threaded down the ancestor
+* chain (root -> paragraph -> run -> pict), the element's own declarations
+* override an inherited binding for the same prefix, matching XML scoping. The
+* inherited object is not mutated; the same reference is returned unchanged when
+* the element declares nothing.
+*/
+function mergeXmlnsDeclarations(inherited, element) {
+	const own = collectXmlnsDeclarations(element);
+	if (Object.keys(own).length === 0) return inherited;
+	return {
+		...inherited,
+		...own
+	};
+}
+/**
+* Return a shallow clone of `element` whose attributes carry every declaration
+* in `xmlnsDecls`. Existing attributes (including any namespace declarations the
+* element already carries) win over the injected ones.
+*/
+function cloneWithXmlnsDeclarations(element, xmlnsDecls) {
+	if (Object.keys(xmlnsDecls).length === 0) return element;
+	return {
+		...element,
+		attributes: {
+			...xmlnsDecls,
+			...element.attributes
+		}
+	};
+}
+//#endregion
+export { NAMESPACES, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findByFullName, findChild, findChildByLocalName, findChildren, findChildrenByLocalName, findDeep, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getTextContent, hasChild, hasFlag, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumericAttribute, parseXml, parseXmlDocument };

package/dist/fields/bookmarkPages.d.ts

@@ -0,0 +1,13 @@
+import { FlowBlock, Page } from "../layout-engine/types.js";
+
+//#region src/fields/bookmarkPages.d.ts
+/**
+ * Map each bookmark name to the 1-indexed page its anchoring paragraph lands on,
+ * for PAGEREF resolution. Computed as a post-pass over a finished layout: walk
+ * pages -> fragments -> the source block's bookmarks. A bookmark whose paragraph
+ * splits across pages takes the first (lowest) page it appears on, matching how
+ * Word resolves a PAGEREF to the start of the bookmark.
+ */
+declare function buildBookmarkPageMap(pages: readonly Page[], blocks: readonly FlowBlock[]): Map<string, number>;
+//#endregion
+export { buildBookmarkPageMap };

package/dist/fields/bookmarkPages.js

@@ -0,0 +1,66 @@
+//#region src/fields/bookmarkPages.ts
+/**
+* Map each bookmark name to the 1-indexed page its anchoring paragraph lands on,
+* for PAGEREF resolution. Computed as a post-pass over a finished layout: walk
+* pages -> fragments -> the source block's bookmarks. A bookmark whose paragraph
+* splits across pages takes the first (lowest) page it appears on, matching how
+* Word resolves a PAGEREF to the start of the bookmark.
+*/
+function buildBookmarkPageMap(pages, blocks) {
+	const anchors = [];
+	for (const block of blocks) collectBookmarkAnchors(block, block.id, anchors);
+	const pageByBookmark = /* @__PURE__ */ new Map();
+	if (anchors.length === 0) return pageByBookmark;
+	for (const page of pages) for (const fragment of page.fragments) for (const anchor of anchors) {
+		if (!fragmentContainsAnchor(fragment, anchor)) continue;
+		assignBookmarkPage(pageByBookmark, anchor.names, page.number);
+	}
+	return pageByBookmark;
+}
+function collectBookmarkAnchors(block, topLevelId, anchors) {
+	if (block.kind === "paragraph") {
+		if (!block.bookmarks || block.bookmarks.length === 0) return;
+		anchors.push({
+			type: "block",
+			blockId: topLevelId,
+			names: [...block.bookmarks]
+		});
+		return;
+	}
+	if (block.kind === "table") {
+		for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex++) {
+			const row = block.rows[rowIndex];
+			if (!row) continue;
+			for (const cell of row.cells) for (const child of cell.blocks) collectTableRowBookmarkAnchors(child, block.id, rowIndex, anchors);
+		}
+		return;
+	}
+	if (block.kind === "textBox") for (const child of block.content) collectBookmarkAnchors(child, topLevelId, anchors);
+}
+function collectTableRowBookmarkAnchors(block, tableId, rowIndex, anchors) {
+	if (block.kind === "paragraph") {
+		if (!block.bookmarks || block.bookmarks.length === 0) return;
+		anchors.push({
+			type: "tableRow",
+			blockId: tableId,
+			rowIndex,
+			names: [...block.bookmarks]
+		});
+		return;
+	}
+	if (block.kind === "table") {
+		for (const row of block.rows) for (const cell of row.cells) for (const child of cell.blocks) collectTableRowBookmarkAnchors(child, tableId, rowIndex, anchors);
+		return;
+	}
+	if (block.kind === "textBox") for (const child of block.content) collectTableRowBookmarkAnchors(child, tableId, rowIndex, anchors);
+}
+function fragmentContainsAnchor(fragment, anchor) {
+	if (fragment.blockId !== anchor.blockId) return false;
+	if (anchor.type === "block") return true;
+	return fragment.kind === "table" && anchor.rowIndex >= fragment.fromRow && anchor.rowIndex < fragment.toRow;
+}
+function assignBookmarkPage(pageByBookmark, names, pageNumber) {
+	for (const name of names) if (!pageByBookmark.has(name)) pageByBookmark.set(name, pageNumber);
+}
+//#endregion
+export { buildBookmarkPageMap };

package/dist/fields/bookmarkText.d.ts

@@ -0,0 +1,16 @@
+import { FlowBlock } from "../layout-engine/types.js";
+
+//#region src/fields/bookmarkText.d.ts
+type BookmarkTextInputs = {
+  fieldValues?: ReadonlyMap<number, string>;
+  seqValues?: ReadonlyMap<number, number>;
+};
+/**
+ * Map each bookmark name to the text of its anchoring paragraph, for REF
+ * cross-references (e.g. "see Section 1.3"). Folio anchors bookmarks at the
+ * paragraph level, so a REF resolves to that paragraph's visible text. Document
+ * order, independent of layout. First paragraph carrying a name wins.
+ */
+declare function buildBookmarkText(blocks: readonly FlowBlock[], inputs?: BookmarkTextInputs): Map<string, string>;
+//#endregion
+export { buildBookmarkText };

package/dist/fields/bookmarkText.js

@@ -0,0 +1,61 @@
+import { parseFieldInstruction } from "../docx/fieldParser.js";
+import { evaluateField } from "./evaluateField.js";
+//#region src/fields/bookmarkText.ts
+const EMPTY_STRING_NUMBER = /* @__PURE__ */ new Map();
+const EMPTY_STRING_STRING = /* @__PURE__ */ new Map();
+const EMPTY_NUMBER_NUMBER = /* @__PURE__ */ new Map();
+/**
+* Map each bookmark name to the text of its anchoring paragraph, for REF
+* cross-references (e.g. "see Section 1.3"). Folio anchors bookmarks at the
+* paragraph level, so a REF resolves to that paragraph's visible text. Document
+* order, independent of layout. First paragraph carrying a name wins.
+*/
+function buildBookmarkText(blocks, inputs = {}) {
+	const map = /* @__PURE__ */ new Map();
+	walkBlocks(blocks, map, inputs);
+	return map;
+}
+function walkBlocks(blocks, map, inputs) {
+	for (const block of blocks) if (block.kind === "paragraph") {
+		if (!block.bookmarks || block.bookmarks.length === 0) continue;
+		const text = paragraphText(block, inputs);
+		for (const name of block.bookmarks) if (!map.has(name)) map.set(name, text);
+	} else if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) walkBlocks(cell.blocks, map, inputs);
+	else if (block.kind === "textBox") walkBlocks(block.content, map, inputs);
+}
+function paragraphText(block, inputs) {
+	let text = "";
+	for (const run of block.runs) if (run.kind === "text") text += run.text;
+	else if (run.kind === "field") text += bookmarkFieldText(run, inputs);
+	return `${visibleListMarker(block)}${text}`.trim();
+}
+function bookmarkFieldText(run, inputs) {
+	if (run.kind !== "field") return "";
+	const resolved = run.pmStart === void 0 ? void 0 : inputs.fieldValues?.get(run.pmStart);
+	if (resolved !== void 0) return resolved;
+	if (run.pmStart === void 0 || !inputs.seqValues?.has(run.pmStart)) return run.fallback ?? "";
+	const parsed = parseFieldInstruction(run.instruction || run.fieldType);
+	if (parsed.type !== "SEQ") return run.fallback ?? "";
+	return evaluateField(parsed, {
+		pageNumber: 1,
+		totalPages: 1,
+		sectionPages: 1,
+		bookmarkPages: EMPTY_STRING_NUMBER,
+		bookmarkText: EMPTY_STRING_STRING,
+		seqValues: inputs.seqValues ?? EMPTY_NUMBER_NUMBER,
+		now: /* @__PURE__ */ new Date(0)
+	}, {
+		fallback: run.fallback ?? "",
+		instanceId: run.pmStart,
+		...run.fldLock ? { locked: true } : {}
+	});
+}
+function visibleListMarker(block) {
+	const marker = block.attrs?.listMarker;
+	if (!marker || block.attrs?.listMarkerHidden) return "";
+	const normalized = marker.replace(/\t+/gu, " ").trim();
+	if (!normalized) return "";
+	return block.attrs?.listMarkerSuffix === "nothing" ? normalized : `${normalized} `;
+}
+//#endregion
+export { buildBookmarkText };