@docen/docx 0.3.0

package/dist/extensions/utils.mjs

@@ -0,0 +1,289 @@
+//#region src/extensions/utils.ts
+/** Common CSS named colors → hex */
+const CSS_COLORS = {
+	black: "#000000",
+	white: "#FFFFFF",
+	red: "#FF0000",
+	green: "#008000",
+	blue: "#0000FF",
+	yellow: "#FFFF00",
+	cyan: "#00FFFF",
+	magenta: "#FF00FF",
+	gray: "#808080",
+	grey: "#808080",
+	orange: "#FFA500",
+	purple: "#800080",
+	pink: "#FFC0CB",
+	brown: "#A52A2A",
+	lime: "#00FF00",
+	navy: "#000080",
+	teal: "#008080",
+	silver: "#C0C0C0",
+	maroon: "#800000",
+	olive: "#808000",
+	aqua: "#00FFFF",
+	fuchsia: "#FF00FF",
+	indigo: "#4B0082",
+	violet: "#EE82EE",
+	coral: "#FF7F50",
+	gold: "#FFD700",
+	salmon: "#FA8072",
+	tomato: "#FF6347"
+};
+/** Normalize a CSS color value to hex (e.g., "red" → "#FF0000", "#ff0000" → "#FF0000"). */
+function normalizeColorToHex(color) {
+	if (!color) return void 0;
+	if (color.startsWith("#")) return color.length === 4 ? `#${color[1]}${color[1]}${color[2]}${color[2]}${color[3]}${color[3]}`.toUpperCase() : color.toUpperCase();
+	if (/^[0-9A-Fa-f]{6}$/.test(color)) return `#${color.toUpperCase()}`;
+	if (/^[0-9A-Fa-f]{3}$/.test(color)) return `#${color[0]}${color[0]}${color[1]}${color[1]}${color[2]}${color[2]}`.toUpperCase();
+	return CSS_COLORS[color.toLowerCase()] ?? void 0;
+}
+/** Resolve a font value (string or OOXML rFonts { ascii, eastAsia, hAnsi, cs }) to a CSS family name. */
+function resolveFontName(font) {
+	if (!font) return null;
+	if (typeof font === "string") return font;
+	if (typeof font === "object") {
+		const f = font;
+		return f.ascii || f.hAnsi || f.eastAsia || null;
+	}
+	return null;
+}
+/** CSS value (e.g., "18pt") → twip number. 1 pt = 20 twips, 1 px = 15 twips (96 DPI). */
+function cssToTwip(value) {
+	if (!value) return void 0;
+	const match = value.match(/^([\d.]+)(pt|px|em|cm|in)?$/);
+	if (!match) return void 0;
+	const num = parseFloat(match[1]);
+	switch (match[2] ?? "pt") {
+		case "pt": return Math.round(num * 20);
+		case "px": return Math.round(num * 15);
+		case "in": return Math.round(num * 1440);
+		case "cm": return Math.round(num * 567);
+		case "em": return Math.round(num * 240);
+		default: return Math.round(num * 20);
+	}
+}
+/** Twip value → CSS string (e.g., 360 → "18pt"). */
+function twipToCss(value) {
+	if (value == null) return null;
+	if (typeof value === "string") return value;
+	return `${value / 20}pt`;
+}
+const ALIGNMENT_TO_CSS = {
+	left: "left",
+	center: "center",
+	right: "right",
+	start: "start",
+	end: "end",
+	both: "justify",
+	distribute: "justify"
+};
+const CSS_TO_ALIGNMENT = {
+	left: "left",
+	center: "center",
+	right: "right",
+	start: "start",
+	end: "end",
+	justify: "both"
+};
+/** OOXML alignment → CSS text-align. */
+function alignmentToCss(alignment) {
+	if (!alignment) return null;
+	return ALIGNMENT_TO_CSS[alignment] ?? null;
+}
+/** CSS text-align → OOXML alignment. */
+function alignmentFromCss(css) {
+	if (!css) return null;
+	return CSS_TO_ALIGNMENT[css] ?? null;
+}
+/** Shading.fill → CSS background-color hex. */
+function shadingToCss(shading) {
+	if (!shading?.fill) return null;
+	return normalizeColorToHex(shading.fill) ?? null;
+}
+/** CSS background-color → ShadingAttributesProperties (fill normalized to hex). */
+function shadingFromCss(css) {
+	const hex = normalizeColorToHex(css ?? void 0);
+	return hex ? {
+		fill: hex,
+		type: "clear"
+	} : null;
+}
+function lineSpacingToCss(spacing) {
+	if (!spacing?.line) return null;
+	const rule = spacing.lineRule;
+	if (rule === "exact" || rule === "exactly" || rule === "atLeast") return `${spacing.line / 20}pt`;
+	const multiple = Number((spacing.line / 240).toFixed(2));
+	return String(multiple);
+}
+function sizeToCss(size) {
+	if (size == null) return null;
+	return `${size}pt`;
+}
+function sizeFromCss(css) {
+	if (!css) return null;
+	const m = css.match(/^([\d.]+)(pt|px)?$/);
+	if (!m) return null;
+	const num = parseFloat(m[1]);
+	return (m[2] ?? "pt") === "px" ? num * .75 : num;
+}
+function characterSpacingToCss(spacing) {
+	if (spacing == null) return null;
+	return `${spacing / 20}pt`;
+}
+function characterSpacingFromCss(css) {
+	if (!css) return null;
+	const m = css.match(/^(-?[\d.]+)pt$/);
+	return m ? Math.round(parseFloat(m[1]) * 20) : null;
+}
+/** Render a BorderOptions to CSS string. OOXML border.size is in eighths of a point. */
+function renderBorderCSS(border) {
+	if (!border || border.style === "none") return null;
+	const size = border.size != null ? `${border.size / 8}pt` : "1pt";
+	const cssStyle = {
+		single: "solid",
+		dashed: "dashed",
+		dotted: "dotted",
+		double: "double",
+		dotDash: "dashed",
+		dotDotDash: "dotted"
+	}[border.style || "single"] || "solid";
+	const hex = border.color && border.color !== "auto" ? normalizeColorToHex(border.color) : null;
+	return hex ? `${cssStyle} ${size} ${hex}` : `${cssStyle} ${size}`;
+}
+/**
+* Compute all paragraph-level CSS styles from nested attrs.
+* Shared by Paragraph and Heading extensions for node-level renderHTML.
+* Attrs store office-open native values; mappers here convert to CSS.
+*/
+function renderParagraphStyles(attrs) {
+	const a = attrs;
+	const styles = [];
+	const align = alignmentToCss(a.alignment);
+	if (align) styles.push(`text-align:${align}`);
+	if (a.indent) {
+		const left = twipToCss(a.indent.left);
+		if (left) styles.push(`margin-left:${left}`);
+		const right = twipToCss(a.indent.right);
+		if (right) styles.push(`margin-right:${right}`);
+		if (a.indent.firstLine != null) {
+			const fl = twipToCss(a.indent.firstLine);
+			if (fl) styles.push(`text-indent:${fl}`);
+		} else if (a.indent.hanging != null) {
+			const h = twipToCss(a.indent.hanging);
+			if (h) styles.push(`text-indent:-${h}`);
+		} else if (a.indent.firstLineChars != null) styles.push(`text-indent:${a.indent.firstLineChars / 100}em`);
+	}
+	if (a.spacing) {
+		const before = twipToCss(a.spacing.before);
+		if (before) styles.push(`margin-top:${before}`);
+		const after = twipToCss(a.spacing.after);
+		if (after) styles.push(`margin-bottom:${after}`);
+		const lh = lineSpacingToCss(a.spacing);
+		if (lh) styles.push(`line-height:${lh}`);
+	}
+	const bg = shadingToCss(a.shading);
+	if (bg) styles.push(`background-color:${bg}`);
+	if (a.border) {
+		const sides = [
+			["top", a.border.top],
+			["bottom", a.border.bottom],
+			["left", a.border.left],
+			["right", a.border.right]
+		];
+		for (const [side, b] of sides) {
+			const css = b ? renderBorderCSS(b) : null;
+			if (css) styles.push(`border-${side}:${css}`);
+		}
+	}
+	return styles;
+}
+/**
+* Compute table cell CSS styles from nested attrs.
+* Shared by TableCell and TableHeader extensions.
+*/
+function renderTableCellStyles(attrs) {
+	const a = attrs;
+	const styles = [];
+	if (a.noWrap) styles.push("white-space:nowrap");
+	const bg = shadingToCss(a.shading);
+	if (bg) styles.push(`background-color:${bg}`);
+	if (a.verticalAlign) styles.push(`vertical-align:${a.verticalAlign}`);
+	return styles;
+}
+/** Parse text-align → OOXML alignment. */
+function alignmentFromElement(el) {
+	return alignmentFromCss(el.style.textAlign || null);
+}
+/** Parse margin-left/right + text-indent → OOXML indent (twips). */
+function indentFromElement(el) {
+	const indent = {};
+	const left = cssToTwip(el.style.marginLeft);
+	if (left) indent.left = left;
+	const right = cssToTwip(el.style.marginRight);
+	if (right) indent.right = right;
+	const ti = el.style.textIndent;
+	if (ti) if (ti.startsWith("-")) {
+		const h = cssToTwip(ti.slice(1));
+		if (h) indent.hanging = h;
+	} else {
+		const f = cssToTwip(ti);
+		if (f) indent.firstLine = f;
+	}
+	return Object.keys(indent).length > 0 ? indent : null;
+}
+/** Parse margin-top/bottom + line-height → OOXML spacing (twips). */
+function spacingFromElement(el) {
+	const spacing = {};
+	const before = cssToTwip(el.style.marginTop);
+	if (before) spacing.before = before;
+	const after = cssToTwip(el.style.marginBottom);
+	if (after) spacing.after = after;
+	const lh = el.style.lineHeight;
+	if (lh) {
+		const m = lh.match(/^([\d.]+)(pt|px)?$/);
+		if (m) {
+			const num = parseFloat(m[1]);
+			if (m[2]) {
+				spacing.line = Math.round(num * (m[2] === "px" ? 15 : 20));
+				spacing.lineRule = "exact";
+			} else {
+				spacing.line = Math.round(num * 240);
+				spacing.lineRule = "auto";
+			}
+		}
+	}
+	return Object.keys(spacing).length > 0 ? spacing : null;
+}
+/** Parse border-* → OOXML BordersOptions. */
+function bordersFromElement(el) {
+	const borders = {};
+	const sides = [
+		["top", el.style.borderTop],
+		["bottom", el.style.borderBottom],
+		["left", el.style.borderLeft],
+		["right", el.style.borderRight]
+	];
+	for (const [side, css] of sides) {
+		if (!css || css === "initial" || css === "none") continue;
+		const m = css.match(/^(none|solid|dashed|dotted|double)\s+([\d.]+pt)\s+(.+)$/);
+		if (!m) continue;
+		borders[side] = {
+			style: {
+				solid: "single",
+				dashed: "dashed",
+				dotted: "dotted",
+				double: "double"
+			}[m[1]] ?? "single",
+			size: Math.round(parseFloat(m[2]) * 8),
+			color: m[3]
+		};
+	}
+	return Object.keys(borders).length > 0 ? borders : null;
+}
+/** Parse background-color → OOXML shading. */
+function shadingFromElement(el) {
+	return shadingFromCss(el.style.backgroundColor || null);
+}
+//#endregion
+export { alignmentFromCss, alignmentFromElement, alignmentToCss, bordersFromElement, characterSpacingFromCss, characterSpacingToCss, cssToTwip, indentFromElement, lineSpacingToCss, normalizeColorToHex, renderBorderCSS, renderParagraphStyles, renderTableCellStyles, resolveFontName, shadingFromCss, shadingFromElement, shadingToCss, sizeFromCss, sizeToCss, spacingFromElement, twipToCss };

