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

package/dist/prosemirror/extensions/core/ParagraphExtension.js

@@ -0,0 +1,619 @@
+import { paragraphToStyle } from "../../../utils/formatToStyle.js";
+import { directionIsRtl } from "../../paragraphDirection.js";
+import { expectParagraphAttrs } from "../../attrs/index.js";
+import { autospacingMatchesBase } from "../../autospacingBase.js";
+import { createNodeExtension } from "../create.js";
+import { collectHeadings } from "../../../utils/headingCollector.js";
+import { listAttrsFromResolvedStyle, paragraphAttrsFromResolvedStyle } from "../../styles/resolvedStyleAttrs.js";
+import { Fragment } from "prosemirror-model";
+//#region src/prosemirror/extensions/core/ParagraphExtension.ts
+/**
+* Paragraph Extension — paragraph node with alignment, spacing, indent, style commands
+*
+* Moves:
+* - NodeSpec from nodes.ts (paragraph, ParagraphAttrs, paragraphAttrsToDOMStyle, getListClass helpers)
+* - Commands from paragraph.ts (alignment, spacing, indent, style)
+*/
+function paragraphAttrsToDOMStyle(attrs) {
+	const rawIndentLeft = Reflect.get(attrs, "indentLeft");
+	let indentLeft = typeof rawIndentLeft === "number" ? rawIndentLeft : void 0;
+	if (attrs.numPr?.numId && (rawIndentLeft === null || rawIndentLeft === void 0)) indentLeft = ((attrs.numPr.ilvl ?? 0) + 1) * 720;
+	const style = paragraphToStyle({
+		...attrs.alignment !== void 0 ? { alignment: attrs.alignment } : {},
+		...attrs.spaceBefore !== void 0 ? { spaceBefore: attrs.spaceBefore } : {},
+		...attrs.spaceAfter !== void 0 ? { spaceAfter: attrs.spaceAfter } : {},
+		...attrs.lineSpacing !== void 0 ? { lineSpacing: attrs.lineSpacing } : {},
+		...attrs.lineSpacingRule !== void 0 ? { lineSpacingRule: attrs.lineSpacingRule } : {},
+		...indentLeft !== void 0 ? { indentLeft } : {},
+		...attrs.indentRight !== void 0 ? { indentRight: attrs.indentRight } : {},
+		...attrs.indentFirstLine !== void 0 ? { indentFirstLine: attrs.indentFirstLine } : {},
+		...attrs.hangingIndent !== void 0 ? { hangingIndent: attrs.hangingIndent } : {},
+		...attrs.borders !== void 0 ? { borders: attrs.borders } : {},
+		...attrs.shading !== void 0 ? { shading: attrs.shading } : {},
+		...autospacingMatchesBase(attrs._autospacingBase, "before", attrs.spaceBefore) ? { beforeAutospacing: true } : {},
+		...autospacingMatchesBase(attrs._autospacingBase, "after", attrs.spaceAfter) ? { afterAutospacing: true } : {}
+	});
+	const customStyle = {};
+	if (style.marginTop) customStyle["--docx-space-before"] = style.marginTop;
+	if (style.marginBottom) customStyle["--docx-space-after"] = style.marginBottom;
+	return Object.entries({
+		...style,
+		...customStyle
+	}).map(([key, value]) => {
+		return `${key.replace(/(?<char>[A-Z])/gu, "-$<char>").toLowerCase()}: ${value}`;
+	}).join("; ");
+}
+function numFmtToClass(numFmt) {
+	switch (numFmt) {
+		case "upperRoman": return "docx-list-upper-roman";
+		case "lowerRoman": return "docx-list-lower-roman";
+		case "upperLetter": return "docx-list-upper-alpha";
+		case "lowerLetter": return "docx-list-lower-alpha";
+		default: return "docx-list-decimal";
+	}
+}
+function getListClass(numPr, listIsBullet, listNumFmt) {
+	if (!numPr?.numId) return "";
+	const level = numPr.ilvl ?? 0;
+	if (listIsBullet) return `docx-list-bullet docx-list-level-${level}`;
+	return `docx-list-numbered ${numFmtToClass(listNumFmt)} docx-list-level-${level}`;
+}
+/**
+* Parse a CSS length value to twips.
+* Supports pt, px, in, cm, mm units. Returns undefined for unparseable values.
+*
+* Conversion factors (1 inch = 1440 twips):
+* - 1pt = 20 twips (1440/72)
+* - 1px = 15 twips (1440/96)
+* - 1cm = 567 twips (1440/2.54, rounded)
+* - 1mm = 56.7 twips (1440/25.4)
+*/
+function cssLengthToTwips(value) {
+	if (!value) return;
+	const trimmed = value.trim();
+	const num = Number.parseFloat(trimmed);
+	if (Number.isNaN(num) || num === 0) return;
+	if (trimmed.endsWith("pt")) return Math.round(num * 20);
+	if (trimmed.endsWith("px")) return Math.round(num * 15);
+	if (trimmed.endsWith("in")) return Math.round(num * 1440);
+	if (trimmed.endsWith("mm")) return Math.round(num * (1440 / 25.4));
+	if (trimmed.endsWith("cm")) return Math.round(num * (1440 / 2.54));
+	if (/^[\d.]+$/u.test(trimmed)) return Math.round(num * 15);
+}
+/**
+* Map CSS text-align value to ParagraphAlignment.
+*/
+function cssTextAlignToAlignment(value) {
+	switch (value.trim().toLowerCase()) {
+		case "left":
+		case "start": return "left";
+		case "center": return "center";
+		case "right":
+		case "end": return "right";
+		case "justify": return "both";
+		default: return;
+	}
+}
+/**
+* Parse CSS line-height to twips.
+* - Unitless multiplier (e.g. "1.5"): 240 twips * multiplier (single=240)
+* - Percentage (e.g. "150%"): 240 twips * (pct/100)
+* - Absolute length (e.g. "18pt"): converted to twips directly with 'exact' rule
+*
+* Returns { lineSpacing, lineSpacingRule } or undefined.
+*/
+function cssLineHeightToSpacing(value) {
+	if (!value || value === "normal") return;
+	const trimmed = value.trim();
+	if (trimmed.endsWith("%")) {
+		const pct = Number.parseFloat(trimmed);
+		if (Number.isNaN(pct) || pct === 0) return;
+		return {
+			lineSpacing: Math.round(240 * (pct / 100)),
+			lineSpacingRule: "auto"
+		};
+	}
+	if (/[a-z]/iu.test(trimmed)) {
+		const twips = cssLengthToTwips(trimmed);
+		if (twips === void 0) return;
+		return {
+			lineSpacing: twips,
+			lineSpacingRule: "exact"
+		};
+	}
+	const multiplier = Number.parseFloat(trimmed);
+	if (Number.isNaN(multiplier) || multiplier === 0) return;
+	return {
+		lineSpacing: Math.round(240 * multiplier),
+		lineSpacingRule: "auto"
+	};
+}
+/**
+* Extract paragraph-level attributes from a pasted HTML <p> element's inline styles.
+* Used by parseDOM to preserve formatting from external apps (Google Docs, Word Online, etc.).
+*/
+function extractParagraphAttrsFromStyle(element) {
+	const style = element.style;
+	const attrs = {};
+	if (style.textAlign) {
+		const alignment = cssTextAlignToAlignment(style.textAlign);
+		if (alignment) attrs.alignment = alignment;
+	}
+	const marginLeft = style.marginLeft || style.paddingLeft;
+	if (marginLeft) {
+		const twips = cssLengthToTwips(marginLeft);
+		if (twips !== void 0) attrs.indentLeft = twips;
+	}
+	const marginRight = style.marginRight || style.paddingRight;
+	if (marginRight) {
+		const twips = cssLengthToTwips(marginRight);
+		if (twips !== void 0) attrs.indentRight = twips;
+	}
+	if (style.textIndent) {
+		const twips = cssLengthToTwips(style.textIndent);
+		if (twips !== void 0) if (twips < 0) {
+			attrs.indentFirstLine = Math.abs(twips);
+			attrs.hangingIndent = true;
+		} else attrs.indentFirstLine = twips;
+	}
+	if (style.lineHeight) {
+		const spacing = cssLineHeightToSpacing(style.lineHeight);
+		if (spacing) {
+			attrs.lineSpacing = spacing.lineSpacing;
+			attrs.lineSpacingRule = spacing.lineSpacingRule;
+		}
+	}
+	if (style.marginTop) {
+		const twips = cssLengthToTwips(style.marginTop);
+		if (twips !== void 0) attrs.spaceBefore = twips;
+	}
+	if (style.marginBottom) {
+		const twips = cssLengthToTwips(style.marginBottom);
+		if (twips !== void 0) attrs.spaceAfter = twips;
+	}
+	return attrs;
+}
+const paragraphNodeSpec = {
+	content: "inline*",
+	group: "block",
+	attrs: {
+		paraId: { default: null },
+		textId: { default: null },
+		alignment: { default: null },
+		spaceBefore: { default: null },
+		spaceAfter: { default: null },
+		lineSpacing: { default: null },
+		lineSpacingRule: { default: null },
+		spacingExplicit: { default: null },
+		indentLeft: { default: null },
+		indentRight: { default: null },
+		indentFirstLine: { default: null },
+		hangingIndent: { default: false },
+		numPr: { default: null },
+		numPrFromStyle: { default: null },
+		listNumFmt: { default: null },
+		listIsBullet: { default: null },
+		listIsLegal: { default: null },
+		listMarker: { default: null },
+		listMarkerHidden: { default: null },
+		listMarkerFontFamily: { default: null },
+		listMarkerFontSize: { default: null },
+		listMarkerSuffix: { default: null },
+		listMarkerAllCaps: { default: null },
+		listImplicitChildLevelAdvances: { default: null },
+		listMarkerSecondSlotOffsetTwips: { default: null },
+		listLevelNumFmts: { default: null },
+		listAbstractNumId: { default: null },
+		listStartOverride: { default: null },
+		styleId: { default: null },
+		borders: { default: null },
+		shading: { default: null },
+		tabs: { default: null },
+		pageBreakBefore: { default: null },
+		renderedPageBreakBefore: { default: null },
+		keepNext: { default: null },
+		keepLines: { default: null },
+		contextualSpacing: { default: null },
+		runInWithNext: { default: null },
+		defaultTextFormatting: { default: null },
+		sectionBreakType: { default: null },
+		direction: { default: null },
+		outlineLevel: { default: null },
+		bookmarks: { default: null },
+		_emptyHyperlinks: { default: null },
+		_originalFormatting: { default: null },
+		_autospacingBase: { default: null },
+		_sectionProperties: { default: null },
+		_propertyChanges: { default: null },
+		pPrMark: { default: null }
+	},
+	parseDOM: [{
+		tag: "p",
+		getAttrs(dom) {
+			if (!(dom instanceof HTMLElement)) return false;
+			const element = dom;
+			const paraId = element.dataset["paraId"];
+			const alignment = element.dataset["alignment"];
+			const styleId = element.dataset["styleId"];
+			const sectionBreakType = element.dataset["sectionBreak"];
+			const attrs = {
+				...paraId ? { paraId } : {},
+				...alignment ? { alignment } : {},
+				...styleId ? { styleId } : {},
+				...sectionBreakType ? { sectionBreakType } : {}
+			};
+			const styleAttrs = extractParagraphAttrsFromStyle(element);
+			const mergedAlignment = attrs.alignment || styleAttrs.alignment;
+			return {
+				...styleAttrs,
+				...attrs,
+				...mergedAlignment !== void 0 ? { alignment: mergedAlignment } : {}
+			};
+		}
+	}, ...[
+		"h1",
+		"h2",
+		"h3",
+		"h4",
+		"h5",
+		"h6"
+	].map((tag) => ({
+		tag,
+		getAttrs(dom) {
+			const level = Number.parseInt(tag.charAt(1), 10);
+			return {
+				...extractParagraphAttrsFromStyle(dom),
+				styleId: `Heading${level}`,
+				outlineLevel: level - 1
+			};
+		}
+	}))],
+	toDOM(node) {
+		const attrs = expectParagraphAttrs(node);
+		const style = paragraphAttrsToDOMStyle(attrs);
+		const listClass = getListClass(attrs.numPr, attrs.listIsBullet, attrs.listNumFmt);
+		const domAttrs = {};
+		if (style) domAttrs["style"] = style;
+		if (listClass) domAttrs["class"] = listClass;
+		if (attrs.paraId) domAttrs["data-para-id"] = attrs.paraId;
+		if (attrs.alignment) domAttrs["data-alignment"] = attrs.alignment;
+		if (attrs.styleId) domAttrs["data-style-id"] = attrs.styleId;
+		if (attrs.listMarker) domAttrs["data-list-marker"] = attrs.listMarker;
+		if (directionIsRtl(attrs.direction)) domAttrs["dir"] = "rtl";
+		if (attrs.sectionBreakType) {
+			domAttrs["data-section-break"] = attrs.sectionBreakType;
+			domAttrs["class"] = `${domAttrs["class"] ? `${domAttrs["class"]} ` : ""}docx-section-break`;
+		}
+		return [
+			"p",
+			domAttrs,
+			0
+		];
+	}
+};
+function setParagraphAttr(attr, value) {
+	return (state, dispatch) => {
+		const { $from, $to } = state.selection;
+		if (!dispatch) return true;
+		let tr = state.tr;
+		const seen = /* @__PURE__ */ new Set();
+		state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
+			if (node.type.name === "paragraph" && !seen.has(pos)) {
+				seen.add(pos);
+				tr = tr.setNodeMarkup(pos, void 0, {
+					...node.attrs,
+					[attr]: value
+				});
+			}
+		});
+		dispatch(tr.scrollIntoView());
+		return true;
+	};
+}
+function setParagraphAttrsCmd(attrs) {
+	return (state, dispatch) => {
+		const { $from, $to } = state.selection;
+		if (!dispatch) return true;
+		let tr = state.tr;
+		const seen = /* @__PURE__ */ new Set();
+		state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
+			if (node.type.name === "paragraph" && !seen.has(pos)) {
+				seen.add(pos);
+				tr = tr.setNodeMarkup(pos, void 0, {
+					...node.attrs,
+					...attrs
+				});
+			}
+		});
+		dispatch(tr.scrollIntoView());
+		return true;
+	};
+}
+function makeSetAlignment(alignment) {
+	return (state, dispatch) => setParagraphAttr("alignment", alignment)(state, dispatch);
+}
+function makeSetLineSpacing(value, rule = "auto") {
+	return (state, dispatch) => setParagraphAttrsCmd({
+		lineSpacing: value,
+		lineSpacingRule: rule
+	})(state, dispatch);
+}
+function makeIncreaseIndent(amount = 720) {
+	return (state, dispatch) => {
+		const { $from, $to } = state.selection;
+		if (!dispatch) return true;
+		let tr = state.tr;
+		const seen = /* @__PURE__ */ new Set();
+		state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
+			if (node.type.name === "paragraph" && !seen.has(pos)) {
+				seen.add(pos);
+				const currentIndent = node.attrs["indentLeft"] || 0;
+				tr = tr.setNodeMarkup(pos, void 0, {
+					...node.attrs,
+					indentLeft: currentIndent + amount
+				});
+			}
+		});
+		dispatch(tr.scrollIntoView());
+		return true;
+	};
+}
+function makeDecreaseIndent(amount = 720) {
+	return (state, dispatch) => {
+		const { $from, $to } = state.selection;
+		if (!dispatch) return true;
+		let tr = state.tr;
+		const seen = /* @__PURE__ */ new Set();
+		state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
+			if (node.type.name === "paragraph" && !seen.has(pos)) {
+				seen.add(pos);
+				const currentIndent = node.attrs["indentLeft"] || 0;
+				const newIndent = Math.max(0, currentIndent - amount);
+				tr = tr.setNodeMarkup(pos, void 0, {
+					...node.attrs,
+					indentLeft: newIndent > 0 ? newIndent : null
+				});
+			}
+		});
+		dispatch(tr.scrollIntoView());
+		return true;
+	};
+}
+function makeApplyStyle(schema) {
+	return (styleId, resolvedAttrs) => (state, dispatch) => {
+		const { $from, $to } = state.selection;
+		if (!dispatch) return true;
+		let tr = state.tr;
+		const seen = /* @__PURE__ */ new Set();
+		const styleMarks = [];
+		if (resolvedAttrs?.runFormatting) {
+			const rpr = resolvedAttrs.runFormatting;
+			if (rpr.bold && schema.marks["bold"]) styleMarks.push(schema.marks["bold"].create());
+			if (rpr.italic && schema.marks["italic"]) styleMarks.push(schema.marks["italic"].create());
+			if (rpr.fontSize && schema.marks["fontSize"]) styleMarks.push(schema.marks["fontSize"].create({ size: rpr.fontSize }));
+			if (rpr.fontFamily && schema.marks["fontFamily"]) styleMarks.push(schema.marks["fontFamily"].create({
+				ascii: rpr.fontFamily.ascii,
+				hAnsi: rpr.fontFamily.hAnsi,
+				asciiTheme: rpr.fontFamily.asciiTheme
+			}));
+			if (rpr.color && !rpr.color.auto && schema.marks["textColor"]) styleMarks.push(schema.marks["textColor"].create({
+				rgb: rpr.color.rgb,
+				themeColor: rpr.color.themeColor,
+				themeTint: rpr.color.themeTint,
+				themeShade: rpr.color.themeShade
+			}));
+			if (rpr.underline && rpr.underline.style !== "none" && schema.marks["underline"]) styleMarks.push(schema.marks["underline"].create({
+				style: rpr.underline.style,
+				color: rpr.underline.color
+			}));
+			if ((rpr.strike || rpr.doubleStrike) && schema.marks["strike"]) styleMarks.push(schema.marks["strike"].create({ double: rpr.doubleStrike || false }));
+		}
+		const styleControlledMarks = [
+			schema.marks["bold"],
+			schema.marks["italic"],
+			schema.marks["fontSize"],
+			schema.marks["fontFamily"],
+			schema.marks["textColor"],
+			schema.marks["underline"],
+			schema.marks["strike"]
+		].filter(Boolean);
+		state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
+			if (node.type.name === "paragraph" && !seen.has(pos)) {
+				seen.add(pos);
+				const newAttrs = {
+					...node.attrs,
+					styleId
+				};
+				if (resolvedAttrs) {
+					Object.assign(newAttrs, paragraphAttrsFromResolvedStyle(resolvedAttrs));
+					const listAttrs = listAttrsFromResolvedStyle(resolvedAttrs, resolvedAttrs.numbering);
+					if (listAttrs) Object.assign(newAttrs, listAttrs);
+				}
+				tr = tr.setNodeMarkup(pos, void 0, newAttrs);
+				if (resolvedAttrs) {
+					const paragraphStart = pos + 1;
+					const paragraphEnd = pos + node.nodeSize - 1;
+					if (paragraphEnd > paragraphStart) {
+						for (const markType of styleControlledMarks) tr = tr.removeMark(paragraphStart, paragraphEnd, markType);
+						for (const mark of styleMarks) tr = tr.addMark(paragraphStart, paragraphEnd, mark);
+					}
+				}
+			}
+		});
+		if (styleMarks.length > 0) tr = tr.setStoredMarks(styleMarks);
+		dispatch(tr.scrollIntoView());
+		return true;
+	};
+}
+function getParagraphAlignment(state) {
+	const { $from } = state.selection;
+	const paragraph = $from.parent;
+	if (paragraph.type.name !== "paragraph") return null;
+	return paragraph.attrs["alignment"] || null;
+}
+function getParagraphTabs(state) {
+	const { $from } = state.selection;
+	const paragraph = $from.parent;
+	if (paragraph.type.name !== "paragraph") return null;
+	return paragraph.attrs["tabs"] || null;
+}
+function getStyleId(state) {
+	const { $from } = state.selection;
+	const paragraph = $from.parent;
+	if (paragraph.type.name !== "paragraph") return null;
+	return paragraph.attrs["styleId"] || null;
+}
+function getParagraphBidi(state) {
+	const { $from } = state.selection;
+	const paragraph = $from.parent;
+	if (paragraph.type.name !== "paragraph") return false;
+	return directionIsRtl(paragraph.attrs["direction"]);
+}
+const ParagraphExtension = createNodeExtension({
+	name: "paragraph",
+	schemaNodeName: "paragraph",
+	nodeSpec: paragraphNodeSpec,
+	onSchemaReady(ctx) {
+		const applyStyleFn = makeApplyStyle(ctx.schema);
+		return { commands: {
+			setAlignment: (alignment) => makeSetAlignment(alignment),
+			alignLeft: () => makeSetAlignment("left"),
+			alignCenter: () => makeSetAlignment("center"),
+			alignRight: () => makeSetAlignment("right"),
+			alignJustify: () => makeSetAlignment("both"),
+			setLineSpacing: (value, rule) => makeSetLineSpacing(value, rule),
+			singleSpacing: () => makeSetLineSpacing(240),
+			oneAndHalfSpacing: () => makeSetLineSpacing(360),
+			doubleSpacing: () => makeSetLineSpacing(480),
+			setSpaceBefore: (twips) => setParagraphAttr("spaceBefore", twips),
+			setSpaceAfter: (twips) => setParagraphAttr("spaceAfter", twips),
+			increaseIndent: (amount) => makeIncreaseIndent(amount),
+			decreaseIndent: (amount) => makeDecreaseIndent(amount),
+			setIndentLeft: (twips) => setParagraphAttr("indentLeft", twips > 0 ? twips : null),
+			setIndentRight: (twips) => setParagraphAttr("indentRight", twips > 0 ? twips : null),
+			setIndentFirstLine: (twips, hanging) => setParagraphAttrsCmd({
+				indentFirstLine: twips > 0 ? twips : null,
+				hangingIndent: hanging ?? false
+			}),
+			applyStyle: (styleId, resolvedAttrs) => applyStyleFn(styleId, resolvedAttrs),
+			clearStyle: () => setParagraphAttr("styleId", null),
+			insertSectionBreak: (breakType) => setParagraphAttr("sectionBreakType", breakType),
+			removeSectionBreak: () => setParagraphAttr("sectionBreakType", null),
+			generateTOC: () => (state, dispatch) => {
+				const headings = collectHeadings(state.doc);
+				if (headings.length === 0) return false;
+				if (!dispatch) return true;
+				const { schema: s } = state;
+				const tr = state.tr;
+				const bookmarkEntries = [];
+				for (const h of headings) {
+					const bookmarkName = `_Toc${Math.floor(1e8 + Math.random() * 9e8)}`;
+					bookmarkEntries.push({
+						name: bookmarkName,
+						level: h.level,
+						text: h.text
+					});
+					const mappedPos = tr.mapping.map(h.pmPos);
+					const paragraphNode = tr.doc.resolve(mappedPos).nodeAfter;
+					if (paragraphNode && paragraphNode.type.name === "paragraph") {
+						const newBookmarks = [...(paragraphNode.attrs["bookmarks"] ?? []).filter((b) => !b.name.startsWith("_Toc")), {
+							id: Math.floor(Math.random() * 2147483647),
+							name: bookmarkName
+						}];
+						tr.setNodeMarkup(mappedPos, void 0, {
+							...paragraphNode.attrs,
+							bookmarks: newBookmarks
+						});
+					}
+				}
+				const tocNodes = [];
+				tocNodes.push(s.node("paragraph", {
+					styleId: "TOCHeading",
+					alignment: "center"
+				}, [s.text("Table of Contents", s.marks["bold"] ? [s.marks["bold"].create()] : [])]));
+				const DEFAULT_MARGIN_TWIPS = 1440;
+				let tocTabStopTwips = 12240 - 2 * DEFAULT_MARGIN_TWIPS;
+				let tabStopResolved = false;
+				state.doc.descendants((node) => {
+					if (tabStopResolved || node.type.name !== "paragraph") return;
+					const sp = node.attrs["_sectionProperties"];
+					if (sp && typeof sp.pageWidth === "number" && sp.pageWidth > 0) {
+						const left = typeof sp.marginLeft === "number" ? sp.marginLeft : DEFAULT_MARGIN_TWIPS;
+						const right = typeof sp.marginRight === "number" ? sp.marginRight : DEFAULT_MARGIN_TWIPS;
+						tocTabStopTwips = sp.pageWidth - left - right;
+						tabStopResolved = true;
+					}
+				});
+				const canPageNumber = Boolean(s.nodes["field"] && s.nodes["tab"]);
+				for (const entry of bookmarkEntries) {
+					const indent = entry.level * 720;
+					const tocStyleId = `TOC${entry.level + 1}`;
+					if (!s.marks["hyperlink"]) continue;
+					const linkMark = s.marks["hyperlink"].create({ href: `#${entry.name}` });
+					const content = [s.text(entry.text, [linkMark])];
+					if (canPageNumber) content.push(s.node("tab"), s.node("field", {
+						fieldType: "PAGEREF",
+						instruction: `PAGEREF ${entry.name} \\h`,
+						displayText: "1",
+						fieldKind: "complex",
+						fldLock: false,
+						dirty: true
+					}));
+					tocNodes.push(s.node("paragraph", {
+						styleId: tocStyleId,
+						indentLeft: indent > 0 ? indent : null,
+						...canPageNumber ? { tabs: [{
+							position: tocTabStopTwips,
+							alignment: "right",
+							leader: "dot"
+						}] } : {}
+					}, content));
+				}
+				const insertPos = tr.mapping.map(state.selection.from);
+				tr.insert(insertPos, Fragment.from(tocNodes));
+				dispatch(tr.scrollIntoView());
+				return true;
+			},
+			toggleBidi: () => (state, dispatch) => {
+				const { $from } = state.selection;
+				const paragraph = $from.parent;
+				if (paragraph.type.name !== "paragraph") return false;
+				return setParagraphAttr("direction", directionIsRtl(paragraph.attrs["direction"]) ? {
+					source: "manual",
+					value: "ltr"
+				} : {
+					source: "manual",
+					value: "rtl"
+				})(state, dispatch);
+			},
+			setRtl: () => setParagraphAttr("direction", {
+				source: "manual",
+				value: "rtl"
+			}),
+			setLtr: () => setParagraphAttr("direction", {
+				source: "manual",
+				value: "ltr"
+			}),
+			setTabs: (tabs) => setParagraphAttr("tabs", tabs.length > 0 ? tabs : null),
+			addTabStop: (position, alignment = "left", leader = "none") => (state, dispatch) => {
+				const { $from } = state.selection;
+				const paragraph = $from.parent;
+				if (paragraph.type.name !== "paragraph") return false;
+				return setParagraphAttr("tabs", [...(paragraph.attrs["tabs"] || []).filter((t) => t.position !== position), {
+					position,
+					alignment,
+					leader
+				}].toSorted((a, b) => a.position - b.position))(state, dispatch);
+			},
+			removeTabStop: (position) => (state, dispatch) => {
+				const { $from } = state.selection;
+				const paragraph = $from.parent;
+				if (paragraph.type.name !== "paragraph") return false;
+				const newTabs = (paragraph.attrs["tabs"] || []).filter((t) => t.position !== position);
+				return setParagraphAttr("tabs", newTabs.length > 0 ? newTabs : null)(state, dispatch);
+			}
+		} };
+	}
+});
+//#endregion
+export { ParagraphExtension, getParagraphAlignment, getParagraphBidi, getParagraphTabs, getStyleId };

