@docen/docx 0.3.0 → 0.3.1

package/dist/styles-QSX3RhxK.mjs

@@ -0,0 +1,285 @@
+import { f as renderParagraphStyles, h as resolveFontName, p as renderRunStyles } from "./utils-BPT4tjcn.mjs";
+//#region src/converters/styles.ts
+/** Escape a style id for safe use in a CSS class selector. OOXML style ids are
+*  NCNames so this is rarely needed, but it keeps arbitrary ids safe. */
+function escapeClass(id) {
+	return id.replace(/[^A-Za-z0-9_-]/g, (ch) => `\\${ch}`);
+}
+/** The pStyle val (class hook `docx-style-{id}`) for a built-in named style
+*  nested under DefaultStylesOptions: the key with its first letter upper-cased
+*  ("heading1" → "Heading1", "title" → "Title", "listParagraph" → "ListParagraph").
+*  This matches office-open's HeadingLevel literals / pStyle ids, so we derive
+*  the id from the key instead of hard-coding a name table. */
+function pStyleIdFromKey(key) {
+	return key.charAt(0).toUpperCase() + key.slice(1);
+}
+/** The styleId of the document's default paragraph style (`w:default="1"`
+*  type="paragraph") — the implicit style applied to every paragraph WITHOUT an
+*  explicit pStyle. OOXML renders a pStyle-less paragraph as this style (usually
+*  "Normal"), so the editor's `.docx-default` class — emitted by Paragraph/
+*  Heading renderHTML on a styleId-less node — targets it. Searched in
+*  `paragraphStyles` and the built-in named styles nested under `default`
+*  (key → pStyle id). null when the document declares none. */
+function defaultParagraphStyleId(styles) {
+	if (!styles) return null;
+	for (const ps of styles.paragraphStyles ?? []) if (ps.default) return ps.id;
+	const defaults = styles.default;
+	for (const [key, style] of Object.entries(defaults ?? {})) {
+		if (key === "document" || !style) continue;
+		if (style.default) return pStyleIdFromKey(key);
+	}
+	return null;
+}
+/**
+* Generate scoped CSS from a document's `styles.xml` model (`StylesOptions`) so
+* named paragraph/character styles and the document defaults render correctly
+* in the editor. All rules are scoped to `.docen-page` (the editor's page
+* surface); the editor injects the result into a `<style>` after load.
+*
+* - `default.document` → `.docen-page` base run + paragraph defaults (the doc's
+*   default font/size, line spacing, …).
+* - `paragraphStyles[]` → `.docen-page .docx-style-{id}` (run + paragraph CSS).
+*   Paragraph nodes carry `class="docx-style-{styleId}"` (see the Paragraph /
+*   Heading extensions' pStyle ↔ styleId round-trip).
+* - `characterStyles[]` → `.docen-page .docx-char-{id}` (run CSS).
+*
+* `basedOn` inheritance is deep-merged per-property into each named style's
+* rule (root first, child overrides) — see mergeStyleChain. CSS inheritance
+* follows the DOM tree, not a style's basedOn, so each `.docx-style-{id}` rule
+* carries its full ancestor chain rather than relying on source order.
+*/
+function stylesToCss(styles, scope) {
+	if (!styles) return "";
+	const rules = [];
+	const within = scope ? `${scope} ` : "";
+	const doc = styles.default?.document;
+	if (doc) {
+		const runDecls = doc.run ? renderRunStyles(doc.run) : [];
+		if (runDecls.length && scope) rules.push(`${scope} { ${runDecls.join(";")} }`);
+		const paraDecls = doc.paragraph ? renderParagraphStyles(doc.paragraph) : [];
+		if (paraDecls.length) {
+			const paraSel = `${within}p, ${within}h1, ${within}h2, ${within}h3, ${within}h4, ${within}h5, ${within}h6`;
+			rules.push(`${paraSel} { ${paraDecls.join(";")} }`);
+		}
+	}
+	const byId = indexParagraphStyles(styles);
+	const defaultId = defaultParagraphStyleId(styles);
+	for (const id of byId.keys()) {
+		const { run, paragraph } = mergeStyleChain(byId, id);
+		const decls = [];
+		if (Object.keys(run).length) decls.push(...renderRunStyles(run));
+		if (Object.keys(paragraph).length) decls.push(...renderParagraphStyles(paragraph));
+		if (!decls.length) continue;
+		const selector = id === defaultId ? `${within}.docx-default, ${within}.docx-style-${escapeClass(id)}` : `${within}.docx-style-${escapeClass(id)}`;
+		rules.push(`${selector} { ${decls.join(";")} }`);
+	}
+	for (const cs of styles.characterStyles ?? []) {
+		const decls = [];
+		if (cs.run) decls.push(...renderRunStyles(cs.run));
+		if (decls.length) rules.push(`${within}.docx-char-${escapeClass(cs.id)} { ${decls.join(";")} }`);
+	}
+	return rules.join("\n");
+}
+/** Build an id → style-entry index over every paragraph style: the explicit
+*  `paragraphStyles` plus the built-in named styles nested under `default`
+*  (key → pStyle id via pStyleIdFromKey). `document` is docDefaults, not a
+*  named style, so it is excluded. A built-in that also appears in
+*  paragraphStyles is deduped by id (paragraphStyles wins on insertion order). */
+function indexParagraphStyles(styles) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const ps of styles.paragraphStyles ?? []) byId.set(ps.id, ps);
+	const defaults = styles.default;
+	for (const [key, style] of Object.entries(defaults ?? {})) {
+		if (key === "document" || !style) continue;
+		byId.set(pStyleIdFromKey(key), style);
+	}
+	return byId;
+}
+/** Merge a paragraph style's run/paragraph properties with its `basedOn` chain
+*  (root first, child overrides per-property) — the OOXML inheritance model. A
+*  flat property-level merge: a child property overrides the parent's; an unset
+*  property is inherited. Shared by stylesToCss (rendering) and
+*  effectiveRunProps (the caret resolver) so the gallery box and the rendered
+*  page resolve identical values. */
+function mergeStyleChain(byId, styleId) {
+	const chain = [];
+	const visited = /* @__PURE__ */ new Set();
+	let curId = styleId || void 0;
+	while (curId && !visited.has(curId)) {
+		visited.add(curId);
+		const style = byId.get(curId);
+		if (!style) break;
+		chain.unshift(style);
+		curId = style.basedOn ?? void 0;
+	}
+	const run = {};
+	const paragraph = {};
+	for (const style of chain) {
+		const s = style;
+		if (s.run) Object.assign(run, s.run);
+		if (s.paragraph) Object.assign(paragraph, s.paragraph);
+	}
+	return {
+		run,
+		paragraph
+	};
+}
+/** The `DefaultStylesOptions` keys whose values are character styles, not
+*  paragraph styles. The Quick Styles gallery is paragraph-only, so these are
+*  excluded even when flagged `quickFormat` (the authoritative source is
+*  office-open's DefaultStylesOptions interface). */
+const CHARACTER_DEFAULT_KEYS = new Set([
+	"hyperlink",
+	"footnoteReference",
+	"footnoteTextChar",
+	"endnoteReference",
+	"endnoteTextChar"
+]);
+/**
+* The paragraph styles to list in the Quick Styles gallery, matching Word's
+* default behavior: the gallery is a *paragraph-style* selector (it applies a
+* pStyle), so only paragraph styles appear — never character styles, even
+* those flagged `quickFormat` (those live in the Styles task pane). Among
+* paragraph styles, only those flagged `quickFormat` are listed, ordered by
+* `uiPriority` (Word orders the gallery this way).
+*
+* Reads `quickFormat`/`uiPriority`/`name` straight from office-open's styles
+* model (`StylesOptions`): `paragraphStyles` (Normal + custom) and the built-in
+* named paragraph styles nested under `default` (title/heading1-9/quote/…). The
+* `default` keys that hold character styles are excluded via
+* `CHARACTER_DEFAULT_KEYS`. When a document carries no quickFormat flags at all
+* (e.g. some LibreOffice-generated files), fall back to all paragraph styles so
+* the gallery is never empty.
+*/
+function quickStyles(styles) {
+	if (!styles) return [];
+	const all = [];
+	const seen = /* @__PURE__ */ new Set();
+	const push = (id, style) => {
+		if (seen.has(id)) return;
+		seen.add(id);
+		all.push({
+			id,
+			name: style.name || id,
+			uiPriority: style.uiPriority ?? 9999,
+			quick: !!style.quickFormat
+		});
+	};
+	for (const ps of styles.paragraphStyles ?? []) push(ps.id, ps);
+	const defaults = styles.default;
+	for (const [key, style] of Object.entries(defaults)) {
+		if (key === "document" || CHARACTER_DEFAULT_KEYS.has(key) || !style) continue;
+		push(pStyleIdFromKey(key), style);
+	}
+	const byPriority = (a, b) => a.uiPriority - b.uiPriority;
+	const quick = all.filter((s) => s.quick).sort(byPriority);
+	return (quick.length > 0 ? quick : all).map(({ id, name }) => ({
+		id,
+		name
+	}));
+}
+/** Resolve the effective run-level properties (font name, size in points) at the
+*  caret, staying in the document's own units — no px conversion. Priority:
+*  direct run props (the textStyle mark) → the paragraph style (`styleId`) →
+*  its `basedOn` chain → the document defaults. `font` is resolved to a single
+*  display name (ascii/hAnsi/eastAsia). Returns null where nothing in the chain
+*  sets a property, so the caller can leave the box empty. */
+function effectiveRunProps(styles, styleId, direct) {
+	let font = null;
+	let size = null;
+	if (direct) {
+		font = resolveFontName(direct.font);
+		if (typeof direct.size === "number" && direct.size > 0) size = direct.size;
+	}
+	if ((font == null || size == null) && styles) {
+		const effStyleId = styleId || defaultParagraphStyleId(styles);
+		const { run } = mergeStyleChain(indexParagraphStyles(styles), effStyleId);
+		if (font == null) font = resolveFontName(run.font);
+		if (size == null && typeof run.size === "number" && run.size > 0) size = run.size;
+		if (font == null || size == null) {
+			const docRun = styles.default?.document?.run;
+			if (docRun) {
+				if (font == null) font = resolveFontName(docRun.font);
+				if (size == null && typeof docRun.size === "number" && docRun.size > 0) size = docRun.size;
+			}
+		}
+	}
+	return {
+		font,
+		size
+	};
+}
+/** Index a document's character styles (explicit `characterStyles` + the
+*  built-in character keys under `default`) by pStyle id → run properties. Core
+*  phase: a character style's own run only (its basedOn chain is not walked —
+*  rare in practice; paragraph styles above already deep-merge). */
+function indexCharacterRunStyles(styles) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const cs of styles.characterStyles ?? []) if (cs.run) byId.set(cs.id, cs.run);
+	const defaults = styles.default;
+	for (const [key, style] of Object.entries(defaults ?? {})) {
+		if (!style || !style.run || key === "document") continue;
+		if (!CHARACTER_DEFAULT_KEYS.has(key)) continue;
+		byId.set(pStyleIdFromKey(key), style.run);
+	}
+	return byId;
+}
+/** Resolve one node's style inheritance: a paragraph/heading absorbs its
+*  styleId's basedOn chain (paragraph properties + the default `run`); a
+*  textStyle mark absorbs its character style's run. Explicit attrs/marks
+*  override the inherited values; styleId is preserved. Pure JSON — no DOM, no
+*  marks pushed onto text. */
+function resolveNode(node, paraById, charRunById) {
+	const out = { ...node };
+	const attrs = node.attrs;
+	const type = node.type;
+	if ((type === "paragraph" || type === "heading") && attrs?.styleId) {
+		const { paragraph, run } = mergeStyleChain(paraById, attrs.styleId);
+		const mergedRun = {
+			...run,
+			...attrs.run
+		};
+		out.attrs = {
+			...paragraph,
+			...attrs,
+			run: mergedRun
+		};
+	}
+	if (node.marks) out.marks = node.marks.map((m) => {
+		if (m.type !== "textStyle") return m;
+		const sid = m.attrs?.styleId;
+		const crun = sid ? charRunById.get(sid) : void 0;
+		return crun ? {
+			...m,
+			attrs: {
+				...crun,
+				...m.attrs
+			}
+		} : m;
+	});
+	if (node.content) out.content = node.content.map((c) => resolveNode(c, paraById, charRunById));
+	return out;
+}
+/**
+* Inline a document's styles into each node's attrs — a self-contained
+* JSONContent that round-trips and renders without the styles context. A
+* paragraph/heading absorbs its styleId's `basedOn` chain (paragraph properties
+* + the paragraph's default `run`); a textStyle mark absorbs its character
+* style's run. Explicit attrs/marks always override the inherited values;
+* styleId is preserved (the semantic reference is kept). The style definitions
+* themselves are untouched — only properties are copied onto nodes.
+*
+* Styles default to the document's own `attrs.styles` (the round-tripped
+* styles.xml model carried on the doc node), so `inlineStyles(doc)` needs no
+* second argument; pass `styles` explicitly to override. Use cases:
+* cross-document paste (the snippet carries its styling) and self-contained
+* export. The editor still renders via global styles — this only merges JSON
+* properties.
+*/
+function inlineStyles(json, styles) {
+	const docStyles = styles ?? json.attrs?.styles;
+	if (!docStyles) return json;
+	return resolveNode(json, indexParagraphStyles(docStyles), indexCharacterRunStyles(docStyles));
+}
+//#endregion
+export { stylesToCss as a, quickStyles as i, effectiveRunProps as n, inlineStyles as r, defaultParagraphStyleId as t };