package/dist/heading-BvqBD2zX.d.mts

@@ -0,0 +1,8 @@
+import { JSONContent } from "@tiptap/core";
+
+//#region src/extensions/heading.d.ts
+declare function renderDocx(node: JSONContent): Record<string, unknown>;
+declare function parseDocx(opts: Record<string, unknown>): Record<string, unknown>;
+declare const Heading: import("@tiptap/core").Node<import("@tiptap/extension-heading").HeadingOptions, any>;
+//#endregion
+export { parseDocx as n, renderDocx as r, Heading as t };

package/dist/image-Ge1y6uam.d.mts

@@ -0,0 +1,47 @@
+import { JSONContent } from "@tiptap/core";
+
+//#region src/extensions/image.d.ts
+type CropRect = {
+  left?: number;
+  top?: number;
+  right?: number;
+  bottom?: number;
+};
+/**
+ * Custom Image extension with node-level renderHTML + renderDocx/parseDocx.
+ *
+ * Attrs:
+ *  - src/alt/title/width/height: Tiptap structural names (kept verbatim so base
+ *    image commands work).
+ *  - rotation: editor display only (CSS transform) but also carried through DOCX
+ *    via transformation.rotation (MediaTransformation.rotation).
+ *  - floating/outline: nested office-open objects (Floating / OutlineOptions).
+ *  - crop: nested office-open SourceRectangleOptions (srcRect).
+ *  - display: editor-only display hint, no OOXML equivalent.
+ *
+ * DOCX round-trip is near-identity: renderDocx packs attrs into CoreImageOptions;
+ * parseDocx unpacks them back. src is a data URL ↔ { type, data } base64.
+ * Node-level renderHTML solves the style merge problem (rotation + floating).
+ */
+/**
+ * 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): 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>;
+declare function renderCropAttrs(crop: Record<string, unknown> | CropRect): {
+  style: string;
+};
+declare const Image: import("@tiptap/core").Node<import("@tiptap/extension-image").ImageOptions, any>;
+//#endregion
+export { renderDocx as i, parseDocx as n, renderCropAttrs as r, Image as t };

package/dist/index.d.mts

@@ -0,0 +1,213 @@
+import { a as JSONContent, c as StarterKit, d as docxExtensions, f as tiptapMarkExtensions, l as StarterKitOptions, p as tiptapNodeExtensions, t as AnyExtension } from "./core-omBKMRtl.mjs";
+import { ImageFetchHandler, PrepareStep, fetchImageHandler, prepareDocument, prepareImages } from "./converters/prepare.mjs";
+import { DocxGenerateOptions, DocxManager, compileDocument, generateDOCX, generateDOCXStream, generateDOCXSync, parseDOCX, resolveDocument } from "./converters/docx.mjs";
+import { generateHTML, parseHTML } from "./converters/html.mjs";
+import { generateMarkdown, parseMarkdown } from "./converters/markdown.mjs";
+import { DocxPatchContent, DocxPatchOptions, patchDOCX } from "./converters/patch.mjs";
+import { DocxEditorOptions, createDocxEditor } from "./editor.mjs";
+import { JSONContent as TiptapJSONContent } from "@tiptap/core";
+import { AlignmentType, BookmarkOptions, BorderOptions, BordersOptions, DocumentOptions, EmphasisMarkType, ExternalHyperlinkOptions, Floating, FontAttributesProperties, FrameOptions, HeadingLevel, HeightRule, HighlightColor, ImageChild, ImageOptions, IndentAttributesProperties, InternalHyperlinkOptions, LeaderType, LevelParagraphStylePropertiesOptions, LineRuleType, Margins, MathChild, MathInput, MediaTransformation, ParagraphChild, ParagraphOptions, ParagraphPropertiesOptions, ParagraphPropertiesOptionsBase, ParagraphPropertiesOptionsBase as ParagraphPropertiesOptionsBase$1, ParagraphRunPropertiesOptions, ParagraphStylePropertiesOptions, RubyOptions, RunOptions, RunPropertiesOptions, RunStylePropertiesOptions, RunStylePropertiesOptions as RunStylePropertiesOptions$1, SectionChild, SectionOptions, ShadingAttributesProperties, SpacingProperties, TabStopDefinition, TabStopPosition, TabStopType, TableBordersOptions, TableCellBordersOptions, TableCellOptions, TableCellOptions as TableCellOptions$1, TableFloatOptions, TableLayoutType, TableLookOptions, TableOptions, TableOptions as TableOptions$1, TableRowOptions, TableRowPropertiesOptionsBase, TableRowPropertiesOptionsBase as TableRowPropertiesOptionsBase$1, TableVerticalAlign, TableWidthProperties, TextAlignmentType, UnderlineType, WidthType } from "@office-open/docx";
+
+//#region src/types.d.ts
+/**
+ * Make every property of T nullable and required.
+ * ProseMirror stores every declared attr; explicit null matches that model.
+ */
+type AttrNullable<T> = { [K in keyof T]-?: T[K] | null };
+/**
+ * Paragraph and heading attrs — mirrors ParagraphPropertiesOptionsBase.
+ *
+ * indent/spacing/border/run/frame are nested objects (matching office-open),
+ * so one `indent` attr replaces 13 flattened indent attrs.
+ */
+type ParagraphAttrs = AttrNullable<ParagraphPropertiesOptionsBase$1>;
+/**
+ * Text style mark attrs — mirrors RunStylePropertiesOptions.
+ *
+ * Omits properties handled by dedicated marks (bold, italic, strike,
+ * doubleStrike, subScript, superScript). `size` is in POINTS.
+ */
+type TextStyleAttrs = AttrNullable<Omit<RunStylePropertiesOptions$1, "bold" | "boldComplexScript" | "italic" | "italicComplexScript" | "strike" | "doubleStrike" | "subScript" | "superScript">>;
+/**
+ * Link mark attrs.
+ */
+interface LinkAttrs {
+  href: string | null;
+  target: string | null;
+  rel: string | null;
+  class: string | null;
+  title: string | null;
+}
+/**
+ * Table attrs — mirrors TableOptions (minus `rows`, which is structural).
+ */
+type TableAttrs = AttrNullable<Omit<TableOptions$1, "rows">>;
+/**
+ * Table row attrs — mirrors TableRowPropertiesOptionsBase.
+ * height is nested { value, rule } matching office-open.
+ */
+type TableRowAttrs = AttrNullable<TableRowPropertiesOptionsBase$1>;
+/**
+ * Table cell / header attrs — mirrors TableCellOptions.
+ *
+ * colspan/rowspan/colwidth kept as Tiptap structural names (base extension
+ * dependent); office-open columnSpan/rowSpan are mapped in renderDocx.
+ */
+type TableCellAttrs = AttrNullable<Omit<TableCellOptions$1, "children" | "columnSpan" | "rowSpan">> & {
+  /** Horizontal span (Tiptap base name; maps to office-open columnSpan). */colspan: number; /** Vertical span (Tiptap base name; maps to office-open rowSpan). */
+  rowspan: number; /** Column width in pixels per cell (Tiptap base name). */
+  colwidth: number[] | null;
+};
+/**
+ * Image attrs.
+ * src/alt/title kept as Tiptap structural names.
+ * width/height are pixel dimensions for editor display.
+ */
+interface ImageAttrs {
+  src: string;
+  alt: string | null;
+  title: string | null;
+  width: number | null;
+  height: number | null;
+  rotation: number | null;
+  floating: Record<string, unknown> | null;
+  outline: Record<string, unknown> | null;
+  crop: Record<string, unknown> | null;
+  display: string | null;
+}
+/**
+ * Strike mark attrs.
+ */
+interface StrikeAttrs {
+  doubleStrike: boolean | null;
+}
+interface TextNode {
+  type: "text";
+  text: string;
+  marks?: Mark[];
+}
+interface HardBreakNode {
+  type: "hardBreak";
+  marks?: Mark[];
+}
+type Mark = {
+  type: "bold";
+} | {
+  type: "italic";
+} | {
+  type: "underline";
+} | {
+  type: "strike";
+  attrs?: StrikeAttrs;
+} | {
+  type: "code";
+} | {
+  type: "subscript";
+} | {
+  type: "superscript";
+} | {
+  type: "highlight";
+  attrs?: {
+    color?: string;
+  };
+} | {
+  type: "textStyle";
+  attrs?: TextStyleAttrs;
+} | {
+  type: "link";
+  attrs?: LinkAttrs;
+};
+interface ParagraphNode extends TiptapJSONContent {
+  type: "paragraph";
+  attrs?: ParagraphAttrs;
+  content?: Array<TextNode | HardBreakNode | ImageNode>;
+}
+interface HeadingNode extends TiptapJSONContent {
+  type: "heading";
+  attrs: {
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+  } & ParagraphAttrs;
+  content?: Array<TextNode | HardBreakNode>;
+}
+interface BlockquoteNode extends TiptapJSONContent {
+  type: "blockquote";
+  content?: Array<ParagraphNode>;
+}
+interface CodeBlockNode extends TiptapJSONContent {
+  type: "codeBlock";
+  attrs?: {
+    language?: string;
+  };
+  content?: Array<TextNode>;
+}
+interface HorizontalRuleNode extends TiptapJSONContent {
+  type: "horizontalRule";
+}
+interface BulletListNode extends TiptapJSONContent {
+  type: "bulletList";
+  content?: Array<ListItemNode>;
+}
+interface OrderedListNode extends TiptapJSONContent {
+  type: "orderedList";
+  attrs?: {
+    start?: number;
+    order?: number;
+    type?: string | null;
+  };
+  content?: Array<ListItemNode>;
+}
+interface TaskListNode extends TiptapJSONContent {
+  type: "taskList";
+  content?: Array<TaskItemNode>;
+}
+interface ListItemNode extends TiptapJSONContent {
+  type: "listItem";
+  content?: Array<ParagraphNode>;
+}
+interface TaskItemNode extends TiptapJSONContent {
+  type: "taskItem";
+  attrs?: {
+    checked?: boolean;
+  };
+  content?: Array<ParagraphNode>;
+}
+interface TableNode extends TiptapJSONContent {
+  type: "table";
+  attrs?: TableAttrs;
+  content?: Array<TableRowNode>;
+}
+interface TableRowNode extends TiptapJSONContent {
+  type: "tableRow";
+  attrs?: TableRowAttrs;
+  content?: Array<TableCellNode | TableHeaderNode>;
+}
+interface TableCellNode extends TiptapJSONContent {
+  type: "tableCell";
+  attrs?: TableCellAttrs;
+  content?: Array<ParagraphNode>;
+}
+interface TableHeaderNode extends TiptapJSONContent {
+  type: "tableHeader";
+  attrs?: TableCellAttrs;
+  content?: Array<ParagraphNode>;
+}
+interface ImageNode extends TiptapJSONContent {
+  type: "image";
+  attrs?: ImageAttrs;
+}
+interface DetailsNode extends TiptapJSONContent {
+  type: "details";
+  content?: Array<DetailsSummaryNode | DetailsContentNode>;
+}
+interface DetailsSummaryNode extends TiptapJSONContent {
+  type: "detailsSummary";
+  content?: Array<TextNode | HardBreakNode>;
+}
+interface DetailsContentNode extends TiptapJSONContent {
+  type: "detailsContent";
+  content?: Array<BlockNode>;
+}
+type InlineContent = TextNode | HardBreakNode;
+type BlockNode = ParagraphNode | HeadingNode | BlockquoteNode | CodeBlockNode | HorizontalRuleNode | BulletListNode | OrderedListNode | TaskListNode | TableNode | ImageNode | DetailsNode;
+//#endregion
+export { type AlignmentType, type AnyExtension, type AttrNullable, type BlockNode, type BlockquoteNode, type BookmarkOptions, type BorderOptions, type BordersOptions, type BulletListNode, type CodeBlockNode, type DetailsContentNode, type DetailsNode, type DetailsSummaryNode, type DocumentOptions, type DocxEditorOptions, type DocxGenerateOptions, DocxManager, type DocxPatchContent, type DocxPatchOptions, type EmphasisMarkType, type ExternalHyperlinkOptions, type Floating, type FontAttributesProperties, type FrameOptions, type HardBreakNode, type HeadingLevel, type HeadingNode, type HeightRule, type HighlightColor, type HorizontalRuleNode, type ImageAttrs, type ImageChild, type ImageFetchHandler, type ImageNode, type ImageOptions, type IndentAttributesProperties, type InlineContent, type InternalHyperlinkOptions, type JSONContent, type LeaderType, type LevelParagraphStylePropertiesOptions, type LineRuleType, type LinkAttrs, type ListItemNode, type Margins, type Mark, type MathChild, type MathInput, type MediaTransformation, type OrderedListNode, type ParagraphAttrs, type ParagraphChild, type ParagraphNode, type ParagraphOptions, type ParagraphPropertiesOptions, type ParagraphPropertiesOptionsBase, type ParagraphRunPropertiesOptions, type ParagraphStylePropertiesOptions, type PrepareStep, type RubyOptions, type RunOptions, type RunPropertiesOptions, type RunStylePropertiesOptions, type SectionChild, type SectionOptions, type ShadingAttributesProperties, type SpacingProperties, StarterKit, type StarterKitOptions, type StrikeAttrs, type TabStopDefinition, type TabStopPosition, type TabStopType, type TableAttrs, type TableBordersOptions, type TableCellAttrs, type TableCellBordersOptions, type TableCellNode, type TableCellOptions, type TableFloatOptions, type TableHeaderNode, type TableLayoutType, type TableLookOptions, type TableNode, type TableOptions, type TableRowAttrs, type TableRowNode, type TableRowOptions, type TableRowPropertiesOptionsBase, type TableVerticalAlign, type TableWidthProperties, type TaskItemNode, type TaskListNode, type TextAlignmentType, type TextNode, type TextStyleAttrs, type UnderlineType, type WidthType, compileDocument, createDocxEditor, docxExtensions, fetchImageHandler, generateDOCX, generateDOCXStream, generateDOCXSync, generateHTML, generateMarkdown, parseDOCX, parseHTML, parseMarkdown, patchDOCX, prepareDocument, prepareImages, resolveDocument, tiptapMarkExtensions, tiptapNodeExtensions };

