@docen/docx 0.3.1 → 0.3.2

package/dist/converters/html.d.mts

@@ -1,2 +1,29 @@
-import { n as parseHTML, t as generateHTML } from "../html-DCC_DSHv.mjs";
+import { a as JSONContent, i as Extensions } from "../core-C9VunJ8o.mjs";
+import { ParseOptions } from "@tiptap/pm/model";
+
+//#region src/converters/html.d.ts
+/**
+ * Serialize Tiptap JSON to an HTML string. Renders per-section: each OOXML
+ * section (CT_SectPr) becomes a `<section>` carrying its own page margin
+ * (padding) and a document-grid line-height (the font's `normal` metric —
+ * Word does not add the grid pitch to rendered line height), so paragraph
+ * line-spacing multiples resolve against the section's font, not a fallback.
+ * The document background (CT_DocumentBase, single for the whole doc) wraps all
+ * sections.
+ *
+ * Same ProseMirror DOMSerializer pipeline as @tiptap/html, on a linkedom
+ * document: happy-dom drops calc(var(…)) when re-serializing the style
+ * attribute, so DOCX line-spacing survives only with linkedom.
+ */
+declare function generateHTML(doc: JSONContent, extensions?: Extensions): string;
+/**
+ * Parse an HTML string into Tiptap JSON. Same ProseMirror DOMParser pipeline as
+ * @tiptap/html on a linkedom document. The background wrapper and section
+ * containers are unknown elements (no doc/div/section node in the schema), so
+ * the parser ignores their tags and extracts the content. Section geometry
+ * (linePitch/margins) and the page background are section/doc-level metadata,
+ * not content — they round-trip losslessly via DOCX, not HTML.
+ */
+declare function parseHTML(html: string, extensions?: Extensions, options?: ParseOptions): JSONContent;
+//#endregion
 export { generateHTML, parseHTML };

package/dist/converters/html.mjs

