@stll/folio-core 0.28.1 → 0.29.0

package/dist/prosemirror/extensions/nodes/BookmarkBoundaryExtension.js

@@ -0,0 +1,67 @@
+import { expectBookmarkBoundaryAttrs } from "../../bookmarkBoundaryAttrs.js";
+import { createNodeExtension } from "../create.js";
+//#region src/prosemirror/extensions/nodes/BookmarkBoundaryExtension.ts
+/** Zero-width bookmark boundary that preserves its position through ProseMirror edits. */
+function readNonnegativeInteger(value) {
+	if (value === null || !/^(?:0|[1-9]\d*)$/.test(value)) return false;
+	const parsed = Number(value);
+	return Number.isSafeInteger(parsed) ? parsed : false;
+}
+function readOptionalColumn(dom, attribute) {
+	const value = dom.getAttribute(attribute);
+	return value === null ? void 0 : readNonnegativeInteger(value);
+}
+const BookmarkBoundaryExtension = createNodeExtension({
+	name: "bookmarkBoundary",
+	schemaNodeName: "bookmarkBoundary",
+	nodeSpec: (options) => ({
+		inline: true,
+		group: "inline",
+		marks: "_",
+		atom: true,
+		selectable: false,
+		attrs: {
+			type: {},
+			id: {},
+			name: { default: null },
+			colFirst: { default: null },
+			colLast: { default: null }
+		},
+		parseDOM: [{
+			tag: "span[data-docx-bookmark-boundary]",
+			getAttrs(dom) {
+				const type = dom.getAttribute("data-docx-bookmark-boundary");
+				const id = readNonnegativeInteger(dom.getAttribute("data-docx-bookmark-id"));
+				if (type !== "start" && type !== "end" || id === false) return false;
+				const name = dom.getAttribute("data-docx-bookmark-name");
+				if (type === "start" && !name) return false;
+				const colFirst = readOptionalColumn(dom, "data-docx-bookmark-col-first");
+				const colLast = readOptionalColumn(dom, "data-docx-bookmark-col-last");
+				if (colFirst === false || colLast === false) return false;
+				return {
+					type,
+					id,
+					...name ? { name } : {},
+					...colFirst !== void 0 ? { colFirst } : {},
+					...colLast !== void 0 ? { colLast } : {}
+				};
+			}
+		}],
+		toDOM(node) {
+			const attrs = expectBookmarkBoundaryAttrs(node);
+			return ["span", {
+				"data-docx-bookmark-boundary": attrs.type,
+				"data-docx-bookmark-id": String(attrs.id),
+				...attrs.type === "start" ? { "data-docx-bookmark-name": attrs.name } : {},
+				...attrs.type === "start" && attrs.colFirst !== void 0 ? { "data-docx-bookmark-col-first": String(attrs.colFirst) } : {},
+				...attrs.type === "start" && attrs.colLast !== void 0 ? { "data-docx-bookmark-col-last": String(attrs.colLast) } : {},
+				"aria-hidden": "true",
+				contenteditable: "false",
+				style: "display: none;",
+				...options.getInternalClipboardToken ? { "data-docx-internal-clipboard": options.getInternalClipboardToken() } : {}
+			}];
+		}
+	})
+});
+//#endregion
+export { BookmarkBoundaryExtension };

package/dist/prosemirror/extensions/nodes/FieldExtension.d.ts

@@ -1,11 +1,17 @@
 import { NodeExtension } from "../types.js";
 //#region src/prosemirror/extensions/nodes/FieldExtension.d.ts
 /**
- * Field Extension — inline field node (PAGE, NUMPAGES, DATE, MERGEFIELD, etc.)
+ * Field extensions — atomic inline fields (PAGE, NUMPAGES, REF, etc.).
  *
- * Represents OOXML simple and complex fields as an atomic inline node.
- * At render time, field values are substituted (e.g., PAGE → actual page number).
+ * Ordinary fields are true ProseMirror leaves, so `textContent`, `textBetween`,
+ * and the default plain-text clipboard serializer can use `leafText`.
+ * Simple fields that must preserve hyperlink structure use a distinct atomic
+ * node with inline children; their visible text comes from those children.
  */
+type StructuredFieldOptions = {
+  getInternalClipboardToken?: () => string;
+};
 declare const FieldExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+declare const StructuredFieldExtension: (options?: Partial<StructuredFieldOptions> | undefined) => NodeExtension;
 //#endregion
-export { FieldExtension };
+export { FieldExtension, StructuredFieldExtension };

