@stll/folio-core 0.28.1 → 0.30.0

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

@@ -1,4 +1,6 @@
 import { stripXmlDeclarations } from "../../../utils/stripXmlDeclarations.js";
+import { readBookmarkBoundaryAttrs } from "../../bookmarkBoundaryAttrs.js";
+import { Fragment, Slice } from "prosemirror-model";
 //#region src/prosemirror/extensions/features/pasteCleanup.ts
 /**
 * Office / web paste cleanup
@@ -117,56 +119,109 @@ const STRAY_XML_TAG = new RegExp(`<\\/?xml${TAG_TAIL}>`, "gi");
 const NOISE_TAG = new RegExp(`<\\/?(?:font|meta|link)${TAG_TAIL}>`, "gi");
 const EMPTY_SPAN = new RegExp(`<span(?:\\s${TAG_TAIL})?><\\/span>`, "gi");
 const MAX_EMPTY_SPAN_PASSES = 5;
-const PM_SLICE_MARKER = /\bdata-pm-slice\s*=/i;
+const INTERNAL_CLIPBOARD_ATTR_PATTERN = /\s+data-docx-internal-clipboard(?:="([^"]*)"|='([^']*)'|=([^\s>]+))?/gi;
 const TEXTBOX_ANCHOR_ATTR = /\s+data-docx-textbox-anchor(?:="[^"]*"|='[^']*')?/gi;
+const BOOKMARK_BOUNDARY_ATTR = /\s+data-docx-bookmark-(?:boundary|id|name|col-first|col-last)(?:="[^"]*"|='[^']*'|=[^\s>]+)?/gi;
+const STRUCTURED_FIELD_ATTR = /\s+data-field-structured(?:="[^"]*"|='[^']*'|=[^\s>]+)?/gi;
 /**
-* Remove the `data-docx-textbox-anchor` marker from HTML that did not come
-* from a ProseMirror clipboard slice (see {@link PM_SLICE_MARKER}). Internal
-* copy/paste of a real text box carries the marker HTML unmodified so it
-* keeps working; anything else has the marker stripped defensively.
+* Treat reconstruction attributes as internal only when the HTML carries the
+* unguessable capability created with this editor schema. `data-pm-slice`
+* cannot establish trust because arbitrary external HTML can forge it.
 */
