@docen/docx 0.3.1 → 0.3.3

package/dist/core-DRaLI8nd.d.mts

@@ -0,0 +1,203 @@
+import { AnyExtension, Editor, Extension, Extensions, JSONContent as JSONContent$1, Mark, Node } from "@tiptap/core";
+import { TextAlign } from "@tiptap/extension-text-align";
+
+//#region src/extensions/image.d.ts
+type CropRect = {
+  left?: number;
+  top?: number;
+  right?: number;
+  bottom?: number;
+};
+/**
+ * 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).
+ */
+declare function renderDocx(node: JSONContent$1): Record<string, unknown> | null;
+/**
+ * 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).
+ */
+declare function parseDocx(imageOpts: Record<string, unknown>): Record<string, unknown>;
+/** Extent-box dimensions needed to size the inner <img> for a cropped image. */
+interface CropRenderContext {
+  width?: number;
+  height?: number;
+}
+/**
+ * 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).
+ */
+declare function renderCropAttrs(crop: Record<string, unknown> | CropRect, ctx?: CropRenderContext): {
+  style: string;
+};
+declare const Image: import("@tiptap/core").Node<import("@tiptap/extension-image").ImageOptions, any>;
+//#endregion
+//#region src/extensions/wpg-group.d.ts
+interface FillColor {
+  value?: string;
+}
+interface Fill {
+  type?: string;
+  color?: FillColor;
+}
+interface Outline {
+  type?: string;
+  color?: FillColor;
+  width?: number;
+  dash?: string;
+}
+/** wps shape data (WpsShapeCoreOptions subset used for rendering). */
+interface WpsBodyProperties {
+  rotation?: number;
+  lIns?: number;
+  tIns?: number;
+  rIns?: number;
+  bIns?: number;
+  vert?: string;
+}
+interface WpsData {
+  fill?: Fill;
+  outline?: Outline;
+  bodyProperties?: WpsBodyProperties & Record<string, unknown>;
+  children?: unknown[];
+}
+type Spec = ReadonlyArray<unknown>;
+/** 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. */
+declare function renderWpsText(children: unknown): Spec[];
+/**
+ * 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).
+ */
+declare function renderWpsInterior(data: WpsData, positionStyle: string, opts?: {
+  rotation?: number;
+  attrs?: Record<string, string>;
+}): Spec;
+declare const WpgGroup: Node<any, any>;
+//#endregion
+//#region src/extensions/wps-shape.d.ts
+declare const WpsShape: Node<any, any>;
+//#endregion
+//#region src/extensions/passthrough.d.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.
+ */
+declare const Passthrough: Node<any, any>;
+//#endregion
+//#region src/extensions/toc-field.d.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.
+ */
+declare const TocField: Node<any, any>;
+//#endregion
+//#region src/extensions/extensions.d.ts
+declare const tiptapNodeExtensions: AnyExtension[];
+declare const tiptapMarkExtensions: AnyExtension[];
+declare const docxExtensions: AnyExtension[];
+interface DocxKitOptions {
+  bold?: Record<string, any> | false;
+  blockquote?: Record<string, any> | false;
+  bulletList?: Record<string, any> | false;
+  code?: Record<string, any> | false;
+  codeBlock?: Record<string, any> | false;
+  document?: false;
+  hardBreak?: Record<string, any> | false;
+  heading?: Record<string, any> | false;
+  horizontalRule?: Record<string, any> | false;
+  italic?: Record<string, any> | false;
+  listItem?: Record<string, any> | false;
+  link?: Record<string, any> | false;
+  orderedList?: Record<string, any> | false;
+  paragraph?: Record<string, any> | false;
+  strike?: Record<string, any> | false;
+  text?: false;
+  underline?: Record<string, any> | false;
+}
+declare const DocxKit: Extension<DocxKitOptions, any>;
+//#endregion
+//#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
+export { Image as C, renderDocx as E, CropRenderContext as S, renderCropAttrs as T, WpsShape as _, JSONContent$1 as a, renderWpsInterior as b, PageBreak as c, TextAlign as d, docxExtensions as f, Passthrough as g, TocField as h, Extensions as i, DocxKit as l, tiptapNodeExtensions as m, Editor as n, Mark as o, tiptapMarkExtensions as p, Extension as r, Node as s, AnyExtension as t, DocxKitOptions as u, WpgGroup as v, parseDocx as w, renderWpsText as x, WpsData as y };

package/dist/core.d.mts

