@docen/docx 0.3.1 → 0.3.2

package/dist/prepare-Bdk8Cjkf.mjs

@@ -1,122 +0,0 @@
-import { t as encodeBase64 } from "./dist-B6B3HnVZ.mjs";
-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 { prepareImages as i, prepareDocument as n, prepareImageSizes as r, fetchImageHandler as t };

package/dist/prepare-CPAvcv6q.d.mts

@@ -1,63 +0,0 @@
-import { a as JSONContent } from "./core-fBMCCj4D.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 { prepareImageSizes as a, prepareDocument as i, PrepareStep as n, prepareImages as o, fetchImageHandler as r, ImageFetchHandler as t };

package/dist/strike-hWxShOgb.mjs

@@ -1,50 +0,0 @@
-import { E as Strike$1 } from "./tiptap-D7pl4I5U.mjs";
-//#region src/extensions/strike.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`.
-*/
-function renderDocx(attrs) {
-	return attrs.doubleStrike ? { doubleStrike: true } : { strike: true };
-}
-/**
-* 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.
-*/
-function parseDocx(runOpts) {
-	return { doubleStrike: runOpts.doubleStrike ?? null };
-}
-const attrNative = () => ({
-	default: null,
-	parseHTML: () => null,
-	rendered: false
-});
-const Strike = Strike$1.extend({
-	addAttributes() {
-		return {
-			...this.parent?.(),
-			doubleStrike: attrNative()
-		};
-	},
-	renderDocx,
-	parseDocx
-});
-//#endregion
-export { parseDocx as n, renderDocx as r, Strike as t };

package/dist/styles-QSX3RhxK.mjs

@@ -1,285 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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 };