@docen/docx 0.3.0 → 0.3.1

package/dist/converters/patch.d.mts

@@ -1,53 +1,2 @@
-import { a as JSONContent } from "../core-omBKMRtl.mjs";
-import { PrepareStep } from "./prepare.mjs";
-import { OutputByType, OutputType, patchDocument } from "@office-open/docx";
-
-//#region src/converters/patch.d.ts
-/**
- * A patch's replacement content, expressed as Tiptap JSON. `compileDocument`
- * converts it to office-open `SectionChild[]` before applying.
- */
-interface DocxPatchContent {
-  content: JSONContent;
-}
-/**
- * Options for patching a DOCX template.
- *
- * Mirrors the legacy `@docen/export-docx` DocxPatchOptions minus `exportOptions`
- * — `compileDocument` already derives all styling from the Tiptap attrs, so no
- * separate export configuration is needed.
- */
-interface DocxPatchOptions<T extends OutputType = OutputType> {
-  /** Template DOCX to patch. */
-  template: Parameters<typeof patchDocument>[0]["data"];
-  /** Placeholder name → replacement content. */
-  patches: Record<string, DocxPatchContent>;
-  /**
-   * Pre-compilation steps run on each patch's content in place (default:
-   * `prepareImages()`). `false` skips; `PrepareStep[]` runs custom steps.
-   * Required when patch content references http image URLs.
-   */
-  prepare?: boolean | PrepareStep[];
-  /** Custom placeholder delimiters (default `{{` / `}}`). */
-  placeholderDelimiters?: {
-    start?: string;
-    end?: string;
-  };
-  /** Keep the template's paragraph styles on patched content. */
-  keepOriginalStyles?: boolean;
-  /** Recurse into nested patches. */
-  recursive?: boolean;
-  /** Output container type. */
-  outputType: T;
-}
-/**
- * Patch a DOCX template by replacing placeholders with Tiptap-JSON content.
- *
- * Each patch's `content` is prepared (default: `prepareImages`, in place) then
- * compiled (`compileDocument` → `DocumentOptions`); its first section's
- * `children` become the replacement. Patching is delegated to
- * `@office-open/docx`'s `patchDocument`.
- */
-declare function patchDOCX<T extends OutputType>(options: DocxPatchOptions<T>): Promise<OutputByType[T]>;
-//#endregion
+import { n as DocxPatchOptions, r as patchDOCX, t as DocxPatchContent } from "../patch-Cdp5WKJz.mjs";
 export { DocxPatchContent, DocxPatchOptions, patchDOCX };

package/dist/converters/patch.mjs

@@ -1,37 +1,2 @@
-import { prepareDocument } from "./prepare.mjs";
-import { compileDocument } from "./docx.mjs";
-import { PatchType, patchDocument } from "@office-open/docx";
-//#region src/converters/patch.ts
-/**
-* Patch a DOCX template by replacing placeholders with Tiptap-JSON content.
-*
-* Each patch's `content` is prepared (default: `prepareImages`, in place) then
-* compiled (`compileDocument` → `DocumentOptions`); its first section's
-* `children` become the replacement. Patching is delegated to
-* `@office-open/docx`'s `patchDocument`.
-*/
-async function patchDOCX(options) {
-	const { template, patches, prepare = true, placeholderDelimiters, keepOriginalStyles, recursive, outputType } = options;
-	const patchesObject = {};
-	for (const [key, patchContent] of Object.entries(patches)) {
-		if (prepare !== false) await prepareDocument(patchContent.content, prepare === true ? void 0 : prepare);
-		const children = compileDocument(patchContent.content).sections?.[0]?.children ?? [];
-		patchesObject[key] = {
-			type: PatchType.DOCUMENT,
-			children
-		};
-	}
-	return patchDocument({
-		outputType,
-		data: template,
-		patches: patchesObject,
-		...keepOriginalStyles !== void 0 && { keepOriginalStyles },
-		...recursive !== void 0 && { recursive },
-		...placeholderDelimiters && { placeholderDelimiters: {
-			start: placeholderDelimiters.start ?? "{{",
-			end: placeholderDelimiters.end ?? "}}"
-		} }
-	});
-}
-//#endregion
+import { t as patchDOCX } from "../patch-IZ13tXTu.mjs";
 export { patchDOCX };

package/dist/converters/prepare.d.mts