package/dist/prosemirror/extensions/nodes/FieldExtension.js

@@ -2,12 +2,49 @@ import { parseFieldInstruction } from "../../../docx/fieldParser.js";
 import { expectFieldAttrs } from "../../attrs/index.js";
 import { createNodeExtension } from "../create.js";
 //#region src/prosemirror/extensions/nodes/FieldExtension.ts
-/**
-* Field Extension — inline field node (PAGE, NUMPAGES, DATE, MERGEFIELD, etc.)
-*
-* Represents OOXML simple and complex fields as an atomic inline node.
-* At render time, field values are substituted (e.g., PAGE → actual page number).
-*/
+const createFieldAttrs = () => ({
+	fieldType: { default: "UNKNOWN" },
+	instruction: { default: "" },
+	displayText: { default: "" },
+	_numberedRefBaseline: { default: void 0 },
+	fieldKind: { default: "simple" },
+	fldLock: { default: false },
+	dirty: { default: false }
+});
+const readFieldDomAttrs = (dom) => ({
+	fieldType: dom.dataset["fieldType"] ?? "UNKNOWN",
+	instruction: dom.dataset["instruction"] ?? "",
+	displayText: dom.textContent ?? "",
+	fieldKind: dom.dataset["fieldKind"] ?? "simple",
+	fldLock: dom.dataset["fldLock"] === "true",
+	dirty: dom.dataset["dirty"] === "true"
+});
+const getFieldDomAttrs = (node) => {
+	const { fieldType, instruction, fieldKind, fldLock, dirty } = expectFieldAttrs(node);
+	return {
+		class: `docx-field docx-field-${fieldType.toLowerCase()}`,
+		"data-field-type": fieldType,
+		"data-instruction": instruction,
+		"data-field-kind": fieldKind,
+		...fldLock ? { "data-fld-lock": "true" } : {},
+		...dirty ? { "data-dirty": "true" } : {},
+		style: "outline: 1px solid var(--doc-field-outline, rgba(200,200,200,0.4)); padding: 0 1px; border-radius: 2px;"
+	};
+};
+const getFieldVisibleText = (node) => {
+	const { fieldType, instruction, displayText } = expectFieldAttrs(node);
+	if (displayText) return displayText;
+	switch (fieldType) {
+		case "PAGE": return "{page}";
+		case "NUMPAGES": return "{pages}";
+		case "DATE":
+		case "TIME":
+		case "CREATEDATE":
+		case "SAVEDATE": return (/* @__PURE__ */ new Date()).toLocaleDateString();
+		case "MERGEFIELD": return `«${getMergeFieldName(instruction)}»`;
+		default: return `{${fieldType}}`;
+	}
+};
 const FieldExtension = createNodeExtension({
 	name: "field",
 	schemaNodeName: "field",
@@ -16,72 +53,53 @@ const FieldExtension = createNodeExtension({
 		group: "inline",
 		atom: true,
 		selectable: true,
-		attrs: {
-			/** Field type: PAGE, NUMPAGES, DATE, MERGEFIELD, etc. */
-			fieldType: { default: "UNKNOWN" },
-			/** Full field instruction (e.g., "PAGE \\* MERGEFORMAT") */
-			instruction: { default: "" },
-			/** Display text (the current/cached field value) */
-			displayText: { default: "" },
-			/** Whether this is a simple or complex field */
-			fieldKind: { default: "simple" },
-			/** Field is locked */
-			fldLock: { default: false },
-			/** Field is dirty (needs update) */
-			dirty: { default: false }
-		},
+		attrs: createFieldAttrs(),
+		leafText: getFieldVisibleText,
+		parseDOM: [{
+			tag: "span.docx-field:not([data-field-structured])",
+			getAttrs: readFieldDomAttrs
+		}],
+		toDOM(node) {
+			return [
+				"span",
+				getFieldDomAttrs(node),
+				getFieldVisibleText(node)
+			];
+		}
+	}
+});
+const StructuredFieldExtension = createNodeExtension({
+	name: "structuredField",
+	schemaNodeName: "structuredField",
+	nodeSpec: (options) => ({
+		inline: true,
+		group: "inline",
+		content: "(text | bookmarkBoundary | tab | symbol | hardBreak | image | shape | renderedPageBreak | textBoxAnchor)+",
+		atom: true,
+		selectable: true,
+		attrs: createFieldAttrs(),
 		parseDOM: [{
-			tag: "span.docx-field",
+			tag: "span.docx-field[data-field-structured=\"true\"]",
 			getAttrs(dom) {
-				return {
-					fieldType: dom.dataset["fieldType"] ?? "UNKNOWN",
-					instruction: dom.dataset["instruction"] ?? "",
-					displayText: dom.textContent,
-					fieldKind: dom.dataset["fieldKind"] ?? "simple",
-					fldLock: dom.dataset["fldLock"] === "true",
-					dirty: dom.dataset["dirty"] === "true"
-				};
+				if (dom.dataset["fieldKind"] !== "simple" || !dom.querySelector("a[href]")) return false;
+				return readFieldDomAttrs(dom);
 			}
 		}],
 		toDOM(node) {
-			const { fieldType, instruction, displayText, fieldKind, fldLock, dirty } = expectFieldAttrs(node);
-			let text = displayText || "";
-			if (!text) switch (fieldType) {
-				case "PAGE":
-					text = "{page}";
-					break;
-				case "NUMPAGES":
-					text = "{pages}";
-					break;
-				case "DATE":
-				case "TIME":
-				case "CREATEDATE":
-				case "SAVEDATE":
-					text = (/* @__PURE__ */ new Date()).toLocaleDateString();
-					break;
-				case "MERGEFIELD":
-					text = `«${getMergeFieldName(instruction)}»`;
-					break;
-				default: text = `{${fieldType}}`;
-			}
 			return [
 				"span",
 				{
-					class: `docx-field docx-field-${fieldType.toLowerCase()}`,
-					"data-field-type": fieldType,
-					"data-instruction": instruction,
-					"data-field-kind": fieldKind,
-					...fldLock ? { "data-fld-lock": "true" } : {},
-					...dirty ? { "data-dirty": "true" } : {},
-					style: "outline: 1px solid var(--doc-field-outline, rgba(200,200,200,0.4)); padding: 0 1px; border-radius: 2px;"
+					...getFieldDomAttrs(node),
+					"data-field-structured": "true",
+					...options.getInternalClipboardToken ? { "data-docx-internal-clipboard": options.getInternalClipboardToken() } : {}
 				},
-				text
+				0
 			];
 		}
-	}
+	})
 });
 function getMergeFieldName(instruction) {
 	return parseFieldInstruction(instruction).argument ?? "";
 }
 //#endregion
