@stll/folio-core 0.52.0 → 0.53.0

package/dist/prosemirror/extensions/features/pastedHtmlLists.js

@@ -0,0 +1,126 @@
+import { mintListInstance } from "../../../docx/listNumberingInstances.js";
+import { createNumberingMap } from "../../../docx/numberingParser.js";
+import { expectParagraphAttrs } from "../../attrs/index.js";
+import { completeNumberingForDoc } from "../../listInstanceReferences.js";
+import { listItemAttrs } from "../../listNumbering.js";
+import { getPackageNumberingDefinitions } from "../../plugins/documentNumbering.js";
+import { panic } from "better-result";
+import { Fragment, Slice } from "prosemirror-model";
+//#region src/prosemirror/extensions/features/pastedHtmlLists.ts
+/** Convert browser list markup into the editor's numbered-paragraph model. */
+const isList = (element) => element.localName === "ul" || element.localName === "ol";
+const hasListHint = (node) => node?.type.name === "paragraph" && Boolean(expectParagraphAttrs(node)._pastedHtmlList);
+/**
+* Flatten only list containers. Other HTML remains in place for the normal
+* clipboard parser, including tables and inline formatting inside list items.
+*/
+const flattenPastedHtmlLists = (html) => {
+	if (!/<(?:ul|ol)\b/iu.test(html)) return html;
+	const host = document.createElement("div");
+	host.innerHTML = html;
+	let nextGroup = 0;
+	const flatten = (list, level) => {
+		const fragment = document.createDocumentFragment();
+		const group = ++nextGroup;
+		const kind = list.localName === "ul" ? "bullet" : "numbered";
+		const rawStart = Number(list.getAttribute("start"));
+		const start = Number.isSafeInteger(rawStart) && rawStart > 0 ? rawStart : void 0;
+		for (const item of Array.from(list.children)) {
+			if (item.localName !== "li") continue;
+			let paragraph = document.createElement("p");
+			let emitted = false;
+			const mark = (element) => {
+				element.setAttribute("data-folio-list-group", String(group));
+				element.setAttribute("data-folio-list-level", String(Math.min(level, 8)));
+				element.setAttribute("data-folio-list-kind", kind);
+				if (start !== void 0) element.setAttribute("data-folio-list-start", String(start));
+			};
+			const flush = () => {
+				if (!paragraph.hasChildNodes()) return;
+				mark(paragraph);
+				fragment.append(paragraph);
+				paragraph = document.createElement("p");
+				emitted = true;
+			};
+			for (const child of Array.from(item.childNodes)) if (child instanceof Element && isList(child)) {
+				flush();
+				fragment.append(flatten(child, level + 1));
+			} else if (child instanceof Element && child.localName === "p") {
+				flush();
+				mark(child);
+				fragment.append(child);
+				emitted = true;
+			} else if (child.nodeType !== Node.TEXT_NODE || child.textContent?.trim()) paragraph.append(child);
+			flush();
+			if (!emitted) {
+				mark(paragraph);
+				fragment.append(paragraph);
+			}
+		}
+		return fragment;
+	};
+	for (const list of Array.from(host.querySelectorAll("ul,ol"))) {
+		if (!list.parentNode || list.parentElement?.closest("ul,ol")) continue;
+		list.replaceWith(flatten(list, 0));
+	}
+	return host.innerHTML;
+};
+/** Resolve clipboard-only list hints against fresh document numbering ids. */
+const numberPastedHtmlLists = (slice, view) => {
+	let hasList = false;
+	slice.content.descendants((node) => {
+		if (hasListHint(node)) {
+			hasList = true;
+			return false;
+		}
+		return !hasList;
+	});
+	if (!hasList) return slice;
+	const startsWithList = hasListHint(slice.content.firstChild);
+	const endsWithList = hasListHint(slice.content.lastChild);
+	let definitions = completeNumberingForDoc(getPackageNumberingDefinitions(view.state) ?? void 0, view.state.doc);
+	let numbering = null;
+	const groups = /* @__PURE__ */ new Map();
+	let changed = false;
+	const convert = (node) => {
+		let result = node;
+		if (node.type.name === "paragraph") {
+			const attrs = expectParagraphAttrs(node);
+			const hint = attrs._pastedHtmlList;
+			if (hint) {
+				let group = groups.get(hint.group);
+				if (!group || group.kind !== hint.kind) {
+					const minted = mintListInstance(definitions, {
+						kind: hint.kind,
+						...hint.start === void 0 ? {} : { start: hint.start }
+					});
+					definitions = minted.definitions;
+					numbering = createNumberingMap(definitions);
+					group = {
+						numId: minted.numId,
+						kind: hint.kind
+					};
+					groups.set(hint.group, group);
+				}
+				if (!numbering) panic("Pasted list group has no numbering definition");
+				result = node.type.create(listItemAttrs({
+					...attrs,
+					_pastedHtmlList: void 0
+				}, {
+					numId: group.numId,
+					ilvl: hint.level
+				}, numbering), node.content, node.marks);
+				changed = true;
+			}
+		}
+		if (result.childCount === 0) return result;
+		const children = [];
+		result.forEach((child) => children.push(convert(child)));
+		return result.copy(Fragment.fromArray(children));
+	};
+	const children = [];
+	slice.content.forEach((node) => children.push(convert(node)));
+	return changed ? new Slice(Fragment.fromArray(children), startsWithList ? 0 : slice.openStart, endsWithList ? 0 : slice.openEnd) : slice;
+};
+//#endregion
+export { flattenPastedHtmlLists, numberPastedHtmlLists };