@@ -1,2 +1,104 @@
-import { n as parseHTML, t as generateHTML } from "../html-DedDWPoO.mjs";
+import { s as docxExtensions } from "../core-DT9IrTzN.mjs";
+import { sectionLinePitchCss, sectionMarginCss } from "../extensions/utils.mjs";
+import { getSchema } from "@tiptap/core";
+import { encodeBase64 } from "@office-open/core";
+import { DOMParser, DOMSerializer, Node } from "@tiptap/pm/model";
+import { parseHTML as parseHTML$1 } from "linkedom";
+//#region src/converters/html.ts
+const defaultExtensions = docxExtensions;
+/** JSON round-trips byte arrays as plain objects ({0:byte,…}); rebuild here. */
+function toBytes(data) {
+	if (!data) return null;
+	return data instanceof Uint8Array ? data : new Uint8Array(Object.values(data));
+}
+/** Page background → CSS for the root wrapper. Color renders directly; a VML
+*  pattern's first media item tiles as an image. OOXML patterns have no CSS
+*  equivalent, so DOCX (not HTML) is the fidelity source. */
+function backgroundToCss(bg) {
+	const styles = [];
+	if (bg?.color) styles.push(`background-color:#${bg.color}`);
+	const media = bg?.rawMedia?.[0];
+	const bytes = toBytes(media?.data);
+	if (bytes) styles.push(`background-image:url(data:image/${media?.type ?? "png"};base64,${encodeBase64(bytes)})`, "background-repeat:repeat");
+	return styles.length ? styles.join(";") : void 0;
+}
+/** Split flat `doc > block+` into sections by section-carrying paragraphs.
+*  Mirrors DocxManager's compile-time split (converters/docx.ts): a paragraph
+*  with `sectionProperties` closes its section; trailing blocks form the final
+*  section under doc.attrs.sectionProperties. No section-carrying paragraph →
+*  a single section (backward compatible). */
+function splitJsonSections(doc) {
+	const sections = [];
+	let current = [];
+	for (const node of doc.content ?? []) {
+		current.push(node);
+		const sp = node.attrs?.sectionProperties;
+		if (sp != null) {
+			sections.push({
+				properties: sp,
+				blocks: current
+			});
+			current = [];
+		}
+	}
+	const tailProps = doc.attrs?.sectionProperties;
+	sections.push({
+		properties: tailProps ?? null,
+		blocks: current
+	});
+	return sections;
+}
+/**
+* Serialize Tiptap JSON to an HTML string. Renders per-section: each OOXML
+* section (CT_SectPr) becomes a `<section>` carrying its own page margin
+* (padding) and a document-grid line-height (the font's `normal` metric —
+* Word does not add the grid pitch to rendered line height), so paragraph
+* line-spacing multiples resolve against the section's font, not a fallback.
+* The document background (CT_DocumentBase, single for the whole doc) wraps all
+* sections.
+*
+* Same ProseMirror DOMSerializer pipeline as @tiptap/html, on a linkedom
+* document: happy-dom drops calc(var(…)) when re-serializing the style
+* attribute, so DOCX line-spacing survives only with linkedom.
+*/
+function generateHTML(doc, extensions = defaultExtensions) {
+	const schema = getSchema(extensions);
+	const { document } = parseHTML$1("<!DOCTYPE html><html><body></body></html>");
+	const serializer = DOMSerializer.fromSchema(schema);
+	const parts = [];
+	for (const section of splitJsonSections(doc)) {
+		const sp = section.properties;
+		const styles = [];
+		const padding = sectionMarginCss(sp?.page?.margin);
+		if (padding) styles.push(padding);
+		styles.push(...sectionLinePitchCss(sp?.grid));
+		const sec = document.createElement("section");
+		if (styles.length) sec.setAttribute("style", styles.join(";"));
+		if (section.blocks.length) {
+			const fragment = Node.fromJSON(schema, {
+				type: "doc",
+				content: section.blocks
+			}).content;
+			serializer.serializeFragment(fragment, { document }, sec);
+		}
+		parts.push(sec.outerHTML);
+	}
+	const body = parts.join("");
+	const bgCss = backgroundToCss(doc.attrs?.background);
+	return bgCss ? `<div style="${bgCss}">${body}</div>` : body;
+}
+/**
+* Parse an HTML string into Tiptap JSON. Same ProseMirror DOMParser pipeline as
+* @tiptap/html on a linkedom document. The background wrapper and section
+* containers are unknown elements (no doc/div/section node in the schema), so
+* the parser ignores their tags and extracts the content. Section geometry
+* (linePitch/margins) and the page background are section/doc-level metadata,
+* not content — they round-trip losslessly via DOCX, not HTML.
+*/
+function parseHTML(html, extensions = defaultExtensions, options) {
+	const schema = getSchema(extensions);
+	const { document } = parseHTML$1(`<!DOCTYPE html><html><body>${html}</body></html>`);
+	return DOMParser.fromSchema(schema).parse(document.body, options).toJSON();
+}
+//#endregion
 export { generateHTML, parseHTML };

package/dist/converters/markdown.d.mts

@@ -1,2 +1,13 @@
-import { n as parseMarkdown, t as generateMarkdown } from "../markdown-D0k0sRYS.mjs";
+import { a as JSONContent } from "../core-C9VunJ8o.mjs";
+
+//#region src/converters/markdown.d.ts
+/**
+ * Parse Markdown string to Tiptap JSON.
+ */
+declare function parseMarkdown(markdown: string): JSONContent;
+/**
+ * Generate Markdown string from Tiptap JSON.
+ */
+declare function generateMarkdown(doc: JSONContent): string;
+//#endregion
 export { generateMarkdown, parseMarkdown };

package/dist/converters/markdown.mjs

@@ -1,2 +1,18 @@
-import { n as parseMarkdown, t as generateMarkdown } from "../markdown-BzJmRsBs.mjs";
+import { s as docxExtensions } from "../core-DT9IrTzN.mjs";
+import { Markdown, MarkdownManager } from "@tiptap/markdown";
+//#region src/converters/markdown.ts
+const markdownManager = new MarkdownManager({ extensions: [...docxExtensions, Markdown] });
+/**
+* Parse Markdown string to Tiptap JSON.
+*/
+function parseMarkdown(markdown) {
+	return markdownManager.parse(markdown);
+}
+/**
+* Generate Markdown string from Tiptap JSON.
+*/
+function generateMarkdown(doc) {
+	return markdownManager.serialize(doc);
+}
+//#endregion
 export { generateMarkdown, parseMarkdown };

