@docen/docx 0.3.3 → 0.3.5

package/dist/core-DC0_-WcE.d.mts

@@ -0,0 +1,387 @@
+import { AnyExtension, Editor, Extension, Extensions, JSONContent as JSONContent$1, Mark, Node } from "@tiptap/core";
+
+//#region src/extensions/code-block.d.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). */
+declare function renderDocx$1(_node: JSONContent$1): Record<string, unknown>;
+declare const CodeBlock: import("@tiptap/core").Node<import("@tiptap/extension-code-block-lowlight").CodeBlockLowlightOptions, any>;
+//#endregion
+//#region src/extensions/column-break.d.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.
+ */
+declare const ColumnBreak: Node<any, any>;
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    columnBreak: {
+      /** Insert a column break atom at the cursor (round-trip only until
+       *  multi-column layout lands). */
+      setColumnBreak: () => ReturnType;
+    };
+  }
+}
+//#endregion
+//#region src/extensions/section-break.d.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.
+ */
+declare const SectionBreak: Extension<any, any>;
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    sectionBreak: {
+      /** Insert a Next Page section break at the current paragraph. */setSectionBreak: () => ReturnType;
+    };
+  }
+}
+//#endregion
+//#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/formatting-marks.d.ts
+/**
+ * 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).
+ */
+declare const FormattingMarks: Extension<any, any>;
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    formattingMarks: {
+      /** Toggle the non-printing paragraph marks on or off. */toggleFormattingMarks: () => ReturnType;
+    };
+  }
+}
+//#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
+//#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;
+  anchor?: 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[];
+/** Inner style of a wps text-box: fill + outline + textbox insets (padding).
+ *  Lives on the contentDOM (the editable interior). Never carries rotation or
+ *  writing-mode — those go on the outer positioning wrapper (see
+ *  wpsRotationVert), because transform/writing-mode on an editable region
+ *  distort the caret rect and break CJK IME composition. */
+declare function wpsInnerStyle(data: WpsData): string;
+/** Rotation + writing-mode (text direction) for a wps shape. Lives on the
+ *  positioning wrapper OUTSIDE the contentDOM. `rotationOverride` covers a
+ *  group child whose rotation comes from the group transform, not bodyPr. */
+declare function wpsRotationVert(data: WpsData, rotationOverride?: number): string;
+/**
+ * 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).
+ *
+ * The wpg path merges placement + interior into ONE div (an atom has no
+ * contentDOM, so rotation/writing-mode on the element is safe — no caret inside).
+ * The editable wpsShape node instead splits these across two elements via
+ * wpsShapeStyles (outer = position+rotation+vert, inner = contentDOM).
+ */
+declare function renderWpsInterior(data: WpsData, positionStyle: string, opts?: {
+  rotation?: number;
+  attrs?: Record<string, string>;
+}): Spec;
+/** Shape data subset carrying its own extent + floating anchor (a standalone
+ *  wpsShape, not a wpg group child). */
+interface WpsShapeStandalone extends WpsData {
+  transformation?: {
+    width?: number;
+    height?: number;
+  };
+  floating?: unknown;
+}
+interface WpsShapeStyles {
+  /** outer wrapper (dom): floating/inline placement + size + rotation + writing-mode. */
+  outer: string;
+  /** inner contentDOM: box-sizing + fill + outline + textbox insets (padding). */
+  inner: string;
+  /** true when the floating anchor resolves against the anchor paragraph
+   *  (vRelative "paragraph") — the editor marks the anchor <p> relative. */
+  paragraphAnchor: boolean;
+}
+/** Two-element style split for an editable standalone wpsShape: `outer` for the
+ *  positioning wrapper (dom), `inner` for the contentDOM. rotation/writing-mode
+ *  stay on `outer` so the editable interior has a clean caret/IME rect. The
+ *  geometry (EMU extent → px, floating anchor CSS) is computed here so the
+ *  editor's NodeView and generateHTML render identically without re-deriving
+ *  the engine's EMU/floating math. */
+declare function wpsShapeStyles(ws: WpsShapeStandalone): WpsShapeStyles;
+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>;
+/**
+ * InlinePassthrough — inline atom carrying an opaque inline ParagraphChild that
+ * has no native Tiptap representation (bookmarkStart/End, comment range markers,
+ * proofErr, track-change markers, …). The full ParagraphChild rides in
+ * `attrs.data` as JSON so DOCX→JSON→DOCX round-trips byte-faithful; the atom is
+ * zero-width (bookmark/range markers carry no layout box), matching Word's
+ * non-printing metadata. Mirrors the block-level Passthrough for inline children.
+ */
+declare const InlinePassthrough: 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/tab.d.ts
+/**
+ * Tab — an inline atom representing a DOCX `<w:r><w:tab/></w:r>` tab character.
+ *
+ * office-open parses `<w:tab/>` as `{ tab: true }` inside a run's children. The
+ * resolve path turns that into this node so the tab is not lost: previously
+ * `<w:tab/>` was dropped, which let `mergeTextNodes` collapse a TOC entry's title
+ * and page number into adjacent text (no leader, no right alignment). The node is
+ * zero-width, non-editable, and carries no text height — measure skips it the
+ * same way it skips other inline atoms, so pagination is unaffected. It only
+ * marks where a tab leader (e.g. a TOC's dotted leader) renders. compile turns it
+ * back into `{ tab: true }`.
+ */
+declare const Tab: 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
+export { Image as A, renderWpsText as C, PageBreak as D, wpsShapeStyles as E, ColumnBreak as F, CodeBlock as I, renderDocx$1 as L, renderCropAttrs as M, renderDocx as N, FormattingMarks as O, SectionBreak as P, renderWpsInterior as S, wpsRotationVert as T, WpsShape as _, JSONContent$1 as a, WpsShapeStandalone as b, DocxKit as c, tiptapMarkExtensions as d, tiptapNodeExtensions as f, Passthrough as g, InlinePassthrough as h, Extensions as i, parseDocx as j, CropRenderContext as k, DocxKitOptions as l, TocField as m, Editor as n, Mark as o, Tab as p, Extension as r, Node as s, AnyExtension as t, docxExtensions as u, WpgGroup as v, wpsInnerStyle as w, WpsShapeStyles as x, WpsData as y };