-function stripForeignTextBoxAnchors(html, originalHtml) {
-	if (PM_SLICE_MARKER.test(originalHtml)) return html;
+function hasInternalClipboardCapability(html, token) {
+	if (!token) return false;
+	INTERNAL_CLIPBOARD_ATTR_PATTERN.lastIndex = 0;
+	for (const match of html.matchAll(INTERNAL_CLIPBOARD_ATTR_PATTERN)) if ((match[1] ?? match[2] ?? match[3]) === token) return true;
+	return false;
+}
+function stripForeignTextBoxAnchors(html, internal) {
+	if (internal) return html;
 	return html.replace(TEXTBOX_ANCHOR_ATTR, "");
 }
+function stripForeignBookmarkBoundaries(html, internal) {
+	if (internal) return html;
+	return html.replace(BOOKMARK_BOUNDARY_ATTR, "");
+}
+function stripForeignStructuredFields(html, internal) {
+	if (internal) return html;
+	return html.replace(STRUCTURED_FIELD_ATTR, "");
+}
 /**
 * Remove empty spans left behind after stripping `mso-*` styles. Only truly
 * empty spans are removed (whitespace-only spans are kept so word-separating
 * spacer runs never collapse two words together). Repeated a bounded number of
 * times to unwrap nested empties (`<span><span></span></span>`).
 */
-function stripEmptySpans(html) {
+function stripEmptySpans(html, preserveInternalAtoms) {
 	let current = html;
 	for (let pass = 0; pass < MAX_EMPTY_SPAN_PASSES; pass++) {
-		const next = current.replace(EMPTY_SPAN, "");
+		const next = current.replace(EMPTY_SPAN, (span) => {
+			if (preserveInternalAtoms && /\bdata-docx-(?:bookmark-boundary|textbox-anchor)\s*=/i.test(span)) return span;
+			return "";
+		});
 		if (next === current) break;
 		current = next;
 	}
 	return current;
 }
-/**
-* Strip Office/web producer cruft from a raw clipboard HTML string.
-*
-* Best-effort and non-throwing: any unexpected failure returns the original
-* markup so a paste degrades to the browser default rather than losing content.
-* `<style>` blocks are intentionally left in place for the downstream style
-* inliner, which resolves class-based CSS before the schema parser runs.
-*/
-function cleanPastedHtml(html) {
+function cleanPastedHtml(html, options = {}) {
 	if (!html) return html;
 	try {
+		const internal = hasInternalClipboardCapability(html, options.internalClipboardToken);
 		let cleaned = stripHtmlComments(html);
 		cleaned = stripXmlDeclarations(cleaned);
 		cleaned = cleaned.replace(NAMESPACED_TAG, "");
 		cleaned = cleaned.replace(STRAY_XML_TAG, "");
 		cleaned = cleaned.replace(NOISE_TAG, "");
 		cleaned = stripMsoStyles(cleaned);
-		cleaned = stripEmptySpans(cleaned);
-		cleaned = stripForeignTextBoxAnchors(cleaned, html);
+		cleaned = stripEmptySpans(cleaned, internal);
+		cleaned = stripForeignTextBoxAnchors(cleaned, internal);
+		cleaned = stripForeignBookmarkBoundaries(cleaned, internal);
+		cleaned = stripForeignStructuredFields(cleaned, internal);
+		cleaned = cleaned.replace(INTERNAL_CLIPBOARD_ATTR_PATTERN, "");
 		return cleaned.trim();
 	} catch {
-		return html;
+		return "";
 	}
 }
+/** Remove incomplete or duplicate bookmark pairs at copied slice edges. */
+function removeUnpairedBookmarkBoundaries(slice) {
+	const counts = /* @__PURE__ */ new Map();
+	let boundaryIndex = 0;
+	slice.content.descendants((node) => {
+		if (node.type.name !== "bookmarkBoundary") return true;
+		const result = readBookmarkBoundaryAttrs(node);
+		if (!result.ok) return false;
+		const attrs = result.value;
+		const count = counts.get(attrs.id) ?? {
+			starts: 0,
+			ends: 0
+		};
+		if (attrs.type === "start") {
+			count.starts += 1;
+			count.firstStart ??= boundaryIndex;
+		} else {
+			count.ends += 1;
+			count.firstEnd ??= boundaryIndex;
+		}
+		boundaryIndex += 1;
+		counts.set(attrs.id, count);
+		return false;
+	});
+	const pairedIds = new Set([...counts].flatMap(([id, count]) => count.starts === 1 && count.ends === 1 && count.firstStart !== void 0 && count.firstEnd !== void 0 && count.firstStart < count.firstEnd ? [id] : []));
+	const filterFragment = (fragment) => {
+		const children = [];
+		fragment.forEach((node) => {
+			if (node.type.name === "bookmarkBoundary") {
+				const result = readBookmarkBoundaryAttrs(node);
+				if (result.ok && pairedIds.has(result.value.id)) children.push(node);
+				return;
+			}
+			children.push(node.childCount === 0 ? node : node.copy(filterFragment(node.content)));
+		});
+		return Fragment.fromArray(children);
+	};
+	return new Slice(filterFragment(slice.content), slice.openStart, slice.openEnd);
+}
 //#endregion
-export { cleanPastedHtml };
+export { cleanPastedHtml, removeUnpairedBookmarkBoundaries };

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

@@ -1,3 +1,4 @@
+import { getHorizontalScaleFactor, normalizeHorizontalScalePercent, parseHorizontalScalePercent } from "../../../utils/horizontalScale.js";
 import { formatPx, twipsToPixels } from "../../../utils/units.js";
 import { expectCharacterSpacingMarkAttrs } from "../../attrs/index.js";
 import { createMarkExtension } from "../create.js";
@@ -28,12 +29,13 @@ const CharacterSpacingExtension = createMarkExtension({
 			getAttrs: (dom) => ({
 				spacing: dom.dataset["spacing"] ? Number(dom.dataset["spacing"]) : null,
 				position: dom.dataset["position"] ? Number(dom.dataset["position"]) : null,
-				scale: dom.dataset["scale"] ? Number(dom.dataset["scale"]) : null,
+				scale: parseHorizontalScalePercent(dom.dataset["scale"]),
 				kerning: dom.dataset["kerning"] ? Number(dom.dataset["kerning"]) : null
 			})
 		}],
 		toDOM(mark) {
-			const { spacing, position, scale, kerning } = expectCharacterSpacingMarkAttrs(mark);
+			const { spacing, position, scale: authoredScale, kerning } = expectCharacterSpacingMarkAttrs(mark);
+			const scale = normalizeHorizontalScalePercent(authoredScale);
 			const styles = [];
 			const dataAttrs = { class: "docx-char-spacing" };
 			if (spacing !== void 0 && spacing !== 0) {
@@ -45,10 +47,12 @@ const CharacterSpacingExtension = createMarkExtension({
 				styles.push(`vertical-align: ${formatPx(px)}`);
 				dataAttrs["data-position"] = String(position);
 			}
-			if (scale !== void 0 && scale !== 100) {
-				styles.push(`transform: scaleX(${scale / 100})`);
-				styles.push("display: inline-block");
+			if (scale !== void 0) {
 				dataAttrs["data-scale"] = String(scale);
+				if (scale !== 100) {
+					styles.push(`transform: scaleX(${getHorizontalScaleFactor(scale)})`);
+					styles.push("display: inline-block");
+				}
 			}
 			if (kerning !== void 0) dataAttrs["data-kerning"] = String(kerning);
 			if (styles.length > 0) dataAttrs["style"] = styles.join("; ");

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

@@ -0,0 +1,9 @@
+import { NodeExtension } from "../types.js";
+//#region src/prosemirror/extensions/nodes/BookmarkBoundaryExtension.d.ts
+/** Zero-width bookmark boundary that preserves its position through ProseMirror edits. */
+type BookmarkBoundaryOptions = {
+  getInternalClipboardToken?: () => string;
+};
+declare const BookmarkBoundaryExtension: (options?: Partial<BookmarkBoundaryOptions> | undefined) => NodeExtension;
+//#endregion
+export { BookmarkBoundaryExtension };

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/TableExtension.js

@@ -154,6 +154,7 @@ const tableSpec = {
 		look: { default: null },
 		borders: { default: null },
 		_resolvedIndent: { default: null },
+		_resolvedJustification: { default: null },
 		_resolvedBidi: { default: null },
 		_originalFormatting: { default: null },
 		tblPrChange: { default: null },
@@ -200,6 +201,7 @@ const tableRowSpec = {
 		heightRule: { default: null },
 		isHeader: { default: false },
 		hidden: { default: false },
+		_resolvedJustification: { default: null },
 		_originalFormatting: { default: null },
 		trPrChange: { default: null },
 		trIns: { default: null },

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/extensions/nodes/TextBoxExtension.js

@@ -1,4 +1,4 @@
-import { IMAGE_WRAP_TYPE_VALUES } from "../../../types/documentEnumValues.js";
+import { IMAGE_WRAP_TYPE_VALUES, normalizeShapeTextAnchor } from "../../../types/documentEnumValues.js";
 import { expectTextBoxAttrs } from "../../attrs/index.js";
 import { createNodeExtension } from "../create.js";
 //#region src/prosemirror/extensions/nodes/TextBoxExtension.ts
@@ -21,6 +21,9 @@ function parseTextBoxAutoFit(raw) {
 function parseTextBoxTextWrap(raw) {
 	if (raw === "none" || raw === "square") return raw;
 }
+function parseTextBoxVerticalAlign(raw) {
+	return normalizeShapeTextAnchor(raw);
+}
 const TextBoxExtension = createNodeExtension({
 	name: "textBox",
 	schemaNodeName: "textBox",
@@ -68,6 +71,7 @@ const TextBoxExtension = createNodeExtension({
 				const wrapType = parseTextBoxWrapType(d["wrapType"]);
 				const autoFit = parseTextBoxAutoFit(d["autoFit"]);
 				const textWrap = parseTextBoxTextWrap(d["textWrap"]);
+				const verticalAlign = parseTextBoxVerticalAlign(d["verticalAlign"]);
 				return {
 					...d["width"] ? { width: Number(d["width"]) } : {},
 					...d["height"] ? { height: Number(d["height"]) } : {},
@@ -82,7 +86,7 @@ const TextBoxExtension = createNodeExtension({
 					...d["marginBottom"] ? { marginBottom: Number(d["marginBottom"]) } : {},
 					...d["marginLeft"] ? { marginLeft: Number(d["marginLeft"]) } : {},
 					...d["marginRight"] ? { marginRight: Number(d["marginRight"]) } : {},
-					...d["verticalAlign"] ? { verticalAlign: d["verticalAlign"] } : {},
+					...verticalAlign ? { verticalAlign } : {},
 					...d["displayMode"] ? { displayMode: d["displayMode"] } : {},
 					...d["cssFloat"] ? { cssFloat: d["cssFloat"] } : {},
 					...wrapType ? { wrapType } : {},

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 };