@@ -1,2 +1,2 @@
-import { a as JSONContent, d as docxExtensions, i as Extensions, n as Editor, o as Mark, r as Extension, s as Node, t as AnyExtension } from "./core-fBMCCj4D.mjs";
+import { a as JSONContent, f as docxExtensions, i as Extensions, n as Editor, o as Mark, r as Extension, s as Node, t as AnyExtension } from "./core-DRaLI8nd.mjs";
 export { type AnyExtension, Editor, Extension, type Extensions, type JSONContent, Mark, Node, docxExtensions };

package/dist/core.mjs

@@ -1,2 +1,2 @@
-import { i as Node, n as Extension, r as Mark, s as docxExtensions, t as Editor } from "./core-DEqBHRzE.mjs";
+import { i as Node, n as Extension, r as Mark, s as docxExtensions, t as Editor } from "./core-B8ba_FNi.mjs";
 export { Editor, Extension, Mark, Node, docxExtensions };

package/dist/document-Cws7XTYL.d.mts

@@ -0,0 +1,28 @@
+//#region src/extensions/document.d.ts
+/**
+ * Document extension carrying DOCX document-level data through the Tiptap JSON
+ * for lossless round-trip (declared as attrs so editor setContent → getJSON
+ * preserves them, not just the standalone converters):
+ *
+ * - `attrs.styles` — office-open `StylesOptions` (styles.xml: importedStyles /
+ *   docDefaultsXml / latentStylesXml as raw XML).
+ * - `attrs.core` — docProps/core.xml properties (title/creator/description/…,
+ *   see DocxCoreProperties in converters/docx.ts).
+ * - `attrs.sectionProperties` — the last section's page layout (page size/margin/
+ *   orientation, columns, type, grid; intermediate sections carry theirs on
+ *   sectionBreak nodes).
+ *
+ * None rendered to HTML — phase 2 applies styles via injected CSS.
+ *
+ * Factory form (`createDocument`): the editor layer needs a different top-level
+ * content expression (`doc > page+` for the C-route editing schema) but the SAME
+ * DOCX attrs. Building it via this factory keeps the Document definition in ONE
+ * place (here) — the editor parameterizes only `content`, instead of `.extend`-
+ * overriding this Document and re-stating the attrs. `Document` is the default
+ * flat `doc > block+` shape used by the docx package itself.
+ */
+declare function createDocument(content?: string): import("@tiptap/core").Node<any, any>;
+/** Default flat Document (`doc > block+`) — the DOCX round-trip shape. */
+declare const Document: import("@tiptap/core").Node<any, any>;
+//#endregion
+export { createDocument as n, Document as t };

package/dist/editor.d.mts

@@ -1,2 +1,21 @@
-import { n as createDocxEditor, t as DocxEditorOptions } from "./editor-DReY3Rb9.mjs";
+import { n as Editor, t as AnyExtension } from "./core-DRaLI8nd.mjs";
+
+//#region src/editor.d.ts
+interface DocxEditorOptions {
+  /** DOM element to mount the editor */
+  element: HTMLElement;
+  /** Additional Tiptap extensions */
+  extensions?: AnyExtension[];
+  /** Initial content (Tiptap JSON or HTML string) */
+  content?: Record<string, unknown> | string;
+  /** Enable spellcheck (disable for large documents) */
+  spellcheck?: boolean;
+  /** Editor is editable */
+  editable?: boolean;
+}
+/**
+ * Create a Tiptap editor configured for DOCX editing.
+ */
+declare function createDocxEditor(options: DocxEditorOptions): Editor;
+//#endregion
 export { DocxEditorOptions, createDocxEditor };

package/dist/editor.mjs

@@ -1,2 +1,21 @@
-import { t as createDocxEditor } from "./editor-Bf3CxQnY.mjs";
+import { s as docxExtensions, t as Editor } from "./core-B8ba_FNi.mjs";
+//#region src/editor.ts
+/**
+* Create a Tiptap editor configured for DOCX editing.
+*/
+function createDocxEditor(options) {
+	const { element, extensions: extraExtensions = [], content, spellcheck = true, editable = true } = options;
+	const extraNames = new Set(extraExtensions.map((e) => e.name).filter(Boolean));
+	return new Editor({
+		element,
+		extensions: [...docxExtensions.filter((e) => !extraNames.has(e.name)), ...extraExtensions],
+		content: content ?? {
+			type: "doc",
+			content: [{ type: "paragraph" }]
+		},
+		editable,
+		editorProps: { attributes: { spellcheck: spellcheck ? "true" : "false" } }
+	});
+}
+//#endregion
 export { createDocxEditor };

package/dist/extensions/blockquote.d.mts