package/dist/core.d.mts

@@ -1,2 +1,2 @@
-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";
+import { a as JSONContent, i as Extensions, n as Editor, o as Mark, r as Extension, s as Node, t as AnyExtension, u as docxExtensions } from "./core-DC0_-WcE.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-B8ba_FNi.mjs";
+import { i as Node, n as Extension, o as docxExtensions, r as Mark, t as Editor } from "./core-BnF8XhVE.mjs";
 export { Editor, Extension, Mark, Node, docxExtensions };

package/dist/details-Dd5MqqmR.d.mts

@@ -0,0 +1,17 @@
+//#region src/extensions/details.d.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. */
+declare const DETAILS_TAG = "docen-details";
+/** Paragraph style marking the summary line within a details group-SDT. */
+declare const DETAILS_SUMMARY_STYLE = "DocenDetailsSummary";
+//#endregion
+export { DETAILS_TAG as n, DETAILS_SUMMARY_STYLE as t };

package/dist/editor.d.mts

@@ -1,4 +1,4 @@
-import { n as Editor, t as AnyExtension } from "./core-DRaLI8nd.mjs";
+import { n as Editor, t as AnyExtension } from "./core-DC0_-WcE.mjs";
 
 //#region src/editor.d.ts
 interface DocxEditorOptions {

package/dist/editor.mjs

@@ -1,4 +1,4 @@
-import { s as docxExtensions, t as Editor } from "./core-B8ba_FNi.mjs";
+import { o as docxExtensions, t as Editor } from "./core-BnF8XhVE.mjs";
 //#region src/editor.ts
 /**
 * Create a Tiptap editor configured for DOCX editing.

package/dist/extensions/blockquote.d.mts

@@ -1,23 +1,3 @@
-import { t as Blockquote } from "../tiptap-pZsNPsvV.mjs";
-
-//#region src/extensions/blockquote.d.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. */
-declare const BLOCKQUOTE_INDENT_LEFT = 720;
-/** Left border marking a blockquote. */
-declare const BLOCKQUOTE_BORDER: {
-  readonly style: "single";
-  readonly size: 18;
-  readonly space: 12;
-  readonly color: "CCCCCC";
-};
-/** Apply the blockquote signature (left indent + left border) to paragraph opts. */
-declare function applyBlockquoteStyle(paraObj: Record<string, unknown>): void;
-//#endregion
+import { t as Blockquote } from "../tiptap-BKqn41uT.mjs";
+import { n as BLOCKQUOTE_INDENT_LEFT, r as applyBlockquoteStyle, t as BLOCKQUOTE_BORDER } from "../blockquote-DY80QC06.mjs";
 export { BLOCKQUOTE_BORDER, BLOCKQUOTE_INDENT_LEFT, Blockquote, applyBlockquoteStyle };

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

@@ -0,0 +1,2 @@
+import { t as BulletList } from "../bullet-list-DF60pnSL.mjs";
+export { BulletList };

package/dist/extensions/bullet-list.mjs

@@ -0,0 +1,21 @@
+import { BulletList as BulletList$1 } from "./tiptap.mjs";
+//#region src/extensions/bullet-list.ts
+/**
+* BulletList — carries the source DOCX abstractNum reference (when the list came
+* from parseDOCX) so the round-trip reuses the original numbering definition
+* (custom bullet glyph/font/indent, e.g. a Wingdings marker) instead of
+* regenerating the default. The `numbering` attr is DOCX-only (not rendered
+* to HTML); lists created in the editor carry null and compile to the default
+* bullet.
+*/
+const BulletList = BulletList$1.extend({ addAttributes() {
+	return {
+		...this.parent?.(),
+		numbering: {
+			default: null,
+			rendered: false
+		}
+	};
+} });
+//#endregion
+export { BulletList };

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

@@ -1,19 +1,2 @@
-import { a as JSONContent } from "../core-DRaLI8nd.mjs";
-
-//#region src/extensions/code-block.d.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). */
-declare function renderDocx(_node: JSONContent): Record<string, unknown>;
-declare const CodeBlock: import("@tiptap/core").Node<import("@tiptap/extension-code-block-lowlight").CodeBlockLowlightOptions, any>;
-//#endregion
+import { I as CodeBlock, L as renderDocx } from "../core-DC0_-WcE.mjs";
 export { CodeBlock, renderDocx };

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

@@ -1,31 +1,2 @@
-import { s as Node } from "../core-DRaLI8nd.mjs";
-
-//#region src/extensions/column-break.d.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.
- */
-declare const ColumnBreak: Node<any, any>;
-declare module "@tiptap/core" {
-  interface Commands<ReturnType> {
-    columnBreak: {
-      /** Insert a column break atom at the cursor (round-trip only until
-       *  multi-column layout lands). */
-      setColumnBreak: () => ReturnType;
-    };
-  }
-}
-//#endregion
+import { F as ColumnBreak } from "../core-DC0_-WcE.mjs";
 export { ColumnBreak };

package/dist/extensions/column-break.mjs

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

package/dist/extensions/details.d.mts

@@ -1,19 +1,3 @@
-import { c as DetailsSummary, o as Details, s as DetailsContent } from "../tiptap-pZsNPsvV.mjs";
-
-//#region src/extensions/details.d.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. */
-declare const DETAILS_TAG = "docen-details";
-/** Paragraph style marking the summary line within a details group-SDT. */
-declare const DETAILS_SUMMARY_STYLE = "DocenDetailsSummary";
-//#endregion
+import { c as DetailsSummary, o as Details, s as DetailsContent } from "../tiptap-BKqn41uT.mjs";
+import { n as DETAILS_TAG, t as DETAILS_SUMMARY_STYLE } from "../details-Dd5MqqmR.mjs";
 export { DETAILS_SUMMARY_STYLE, DETAILS_TAG, Details, DetailsContent, DetailsSummary };

package/dist/extensions/document.mjs

@@ -35,7 +35,8 @@ function createDocument(content = "block+") {
 				sectionHeaders: attrNative(),
 				sectionFooters: attrNative(),
 				background: attrNative(),
-				documentExtras: attrNative()
+				documentExtras: attrNative(),
+				numbering: attrNative()
 			};
 		}
 	});