package/dist/prosemirror/extensions/marks/FootnoteRefExtension.js

@@ -1,5 +1,7 @@
 import { expectFootnoteRefMarkAttrs } from "../../attrs/index.js";
+import { suggestionModeKey } from "../../plugins/suggestionMode.js";
 import { createMarkExtension } from "../create.js";
+import { expandNoteReferenceDeletionRange } from "./noteReferenceDeletion.js";
 import { panic } from "better-result";
 //#region src/prosemirror/extensions/marks/FootnoteRefExtension.ts
 /**
@@ -59,6 +61,14 @@ const FootnoteRefExtension = createMarkExtension({
 	},
 	onSchemaReady(ctx) {
 		const { schema } = ctx;
+		const deleteWholeNoteReference = (direction) => (state, dispatch) => {
+			if (suggestionModeKey.getState(state)?.active) return false;
+			const { from, to, empty } = state.selection;
+			const range = expandNoteReferenceDeletionRange(state.doc, empty && direction === "backward" ? Math.max(0, from - 1) : from, empty && direction === "forward" ? Math.min(state.doc.content.size, to + 1) : to);
+			if (!range) return false;
+			dispatch?.(state.tr.delete(range.from, range.to).scrollIntoView());
+			return true;
+		};
 		function makeInsertNote(noteType) {
 			return (id) => (state, dispatch) => {
 				if (!dispatch) return true;
@@ -83,11 +93,17 @@ const FootnoteRefExtension = createMarkExtension({
 			dispatch(tr.scrollIntoView());
 			return true;
 		};
-		return { commands: {
-			insertFootnote: makeInsertNote("footnote"),
-			insertEndnote: makeInsertNote("endnote"),
-			deleteNoteRef: () => deleteNoteRef
-		} };
+		return {
+			keyboardShortcuts: {
+				Backspace: deleteWholeNoteReference("backward"),
+				Delete: deleteWholeNoteReference("forward")
+			},
+			commands: {
+				insertFootnote: makeInsertNote("footnote"),
+				insertEndnote: makeInsertNote("endnote"),
+				deleteNoteRef: () => deleteNoteRef
+			}
+		};
 	}
 });
 //#endregion

package/dist/prosemirror/extensions/marks/RunIdentityExtension.d.ts

@@ -1,26 +1,29 @@
 import { MarkExtension } from "../types.js";
+import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/extensions/marks/RunIdentityExtension.d.ts
+type InsertedRange = {
+  from: number;
+  to: number;
+};
 /**
- * Editor-side identity for one authored `w:r`, and the payload that element
- * carried which no formatting mark holds.
+ * Every range `transactions` inserted, in the document they produced.
  *
- * Ordinary formatting marks cannot tell two adjacent source runs with
- * identical properties apart, so the save leg would fold them into one and
- * discard whichever record it did not keep. This mark is what keeps them
- * apart: it is in `getMarksKey`, so a change of identity is a run boundary,
- * and `joinsOwnedSourceRun` rejoins the leaves a page break cut out of one
- * authored run.
+ * A step map reports each replacement as an old span and the new span it
+ * became; a new span longer than nothing is content the step put there, which
+ * is exactly the text that may not claim an authored run. Each range is then
+ * carried through the steps that followed it — the rest of its own
+ * transaction, then every later one — so a batch applied together reports
+ * positions in the document this hook is looking at rather than in an
+ * intermediate one.
  *
- * `inclusive: false` settles the edges. The interior is settled by the strip
- * below: ProseMirror's stored marks at a position inside a span include every
- * mark of the preceding character, so text typed inside an authored run would
- * otherwise ride that run's `w:rsidR` — a claim about which editing session
- * wrote it. folio cannot register a session (`settings.xml`'s `w:rsids` is
- * copied through on every repack, and no save path mints one), so it must
- * never write a session id it did not read. Typed text becomes its own run
- * with no attributes instead, and `w:rsidRDefault` on the parent `w:p`
- * supplies the session the format itself says such a run belongs to.
+ * An undo is not an insertion: it puts back what an edit took away, identity
+ * included, and stripping that would leave the restored text claiming no run
+ * it came from. `skip` names the transactions to pass over; they still carry
+ * the ranges of the others forward.
+ *
+ * @internal Exported for the per-step equivalence test.
  */
