@docen/docx 0.3.1 → 0.3.3

package/dist/extensions/heading.mjs

@@ -1,2 +1,188 @@
-import { n as parseDocx, r as renderDocx, t as Heading } from "../heading-DAubgJJN.mjs";
+import { Heading as Heading$1 } from "./tiptap.mjs";
+import { alignmentFromElement, attrNative, bordersFromElement, indentFromElement, renderParagraphStyles, shadingFromElement, spacingFromElement } from "./utils.mjs";
+//#region src/extensions/heading.ts
+/**
+* Heading extension with nested office-open attrs (mirrors Paragraph).
+*
+* Attrs mirror ParagraphPropertiesOptionsBase (alignment/indent/spacing/border/
+* shading/frame as nested objects + scalar OOXML properties) plus the inherited
+* Tiptap `level` (1-6, rendered: false). DOCX round-trip is near-identity:
+* renderDocx/parseDocx pass attrs through and only map `level` ↔ OOXML
+* `heading` (HeadingLevel literal). CSS conversion happens solely in
+* renderHTML via utils mappers.
+*/
+const HEADING_COMPILE_MAP = {
+	1: "Heading1",
+	2: "Heading2",
+	3: "Heading3",
+	4: "Heading4",
+	5: "Heading5",
+	6: "Heading6",
+	7: "Heading7",
+	8: "Heading8",
+	9: "Heading9"
+};
+const HEADING_PARSE_MAP = {
+	Heading1: 1,
+	Heading2: 2,
+	Heading3: 3,
+	Heading4: 4,
+	Heading5: 5,
+	Heading6: 6,
+	Heading7: 7,
+	Heading8: 8,
+	Heading9: 9,
+	Title: 1
+};
+/** Runtime-only attrs the TableOfContents extension injects on each heading
+*  (`id` / `data-toc-id`). They are regenerated on every load, so never persist
+*  them to DOCX — skip them in renderDocx. */
+const TOC_RUNTIME_KEYS = new Set(["id", "data-toc-id"]);
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	const level = typeof attrs.level === "number" ? attrs.level : void 0;
+	const styleId = attrs.styleId;
+	if (styleId) opts.heading = styleId;
+	else if (level) opts.heading = HEADING_COMPILE_MAP[level] ?? "Heading1";
+	for (const [key, value] of Object.entries(attrs)) {
+		if (key === "level" || key === "styleId" || TOC_RUNTIME_KEYS.has(key)) continue;
+		if (value !== null && value !== void 0) opts[key] = value;
+	}
+	return opts;
+}
+/** Structural/semantic keys expressed elsewhere (heading handled separately, list handling, run children). */
+const SKIP_KEYS = new Set([
+	"heading",
+	"style",
+	"bullet",
+	"numbering",
+	"run",
+	"children",
+	"text",
+	"thematicBreak"
+]);
+function parseDocx(opts) {
+	const resolved = typeof opts === "string" ? { text: opts } : opts;
+	const attrs = {};
+	if (resolved.heading) {
+		const level = HEADING_PARSE_MAP[resolved.heading];
+		if (level) attrs.level = level;
+		attrs.styleId = resolved.heading;
+	}
+	if (resolved.style) attrs.styleId = resolved.style;
+	for (const [key, value] of Object.entries(resolved)) {
+		if (SKIP_KEYS.has(key)) continue;
+		attrs[key] = value ?? null;
+	}
+	return attrs;
+}
+const Heading = Heading$1.extend({
+	parseHTML() {
+		return [{
+			tag: "h6[data-heading-level]",
+			getAttrs: (el) => {
+				const level = Number(el.getAttribute("data-heading-level"));
+				return { level: Number.isInteger(level) && level >= 1 && level <= 9 ? level : 6 };
+			}
+		}, ...[
+			1,
+			2,
+			3,
+			4,
+			5,
+			6
+		].map((level) => ({
+			tag: `h${level}`,
+			attrs: { level }
+		}))];
+	},
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			styleId: {
+				default: null,
+				parseHTML: (el) => {
+					const m = (el.getAttribute("class") || "").match(/(?:^|\s)docx-style-(\S+)/);
+					return m ? m[1] : null;
+				}
+			},
+			alignment: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => alignmentFromElement(el)
+			},
+			indent: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => indentFromElement(el)
+			},
+			spacing: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => spacingFromElement(el)
+			},
+			shading: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => shadingFromElement(el)
+			},
+			border: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => bordersFromElement(el)
+			},
+			frame: attrNative(),
+			keepNext: attrNative(),
+			keepLines: attrNative(),
+			pageBreakBefore: attrNative(),
+			widowControl: attrNative(),
+			contextualSpacing: attrNative(),
+			bidirectional: attrNative(),
+			outlineLevel: attrNative(),
+			textDirection: attrNative(),
+			textAlignment: attrNative(),
+			suppressLineNumbers: attrNative(),
+			wordWrap: attrNative(),
+			overflowPunctuation: attrNative(),
+			autoSpaceEastAsianText: attrNative(),
+			suppressOverlap: attrNative(),
+			suppressAutoHyphens: attrNative(),
+			adjustRightInd: attrNative(),
+			snapToGrid: attrNative(),
+			mirrorIndents: attrNative(),
+			kinsoku: attrNative(),
+			topLinePunct: attrNative(),
+			autoSpaceDE: attrNative(),
+			textboxTightWrap: attrNative(),
+			rightTabStop: attrNative(),
+			leftTabStop: attrNative(),
+			divId: attrNative(),
+			tabStops: attrNative(),
+			cnfStyle: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		let hasContent = false;
+		node.forEach?.((child) => {
+			if (child.isText || child.type?.name === "hardBreak" || child.type?.name === "image") hasContent = true;
+		});
+		const styles = renderParagraphStyles(node.attrs, { empty: !hasContent });
+		const level = node.attrs?.level ?? 1;
+		const attrs = { ...HTMLAttributes };
+		const styleId = node.attrs.styleId;
+		if (styleId) attrs.class = `docx-style-${styleId}`;
+		if (styles.length > 0) attrs.style = styles.join(";");
+		const tag = level >= 1 && level <= 6 ? `h${level}` : "h6";
+		if (level >= 7) attrs["data-heading-level"] = String(level);
+		return [
+			tag,
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
 export { Heading, parseDocx, renderDocx };

package/dist/extensions/image.d.mts

@@ -1,2 +1,2 @@
-import { _ as parseDocx, g as Image, h as CropRenderContext, v as renderCropAttrs, y as renderDocx } from "../core-fBMCCj4D.mjs";
+import { C as Image, E as renderDocx, S as CropRenderContext, T as renderCropAttrs, w as parseDocx } from "../core-DRaLI8nd.mjs";
 export { CropRenderContext, Image, parseDocx, renderCropAttrs, renderDocx };

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 { n as createDocument, t as Document } from "../document-Cws7XTYL.mjs";
+import { c as PageBreak, f as docxExtensions, l as DocxKit, m as tiptapNodeExtensions, p as tiptapMarkExtensions, u as DocxKitOptions } from "../core-DRaLI8nd.mjs";
+import { A as twipsToMm, S as sectionMarginCss, b as resolvePageSize, x as sectionLinePitchCss, y as resolveFontName } from "../utils-BJwDQts7.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 { _ as PageBreak, a as DocxKit, c as tiptapMarkExtensions, l as tiptapNodeExtensions, s as docxExtensions } from "../core-B8ba_FNi.mjs";
+import { resolveFontName, resolvePageSize, sectionLinePitchCss, sectionMarginCss, twipsToMm } from "./utils.mjs";
+import { Document, createDocument } from "./document.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