package/dist/extensions/extensions.d.mts

@@ -1,12 +1,16 @@
-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 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 { A as TaskItem, F as Underline, M as Text, N as TextAlign, T as Superscript, 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, s as DetailsContent, t as Blockquote, u as Emoji, v as ListItem, w as Subscript, y as Mathematics } from "../tiptap-BKqn41uT.mjs";
+import { n as createDocument, t as Document } from "../document-Cws7XTYL.mjs";
 import { t as Paragraph } from "../paragraph-D8mpHo_o.mjs";
-import { t as TableRow } from "../table-row-kgzYkZlW.mjs";
+import { t as Heading } from "../heading-BvqBD2zX.mjs";
+import { t as BulletList } from "../bullet-list-DF60pnSL.mjs";
+import { r as OrderedList } from "../ordered-list-DFAe-YEV.mjs";
+import { A as Image, D as PageBreak, E as wpsShapeStyles, F as ColumnBreak, I as CodeBlock, O as FormattingMarks, P as SectionBreak, _ as WpsShape, b as WpsShapeStandalone, c as DocxKit, d as tiptapMarkExtensions, f as tiptapNodeExtensions, g as Passthrough, h as InlinePassthrough, l as DocxKitOptions, m as TocField, p as Tab, u as docxExtensions, v as WpgGroup, x as WpsShapeStyles } from "../core-DC0_-WcE.mjs";
 import { t as Table } from "../table-BFkfeRp9.mjs";
