docx-kit 0.1.0 → 0.2.0

package/dist/{compileDocument-BvuU28Yj.js → compileDocument-Vy7rz9_8.js}

@@ -1,6 +1,6 @@
+import { n as dataUrlToUint8Array, t as createImageRun } from "./image-CdfLh9GO.js";
 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";
+import { AlignmentType, BorderStyle, Document, ExternalHyperlink, Footer, Header, HeadingLevel, HighlightColor, LevelFormat, 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.
@@ -251,9 +251,40 @@ function toTwip(value) {
 * @module compiler/compileStyle
 */
 /**
+* Compile all border properties from a `DocxStyleRule`.
+*
+* Returns `undefined` if no borders are specified.
+*
+* @param style - — The resolved style rule
+* @returns Border options for `docx` or `undefined`
+*
+* @example
+* ```ts
+* compileBorder({ border: { style: 'single', color: '#333', width: '1pt' } })
+* // => { top: {...}, right: {...}, bottom: {...}, left: {...} }
+* ```
+*/
+function compileBorder(style) {
+	const b = style.border;
+	const bt = style.borderTop ?? b;
+	const br = style.borderRight ?? b;
+	const bb = style.borderBottom ?? b;
+	const bl = style.borderLeft ?? b;
+	if (!bt && !br && !bb && !bl) return;
+	return {
+		bottom: bb ? compileSingleBorder(bb) : void 0,
+		left: bl ? compileSingleBorder(bl) : void 0,
+		right: br ? compileSingleBorder(br) : void 0,
+		top: bt ? compileSingleBorder(bt) : void 0
+	};
+}
+/**
 * Compile a `DocxStyleRule` into `docx` table cell options
 * (vertical alignment, margins, shading).
 *
+* Applies sensible default cell padding (5 pt left/right, 2 pt top/bottom)
+* when no margins are explicitly set.
+*
 * @param style - — The resolved style rule
 * @returns Options object suitable for `new TableCell(...)`
 *
@@ -265,13 +296,23 @@ function toTwip(value) {
 */
 function compileCellStyle(style) {
 	const shorthand = style.margin == null ? void 0 : parseShorthandTwip(style.margin);
+	const bottom = toTwip(style.marginBottom) ?? shorthand?.bottom;
+	const left = toTwip(style.marginLeft) ?? shorthand?.left;
+	const right = toTwip(style.marginRight) ?? shorthand?.right;
+	const top = toTwip(style.marginTop) ?? shorthand?.top;
+	const hasAnyMargin = bottom != null || left != null || right != null || top != null;
 	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
+		margins: hasAnyMargin ? {
+			bottom: bottom ?? 0,
+			left: left ?? 0,
+			right: right ?? 0,
+			top: top ?? 0
+		} : {
+			bottom: 0,
+			left: 100,
+			right: 100,
+			top: 0
 		},
 		shading: style.backgroundColor == null ? void 0 : {
 			fill: normalizeColor(style.backgroundColor),
@@ -300,6 +341,12 @@ function compileColumnWidth(width) {
 		type: WidthType.PERCENTAGE
 	};
 }
+/** Compile paragraph-level borders (separate from cell borders). */
+function compileParagraphBorder(style) {
+	const borders = compileBorder(style);
+	if (!borders) return {};
+	return { border: borders };
+}
 /**
 * Compile a `DocxStyleRule` into `docx` paragraph-level options
 * (alignment, indent, spacing).
@@ -318,7 +365,11 @@ function compileParagraphStyle(style) {
 	const indent = resolveIndent(style);
 	return {
 		alignment: compileAlignment(style.textAlign),
+		...compileParagraphBorder(style),
 		indent,
+		keepLines: style.keepLines,
+		keepNext: style.keepNext,
+		pageBreakBefore: style.pageBreakBefore,
 		spacing
 	};
 }
@@ -341,11 +392,16 @@ function compileTextStyle(style) {
 	const result = {
 		allCaps: style.allCaps,
 		bold: style.fontWeight === "bold" || Number(style.fontWeight) >= 600,
+		characterSpacing: style.characterSpacing,
 		color: normalizeColor(style.color),
 		font: style.fontFamily,
+		highlight: compileHighlight(style.highlight),
 		italics: style.fontStyle === "italic",
 		size: toPtHalf(style.fontSize),
+		smallCaps: style.smallCaps,
 		strike: style.strike,
+		subScript: style.subScript,
+		superScript: style.superScript,
 		underline: style.underline ? {} : void 0
 	};
 	if (style.docx) Object.assign(result, style.docx);
@@ -360,12 +416,39 @@ function compileAlignment(value) {
 	if (value === "justify") return AlignmentType.JUSTIFIED;
 	return AlignmentType.LEFT;
 }
+/**
+* Map a CSS-like border-style string to a `docx` `BorderStyle` enum value.
+*/
+function compileBorderStyle(style) {
+	if (style === "dashed") return BorderStyle.DASHED;
+	if (style === "dotted") return BorderStyle.DOTTED;
+	if (style === "double") return BorderStyle.DOUBLE;
+	if (style === "none") return BorderStyle.NONE;
+	return BorderStyle.SINGLE;
+}
+/**
+* Map a highlight color name to `docx` `HighlightColor`.
+*/
+function compileHighlight(color) {
+	if (!color || color === "none") return;
+	return HighlightColor[color.toUpperCase()];
+}
 /** 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);
 }
 /**
+* Compile a single border side into `docx` border options.
+*/
+function compileSingleBorder(rule) {
+	return {
+		color: normalizeColor(rule.color),
+		size: rule.width == null ? 1 : toTwip(rule.width),
+		style: compileBorderStyle(rule.style)
+	};
+}
+/**
 * Map the CSS-like vertical-align to a `docx` `VerticalAlign` enum value.
 */
 function compileVerticalAlign(value) {
@@ -449,9 +532,13 @@ const HEADING_MAP = {
 */
 async function compileNode(ctx) {
 	switch (ctx.node.type) {
+		case "bulletList": return compileBulletList(ctx.node, ctx.config);
 		case "heading": return compileHeading(ctx.node, ctx.config);
+		case "hyperlink": return compileHyperlink(ctx.node, ctx.config);
 		case "image": return compileImage(ctx.node, ctx.config);
+		case "numberedList": return compileNumberedList(ctx.node, ctx.config);
 		case "pageBreak": return new Paragraph({ children: [new PageBreak()] });
+		case "sectionBreak": throw new DocxKitError("UNKNOWN_NODE_TYPE", "Section break nodes must be handled at the document compilation level");
 		case "paragraph": return compileParagraph(ctx.node, ctx.config);
 		case "table": return compileTable(ctx.node, ctx.config);
 		case "plugin": {
@@ -498,22 +585,58 @@ function compileHeading(node, config) {
 	});
 }
 /**
+* Compile a hyperlink node into an `ExternalHyperlink` containing `TextRun`s.
+*/
+function compileHyperlink(node, config) {
+	const style = resolveStyle({
+		className: node.className,
+		inline: node.style,
+		styles: config.styles
+	});
+	return new Paragraph({ children: [new ExternalHyperlink({
+		children: node.children.map((child) => {
+			if (typeof child === "string") return new TextRun({
+				text: child,
+				...compileTextStyle(style)
+			});
+			return new TextRun({
+				text: child.text,
+				...compileTextStyle(resolveStyle({
+					base: style,
+					className: child.className,
+					inline: child.style,
+					styles: config.styles
+				}))
+			});
+		}),
+		link: node.url
+	})] });
+}
+/**
 * 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) {
+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)
-	})] });
+	return new Paragraph({
+		...compileParagraphStyle(resolveStyle({
+			base: config.defaults?.image,
+			className: node.className,
+			inline: node.style,
+			styles: config.styles
+		})),
+		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.
@@ -546,6 +669,104 @@ function compileParagraph(node, config) {
 		children
 	});
 }
+const numberingConfigMap = /* @__PURE__ */ new Map();
+let numberingCounter = 0;
+/** Reset numbering state between compilations. */
+function resetNumberingState() {
+	numberingConfigMap.clear();
+	numberingCounter = 0;
+}
+/**
+* Generate a numbering config entry for a bullet list
+* and return Paragraphs with numbering references.
+*/
+function compileBulletList(node, config) {
+	const ref = `bullet-${++numberingCounter}`;
+	const bullet = node.bullet ?? "•";
+	numberingConfigMap.set(ref, {
+		reference: ref,
+		levels: [{
+			alignment: AlignmentType.LEFT,
+			format: LevelFormat.BULLET,
+			level: node.level ?? 0,
+			text: bullet
+		}]
+	});
+	const style = resolveStyle({
+		className: node.className,
+		inline: node.style,
+		styles: config.styles
+	});
+	return node.items.map((item) => {
+		const text = typeof item === "string" ? item : item.text;
+		const itemStyle = typeof item === "object" ? resolveStyle({
+			base: style,
+			className: item.className,
+			inline: item.style,
+			styles: config.styles
+		}) : style;
+		return new Paragraph({
+			...compileParagraphStyle(itemStyle),
+			numbering: {
+				level: node.level ?? 0,
+				reference: ref
+			},
+			children: [new TextRun({
+				text,
+				...compileTextStyle(itemStyle)
+			})]
+		});
+	});
+}
+/**
+* Generate a numbering config entry for an ordered list
+* and return Paragraphs with numbering references.
+*/
+function compileNumberedList(node, config) {
+	const ref = `numbered-${++numberingCounter}`;
+	const formatMap = {
+		decimal: LevelFormat.DECIMAL,
+		lowerLetter: LevelFormat.LOWER_LETTER,
+		lowerRoman: LevelFormat.LOWER_ROMAN,
+		upperLetter: LevelFormat.UPPER_LETTER,
+		upperRoman: LevelFormat.UPPER_ROMAN
+	};
+	numberingConfigMap.set(ref, {
+		reference: ref,
+		levels: [{
+			alignment: AlignmentType.LEFT,
+			level: node.level ?? 0,
+			start: node.start ?? 1,
+			text: "%1.",
+			format: formatMap[node.numberingFormat ?? "decimal"] ?? LevelFormat.DECIMAL
+		}]
+	});
+	const style = resolveStyle({
+		className: node.className,
+		inline: node.style,
+		styles: config.styles
+	});
+	return node.items.map((item) => {
+		const text = typeof item === "string" ? item : item.text;
+		const itemStyle = typeof item === "object" ? resolveStyle({
+			base: style,
+			className: item.className,
+			inline: item.style,
+			styles: config.styles
+		}) : style;
+		return new Paragraph({
+			...compileParagraphStyle(itemStyle),
+			numbering: {
+				level: node.level ?? 0,
+				reference: ref
+			},
+			children: [new TextRun({
+				text,
+				...compileTextStyle(itemStyle)
+			})]
+		});
+	});
+}
 /**
 * Compile a table node into a `docx` Table.
 *
@@ -560,15 +781,24 @@ function compileTable(node, _config) {
 		children: node.columns.map((col) => new TableCell({
 			...compileCellStyle(node.headerCellStyle ?? {}),
 			children: [new Paragraph(String(col.title))],
+			...col.colSpan && col.colSpan > 1 ? { columnSpan: col.colSpan } : {},
 			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 ?? "");
+		const cellColSpan = row[`_${col.key}_colSpan`] ?? col.colSpan;
+		const isEvenRow = rowIndex % 2 === 1;
+		const baseCellStyle = node.cellStyle ? { ...compileCellStyle(node.cellStyle) } : {};
 		return new TableCell({
-			...compileCellStyle(node.cellStyle ?? {}),
+			...baseCellStyle,
+			...node.striped && isEvenRow && baseCellStyle.shading ? { shading: {
+				...baseCellStyle.shading,
+				fill: "F2F2F2"
+			} } : {},
 			children: [new Paragraph(String(rendered))],
+			...cellColSpan && cellColSpan > 1 ? { columnSpan: cellColSpan } : {},
 			width: compileColumnWidth(col.width)
 		});
 	}) })));
@@ -616,7 +846,10 @@ async function normalizeImageData(data) {
 *
 * 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.
+* `Document` with page properties and metadata.
+*
+* Multi-section support: {@link SectionBreakNode} markers split content
+* into separate sections, each with its own page setup, headers, and footers.
 *
 * @module compiler/compileDocument
 */
@@ -626,6 +859,9 @@ async function normalizeImageData(data) {
 * This is the primary compilation pipeline — nodes flow through
 * `compileNode` → individual sub-compilers → `docx` objects → `Document`.
 *
+* If `SectionBreakNode` markers are present, content is split into
+* multiple sections, each with its own page setup, headers, and footers.
+*
 * @param options - — Compilation options with config, nodes, and plugins
 * @returns A `docx` `Document` ready for packaging
 *
@@ -642,16 +878,35 @@ async function normalizeImageData(data) {
 * ```
 */
 async function compileDocument(options) {
-	const children = [];
-	for (const node of options.nodes) {
-		const compiled = await compileNode({
-			config: options.config,
-			node,
-			plugins: options.plugins
+	resetNumberingState();
+	const sectionGroups = [{ nodes: [] }];
+	for (const node of options.nodes) if (node.type === "sectionBreak") sectionGroups.push({
+		config: node.config,
+		nodes: []
+	});
+	else sectionGroups[sectionGroups.length - 1].nodes.push(node);
+	const sections = [];
+	for (const [i, group] of sectionGroups.entries()) {
+		const children = [];
+		for (const node of group.nodes) {
+			const compiled = await compileNode({
+				config: options.config,
+				node,
+				plugins: options.plugins
+			});
+			if (Array.isArray(compiled)) children.push(...compiled);
+			else children.push(compiled);
+		}
+		const sectionConfig = group.config;
+		const pageConfig = i === 0 ? options.config : mergePageConfig(options.config, sectionConfig);
+		sections.push({
+			...compileSectionProperties(pageConfig),
+			children,
+			footers: compileFooters(i === 0 ? void 0 : sectionConfig?.footer, options.config),
+			headers: compileHeaders(i === 0 ? void 0 : sectionConfig?.header, options.config)
 		});
-		if (Array.isArray(compiled)) children.push(...compiled);
-		else children.push(compiled);
 	}
+	const numberingConfig = numberingConfigMap.size > 0 ? Array.from(numberingConfigMap.values()) : void 0;
 	return new Document({
 		creator: options.config.metadata?.creator,
 		description: options.config.metadata?.description,
@@ -659,13 +914,43 @@ async function compileDocument(options) {
 		lastModifiedBy: options.config.metadata?.lastModifiedBy,
 		subject: options.config.metadata?.subject,
 		title: options.config.metadata?.title,
-		sections: [{
-			...compileSectionProperties(options.config),
-			children
-		}]
+		...numberingConfig ? { numbering: { config: numberingConfig } } : {},
+		sections
 	});
 }
 /**
+* Compile section footers into `docx` `Footer` objects.
+*
+* @returns `{ default?, first?, even? }` or `undefined` if no footers defined
+*/
+function compileFooters(config, _docConfig) {
+	if (!config) return;
+	const result = {};
+	if (config.default) result.default = new Footer({ children: compileHeaderFooterChildren(config.default) });
+	if (config.first) result.first = new Footer({ children: compileHeaderFooterChildren(config.first) });
+	if (config.even) result.even = new Footer({ children: compileHeaderFooterChildren(config.even) });
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/**
+* Compile a `HeaderFooterContent` into a list of `docx` `Paragraph`s.
+*/
+function compileHeaderFooterChildren(content) {
+	return content.children.map((text) => new Paragraph(text));
+}
+/**
+* Compile section headers into `docx` `Header` objects.
+*
+* @returns `{ default?, first?, even? }` or `undefined` if no headers defined
+*/
+function compileHeaders(config, _docConfig) {
+	if (!config) return;
+	const result = {};
+	if (config.default) result.default = new Header({ children: compileHeaderFooterChildren(config.default) });
+	if (config.first) result.first = new Header({ children: compileHeaderFooterChildren(config.first) });
+	if (config.even) result.even = new Header({ children: compileHeaderFooterChildren(config.even) });
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/**
 * Compile a single page margin value (shorthand or explicit) into twips.
 */
 function compilePageMargin(margin) {
@@ -689,6 +974,22 @@ function compileSectionProperties(config) {
 	} } };
 }
 /**
+* Merge document-level page config with per-section overrides.
+*
+* Section config wins when both are specified; falls back to document
+* defaults for any property not set in the section.
+*/
+function mergePageConfig(docConfig, sectionConfig) {
+	if (!sectionConfig?.page) return docConfig;
+	return {
+		...docConfig,
+		page: {
+			...docConfig.page,
+			...sectionConfig.page
+		}
+	};
+}
+/**
 * Page size presets in twips (width × height).
 *
 * Values sourced from the OOXML specification.

package/dist/errors-c9CC63Ti.mjs

@@ -0,0 +1,63 @@
+//#region src/errors.ts
+/**
+* Error handling types and classes for docx-kit.
+*
+* @module errors
+*/
+/**
+* Well-known error codes used throughout the library.
+*
+* Consumers can match against these codes for structured error handling.
+*/
+const ERROR_CODES = {
+	/** Document export failed. */
+	EXPORT_FAILED: "EXPORT_FAILED",
+	/** Image data is empty, corrupt, or unsupported. */
+	IMAGE_INVALID_DATA: "IMAGE_INVALID_DATA",
+	/** A plugin node referenced an unregistered plugin. */
+	PLUGIN_NOT_REGISTERED: "PLUGIN_NOT_REGISTERED",
+	/** A plugin's `render()` method threw an error. */
+	PLUGIN_RENDER_FAILED: "PLUGIN_RENDER_FAILED",
+	/** A `className` referenced a stylesheet key that doesn't exist. */
+	STYLE_UNKNOWN_CLASS: "STYLE_UNKNOWN_CLASS",
+	/** Table was created with no columns. */
+	TABLE_INVALID_COLUMNS: "TABLE_INVALID_COLUMNS",
+	/** Encountered a node type that has no registered compiler. */
+	UNKNOWN_NODE_TYPE: "UNKNOWN_NODE_TYPE"
+};
+/**
+* Structured error class for docx-kit.
+*
+* Carries a machine-readable `code`, a human-readable `message`,
+* and optionally the underlying `cause`.
+*
+* @example
+* ```ts
+* try {
+*   await doc.save('output.docx')
+* } catch (err) {
+*   if (err instanceof DocxKitError && err.code === ERROR_CODES.EXPORT_FAILED) {
+*     console.error('Export failed:', err.message)
+*   }
+* }
+* ```
+*/
+var DocxKitError = class extends Error {
+	/** The underlying error that caused this failure (if any). */
+	cause;
+	/** Machine-readable error code. */
+	code;
+	/**
+	* @param code - — Known error code from {@link ERROR_CODES}
+	* @param message - — Human-readable description
+	* @param cause - — Optional underlying error
+	*/
+	constructor(code, message, cause) {
+		super(message);
+		this.name = "DocxKitError";
+		this.code = code;
+		this.cause = cause;
+	}
+};
+//#endregion
+export { ERROR_CODES as n, DocxKitError as t };

package/dist/fs-BuKdtuxB.js

@@ -0,0 +1,30 @@
+import { Packer } from "docx";
+//#region src/node/fs.ts
+/**
+* Node.js filesystem utilities for saving documents to disk.
+*
+* @module node/fs
+*/
+/**
+* Save a compiled document to a file on disk.
+*
+* Uses `Packer.toBuffer()` to produce the .docx binary, then
+* writes via `node:fs/promises`. This function is **Node.js only**.
+*
+* @param doc - — A compiled `docx` `Document` instance
+* @param filename - — Output file path (e.g. `"report.docx"`)
+*
+* @example
+* ```ts
+* import { saveDocument } from 'docx-kit/node'
+*
+* const doc = await compileDocument({ ... })
+* await saveDocument(doc, 'report.docx')
+* ```
+*/
+async function saveDocument(doc, filename) {
+	const { writeFile } = await import("node:fs/promises");
+	await writeFile(filename, await Packer.toBuffer(doc));
+}
+//#endregion
+export { saveDocument };

package/dist/{image-6yS25Ggr.js → image-CdfLh9GO.js}

@@ -46,8 +46,8 @@ async function dataUrlToUint8Array(dataUrl) {
 /**
 * Shared image utilities for internal use by compilers and plugins.
 *
-* Centralizes the `as any` casts required by the `docx` library's
-* strict `ImageRun` constructor types into one audited location.
+* Bridges the `docx` library's `IImageOptions` with `docx-kit`'s
+* own `CreateImageRunOptions`, confining type casts to this single module.
 *
 * @module utils/image
 */
@@ -56,7 +56,7 @@ async function dataUrlToUint8Array(dataUrl) {
 *
 * All paths that construct an `ImageRun` should use this factory
 * instead of calling `new ImageRun(...)` directly, ensuring that
-* all `as any` casts are confined to a single audited function.
+* type casts are confined to a single audited function.
 *
 * @param options - — Image data and layout options
 * @returns A configured `ImageRun` instance

package/dist/image-CdfLh9GO.mjs

@@ -0,0 +1,76 @@
+import { ImageRun } from "docx";
+//#region src/utils/dataUrl.ts
+/**
+* Cross-platform base64 data-URL decoder.
+*
+* Auto-detects the runtime environment and uses the appropriate
+* implementation:
+* - **Node.js**: `Buffer.from(base64, 'base64')`
+* - **Browser**: `atob(base64)` + manual byte population
+*
+* This is the internal shared version used by the compiler and
+* built-in plugins. For platform-specific direct access, import
+* from `'docx-kit/node'` or `'docx-kit/browser'`.
+*
+* @module utils/dataUrl
+*/
+/**
+* Decode a base64 data-URL to raw bytes (works in both browser & Node.js).
+*
+* Strips the `"data:*;base64,"` prefix and decodes using the appropriate
+* runtime API.
+*
+* @param dataUrl - — A base64 data-URI string (e.g. `"data:image/png;base64,iVBO..."`)
+* @returns Raw bytes as `Uint8Array`
+*
+* @example
+* ```ts
+* import { dataUrlToUint8Array } from 'docx-kit'
+*
+* const bytes = await dataUrlToUint8Array('data:image/png;base64,iVBORw...')
+* ```
+*/
+async function dataUrlToUint8Array(dataUrl) {
+	const base64 = dataUrl.split(",")[1];
+	if (typeof atob === "function") {
+		const binary = atob(base64);
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+		return bytes;
+	}
+	const { Buffer } = await import("node:buffer");
+	return new Uint8Array(Buffer.from(base64, "base64"));
+}
+//#endregion
+//#region src/utils/image.ts
+/**
+* Shared image utilities for internal use by compilers and plugins.
+*
+* Bridges the `docx` library's `IImageOptions` with `docx-kit`'s
+* own `CreateImageRunOptions`, confining type casts to this single module.
+*
+* @module utils/image
+*/
+/**
+* Create an `ImageRun` with type-safe defaults.
+*
+* All paths that construct an `ImageRun` should use this factory
+* instead of calling `new ImageRun(...)` directly, ensuring that
+* type casts are confined to a single audited function.
+*
+* @param options - — Image data and layout options
+* @returns A configured `ImageRun` instance
+*/
+function createImageRun(options) {
+	return new ImageRun({
+		data: options.data,
+		floating: options.floating,
+		type: options.type,
+		transformation: {
+			height: options.height ?? 180,
+			width: options.width ?? 300
+		}
+	});
+}
+//#endregion
+export { dataUrlToUint8Array as n, createImageRun as t };