@@ -1,4 +1,4 @@
-import { t as Blockquote } from "../tiptap-TErPjuNJ.mjs";
+import { t as Blockquote } from "../tiptap-pZsNPsvV.mjs";
 
 //#region src/extensions/blockquote.d.ts
 /**

package/dist/extensions/blockquote.mjs

@@ -1,3 +1,31 @@
-import { t as Blockquote } from "../tiptap-D7pl4I5U.mjs";
-import { n as BLOCKQUOTE_INDENT_LEFT, r as applyBlockquoteStyle, t as BLOCKQUOTE_BORDER } from "../blockquote-Ky9xD_Q-.mjs";
+import { Blockquote } from "./tiptap.mjs";
+//#region src/extensions/blockquote.ts
+/**
+* Blockquote extension — owns the DOCX expression of a blockquote.
+*
+* DOCX has no blockquote element; the convention is a left indent plus a left
+* border on each contained paragraph. This module owns that signature; the
+* DocxManager walks the blockquote's child paragraphs and applies it to each.
+*/
+/** Left indent (twips, ~0.5 inch) marking a blockquote. */
+const BLOCKQUOTE_INDENT_LEFT = 720;
+/** Left border marking a blockquote. */
+const BLOCKQUOTE_BORDER = {
+	style: "single",
+	size: 18,
+	space: 12,
+	color: "CCCCCC"
+};
+/** Apply the blockquote signature (left indent + left border) to paragraph opts. */
+function applyBlockquoteStyle(paraObj) {
+	paraObj.indent = {
+		...paraObj.indent ?? {},
+		left: 720
+	};
+	paraObj.border = {
+		...paraObj.border ?? {},
+		left: BLOCKQUOTE_BORDER
+	};
+}
+//#endregion
 export { BLOCKQUOTE_BORDER, BLOCKQUOTE_INDENT_LEFT, Blockquote, applyBlockquoteStyle };

package/dist/extensions/code-block.d.mts

@@ -1,4 +1,4 @@
-import { a as JSONContent } from "../core-fBMCCj4D.mjs";
+import { a as JSONContent } from "../core-DRaLI8nd.mjs";
 
 //#region src/extensions/code-block.d.ts
 /**

package/dist/extensions/code-block.mjs

@@ -1,2 +1,23 @@
-import { n as renderDocx, t as CodeBlock } from "../code-block-BgNjhADy.mjs";
+import { CodeBlockLowlight } from "./tiptap.mjs";
+//#region src/extensions/code-block.ts
+/**
+* CodeBlock extension — CodeBlockLowlight with a DOCX renderDocx.
+*
+* DOCX has no dedicated code-block element. A code block maps to a single
+* paragraph styled "Code" with a monospace run font. Inline marks (syntax-
+* highlight tokens) and line breaks (`\n` → `<w:br/>`) are handled by
+* DocxManager's shared inline-content compilation; resolveCodeBlock reassembles
+* the text. This module owns only the paragraph-level style.
+*
+* `language` has no OOXML carrier and is intentionally dropped (known lossy).
+*/
+/** codeBlock node → paragraph properties (style "Code" + monospace font). */
+function renderDocx(_node) {
+	return {
+		style: "Code",
+		run: { font: "Consolas" }
+	};
+}
+const CodeBlock = CodeBlockLowlight.extend({ renderDocx });
+//#endregion
 export { CodeBlock, renderDocx };

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

@@ -1,4 +1,4 @@
-import { s as Node } from "../core-fBMCCj4D.mjs";
+import { s as Node } from "../core-DRaLI8nd.mjs";
 
 //#region src/extensions/column-break.d.ts
 /**

package/dist/extensions/column-break.mjs

@@ -1,2 +1,2 @@
-import { h as ColumnBreak } from "../core-DEqBHRzE.mjs";
+import { y as ColumnBreak } from "../core-B8ba_FNi.mjs";
 export { ColumnBreak };

package/dist/extensions/details.d.mts

@@ -1,4 +1,4 @@
-import { c as DetailsSummary, o as Details, s as DetailsContent } from "../tiptap-TErPjuNJ.mjs";
+import { c as DetailsSummary, o as Details, s as DetailsContent } from "../tiptap-pZsNPsvV.mjs";
 
 //#region src/extensions/details.d.ts
 /**

package/dist/extensions/details.mjs

@@ -1,3 +1,18 @@
-import { c as DetailsSummary, o as Details, s as DetailsContent } from "../tiptap-D7pl4I5U.mjs";
-import { n as DETAILS_TAG, t as DETAILS_SUMMARY_STYLE } from "../details-Dh8luWb2.mjs";
+import { Details, DetailsContent, DetailsSummary } from "./tiptap.mjs";
+//#region src/extensions/details.ts
+/**
+* Details extension — owns the DOCX expression of a collapsible details block.
+*
+* DOCX has no native collapsible region, but a block-level group-SDT is a
+* reversible container. The details maps to one group-SDT tagged "docen-
+* details"; the summary paragraph is marked with a fixed style so resolve can
+* split it back out from the content paragraphs. Structure round-trips fully
+* (summary + content); Word shows it expanded (no collapse) — an inherent
+* DOCX limitation, not data loss.
+*/
+/** SDT tag marking a details group content control. */
+const DETAILS_TAG = "docen-details";
+/** Paragraph style marking the summary line within a details group-SDT. */
+const DETAILS_SUMMARY_STYLE = "DocenDetailsSummary";
+//#endregion
 export { DETAILS_SUMMARY_STYLE, DETAILS_TAG, Details, DetailsContent, DetailsSummary };