package/dist/index.mjs

@@ -0,0 +1,8 @@
+import { a as StarterKit, c as tiptapMarkExtensions, l as tiptapNodeExtensions, s as docxExtensions } from "./core-CFIQVRfx.mjs";
+import { createDocxEditor } from "./editor.mjs";
+import { fetchImageHandler, prepareDocument, prepareImages } from "./converters/prepare.mjs";
+import { DocxManager, compileDocument, generateDOCX, generateDOCXStream, generateDOCXSync, parseDOCX, resolveDocument } from "./converters/docx.mjs";
+import { patchDOCX } from "./converters/patch.mjs";
+import { generateHTML, parseHTML } from "./converters/html.mjs";
+import { generateMarkdown, parseMarkdown } from "./converters/markdown.mjs";
+export { DocxManager, StarterKit, compileDocument, createDocxEditor, docxExtensions, fetchImageHandler, generateDOCX, generateDOCXStream, generateDOCXSync, generateHTML, generateMarkdown, parseDOCX, parseHTML, parseMarkdown, patchDOCX, prepareDocument, prepareImages, resolveDocument, tiptapMarkExtensions, tiptapNodeExtensions };

package/dist/paragraph-fhEXtAN2.d.mts

@@ -0,0 +1,16 @@
+import { JSONContent } from "@tiptap/core";
+
+//#region src/extensions/paragraph.d.ts
+/**
+ * Paragraph extension with nested office-open attrs.
+ *
+ * Attrs mirror ParagraphPropertiesOptionsBase (alignment/indent/spacing/border/
+ * shading/frame as nested objects + scalar OOXML properties). DOCX round-trip is
+ * near-identity: renderDocx/parseDocx pass attrs through; CSS conversion happens
+ * only in renderHTML via utils mappers.
+ */
+declare function renderDocx(node: JSONContent): Record<string, unknown>;
+declare function parseDocx(opts: Record<string, unknown>): Record<string, unknown>;
+declare const Paragraph: import("@tiptap/core").Node<import("@tiptap/extension-paragraph").ParagraphOptions, any>;
+//#endregion
+export { parseDocx as n, renderDocx as r, Paragraph as t };