-export { FieldExtension };
+export { FieldExtension, StructuredFieldExtension };

package/dist/prosemirror/extensions/nodes/TextBoxAnchorExtension.d.ts

@@ -7,6 +7,9 @@ import { NodeExtension } from "../types.js";
  * map its position as surrounding text is edited. The save conversion consumes
  * it when the sibling text box is restored to the DOCX run stream.
  */
-declare const TextBoxAnchorExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+type TextBoxAnchorOptions = {
+  getInternalClipboardToken?: () => string;
+};
+declare const TextBoxAnchorExtension: (options?: Partial<TextBoxAnchorOptions> | undefined) => NodeExtension;
 //#endregion
 export { TextBoxAnchorExtension };

package/dist/prosemirror/extensions/nodes/TextBoxAnchorExtension.js

@@ -11,7 +11,7 @@ import { createNodeExtension } from "../create.js";
 const TextBoxAnchorExtension = createNodeExtension({
 	name: "textBoxAnchor",
 	schemaNodeName: "textBoxAnchor",
-	nodeSpec: {
+	nodeSpec: (options) => ({
 		inline: true,
 		group: "inline",
 		marks: "_",
@@ -32,10 +32,11 @@ const TextBoxAnchorExtension = createNodeExtension({
 				"data-docx-textbox-anchor": anchorId,
 				"aria-hidden": "true",
 				contenteditable: "false",
-				style: "display: inline-block; width: 0; height: 0; overflow: hidden; pointer-events: none;"
+				style: "display: inline-block; width: 0; height: 0; overflow: hidden; pointer-events: none;",
+				...options.getInternalClipboardToken ? { "data-docx-internal-clipboard": options.getInternalClipboardToken() } : {}
 			}];
 		}
-	}
+	})
 });
 //#endregion
 export { TextBoxAnchorExtension };

package/dist/prosemirror/listMarker.d.ts

