@docen/docx 0.3.1 → 0.3.2

package/dist/extensions/image.mjs

@@ -1,2 +1,396 @@
-import { i as renderDocx, n as parseDocx, r as renderCropAttrs, t as Image } from "../image-CuEIXoZl.mjs";
+import { Image as Image$1 } from "./tiptap.mjs";
+import { floatAnchorScope, floatingToStyles } from "./utils.mjs";
+import { convertEmuToPixels } from "@office-open/core";
+//#region src/extensions/image.ts
+/**
+* Custom Image extension with node-level renderHTML + renderDocx/parseDocx.
+*
+* Attrs:
+*  - src/alt/title/width/height: Tiptap structural names (kept verbatim so base
+*    image commands work).
+*  - rotation: editor display only (CSS transform) but also carried through DOCX
+*    via transformation.rotation (MediaTransformation.rotation).
+*  - floating/outline: nested office-open objects (Floating / OutlineOptions).
+*  - crop: nested office-open SourceRectangleOptions (srcRect).
+*  - display: editor-only display hint, no OOXML equivalent.
+*
+* DOCX round-trip is near-identity: renderDocx packs attrs into CoreImageOptions;
+* parseDocx unpacks them back. src is a data URL ↔ { type, data } base64.
+* Node-level renderHTML solves the style merge problem (rotation + floating).
+*/
+/** Attribute spec for a nested office-open value stored as JSON in a data-* attr. */
+const attrDataJson = (name) => ({
+	default: null,
+	rendered: false,
+	parseHTML: (element) => {
+		const raw = element.getAttribute(name);
+		if (!raw) return null;
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	}
+});
+/**
+* Tiptap JSON image node → CoreImageOptions-shaped object.
+*
+* Returns `{ image: ImageOptions }` (structural wrapper) or null when no
+* embedded image data is available (external URLs need pre-fetching).
+* rotation is carried via transformation.rotation (not dropped).
+*/
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const imageOpts = {};
+	const src = attrs.src;
+	if (src?.startsWith("data:image/")) {
+		const match = src.match(/^data:image\/([\w.+-]+);base64,(.+)$/);
+		if (match) {
+			imageOpts.type = match[1] === "jpeg" ? "jpg" : match[1];
+			const binary = atob(match[2]);
+			const bytes = new Uint8Array(binary.length);
+			for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+			imageOpts.data = bytes;
+		}
+	}
+	if (!imageOpts.data) return null;
+	const width = attrs.width ?? 600;
+	const height = attrs.height ?? 400;
+	const transformation = {
+		width: `${width}px`,
+		height: `${height}px`
+	};
+	const rotation = attrs.rotation;
+	if (rotation != null) transformation.rotation = rotation;
+	imageOpts.transformation = transformation;
+	const altText = {};
+	if (attrs.alt) altText.name = attrs.alt;
+	if (attrs.title) altText.description = attrs.title;
+	if (Object.keys(altText).length > 0) imageOpts.altText = altText;
+	if (attrs.floating) imageOpts.floating = attrs.floating;
+	if (attrs.crop) imageOpts.sourceRectangle = attrs.crop;
+	if (attrs.outline) imageOpts.outline = attrs.outline;
+	if (attrs.nonVisualProperties) imageOpts.nonVisualProperties = attrs.nonVisualProperties;
+	if (attrs.effectExtent) transformation.effectExtent = attrs.effectExtent;
+	if (attrs.graphicFrameLocks) imageOpts.graphicFrameLocks = attrs.graphicFrameLocks;
+	if (attrs.blipEffects) imageOpts.blipEffects = attrs.blipEffects;
+	if (attrs.useLocalDpi !== null && attrs.useLocalDpi !== void 0) imageOpts.useLocalDpi = attrs.useLocalDpi;
+	if (attrs.fill) imageOpts.fill = attrs.fill;
+	if (attrs.effects) imageOpts.effects = attrs.effects;
+	if (attrs.tile) imageOpts.tile = attrs.tile;
+	if (attrs.runPropertiesRawXml) imageOpts.runPropertiesRawXml = attrs.runPropertiesRawXml;
+	return { image: imageOpts };
+}
+/**
+* ImageOptions-shaped object → Tiptap attrs.
+*
+* Near-identity unpack: transformation → width/height/rotation, altText → alt/title,
+* floating/srcRect(→crop)/outline passed through verbatim. src is reconstructed by
+* DocxManager from the image data bytes (kept out of parseDocx).
+*/
+function parseDocx(imageOpts) {
+	const opts = imageOpts ?? {};
+	const attrs = {};
+	const transformation = opts.transformation;
+	if (transformation) {
+		if (typeof transformation.width === "number") attrs.width = convertEmuToPixels(transformation.width);
+		if (typeof transformation.height === "number") attrs.height = convertEmuToPixels(transformation.height);
+		if (typeof transformation.rotation === "number") attrs.rotation = transformation.rotation;
+	}
+	const altText = opts.altText;
+	if (altText) {
+		if (altText.name) attrs.alt = altText.name;
+		if (altText.description) attrs.title = altText.description;
+	}
+	if (opts.floating) attrs.floating = opts.floating;
+	if (opts.sourceRectangle) attrs.crop = opts.sourceRectangle;
+	if (opts.outline) attrs.outline = opts.outline;
+	if (opts.nonVisualProperties) attrs.nonVisualProperties = opts.nonVisualProperties;
+	const effectExtent = opts.transformation?.effectExtent;
+	if (effectExtent) attrs.effectExtent = effectExtent;
+	if (opts.graphicFrameLocks) attrs.graphicFrameLocks = opts.graphicFrameLocks;
+	if (opts.blipEffects) attrs.blipEffects = opts.blipEffects;
+	if (opts.useLocalDpi !== void 0) attrs.useLocalDpi = opts.useLocalDpi;
+	if (opts.fill) attrs.fill = opts.fill;
+	if (opts.effects) attrs.effects = opts.effects;
+	if (opts.tile) attrs.tile = opts.tile;
+	if (opts.runPropertiesRawXml) attrs.runPropertiesRawXml = opts.runPropertiesRawXml;
+	return attrs;
+}
+/**
+* Render crop as the inner <img> style for byte-accurate four-sided srcRect.
+*
+* object-fit:cover scales uniformly, so it only matches single-axis crops.
+* Instead the inner <img> is sized to the un-cropped display size per axis
+* (imgW = W/visibleW, imgH = H/visibleH) and translated so the visible srcRect
+* region maps exactly onto the extent box; the outer box clips (overflow:hidden)
+* the cropped-out left/top region. Mathematically equivalent to a
+* background-size/background-position crop, but keeps a real <img> (alt,
+* accessibility, semantics, drag-to-save).
+*/
+function renderCropAttrs(crop, ctx = {}) {
+	const c = crop;
+	const leftPct = (c.left || 0) / 1e5;
+	const topPct = (c.top || 0) / 1e5;
+	const rightPct = (c.right || 0) / 1e5;
+	const bottomPct = (c.bottom || 0) / 1e5;
+	const visibleW = 1 - leftPct - rightPct;
+	const visibleH = 1 - topPct - bottomPct;
+	const w = ctx.width ?? 0;
+	const h = ctx.height ?? 0;
+	const imgW = visibleW > 0 ? w / visibleW : w;
+	const imgH = visibleH > 0 ? h / visibleH : h;
+	const offX = -(leftPct * imgW);
+	const offY = -(topPct * imgH);
+	return { style: [
+		"display:block",
+		`width:${imgW.toFixed(2)}px`,
+		`height:${imgH.toFixed(2)}px`,
+		`transform:translate(${offX.toFixed(2)}px,${offY.toFixed(2)}px)`,
+		"transform-origin:0 0"
+	].join(";") };
+}
+function renderImageStyles(attrs) {
+	const styles = [];
+	if (attrs.display) styles.push(`display:${attrs.display}`);
+	else if (!attrs.floating) styles.push("display:inline-block");
+	if (attrs.rotation) styles.push(`transform:rotate(${attrs.rotation}deg)`);
+	if (attrs.floating) styles.push(...floatingToStyles(attrs.floating, attrs.src, attrs.width));
+	return styles;
+}
+/** Office vector (GDI) formats the browser cannot decode — EMF/WMF render as
+*  a labeled placeholder (Image.renderHTML) instead of an <img> that decodes
+*  to naturalWidth 0 (an empty box). */
+function isVectorImage(src) {
+	return typeof src === "string" && /^data:image\/(?:x-)?(?:emf|wmf)/i.test(src);
+}
+/**
+* Stamp the nested office-open attrs onto an HTML attribute map as JSON
+* data-* pairs. Shared by the cropped-div and plain-img render branches so the
+* fidelity fields (floating/outline/nonVisualProperties/…) round-trip through
+* HTML identically. `crop` is handled separately (crop branch only).
+*/
+const RAW_ATTR_DATA = [
+	["floating", "data-floating"],
+	["outline", "data-outline"],
+	["nonVisualProperties", "data-non-visual"],
+	["effectExtent", "data-effect-extent"],
+	["graphicFrameLocks", "data-graphic-frame-locks"],
+	["blipEffects", "data-blip-effects"],
+	["useLocalDpi", "data-use-local-dpi"],
+	["fill", "data-fill"],
+	["effects", "data-effects"],
+	["tile", "data-tile"],
+	["runPropertiesRawXml", "data-run-properties-raw-xml"]
+];
+function attachRawAttrs(target, attrs) {
+	for (const [attr, data] of RAW_ATTR_DATA) {
+		const value = attrs[attr];
+		if (value !== null && value !== void 0) target[data] = JSON.stringify(value);
+	}
+}
+const Image = Image$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			display: {
+				default: null,
+				rendered: false,
+				parseHTML: () => this.options.inline ? "inline-block" : null
+			},
+			rotation: {
+				default: null,
+				rendered: false,
+				parseHTML: (element) => {
+					const match = (element.getAttribute("style") || "").match(/transform:\s*rotate\(([\d.]+)deg\)/);
+					return match ? parseFloat(match[1]) : null;
+				}
+			},
+			width: { parseHTML: (element) => {
+				const attr = element.getAttribute("width");
+				if (attr != null) {
+					const n = parseFloat(attr);
+					if (!Number.isNaN(n)) return n;
+				}
+				const m = (element.getAttribute("style") || "").match(/(?:^|;)\s*width:\s*([\d.]+)px/);
+				return m ? parseFloat(m[1]) : null;
+			} },
+			height: { parseHTML: (element) => {
+				const attr = element.getAttribute("height");
+				if (attr != null) {
+					const n = parseFloat(attr);
+					if (!Number.isNaN(n)) return n;
+				}
+				const m = (element.getAttribute("style") || "").match(/(?:^|;)\s*height:\s*([\d.]+)px/);
+				return m ? parseFloat(m[1]) : null;
+			} },
+			floating: {
+				default: null,
+				rendered: false,
+				parseHTML: (element) => {
+					const raw = element.getAttribute("data-floating");
+					if (!raw) return null;
+					try {
+						return JSON.parse(raw);
+					} catch {
+						return null;
+					}
+				}
+			},
+			outline: {
+				default: null,
+				rendered: false,
+				parseHTML: (element) => {
+					const raw = element.getAttribute("data-outline");
+					if (!raw) return null;
+					try {
+						return JSON.parse(raw);
+					} catch {
+						return null;
+					}
+				}
+			},
+			crop: {
+				default: null,
+				rendered: false,
+				parseHTML: (element) => {
+					const raw = element.getAttribute("data-crop");
+					if (!raw) return null;
+					try {
+						return JSON.parse(raw);
+					} catch {
+						return null;
+					}
+				}
+			},
+			nonVisualProperties: attrDataJson("data-non-visual"),
+			effectExtent: attrDataJson("data-effect-extent"),
+			graphicFrameLocks: attrDataJson("data-graphic-frame-locks"),
+			blipEffects: attrDataJson("data-blip-effects"),
+			useLocalDpi: attrDataJson("data-use-local-dpi"),
+			fill: attrDataJson("data-fill"),
+			effects: attrDataJson("data-effects"),
+			tile: attrDataJson("data-tile"),
+			runPropertiesRawXml: attrDataJson("data-run-properties-raw-xml")
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const attrs = node.attrs;
+		const floatAnchor = attrs.floating && floatAnchorScope(attrs.floating) === "paragraph" ? "paragraph" : null;
+		if (isVectorImage(attrs.src)) {
+			const styles = renderImageStyles(attrs);
+			if (attrs.width != null) styles.push(`width:${attrs.width}px`);
+			if (attrs.height != null) styles.push(`height:${attrs.height}px`);
+			const divAttrs = {
+				"data-image": "vector",
+				role: "img",
+				"data-vector-src": attrs.src,
+				style: styles.join(";")
+			};
+			if (attrs.alt) divAttrs["aria-label"] = attrs.alt;
+			if (attrs.title) divAttrs["title"] = attrs.title;
+			attachRawAttrs(divAttrs, attrs);
+			if (floatAnchor) divAttrs["data-float-anchor"] = floatAnchor;
+			return [
+				"div",
+				divAttrs,
+				"Vector image"
+			];
+		}
+		if (attrs.crop) {
+			const width = attrs.width;
+			const height = attrs.height;
+			const boxStyles = renderImageStyles(attrs);
+			boxStyles.push("overflow:hidden", `width:${width}px`, `height:${height}px`);
+			const crop = renderCropAttrs(attrs.crop, {
+				width,
+				height
+			});
+			const boxAttrs = {
+				"data-image": "crop",
+				style: boxStyles.join(";")
+			};
+			attachRawAttrs(boxAttrs, attrs);
+			boxAttrs["data-crop"] = JSON.stringify(attrs.crop);
+			if (floatAnchor) boxAttrs["data-float-anchor"] = floatAnchor;
+			const imgAttrs = {
+				src: attrs.src,
+				style: crop.style
+			};
+			if (attrs.alt) imgAttrs.alt = attrs.alt;
+			if (attrs.title) imgAttrs.title = attrs.title;
+			return [
+				"span",
+				boxAttrs,
+				["img", imgAttrs]
+			];
+		}
+		const htmlAttrs = { ...HTMLAttributes };
+		const styles = renderImageStyles(attrs);
+		if (styles.length > 0) htmlAttrs.style = styles.join(";");
+		attachRawAttrs(htmlAttrs, attrs);
+		if (floatAnchor) htmlAttrs["data-float-anchor"] = floatAnchor;
+		return ["img", htmlAttrs];
+	},
+	parseHTML() {
+		return [
+			{
+				tag: "span[data-image=crop]",
+				getAttrs: (el) => parseCropDiv(el)
+			},
+			{
+				tag: "div[data-image=vector]",
+				getAttrs: (el) => parseVectorDiv(el)
+			},
+			{ tag: "img[src]" }
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+/**
+* Reverse-parse a cropped span[extent-box] back into image attrs.
+*
+* src/alt/title live on the inner <img>; width/height on the outer box inline
+* style (the extent box, not the img's un-cropped display size).
+* rotation/crop/floating/outline are left to their attribute parseHTML rules,
+* which read the style/data-* the box carries.
+*/
+function parseCropDiv(el) {
+	const attrs = {};
+	const img = el.querySelector("img");
+	if (img) {
+		const src = img.getAttribute("src");
+		if (src) attrs.src = src;
+		const alt = img.getAttribute("alt");
+		if (alt) attrs.alt = alt;
+		const title = img.getAttribute("title");
+		if (title) attrs.title = title;
+	}
+	const style = el.getAttribute("style") || "";
+	const wMatch = style.match(/(?:^|;)\s*width:\s*([\d.]+)px/);
+	const hMatch = style.match(/(?:^|;)\s*height:\s*([\d.]+)px/);
+	if (wMatch) attrs.width = parseFloat(wMatch[1]);
+	if (hMatch) attrs.height = parseFloat(hMatch[1]);
+	return attrs;
+}
+/** Reverse-parse an EMF/WMF placeholder div back into image attrs: src from
+*  data-vector-src, extent from the inline width/height, alt/title from
+*  aria-label/title. Floating/rotation/etc. round-trip via attribute rules. */
+function parseVectorDiv(el) {
+	const attrs = {};
+	const src = el.getAttribute("data-vector-src");
+	if (src) attrs.src = src;
+	const style = el.getAttribute("style") || "";
+	const wMatch = style.match(/(?:^|;)\s*width:\s*([\d.]+)px/);
+	const hMatch = style.match(/(?:^|;)\s*height:\s*([\d.]+)px/);
+	if (wMatch) attrs.width = parseFloat(wMatch[1]);
+	if (hMatch) attrs.height = parseFloat(hMatch[1]);
+	const ariaLabel = el.getAttribute("aria-label");
+	if (ariaLabel) attrs.alt = ariaLabel;
+	const title = el.getAttribute("title");
+	if (title) attrs.title = title;
+	return attrs;
+}
+//#endregion
 export { Image, parseDocx, renderCropAttrs, renderDocx };

package/dist/extensions/index.d.mts

@@ -1,3 +1,4 @@
 import { n as createDocument, t as Document } from "../document-BH1y4qHM.mjs";
-import { c as DocxKit, d as docxExtensions, f as tiptapMarkExtensions, l as DocxKitOptions, p as tiptapNodeExtensions } from "../core-fBMCCj4D.mjs";
-export { Document, DocxKit, type DocxKitOptions, createDocument, docxExtensions, tiptapMarkExtensions, tiptapNodeExtensions };
+import { c as PageBreak, f as docxExtensions, l as DocxKit, m as tiptapNodeExtensions, p as tiptapMarkExtensions, u as DocxKitOptions } from "../core-C9VunJ8o.mjs";
+import { b as sectionLinePitchCss, k as twipsToMm, v as resolveFontName, x as sectionMarginCss, y as resolvePageSize } from "../utils-D87vukzp.mjs";
+export { Document, DocxKit, type DocxKitOptions, PageBreak, createDocument, docxExtensions, resolveFontName, resolvePageSize, sectionLinePitchCss, sectionMarginCss, tiptapMarkExtensions, tiptapNodeExtensions, twipsToMm };

package/dist/extensions/index.mjs

@@ -1,3 +1,4 @@
-import { a as DocxKit, c as tiptapMarkExtensions, l as tiptapNodeExtensions, s as docxExtensions } from "../core-DEqBHRzE.mjs";
-import { n as createDocument, t as Document } from "../document-CvTym-FM.mjs";
-export { Document, DocxKit, createDocument, docxExtensions, tiptapMarkExtensions, tiptapNodeExtensions };
+import { a as DocxKit, c as tiptapMarkExtensions, g as PageBreak, l as tiptapNodeExtensions, s as docxExtensions } from "../core-DT9IrTzN.mjs";
+import { Document, createDocument } from "./document.mjs";
+import { resolveFontName, resolvePageSize, sectionLinePitchCss, sectionMarginCss, twipsToMm } from "./utils.mjs";
+export { Document, DocxKit, PageBreak, createDocument, docxExtensions, resolveFontName, resolvePageSize, sectionLinePitchCss, sectionMarginCss, tiptapMarkExtensions, tiptapNodeExtensions, twipsToMm };

package/dist/extensions/mention.d.mts

@@ -1,4 +1,4 @@
-import { C as Mention } from "../tiptap-TErPjuNJ.mjs";
+import { b as Mention } from "../tiptap-pZsNPsvV.mjs";
 
 //#region src/extensions/mention.d.ts
 /**

package/dist/extensions/mention.mjs

@@ -1,3 +1,44 @@
-import { C as Mention } from "../tiptap-D7pl4I5U.mjs";
-import { i as readMention, n as createMention, r as isMention, t as MENTION_TAG } from "../mention-C-dTR6MK.mjs";
+import { Mention } from "./tiptap.mjs";
+//#region src/extensions/mention.ts
+/**
+* Mention extension — owns the DOCX expression of an inline mention.
+*
+* A mention is an atom node carrying `{ id, label }`. DOCX has no mention
+* element, but an inline text-SDT (CT_SdtRun) is a reversible carrier: the
+* `id` rides in the SDT alias, the `label` as the SDT's run text, and a fixed
+* tag marks the type so resolve can recover the mention. (customXml would also
+* carry the id but triggers Word's i4i patent warning; SDT does not.)
+*/
+/** SDT tag marking a mention content control. */
+const MENTION_TAG = "docen-mention";
+/** Inline text-SDT carrying a mention (id in alias, label as run text). */
+function createMention(id, label) {
+	return { sdt: {
+		properties: {
+			tag: MENTION_TAG,
+			alias: id,
+			text: {}
+		},
+		children: [{ text: label }]
+	} };
+}
+/** True if an inline SDT child carries a mention. */
+function isMention(child) {
+	if (typeof child !== "object" || child === null || !("sdt" in child)) return false;
+	return child.sdt?.properties?.tag === MENTION_TAG;
+}
+/** Read a mention SDT → `{ id, label }`. */
+function readMention(child) {
+	const sdt = child.sdt;
+	const id = sdt?.properties?.alias ?? "";
+	let label = "";
+	const first = sdt?.children?.[0];
+	if (typeof first === "string") label = first;
+	else if (first && typeof first === "object" && "text" in first) label = String(first.text ?? "");
+	return {
+		id,
+		label
+	};
+}
+//#endregion
 export { MENTION_TAG, Mention, createMention, isMention, readMention };

package/dist/extensions/ordered-list.d.mts

@@ -1,4 +1,4 @@
-import { w as OrderedList } from "../tiptap-TErPjuNJ.mjs";
+import { x as OrderedList } from "../tiptap-pZsNPsvV.mjs";
 import { LevelsOptions } from "@office-open/docx";
 
 //#region src/extensions/ordered-list.d.ts

package/dist/extensions/ordered-list.mjs

@@ -1,3 +1,41 @@
-import { w as OrderedList } from "../tiptap-D7pl4I5U.mjs";
-import { n as ORDERED_REFERENCE_PREFIX, r as buildOrderedLevels, t as ORDERED_LEVEL_TEXT } from "../ordered-list-V-3xFQmV.mjs";
+import { OrderedList } from "./tiptap.mjs";
+import { LevelFormat } from "@office-open/docx";
+//#region src/extensions/ordered-list.ts
+/**
+* OrderedList extension — owns the DOCX expression of an ordered list.
+*
+* A Tiptap orderedList maps to a sequence of paragraphs referencing one
+* abstractNum (decimal). The reference is keyed by `start` so lists with the
+* same start share a definition; DocxManager gives each list its own instance
+* for independent counting. This module owns that abstractNum shape; DocxManager
+* owns the cross-paragraph tree walk, start recovery, and numbering-instance
+* bookkeeping.
+*/
+/** Reference prefix for generated ordered-list abstractNum definitions. */
+const ORDERED_REFERENCE_PREFIX = "docen-ordered";
+/** lvlText per nesting depth (level 0 → "%1.", … level 8 → "%9."). */
+const ORDERED_LEVEL_TEXT = [
+	"%1.",
+	"%2.",
+	"%3.",
+	"%4.",
+	"%5.",
+	"%6.",
+	"%7.",
+	"%8.",
+	"%9."
+];
+/**
+* Build nine decimal numbering levels for an ordered list. Level 0 carries
+* `start`; deeper levels restart at 1 (Word convention).
+*/
+function buildOrderedLevels(start) {
+	return Array.from({ length: 9 }, (_, level) => ({
+		level,
+		format: LevelFormat.DECIMAL,
+		start: level === 0 ? start : 1,
+		text: ORDERED_LEVEL_TEXT[level]
+	}));
+}
+//#endregion
 export { ORDERED_LEVEL_TEXT, ORDERED_REFERENCE_PREFIX, OrderedList, buildOrderedLevels };

package/dist/extensions/page-break.d.mts

@@ -1,34 +1,2 @@
-import { s as Node } from "../core-fBMCCj4D.mjs";
-
-//#region src/extensions/page-break.d.ts
-/**
- * PageBreak — inline atom node for DOCX page breaks (`<w:br w:type="page"/>`).
- *
- * OOXML page breaks live inside a run (inline), so the Tiptap node is inline
- * too (group "inline"). This keeps a break inside its paragraph on round-trip
- * — a break mid-paragraph stays mid-paragraph instead of splitting the
- * paragraph into separate blocks (which would lose the original structure).
- * Sibling to HardBreak: both render `<w:br>`, differing only by type.
- *
- * The DOCX payload (`{ pageBreak: true }`) is inlined in DocxManager — a
- * one-liner with no per-node variance, so no extension helper for it.
- *
- * Inserting a page break must also visually reflow (the C-route paginator only
- * forces a new page after a block *containing* a pageBreak atom). So
- * `setPageBreak` inserts the atom then splits the paragraph — the atom lands at
- * the end of the first half, the trailing text becomes a fresh paragraph, and
- * the paginator's `forcesPageBreakAfter` moves it to the next page (matching
- * Word's Ctrl+Enter behavior).
- */
-declare const PageBreak: Node<any, any>;
-declare module "@tiptap/core" {
-  interface Commands<ReturnType> {
-    pageBreak: {
-      /** Insert a page break at the cursor and split the paragraph so the
-       *  trailing content reflows to the next page. */
-      setPageBreak: () => ReturnType;
-    };
-  }
-}
-//#endregion
+import { c as PageBreak } from "../core-C9VunJ8o.mjs";
 export { PageBreak };

package/dist/extensions/page-break.mjs

@@ -1,2 +1,2 @@
-import { f as PageBreak } from "../core-DEqBHRzE.mjs";
+import { g as PageBreak } from "../core-DT9IrTzN.mjs";
 export { PageBreak };