+import { t as TableRow } from "../table-row-kgzYkZlW.mjs";
 import { t as TableCell } from "../table-cell-D_FV4D2h.mjs";
 import { t as TableHeader } from "../table-header-KGQ2aEkP.mjs";
+import { t as Link } from "../link-BawPjQZR.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, 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 };
+import { n as scrollContainerOf, t as scrollCaretToTop } from "../scroll-ZNeThJsJ.mjs";
+export { Blockquote, Bold, BulletList, Code, CodeBlock, CodeBlockLowlight, ColumnBreak, Details, DetailsContent, DetailsSummary, Document, DocxKit, DocxKitOptions, Emoji, FormattingMarks, HardBreak, Heading, Highlight, HorizontalRule, Image, InlinePassthrough, Italic, Link, ListItem, Mathematics, Mention, OrderedList, PageBreak, Paragraph, Passthrough, SectionBreak, Strike, Subscript, Superscript, Tab, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, TocField, Underline, WpgGroup, WpsShape, type WpsShapeStandalone, type WpsShapeStyles, createDocument, docxExtensions, scrollCaretToTop, scrollContainerOf, tiptapMarkExtensions, tiptapNodeExtensions, wpsShapeStyles };

package/dist/extensions/extensions.mjs

@@ -1,8 +1,13 @@
-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 { Blockquote, Bold, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Emoji, HardBreak, Highlight, HorizontalRule, Italic, ListItem, Mathematics, Mention, Subscript, Superscript, TaskItem, TaskList, Text, TextAlign, Underline } from "./tiptap.mjs";
+import { BulletList } from "./bullet-list.mjs";
+import { CodeBlock } from "./code-block.mjs";
+import { C as ColumnBreak, S as FormattingMarks, _ as Tab, a as DocxKit, b as Passthrough, c as tiptapNodeExtensions, g as TocField, h as wpsShapeStyles, l as WpsShape, o as docxExtensions, s as tiptapMarkExtensions, u as WpgGroup, v as SectionBreak, x as PageBreak, y as InlinePassthrough } from "../core-BnF8XhVE.mjs";
+import { Document, createDocument } from "./document.mjs";
 import { Heading } from "./heading.mjs";
 import { Image } from "./image.mjs";
+import { scrollCaretToTop, scrollContainerOf } from "./scroll.mjs";
+import { Link } from "./link.mjs";
+import { OrderedList } from "./ordered-list.mjs";
 import { Paragraph } from "./paragraph.mjs";
 import { Strike } from "./strike.mjs";
 import { Table } from "./table.mjs";
@@ -10,4 +15,4 @@ 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 };
+export { Blockquote, Bold, BulletList, Code, CodeBlock, CodeBlockLowlight, ColumnBreak, Details, DetailsContent, DetailsSummary, Document, DocxKit, Emoji, FormattingMarks, HardBreak, Heading, Highlight, HorizontalRule, Image, InlinePassthrough, Italic, Link, ListItem, Mathematics, Mention, OrderedList, PageBreak, Paragraph, Passthrough, SectionBreak, Strike, Subscript, Superscript, Tab, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, TocField, Underline, WpgGroup, WpsShape, createDocument, docxExtensions, scrollCaretToTop, scrollContainerOf, tiptapMarkExtensions, tiptapNodeExtensions, wpsShapeStyles };