package/dist/extensions/document.d.mts

@@ -1,2 +1,2 @@
-import { n as createDocument, t as Document } from "../document-BH1y4qHM.mjs";
+import { n as createDocument, t as Document } from "../document-Cws7XTYL.mjs";
 export { Document, createDocument };

package/dist/extensions/document.mjs

@@ -1,2 +1,46 @@
-import { n as createDocument, t as Document } from "../document-CvTym-FM.mjs";
+import { Document as Document$1 } from "./tiptap.mjs";
+import { attrNative } from "./utils.mjs";
+//#region src/extensions/document.ts
+/**
+* Document extension carrying DOCX document-level data through the Tiptap JSON
+* for lossless round-trip (declared as attrs so editor setContent → getJSON
+* preserves them, not just the standalone converters):
+*
+* - `attrs.styles` — office-open `StylesOptions` (styles.xml: importedStyles /
+*   docDefaultsXml / latentStylesXml as raw XML).
+* - `attrs.core` — docProps/core.xml properties (title/creator/description/…,
+*   see DocxCoreProperties in converters/docx.ts).
+* - `attrs.sectionProperties` — the last section's page layout (page size/margin/
+*   orientation, columns, type, grid; intermediate sections carry theirs on
+*   sectionBreak nodes).
+*
+* None rendered to HTML — phase 2 applies styles via injected CSS.
+*
+* Factory form (`createDocument`): the editor layer needs a different top-level
+* content expression (`doc > page+` for the C-route editing schema) but the SAME
+* DOCX attrs. Building it via this factory keeps the Document definition in ONE
+* place (here) — the editor parameterizes only `content`, instead of `.extend`-
+* overriding this Document and re-stating the attrs. `Document` is the default
+* flat `doc > block+` shape used by the docx package itself.
+*/
+function createDocument(content = "block+") {
+	return Document$1.extend({
+		content,
+		addAttributes() {
+			return {
+				...this.parent?.(),
+				styles: attrNative(),
+				core: attrNative(),
+				sectionProperties: attrNative(),
+				sectionHeaders: attrNative(),
+				sectionFooters: attrNative(),
+				background: attrNative(),
+				documentExtras: attrNative()
+			};
+		}
+	});
+}
+/** Default flat Document (`doc > block+`) — the DOCX round-trip shape. */
+const Document = createDocument();
+//#endregion
 export { Document, createDocument };

package/dist/extensions/extensions.d.mts