@@ -0,0 +1,58 @@
+import { document_d_exports } from "../types/document.js";
+import { ParagraphAttrs } from "./schema/nodes.js";
+//#region src/prosemirror/listMarker.d.ts
+type ListCounterState = {
+  counters: Map<number, number[]>;
+  abstractCounters: Map<number, number[]>;
+  seenLevels: Set<string>;
+  lastAdvancedNumId?: number;
+};
+type ListCounterStreams = {
+  final: ListCounterState;
+  original: ListCounterState;
+};
+type ListCounterStream = keyof ListCounterStreams;
+type AdvancedListMarker = {
+  marker: string | null;
+  counterAttrs: ParagraphAttrs;
+  counterState: ListCounterState;
+  stream: ListCounterStream;
+};
+type VisibleListMarker = {
+  marker: string | null;
+  counterAttrs: ParagraphAttrs;
+  counterState: ListCounterState;
+  stream: ListCounterStream;
+  advances: readonly AdvancedListMarker[];
+};
+type ResolvedListComponent = {
+  level: number;
+  relativeStart: number;
+  start: number;
+  end: number;
+};
+type ResolvedListTemplate = {
+  value: string;
+  components: readonly ResolvedListComponent[];
+};
+declare const MAX_LIST_LEVEL = 8;
+declare function createListCounterState(): ListCounterState;
+declare function cloneListCounterState(state: ListCounterState): ListCounterState;
+/**
+ * Advance the counter stream that paints this paragraph's marker. Normal
+ * paragraphs advance both final and original streams; inserted/deleted list
+ * paragraphs advance only the document view in which they exist.
+ */
+declare function advanceVisibleListMarker(attrs: ParagraphAttrs, streams: ListCounterStreams): VisibleListMarker;
+declare function formatCounter(value: number, format: document_d_exports.NumberFormat | undefined): string;
+type ResolveListTemplateOptions = {
+  template: string;
+  counters: number[];
+  levelFormats?: document_d_exports.NumberFormat[] | undefined;
+  forceDecimal?: boolean | undefined;
+};
+declare function resolveListTemplate(options: ResolveListTemplateOptions): string;
+declare function resolveListTemplateWithComponents({ template, counters, levelFormats, forceDecimal }: ResolveListTemplateOptions): ResolvedListTemplate;
+declare function advanceListMarker(attrs: ParagraphAttrs, state: ListCounterState): string | null;
+//#endregion
+export { AdvancedListMarker, ListCounterState, ListCounterStream, ListCounterStreams, MAX_LIST_LEVEL, ResolvedListComponent, ResolvedListTemplate, VisibleListMarker, advanceListMarker, advanceVisibleListMarker, cloneListCounterState, createListCounterState, formatCounter, resolveListTemplate, resolveListTemplateWithComponents };

package/dist/prosemirror/listMarker.js