package/dist/styles-ugspkrxz.d.mts

@@ -0,0 +1,85 @@
+import { JSONContent } from "@tiptap/core";
+import { StylesOptions } from "@office-open/docx";
+
+//#region src/converters/styles.d.ts
+/** The styleId of the document's default paragraph style (`w:default="1"`
+ *  type="paragraph") — the implicit style applied to every paragraph WITHOUT an
+ *  explicit pStyle. OOXML renders a pStyle-less paragraph as this style (usually
+ *  "Normal"), so the editor's `.docx-default` class — emitted by Paragraph/
+ *  Heading renderHTML on a styleId-less node — targets it. Searched in
+ *  `paragraphStyles` and the built-in named styles nested under `default`
+ *  (key → pStyle id). null when the document declares none. */
+declare function defaultParagraphStyleId(styles: StylesOptions | null | undefined): string | null;
+/**
+ * Generate scoped CSS from a document's `styles.xml` model (`StylesOptions`) so
+ * named paragraph/character styles and the document defaults render correctly
+ * in the editor. All rules are scoped to `.docen-page` (the editor's page
+ * surface); the editor injects the result into a `<style>` after load.
+ *
+ * - `default.document` → `.docen-page` base run + paragraph defaults (the doc's
+ *   default font/size, line spacing, …).
+ * - `paragraphStyles[]` → `.docen-page .docx-style-{id}` (run + paragraph CSS).
+ *   Paragraph nodes carry `class="docx-style-{styleId}"` (see the Paragraph /
+ *   Heading extensions' pStyle ↔ styleId round-trip).
+ * - `characterStyles[]` → `.docen-page .docx-char-{id}` (run CSS).
+ *
+ * `basedOn` inheritance is deep-merged per-property into each named style's
+ * rule (root first, child overrides) — see mergeStyleChain. CSS inheritance
+ * follows the DOM tree, not a style's basedOn, so each `.docx-style-{id}` rule
+ * carries its full ancestor chain rather than relying on source order.
+ */
+declare function stylesToCss(styles: StylesOptions | null | undefined, scope: string): string;
+/** A gallery-ready paragraph-style entry for the Styles combobox. */
+interface QuickStyleEntry {
+  id: string;
+  name: string;
+}
+/**
+ * The paragraph styles to list in the Quick Styles gallery, matching Word's
+ * default behavior: the gallery is a *paragraph-style* selector (it applies a
+ * pStyle), so only paragraph styles appear — never character styles, even
+ * those flagged `quickFormat` (those live in the Styles task pane). Among
+ * paragraph styles, only those flagged `quickFormat` are listed, ordered by
+ * `uiPriority` (Word orders the gallery this way).
+ *
+ * Reads `quickFormat`/`uiPriority`/`name` straight from office-open's styles
+ * model (`StylesOptions`): `paragraphStyles` (Normal + custom) and the built-in
+ * named paragraph styles nested under `default` (title/heading1-9/quote/…). The
+ * `default` keys that hold character styles are excluded via
+ * `CHARACTER_DEFAULT_KEYS`. When a document carries no quickFormat flags at all
+ * (e.g. some LibreOffice-generated files), fall back to all paragraph styles so
+ * the gallery is never empty.
+ */
+declare function quickStyles(styles: StylesOptions | null | undefined): QuickStyleEntry[];
+/** Resolve the effective run-level properties (font name, size in points) at the
+ *  caret, staying in the document's own units — no px conversion. Priority:
+ *  direct run props (the textStyle mark) → the paragraph style (`styleId`) →
+ *  its `basedOn` chain → the document defaults. `font` is resolved to a single
+ *  display name (ascii/hAnsi/eastAsia). Returns null where nothing in the chain
+ *  sets a property, so the caller can leave the box empty. */
+declare function effectiveRunProps(styles: StylesOptions | null | undefined, styleId: string | null | undefined, direct?: {
+  font?: unknown;
+  size?: unknown;
+}): {
+  font: string | null;
+  size: number | null;
+};
+/**
+ * Inline a document's styles into each node's attrs — a self-contained
+ * JSONContent that round-trips and renders without the styles context. A
+ * paragraph/heading absorbs its styleId's `basedOn` chain (paragraph properties
+ * + the paragraph's default `run`); a textStyle mark absorbs its character
+ * style's run. Explicit attrs/marks always override the inherited values;
+ * styleId is preserved (the semantic reference is kept). The style definitions
+ * themselves are untouched — only properties are copied onto nodes.
+ *
+ * Styles default to the document's own `attrs.styles` (the round-tripped
+ * styles.xml model carried on the doc node), so `inlineStyles(doc)` needs no
+ * second argument; pass `styles` explicitly to override. Use cases:
+ * cross-document paste (the snippet carries its styling) and self-contained
+ * export. The editor still renders via global styles — this only merges JSON
+ * properties.
+ */
+declare function inlineStyles(json: JSONContent, styles?: StylesOptions | null): JSONContent;
+//#endregion
+export { inlineStyles as a, effectiveRunProps as i, StylesOptions as n, quickStyles as o, defaultParagraphStyleId as r, stylesToCss as s, QuickStyleEntry as t };