package/dist/prosemirror/extensions/core/TextExtension.d.ts

@@ -0,0 +1,9 @@
+import { NodeExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/core/TextExtension.d.ts
+/**
+ * Text Extension — inline text node
+ */
+declare const TextExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion
+export { TextExtension };

package/dist/prosemirror/extensions/core/TextExtension.js

@@ -0,0 +1,12 @@
+import { createNodeExtension } from "../create.js";
+//#region src/prosemirror/extensions/core/TextExtension.ts
+/**
+* Text Extension — inline text node
+*/
+const TextExtension = createNodeExtension({
+	name: "text",
+	schemaNodeName: "text",
+	nodeSpec: { group: "inline" }
+});
+//#endregion
+export { TextExtension };

package/dist/prosemirror/extensions/create.d.ts

@@ -0,0 +1,17 @@
+import { Extension, ExtensionDefinition, MarkExtension, MarkExtensionDefinition, NodeExtension, NodeExtensionDefinition } from "./types.js";
+
+//#region src/prosemirror/extensions/create.d.ts
+/**
+ * Create a generic extension (plugins, commands, keymaps — no schema contribution)
+ */
+declare function createExtension<TOptions extends Record<string, unknown> = Record<string, unknown>>(def: ExtensionDefinition<TOptions>): (options?: Partial<TOptions>) => Extension;
+/**
+ * Create a node extension (contributes a NodeSpec to the schema)
+ */
+declare function createNodeExtension<TOptions extends Record<string, unknown> = Record<string, unknown>>(def: NodeExtensionDefinition<TOptions>): (options?: Partial<TOptions>) => NodeExtension;
+/**
+ * Create a mark extension (contributes a MarkSpec to the schema)
+ */
+declare function createMarkExtension<TOptions extends Record<string, unknown> = Record<string, unknown>>(def: MarkExtensionDefinition<TOptions>): (options?: Partial<TOptions>) => MarkExtension;
+//#endregion
+export { createExtension, createMarkExtension, createNodeExtension };