package/dist/converters/patch.d.mts

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

package/dist/converters/patch.mjs

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

package/dist/converters/prepare.d.mts

@@ -1,2 +1,63 @@
-import { a as prepareImageSizes, i as prepareDocument, n as PrepareStep, o as prepareImages, r as fetchImageHandler, t as ImageFetchHandler } from "../prepare-CPAvcv6q.mjs";
+import { a as JSONContent } from "../core-C9VunJ8o.mjs";
+
+//#region src/converters/prepare.d.ts
+/**
+ * A prepare step that transforms Tiptap JSON in place (e.g. fetch external resources).
+ */
+type PrepareStep = (json: JSONContent) => Promise<void>;
+/**
+ * Fetch handler for external image URLs.
+ *
+ * Receives the URL, returns the image binary data.
+ * Override to customize fetching (proxy, auth, caching, etc.).
+ */
+type ImageFetchHandler = (url: string) => Promise<Uint8Array>;
+/**
+ * Default fetch handler using the global `fetch` API (Node 18+ and browsers).
+ */
+declare function fetchImageHandler(url: string): Promise<Uint8Array>;
+/**
+ * Create a prepare step that fetches external image URLs and converts them to data URLs.
+ *
+ * @param handler - Custom fetch handler (defaults to `fetchImageHandler`)
+ *
+ * @example
+ * ```ts
+ * // Use with defaults
+ * await prepareDocument(json);
+ *
+ * // Custom handler
+ * await prepareDocument(json, [prepareImages(myHandler)]);
+ * ```
+ */
+declare function prepareImages(handler?: ImageFetchHandler): PrepareStep;
+/**
+ * Create a prepare step that fills in missing image dimensions by reading image
+ * metadata. Intended to run after {@link prepareImages} so HTTP sources are
+ * already embedded as data URLs.
+ *
+ * Only images lacking `width` or `height` are probed — the DOCX round-trip path
+ * already carries `transformation.width/height`, so this mainly serves images
+ * entering via HTML/Markdown (which carry no intrinsic size). Images whose
+ * metadata can't be read are left untouched; `renderDocx` falls back to 600×400
+ * (see extensions/image.ts).
+ */
+declare function prepareImageSizes(): PrepareStep;
+/**
+ * Run prepare steps on a Tiptap JSON document before compilation.
+ *
+ * Each step receives the JSON and may mutate it in place (e.g. replace external
+ * URLs with embedded data). Steps run sequentially in order.
+ *
+ * Defaults to `[prepareImages(), prepareImageSizes()]` when no steps are provided.
+ *
+ * @example
+ * ```ts
+ * const json = parseHTML(html);
+ * await prepareDocument(json);             // default: fetch images
+ * const docOpts = compileDocument(json);
+ * ```
+ */
+declare function prepareDocument(json: JSONContent, steps?: readonly PrepareStep[]): Promise<void>;
+//#endregion
 export { ImageFetchHandler, PrepareStep, fetchImageHandler, prepareDocument, prepareImageSizes, prepareImages };

package/dist/converters/prepare.mjs