package/dist/table-DrA12lxX.mjs

@@ -0,0 +1,159 @@
+import { k as Table$1 } from "./tiptap-D7pl4I5U.mjs";
+import { S as twipToCss, _ as shadingFromElement, d as renderBorderCSS, i as bordersFromElement, n as alignmentFromElement, r as alignmentToCss, v as shadingToCss } from "./utils-BPT4tjcn.mjs";
+//#region src/extensions/table.ts
+/**
+* Table extension with nested office-open attrs.
+*
+* Attrs mirror TableOptions (width/float/layout/borders/alignment/margins/indent/
+* cellSpacing/tableLook/columnWidths/etc.). DOCX round-trip is near-identity:
+* renderDocx/parseDocx pass attrs through (omitting only `rows`, which DocxManager
+* rebuilds from the row/cell nodes). CSS conversion happens only in renderHTML.
+*/
+/** Structural key rebuilt by DocxManager (compileTableNode walks the row nodes). */
+const SKIP_KEYS = new Set(["rows", "columnWidthsRevision"]);
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	for (const [key, value] of Object.entries(attrs)) {
+		if (SKIP_KEYS.has(key)) continue;
+		if (value !== null && value !== void 0) opts[key] = value;
+	}
+	return opts;
+}
+function parseDocx(opts) {
+	const attrs = {};
+	for (const [key, value] of Object.entries(opts)) {
+		if (SKIP_KEYS.has(key)) continue;
+		attrs[key] = value ?? null;
+	}
+	return attrs;
+}
+const attrNative = () => ({
+	default: null,
+	parseHTML: () => null,
+	rendered: false
+});
+const Table = Table$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			width: attrNative(),
+			columnWidths: attrNative(),
+			indent: attrNative(),
+			margins: attrNative(),
+			float: attrNative(),
+			borders: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => bordersFromElement(el)
+			},
+			shading: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => shadingFromElement(el)
+			},
+			alignment: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => alignmentFromElement(el)
+			},
+			layout: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => el.style.tableLayout === "fixed" ? "fixed" : null
+			},
+			style: attrNative(),
+			visuallyRightToLeft: attrNative(),
+			tableLook: attrNative(),
+			cellSpacing: attrNative(),
+			styleRowBandSize: attrNative(),
+			styleColBandSize: attrNative(),
+			caption: attrNative(),
+			description: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const a = node.attrs;
+		const attrs = { ...HTMLAttributes };
+		const styles = [];
+		const align = alignmentToCss(a.alignment);
+		if (align === "center") styles.push("margin-left:auto", "margin-right:auto");
+		else if (align === "right") styles.push("margin-left:auto", "margin-right:0");
+		else if (align) styles.push("margin-left:0", "margin-right:auto");
+		if (a.layout === "fixed") styles.push("table-layout:fixed");
+		if (a.width && typeof a.width === "object") {
+			const w = a.width;
+			const numSize = typeof w.size === "string" ? parseFloat(w.size) : w.size;
+			if (w.type === "pct") {
+				if (typeof w.size === "string" && w.size.includes("%")) styles.push(`width:${w.size}`);
+				else if (!Number.isNaN(numSize)) styles.push(`width:${numSize / 50}%`);
+			} else if (w.type === "auto") styles.push("width:100%");
+			else if (numSize != null) {
+				const css = twipToCss(numSize);
+				if (css) styles.push(`width:${css}`);
+			}
+		} else styles.push("width:100%");
+		if (a.indent && typeof a.indent === "object") {
+			const ind = a.indent;
+			if (ind.size != null) {
+				const css = twipToCss(ind.size);
+				if (css) styles.push(`margin-left:${css}`);
+			}
+		}
+		if (a.cellSpacing && typeof a.cellSpacing === "object") {
+			const cs = a.cellSpacing;
+			if (cs.value != null) {
+				const css = twipToCss(cs.value);
+				if (css) styles.push(`border-spacing:${css}`);
+			}
+		}
+		const bg = shadingToCss(a.shading);
+		if (bg) styles.push(`background-color:${bg}`);
+		if (a.borders && typeof a.borders === "object") {
+			const b = a.borders;
+			const sides = [
+				["top", b.top],
+				["bottom", b.bottom],
+				["left", b.left],
+				["right", b.right]
+			];
+			for (const [side, border] of sides) {
+				const css = renderBorderCSS(border);
+				if (css) styles.push(`border-${side}:${css}`);
+			}
+		}
+		const firstRow = node.firstChild;
+		const cellPx = [];
+		if (firstRow) for (let i = 0; i < firstRow.childCount; i++) {
+			const cw = firstRow.child(i).attrs.colwidth;
+			if (Array.isArray(cw) && cw.length) for (const w of cw) cellPx.push(w || 0);
+			else cellPx.push(0);
+		}
+		const hasCellWidths = cellPx.some((w) => w > 0);
+		const tblGridPx = (a.columnWidths ?? []).map((w) => Math.round((w || 0) / 15));
+		const gridPx = tblGridPx.some((w) => w > 0) ? tblGridPx : hasCellWidths ? cellPx : tblGridPx;
+		if (styles.length > 0) attrs.style = styles.join(";");
+		if (gridPx.some((w) => w > 0)) {
+			const gridTotal = gridPx.reduce((sum, w) => sum + w, 0);
+			return [
+				"table",
+				attrs,
+				[
+					"colgroup",
+					{},
+					...gridPx.map((w) => ["col", { style: `width:${gridTotal > 0 ? (w / gridTotal * 100).toFixed(2) : 0}%` }])
+				],
+				["tbody", 0]
+			];
+		}
+		return [
+			"table",
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
+export { parseDocx as n, renderDocx as r, Table as t };

package/dist/table-cell-DmkfYwDc.mjs

@@ -0,0 +1,112 @@
+import { A as TableCell$1 } from "./tiptap-D7pl4I5U.mjs";
+import { _ as shadingFromElement, i as bordersFromElement, m as renderTableCellStyles } from "./utils-BPT4tjcn.mjs";
+//#region src/extensions/table-cell.ts
+/**
+* Table cell extension with nested office-open attrs.
+*
+* Attrs mirror TableCellPropertiesOptionsBase (shading/margins/borders/width as
+* nested objects + scalar OOXML properties) plus the inherited Tiptap structural
+* names colspan/rowspan/colwidth/align (rendered: false for the OOXML-named ones).
+* DOCX round-trip is near-identity: renderDocx/parseDocx pass OOXML-native attrs
+* through and only map the Tiptap structural names colspan/rowspan/colwidth to
+* OOXML columnSpan/rowSpan/width. CSS conversion happens solely in renderHTML via
+* utils.renderTableCellStyles (consuming nested shading/verticalAlign/noWrap).
+*/
+/** Tiptap structural attrs expressed via OOXML structural fields, not passed through. */
+const SKIP_KEYS = new Set([
+	"colspan",
+	"rowspan",
+	"colwidth",
+	"children"
+]);
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	const colspan = attrs.colspan;
+	if (colspan && colspan > 1) opts.columnSpan = colspan;
+	const rowspan = attrs.rowspan;
+	if (rowspan && rowspan > 1) opts.rowSpan = rowspan;
+	const colwidth = attrs.colwidth;
+	if (colwidth && colwidth.length > 0) {
+		const totalPx = colwidth.reduce((sum, w) => sum + (w || 0), 0);
+		if (totalPx > 0) opts.width = {
+			size: totalPx * 15,
+			type: "dxa"
+		};
+	}
+	for (const [key, value] of Object.entries(attrs)) {
+		if (SKIP_KEYS.has(key)) continue;
+		if (value !== null && value !== void 0) opts[key] = value;
+	}
+	return opts;
+}
+function parseDocx(opts) {
+	const resolved = typeof opts === "string" ? { text: opts } : opts;
+	const attrs = {};
+	if (resolved.columnSpan != null) attrs.colspan = resolved.columnSpan;
+	if (resolved.rowSpan != null) attrs.rowspan = resolved.rowSpan;
+	if (resolved.width) {
+		const twips = resolved.width.size ?? 0;
+		if (twips) attrs.colwidth = [Math.round(twips / 15)];
+	}
+	for (const [key, value] of Object.entries(resolved)) {
+		if (key === "columnSpan" || key === "rowSpan" || key === "width" || key === "children") continue;
+		attrs[key] = value ?? null;
+	}
+	return attrs;
+}
+const attrNative = () => ({
+	default: null,
+	parseHTML: () => null,
+	rendered: false
+});
+const TableCell = TableCell$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			shading: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => shadingFromElement(el)
+			},
+			borders: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => bordersFromElement(el)
+			},
+			verticalAlign: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => el.style.verticalAlign || null
+			},
+			textDirection: attrNative(),
+			width: attrNative(),
+			margins: attrNative(),
+			noWrap: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => el.style.whiteSpace === "nowrap" ? true : null
+			},
+			verticalMerge: attrNative(),
+			horizontalMerge: attrNative(),
+			fitText: attrNative(),
+			hideMark: attrNative(),
+			headers: attrNative(),
+			cnfStyle: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const styles = renderTableCellStyles(node.attrs);
+		const attrs = { ...HTMLAttributes };
+		if (styles.length > 0) attrs.style = styles.join(";");
+		return [
+			"td",
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
+export { parseDocx as n, renderDocx as r, TableCell as t };