@@ -0,0 +1,185 @@
+import { convertBulletToUnicode } from "../docx/bulletMarkers.js";
+import { formatOoxmlCounter } from "../docx/ooxmlCounterFormatter.js";
+//#region src/prosemirror/listMarker.ts
+const MAX_LIST_LEVEL = 8;
+function createListCounterState() {
+	return {
+		counters: /* @__PURE__ */ new Map(),
+		abstractCounters: /* @__PURE__ */ new Map(),
+		seenLevels: /* @__PURE__ */ new Set()
+	};
+}
+function cloneListCounterState(state) {
+	const counters = /* @__PURE__ */ new Map();
+	for (const [numId, values] of state.counters) counters.set(numId, [...values]);
+	const abstractCounters = /* @__PURE__ */ new Map();
+	for (const [abstractNumId, values] of state.abstractCounters) abstractCounters.set(abstractNumId, [...values]);
+	return {
+		counters,
+		abstractCounters,
+		seenLevels: new Set(state.seenLevels),
+		...state.lastAdvancedNumId !== void 0 ? { lastAdvancedNumId: state.lastAdvancedNumId } : {}
+	};
+}
+const isListNumPr = (value) => value !== void 0 && value !== null;
+const sameListNumPr = (left, right) => left.numId === right.numId && left.ilvl === right.ilvl;
+function previousListAttrs(attrs) {
+	const previous = (attrs._propertyChanges?.find(({ previousFormatting }) => {
+		const previousNumPr = previousFormatting?.numPr;
+		return isListNumPr(previousNumPr) && (!attrs.numPr || !sameListNumPr(previousNumPr, attrs.numPr));
+	}))?.previousFormatting;
+	if (!previous || !isListNumPr(previous.numPr)) return null;
+	return {
+		numPr: previous.numPr,
+		...previous.listIsBullet !== void 0 ? { listIsBullet: previous.listIsBullet } : {},
+		...previous.listIsLegal !== void 0 ? { listIsLegal: previous.listIsLegal } : {},
+		...previous.listNumFmt !== void 0 ? { listNumFmt: previous.listNumFmt } : {},
+		...previous.listMarker !== void 0 ? { listMarker: previous.listMarker } : {},
+		...previous.listMarkerHidden !== void 0 ? { listMarkerHidden: previous.listMarkerHidden } : {},
+		...previous.listLevelNumFmts !== void 0 ? { listLevelNumFmts: previous.listLevelNumFmts } : {},
+		...previous.listLevelStarts !== void 0 ? { listLevelStarts: previous.listLevelStarts } : {},
+		...previous.listAbstractNumId !== void 0 ? { listAbstractNumId: previous.listAbstractNumId } : {},
+		...previous.listStartOverride !== void 0 ? { listStartOverride: previous.listStartOverride } : {}
+	};
+}
+/**
+* Advance the counter stream that paints this paragraph's marker. Normal
+* paragraphs advance both final and original streams; inserted/deleted list
+* paragraphs advance only the document view in which they exist.
+*/
+function advanceVisibleListMarker(attrs, streams) {
+	const advances = [];
+	const advance = (counterAttrs, stream) => {
+		const counterState = streams[stream];
+		const advanced = {
+			marker: advanceListMarker(counterAttrs, counterState),
+			counterAttrs,
+			counterState,
+			stream
+		};
+		advances.push(advanced);
+		return advanced;
+	};
+	const previous = previousListAttrs(attrs);
+	if (!attrs.numPr) return {
+		...advance(previous ?? attrs, previous ? "original" : "final"),
+		advances
+	};
+	if (attrs.pPrMark?.kind === "del") return {
+		...advance(attrs, "original"),
+		advances
+	};
+	const numberingWasAdded = attrs._propertyChanges?.some(({ previousFormatting }) => previousFormatting && Object.hasOwn(previousFormatting, "numPr") && previousFormatting.numPr == null);
+	const numberingChanged = previous?.numPr !== void 0 && !sameListNumPr(previous.numPr, attrs.numPr);
+	const visible = advance(attrs, "final");
+	if (attrs.pPrMark?.kind !== "ins" && !numberingWasAdded && !numberingChanged) advance(attrs, "original");
+	else if (numberingChanged && previous) advance(previous, "original");
+	return {
+		...visible,
+		advances
+	};
+}
+function formatCounter(value, format) {
+	return formatOoxmlCounter(value, format);
+}
+function resolveListTemplate(options) {
+	return resolveListTemplateWithComponents(options).value;
+}
+function resolveListTemplateWithComponents({ template, counters, levelFormats, forceDecimal = false }) {
+	const components = [];
+	let value = "";
+	let sourceEnd = 0;
+	for (const match of template.matchAll(/%(?<digit>\d)(?<punct>[.):\]])?/gu)) {
+		const sourceStart = match.index;
+		const relativeStart = value.length;
+		value += template.slice(sourceEnd, sourceStart);
+		sourceEnd = sourceStart + match[0].length;
+		const index = Number.parseInt(match.groups?.["digit"] ?? "", 10) - 1;
+		if (index < 0) continue;
+		const counter = counters[index];
+		if (counter === void 0 || Number.isNaN(counter)) continue;
+		const formatted = formatCounter(counter, forceDecimal ? "decimal" : levelFormats?.[index]);
+		if (!formatted) continue;
+		const start = value.length;
+		value += formatted;
+		components.push({
+			level: index,
+			relativeStart,
+			start,
+			end: value.length
+		});
+		value += match.groups?.["punct"] ?? "";
+	}
+	value += template.slice(sourceEnd);
+	return {
+		value,
+		components
+	};
+}
+function getLastListCounters(state) {
+	return state.lastAdvancedNumId === void 0 ? void 0 : state.counters.get(state.lastAdvancedNumId);
+}
+function formatNumberedMarker(counters, level) {
+	const parts = [];
+	for (let index = 0; index <= level; index += 1) {
+		const value = counters[index] ?? 0;
+		if (!Number.isFinite(value) || value <= 0) break;
+		parts.push(value);
+	}
+	return parts.length === 0 ? "1." : `${parts.join(".")}.`;
+}
+function advanceListMarker(attrs, state) {
+	const level = attrs.numPr?.ilvl ?? 0;
+	if (!Number.isInteger(level) || level < 0 || level > 8) return null;
+	const numId = attrs.numPr?.numId;
+	if (numId === void 0 || numId === 0) {
+		if (attrs.listMarker?.includes("%") && !attrs.listIsBullet) {
+			const counters = getLastListCounters(state);
+			if (counters) return resolveListTemplate({
+				template: attrs.listMarker,
+				counters,
+				levelFormats: attrs.listLevelNumFmts,
+				forceDecimal: attrs.listIsLegal
+			});
+		}
+		return null;
+	}
+	if (attrs.listIsBullet) return convertBulletToUnicode(attrs.listMarker ?? "");
+	const counters = state.counters.get(numId) ?? Array.from({ length: 9 }, () => NaN);
+	const abstractNumId = attrs.listAbstractNumId;
+	if (level > 0) {
+		const latestAbstractCounters = abstractNumId === void 0 ? void 0 : state.abstractCounters.get(abstractNumId);
+		if (counters.slice(0, level).every((counter) => !Number.isFinite(counter))) for (let index = 0; index < level; index += 1) {
+			const latestCounter = latestAbstractCounters?.[index];
+			counters[index] = latestCounter !== void 0 && Number.isFinite(latestCounter) ? latestCounter : attrs.listLevelStarts?.[index] ?? 1;
+		}
+	}
+	const seenKey = `${numId}:${level}`;
+	if (!state.seenLevels.has(seenKey)) {
+		state.seenLevels.add(seenKey);
+		if (attrs.listStartOverride != null) counters[level] = attrs.listStartOverride - 1;
+	}
+	if (!Number.isFinite(counters[level])) counters[level] = (attrs.listLevelStarts?.[level] ?? 1) - 1;
+	counters[level] = (counters[level] ?? 0) + 1;
+	for (let index = level + 1; index < counters.length; index += 1) counters[index] = NaN;
+	const childAdvances = attrs.listImplicitChildLevelAdvances ?? 0;
+	if (childAdvances > 0 && level + 1 < counters.length) {
+		const childCounter = counters[level + 1];
+		counters[level + 1] = (childCounter === void 0 || !Number.isFinite(childCounter) ? 0 : childCounter) + childAdvances;
+	}
+	state.counters.set(numId, counters);
+	state.lastAdvancedNumId = numId;
+	if (abstractNumId !== void 0) state.abstractCounters.set(abstractNumId, [...counters]);
+	const levelFormats = attrs.listLevelNumFmts ?? (attrs.listNumFmt ? [attrs.listNumFmt] : void 0);
+	if (attrs.listMarker?.includes("%")) return resolveListTemplate({
+		template: attrs.listMarker,
+		counters,
+		levelFormats,
+		forceDecimal: attrs.listIsLegal
+	});
+	if (attrs.listMarker) return attrs.listMarker;
+	if ((levelFormats?.[level] ?? attrs.listNumFmt) === "none" || attrs.listMarker === "") return null;
+	return formatNumberedMarker(counters, level);
+}
+//#endregion
+export { MAX_LIST_LEVEL, advanceListMarker, advanceVisibleListMarker, cloneListCounterState, createListCounterState, formatCounter, resolveListTemplate, resolveListTemplateWithComponents };