@@ -1,51 +1,2 @@
-import { a as JSONContent } from "../core-omBKMRtl.mjs";
-
-//#region src/converters/prepare.d.ts
-/**
- * A prepare step that transforms Tiptap JSON in place (e.g. fetch external resources).
- */
-type PrepareStep = (json: JSONContent) => Promise<void>;
-/**
- * Fetch handler for external image URLs.
- *
- * Receives the URL, returns the image binary data.
- * Override to customize fetching (proxy, auth, caching, etc.).
- */
-type ImageFetchHandler = (url: string) => Promise<Uint8Array>;
-/**
- * Default fetch handler using the global `fetch` API (Node 18+ and browsers).
- */
-declare function fetchImageHandler(url: string): Promise<Uint8Array>;
-/**
- * Create a prepare step that fetches external image URLs and converts them to data URLs.
- *
- * @param handler - Custom fetch handler (defaults to `fetchImageHandler`)
- *
- * @example
- * ```ts
- * // Use with defaults
- * await prepareDocument(json);
- *
- * // Custom handler
- * await prepareDocument(json, [prepareImages(myHandler)]);
- * ```
- */
-declare function prepareImages(handler?: ImageFetchHandler): PrepareStep;
-/**
- * Run prepare steps on a Tiptap JSON document before compilation.
- *
- * Each step receives the JSON and may mutate it in place (e.g. replace external
- * URLs with embedded data). Steps run sequentially in order.
- *
- * Defaults to `[prepareImages()]` when no steps are provided.
- *
- * @example
- * ```ts
- * const json = parseHTML(html);
- * await prepareDocument(json);             // default: fetch images
- * const docOpts = compileDocument(json);
- * ```
- */
-declare function prepareDocument(json: JSONContent, steps?: readonly PrepareStep[]): Promise<void>;
-//#endregion
-export { ImageFetchHandler, PrepareStep, fetchImageHandler, prepareDocument, prepareImages };
+import { a as prepareImageSizes, i as prepareDocument, n as PrepareStep, o as prepareImages, r as fetchImageHandler, t as ImageFetchHandler } from "../prepare-CPAvcv6q.mjs";
+export { ImageFetchHandler, PrepareStep, fetchImageHandler, prepareDocument, prepareImageSizes, prepareImages };

package/dist/converters/prepare.mjs

@@ -1,76 +1,2 @@
-//#region src/converters/prepare.ts
-/**
-* Default fetch handler using the global `fetch` API (Node 18+ and browsers).
-*/
-async function fetchImageHandler(url) {
-	const response = await fetch(url);
-	if (!response.ok) throw new Error(`Failed to fetch image from ${url}: ${response.status} ${response.statusText}`);
-	const buffer = await response.arrayBuffer();
-	return new Uint8Array(buffer);
-}
-/**
-* Create a prepare step that fetches external image URLs and converts them to data URLs.
-*
-* @param handler - Custom fetch handler (defaults to `fetchImageHandler`)
-*
-* @example
-* ```ts
-* // Use with defaults
-* await prepareDocument(json);
-*
-* // Custom handler
-* await prepareDocument(json, [prepareImages(myHandler)]);
-* ```
-*/
-function prepareImages(handler = fetchImageHandler) {
-	return async (json) => {
-		await walkImages(json, handler);
-	};
-}
-/** Built-in prepare steps, run when no custom steps are provided. */
-const DEFAULT_STEPS = [prepareImages()];
-/**
-* Run prepare steps on a Tiptap JSON document before compilation.
-*
-* Each step receives the JSON and may mutate it in place (e.g. replace external
-* URLs with embedded data). Steps run sequentially in order.
-*
-* Defaults to `[prepareImages()]` when no steps are provided.
-*
-* @example
-* ```ts
-* const json = parseHTML(html);
-* await prepareDocument(json);             // default: fetch images
-* const docOpts = compileDocument(json);
-* ```
-*/
-async function prepareDocument(json, steps = DEFAULT_STEPS) {
-	for (const step of steps) await step(json);
-}
-async function toDataUrl(src, handler) {
-	const data = await handler(src);
-	return `data:${{
-		jpg: "image/jpeg",
-		jpeg: "image/jpeg",
-		png: "image/png",
-		gif: "image/gif",
-		bmp: "image/bmp",
-		svg: "image/svg+xml",
-		webp: "image/webp"
-	}[src.split(".").pop()?.toLowerCase() ?? "png"] ?? "image/png"};base64,${typeof btoa !== "undefined" ? btoa(String.fromCharCode(...data)) : Buffer.from(data).toString("base64")}`;
-}
-async function walkImages(node, handler) {
-	if (node.type === "image" && node.attrs) {
-		const src = node.attrs.src;
-		if (src && (src.startsWith("http://") || src.startsWith("https://"))) try {
-			node.attrs.src = await toDataUrl(src, handler);
-		} catch (error) {
-			console.warn(`Failed to fetch image: ${src}`, error instanceof Error ? error.message : error);
-		}
-	}
-	const tasks = [];
-	for (const child of node.content ?? []) tasks.push(walkImages(child, handler));
-	await Promise.all(tasks);
-}
-//#endregion
-export { fetchImageHandler, prepareDocument, prepareImages };
+import { i as prepareImages, n as prepareDocument, r as prepareImageSizes, t as fetchImageHandler } from "../prepare-Bdk8Cjkf.mjs";
+export { fetchImageHandler, prepareDocument, prepareImageSizes, prepareImages };

