@docen/docx 0.3.1 → 0.3.3

package/dist/core-B8ba_FNi.mjs

@@ -0,0 +1,717 @@
+import { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Emoji, HardBreak, Highlight, HorizontalRule, Italic, Link, ListItem, Mathematics, Mention, OrderedList, Subscript, Superscript, TaskItem, TaskList, Text, TextAlign as TextAlign$1, Underline } from "./extensions/tiptap.mjs";
+import "./extensions/blockquote.mjs";
+import { CodeBlock } from "./extensions/code-block.mjs";
+import "./extensions/details.mjs";
+import { attrNative, floatAnchorScope, floatingToStyles, normalizeColorToHex, renderRunStyles } from "./extensions/utils.mjs";
+import { Document } from "./extensions/document.mjs";
+import { Heading } from "./extensions/heading.mjs";
+import { Image } from "./extensions/image.mjs";
+import "./extensions/mention.mjs";
+import "./extensions/ordered-list.mjs";
+import { Paragraph } from "./extensions/paragraph.mjs";
+import { Strike } from "./extensions/strike.mjs";
+import { Table } from "./extensions/table.mjs";
+import { TableCell } from "./extensions/table-cell.mjs";
+import { TableHeader } from "./extensions/table-header.mjs";
+import { TableRow } from "./extensions/table-row.mjs";
+import "./extensions/task-item.mjs";
+import { TextStyle } from "./extensions/text-style.mjs";
+import { Editor, Extension, Mark, Node } from "@tiptap/core";
+import { all, createLowlight } from "lowlight";
+import { TextAlign } from "@tiptap/extension-text-align";
+import { Plugin, PluginKey, TextSelection } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+import { convertEmuToPixels, encodeBase64 } from "@office-open/core";
+//#region src/extensions/column-break.ts
+/**
+* ColumnBreak — inline atom node for DOCX column breaks (`<w:br w:type="column"/>`).
+*
+* Sibling to PageBreak and HardBreak: all three render `<w:br>`, differing only
+* by type. Inline (group "inline") to match the run-internal OOXML position,
+* keeping a column break inside its paragraph on round-trip. Visual column
+* layout (paged.js multi-column) is a future concern; the node preserves the
+* break losslessly regardless.
+*
+* The DOCX payload (`{ columnBreak: true }`) is inlined in DocxManager — a
+* one-liner with no per-node variance, so no extension helper for it.
+*
+* `setColumnBreak` only inserts the atom (no paragraph split): a column break
+* does not start a new page, and there is no column layout to reflow yet, so
+* the node is purely for round-trip fidelity until multi-column lands.
+*/
+const ColumnBreak = Node.create({
+	name: "columnBreak",
+	inline: true,
+	group: "inline",
+	atom: true,
+	parseHTML() {
+		return [{ tag: "span[data-type=\"columnBreak\"]" }, { tag: "br[data-type=\"columnBreak\"]" }];
+	},
+	renderHTML() {
+		return ["span", {
+			"data-type": "columnBreak",
+			style: "break-after:column"
+		}];
+	},
+	addCommands() {
+		return { setColumnBreak: () => ({ commands }) => commands.insertContent({ type: "columnBreak" }) };
+	}
+});
+//#endregion
+//#region src/extensions/formatting-marks.ts
+/** Plugin key holding {enabled, decos} for the formatting-marks plugin.
+*  `enabled` is toggled by a transaction meta; `decos` caches the widget set so
+*  a pure selection/cursor transaction (doc unchanged) reuses it instead of
+*  re-traversing every textblock. The un-cached version ran that traversal on
+*  every selectionUpdate — 200ms+ on a 1000-page document — making the caret
+*  and selection feel frozen. */
+const FORMAT_MARKS_KEY = new PluginKey("docen-formatting-marks");
+/** Build a widget set with one paragraph-mark widget at each textblock's
+*  closing position. Called only on doc change or marks toggle. */
+function buildParagraphMarkDecos(doc) {
+	const decos = [];
+	doc.descendants((node, pos) => {
+		if (!node.isTextblock) return;
+		decos.push(Decoration.widget(pos + node.nodeSize - 1, () => {
+			const span = document.createElement("span");
+			span.className = "docen-para-mark";
+			span.contentEditable = "false";
+			span.textContent = "↲";
+			return span;
+		}, { side: 1 }));
+	});
+	return DecorationSet.create(doc, decos);
+}
+/**
+* FormattingMarks — paints the non-printing paragraph mark via ProseMirror
+* widget decorations.
+*
+* CSS `p::after { content: "…" }` does NOT work on a ProseMirror-managed
+* paragraph: the view owns the DOM and the trailing-break kludge pushes the
+* pseudo-element off the visible line, so the mark never appears (verified).
+* Marijn Haverbeke endorses widget decorations for exactly this use case
+* (https://discuss.prosemirror.net/t/1442). Each textblock gets a widget at its
+* closing position (inside the textblock, so it stays on the content's line)
+* holding a non-editable `<span class="docen-para-mark">`. `side: 1` keeps the
+* mark to the right of a cursor resting at the paragraph end (the cursor always
+* precedes its own paragraph mark).
+*
+* Glyph: a down-then-left return arrow (↲, U+21B2 "downwards arrow with tip
+* leftwards" — the Enter-key glyph). Word/WPS use the pilcrow ¶ for paragraph
+* marks; that down-then-left arrow is Word's line-break glyph — adopted here as
+* the paragraph mark per the project's visual preference.
+*
+* Performance: the widget set is cached in plugin state and rebuilt only on a
+* doc change or a marks toggle — NOT on every selectionUpdate. Without the
+* cache, each caret move / selection re-traverses the whole document (one
+* widget per textblock) and rebuilds the set, which costs 200ms+ on 1000-page
+* documents. Pure selection transactions now reuse the cached set in O(1).
+*/
+const FormattingMarks = Extension.create({
+	name: "formattingMarks",
+	addProseMirrorPlugins() {
+		return [new Plugin({
+			key: FORMAT_MARKS_KEY,
+			state: {
+				init: () => ({
+					enabled: false,
+					decos: DecorationSet.empty
+				}),
+				apply: (tr, prev) => {
+					const toggled = tr.getMeta(FORMAT_MARKS_KEY) === "toggle";
+					const enabled = toggled ? !prev.enabled : prev.enabled;
+					if (!enabled) return {
+						enabled: false,
+						decos: DecorationSet.empty
+					};
+					if (toggled || tr.docChanged) return {
+						enabled,
+						decos: buildParagraphMarkDecos(tr.doc)
+					};
+					return {
+						enabled,
+						decos: prev.decos
+					};
+				}
+			},
+			props: { decorations: (state) => FORMAT_MARKS_KEY.getState(state).decos }
+		})];
+	},
+	addCommands() {
+		return { toggleFormattingMarks: () => ({ tr, dispatch }) => {
+			if (dispatch) dispatch(tr.setMeta(FORMAT_MARKS_KEY, "toggle"));
+			return true;
+		} };
+	}
+});
+//#endregion
+//#region src/extensions/page-break.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).
+*/
+const PageBreak = Node.create({
+	name: "pageBreak",
+	inline: true,
+	group: "inline",
+	atom: true,
+	parseHTML() {
+		return [{ tag: "span[data-type=\"pageBreak\"]" }, { tag: "br[data-type=\"pageBreak\"]" }];
+	},
+	renderHTML() {
+		return ["span", {
+			"data-type": "pageBreak",
+			style: "break-after:page"
+		}];
+	},
+	addProseMirrorPlugins() {
+		return [new Plugin({ appendTransaction: (transactions, _oldState, newState) => {
+			if (!transactions.some((tr) => tr.docChanged)) return null;
+			const doc = newState.doc;
+			const tr = newState.tr;
+			const splits = [];
+			doc.descendants((node, pos) => {
+				if (!node.isTextblock) return;
+				const last = node.childCount - 1;
+				node.forEach((child, offset, index) => {
+					if (child.type.name === "pageBreak" && index < last) splits.push(pos + 1 + offset + child.nodeSize);
+				});
+				return false;
+			});
+			if (splits.length === 0) return null;
+			splits.sort((a, b) => b - a);
+			for (const splitPos of splits) tr.split(splitPos, 1);
+			tr.setSelection(newState.selection.map(tr.doc, tr.mapping));
+			return tr;
+		} })];
+	},
+	addCommands() {
+		return { setPageBreak: () => ({ tr, state, dispatch }) => {
+			if (!dispatch) return true;
+			const { $from } = state.selection;
+			const depth = $from.depth;
+			if (($from.index(depth) > 0 ? $from.parent.child($from.index(depth) - 1) : null)?.type.name === "pageBreak") {
+				const after = $from.after(depth);
+				const carrier = state.schema.nodes.paragraph.create(null, [state.schema.nodes.pageBreak.create()]);
+				tr.insert(after, carrier);
+				tr.setSelection(TextSelection.near(tr.doc.resolve(after + carrier.nodeSize)));
+				tr.scrollIntoView();
+				return true;
+			}
+			tr.replaceSelectionWith(state.schema.nodes.pageBreak.create());
+			tr.split(tr.selection.from, 1);
+			tr.scrollIntoView();
+			return true;
+		} };
+	}
+});
+//#endregion
+//#region src/extensions/passthrough.ts
+/**
+* Passthrough — block atom carrying an opaque {@link SectionChild} that has
+* no native Tiptap representation (rawXml, bookmarkStart/End, textbox,
+* altChunk, subDoc, customXml).
+*
+* The full SectionChild is stored as JSON in `attrs.data` so the DOCX→JSON→DOCX
+* round-trip stays byte-faithful: office-open's stringify handles the inner
+* structure verbatim (including a textbox's nested children, which remain as
+* structured ParagraphOptions inside the blob rather than editable Tiptap
+* nodes). The node is not editable — it renders a read-only placeholder in HTML.
+*
+* DOCX serialization is inlined in DocxManager (compile/resolve read/write
+* `attrs.data` directly), so no renderDocx/parseDocx is needed here.
+*/
+const Passthrough = Node.create({
+	name: "passthrough",
+	group: "block",
+	atom: true,
+	addAttributes() {
+		return { data: {
+			default: "{}",
+			rendered: false
+		} };
+	},
+	parseHTML() {
+		return [{ tag: "div[data-passthrough]" }];
+	},
+	renderHTML({ node }) {
+		let label = "DOCX";
+		let key = "";
+		try {
+			const parsed = JSON.parse(node.attrs.data || "{}");
+			key = Object.keys(parsed)[0] ?? "";
+			if (key) label = key;
+		} catch {}
+		if (key === "bookmarkStart" || key === "bookmarkEnd") return ["div", {
+			"data-passthrough": label,
+			contenteditable: "false",
+			style: "display:none"
+		}];
+		return [
+			"div",
+			{
+				"data-passthrough": label,
+				contenteditable: "false",
+				style: "display:block;padding:0.5em 0.75em;margin:0.5em 0;border:1px dashed #bbb;border-radius:4px;color:#888;font-size:0.85em;background:#fafafa"
+			},
+			[
+				"span",
+				{},
+				`[${label}]`
+			]
+		];
+	}
+});
+//#endregion
+//#region src/extensions/section-break.ts
+/**
+* SectionBreak — command extension that marks a paragraph as a section boundary.
+*
+* OOXML sections (sectPr) attach to a section's LAST paragraph's pPr, NOT a
+* standalone node. So this extension provides only the `setSectionBreak`
+* command (stamps sectionProperties on the current paragraph); the paragraph
+* extension carries the sectionProperties/sectionHeaders/sectionFooters attrs,
+* and DocxManager splits/merges sections in compile/resolve by reading them off
+* the paragraph.
+*
+* The final section's sectPr rides on doc.attrs.sectionProperties (it lives at
+* <w:body>'s end in OOXML). Single-section documents have no section-carrying
+* paragraph at all.
+*
+* Next Page semantics: `setSectionBreak` stamps sectionProperties on the current
+* paragraph (making it the section's last paragraph) AND inserts a fresh empty
+* paragraph after it (the next section's first paragraph), then moves the
+* selection into that new paragraph. The page-plugin's `forcesPageBreakAfter`
+* treats a sectionProperties-bearing paragraph as a page break, so repaginate
+* pushes the new paragraph onto the next page — and the caret follows. This
+* mirrors Word's "Section Break (Next Page)".
+*
+* Split hygiene: pressing Enter inside a section-carrying paragraph must NOT
+* split it. A split would place the new paragraph past the section boundary —
+* forcesPageBreakAfter then pushes it onto the next page (next section), and
+* splitBlock would copy sectionProperties onto it (a second break mark). Word
+* instead inserts a fresh paragraph BEFORE the section's last paragraph, so the
+* new paragraph stays in this section and the stamped paragraph remains last.
+* The Enter shortcut does exactly that; non-section paragraphs fall through to
+* the default Enter unchanged.
+*/
+const SectionBreak = Extension.create({
+	name: "sectionBreak",
+	priority: 1e3,
+	addCommands() {
+		return { setSectionBreak: () => ({ tr, state, dispatch }) => {
+			if (!dispatch) return true;
+			const { $from } = tr.selection;
+			const para = $from.parent;
+			if (para.type.name !== "paragraph") return false;
+			const paraPos = $from.before($from.depth);
+			tr.setNodeMarkup(paraPos, void 0, {
+				...para.attrs,
+				sectionProperties: {}
+			});
+			const paraEnd = paraPos + para.nodeSize;
+			tr.insert(paraEnd, state.schema.nodes.paragraph.create());
+			tr.setSelection(TextSelection.near(tr.doc.resolve(paraEnd + 1)));
+			tr.scrollIntoView();
+			return true;
+		} };
+	},
+	addKeyboardShortcuts() {
+		return { Enter: ({ editor }) => {
+			const { $from } = editor.state.selection;
+			const para = $from.parent;
+			if (para.attrs.sectionProperties == null) return false;
+			const paraPos = $from.before($from.depth);
+			return editor.chain().insertContentAt(paraPos, { type: para.type.name }).setTextSelection(paraPos + 1).run();
+		} };
+	}
+});
+//#endregion
+//#region src/extensions/toc-field.ts
+/**
+* TOC field (`tocField`) — a block container representing a DOCX table of
+* contents, with the rendered entries as editable `content` and the TOC field
+* switches on `attrs.options`.
+*
+* Named `tocField` (not `tableOfContents`) to avoid colliding with the official
+* `@tiptap/extension-table-of-contents`, which is an `Extension` (a live outline
+* generator injected into the editor) that already owns the `tableOfContents`
+* name. Same-name extensions dedupe in Tiptap, and since the official one is not
+* a node it would erase this node type from the schema. The two coexist for
+* different purposes: this node persists a DOCX's rendered TOC; the official
+* extension drives the heading-outline pane.
+*
+* Structuring the TOC as a node (instead of opaque passthrough) is what fixes
+* the export crash. Each entry paragraph's `w:hyperlink` wraps a HYPERLINK field
+* whose content-less runs (fldChar begin/separate/end) office-open parses as
+* `null`. As opaque passthrough those nulls survived verbatim to
+* `generateDocument`, where office-open's `stringifyRunInline(null).break`
+* crashed. Resolving the entries through `resolveParagraphChildren` drops the
+* nulls (the existing `child !== null` guard), so compile rebuilds clean entries
+* and the generate path never sees a null — no office-open change required.
+*
+* DOCX serialization is inlined in DocxManager (resolve/compile read/write
+* `attrs.options` + the entry content directly), so no renderDocx/parseDocx is
+* needed here — the same pattern as the details extension.
+*/
+const TocField = Node.create({
+	name: "tocField",
+	group: "block",
+	content: "block+",
+	addAttributes() {
+		return { options: attrNative() };
+	},
+	parseHTML() {
+		return [{ tag: "div.docx-toc" }];
+	},
+	renderHTML() {
+		return [
+			"div",
+			{ class: "docx-toc" },
+			0
+		];
+	}
+});
+//#endregion
+//#region src/extensions/wpg-group.ts
+/**
+* wpgGroup — inline atom carrying a DOCX drawing group (wpg: wordprocessingGroup)
+* as an opaque blob. Mirrors the office-open `WpgGroupRunOptions` / ParagraphChild
+* `wpgGroup` field verbatim in attrs.wpgGroup, so the node name and attr stay
+* aligned with the OOXML concept (CT_WordprocessingGroup).
+*
+* A group bundles pictures (pic), shapes (wps), and nested groups (wpg) behind a
+* shared coordinate space (grpSpPr chOff/chExt → extent). renderHTML lays each
+* child out at its transformed position/size so the group renders as Word draws
+* it (e.g. a row of colored decoration bars), instead of a single picture.
+*/
+const EMU_PER_PT = 12700;
+const EMU_PER_PX = 9525;
+/** Solid fill → CSS color (noFill/none/gradient → undefined). */
+function fillToCss(fill) {
+	if (!fill || fill.type !== "solid") return void 0;
+	return normalizeColorToHex(fill.color?.value);
+}
+/** Shape outline → CSS border (EMU width → pt). noFill → undefined. */
+function outlineToCss(outline) {
+	if (!outline || outline.type === "noFill" || outline.type === "none") return void 0;
+	const color = normalizeColorToHex(outline.color?.value) ?? "black";
+	return `border:${outline.width != null ? `${outline.width / EMU_PER_PT}pt` : "0.75pt"} ${outline.dash === "sysDot" || outline.dash === "sysDash" ? "dashed" : "solid"} ${color}`;
+}
+/** Group extent in px: top-level groups carry {width,height}; nested wpg children
+*  carry a ChildTransformation whose pixels/emus give the size. */
+function groupExtent(group) {
+	const t = group.transformation;
+	return {
+		w: t?.width != null ? convertEmuToPixels(t.width) : t?.pixels?.x ?? 0,
+		h: t?.height != null ? convertEmuToPixels(t.height) : t?.pixels?.y ?? 0
+	};
+}
+/** Child coord (EMU, group's chOff/chExt space) → group-local px. */
+function childBox(child, chOff, scaleX, scaleY) {
+	const t = child.transformation;
+	const off = t?.offset?.emus ?? {
+		x: 0,
+		y: 0
+	};
+	const size = t?.emus ?? {
+		x: 0,
+		y: 0
+	};
+	return {
+		x: (off.x - chOff.x) * scaleX,
+		y: (off.y - chOff.y) * scaleY,
+		w: size.x * scaleX,
+		h: size.y * scaleY
+	};
+}
+/** pic media type + raw bytes → data URL (bytes may arrive as Uint8Array or a
+*  plain object of byte values across the JSON boundary). */
+function picSrc(mediaType, data) {
+	if (!data) return null;
+	return `data:image/${mediaType};base64,${encodeBase64(data instanceof Uint8Array ? data : new Uint8Array(Object.values(data)))}`;
+}
+function renderChild(child, chOff, scaleX, scaleY) {
+	const box = childBox(child, chOff, scaleX, scaleY);
+	const base = `position:absolute;left:${box.x}px;top:${box.y}px;width:${box.w}px;height:${box.h}px;box-sizing:border-box`;
+	if (child.type === "wpg") return renderGroup(child, box.w, box.h, base);
+	if (child.type === "wps") {
+		const data = child.data ?? {};
+		return renderWpsInterior(data, base, {
+			rotation: data.bodyProperties?.rotation ?? child.transformation?.rotation,
+			attrs: { "data-wpg-wps": "" }
+		});
+	}
+	if (child.type) {
+		const src = picSrc(child.type, child.data);
+		if (src) return ["img", {
+			src,
+			alt: "",
+			style: base
+		}];
+	}
+	return [];
+}
+/** wps text-body paragraphs (office-open ParagraphOptions[]) → inline HTML runs
+*  so a text-box shape shows its text. Each paragraph's run defaults merge with
+*  each text run; renderRunStyles converts font/color/size/… to CSS. Advanced run
+*  props (shadow w14RawXml, kern) are carried in attrs but not rendered. */
+function renderWpsText(children) {
+	if (!Array.isArray(children)) return [];
+	return children.map((para) => {
+		if (typeof para === "string") return [
+			"p",
+			{ style: "margin:0" },
+			para
+		];
+		const defaultRun = para.run ?? {};
+		const runs = (para.children ?? []).map((r) => {
+			if (typeof r === "string") return r;
+			const css = renderRunStyles({
+				...defaultRun,
+				...r
+			});
+			return [
+				"span",
+				css.length ? { style: css.join(";") } : {},
+				r.text ?? ""
+			];
+		});
+		return [
+			"p",
+			{ style: para.alignment ? `margin:0;text-align:${para.alignment}` : "margin:0" },
+			...runs
+		];
+	});
+}
+/**
+* Render a wps shape's interior (fill/outline/insets/rotation/writing-mode + text
+* body) as a positioned div. Shared by the wpg group's inline wps children and
+* the standalone wpsShape node, so a text-box shape renders identically whether
+* it floats alone (wp:anchor > wps:wsp) or sits inside a group. `positionStyle`
+* carries the placement — absolute group coords for a group child, the floating
+* anchor CSS for a standalone shape. `opts.rotation` overrides bodyPr rotation
+* (a group child's rotation may come from the group transform, not bodyPr).
+*/
+function renderWpsInterior(data, positionStyle, opts) {
+	const styles = [positionStyle];
+	const fill = fillToCss(data.fill);
+	if (fill) styles.push(`background-color:${fill}`);
+	const outline = outlineToCss(data.outline);
+	if (outline) styles.push(outline);
+	const bp = data.bodyProperties;
+	if (bp) {
+		const ins = (v) => v != null ? `${(v / EMU_PER_PX).toFixed(1)}px` : "0px";
+		styles.push(`padding:${ins(bp.tIns)} ${ins(bp.rIns)} ${ins(bp.bIns)} ${ins(bp.lIns)}`);
+	}
+	const rotation = opts?.rotation ?? bp?.rotation;
+	if (rotation) styles.push(`transform:rotate(${rotation}deg)`);
+	const vert = bp?.vert;
+	if (vert && vert !== "horz") styles.push(`writing-mode:${vert === "vert270" ? "vertical-lr" : "vertical-rl"}`);
+	const attrs = { style: styles.join(";") };
+	if (opts?.attrs) Object.assign(attrs, opts.attrs);
+	return [
+		"div",
+		attrs,
+		...renderWpsText(data.children)
+	];
+}
+/** Render a wpg group (top-level or nested) as a positioned container.
+*  actualW/H are the group's real pixel size — top-level groups read them from
+*  transformation.width/height; nested groups receive the box their parent
+*  transform mapped them to. containerStyle (when set) carries the absolute
+*  placement for a nested group; otherwise the group is an inline-block. */
+function renderGroup(group, actualW, actualH, containerStyle, extraAttrs) {
+	const chOff = group.childOffset ?? {
+		x: 0,
+		y: 0
+	};
+	const chExt = group.childExtent ?? {
+		cx: 1,
+		cy: 1
+	};
+	const scaleX = actualW / chExt.cx;
+	const scaleY = actualH / chExt.cy;
+	const style = containerStyle ?? `position:relative;display:inline-block;vertical-align:middle;width:${actualW}px;height:${actualH}px`;
+	const children = (group.children ?? []).map((c) => renderChild(c, chOff, scaleX, scaleY)).filter((c) => Array.isArray(c) && c.length > 0);
+	const attrs = {
+		"data-wpg-group": "",
+		style
+	};
+	if (extraAttrs) Object.assign(attrs, extraAttrs);
+	return [
+		"span",
+		attrs,
+		...children
+	];
+}
+const attrWpgGroup = () => ({
+	default: null,
+	rendered: false,
+	parseHTML: (element) => {
+		const raw = element.getAttribute("data-wpg-group");
+		if (!raw) return null;
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	}
+});
+const WpgGroup = Node.create({
+	name: "wpgGroup",
+	group: "inline",
+	inline: true,
+	atom: true,
+	addAttributes() {
+		return { wpgGroup: attrWpgGroup() };
+	},
+	parseHTML() {
+		return [{ tag: "span[data-wpg-group]" }];
+	},
+	renderHTML({ node }) {
+		const wpg = node.attrs.wpgGroup ?? {};
+		const { w, h } = groupExtent(wpg);
+		if (wpg.floating) return renderGroup(wpg, w, h, [
+			...floatingToStyles(wpg.floating, void 0, w),
+			`width:${w}px`,
+			`height:${h}px`
+		].join(";"), floatAnchorScope(wpg.floating) === "paragraph" ? { "data-float-anchor": "paragraph" } : void 0);
+		return renderGroup(wpg, w, h);
+	}
+});
+//#endregion
+//#region src/extensions/wps-shape.ts
+const attrWpsShape = () => ({
+	default: null,
+	rendered: false,
+	parseHTML: (element) => {
+		const raw = element.getAttribute("data-wps-shape");
+		if (!raw) return null;
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	}
+});
+const WpsShape = Node.create({
+	name: "wpsShape",
+	group: "inline",
+	inline: true,
+	atom: true,
+	addAttributes() {
+		return { wpsShape: attrWpsShape() };
+	},
+	parseHTML() {
+		return [{ tag: "div[data-wps-shape]" }];
+	},
+	renderHTML({ node }) {
+		const ws = node.attrs.wpsShape ?? {};
+		const sizeStyle = `width:${ws.transformation?.width != null ? convertEmuToPixels(ws.transformation.width) : 0}px;height:${ws.transformation?.height != null ? convertEmuToPixels(ws.transformation.height) : 0}px;box-sizing:border-box`;
+		if (ws.floating) {
+			const pos = [...floatingToStyles(ws.floating, void 0, ws.transformation?.width), sizeStyle].join(";");
+			const attrs = { "data-wps-shape": "" };
+			if (floatAnchorScope(ws.floating) === "paragraph") attrs["data-float-anchor"] = "paragraph";
+			return renderWpsInterior(ws, pos, { attrs });
+		}
+		return renderWpsInterior(ws, `display:inline-block;vertical-align:middle;${sizeStyle}`, { attrs: { "data-wps-shape": "" } });
+	}
+});
+//#endregion
+//#region src/extensions/extensions.ts
+const tiptapNodeExtensions = [
+	Document,
+	Paragraph,
+	Text,
+	HardBreak,
+	PageBreak,
+	ColumnBreak,
+	SectionBreak,
+	Passthrough,
+	TocField,
+	Blockquote,
+	OrderedList,
+	BulletList,
+	ListItem,
+	CodeBlock.configure({ lowlight: createLowlight(all) }),
+	Details,
+	DetailsSummary,
+	DetailsContent,
+	Emoji,
+	HorizontalRule,
+	Image.configure({ inline: true }),
+	WpgGroup,
+	WpsShape,
+	Mathematics,
+	Mention,
+	Table,
+	TableRow,
+	TableCell,
+	TableHeader,
+	TaskList,
+	TaskItem,
+	Heading,
+	TextAlign$1.configure({ types: ["heading", "paragraph"] })
+];
+const tiptapMarkExtensions = [
+	Bold,
+	Code,
+	Highlight,
+	Italic,
+	Link,
+	Strike,
+	Subscript,
+	Superscript,
+	TextStyle,
+	Underline
+];
+const docxExtensions = [
+	...tiptapNodeExtensions,
+	...tiptapMarkExtensions,
+	FormattingMarks
+];
+const DocxKit = Extension.create({
+	name: "docxKit",
+	addExtensions() {
+		const extensions = [];
+		if (this.options.bold !== false) extensions.push(Bold.configure(this.options.bold));
+		if (this.options.blockquote !== false) extensions.push(Blockquote.configure(this.options.blockquote));
+		if (this.options.bulletList !== false) extensions.push(BulletList.configure(this.options.bulletList));
+		if (this.options.code !== false) extensions.push(Code.configure(this.options.code));
+		if (this.options.codeBlock !== false) extensions.push(CodeBlockLowlight.configure({
+			lowlight: createLowlight(all),
+			...this.options.codeBlock
+		}));
+		if (this.options.document !== false) extensions.push(Document);
+		if (this.options.hardBreak !== false) extensions.push(HardBreak.configure(this.options.hardBreak));
+		if (this.options.heading !== false) extensions.push(Heading.configure(this.options.heading));
+		if (this.options.horizontalRule !== false) extensions.push(HorizontalRule.configure(this.options.horizontalRule));
+		if (this.options.italic !== false) extensions.push(Italic.configure(this.options.italic));
+		if (this.options.listItem !== false) extensions.push(ListItem.configure(this.options.listItem));
+		if (this.options.link !== false) extensions.push(Link.configure(this.options.link));
+		if (this.options.orderedList !== false) extensions.push(OrderedList.configure(this.options.orderedList));
+		if (this.options.paragraph !== false) extensions.push(Paragraph.configure(this.options.paragraph));
+		if (this.options.strike !== false) extensions.push(Strike.configure(this.options.strike));
+		if (this.options.text !== false) extensions.push(Text);
+		if (this.options.underline !== false) extensions.push(Underline.configure(this.options.underline));
+		return extensions;
+	}
+});
+//#endregion
+export { PageBreak as _, DocxKit as a, tiptapMarkExtensions as c, WpgGroup as d, renderWpsInterior as f, Passthrough as g, SectionBreak as h, Node as i, tiptapNodeExtensions as l, TocField as m, Extension as n, TextAlign as o, renderWpsText as p, Mark as r, docxExtensions as s, Editor as t, WpsShape as u, FormattingMarks as v, ColumnBreak as y };