+declare const insertedRanges: (transactions: readonly Transaction[], skip?: (transaction: Transaction) => boolean) => InsertedRange[];
 declare const RunIdentityExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
 //#endregion
-export { RunIdentityExtension };
+export { RunIdentityExtension, insertedRanges };

package/dist/prosemirror/extensions/marks/RunIdentityExtension.js

@@ -1,7 +1,10 @@
 import { expectRunIdentityMarkAttrs } from "../../attrs/index.js";
+import { nodesBetweenIndexed } from "../../indexedNodeLookup.js";
+import { sweepPositions } from "../../positionSweep.js";
 import { RUN_IDENTITY_ATTRIBUTE, RUN_IDENTITY_MARK_NAME, runIdentityAttrs } from "../../runIdentity.js";
 import { createMarkExtension } from "../create.js";
 import { Plugin, PluginKey } from "prosemirror-state";
+import { isHistoryTransaction, undoDepth } from "prosemirror-history";
 //#region src/prosemirror/extensions/marks/RunIdentityExtension.ts
 /**
 * Editor-side identity for one authored `w:r`, and the payload that element
@@ -36,27 +39,43 @@ const runIdentityStripKey = new PluginKey("runIdentityStrip");
 * transaction, then every later one — so a batch applied together reports
 * positions in the document this hook is looking at rather than in an
 * intermediate one.
+*
+* An undo is not an insertion: it puts back what an edit took away, identity
+* included, and stripping that would leave the restored text claiming no run
+* it came from. `skip` names the transactions to pass over; they still carry
+* the ranges of the others forward.
+*
+* @internal Exported for the per-step equivalence test.
 */