@@ -1,8 +1,7 @@
-import { B as UndoRedo, C as Mention, D as Subscript, F as Text, 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-TErPjuNJ.mjs";
-import { t as Document } from "../document-BH1y4qHM.mjs";
-import { t as Emoji } from "../emoji-BZ1dJD7d.mjs";
+import { A as TaskItem, F as Underline, M as Text, T as Superscript, _ as Link, a as CodeBlockLowlight, b as Mention, c as DetailsSummary, d as HardBreak, g as Italic, i as Code, j as TaskList, m as HorizontalRule, n as Bold, o as Details, p as Highlight, r as BulletList, s as DetailsContent, t as Blockquote, u as Emoji, v as ListItem, w as Subscript, x as OrderedList, y as Mathematics } from "../tiptap-pZsNPsvV.mjs";
+import { t as Document } from "../document-Cws7XTYL.mjs";
 import { t as Heading } from "../heading-BvqBD2zX.mjs";
-import { c as DocxKit, d as docxExtensions, f as tiptapMarkExtensions, g as Image, l as DocxKitOptions, m as Passthrough, p as tiptapNodeExtensions, u as TextAlign } from "../core-fBMCCj4D.mjs";
+import { C as Image, _ as WpsShape, d as TextAlign, f as docxExtensions, g as Passthrough, h as TocField, l as DocxKit, m as tiptapNodeExtensions, p as tiptapMarkExtensions, u as DocxKitOptions, v as WpgGroup } from "../core-DRaLI8nd.mjs";
 import { t as Paragraph } from "../paragraph-D8mpHo_o.mjs";
 import { t as TableRow } from "../table-row-kgzYkZlW.mjs";
 import { t as Table } from "../table-BFkfeRp9.mjs";
@@ -10,4 +9,4 @@ import { t as TableCell } from "../table-cell-D_FV4D2h.mjs";
 import { t as TableHeader } from "../table-header-KGQ2aEkP.mjs";
 import { t as Strike } from "../strike-BgWGvjKr.mjs";
 import { t as TextStyle } from "../text-style-BHdtXkMb.mjs";
-export { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Document, DocxKit, DocxKitOptions, Dropcursor, Emoji, Gapcursor, HardBreak, Heading, Highlight, HorizontalRule, Image, Italic, Link, ListItem, ListKeymap, Mathematics, Mention, OrderedList, Paragraph, Passthrough, Strike, Subscript, Superscript, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, TrailingNode, Underline, UndoRedo, docxExtensions, tiptapMarkExtensions, tiptapNodeExtensions };
+export { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Document, DocxKit, DocxKitOptions, Emoji, HardBreak, Heading, Highlight, HorizontalRule, Image, Italic, Link, ListItem, Mathematics, Mention, OrderedList, Paragraph, Passthrough, Strike, Subscript, Superscript, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, TocField, Underline, WpgGroup, WpsShape, docxExtensions, tiptapMarkExtensions, tiptapNodeExtensions };

package/dist/extensions/extensions.mjs

@@ -1,14 +1,13 @@
-import { B as UndoRedo, C as Mention, D as Subscript, F as Text, 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 { a as DocxKit, c as tiptapMarkExtensions, d as Passthrough, l as tiptapNodeExtensions, o as TextAlign, s as docxExtensions } from "../core-DEqBHRzE.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 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 { t as TextStyle } from "../text-style-tMeBq5XQ.mjs";
-export { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Document, DocxKit, Dropcursor, Emoji, Gapcursor, HardBreak, Heading, Highlight, HorizontalRule, Image, Italic, Link, ListItem, ListKeymap, Mathematics, Mention, OrderedList, Paragraph, Passthrough, Strike, Subscript, Superscript, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, TrailingNode, Underline, UndoRedo, docxExtensions, tiptapMarkExtensions, tiptapNodeExtensions };
+import { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Emoji, HardBreak, Highlight, HorizontalRule, Italic, Link, ListItem, Mathematics, Mention, OrderedList, Subscript, Superscript, TaskItem, TaskList, Text, Underline } from "./tiptap.mjs";
+import { a as DocxKit, c as tiptapMarkExtensions, d as WpgGroup, g as Passthrough, l as tiptapNodeExtensions, m as TocField, o as TextAlign, s as docxExtensions, u as WpsShape } from "../core-B8ba_FNi.mjs";
+import { Document } from "./document.mjs";
+import { Heading } from "./heading.mjs";
+import { Image } from "./image.mjs";
+import { Paragraph } from "./paragraph.mjs";
+import { Strike } from "./strike.mjs";
+import { Table } from "./table.mjs";
+import { TableCell } from "./table-cell.mjs";
+import { TableHeader } from "./table-header.mjs";
+import { TableRow } from "./table-row.mjs";
+import { TextStyle } from "./text-style.mjs";
+export { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Document, DocxKit, Emoji, HardBreak, Heading, Highlight, HorizontalRule, Image, Italic, Link, ListItem, Mathematics, Mention, OrderedList, Paragraph, Passthrough, Strike, Subscript, Superscript, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, TocField, Underline, WpgGroup, WpsShape, docxExtensions, tiptapMarkExtensions, tiptapNodeExtensions };

package/dist/extensions/formatting-marks.d.mts

@@ -1,4 +1,4 @@
-import { r as Extension } from "../core-fBMCCj4D.mjs";
+import { r as Extension } from "../core-DRaLI8nd.mjs";
 
 //#region src/extensions/formatting-marks.d.ts
 /**
@@ -19,6 +19,12 @@ import { r as Extension } from "../core-fBMCCj4D.mjs";
  * 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).
  */
 declare const FormattingMarks: Extension<any, any>;
 declare module "@tiptap/core" {

package/dist/extensions/formatting-marks.mjs

@@ -1,2 +1,2 @@
-import { m as FormattingMarks } from "../core-DEqBHRzE.mjs";
+import { v as FormattingMarks } from "../core-B8ba_FNi.mjs";
 export { FormattingMarks };