package/dist/strike-BgWGvjKr.d.mts

@@ -0,0 +1,33 @@
+import { RunOptions } from "@office-open/docx";
+
+//#region src/extensions/strike.d.ts
+/**
+ * Strike mark extension with nested office-open attrs.
+ *
+ * OOXML represents strikethrough on a run via two mutually exclusive booleans:
+ * `strike` (single) and `doubleStrike` (double). The mark itself is "single
+ * strikethrough"; the `doubleStrike` attr flips it to double. DOCX round-trip
+ * is near-identity for the doubleStrike flag; `strike` itself is implied by the
+ * mark's presence and handled in renderDocx/parseDocx.
+ *
+ * Mark attribute-level renderHTML is delegated to the base Strike extension
+ * (renders `<s>`); only the DOCX flag needs custom handling.
+ */
+/**
+ * attrs → run properties.
+ *
+ * The mark presence itself means single strikethrough. When `doubleStrike` is
+ * set, emit the OOXML double-strike flag instead (the two are mutually
+ * exclusive in OOXML). DocxManager calls this with `mark.attrs`.
+ */
+declare function renderDocx(attrs: Record<string, unknown>): Partial<RunOptions>;
+/**
+ * run properties → attrs.
+ *
+ * Only the `doubleStrike` flag needs to round-trip; single strike is implied by
+ * the mark's existence. `strike` is structural/semantic (the mark) and skipped.
+ */
+declare function parseDocx(runOpts: RunOptions): Record<string, unknown>;
+declare const Strike: import("@tiptap/core").Mark<import("@tiptap/extension-strike").StrikeOptions, any>;
+//#endregion
+export { parseDocx as n, renderDocx as r, Strike as t };