-const insertedRanges = (transactions) => {
-	const ranges = [];
-	for (const [transactionIndex, transaction] of transactions.entries()) {
-		const later = transactions.slice(transactionIndex + 1);
-		const carryForward = (pos, bias) => {
-			let mapped = pos;
-			for (const next of later) mapped = next.mapping.map(mapped, bias);
-			return mapped;
-		};
+const insertedRanges = (transactions, skip = () => false) => {
+	const queries = [];
+	let stepOffset = 0;
+	for (const transaction of transactions) {
+		const offset = stepOffset;
+		stepOffset += transaction.mapping.maps.length;
+		if (skip(transaction)) continue;
 		transaction.mapping.maps.forEach((stepMap, stepIndex) => {
-			const rest = transaction.mapping.slice(stepIndex + 1);
+			const from = offset + stepIndex + 1;
 			stepMap.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
 				if (newEnd <= newStart) return;
-				ranges.push({
-					from: carryForward(rest.map(newStart, -1), -1),
-					to: carryForward(rest.map(newEnd, 1), 1)
+				queries.push({
+					pos: newStart,
+					assoc: -1,
+					from
+				}, {
+					pos: newEnd,
+					assoc: 1,
+					from
 				});
 			});
 		});
 	}
+	const mapped = sweepPositions(transactions.map((transaction) => transaction.mapping), queries);
+	const ranges = [];
+	for (let index = 0; index < mapped.length; index += 2) ranges.push({
+		from: mapped[index].pos,
+		to: mapped[index + 1].pos
+	});
 	return ranges;
 };
 /**
@@ -69,11 +88,12 @@ const insertedRanges = (transactions) => {
 */
 const createRunIdentityStripPlugin = () => new Plugin({
 	key: runIdentityStripKey,
-	appendTransaction(transactions, _oldState, newState) {
+	appendTransaction(transactions, oldState, newState) {
 		if (!transactions.some((transaction) => transaction.docChanged)) return null;
 		const markType = newState.schema.marks[RUN_IDENTITY_MARK_NAME];
 		if (markType === void 0) return null;
-		const ranges = insertedRanges(transactions);
+		const undoing = undoDepth(newState) < undoDepth(oldState);
+		const ranges = insertedRanges(transactions, (transaction) => undoing && isHistoryTransaction(transaction));
 		if (ranges.length === 0) return null;
 		const tr = newState.tr;
 		const stripRange = ({ from, to }) => {
@@ -81,7 +101,7 @@ const createRunIdentityStripPlugin = () => new Plugin({
 			const clampedFrom = Math.min(from, clampedTo);
 			if (clampedFrom === clampedTo) return false;
 			let rangeStripped = false;
-			newState.doc.nodesBetween(clampedFrom, clampedTo, (node, pos) => {
+			nodesBetweenIndexed(newState.doc, clampedFrom, clampedTo, (node, pos) => {
 				if (!node.isInline || !markType.isInSet(node.marks)) return true;
 				tr.removeMark(Math.max(pos, clampedFrom), Math.min(pos + node.nodeSize, clampedTo), markType);
 				rangeStripped = true;
@@ -132,4 +152,4 @@ const RunIdentityExtension = createMarkExtension({
 	}
 });
 //#endregion
-export { RunIdentityExtension };
+export { RunIdentityExtension, insertedRanges };

package/dist/prosemirror/extensions/marks/markUtils.d.ts

@@ -1,6 +1,6 @@
 import { document_d_exports } from "../../../types/document.js";
-import { Command, EditorState } from "prosemirror-state";
 import { Attrs, Mark, MarkType, Schema } from "prosemirror-model";
+import { Command, EditorState } from "prosemirror-state";
 //#region src/prosemirror/extensions/marks/markUtils.d.ts
 type MarkAttrs = Record<string, unknown>;
 declare function marksToTextFormatting(marks: readonly Mark[]): document_d_exports.TextFormatting;
@@ -39,7 +39,12 @@ type TextFormattingToMarksOptions = {
 };
 declare function textFormattingToMarks(formatting: document_d_exports.TextFormatting | undefined, schema: Schema, options?: TextFormattingToMarksOptions): Mark[];
 /**
- * Clear all text formatting (remove all marks)
+ * Clear character formatting from the selection.
+ *
+ * Only the marks that carry run formatting go. A comment anchor, a hyperlink,
+ * a note reference, a tracked insertion or deletion and a run's identity are
+ * not formatting, and removing them deleted the comment's range, unlinked the
+ * text, orphaned the note and silently resolved the revision.
  */
 declare const clearFormatting: Command;
 /**

package/dist/prosemirror/extensions/marks/markUtils.js

@@ -4,6 +4,7 @@ import { normalizeHorizontalScalePercent } from "../../../utils/horizontalScale.
 import { expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectEmphasisMarkAttrs, expectFontFamilyMarkAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectStrikeMarkAttrs, expectTextEffectMarkAttrs } from "../../attrs/index.js";
 import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "../../conversion/runShadingMark.js";
 import { selectRunFormattingCarrierRepresentations } from "../../runFormattingInlineCarriers.js";
+import { RUN_FORMATTING_MARK_NAMES } from "../../runFormattingMarkNames.js";
 import { hasRunFormattingOverrideAttrs } from "../../runFormattingProvenance.js";
 import { COMPLEX_SCRIPT_RUN_PROPERTY_KEYS } from "../../schema/marks.js";
 import { applyRunFormattingOverrideMark, buildRunFormattingOverrideAttrs } from "./RunFormattingOverrideExtension.js";
@@ -480,7 +481,12 @@ function textFormattingToMarks(formatting, schema, options) {
 	return marks;
 }
 /**
-* Clear all text formatting (remove all marks)
+* Clear character formatting from the selection.
+*
+* Only the marks that carry run formatting go. A comment anchor, a hyperlink,
+* a note reference, a tracked insertion or deletion and a run's identity are
+* not formatting, and removing them deleted the comment's range, unlinked the
+* text, orphaned the note and silently resolved the revision.
 */
 const clearFormatting = (state, dispatch) => {
 	const { from, to, empty } = state.selection;
@@ -498,7 +504,7 @@ const clearFormatting = (state, dispatch) => {
 			if (node.isText && node.marks.length > 0) {
 				const start = Math.max(from, pos);
 				const end = Math.min(to, pos + node.nodeSize);
-				for (const mark of node.marks) tr = tr.removeMark(start, end, mark.type);
+				for (const mark of node.marks) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr = tr.removeMark(start, end, mark.type);
 			}
 		});
 		dispatch(tr.scrollIntoView());

package/dist/prosemirror/extensions/marks/noteReferenceDeletion.d.ts

@@ -0,0 +1,10 @@
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/extensions/marks/noteReferenceDeletion.d.ts
+type DeletionRange = {
+  from: number;
+  to: number;
+};
+/** Keep the text carrying one OOXML note reference together during deletion. */
+declare const expandNoteReferenceDeletionRange: (doc: Node, from: number, to: number) => DeletionRange | null;
+//#endregion
+export { expandNoteReferenceDeletionRange };

package/dist/prosemirror/extensions/marks/noteReferenceDeletion.js

@@ -0,0 +1,35 @@
+//#region src/prosemirror/extensions/marks/noteReferenceDeletion.ts
+/** Keep the text carrying one OOXML note reference together during deletion. */
+const expandNoteReferenceDeletionRange = (doc, from, to) => {
+	let expandedFrom = from;
+	let expandedTo = to;
+	let intersectsReference = false;
+	doc.nodesBetween(from, to, (node, pos) => {
+		const reference = node.marks.find((mark) => mark.type.name === "footnoteRef");
+		if (!node.isText || !reference) return;
+		intersectsReference = true;
+		const $pos = doc.resolve(pos);
+		const parent = $pos.parent;
+		const index = $pos.index();
+		let referenceFrom = pos;
+		let referenceTo = pos + node.nodeSize;
+		for (let left = index - 1; left >= 0; left--) {
+			const sibling = parent.child(left);
+			if (!sibling.isText || !sibling.marks.some((mark) => mark.eq(reference))) break;
+			referenceFrom -= sibling.nodeSize;
+		}
+		for (let right = index + 1; right < parent.childCount; right++) {
+			const sibling = parent.child(right);
+			if (!sibling.isText || !sibling.marks.some((mark) => mark.eq(reference))) break;
+			referenceTo += sibling.nodeSize;
+		}
+		expandedFrom = Math.min(expandedFrom, referenceFrom);
+		expandedTo = Math.max(expandedTo, referenceTo);
+	});
+	return intersectsReference ? {
+		from: expandedFrom,
+		to: expandedTo
+	} : null;
+};
+//#endregion
+export { expandNoteReferenceDeletionRange };

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

@@ -0,0 +1,6 @@
+import { NodeExtension } from "../types.js";
+//#region src/prosemirror/extensions/nodes/BlockCustomXmlExtension.d.ts
+/** An editable block sequence inside an authored custom XML wrapper. */
+declare const BlockCustomXmlExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion
+export { BlockCustomXmlExtension };

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

@@ -0,0 +1,52 @@
+import { createNodeExtension } from "../create.js";
+//#region src/prosemirror/extensions/nodes/BlockCustomXmlExtension.ts
+/** An editable block sequence inside an authored custom XML wrapper. */
+const BlockCustomXmlExtension = createNodeExtension({
+	name: "blockCustomXml",
+	schemaNodeName: "blockCustomXml",
+	nodeSpec: {
+		group: "block",
+		content: "block+",
+		isolating: true,
+		defining: true,
+		attrs: {
+			openingXml: { default: null },
+			closingXml: { default: null },
+			_originallyEmpty: { default: false }
+		},
+		parseDOM: [{
+			tag: "div[data-docx-block-custom-xml-open]",
+			getAttrs(dom) {
+				if (!(dom instanceof HTMLElement)) return false;
+				const openingXml = dom.dataset["docxBlockCustomXmlOpen"];
+				const closingXml = dom.dataset["docxBlockCustomXmlClose"];
+				if (!openingXml || !closingXml) return false;
+				return {
+					openingXml,
+					closingXml,
+					_originallyEmpty: dom.dataset["docxBlockCustomXmlEmpty"] === "true"
+				};
+			}
+		}],
+		toDOM(node) {
+			const { openingXml, closingXml, _originallyEmpty } = node.attrs;
+			if (typeof openingXml !== "string" || typeof closingXml !== "string") return [
+				"div",
+				{ class: "docx-block-custom-xml" },
+				0
+			];
+			return [
+				"div",
+				{
+					class: "docx-block-custom-xml",
+					"data-docx-block-custom-xml-open": openingXml,
+					"data-docx-block-custom-xml-close": closingXml,
+					"data-docx-block-custom-xml-empty": String(_originallyEmpty === true)
+				},
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { BlockCustomXmlExtension };

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

@@ -8,10 +8,10 @@ import { NodeExtension } from "../types.js";
  * Simple fields that must preserve hyperlink structure use a distinct atomic
  * node with inline children; their visible text comes from those children.
  */
-type StructuredFieldOptions = {
+type FieldOptions = {
   getInternalClipboardToken?: () => string;
 };
-declare const FieldExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
-declare const StructuredFieldExtension: (options?: Partial<StructuredFieldOptions> | undefined) => NodeExtension;
+declare const FieldExtension: (options?: Partial<FieldOptions> | undefined) => NodeExtension;
+declare const StructuredFieldExtension: (options?: Partial<FieldOptions> | undefined) => NodeExtension;
 //#endregion
 export { FieldExtension, StructuredFieldExtension };

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

@@ -1,5 +1,5 @@
 import { parseFieldInstruction } from "../../../docx/fieldParser.js";
-import { expectFieldAttrs } from "../../attrs/index.js";
+import { expectFieldAttrs, isValidEmptyFieldResultRuns, isValidFieldCode } from "../../attrs/index.js";
 import { createNodeExtension } from "../create.js";
 //#region src/prosemirror/extensions/nodes/FieldExtension.ts
 const createFieldAttrs = () => ({
@@ -10,21 +10,48 @@ const createFieldAttrs = () => ({
 	fieldKind: { default: "simple" },
 	fldLock: { default: null },
 	dirty: { default: null },
-	fieldResultIsFallback: { default: null }
+	fieldResultIsFallback: { default: null },
+	formFieldDataXml: { default: null },
+	_docxEmptyResultRuns: { default: null },
+	_docxFieldCode: { default: null }
 });
 /** A `data-` flag a pasted field carried: absent states nothing. */
 const statedFlag = (value) => value === void 0 ? null : value === "true";
-const readFieldDomAttrs = (dom) => ({
-	fieldType: dom.dataset["fieldType"] ?? "UNKNOWN",
-	instruction: dom.dataset["instruction"] ?? "",
-	displayText: dom.textContent ?? "",
-	fieldKind: dom.dataset["fieldKind"] ?? "simple",
-	fldLock: statedFlag(dom.dataset["fldLock"]),
-	dirty: statedFlag(dom.dataset["dirty"]),
-	fieldResultIsFallback: statedFlag(dom.dataset["fieldResultIsFallback"])
-});
+const readEmptyResultRuns = (value) => {
+	if (value === void 0) return null;
+	try {
+		const parsed = JSON.parse(value);
+		return isValidEmptyFieldResultRuns(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+};
+const readFieldCode = (value) => {
+	if (value === void 0) return null;
+	try {
+		const parsed = JSON.parse(value);
+		return isValidFieldCode(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+};
+const readFieldDomAttrs = (dom) => {
+	const emptyResultRuns = readEmptyResultRuns(dom.dataset["emptyResultRuns"]);
+	return {
+		fieldType: dom.dataset["fieldType"] ?? "UNKNOWN",
+		instruction: dom.dataset["instruction"] ?? "",
+		displayText: (emptyResultRuns === null ? void 0 : dom.dataset["displayText"]) ?? dom.textContent ?? "",
+		fieldKind: dom.dataset["fieldKind"] ?? "simple",
+		fldLock: statedFlag(dom.dataset["fldLock"]),
+		dirty: statedFlag(dom.dataset["dirty"]),
+		fieldResultIsFallback: statedFlag(dom.dataset["fieldResultIsFallback"]),
+		formFieldDataXml: dom.dataset["formFieldDataXml"] ?? null,
+		_docxEmptyResultRuns: emptyResultRuns,
+		_docxFieldCode: readFieldCode(dom.dataset["fieldCode"])
+	};
+};
 const getFieldDomAttrs = (node) => {
-	const { fieldType, instruction, fieldKind, fldLock, dirty, fieldResultIsFallback } = expectFieldAttrs(node);
+	const { fieldType, instruction, fieldKind, fldLock, dirty, fieldResultIsFallback, formFieldDataXml, _docxEmptyResultRuns, _docxFieldCode } = expectFieldAttrs(node);
 	return {
 		class: `docx-field docx-field-${fieldType.toLowerCase()}`,
 		"data-field-type": fieldType,
@@ -33,6 +60,9 @@ const getFieldDomAttrs = (node) => {
 		...fldLock === void 0 ? {} : { "data-fld-lock": String(fldLock) },
 		...dirty === void 0 ? {} : { "data-dirty": String(dirty) },
 		...fieldResultIsFallback === void 0 ? {} : { "data-field-result-is-fallback": String(fieldResultIsFallback) },
+		...formFieldDataXml === void 0 ? {} : { "data-form-field-data-xml": formFieldDataXml },
+		..._docxEmptyResultRuns === void 0 ? {} : { "data-empty-result-runs": JSON.stringify(_docxEmptyResultRuns) },
+		..._docxFieldCode === void 0 ? {} : { "data-field-code": JSON.stringify(_docxFieldCode) },
 		style: "outline: 1px solid var(--doc-field-outline, rgba(200,200,200,0.4)); padding: 0 1px; border-radius: 2px;"
 	};
 };
@@ -53,7 +83,7 @@ const getFieldVisibleText = (node) => {
 const FieldExtension = createNodeExtension({
 	name: "field",
 	schemaNodeName: "field",
-	nodeSpec: {
+	nodeSpec: (options) => ({
 		inline: true,
 		group: "inline",
 		atom: true,
@@ -65,13 +95,18 @@ const FieldExtension = createNodeExtension({
 			getAttrs: readFieldDomAttrs
 		}],
 		toDOM(node) {
+			const { displayText, _docxEmptyResultRuns } = expectFieldAttrs(node);
 			return [
 				"span",
-				getFieldDomAttrs(node),
+				{
+					...getFieldDomAttrs(node),
+					...options.getInternalClipboardToken ? { "data-docx-internal-clipboard": options.getInternalClipboardToken() } : {},
+					..._docxEmptyResultRuns ? { "data-display-text": displayText } : {}
+				},
 				getFieldVisibleText(node)
 			];
 		}
-	}
+	})
 });
 const StructuredFieldExtension = createNodeExtension({
 	name: "structuredField",

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

@@ -35,7 +35,10 @@ const PreservedBlockExtension = createNodeExtension({
 		group: "block",
 		atom: true,
 		selectable: false,
-		attrs: { xml: {} },
+		attrs: {
+			xml: {},
+			readerText: { default: null }
+		},
 		parseDOM: [{
 			tag: "div[data-docx-preserved-block]",
 			getAttrs(dom) {

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

@@ -1,7 +1,7 @@
 import { ColorValue } from "../../../types/colors.js";
 import { AnyExtension, Extension, NodeExtension } from "../types.js";
-import { Command, EditorState } from "prosemirror-state";
 import { Node } from "prosemirror-model";
+import { Command, EditorState } from "prosemirror-state";
 //#region src/prosemirror/extensions/nodes/TableExtension.d.ts
 type TableContextInfo = {
   isInTable: boolean;