@@ -1,2 +1,122 @@
-import { i as prepareImages, n as prepareDocument, r as prepareImageSizes, t as fetchImageHandler } from "../prepare-Bdk8Cjkf.mjs";
+import { encodeBase64 } from "@office-open/core";
+import { imageMeta } from "image-meta";
+//#region src/converters/prepare.ts
+/**
+* Default fetch handler using the global `fetch` API (Node 18+ and browsers).
+*/
+async function fetchImageHandler(url) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to fetch image from ${url}: ${response.status} ${response.statusText}`);
+	const buffer = await response.arrayBuffer();
+	return new Uint8Array(buffer);
+}
+/**
+* Create a prepare step that fetches external image URLs and converts them to data URLs.
+*
+* @param handler - Custom fetch handler (defaults to `fetchImageHandler`)
+*
+* @example
+* ```ts
+* // Use with defaults
+* await prepareDocument(json);
+*
+* // Custom handler
+* await prepareDocument(json, [prepareImages(myHandler)]);
+* ```
+*/
+function prepareImages(handler = fetchImageHandler) {
+	return async (json) => {
+		await walkImages(json, handler);
+	};
+}
+/**
+* Create a prepare step that fills in missing image dimensions by reading image
+* metadata. Intended to run after {@link prepareImages} so HTTP sources are
+* already embedded as data URLs.
+*
+* Only images lacking `width` or `height` are probed — the DOCX round-trip path
+* already carries `transformation.width/height`, so this mainly serves images
+* entering via HTML/Markdown (which carry no intrinsic size). Images whose
+* metadata can't be read are left untouched; `renderDocx` falls back to 600×400
+* (see extensions/image.ts).
+*/
+function prepareImageSizes() {
+	return async (json) => {
+		await walkImageSizes(json);
+	};
+}
+/** Built-in prepare steps, run when no custom steps are provided. */
+const DEFAULT_STEPS = [prepareImages(), prepareImageSizes()];
+/**
+* Run prepare steps on a Tiptap JSON document before compilation.
+*
+* Each step receives the JSON and may mutate it in place (e.g. replace external
+* URLs with embedded data). Steps run sequentially in order.
+*
+* Defaults to `[prepareImages(), prepareImageSizes()]` when no steps are provided.
+*
+* @example
+* ```ts
+* const json = parseHTML(html);
+* await prepareDocument(json);             // default: fetch images
+* const docOpts = compileDocument(json);
+* ```
+*/
+async function prepareDocument(json, steps = DEFAULT_STEPS) {
+	for (const step of steps) await step(json);
+}
+async function toDataUrl(src, handler) {
+	const data = await handler(src);
+	return `data:${{
+		jpg: "image/jpeg",
+		jpeg: "image/jpeg",
+		png: "image/png",
+		gif: "image/gif",
+		bmp: "image/bmp",
+		svg: "image/svg+xml",
+		webp: "image/webp"
+	}[src.split(".").pop()?.toLowerCase() ?? "png"] ?? "image/png"};base64,${encodeBase64(data)}`;
+}
+async function walkImages(node, handler) {
+	if (node.type === "image" && node.attrs) {
+		const src = node.attrs.src;
+		if (src && (src.startsWith("http://") || src.startsWith("https://"))) try {
+			node.attrs.src = await toDataUrl(src, handler);
+		} catch (error) {
+			console.warn(`Failed to fetch image: ${src}`, error instanceof Error ? error.message : error);
+		}
+	}
+	const tasks = [];
+	for (const child of node.content ?? []) tasks.push(walkImages(child, handler));
+	await Promise.all(tasks);
+}
+async function walkImageSizes(node) {
+	if (node.type === "image" && node.attrs) {
+		const attrs = node.attrs;
+		const needsWidth = attrs.width == null;
+		const needsHeight = attrs.height == null;
+		if (needsWidth || needsHeight) {
+			const bytes = decodeDataUrl(attrs.src);
+			if (bytes) try {
+				const meta = imageMeta(bytes);
+				if (needsWidth && typeof meta.width === "number") attrs.width = meta.width;
+				if (needsHeight && typeof meta.height === "number") attrs.height = meta.height;
+			} catch {}
+		}
+	}
+	const tasks = [];
+	for (const child of node.content ?? []) tasks.push(walkImageSizes(child));
+	await Promise.all(tasks);
+}
+/** Decode a `data:image/...;base64,...` URL to bytes; null if not a data URL. */
+function decodeDataUrl(src) {
+	if (!src) return null;
+	const match = src.match(/^data:image\/[\w.+-]+;base64,(.+)$/);
+	if (!match) return null;
+	const binary = atob(match[1]);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+//#endregion
 export { fetchImageHandler, prepareDocument, prepareImageSizes, prepareImages };

package/dist/converters/styles.d.mts

@@ -1,2 +1,85 @@
-import { a as inlineStyles, i as effectiveRunProps, n as StylesOptions, o as quickStyles, r as defaultParagraphStyleId, s as stylesToCss, t as QuickStyleEntry } from "../styles-ugspkrxz.mjs";
+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 { QuickStyleEntry, type StylesOptions, defaultParagraphStyleId, effectiveRunProps, inlineStyles, quickStyles, stylesToCss };