docx-kit 0.1.0 → 0.3.0

package/dist/compileDocument-BvuU28Yj.js

@@ -1,750 +0,0 @@
-import { t as DocxKitError } from "./errors-c9CC63Ti.js";
-import { n as dataUrlToUint8Array, t as createImageRun } from "./image-6yS25Ggr.js";
-import { AlignmentType, Document, HeadingLevel, PageBreak, Paragraph, ShadingType, Table, TableCell, TableRow, TextRun, VerticalAlign, WidthType } from "docx";
-//#region src/style/normalizeStyle.ts
-/**
-* Style normalization — merge multiple style sources into one resolved rule.
-*
-* Implements the CSS-like cascade:
-* `defaults → className(s) → inline style`
-*
-* @module style/normalizeStyle
-*/
-/**
-* Merge styles in priority order (lowest → highest):
-* `base` → `className`(s) → `inline style`.
-*
-* - `base` — Typically a default style for the element type
-* - `className` — Single string, space-separated string, or array of class names
-* - `inline` — Inline style override on the node itself
-* - `styles` — The stylesheet map to resolve class names against
-*
-* @returns A new merged `DocxStyleRule` (does not mutate inputs).
-*
-* @example
-* ```ts
-* const resolved = resolveStyle({
-*   base:      { fontSize: 12 },
-*   className: ['body', 'blue'],
-*   inline:    { fontWeight: 'bold' },
-*   styles:    { body: { lineHeight: 1.5 }, blue: { color: '#00f' } },
-* })
-* // => { fontSize: 12, lineHeight: 1.5, color: '#00f', fontWeight: 'bold' }
-* ```
-*/
-function resolveStyle(options) {
-	const classStyles = (Array.isArray(options.className) ? options.className : options.className ? options.className.split(/\s+/).filter(Boolean) : []).map((name) => {
-		const rule = options.styles?.[name];
-		if (options.styles != null && rule == null) throw new DocxKitError("STYLE_UNKNOWN_CLASS", `Style class not found: "${name}"`);
-		return rule;
-	}).filter((s) => s != null);
-	return Object.assign({}, options.base, ...classStyles, options.inline);
-}
-//#endregion
-//#region src/compiler/units.ts
-/**
-* Word OpenXML unit conversion utilities.
-*
-* All bare numbers are interpreted according to the property they represent:
-* - `fontSize` (toPtHalf) → **pt**
-* - spacing / indent / margin (toTwip) → **pt**
-* - image size (toPx) → **px**
-*
-* @module compiler/units
-*/
-/**
-* Points per inch — standard typographic convention.
-*
-* All other conversions derive from this and the DPI assumption.
-*/
-const POINTS_PER_INCH = 72;
-/**
-* Pixels per inch at 96 DPI (standard screen resolution).
-*/
-const PIXELS_PER_INCH = 96;
-/**
-* Pixels per point at 96 DPI.
-*
-* 96 px/in ÷ 72 pt/in = 4/3 ≈ 1.333 px/pt.
-*/
-const PX_PER_POINT = PIXELS_PER_INCH / POINTS_PER_INCH;
-/**
-* Points per pixel at 96 DPI.
-*
-* 72 pt/in ÷ 96 px/in = 0.75 pt/px.
-*/
-const POINTS_PER_PX = POINTS_PER_INCH / PIXELS_PER_INCH;
-/**
-* Points per millimeter.
-*
-* 72 pt/in ÷ 25.4 mm/in ≈ 2.835 pt/mm.
-*/
-const POINTS_PER_MM = POINTS_PER_INCH / 25.4;
-/**
-* Points per centimeter.
-*
-* POINTS_PER_MM × 10.
-*/
-const POINTS_PER_CM = POINTS_PER_MM * 10;
-/**
-* Twips per point — the fundamental Word OpenXML spacing unit.
-*
-* 1 twip = 1/20 of a point. All margins, indents, and spacing
-* values in Word are expressed in twips.
-*/
-const TWIPS_PER_POINT = 20;
-/**
-* Twips per pixel at 96 DPI.
-*
-* POINTS_PER_PX × TWIPS_PER_POINT = 0.75 × 20 = 15.
-*/
-const TWIPS_PER_PX = POINTS_PER_PX * TWIPS_PER_POINT;
-/**
-* Half-points per point (used for font sizes in Word OpenXML).
-*
-* Word stores font sizes in half-points: 12pt → 24 half-points.
-*/
-const HALF_POINTS_PER_POINT = 2;
-/**
-* Half-points per pixel at 96 DPI.
-*
-* POINTS_PER_PX × HALF_POINTS_PER_POINT = 0.75 × 2 = 1.5.
-*/
-const HALF_POINTS_PER_PX = POINTS_PER_PX * HALF_POINTS_PER_POINT;
-/**
-* Parse a CSS margin/padding shorthand string into top/right/bottom/left
-* values expressed in **twips** (1/20 pt).
-*
-* Supports 1-value, 2-value, and 4-value shorthand.
-*
-* @param value - — Single number, unit string, or CSS shorthand
-* @returns `{ top, right, bottom, left }` values in twips, or `undefined`
-*
-* @example
-* ```ts
-* parseShorthandTwip('10pt 20pt')
-* // => { top: 200, right: 400, bottom: 200, left: 400 }
-*
-* parseShorthandTwip('5pt 10pt 15pt 20pt')
-* // => { top: 100, right: 200, bottom: 300, left: 400 }
-* ```
-*/
-function parseShorthandTwip(value) {
-	if (value == null) return;
-	const parts = String(value).trim().split(/\s+/);
-	if (parts.length === 1) {
-		const v = toTwip(parts[0]) ?? 0;
-		return {
-			bottom: v,
-			left: v,
-			right: v,
-			top: v
-		};
-	}
-	if (parts.length === 2) {
-		const [tb, lr] = parts.map((p) => toTwip(p) ?? 0);
-		return {
-			bottom: tb,
-			left: lr,
-			right: lr,
-			top: tb
-		};
-	}
-	if (parts.length === 4) {
-		const [top, right, bottom, left] = parts.map((p) => toTwip(p) ?? 0);
-		return {
-			bottom,
-			left,
-			right,
-			top
-		};
-	}
-}
-/**
-* Convert a font-size value to Word **half-points** (used by the `docx`
-* library's `size` field on text runs).
-*
-* Bare number is treated as **pt** (e.g. `12` → 24 half-points).
-*
-* @param value - — Number (pt) or unit string (`"12pt"`, `"16px"`, `"4mm"`, etc.)
-* @returns Half-point integer, or `undefined` if input is null/undefined
-*
-* @example
-* ```ts
-* toPtHalf(12)        // 24   (12pt × 2)
-* toPtHalf('14pt')    // 28
-* toPtHalf('16px')    // 24   (16px ≈ 12pt)
-* ```
-*/
-function toPtHalf(value) {
-	if (value == null) return;
-	if (typeof value === "number") return Math.round(value * HALF_POINTS_PER_POINT);
-	const n = Number.parseFloat(value);
-	if (value.endsWith("pt")) return Math.round(n * HALF_POINTS_PER_POINT);
-	if (value.endsWith("px")) return Math.round(n * HALF_POINTS_PER_PX);
-	if (value.endsWith("mm")) return Math.round(n * POINTS_PER_MM * HALF_POINTS_PER_POINT);
-	if (value.endsWith("cm")) return Math.round(n * POINTS_PER_CM * HALF_POINTS_PER_POINT);
-	if (value.endsWith("in")) return Math.round(n * POINTS_PER_INCH * HALF_POINTS_PER_POINT);
-	return Math.round(n * HALF_POINTS_PER_POINT);
-}
-/**
-* Convert a length value to **pixels** (used for image dimensions).
-*
-* Bare number is treated as **px**.
-*
-* @param value - — Number (px) or unit string (`"100px"`, `"72pt"`, `"5cm"`, etc.)
-* @returns Pixel integer, or `undefined` if input is null/undefined
-*
-* @example
-* ```ts
-* toPx(200)          // 200
-* toPx('150px')      // 150
-* toPx('72pt')       // 96   (72pt × 1.333)
-* ```
-*/
-function toPx(value) {
-	if (value == null) return;
-	if (typeof value === "number") return value;
-	const n = Number.parseFloat(value);
-	if (value.endsWith("px")) return n;
-	if (value.endsWith("pt")) return Math.round(n * PX_PER_POINT);
-	if (value.endsWith("mm")) return Math.round(n * POINTS_PER_MM * PX_PER_POINT);
-	if (value.endsWith("cm")) return Math.round(n * POINTS_PER_CM * PX_PER_POINT);
-	if (value.endsWith("in")) return Math.round(n * PIXELS_PER_INCH);
-	return n;
-}
-/**
-* Convert a length value to **twips** (1/20 of a point).
-*
-* Used for spacing, indent, and margin values in Word OpenXML.
-* Bare number is treated as **pt**.
-*
-* @param value - — Number (pt) or unit string (`"10pt"`, `"12px"`, `"5mm"`, etc.)
-* @returns Twip integer, or `undefined` if input is null/undefined
-*
-* @example
-* ```ts
-* toTwip(12)         // 240  (12pt × 20)
-* toTwip('1in')      // 1440 (1 inch × 1440)
-* toTwip('10mm')     // 567  (10mm × 56.7)
-* ```
-*/
-function toTwip(value) {
-	if (value == null) return;
-	if (typeof value === "number") return Math.round(value * TWIPS_PER_POINT);
-	const n = Number.parseFloat(value);
-	if (value.endsWith("pt")) return Math.round(n * TWIPS_PER_POINT);
-	if (value.endsWith("px")) return Math.round(n * TWIPS_PER_PX);
-	if (value.endsWith("mm")) return Math.round(n * POINTS_PER_MM * TWIPS_PER_POINT);
-	if (value.endsWith("cm")) return Math.round(n * POINTS_PER_CM * TWIPS_PER_POINT);
-	if (value.endsWith("in")) return Math.round(n * POINTS_PER_INCH * TWIPS_PER_POINT);
-	return Math.round(n * TWIPS_PER_POINT);
-}
-//#endregion
-//#region src/compiler/compileStyle.ts
-/**
-* Style compiler — maps `DocxStyleRule` (CSS-like) → `docx` constructor options.
-*
-* Each exported function converts one aspect of a style rule into the shape
-* expected by the underlying `docx` library.
-*
-* @module compiler/compileStyle
-*/
-/**
-* Compile a `DocxStyleRule` into `docx` table cell options
-* (vertical alignment, margins, shading).
-*
-* @param style - — The resolved style rule
-* @returns Options object suitable for `new TableCell(...)`
-*
-* @example
-* ```ts
-* compileCellStyle({ verticalAlign: 'middle', backgroundColor: '#f0f0f0' })
-* // => { verticalAlign: VerticalAlign.CENTER, shading: { fill: 'f0f0f0', ... } }
-* ```
-*/
-function compileCellStyle(style) {
-	const shorthand = style.margin == null ? void 0 : parseShorthandTwip(style.margin);
-	return {
-		verticalAlign: compileVerticalAlign(style.verticalAlign),
-		margins: {
-			bottom: toTwip(style.marginBottom) ?? shorthand?.bottom,
-			left: toTwip(style.marginLeft) ?? shorthand?.left,
-			right: toTwip(style.marginRight) ?? shorthand?.right,
-			top: toTwip(style.marginTop) ?? shorthand?.top
-		},
-		shading: style.backgroundColor == null ? void 0 : {
-			fill: normalizeColor(style.backgroundColor),
-			type: ShadingType.CLEAR
-		}
-	};
-}
-/**
-* Compile a column width value.
-*
-* If the value is a percentage string (e.g. `"30%"`), returns
-* a percentage width config. Otherwise returns `undefined`.
-*
-* @param width - — Column width value
-* @returns Width config or `undefined`
-*
-* @example
-* ```ts
-* compileColumnWidth('25%')
-* // => { size: 25, type: WidthType.PERCENTAGE }
-* ```
-*/
-function compileColumnWidth(width) {
-	if (typeof width === "string" && width.endsWith("%")) return {
-		size: Number.parseFloat(width),
-		type: WidthType.PERCENTAGE
-	};
-}
-/**
-* Compile a `DocxStyleRule` into `docx` paragraph-level options
-* (alignment, indent, spacing).
-*
-* @param style - — The resolved style rule
-* @returns Options object suitable for `new Paragraph(...)`
-*
-* @example
-* ```ts
-* compileParagraphStyle({ textAlign: 'center', marginTop: '10pt' })
-* // => { alignment: AlignmentType.CENTER, spacing: { before: 200, ... } }
-* ```
-*/
-function compileParagraphStyle(style) {
-	const spacing = resolveSpacing(style);
-	const indent = resolveIndent(style);
-	return {
-		alignment: compileAlignment(style.textAlign),
-		indent,
-		spacing
-	};
-}
-/**
-* Compile a `DocxStyleRule` into `docx` run-level options
-* (font, color, size, bold, italic, underline, etc.).
-*
-* Also merges any passthrough properties from `style.docx`.
-*
-* @param style - — The resolved style rule
-* @returns Options object suitable for `new TextRun(...)`
-*
-* @example
-* ```ts
-* compileTextStyle({ fontSize: 14, fontWeight: 'bold', color: '#ff0000' })
-* // => { size: 28, bold: true, color: 'ff0000' }
-* ```
-*/
-function compileTextStyle(style) {
-	const result = {
-		allCaps: style.allCaps,
-		bold: style.fontWeight === "bold" || Number(style.fontWeight) >= 600,
-		color: normalizeColor(style.color),
-		font: style.fontFamily,
-		italics: style.fontStyle === "italic",
-		size: toPtHalf(style.fontSize),
-		strike: style.strike,
-		underline: style.underline ? {} : void 0
-	};
-	if (style.docx) Object.assign(result, style.docx);
-	return result;
-}
-/**
-* Map the CSS-like text-align value to a `docx` `AlignmentType`.
-*/
-function compileAlignment(value) {
-	if (value === "center") return AlignmentType.CENTER;
-	if (value === "right") return AlignmentType.RIGHT;
-	if (value === "justify") return AlignmentType.JUSTIFIED;
-	return AlignmentType.LEFT;
-}
-/** Convert line-height multiplier to twips. 1 → 240 (single-spacing). */
-function compileLineHeight(value) {
-	if (typeof value === "number") return Math.round(value * 240);
-	return toTwip(value);
-}
-/**
-* Map the CSS-like vertical-align to a `docx` `VerticalAlign` enum value.
-*/
-function compileVerticalAlign(value) {
-	if (value === "middle") return VerticalAlign.CENTER;
-	if (value === "bottom") return VerticalAlign.BOTTOM;
-	return VerticalAlign.TOP;
-}
-/** Strip leading `#` from a color string (docx expects raw hex). */
-function normalizeColor(color) {
-	return color?.replace(/^#/, "");
-}
-/**
-* Resolve paragraph indent from a `DocxStyleRule`.
-*
-* Handles margin shorthand, explicit left/right margin, and text-indent.
-*/
-function resolveIndent(style) {
-	const shorthand = style.margin == null ? void 0 : parseShorthandTwip(style.margin);
-	const left = toTwip(style.marginLeft) ?? shorthand?.left;
-	const right = toTwip(style.marginRight) ?? shorthand?.right;
-	const firstLine = toTwip(style.textIndent);
-	if (left == null && right == null && firstLine == null) return;
-	return {
-		firstLine,
-		left,
-		right
-	};
-}
-/**
-* Resolve paragraph spacing from a `DocxStyleRule`.
-*
-* Handles margin shorthand for top/bottom spacing and line height.
-*/
-function resolveSpacing(style) {
-	const shorthand = style.margin == null ? void 0 : parseShorthandTwip(style.margin);
-	const before = toTwip(style.marginTop) ?? shorthand?.top;
-	const after = toTwip(style.marginBottom) ?? shorthand?.bottom;
-	const line = compileLineHeight(style.lineHeight);
-	if (before == null && after == null && line == null) return;
-	return {
-		after,
-		before,
-		line
-	};
-}
-//#endregion
-//#region src/compiler/compileNode.ts
-/**
-* Node compiler — dispatches DSL nodes to `docx` objects.
-*
-* Each node type (heading, paragraph, image, table, pageBreak, plugin)
-* is compiled into the corresponding `docx` constructor.
-*
-* @module compiler/compileNode
-*/
-/** Map heading level numbers to `docx` `HeadingLevel` enum values. */
-const HEADING_MAP = {
-	1: HeadingLevel.HEADING_1,
-	2: HeadingLevel.HEADING_2,
-	3: HeadingLevel.HEADING_3,
-	4: HeadingLevel.HEADING_4,
-	5: HeadingLevel.HEADING_5,
-	6: HeadingLevel.HEADING_6
-};
-/**
-* Compile a single DSL node into its `docx` representation.
-*
-* Dispatches to the appropriate sub-compiler based on `node.type`.
-*
-* @param ctx - — Compilation context with config, node, and plugins
-* @returns A `docx` object (Paragraph, Table, etc.) or array of objects
-*
-* @example
-* ```ts
-* const para = await compileNode({
-*   config:  { styles: { p: { fontSize: 12 } } },
-*   node:    { type: 'paragraph', text: 'Hello', className: 'p' },
-*   plugins: new Map(),
-* })
-* ```
-*/
-async function compileNode(ctx) {
-	switch (ctx.node.type) {
-		case "heading": return compileHeading(ctx.node, ctx.config);
-		case "image": return compileImage(ctx.node, ctx.config);
-		case "pageBreak": return new Paragraph({ children: [new PageBreak()] });
-		case "paragraph": return compileParagraph(ctx.node, ctx.config);
-		case "table": return compileTable(ctx.node, ctx.config);
-		case "plugin": {
-			const plugin = ctx.plugins.get(ctx.node.name);
-			if (!plugin) throw new DocxKitError("PLUGIN_NOT_REGISTERED", `Plugin not registered: ${ctx.node.name}`);
-			try {
-				return await plugin.render(ctx.node.options, createPluginContext(ctx));
-			} catch (err) {
-				throw new DocxKitError("PLUGIN_RENDER_FAILED", `Plugin render failed: ${plugin.name}`, err);
-			}
-		}
-		default: throw new DocxKitError("UNKNOWN_NODE_TYPE", `Unknown node type: ${ctx.node.type}`);
-	}
-}
-/**
-* Build floating layout options for `ImageRun`.
-*/
-function compileFloating(floating) {
-	if (!floating) return;
-	if (floating === true) return {};
-	return {
-		horizontalPosition: floating.x === void 0 ? void 0 : { offset: floating.x },
-		verticalPosition: floating.y === void 0 ? void 0 : { offset: floating.y }
-	};
-}
-/**
-* Compile a heading node into a `docx` Paragraph with heading level.
-*
-* Default class name is `h{level}` (e.g. `h1`, `h2`).
-*/
-function compileHeading(node, config) {
-	const style = resolveStyle({
-		className: node.className ?? `h${node.level}`,
-		inline: node.style,
-		styles: config.styles
-	});
-	return new Paragraph({
-		...compileParagraphStyle(style),
-		heading: HEADING_MAP[node.level],
-		children: [new TextRun({
-			text: node.text,
-			...compileTextStyle(style)
-		})]
-	});
-}
-/**
-* Compile an image node into a `docx` Paragraph containing an `ImageRun`.
-*
-* Handles image data normalization (Blob → Uint8Array), auto format detection,
-* floating layout, and size transformations.
-*/
-async function compileImage(node, _config) {
-	if (node.data == null || typeof node.data === "string" && node.data.length === 0) throw new DocxKitError("IMAGE_INVALID_DATA", "Image data is empty or null");
-	const data = await normalizeImageData(node.data);
-	const imageType = node.imageType ?? "png";
-	return new Paragraph({ children: [createImageRun({
-		data,
-		floating: compileFloating(node.floating),
-		height: toPx(node.height),
-		type: imageType,
-		width: toPx(node.width)
-	})] });
-}
-/**
-* Compile a paragraph node into a `docx` Paragraph.
-*
-* Supports plain text (`node.text`) or inline children (`node.children`).
-*/
-function compileParagraph(node, config) {
-	const style = resolveStyle({
-		base: config.defaults?.paragraph,
-		className: node.className ?? "p",
-		inline: node.style,
-		styles: config.styles
-	});
-	const children = node.children && node.children.length > 0 ? node.children.map((child) => child.type === "text" ? new TextRun({
-		text: child.text,
-		...compileTextStyle(resolveStyle({
-			base: style,
-			className: child.className,
-			inline: child.style,
-			styles: config.styles
-		}))
-	}) : (() => {
-		throw new DocxKitError("UNKNOWN_NODE_TYPE", `Inline image is not supported yet. Use top-level \`.image()\` instead.`);
-	})()) : [new TextRun({
-		text: node.text ?? "",
-		...compileTextStyle(style)
-	})];
-	return new Paragraph({
-		...compileParagraphStyle(style),
-		children
-	});
-}
-/**
-* Compile a table node into a `docx` Table.
-*
-* Generates header row (unless `header: false`) and data rows.
-* Supports custom cell renderers via `column.render`.
-*/
-function compileTable(node, _config) {
-	if (node.columns.length === 0) throw new DocxKitError("TABLE_INVALID_COLUMNS", "Table must have at least one column");
-	const rows = [];
-	if (node.header !== false) rows.push(new TableRow({
-		tableHeader: true,
-		children: node.columns.map((col) => new TableCell({
-			...compileCellStyle(node.headerCellStyle ?? {}),
-			children: [new Paragraph(String(col.title))],
-			width: compileColumnWidth(col.width)
-		}))
-	}));
-	rows.push(...node.data.map((row, rowIndex) => new TableRow({ children: node.columns.map((col) => {
-		const raw = row[col.key];
-		const rendered = col.render ? col.render(raw, row, rowIndex) : String(raw ?? "");
-		return new TableCell({
-			...compileCellStyle(node.cellStyle ?? {}),
-			children: [new Paragraph(String(rendered))],
-			width: compileColumnWidth(col.width)
-		});
-	}) })));
-	return new Table({
-		rows,
-		width: {
-			size: 100,
-			type: WidthType.PERCENTAGE
-		}
-	});
-}
-/**
-* Build a `PluginRenderContext` for plugin rendering.
-*
-* Provides access to config, image utilities, and the ability to
-* recursively compile child nodes.
-*/
-function createPluginContext(ctx) {
-	return {
-		config: ctx.config,
-		utils: { image: {
-			fromDataUrl: (dataUrl) => dataUrlToUint8Array(dataUrl),
-			fromBlob: async (blob) => new Uint8Array(await blob.arrayBuffer())
-		} },
-		compileNode: (node) => compileNode({
-			config: ctx.config,
-			node,
-			plugins: ctx.plugins
-		})
-	};
-}
-/**
-* Normalize image data to a form `ImageRun` accepts.
-*
-* Converts `Blob` → `Uint8Array` in browser environments.
-*/
-async function normalizeImageData(data) {
-	if (typeof Blob !== "undefined" && data instanceof Blob) return new Uint8Array(await data.arrayBuffer());
-	return data;
-}
-//#endregion
-//#region src/compiler/compileDocument.ts
-/**
-* Document compiler — assembles a `docx` `Document` from an array of DSL nodes.
-*
-* This is the top-level compilation entry point. It iterates over all block
-* nodes, compiles each one via {@link compileNode}, and wraps them in a
-* single-section `Document` with page properties and metadata.
-*
-* @module compiler/compileDocument
-*/
-/**
-* Compile an array of block nodes into a `docx` {@link Document} instance.
-*
-* This is the primary compilation pipeline — nodes flow through
-* `compileNode` → individual sub-compilers → `docx` objects → `Document`.
-*
-* @param options - — Compilation options with config, nodes, and plugins
-* @returns A `docx` `Document` ready for packaging
-*
-* @example
-* ```ts
-* const doc = await compileDocument({
-*   config: { page: { size: 'A4' } },
-*   nodes: [
-*     { type: 'heading', level: 1, text: 'Title' },
-*     { type: 'paragraph', text: 'Hello world' },
-*   ],
-*   plugins: new Map(),
-* })
-* ```
-*/
-async function compileDocument(options) {
-	const children = [];
-	for (const node of options.nodes) {
-		const compiled = await compileNode({
-			config: options.config,
-			node,
-			plugins: options.plugins
-		});
-		if (Array.isArray(compiled)) children.push(...compiled);
-		else children.push(compiled);
-	}
-	return new Document({
-		creator: options.config.metadata?.creator,
-		description: options.config.metadata?.description,
-		keywords: options.config.metadata?.keywords?.join(", "),
-		lastModifiedBy: options.config.metadata?.lastModifiedBy,
-		subject: options.config.metadata?.subject,
-		title: options.config.metadata?.title,
-		sections: [{
-			...compileSectionProperties(options.config),
-			children
-		}]
-	});
-}
-/**
-* Compile a single page margin value (shorthand or explicit) into twips.
-*/
-function compilePageMargin(margin) {
-	if (!margin) return;
-	const parsed = parseShorthandTwip(margin);
-	if (!parsed) return;
-	return {
-		bottom: parsed.bottom,
-		left: parsed.left,
-		right: parsed.right,
-		top: parsed.top
-	};
-}
-/**
-* Build the section properties (page size, margin) for the `Document`.
-*/
-function compileSectionProperties(config) {
-	return { properties: { page: {
-		margin: compilePageMargin(config.page?.margin),
-		size: compilePageSize(config.page?.size, config.page?.orientation)
-	} } };
-}
-/**
-* Page size presets in twips (width × height).
-*
-* Values sourced from the OOXML specification.
-*/
-const PAGE_SIZE_PRESETS = {
-	/** A3: 297 × 420 mm */
-	A3: {
-		height: 23811,
-		width: 16838
-	},
-	/** A4: 210 × 297 mm */
-	A4: {
-		height: 16838,
-		width: 11906
-	},
-	/** US Legal: 8.5 × 14 in */
-	Legal: {
-		height: 20160,
-		width: 12240
-	},
-	/** US Letter: 8.5 × 11 in */
-	Letter: {
-		height: 15840,
-		width: 12240
-	}
-};
-/**
-* Compile page size into Word twips.
-*
-* Resolves presets (`"A4"`, `"Letter"`, etc.) or custom dimensions.
-* Swaps width/height when orientation is `"landscape"`.
-*/
-function compilePageSize(size, orientation) {
-	if (!size) return;
-	let width;
-	let height;
-	if (typeof size === "string") {
-		const preset = PAGE_SIZE_PRESETS[size];
-		if (preset) {
-			width = preset.width;
-			height = preset.height;
-		}
-	} else if (typeof size === "object" && size !== null) {
-		const s = size;
-		width = toTwip(s.width);
-		height = toTwip(s.height);
-	}
-	if (width == null || height == null) return;
-	if (orientation === "landscape") return {
-		height: width,
-		width: height
-	};
-	return {
-		height,
-		width
-	};
-}
-//#endregion
-export { compileDocument };