package/dist/prosemirror/numberedRefFields.d.ts

@@ -0,0 +1,24 @@
+import { ListCounterState } from "./listMarker.js";
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/numberedRefFields.d.ts
+type NumberSwitch = "n" | "r" | "w";
+type NumberedRefSpec = {
+  bookmark: string;
+  numberSwitch: NumberSwitch;
+};
+type NumberedRefResolutionOptions = {
+  /** Counter snapshot at the start of this body story. The resolver consumes it in place. */
+  listCounterState?: ListCounterState;
+  /** Counter snapshot for tracked deletions in the original document view. */
+  originalListCounterState?: ListCounterState;
+};
+declare function parseNumberedRefInstruction(instruction: string): NumberedRefSpec | null;
+/** Stamp only proven numbered REF fields with clone-safe calibration state. */
+declare function stampNumberedRefFieldBaselines(doc: Node): Node;
+/**
+ * Resolve bounded, numbered REF fields against bookmarks in the ProseMirror body story.
+ * Unsupported or uncalibrated fields are absent from the returned map and retain their cache.
+ */
+declare function resolveNumberedRefFields(doc: Node, options?: NumberedRefResolutionOptions): ReadonlyMap<Node, string>;
+//#endregion
+export { NumberedRefResolutionOptions, parseNumberedRefInstruction, resolveNumberedRefFields, stampNumberedRefFieldBaselines };