package/dist/table-BFkfeRp9.d.mts

@@ -0,0 +1,9 @@
+import { JSONContent } from "@tiptap/core";
+import { TableOptions } from "@office-open/docx";
+
+//#region src/extensions/table.d.ts
+declare function renderDocx(node: JSONContent): Partial<TableOptions>;
+declare function parseDocx(opts: Record<string, unknown>): Record<string, unknown>;
+declare const Table: import("@tiptap/core").Node<import("@tiptap/extension-table").TableOptions, any>;
+//#endregion
+export { parseDocx as n, renderDocx as r, Table as t };

package/dist/table-cell-D_FV4D2h.d.mts

@@ -0,0 +1,8 @@
+import { JSONContent } from "@tiptap/core";
+
+//#region src/extensions/table-cell.d.ts
+declare function renderDocx(node: JSONContent): Record<string, unknown>;
+declare function parseDocx(opts: Record<string, unknown>): Record<string, unknown>;
+declare const TableCell: import("@tiptap/core").Node<import("@tiptap/extension-table").TableCellOptions, any>;
+//#endregion
+export { parseDocx as n, renderDocx as r, TableCell as t };

package/dist/table-header-KGQ2aEkP.d.mts

@@ -0,0 +1,8 @@
+import { JSONContent } from "@tiptap/core";
+
+//#region src/extensions/table-header.d.ts
+declare function renderDocx(node: JSONContent): Record<string, unknown>;
+declare function parseDocx(opts: Record<string, unknown>): Record<string, unknown>;
+declare const TableHeader: import("@tiptap/core").Node<import("@tiptap/extension-table").TableHeaderOptions, any>;
+//#endregion
+export { parseDocx as n, renderDocx as r, TableHeader as t };

package/dist/table-row-kgzYkZlW.d.mts

@@ -0,0 +1,9 @@
+import { JSONContent } from "@tiptap/core";
+import { TableRowPropertiesOptionsBase } from "@office-open/docx";
+
+//#region src/extensions/table-row.d.ts
+declare function renderDocx(node: JSONContent): Partial<TableRowPropertiesOptionsBase>;
+declare function parseDocx(opts: Record<string, unknown>): Record<string, unknown>;
+declare const TableRow: import("@tiptap/core").Node<import("@tiptap/extension-table").TableRowOptions, any>;
+//#endregion
+export { parseDocx as n, renderDocx as r, TableRow as t };

package/dist/text-style-BHdtXkMb.d.mts

@@ -0,0 +1,8 @@
+import { RunOptions } from "@office-open/docx";
+
+//#region src/extensions/text-style.d.ts
+declare function renderDocx(attrs: Record<string, unknown>): Partial<RunOptions>;
+declare function parseDocx(opts: RunOptions): Record<string, unknown>;
+declare const TextStyle: import("@tiptap/core").Mark<import("@tiptap/extension-text-style").TextStyleOptions, any>;
+//#endregion
+export { parseDocx as n, renderDocx as r, TextStyle as t };