package/dist/converters/styles.d.mts

@@ -0,0 +1,2 @@
+import { a as inlineStyles, i as effectiveRunProps, n as StylesOptions, o as quickStyles, r as defaultParagraphStyleId, s as stylesToCss, t as QuickStyleEntry } from "../styles-ugspkrxz.mjs";
+export { QuickStyleEntry, type StylesOptions, defaultParagraphStyleId, effectiveRunProps, inlineStyles, quickStyles, stylesToCss };

package/dist/converters/styles.mjs

@@ -0,0 +1,2 @@
+import { a as stylesToCss, i as quickStyles, n as effectiveRunProps, r as inlineStyles, t as defaultParagraphStyleId } from "../styles-QSX3RhxK.mjs";
+export { defaultParagraphStyleId, effectiveRunProps, inlineStyles, quickStyles, stylesToCss };

package/dist/core-DEqBHRzE.mjs

@@ -0,0 +1,406 @@
+import { B as UndoRedo, C as Mention, D as Subscript, F as Text, I as TextAlign$1, N as TaskItem, O as Superscript, P as TaskList, R as TrailingNode, S as Mathematics, a as CodeBlockLowlight, b as ListItem, c as DetailsSummary, f as Gapcursor, g as HorizontalRule, h as Highlight, i as Code, n as Bold, o as Details, p as HardBreak, r as BulletList, s as DetailsContent, t as Blockquote, u as Dropcursor, v as Italic, w as OrderedList, x as ListKeymap, y as Link, z as Underline } from "./tiptap-D7pl4I5U.mjs";
+import "./blockquote-Ky9xD_Q-.mjs";
+import { t as CodeBlock } from "./code-block-BgNjhADy.mjs";
+import "./details-Dh8luWb2.mjs";
+import { t as Document } from "./document-CvTym-FM.mjs";
+import { t as Emoji } from "./emoji-C2OsTWR7.mjs";
+import { t as Heading } from "./heading-DAubgJJN.mjs";
+import { t as Image } from "./image-CuEIXoZl.mjs";
+import { t as encodeBase64 } from "./dist-B6B3HnVZ.mjs";
+import "./mention-C-dTR6MK.mjs";
+import "./ordered-list-V-3xFQmV.mjs";
+import { t as Paragraph } from "./paragraph-BrWH-BOV.mjs";
+import { t as Strike } from "./strike-hWxShOgb.mjs";
+import { t as Table } from "./table-DrA12lxX.mjs";
+import { t as TableCell } from "./table-cell-DmkfYwDc.mjs";
+import { t as TableHeader } from "./table-header-Bwr5GKWg.mjs";
+import { t as TableRow } from "./table-row-vew1y7WH.mjs";
+import "./task-item-BnlXGrIG.mjs";
+import { t as TextStyle } from "./text-style-tMeBq5XQ.mjs";
+import { Editor, Extension, Mark, Node } from "@tiptap/core";
+import { all, createLowlight } from "lowlight";
+import { TextAlign } from "@tiptap/extension-text-align";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+//#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 the on/off boolean for formatting marks. Toggled via a
+*  transaction meta so `decorations` recomputes when the user flips the Show/
+*  Hide button. */
+const FORMAT_MARKS_KEY = new PluginKey("docen-formatting-marks");
+/**
+* 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.
+*/
+const FormattingMarks = Extension.create({
+	name: "formattingMarks",
+	addProseMirrorPlugins() {
+		return [new Plugin({
+			key: FORMAT_MARKS_KEY,
+			state: {
+				init: () => false,
+				apply: (tr, value) => {
+					if (tr.getMeta(FORMAT_MARKS_KEY) === "toggle") return !value;
+					return value;
+				}
+			},
+			props: { decorations(state) {
+				if (!FORMAT_MARKS_KEY.getState(state)) return DecorationSet.empty;
+				const decos = [];
+				state.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(state.doc, decos);
+			} }
+		})];
+	},
+	addCommands() {
+		return { toggleFormattingMarks: () => ({ tr, dispatch }) => {
+			if (dispatch) dispatch(tr.setMeta(FORMAT_MARKS_KEY, "toggle"));
+			return true;
+		} };
+	}
+});
+//#endregion
+//#region src/extensions/image-group.ts
+/**
+* ImageGroup — inline atom node carrying a DOCX drawing group (wpg:
+* wordprocessingGroup) as an opaque blob. A group bundles pictures, shapes, and
+* nested groups behind a shared transform; the editor doesn't model its
+* interior — the full WpgGroupRunOptions round-trips verbatim in attrs.wpgGroup.
+*
+* renderHTML paints the first picture (common case: a single-logo header group)
+* so the group is visible; shapes/nested groups fall back to a placeholder.
+* Structured group/shape editing is a separate phase.
+*/
+const EMU_PER_PX = 9525;
+/** Extract the first picture (pic/MediaData) from a group for display. */
+function firstPicture(group) {
+	const pic = group?.children?.find((c) => {
+		const t = c.type;
+		return typeof t === "string" && t !== "wps" && t !== "wpg";
+	});
+	if (!pic?.data) return null;
+	const bytes = pic.data instanceof Uint8Array ? pic.data : new Uint8Array(Object.values(pic.data));
+	const width = pic.transformation?.width;
+	const height = pic.transformation?.height;
+	return {
+		src: `data:image/${pic.type};base64,${encodeBase64(bytes)}`,
+		width: typeof width === "number" ? Math.round(width / EMU_PER_PX) : void 0,
+		height: typeof height === "number" ? Math.round(height / EMU_PER_PX) : void 0
+	};
+}
+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 ImageGroup = Node.create({
+	name: "imageGroup",
+	group: "inline",
+	inline: true,
+	atom: true,
+	addAttributes() {
+		return { wpgGroup: attrWpgGroup() };
+	},
+	parseHTML() {
+		return [{ tag: "span[data-image-group]" }];
+	},
+	renderHTML({ node }) {
+		const attrs = {
+			"data-image-group": "",
+			contenteditable: "false"
+		};
+		const pic = firstPicture(node.attrs.wpgGroup);
+		if (pic) {
+			const imgAttrs = {
+				src: pic.src,
+				alt: ""
+			};
+			if (pic.width && pic.height) imgAttrs.style = `width:${pic.width}px;height:${pic.height}px`;
+			return [
+				"span",
+				attrs,
+				["img", imgAttrs]
+			];
+		}
+		return [
+			"span",
+			attrs,
+			"♢"
+		];
+	}
+});
+//#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"
+		}];
+	},
+	addCommands() {
+		return { setPageBreak: () => ({ tr, state, dispatch }) => {
+			if (!dispatch) 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, toc, 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";
+		try {
+			const parsed = JSON.parse(node.attrs.data || "{}");
+			const key = Object.keys(parsed)[0];
+			if (key) label = key;
+		} catch {}
+		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.
+*/
+const SectionBreak = Extension.create({
+	name: "sectionBreak",
+	addCommands() {
+		return { setSectionBreak: () => ({ commands }) => commands.updateAttributes("paragraph", { sectionProperties: {} }) };
+	}
+});
+//#endregion
+//#region src/extensions/extensions.ts
+const tiptapNodeExtensions = [
+	Document,
+	Paragraph,
+	Text,
+	HardBreak,
+	PageBreak,
+	ColumnBreak,
+	SectionBreak,
+	Passthrough,
+	Blockquote,
+	OrderedList,
+	BulletList,
+	ListItem,
+	CodeBlock.configure({ lowlight: createLowlight(all) }),
+	Details,
+	DetailsSummary,
+	DetailsContent,
+	Emoji,
+	HorizontalRule,
+	Image.configure({ inline: true }),
+	ImageGroup,
+	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,
+	UndoRedo,
+	Dropcursor,
+	Gapcursor,
+	TrailingNode,
+	ListKeymap
+];
+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.dropcursor !== false) extensions.push(Dropcursor.configure(this.options.dropcursor));
+		if (this.options.gapcursor !== false) extensions.push(Gapcursor);
+		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.undoRedo !== false) extensions.push(UndoRedo.configure(this.options.undoRedo));
+		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.listKeymap !== false) extensions.push(ListKeymap.configure(this.options.listKeymap));
+		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));
+		if (this.options.trailingNode !== false) extensions.push(TrailingNode.configure(this.options.trailingNode));
+		return extensions;
+	}
+});
+//#endregion
+export { DocxKit as a, tiptapMarkExtensions as c, Passthrough as d, PageBreak as f, ColumnBreak as h, Node as i, tiptapNodeExtensions as l, FormattingMarks as m, Extension as n, TextAlign as o, ImageGroup as p, Mark as r, docxExtensions as s, Editor as t, SectionBreak as u };