jspdf-md-renderer 3.4.1 → 3.5.1

package/dist/index.mjs

@@ -1,641 +1,1148 @@
-import { marked as e } from "marked";
-import t from "jspdf-autotable";
-//#region src/enums/mdTokenType.ts
-var n = /* @__PURE__ */ function(e) {
-	return e.Heading = "heading", e.Paragraph = "paragraph", e.List = "list", e.ListItem = "list_item", e.Blockquote = "blockquote", e.Code = "code", e.CodeSpan = "codespan", e.Table = "table", e.Html = "html", e.Hr = "hr", e.Image = "image", e.Link = "link", e.Strong = "strong", e.Em = "em", e.TableHeader = "table_header", e.TableCell = "table_cell", e.Raw = "raw", e.Text = "text", e.Br = "br", e;
-}({}), r = "__jmr_", i = /(!\[[^\]]*\]\()([^)]+)(\))\s*\{([^}]+)\}/g, a = /(\w+)\s*=\s*(\w+)/g, o = [
+/*!
+ * jspdf-md-renderer
+ * 
+ * MIT License
+ * 
+ * Copyright (c) 2026 Jeel Gajera
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * 
+ */
+import { marked } from "marked";
+import autoTable from "jspdf-autotable";
+//#region src/parser/imageExtension.ts
+/**
+* Internal hash prefix used to encode image attributes in the URL fragment.
+* This is stripped during token conversion and never reaches the image fetcher.
+*/
+const ATTR_HASH_PREFIX = "__jmr_";
+/**
+* Regex to match an image tag followed by an attribute block.
+* Captures:
+*   Group 1: Everything before the closing `)` (i.e., `![alt](url`)
+*   Group 2: The image URL inside the parentheses
+*   Group 3: The attribute block content (e.g., `width=200 height=150 align=center`)
+*
+* Pattern: ![...](url){key=value ...}
+*/
+const IMAGE_WITH_ATTRS_REGEX = /(!\[[^\]]*\]\()([^)]+)(\))\s*\{([^}]+)\}/g;
+/**
+* Regex to extract individual key=value pairs from the attribute block.
+*/
+const ATTR_PAIR_REGEX = /(\w+)\s*=\s*(\w+)/g;
+/** Valid alignment values */
+const VALID_ALIGNMENTS = [
 	"left",
 	"center",
 	"right"
-], s = (e) => {
-	let t = [];
-	return e.width !== void 0 && t.push(`w=${e.width}`), e.height !== void 0 && t.push(`h=${e.height}`), e.align && t.push(`a=${e.align}`), t.length > 0 ? `#${r}${t.join("&")}` : "";
-}, c = (e) => {
-	let t = {}, n;
-	for (; (n = a.exec(e)) !== null;) {
-		let e = n[1].toLowerCase(), r = n[2];
-		switch (e) {
+];
+/**
+* Encodes image attributes into a URL hash fragment.
+* Example: {width: 200, height: 100, align: 'center'} → '#__jmr_w=200&h=100&a=center'
+*/
+const encodeAttrsToFragment = (attrs) => {
+	const parts = [];
+	if (attrs.width !== void 0) parts.push(`w=${attrs.width}`);
+	if (attrs.height !== void 0) parts.push(`h=${attrs.height}`);
+	if (attrs.align) parts.push(`a=${attrs.align}`);
+	return parts.length > 0 ? `#${ATTR_HASH_PREFIX}${parts.join("&")}` : "";
+};
+/**
+* Parses an attribute string like "width=200 height=150 align=center"
+* into a structured object.
+*/
+const parseRawAttributes = (attrString) => {
+	const attrs = {};
+	let match;
+	while ((match = ATTR_PAIR_REGEX.exec(attrString)) !== null) {
+		const key = match[1].toLowerCase();
+		const value = match[2];
+		switch (key) {
 			case "width":
 			case "w": {
-				let e = parseInt(r, 10);
-				!isNaN(e) && e > 0 && (t.width = e);
+				const num = parseInt(value, 10);
+				if (!isNaN(num) && num > 0) attrs.width = num;
 				break;
 			}
 			case "height":
 			case "h": {
-				let e = parseInt(r, 10);
-				!isNaN(e) && e > 0 && (t.height = e);
+				const num = parseInt(value, 10);
+				if (!isNaN(num) && num > 0) attrs.height = num;
 				break;
 			}
 			case "align": {
-				let e = r.toLowerCase();
-				o.includes(e) && (t.align = e);
+				const alignVal = value.toLowerCase();
+				if (VALID_ALIGNMENTS.includes(alignVal)) attrs.align = alignVal;
 				break;
 			}
 		}
 	}
-	return t;
-}, l = (e) => e.replace(i, (e, t, n, r, i) => `${t}${n}${s(c(i))}${r}`), u = (e) => {
-	let t = e.indexOf(`#${r}`);
-	if (t === -1) return {
-		cleanHref: e,
+	return attrs;
+};
+/**
+* Pre-processes markdown text to embed image attributes into URL fragments.
+*
+* Transforms `![alt](url){width=200 align=center}` into
+* `![alt](url#__jmr_w=200&a=center)` so that each image token
+* carries its own attributes — no shared state needed.
+*
+* Supported attributes:
+* - `width` or `w`: Image width in pixels (number)
+* - `height` or `h`: Image height in pixels (number)
+* - `align`: Image alignment - 'left', 'center', or 'right'
+*
+* @param text - The raw markdown text
+* @returns The cleaned markdown text with attributes encoded in URLs
+*/
+const preprocessImageAttributes = (text) => {
+	return text.replace(IMAGE_WITH_ATTRS_REGEX, (_fullMatch, before, url, closeParen, attrsContent) => {
+		return `${before}${url}${encodeAttrsToFragment(parseRawAttributes(attrsContent))}${closeParen}`;
+	});
+};
+/**
+* Extracts image attributes from a URL that may contain an encoded fragment.
+* Returns the clean URL (without the attribute fragment) and parsed attributes.
+*
+* @param href - The image URL, possibly containing `#__jmr_...` fragment
+* @returns Object with cleanHref and parsed attrs
+*/
+const parseImageAttrsFromHref = (href) => {
+	const fragmentIdx = href.indexOf(`#${ATTR_HASH_PREFIX}`);
+	if (fragmentIdx === -1) return {
+		cleanHref: href,
 		attrs: {}
 	};
-	let n = e.substring(0, t), i = e.substring(t + 1 + 6), a = {}, s = i.split("&");
-	for (let e of s) {
-		let [t, n] = e.split("=");
-		switch (t) {
+	const cleanHref = href.substring(0, fragmentIdx);
+	const fragment = href.substring(fragmentIdx + 1 + 6);
+	const attrs = {};
+	const pairs = fragment.split("&");
+	for (const pair of pairs) {
+		const [key, value] = pair.split("=");
+		switch (key) {
 			case "w": {
-				let e = parseInt(n, 10);
-				!isNaN(e) && e > 0 && (a.width = e);
+				const num = parseInt(value, 10);
+				if (!isNaN(num) && num > 0) attrs.width = num;
 				break;
 			}
 			case "h": {
-				let e = parseInt(n, 10);
-				!isNaN(e) && e > 0 && (a.height = e);
+				const num = parseInt(value, 10);
+				if (!isNaN(num) && num > 0) attrs.height = num;
 				break;
 			}
 			case "a":
-				o.includes(n) && (a.align = n);
+				if (VALID_ALIGNMENTS.includes(value)) attrs.align = value;
 				break;
 		}
 	}
 	return {
-		cleanHref: n,
-		attrs: a
+		cleanHref,
+		attrs
 	};
-}, d = async (t) => {
-	let n = l(t);
-	return f(await e.lexer(n, {
-		async: !0,
-		gfm: !0
+};
+//#endregion
+//#region src/parser/MdTextParser.ts
+/**
+* Parses markdown into tokens and converts to a custom parsed structure.
+*
+* @param text - The markdown content to parse.
+* @returns Parsed markdown elements.
+*/
+const MdTextParser = async (text) => {
+	const processedText = preprocessImageAttributes(text);
+	return convertTokens(await marked.lexer(processedText, {
+		async: true,
+		gfm: true
 	}));
-}, f = (e) => {
-	let t = [];
-	return e.forEach((e) => {
+};
+/**
+* Convert the markdown tokens to ParsedElements.
+*
+* @param tokens - The list of markdown tokens.
+* @returns Parsed elements in a custom structure.
+*/
+const convertTokens = (tokens) => {
+	const parsedElements = [];
+	tokens.forEach((token) => {
 		try {
-			let r = p[e.type];
-			r ? t.push(r(e)) : t.push({
-				type: n.Raw,
-				content: e.raw
+			const handler = tokenHandlers[token.type];
+			if (handler) parsedElements.push(handler(token));
+			else parsedElements.push({
+				type: "raw",
+				content: token.raw
 			});
-		} catch (t) {
-			console.error("Failed to handle token ==>", e, t);
-		}
-	}), t;
-}, p = {
-	[n.Heading]: (e) => ({
-		type: n.Heading,
-		depth: e.depth,
-		content: e.text,
-		items: e.tokens ? f(e.tokens) : []
+		} catch (error) {
+			console.error("Failed to handle token ==>", token, error);
+		}
+	});
+	return parsedElements;
+};
+/**
+* Map each token type to its handler function.
+*/
+const tokenHandlers = {
+	["heading"]: (token) => ({
+		type: "heading",
+		depth: token.depth,
+		content: token.text,
+		items: token.tokens ? convertTokens(token.tokens) : []
 	}),
-	[n.Paragraph]: (e) => ({
-		type: n.Paragraph,
-		content: e.text,
-		items: e.tokens ? f(e.tokens) : []
+	["paragraph"]: (token) => ({
+		type: "paragraph",
+		content: token.text,
+		items: token.tokens ? convertTokens(token.tokens) : []
 	}),
-	[n.List]: (e) => ({
-		type: n.List,
-		ordered: e.ordered,
-		start: e.start,
-		items: e.items ? f(e.items) : []
+	["list"]: (token) => ({
+		type: "list",
+		ordered: token.ordered,
+		start: token.start,
+		items: token.items ? convertTokens(token.items) : []
 	}),
-	[n.ListItem]: (e) => ({
-		type: n.ListItem,
-		content: e.text,
-		items: e.tokens ? f(e.tokens) : []
+	["list_item"]: (token) => ({
+		type: "list_item",
+		content: token.text,
+		items: token.tokens ? convertTokens(token.tokens) : []
 	}),
-	[n.Code]: (e) => ({
-		type: n.Code,
-		lang: e.lang,
-		code: e.text
+	["code"]: (token) => ({
+		type: "code",
+		lang: token.lang,
+		code: token.text
 	}),
-	[n.Table]: (e) => ({
-		type: n.Table,
-		header: e.header.map((e) => ({
-			type: n.TableHeader,
-			content: e.text
+	["table"]: (token) => ({
+		type: "table",
+		header: token.header.map((header) => ({
+			type: "table_header",
+			content: header.text
 		})),
-		rows: e.rows.map((e) => e.map((e) => ({
-			type: n.TableCell,
-			content: e.text
+		rows: token.rows.map((row) => row.map((cell) => ({
+			type: "table_cell",
+			content: cell.text
 		})))
 	}),
-	[n.Image]: (e) => {
-		let { cleanHref: t, attrs: r } = u(e.href);
+	["image"]: (token) => {
+		const { cleanHref, attrs } = parseImageAttrsFromHref(token.href);
 		return {
-			type: n.Image,
-			src: t,
-			alt: e.text,
-			width: r.width,
-			height: r.height,
-			align: r.align
+			type: "image",
+			src: cleanHref,
+			alt: token.text,
+			width: attrs.width,
+			height: attrs.height,
+			align: attrs.align
 		};
 	},
-	[n.Link]: (e) => ({
-		type: n.Link,
-		href: e.href,
-		text: e.text,
-		items: e.tokens ? f(e.tokens) : []
+	["link"]: (token) => ({
+		type: "link",
+		href: token.href,
+		text: token.text,
+		items: token.tokens ? convertTokens(token.tokens) : []
 	}),
-	[n.Strong]: (e) => ({
-		type: n.Strong,
-		content: e.text,
-		items: e.tokens ? f(e.tokens) : []
+	["strong"]: (token) => ({
+		type: "strong",
+		content: token.text,
+		items: token.tokens ? convertTokens(token.tokens) : []
 	}),
-	[n.Em]: (e) => ({
-		type: n.Em,
-		content: e.text,
-		items: e.tokens ? f(e.tokens) : []
+	["em"]: (token) => ({
+		type: "em",
+		content: token.text,
+		items: token.tokens ? convertTokens(token.tokens) : []
 	}),
-	[n.Text]: (e) => ({
-		type: n.Text,
-		content: e.text,
-		items: e.tokens ? f(e.tokens) : []
+	["text"]: (token) => ({
+		type: "text",
+		content: token.text,
+		items: token.tokens ? convertTokens(token.tokens) : []
 	}),
-	[n.Hr]: (e) => ({
-		type: n.Hr,
-		content: e.raw,
-		items: e.tokens ? f(e.tokens) : []
+	["hr"]: (token) => ({
+		type: "hr",
+		content: token.raw,
+		items: token.tokens ? convertTokens(token.tokens) : []
 	}),
-	[n.CodeSpan]: (e) => ({
-		type: n.CodeSpan,
-		content: e.text,
-		items: e.tokens ? f(e.tokens) : []
+	["codespan"]: (token) => ({
+		type: "codespan",
+		content: token.text,
+		items: token.tokens ? convertTokens(token.tokens) : []
 	}),
-	[n.Blockquote]: (e) => ({
-		type: n.Blockquote,
-		content: e.text,
-		items: e.tokens ? f(e.tokens) : []
+	["blockquote"]: (token) => ({
+		type: "blockquote",
+		content: token.text,
+		items: token.tokens ? convertTokens(token.tokens) : []
 	}),
-	[n.Html]: (e) => {
-		let t = String(e.raw ?? e.text ?? "").trim();
-		return /^<br\s*\/?>$/i.test(t) ? {
-			type: n.Br,
+	["html"]: (token) => {
+		const rawHtml = String(token.raw ?? token.text ?? "").trim();
+		if (/^<br\s*\/?>$/i.test(rawHtml)) return {
+			type: "br",
 			content: "\n"
-		} : {
-			type: n.Raw,
-			content: e.raw ?? e.text ?? ""
+		};
+		return {
+			type: "raw",
+			content: token.raw ?? token.text ?? ""
 		};
 	},
-	[n.Br]: () => ({
-		type: n.Br,
+	["br"]: () => ({
+		type: "br",
 		content: "\n"
 	})
-}, m = (e) => e.getTextDimensions("H").h, h = (e) => e.getTextDimensions("H").w, g = (e, t, n, r, i) => {
-	let a = 6 - (t?.depth ?? 0) > 0 ? 6 - (t?.depth ?? 0) : 1;
-	if (e.setFontSize(r.options.page.defaultFontSize + a), t?.items && t?.items.length > 0) for (let e of t?.items ?? []) i(e, n, r, !1);
-	else {
-		let i = m(e);
-		e.text(t?.content ?? "", r.X + n, r.Y, {
-			align: "left",
-			maxWidth: r.options.page.maxContentWidth - n,
-			baseline: "top"
-		}), r.recordContentY(r.Y + i), r.updateY(m(e), "add");
-	}
-	e.setFontSize(r.options.page.defaultFontSize), r.updateX(r.options.page.xpading, "set");
-}, _ = (e, t) => {
-	typeof t.options.pageBreakHandler == "function" ? t.options.pageBreakHandler(e) : e.addPage(t.options.page?.format, t.options.page?.orientation), t.updateY(t.options.page.topmargin), t.updateX(t.options.page.xpading);
-}, v = 96, y = (e, t = "mm") => {
-	switch (t) {
-		case "pt": return e * 72 / v;
-		case "in": return e / v;
-		case "px": return e;
-		default: return e * 25.4 / v;
-	}
-}, b = (e) => {
+};
+//#endregion
+//#region src/utils/doc-helpers.ts
+const getCharHight = (doc) => {
+	return doc.getTextDimensions("H").h;
+};
+const getCharWidth = (doc) => {
+	return doc.getTextDimensions("H").w;
+};
+//#endregion
+//#region src/utils/handlePageBreak.ts
+const HandlePageBreaks = (doc, store) => {
+	if (typeof store.options.pageBreakHandler === "function") store.options.pageBreakHandler(doc);
+	else doc.addPage(store.options.page?.format, store.options.page?.orientation);
+	store.updateY(store.options.page.topmargin);
+	store.updateX(store.options.page.xpading);
+};
+//#endregion
+//#region src/utils/image-utils.ts
+/**
+* Standard DPI for web/screen pixels.
+*/
+const DEFAULT_DPI = 96;
+/**
+* Converts pixel values to the document's unit system.
+* Uses 96 DPI as the standard web pixel density.
+*
+* @param px - Value in pixels
+* @param unit - The document unit ('mm' | 'pt' | 'in' | 'px')
+* @returns Value in document units
+*/
+const pxToDocUnit = (px, unit = "mm") => {
+	switch (unit) {
+		case "pt": return px * 72 / DEFAULT_DPI;
+		case "in": return px / DEFAULT_DPI;
+		case "px": return px;
+		default: return px * 25.4 / DEFAULT_DPI;
+	}
+};
+/**
+* Extracts width and height from an SVG data URI if possible.
+*/
+const extractSvgDimensions = (dataUri) => {
 	try {
-		let t = "";
-		if (e.includes("base64,")) {
-			let n = e.split("base64,")[1];
-			t = typeof window < "u" && typeof window.atob == "function" ? decodeURIComponent(escape(window.atob(n))) : typeof Buffer < "u" ? Buffer.from(n, "base64").toString("utf-8") : decodeURIComponent(escape(atob(n)));
-		} else t = decodeURIComponent(e.split(",")[1] || "");
-		let n = t.match(/<svg[^>]*\swidth=(?:'|")([0-9.]+)[a-zA-Z]*(?:'|")/i), r = t.match(/<svg[^>]*\sheight=(?:'|")([0-9.]+)[a-zA-Z]*(?:'|")/i), i = t.match(/<svg[^>]*\sviewBox=(?:'|")[^'"]*(?:'|")/i), a = n ? parseFloat(n[1]) : 0, o = r ? parseFloat(r[1]) : 0;
-		if ((!a || !o) && i) {
-			let e = i[0].match(/viewBox=(?:'|")([^'"]+)(?:'|")/i);
-			if (e) {
-				let t = e[1].split(/[ ,]+/).filter(Boolean).map(parseFloat);
-				t.length >= 4 && (a ||= t[2], o ||= t[3]);
+		let svgString = "";
+		if (dataUri.includes("base64,")) {
+			const base64 = dataUri.split("base64,")[1];
+			if (typeof window !== "undefined" && typeof window.atob === "function") svgString = decodeURIComponent(escape(window.atob(base64)));
+			else if (typeof Buffer !== "undefined") svgString = Buffer.from(base64, "base64").toString("utf-8");
+			else svgString = decodeURIComponent(escape(atob(base64)));
+		} else svgString = decodeURIComponent(dataUri.split(",")[1] || "");
+		const widthMatch = svgString.match(/<svg[^>]*\swidth=(?:'|")([0-9.]+)[a-zA-Z]*(?:'|")/i);
+		const heightMatch = svgString.match(/<svg[^>]*\sheight=(?:'|")([0-9.]+)[a-zA-Z]*(?:'|")/i);
+		const viewBoxMatch = svgString.match(/<svg[^>]*\sviewBox=(?:'|")[^'"]*(?:'|")/i);
+		let w = widthMatch ? parseFloat(widthMatch[1]) : 0;
+		let h = heightMatch ? parseFloat(heightMatch[1]) : 0;
+		if ((!w || !h) && viewBoxMatch) {
+			const viewBoxStr = viewBoxMatch[0].match(/viewBox=(?:'|")([^'"]+)(?:'|")/i);
+			if (viewBoxStr) {
+				const parts = viewBoxStr[1].split(/[ ,]+/).filter(Boolean).map(parseFloat);
+				if (parts.length >= 4) {
+					w = w || parts[2];
+					h = h || parts[3];
+				}
 			}
 		}
-		if (a > 0 && o > 0) return {
-			width: a,
-			height: o
+		if (w > 0 && h > 0) return {
+			width: w,
+			height: h
 		};
 	} catch (e) {
 		console.warn("Failed to extract SVG dimensions:", e);
 	}
 	return null;
-}, x = (e, t, n, r, i = "mm") => {
-	if (!t.data) return {
+};
+/**
+* Calculates final dimensions for an image, respecting intrinsic size,
+* user-specified attributes, and page bounds.
+*/
+const calculateImageDimensions = (doc, element, maxWidth, maxHeight, docUnit = "mm") => {
+	if (!element.data) return {
 		finalWidth: 0,
 		finalHeight: 0
 	};
-	let a = t.naturalWidth || 0, o = t.naturalHeight || 0;
-	if (!a || !o) if (t.data.startsWith("data:image/svg")) {
-		let e = b(t.data);
-		e && (a = e.width, o = e.height);
-	} else try {
-		let n = e.getImageProperties(t.data);
-		a = n.width, o = n.height;
+	let intrinsicPxW = element.naturalWidth || 0;
+	let intrinsicPxH = element.naturalHeight || 0;
+	if (!intrinsicPxW || !intrinsicPxH) if (!element.data.startsWith("data:image/svg")) try {
+		const props = doc.getImageProperties(element.data);
+		intrinsicPxW = props.width;
+		intrinsicPxH = props.height;
 	} catch (e) {
 		console.warn("Failed to get image properties for intrinsic sizing:", e);
 	}
-	let s = o > 0 ? a / o : 1, c, l;
-	if (t.width && t.height ? (c = y(t.width, i), l = y(t.height, i)) : t.width ? (c = y(t.width, i), l = c / s) : t.height ? (l = y(t.height, i), c = l * s) : (c = y(a, i), l = y(o, i)), c > n) {
-		let e = n / c;
-		c = n, l *= e;
+	else {
+		const svgDims = extractSvgDimensions(element.data);
+		if (svgDims) {
+			intrinsicPxW = svgDims.width;
+			intrinsicPxH = svgDims.height;
+		}
+	}
+	const aspectRatio = intrinsicPxH > 0 ? intrinsicPxW / intrinsicPxH : 1;
+	let finalWidth;
+	let finalHeight;
+	if (element.width && element.height) {
+		finalWidth = pxToDocUnit(element.width, docUnit);
+		finalHeight = pxToDocUnit(element.height, docUnit);
+	} else if (element.width) {
+		finalWidth = pxToDocUnit(element.width, docUnit);
+		finalHeight = finalWidth / aspectRatio;
+	} else if (element.height) {
+		finalHeight = pxToDocUnit(element.height, docUnit);
+		finalWidth = finalHeight * aspectRatio;
+	} else {
+		finalWidth = pxToDocUnit(intrinsicPxW, docUnit);
+		finalHeight = pxToDocUnit(intrinsicPxH, docUnit);
+	}
+	if (finalWidth > maxWidth) {
+		const scale = maxWidth / finalWidth;
+		finalWidth = maxWidth;
+		finalHeight = finalHeight * scale;
 	}
-	if (l > r) {
-		let e = r / l;
-		l = r, c *= e;
+	if (finalHeight > maxHeight) {
+		const scale = maxHeight / finalHeight;
+		finalHeight = maxHeight;
+		finalWidth = finalWidth * scale;
 	}
 	return {
-		finalWidth: c,
-		finalHeight: l
+		finalWidth,
+		finalHeight
 	};
-}, S = async (e) => {
-	for (let t of e) {
-		if (t.type === n.Image && t.src) try {
-			if (t.src.startsWith("data:")) t.data = t.src;
+};
+/**
+* Recursively traverses parsed elements and loads image data for Image tokens.
+* @param elements - The parsed elements to process.
+*/
+const prefetchImages = async (elements) => {
+	for (const element of elements) {
+		if (element.type === "image" && element.src) try {
+			if (element.src.startsWith("data:")) element.data = element.src;
 			else {
-				let e = await fetch(t.src);
-				if (!e.ok) throw Error(`Failed to fetch image: ${e.statusText}`);
-				let n = await e.blob();
-				t.data = await new Promise((e, t) => {
-					let r = new FileReader();
-					r.onloadend = () => {
-						typeof r.result == "string" ? e(r.result) : t(/* @__PURE__ */ Error("Failed to convert image to base64 string"));
-					}, r.onerror = t, r.readAsDataURL(n);
+				const response = await fetch(element.src);
+				if (!response.ok) throw new Error(`Failed to fetch image: ${response.statusText}`);
+				const blob = await response.blob();
+				element.data = await new Promise((resolve, reject) => {
+					const reader = new FileReader();
+					reader.onloadend = () => {
+						if (typeof reader.result === "string") resolve(reader.result);
+						else reject(/* @__PURE__ */ new Error("Failed to convert image to base64 string"));
+					};
+					reader.onerror = reject;
+					reader.readAsDataURL(blob);
 				});
 			}
-			t.data && t.data.startsWith("data:image/svg") && typeof window < "u" && typeof document < "u" && (t.data = await new Promise((e) => {
-				let n = new Image();
-				n.onload = () => {
-					let r = document.createElement("canvas"), i = b(t.data), a = i ? i.width : n.width || 300, o = i ? i.height : n.height || 150;
-					t.naturalWidth = a, t.naturalHeight = o, r.width = a * 4, r.height = o * 4;
-					let s = r.getContext("2d");
-					s ? (s.scale(4, 4), s.drawImage(n, 0, 0, a, o), e(r.toDataURL("image/png"))) : e(t.data);
-				}, n.onerror = () => e(t.data), n.src = t.data;
-			}));
-		} catch (e) {
-			console.warn(`[jspdf-md-renderer] Warning: Failed to load image at ${t.src}. It will be skipped.`, e);
+			if (element.data && element.data.startsWith("data:image/svg")) {
+				if (typeof window !== "undefined" && typeof document !== "undefined") element.data = await new Promise((resolve) => {
+					const img = new Image();
+					img.onload = () => {
+						const canvas = document.createElement("canvas");
+						const dims = extractSvgDimensions(element.data);
+						const w = dims ? dims.width : img.width || 300;
+						const h = dims ? dims.height : img.height || 150;
+						element.naturalWidth = w;
+						element.naturalHeight = h;
+						const scale = 4;
+						canvas.width = w * scale;
+						canvas.height = h * scale;
+						const ctx = canvas.getContext("2d");
+						if (ctx) {
+							ctx.scale(scale, scale);
+							ctx.drawImage(img, 0, 0, w, h);
+							resolve(canvas.toDataURL("image/png"));
+						} else resolve(element.data);
+					};
+					img.onerror = () => resolve(element.data);
+					img.src = element.data;
+				});
+			}
+		} catch (error) {
+			console.warn(`[jspdf-md-renderer] Warning: Failed to load image at ${element.src}. It will be skipped.`, error);
 		}
-		t.items && t.items.length > 0 && await S(t.items);
+		if (element.items && element.items.length > 0) await prefetchImages(element.items);
 	}
-}, C = class {
-	static getCodespanOptions(e) {
-		let t = e.options.codespan ?? {};
+};
+//#endregion
+//#region src/utils/justifiedTextRenderer.ts
+/**
+* JustifiedTextRenderer - Renders mixed inline elements with proper alignment.
+*
+* Features:
+* - Handles bold, italic, codespan, links mixed in paragraph
+* - Proper word spacing distribution for justified alignment
+* - Supports left, right, center, and justify alignments
+* - Page break handling
+* - Preserves link clickability
+* - Codespan background rendering
+*/
+var JustifiedTextRenderer = class {
+	static getCodespanOptions(store) {
+		const opts = store.options.codespan ?? {};
 		return {
-			backgroundColor: t.backgroundColor ?? "#EEEEEE",
-			padding: t.padding ?? .5,
-			showBackground: t.showBackground !== !1,
-			fontSizeScale: t.fontSizeScale ?? .9
+			backgroundColor: opts.backgroundColor ?? "#EEEEEE",
+			padding: opts.padding ?? .5,
+			showBackground: opts.showBackground !== false,
+			fontSizeScale: opts.fontSizeScale ?? .9
 		};
 	}
-	static applyStyle(e, t, n) {
-		let r = e.getFont().fontName, i = e.getFontSize(), a = () => {
-			let e = n.options.font.bold?.name;
-			return e && e !== "" ? e : r;
-		}, o = () => {
-			let e = n.options.font.regular?.name;
-			return e && e !== "" ? e : r;
+	/**
+	* Apply font style to the jsPDF document.
+	*/
+	static applyStyle(doc, style, store) {
+		const currentFont = doc.getFont().fontName;
+		const currentFontSize = doc.getFontSize();
+		const getBoldFont = () => {
+			const boldName = store.options.font.bold?.name;
+			return boldName && boldName !== "" ? boldName : currentFont;
+		};
+		const getRegularFont = () => {
+			const regularName = store.options.font.regular?.name;
+			return regularName && regularName !== "" ? regularName : currentFont;
 		};
-		switch (t) {
+		switch (style) {
 			case "bold":
-				e.setFont(a(), n.options.font.bold?.style || "bold");
+				doc.setFont(getBoldFont(), store.options.font.bold?.style || "bold");
 				break;
 			case "italic":
-				e.setFont(o(), "italic");
+				doc.setFont(getRegularFont(), "italic");
 				break;
 			case "bolditalic":
-				e.setFont(a(), "bolditalic");
+				doc.setFont(getBoldFont(), "bolditalic");
 				break;
 			case "codespan":
-				e.setFont("courier", "normal"), e.setFontSize(i * this.getCodespanOptions(n).fontSizeScale);
+				const codeFont = store.options.font.code || {
+					name: "courier",
+					style: "normal"
+				};
+				doc.setFont(codeFont.name, codeFont.style);
+				doc.setFontSize(currentFontSize * this.getCodespanOptions(store).fontSizeScale);
 				break;
 			default:
-				e.setFont(o(), e.getFont().fontStyle);
+				doc.setFont(getRegularFont(), doc.getFont().fontStyle);
 				break;
 		}
 	}
-	static measureWordWidth(e, t, n, r) {
-		let i = e.getFont(), a = e.getFontSize();
-		this.applyStyle(e, n, r);
-		let o = e.getTextWidth(t), s = e.getCharSpace?.() ?? 0, c = o + t.length * s;
-		return e.setFont(i.fontName, i.fontStyle), e.setFontSize(a), c;
+	/**
+	* Measure word width with a specific style applied.
+	* NOTE: jsPDF's getTextWidth() does NOT include charSpace in its calculation,
+	* so we must manually add it: effectiveWidth = getTextWidth(text) + (text.length * charSpace)
+	*/
+	static measureWordWidth(doc, text, style, store) {
+		const savedFont = doc.getFont();
+		const savedSize = doc.getFontSize();
+		this.applyStyle(doc, style, store);
+		const baseWidth = doc.getTextWidth(text);
+		const charSpace = doc.getCharSpace?.() ?? 0;
+		const effectiveWidth = baseWidth + text.length * charSpace;
+		doc.setFont(savedFont.fontName, savedFont.fontStyle);
+		doc.setFontSize(savedSize);
+		return effectiveWidth;
 	}
-	static getStyleFromType(e, t) {
-		switch (e) {
-			case "strong": return t === "italic" ? "bolditalic" : "bold";
-			case "em": return t === "bold" ? "bolditalic" : "italic";
+	/**
+	* Extract style from element type string.
+	*/
+	static getStyleFromType(type, parentStyle) {
+		switch (type) {
+			case "strong":
+				if (parentStyle === "italic") return "bolditalic";
+				return "bold";
+			case "em":
+				if (parentStyle === "bold") return "bolditalic";
+				return "italic";
 			case "codespan": return "codespan";
-			default: return t || "normal";
-		}
-	}
-	static flattenToWords(e, t, n, r = "normal", i = !1, a) {
-		let o = [];
-		for (let s of t) {
-			let t = this.getStyleFromType(s.type, r), c = s.type === "link" || i, l = s.href || a;
-			if (s.items && s.items.length > 0) {
-				let r = this.flattenToWords(e, s.items, n, t, c, l);
-				o.push(...r);
-			} else if (s.type === "image") {
-				let r = n.options.page.maxContentHeight - n.options.page.topmargin, { finalWidth: i, finalHeight: a } = x(e, s, n.options.page.maxContentWidth - n.options.page.indent * 0, r, n.options.page.unit || "mm");
-				o.push({
+			default: return parentStyle || "normal";
+		}
+	}
+	/**
+	* Flatten ParsedElement tree into an array of StyledWordInfo.
+	* Handles nested inline elements.
+	*/
+	static flattenToWords(doc, elements, store, parentStyle = "normal", isLink = false, href) {
+		const result = [];
+		for (const el of elements) {
+			const style = this.getStyleFromType(el.type, parentStyle);
+			const elIsLink = el.type === "link" || isLink;
+			const elHref = el.href || href;
+			if (el.items && el.items.length > 0) {
+				const nested = this.flattenToWords(doc, el.items, store, style, elIsLink, elHref);
+				result.push(...nested);
+			} else if (el.type === "image") {
+				const maxH = store.options.page.maxContentHeight - store.options.page.topmargin;
+				const { finalWidth, finalHeight } = calculateImageDimensions(doc, el, store.options.page.maxContentWidth - store.options.page.indent * 0, maxH, store.options.page.unit || "mm");
+				result.push({
 					text: "",
-					width: i,
-					style: t,
-					isLink: c,
-					href: l,
-					linkColor: c ? n.options.link?.linkColor || [
+					width: finalWidth,
+					style,
+					isLink: elIsLink,
+					href: elHref,
+					linkColor: elIsLink ? store.options.link?.linkColor || [
 						0,
 						0,
 						255
 					] : void 0,
-					isImage: !0,
-					imageElement: s,
-					imageHeight: a
+					isImage: true,
+					imageElement: el,
+					imageHeight: finalHeight
 				});
-			} else if (s.type === "br") o.push({
+			} else if (el.type === "br") result.push({
 				text: "",
 				width: 0,
-				style: t,
-				isBr: !0
+				style,
+				isBr: true
 			});
 			else {
-				let r = s.content || s.text || "";
-				if (!r) continue;
-				if (/^\s/.test(r) && o.length > 0 && (o[o.length - 1].hasTrailingSpace = !0), t === "codespan") {
-					let i = r.trim();
-					i && o.push({
-						text: i,
-						width: this.measureWordWidth(e, i, t, n),
-						style: t,
-						isLink: c,
-						href: l,
-						linkColor: c ? n.options.link?.linkColor || [
+				const text = el.content || el.text || "";
+				if (!text) continue;
+				if (/^\s/.test(text) && result.length > 0) result[result.length - 1].hasTrailingSpace = true;
+				if (style === "codespan") {
+					const trimmedText = text.trim();
+					if (trimmedText) result.push({
+						text: trimmedText,
+						width: this.measureWordWidth(doc, trimmedText, style, store),
+						style,
+						isLink: elIsLink,
+						href: elHref,
+						linkColor: elIsLink ? store.options.link?.linkColor || [
 							0,
 							0,
 							255
 						] : void 0,
-						hasTrailingSpace: /\s$/.test(r)
+						hasTrailingSpace: /\s$/.test(text)
 					});
 					continue;
 				}
-				let i = r.trim().split(/\s+/).filter((e) => e.length > 0);
-				for (let a = 0; a < i.length; a++) {
-					let s = a !== i.length - 1 || /\s$/.test(r);
-					o.push({
-						text: i[a],
-						width: this.measureWordWidth(e, i[a], t, n),
-						style: t,
-						isLink: c,
-						href: l,
-						linkColor: c ? n.options.link?.linkColor || [
-							0,
-							0,
-							255
-						] : void 0,
-						hasTrailingSpace: s
+				const lines = text.split("\n");
+				for (let partIndex = 0; partIndex < lines.length; partIndex++) {
+					const lineStr = lines[partIndex];
+					const words = lineStr.trim().split(/[ \t\r\v\f]+/).filter((w) => w.length > 0);
+					for (let i = 0; i < words.length; i++) {
+						const hasTrailingSpace = !(i === words.length - 1) || /[ \t\r\v\f]$/.test(lineStr);
+						result.push({
+							text: words[i],
+							width: this.measureWordWidth(doc, words[i], style, store),
+							style,
+							isLink: elIsLink,
+							href: elHref,
+							linkColor: elIsLink ? store.options.link?.linkColor || [
+								0,
+								0,
+								255
+							] : void 0,
+							hasTrailingSpace
+						});
+					}
+					if (partIndex < lines.length - 1) result.push({
+						text: "",
+						width: 0,
+						style,
+						isBr: true
 					});
 				}
 			}
 		}
-		return o;
-	}
-	static breakIntoLines(e, t, n, r) {
-		let i = [], a = [], o = 0, s = 0, c = m(e) * r.options.page.defaultLineHeightFactor, l = e.getTextWidth(" ");
-		for (let u = 0; u < t.length; u++) {
-			let d = t[u], f = a[a.length - 1]?.hasTrailingSpace ? l + d.width : d.width, p = d.isImage && d.imageHeight ? d.imageHeight : m(e) * r.options.page.defaultLineHeightFactor;
-			if (d.isBr) {
-				i.push({
-					words: a,
-					totalTextWidth: o,
-					isLastLine: !0,
-					lineHeight: c
-				}), a = [], o = 0, s = 0, c = m(e) * r.options.page.defaultLineHeightFactor;
+		return result;
+	}
+	/**
+	* Break a flat list of words into lines that fit within maxWidth.
+	* Correctly tracks totalTextWidth (sum of word widths only) for justification.
+	*/
+	static breakIntoLines(doc, words, maxWidth, store) {
+		const lines = [];
+		let currentLine = [];
+		let currentTextWidth = 0;
+		let currentLineWidth = 0;
+		let currentLineHeight = getCharHight(doc) * store.options.page.defaultLineHeightFactor;
+		const spaceWidth = doc.getTextWidth(" ");
+		for (let i = 0; i < words.length; i++) {
+			const word = words[i];
+			const neededWidthWithSpace = currentLine[currentLine.length - 1]?.hasTrailingSpace ? spaceWidth + word.width : word.width;
+			const itemHeight = word.isImage && word.imageHeight ? word.imageHeight : getCharHight(doc) * store.options.page.defaultLineHeightFactor;
+			if (word.isBr) {
+				lines.push({
+					words: currentLine,
+					totalTextWidth: currentTextWidth,
+					isLastLine: true,
+					lineHeight: currentLineHeight
+				});
+				currentLine = [];
+				currentTextWidth = 0;
+				currentLineWidth = 0;
+				currentLineHeight = getCharHight(doc) * store.options.page.defaultLineHeightFactor;
 				continue;
 			}
-			s + f > n && a.length > 0 ? (i.push({
-				words: a,
-				totalTextWidth: o,
-				isLastLine: !1,
-				lineHeight: c
-			}), a = [d], o = d.width, s = d.width, c = p) : (a.push(d), o += d.width, s += f, c = Math.max(c, p));
-		}
-		return a.length > 0 && i.push({
-			words: a,
-			totalTextWidth: o,
-			isLastLine: !0,
-			lineHeight: c
-		}), i;
-	}
-	static renderWord(e, t, n, r, i) {
-		let a = e.getFont(), o = e.getFontSize(), s = e.getTextColor();
-		if (this.applyStyle(e, t.style, i), t.isLink && t.linkColor && e.setTextColor(...t.linkColor), t.isImage && t.imageElement && t.imageElement.data) try {
-			let i = "JPEG";
-			if (t.imageElement.data.startsWith("data:image/png")) i = "PNG";
-			else if (t.imageElement.data.startsWith("data:image/webp")) i = "WEBP";
-			else if (t.imageElement.data.startsWith("data:image/gif")) i = "GIF";
-			else if (t.imageElement.src) {
-				let e = t.imageElement.src.split("?")[0].split("#")[0].split(".").pop()?.toUpperCase();
-				e && [
+			if (currentLineWidth + neededWidthWithSpace > maxWidth && currentLine.length > 0) {
+				lines.push({
+					words: currentLine,
+					totalTextWidth: currentTextWidth,
+					isLastLine: false,
+					lineHeight: currentLineHeight
+				});
+				currentLine = [word];
+				currentTextWidth = word.width;
+				currentLineWidth = word.width;
+				currentLineHeight = itemHeight;
+			} else {
+				currentLine.push(word);
+				currentTextWidth += word.width;
+				currentLineWidth += neededWidthWithSpace;
+				currentLineHeight = Math.max(currentLineHeight, itemHeight);
+			}
+		}
+		if (currentLine.length > 0) lines.push({
+			words: currentLine,
+			totalTextWidth: currentTextWidth,
+			isLastLine: true,
+			lineHeight: currentLineHeight
+		});
+		return lines;
+	}
+	/**
+	* Render a single word with its style applied.
+	*/
+	static renderWord(doc, word, x, y, store) {
+		const savedFont = doc.getFont();
+		const savedSize = doc.getFontSize();
+		const savedColor = doc.getTextColor();
+		this.applyStyle(doc, word.style, store);
+		if (word.isLink && word.linkColor) doc.setTextColor(...word.linkColor);
+		if (word.isImage && word.imageElement && word.imageElement.data) try {
+			let imgFormat = "JPEG";
+			if (word.imageElement.data.startsWith("data:image/png")) imgFormat = "PNG";
+			else if (word.imageElement.data.startsWith("data:image/webp")) imgFormat = "WEBP";
+			else if (word.imageElement.data.startsWith("data:image/gif")) imgFormat = "GIF";
+			else if (word.imageElement.src) {
+				const ext = word.imageElement.src.split("?")[0].split("#")[0].split(".").pop()?.toUpperCase();
+				if (ext && [
 					"PNG",
 					"JPEG",
 					"JPG",
 					"WEBP",
 					"GIF"
-				].includes(e) && (i = e === "JPG" ? "JPEG" : e);
+				].includes(ext)) imgFormat = ext === "JPG" ? "JPEG" : ext;
 			}
-			if (t.width > 0 && (t.imageHeight || 0) > 0) {
-				let a = t.imageHeight || 0, o = r;
-				e.addImage(t.imageElement.data, i, n, o, t.width, a);
+			if (word.width > 0 && (word.imageHeight || 0) > 0) {
+				const imgH = word.imageHeight || 0;
+				const imgY = y;
+				doc.addImage(word.imageElement.data, imgFormat, x, imgY, word.width, imgH);
 			}
 		} catch (e) {
 			console.warn("Failed to render inline image", e);
 		}
 		else {
-			if (t.style === "codespan") {
-				let a = this.getCodespanOptions(i);
-				if (a.showBackground) {
-					let i = m(e), o = a.padding;
-					e.setFillColor(a.backgroundColor), e.rect(n - o, r - o, t.width + o * 2, i + o * 2, "F"), e.setFillColor("#000000");
+			if (word.style === "codespan") {
+				const codespanOpts = this.getCodespanOptions(store);
+				if (codespanOpts.showBackground) {
+					const h = getCharHight(doc);
+					const pad = codespanOpts.padding;
+					doc.setFillColor(codespanOpts.backgroundColor);
+					doc.rect(x - pad, y - pad, word.width + pad * 2, h + pad * 2, "F");
+					doc.setFillColor("#000000");
 				}
 			}
-			e.text(t.text, n, r, { baseline: "top" });
+			doc.text(word.text, x, y, { baseline: "top" });
 		}
-		if (t.isLink && t.href) {
-			let i = t.isImage && t.imageHeight ? t.imageHeight : m(e);
-			e.link(n, r, t.width, i, { url: t.href });
+		if (word.isLink && word.href) {
+			const h = word.isImage && word.imageHeight ? word.imageHeight : getCharHight(doc);
+			doc.link(x, y, word.width, h, { url: word.href });
 		}
-		e.setFont(a.fontName, a.fontStyle), e.setFontSize(o), e.setTextColor(s);
+		doc.setFont(savedFont.fontName, savedFont.fontStyle);
+		doc.setFontSize(savedSize);
+		doc.setTextColor(savedColor);
 	}
-	static renderAlignedLine(e, t, n, r, i, a, o = "left") {
-		let { words: s, totalTextWidth: c, isLastLine: l } = t;
-		if (s.length === 0) return;
-		let u = e.getTextWidth(" "), d = n, f = u, p = c, h = 0;
-		for (let e = 0; e < s.length - 1; e++) s[e].hasTrailingSpace && (p += u, h++);
-		switch (o) {
+	/**
+	* Render a single line with specified alignment.
+	*/
+	static renderAlignedLine(doc, line, x, y, maxWidth, store, alignment = "left") {
+		const { words, totalTextWidth, isLastLine } = line;
+		if (words.length === 0) return;
+		const normalSpaceWidth = doc.getTextWidth(" ");
+		let startX = x;
+		let wordSpacing = normalSpaceWidth;
+		let lineWidthWithNormalSpaces = totalTextWidth;
+		let expandableSpacesCount = 0;
+		for (let i = 0; i < words.length - 1; i++) if (words[i].hasTrailingSpace) {
+			lineWidthWithNormalSpaces += normalSpaceWidth;
+			expandableSpacesCount++;
+		}
+		switch (alignment) {
 			case "right":
-				d = n + i - p;
+				startX = x + maxWidth - lineWidthWithNormalSpaces;
 				break;
 			case "center":
-				d = n + (i - p) / 2;
+				startX = x + (maxWidth - lineWidthWithNormalSpaces) / 2;
 				break;
 			case "justify":
-				!l && h > 0 && (f = (i - c) / h);
+				if (!isLastLine && expandableSpacesCount > 0) wordSpacing = (maxWidth - totalTextWidth) / expandableSpacesCount;
 				break;
 			default: break;
 		}
-		let g = d, _ = m(e) * a.options.page.defaultLineHeightFactor;
-		for (let n = 0; n < s.length; n++) {
-			let i = s[n], o = r, c = i.isImage && i.imageHeight ? i.imageHeight : _;
-			i.isImage ? o = r : c < t.lineHeight && (o = r + (t.lineHeight - c)), this.renderWord(e, i, g, o, a), g += i.width, n < s.length - 1 && i.hasTrailingSpace && (g += f);
-		}
-	}
-	static renderStyledParagraph(e, t, n, r, i, a, o) {
-		let s = o ?? a.options.content?.textAlignment ?? "left", c = this.flattenToWords(e, t, a);
-		if (c.length === 0) return;
-		let l = this.breakIntoLines(e, c, i, a), u = r;
-		for (let t of l) u + t.lineHeight > a.options.page.maxContentHeight && (_(e, a), u = a.Y), this.renderAlignedLine(e, t, n, u, i, a, s), a.recordContentY(u + t.lineHeight), u += t.lineHeight, a.updateY(t.lineHeight, "add");
-		let d = l[l.length - 1];
-		if (d) {
-			let t = 0;
-			for (let e = 0; e < d.words.length - 1; e++) d.words[e].hasTrailingSpace && t++;
-			let r = d.totalTextWidth + t * e.getTextWidth(" ");
-			a.updateX(n + r, "set");
-		}
-	}
-	static renderJustifiedParagraph(e, t, n, r, i, a) {
-		this.renderStyledParagraph(e, t, n, r, i, a);
-	}
-}, w = class {
-	static renderText(e, t, n, r = n.X, i = n.Y, a, o = !1) {
-		let s = e.splitTextToSize(t, a), c = m(e), l = c * n.options.page.defaultLineHeightFactor, u = i;
-		for (let t = 0; t < s.length; t++) {
-			let i = s[t];
-			u + l > n.options.page.maxContentHeight && (_(e, n), u = n.Y), o ? t === s.length - 1 ? e.text(i, r, u, { baseline: "top" }) : e.text(i, r, u, {
-				maxWidth: a,
+		let currentX = startX;
+		const textHeight = getCharHight(doc) * store.options.page.defaultLineHeightFactor;
+		for (let i = 0; i < words.length; i++) {
+			const word = words[i];
+			let drawY = y;
+			const elementHeight = word.isImage && word.imageHeight ? word.imageHeight : textHeight;
+			if (word.isImage) drawY = y;
+			else if (elementHeight < line.lineHeight) drawY = y + (line.lineHeight - elementHeight);
+			this.renderWord(doc, word, currentX, drawY, store);
+			currentX += word.width;
+			if (i < words.length - 1 && word.hasTrailingSpace) currentX += wordSpacing;
+		}
+	}
+	/**
+	* Main entry point: Render a paragraph with mixed inline elements.
+	* Respects user's textAlignment option from store.
+	*
+	* @param doc jsPDF instance
+	* @param elements Array of ParsedElement (inline items in a paragraph)
+	* @param x Starting X coordinate
+	* @param y Starting Y coordinate
+	* @param maxWidth Maximum width for text wrapping
+	* @param store RenderStore instance to use
+	* @param alignment Optional alignment override (defaults to store option)
+	*/
+	static renderStyledParagraph(doc, elements, x, y, maxWidth, store, alignment) {
+		const textAlignment = alignment ?? store.options.content?.textAlignment ?? "left";
+		const words = this.flattenToWords(doc, elements, store);
+		if (words.length === 0) return;
+		const lines = this.breakIntoLines(doc, words, maxWidth, store);
+		let currentY = y;
+		for (const line of lines) {
+			if (currentY + line.lineHeight > store.options.page.maxContentHeight) {
+				HandlePageBreaks(doc, store);
+				currentY = store.Y;
+			}
+			this.renderAlignedLine(doc, line, x, currentY, maxWidth, store, textAlignment);
+			store.recordContentY(currentY + line.lineHeight);
+			currentY += line.lineHeight;
+			store.updateY(line.lineHeight, "add");
+		}
+		const lastLine = lines[lines.length - 1];
+		if (lastLine) {
+			let actualSpacesCount = 0;
+			for (let i = 0; i < lastLine.words.length - 1; i++) if (lastLine.words[i].hasTrailingSpace) actualSpacesCount++;
+			const lastLineWidth = lastLine.totalTextWidth + actualSpacesCount * doc.getTextWidth(" ");
+			store.updateX(x + lastLineWidth, "set");
+		}
+	}
+	/**
+	* @deprecated Use renderStyledParagraph instead
+	*/
+	static renderJustifiedParagraph(doc, elements, x, y, maxWidth, store) {
+		this.renderStyledParagraph(doc, elements, x, y, maxWidth, store);
+	}
+};
+//#endregion
+//#region src/renderer/components/heading.ts
+/**
+* Renders heading elements.
+*/
+const renderHeading = (doc, element, indent, store, parentElementRenderer) => {
+	const size = 6 - (element?.depth ?? 0) > 0 ? 6 - (element?.depth ?? 0) : 1;
+	doc.setFontSize(store.options.page.defaultFontSize + size);
+	if (element?.items && element?.items.length > 0) {
+		const originalLineHeightFactor = store.options.page.defaultLineHeightFactor;
+		store.options.page.defaultLineHeightFactor = 1;
+		JustifiedTextRenderer.renderStyledParagraph(doc, element.items, store.X + indent, store.Y, store.options.page.maxContentWidth - indent, store, "left");
+		store.options.page.defaultLineHeightFactor = originalLineHeightFactor;
+	} else {
+		const charHeight = getCharHight(doc);
+		doc.text(element?.content ?? "", store.X + indent, store.Y, {
+			align: "left",
+			maxWidth: store.options.page.maxContentWidth - indent,
+			baseline: "top"
+		});
+		store.recordContentY(store.Y + charHeight);
+		store.updateY(getCharHight(doc), "add");
+	}
+	doc.setFontSize(store.options.page.defaultFontSize);
+	store.updateX(store.options.page.xpading, "set");
+};
+//#endregion
+//#region src/utils/text-renderer.ts
+var TextRenderer = class {
+	/**
+	* Renders text with automatic line wrapping and page breaking.
+	* @param doc jsPDF instance
+	* @param text Text to render
+	* @param store RenderStore instance to use
+	* @param x X coordinate (if not provided, uses store.X)
+	* @param y Y coordinate (if not provided, uses store.Y)
+	* @param maxWidth Max width for text wrapping
+	* @param justify Whether to justify the text
+	*/
+	static renderText(doc, text, store, x = store.X, y = store.Y, maxWidth, justify = false) {
+		const lines = doc.splitTextToSize(text, maxWidth);
+		const charHeight = getCharHight(doc);
+		const lineHeight = charHeight * store.options.page.defaultLineHeightFactor;
+		let currentY = y;
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+			if (currentY + lineHeight > store.options.page.maxContentHeight) {
+				HandlePageBreaks(doc, store);
+				currentY = store.Y;
+			}
+			if (justify) if (i === lines.length - 1) doc.text(line, x, currentY, { baseline: "top" });
+			else doc.text(line, x, currentY, {
+				maxWidth,
 				align: "justify",
 				baseline: "top"
-			}) : e.text(i, r, u, { baseline: "top" }), n.recordContentY(u + c), u += l, n.updateY(l, "add");
+			});
+			else doc.text(line, x, currentY, { baseline: "top" });
+			store.recordContentY(currentY + charHeight);
+			currentY += lineHeight;
+			store.updateY(lineHeight, "add");
 		}
-		return u;
+		return currentY;
 	}
-}, T = (e, t, r, i, a) => {
-	i.activateInlineLock(), e.setFontSize(i.options.page.defaultFontSize);
-	let o = i.options.page.maxContentWidth - r;
-	if (t?.items && t?.items.length > 0) {
-		if (t.items.length === 1 && t.items[0].type === "image") {
-			a(t.items[0], r, i, !1), i.updateX(i.options.page.xpading), i.deactivateInlineLock();
+};
+//#endregion
+//#region src/renderer/components/paragraph.ts
+/**
+* Renders paragraph elements with proper text alignment.
+* Handles mixed inline styles (bold, italic, codespan) and links.
+* Respects user's textAlignment option from RenderStore.
+*/
+const renderParagraph = (doc, element, indent, store, parentElementRenderer) => {
+	store.activateInlineLock();
+	doc.setFontSize(store.options.page.defaultFontSize);
+	const maxWidth = store.options.page.maxContentWidth - indent;
+	if (element?.items && element?.items.length > 0) {
+		if (element.items.length === 1 && element.items[0].type === "image") {
+			parentElementRenderer(element.items[0], indent, store, false);
+			store.updateX(store.options.page.xpading);
+			store.deactivateInlineLock();
 			return;
 		}
-		let s = [
-			n.Strong,
-			n.Em,
-			n.Text,
-			n.CodeSpan,
-			n.Link,
-			n.Image,
-			n.Br
+		const inlineTypes = [
+			"strong",
+			"em",
+			"text",
+			"codespan",
+			"link",
+			"image",
+			"br"
 		];
-		if (t.items.some((e) => !s.includes(e.type))) {
-			let n = [], c = () => {
-				n.length > 0 && (C.renderStyledParagraph(e, n, i.X + r, i.Y, o, i), n.length = 0);
+		if (element.items.some((item) => !inlineTypes.includes(item.type))) {
+			const inlineBuffer = [];
+			const flushInlineBuffer = () => {
+				if (inlineBuffer.length > 0) {
+					JustifiedTextRenderer.renderStyledParagraph(doc, inlineBuffer, store.X + indent, store.Y, maxWidth, store);
+					inlineBuffer.length = 0;
+				}
 			};
-			for (let e of t.items) s.includes(e.type) ? n.push(e) : (c(), a(e, r, i, !1));
-			c();
-		} else C.renderStyledParagraph(e, t.items, i.X + r, i.Y, o, i);
+			for (const item of element.items) if (inlineTypes.includes(item.type)) inlineBuffer.push(item);
+			else {
+				flushInlineBuffer();
+				parentElementRenderer(item, indent, store, false);
+			}
+			flushInlineBuffer();
+		} else JustifiedTextRenderer.renderStyledParagraph(doc, element.items, store.X + indent, store.Y, maxWidth, store);
 	} else {
-		let n = t.content ?? "", a = i.options.content?.textAlignment ?? "left";
-		n.trim() && w.renderText(e, n, i, i.X + r, i.Y, o, a === "justify");
-	}
-	i.updateX(i.options.page.xpading), i.deactivateInlineLock();
-}, E = (e, t, n, r, i) => {
-	e.setFontSize(r.options.page.defaultFontSize);
-	for (let [e, a] of t?.items?.entries() ?? []) {
-		let o = t.ordered ? (t.start ?? 0) + e : t.start;
-		i(a, n + 1, r, !0, o, t.ordered);
-	}
-}, D = (e, t, r, i, a, o, s) => {
-	i.Y + m(e) >= i.options.page.maxContentHeight && _(e, i);
-	let c = i.options, l = r * c.page.indent, u = s ? `${o}. ` : "• ", d = c.page.xpading;
-	i.updateX(d, "set"), e.setFont(c.font.regular.name, c.font.regular.style), e.text(u, d + l, i.Y, { baseline: "top" });
-	let f = e.getTextWidth(u), p = d + l + f, h = c.page.maxContentWidth - l - f;
-	if (t.items && t.items.length > 0) {
-		let c = [], l = () => {
-			c.length > 0 && (C.renderStyledParagraph(e, c, p, i.Y, h, i), c.length = 0, i.updateX(d, "set"));
+		const content = element.content ?? "";
+		const textAlignment = store.options.content?.textAlignment ?? "left";
+		if (content.trim()) TextRenderer.renderText(doc, content, store, store.X + indent, store.Y, maxWidth, textAlignment === "justify");
+	}
+	store.updateX(store.options.page.xpading);
+	store.deactivateInlineLock();
+};
+//#endregion
+//#region src/renderer/components/list.ts
+const renderList = (doc, element, indentLevel, store, parentElementRenderer) => {
+	doc.setFontSize(store.options.page.defaultFontSize);
+	for (const [i, point] of element?.items?.entries() ?? []) {
+		const _start = element.ordered ? (element.start ?? 0) + i : element.start;
+		parentElementRenderer(point, indentLevel + 1, store, true, _start, element.ordered);
+	}
+};
+//#endregion
+//#region src/renderer/components/listItem.ts
+/**
+* Render a single list item, including bullets/numbering, inline text, and any nested lists.
+*/
+const renderListItem = (doc, element, indentLevel, store, parentElementRenderer, start, ordered) => {
+	if (store.Y + getCharHight(doc) >= store.options.page.maxContentHeight) HandlePageBreaks(doc, store);
+	const options = store.options;
+	const baseIndent = indentLevel * options.page.indent;
+	const bullet = ordered ? `${start}. ` : "• ";
+	const xLeft = options.page.xpading;
+	store.updateX(xLeft, "set");
+	doc.setFont(options.font.regular.name, options.font.regular.style);
+	doc.text(bullet, xLeft + baseIndent, store.Y, { baseline: "top" });
+	const bulletWidth = doc.getTextWidth(bullet);
+	const contentX = xLeft + baseIndent + bulletWidth;
+	const textMaxWidth = options.page.maxContentWidth - baseIndent - bulletWidth;
+	if (element.items && element.items.length > 0) {
+		const inlineBuffer = [];
+		const flushInlineBuffer = () => {
+			if (inlineBuffer.length > 0) {
+				JustifiedTextRenderer.renderStyledParagraph(doc, inlineBuffer, contentX, store.Y, textMaxWidth, store);
+				inlineBuffer.length = 0;
+				store.updateX(xLeft, "set");
+			}
 		};
-		for (let e of t.items) e.type === n.List ? (l(), a(e, r, i, !0, o, e.ordered ?? !1)) : e.type === n.ListItem ? (l(), a(e, r, i, !0, o, s)) : c.push(e);
-		l();
-	} else if (t.content) {
-		let n = c.content?.textAlignment ?? "left";
-		w.renderText(e, t.content, i, p, i.Y, h, n === "justify");
-	}
-}, O = (e, t, n, r, i, a, o, s, c = !0) => {
-	if (t?.items && t?.items.length > 0) for (let e of t?.items ?? []) a(e, n, r, i, o, s, c);
+		for (const subItem of element.items) if (subItem.type === "list") {
+			flushInlineBuffer();
+			parentElementRenderer(subItem, indentLevel, store, true, start, subItem.ordered ?? false);
+		} else if (subItem.type === "list_item") {
+			flushInlineBuffer();
+			parentElementRenderer(subItem, indentLevel, store, true, start, ordered);
+		} else inlineBuffer.push(subItem);
+		flushInlineBuffer();
+	} else if (element.content) {
+		const textAlignment = options.content?.textAlignment ?? "left";
+		TextRenderer.renderText(doc, element.content, store, contentX, store.Y, textMaxWidth, textAlignment === "justify");
+	}
+};
+//#endregion
+//#region src/renderer/components/rawItem.ts
+const renderRawItem = (doc, element, indentLevel, store, hasRawBullet, parentElementRenderer, start, ordered, justify = true) => {
+	if (element?.items && element?.items.length > 0) for (const item of element?.items ?? []) parentElementRenderer(item, indentLevel, store, hasRawBullet, start, ordered, justify);
 	else {
-		let a = r.options, l = n * a.page.indent, u = i ? s ? `${o}. ` : "• " : "", d = t.content || "", f = a.page.xpading;
-		if (!d && !u) return;
-		if (!d.trim() && !u) {
-			let t = (d.match(/\n/g) || []).length;
-			if (t > 1) {
-				let n = (t - 1) * (e.getTextDimensions("A").h * a.page.defaultLineHeightFactor);
-				r.Y + n > a.page.maxContentHeight ? _(e, r) : (r.updateY(n, "add"), r.recordContentY(r.Y));
+		const options = store.options;
+		const indent = indentLevel * options.page.indent;
+		const bullet = hasRawBullet ? ordered ? `${start}. ` : "• " : "";
+		const content = element.content || "";
+		const xLeft = options.page.xpading;
+		if (!content && !bullet) return;
+		if (!content.trim() && !bullet) {
+			const newlines = (content.match(/\n/g) || []).length;
+			if (newlines > 1) {
+				const addedHeight = (newlines - 1) * (doc.getTextDimensions("A").h * options.page.defaultLineHeightFactor);
+				if (store.Y + addedHeight > options.page.maxContentHeight) HandlePageBreaks(doc, store);
+				else {
+					store.updateY(addedHeight, "add");
+					store.recordContentY(store.Y);
+				}
 			}
 			return;
 		}
-		if (r.updateX(f, "set"), i && u) {
-			let t = e.getTextWidth(u), n = a.page.maxContentWidth - l - t;
-			e.setFont(a.font.regular.name, a.font.regular.style), e.text(u, f + l, r.Y, { baseline: "top" }), w.renderText(e, d, r, f + l + t, r.Y, n, c);
+		store.updateX(xLeft, "set");
+		if (hasRawBullet && bullet) {
+			const bulletWidth = doc.getTextWidth(bullet);
+			const textMaxWidth = options.page.maxContentWidth - indent - bulletWidth;
+			doc.setFont(options.font.regular.name, options.font.regular.style);
+			doc.text(bullet, xLeft + indent, store.Y, { baseline: "top" });
+			TextRenderer.renderText(doc, content, store, xLeft + indent + bulletWidth, store.Y, textMaxWidth, justify);
 		} else {
-			let t = a.page.maxContentWidth - l;
-			w.renderText(e, d, r, f + l, r.Y, t, c);
-		}
-		r.updateX(f, "set");
-	}
-}, k = (e, t) => {
-	let n = e.internal.pageSize.getWidth();
-	e.setLineDashPattern([1, 1], 0), e.setLineWidth(.1), e.line(t.options.page.xpading, t.Y, n - t.options.page.xpading, t.Y), e.setLineWidth(.1), e.setLineDashPattern([], 0), t.updateY(m(e), "add");
-}, A = (e, t, n, r) => {
-	let i = e.getFont(), a = e.getFontSize();
-	e.setFont("courier", "normal");
-	let o = r.options.page.defaultFontSize * .9;
-	e.setFontSize(o);
-	let s = n * r.options.page.indent, c = r.options.page.maxContentWidth - s - 8, l = e.getLineHeightFactor(), u = o / e.internal.scaleFactor * l, d = (t.code ?? "").replace(/[\r\n\s]+$/, "");
-	if (!d) {
-		e.setFont(i.fontName, i.fontStyle), e.setFontSize(a);
+			const textMaxWidth = options.page.maxContentWidth - indent;
+			TextRenderer.renderText(doc, content, store, xLeft + indent, store.Y, textMaxWidth, justify);
+		}
+		store.updateX(xLeft, "set");
+	}
+};
+//#endregion
+//#region src/renderer/components/hr.ts
+const renderHR = (doc, store) => {
+	const pageWidth = doc.internal.pageSize.getWidth();
+	doc.setLineDashPattern([1, 1], 0);
+	doc.setLineWidth(.1);
+	doc.line(store.options.page.xpading, store.Y, pageWidth - store.options.page.xpading, store.Y);
+	doc.setLineWidth(.1);
+	doc.setLineDashPattern([], 0);
+	store.updateY(getCharHight(doc), "add");
+};
+//#endregion
+//#region src/renderer/components/code.ts
+const renderCodeBlock = (doc, element, indentLevel, store) => {
+	const savedFont = doc.getFont();
+	const savedFontSize = doc.getFontSize();
+	const codeFont = store.options.font.code || {
+		name: "courier",
+		style: "normal"
+	};
+	doc.setFont(codeFont.name, codeFont.style);
+	const codeFontSize = store.options.page.defaultFontSize * .9;
+	doc.setFontSize(codeFontSize);
+	const indent = indentLevel * store.options.page.indent;
+	const maxWidth = store.options.page.maxContentWidth - indent - 8;
+	const lineHeightFactor = doc.getLineHeightFactor();
+	const lineHeight = codeFontSize / doc.internal.scaleFactor * lineHeightFactor;
+	const content = (element.code ?? "").replace(/[\r\n\s]+$/, "");
+	if (!content) {
+		doc.setFont(savedFont.fontName, savedFont.fontStyle);
+		doc.setFontSize(savedFontSize);
 		return;
 	}
-	let f = e.splitTextToSize(d, c);
-	for (; f.length > 0 && f[f.length - 1].trim() === "";) f.pop();
-	if (f.length === 0) {
-		e.setFont(i.fontName, i.fontStyle), e.setFontSize(a);
+	const lines = doc.splitTextToSize(content, maxWidth);
+	while (lines.length > 0 && lines[lines.length - 1].trim() === "") lines.pop();
+	if (lines.length === 0) {
+		doc.setFont(savedFont.fontName, savedFont.fontStyle);
+		doc.setFontSize(savedFontSize);
 		return;
 	}
-	let p = 0;
-	for (; p < f.length;) {
-		let n = r.options.page.maxContentHeight - r.Y, i = f.length - p, a = n - 8, o = Math.floor(a / u);
-		if (o <= 0) {
-			_(e, r);
+	const padding = 4;
+	const bgColor = "#EEEEEE";
+	const drawColor = "#DDDDDD";
+	let currentLineIndex = 0;
+	while (currentLineIndex < lines.length) {
+		const availableHeight = store.options.page.maxContentHeight - store.Y;
+		const remainingLines = lines.length - currentLineIndex;
+		const effectiveAvailable = availableHeight - padding * 2;
+		let linesToRenderCount = Math.floor(effectiveAvailable / lineHeight);
+		if (linesToRenderCount <= 0) {
+			HandlePageBreaks(doc, store);
 			continue;
 		}
-		o > i && (o = i);
-		let s = f.slice(p, p + o), c = p === 0, l = p + o >= f.length, d = o * u;
-		if (c && r.updateY(4, "add"), e.setFillColor("#EEEEEE"), e.setDrawColor("#DDDDDD"), e.roundedRect(r.X, r.Y - 4, r.options.page.maxContentWidth, d + (c ? 4 : 0) + (l ? 4 : 0), 2, 2, "FD"), c && t.lang) {
-			let n = e.getFontSize();
-			e.setFontSize(10), e.setTextColor("#666666"), e.text(t.lang, r.X + r.options.page.maxContentWidth - e.getTextWidth(t.lang) - 4, r.Y, { baseline: "top" }), e.setFontSize(n), e.setTextColor("#000000");
+		if (linesToRenderCount > remainingLines) linesToRenderCount = remainingLines;
+		const linesToRender = lines.slice(currentLineIndex, currentLineIndex + linesToRenderCount);
+		const isFirstChunk = currentLineIndex === 0;
+		const isLastChunk = currentLineIndex + linesToRenderCount >= lines.length;
+		const textBlockHeight = linesToRenderCount * lineHeight;
+		if (isFirstChunk) store.updateY(padding, "add");
+		doc.setFillColor(bgColor);
+		doc.setDrawColor(drawColor);
+		doc.roundedRect(store.X, store.Y - padding, store.options.page.maxContentWidth, textBlockHeight + (isFirstChunk ? padding : 0) + (isLastChunk ? padding : 0), 2, 2, "FD");
+		if (isFirstChunk && element.lang) {
+			const savedCodeFontSize = doc.getFontSize();
+			doc.setFontSize(10);
+			doc.setTextColor("#666666");
+			doc.text(element.lang, store.X + store.options.page.maxContentWidth - doc.getTextWidth(element.lang) - 4, store.Y, { baseline: "top" });
+			doc.setFontSize(savedCodeFontSize);
+			doc.setTextColor("#000000");
 		}
-		let m = r.Y;
-		for (let t of s) e.text(t, r.X + 4, m, { baseline: "top" }), m += u;
-		r.updateY(d, "add"), r.recordContentY(r.Y + (l ? 4 : 0)), l && r.updateY(4, "add"), p += o, p < f.length && _(e, r);
+		let yPos = store.Y;
+		for (const line of linesToRender) {
+			doc.text(line, store.X + 4, yPos, { baseline: "top" });
+			yPos += lineHeight;
+		}
+		store.updateY(textBlockHeight, "add");
+		store.recordContentY(store.Y + (isLastChunk ? padding : 0));
+		if (isLastChunk) store.updateY(padding, "add");
+		currentLineIndex += linesToRenderCount;
+		if (currentLineIndex < lines.length) HandlePageBreaks(doc, store);
 	}
-	e.setFont(i.fontName, i.fontStyle), e.setFontSize(a);
-}, j = (e, t, n, r) => {
-	let i = e.getFont().fontName, a = e.getFont().fontStyle, o = e.getFontSize(), s = (e) => {
-		switch (e) {
+	doc.setFont(savedFont.fontName, savedFont.fontStyle);
+	doc.setFontSize(savedFontSize);
+};
+//#endregion
+//#region src/renderer/components/inlineText.ts
+/**
+* Renders inline text elements (Strong, Em, and Text) with proper inline styling.
+*/
+const renderInlineText = (doc, element, indent, store) => {
+	const currentFont = doc.getFont().fontName;
+	const currentFontStyle = doc.getFont().fontStyle;
+	const currentFontSize = doc.getFontSize();
+	const spaceMultiplier = (style) => {
+		switch (style) {
 			case "normal": return 0;
 			case "bold": return 1;
 			case "italic": return 1.5;
@@ -643,192 +1150,338 @@ var n = /* @__PURE__ */ function(e) {
 			case "codespan": return .5;
 			default: return 0;
 		}
-	}, c = (t, c) => {
-		c === "bold" ? e.setFont(r.options.font.bold.name && r.options.font.bold.name !== "" ? r.options.font.bold.name : i, r.options.font.bold.style || "bold") : c === "italic" ? e.setFont(r.options.font.regular.name, "italic") : c === "bolditalic" ? e.setFont(r.options.font.bold.name && r.options.font.bold.name !== "" ? r.options.font.bold.name : i, "bolditalic") : c === "codespan" ? (e.setFont("courier", "normal"), e.setFontSize(o * .9)) : e.setFont(r.options.font.regular.name, a);
-		let l = r.options.page.maxContentWidth - n - r.X, u = e.splitTextToSize(t, l), d = c === "codespan", f = "#EEEEEE";
-		if (r.isInlineLockActive) for (let t = 0; t < u.length; t++) {
-			if (d) {
-				let i = e.getTextWidth(u[t]) + h(e), a = m(e);
-				e.setFillColor(f), e.roundedRect(r.X + n - 1, r.Y - 1, i + 2, a + 2, 2, 2, "F"), e.setFillColor("#000000");
+	};
+	const renderTextWithStyle = (text, style) => {
+		if (style === "bold") doc.setFont(store.options.font.bold.name && store.options.font.bold.name !== "" ? store.options.font.bold.name : currentFont, store.options.font.bold.style || "bold");
+		else if (style === "italic") doc.setFont(store.options.font.regular.name, "italic");
+		else if (style === "bolditalic") doc.setFont(store.options.font.bold.name && store.options.font.bold.name !== "" ? store.options.font.bold.name : currentFont, "bolditalic");
+		else if (style === "codespan") {
+			const codeFont = store.options.font.code || {
+				name: "courier",
+				style: "normal"
+			};
+			doc.setFont(codeFont.name, codeFont.style);
+			doc.setFontSize(currentFontSize * .9);
+		} else doc.setFont(store.options.font.regular.name, currentFontStyle);
+		const availableWidth = store.options.page.maxContentWidth - indent - store.X;
+		const textLines = doc.splitTextToSize(text, availableWidth);
+		const isCodeSpan = style === "codespan";
+		const codePadding = 1;
+		const codeBgColor = "#EEEEEE";
+		if (store.isInlineLockActive) for (let i = 0; i < textLines.length; i++) {
+			if (isCodeSpan) {
+				const lineWidth = doc.getTextWidth(textLines[i]) + getCharWidth(doc);
+				const lineHeight = getCharHight(doc);
+				doc.setFillColor(codeBgColor);
+				doc.roundedRect(store.X + indent - codePadding, store.Y - codePadding, lineWidth + codePadding * 2, lineHeight + codePadding * 2, 2, 2, "F");
+				doc.setFillColor("#000000");
 			}
-			e.text(u[t], r.X + n, r.Y, {
+			doc.text(textLines[i], store.X + indent, store.Y, {
 				baseline: "top",
-				maxWidth: l
-			}), r.updateX(e.getTextDimensions(u[t]).w + (d ? 2 : 1), "add"), t < u.length - 1 && (r.updateY(m(e), "add"), r.updateX(r.options.page.xpading, "set"));
-		}
-		else if (u.length > 1) {
-			let t = u[0], i = u?.slice(1)?.join(" ");
-			if (d) {
-				let i = e.getTextWidth(t) + h(e), a = m(e);
-				e.setFillColor(f), e.roundedRect(r.X + (n >= 2 ? n + 2 : 0) - 1, r.Y - 1, i + 2, a + 2, 2, 2, "F"), e.setFillColor("#000000");
+				maxWidth: availableWidth
+			});
+			store.updateX(doc.getTextDimensions(textLines[i]).w + (isCodeSpan ? codePadding * 2 : 1), "add");
+			if (i < textLines.length - 1) {
+				store.updateY(getCharHight(doc), "add");
+				store.updateX(store.options.page.xpading, "set");
+			}
+		}
+		else if (textLines.length > 1) {
+			const firstLine = textLines[0];
+			const restContent = textLines?.slice(1)?.join(" ");
+			if (isCodeSpan) {
+				const w = doc.getTextWidth(firstLine) + getCharWidth(doc);
+				const h = getCharHight(doc);
+				doc.setFillColor(codeBgColor);
+				doc.roundedRect(store.X + (indent >= 2 ? indent + 2 : 0) - codePadding, store.Y - codePadding, w + codePadding * 2, h + codePadding * 2, 2, 2, "F");
+				doc.setFillColor("#000000");
 			}
-			e.text(t, r.X + (n >= 2 ? n + 2 * s(c) : 0), r.Y, {
+			doc.text(firstLine, store.X + (indent >= 2 ? indent + 2 * spaceMultiplier(style) : 0), store.Y, {
 				baseline: "top",
-				maxWidth: l
-			}), r.updateX(r.options.page.xpading + n), r.updateY(m(e), "add");
-			let a = r.options.page.maxContentWidth - n - r.options.page.xpading;
-			e.splitTextToSize(i, a).forEach((t) => {
-				if (d) {
-					let n = e.getTextWidth(t) + h(e), i = m(e);
-					e.setFillColor(f), e.roundedRect(r.X + h(e) - 1, r.Y - 1, n + 2, i + 2, 2, 2, "F"), e.setFillColor("#000000");
+				maxWidth: availableWidth
+			});
+			store.updateX(store.options.page.xpading + indent);
+			store.updateY(getCharHight(doc), "add");
+			const maxWidthForRest = store.options.page.maxContentWidth - indent - store.options.page.xpading;
+			doc.splitTextToSize(restContent, maxWidthForRest).forEach((line) => {
+				if (isCodeSpan) {
+					const w = doc.getTextWidth(line) + getCharWidth(doc);
+					const h = getCharHight(doc);
+					doc.setFillColor(codeBgColor);
+					doc.roundedRect(store.X + getCharWidth(doc) - codePadding, store.Y - codePadding, w + codePadding * 2, h + codePadding * 2, 2, 2, "F");
+					doc.setFillColor("#000000");
 				}
-				e.text(t, r.X + h(e), r.Y, {
+				doc.text(line, store.X + getCharWidth(doc), store.Y, {
 					baseline: "top",
-					maxWidth: a
+					maxWidth: maxWidthForRest
 				});
 			});
 		} else {
-			if (d) {
-				let i = e.getTextWidth(t) + h(e), a = m(e);
-				e.setFillColor(f), e.roundedRect(r.X + n - 1, r.Y - 1, i + 2, a + 2, 2, 2, "F"), e.setFillColor("#000000");
+			if (isCodeSpan) {
+				const w = doc.getTextWidth(text) + getCharWidth(doc);
+				const h = getCharHight(doc);
+				doc.setFillColor(codeBgColor);
+				doc.roundedRect(store.X + indent - codePadding, store.Y - codePadding, w + codePadding * 2, h + codePadding * 2, 2, 2, "F");
+				doc.setFillColor("#000000");
 			}
-			e.text(t, r.X + n, r.Y, {
+			doc.text(text, store.X + indent, store.Y, {
 				baseline: "top",
-				maxWidth: l
-			}), r.updateX(e.getTextDimensions(t).w + (n >= 2 ? t.split(" ").length + 2 : 2) * s(c) * .5 + (d ? 2 : 0), "add");
+				maxWidth: availableWidth
+			});
+			store.updateX(doc.getTextDimensions(text).w + (indent >= 2 ? text.split(" ").length + 2 : 2) * spaceMultiplier(style) * .5 + (isCodeSpan ? codePadding * 2 : 0), "add");
 		}
 	};
-	if (t.type === "text" && t.items && t.items.length > 0) for (let e of t.items) if (e.type === "codespan") c(e.content || "", "codespan");
-	else if (e.type === "em" || e.type === "strong") {
-		let t = e.type === "em" ? "italic" : "bold";
-		if (e.items && e.items.length > 0) for (let n of e.items) n.type === "strong" && t === "italic" || n.type === "em" && t === "bold" ? c(n.content || "", "bolditalic") : c(n.content || "", t);
-		else c(e.content || "", t);
-	} else c(e.content || "", "normal");
-	else t.type === "em" ? c(t.content || "", "italic") : t.type === "strong" ? c(t.content || "", "bold") : t.type === "codespan" ? c(t.content || "", "codespan") : c(t.content || "", "normal");
-	e.setFont(i, a), e.setFontSize(o);
-}, M = (e, t, n, r) => {
-	let i = e.getFont().fontName, a = e.getFont().fontStyle, o = e.getFontSize(), s = e.getTextColor(), c = r.options.link?.linkColor || [
+	if (element.type === "text" && element.items && element.items.length > 0) for (const item of element.items) if (item.type === "codespan") renderTextWithStyle(item.content || "", "codespan");
+	else if (item.type === "em" || item.type === "strong") {
+		const baseStyle = item.type === "em" ? "italic" : "bold";
+		if (item.items && item.items.length > 0) for (const subItem of item.items) if (subItem.type === "strong" && baseStyle === "italic") renderTextWithStyle(subItem.content || "", "bolditalic");
+		else if (subItem.type === "em" && baseStyle === "bold") renderTextWithStyle(subItem.content || "", "bolditalic");
+		else renderTextWithStyle(subItem.content || "", baseStyle);
+		else renderTextWithStyle(item.content || "", baseStyle);
+	} else renderTextWithStyle(item.content || "", "normal");
+	else if (element.type === "em") renderTextWithStyle(element.content || "", "italic");
+	else if (element.type === "strong") renderTextWithStyle(element.content || "", "bold");
+	else if (element.type === "codespan") renderTextWithStyle(element.content || "", "codespan");
+	else renderTextWithStyle(element.content || "", "normal");
+	doc.setFont(currentFont, currentFontStyle);
+	doc.setFontSize(currentFontSize);
+};
+//#endregion
+//#region src/renderer/components/link.ts
+/**
+* Renders link elements with proper styling and URL handling.
+* Links are rendered in blue color and underlined to distinguish them from regular text.
+*/
+const renderLink = (doc, element, indent, store) => {
+	const currentFont = doc.getFont().fontName;
+	const currentFontStyle = doc.getFont().fontStyle;
+	const currentFontSize = doc.getFontSize();
+	const currentTextColor = doc.getTextColor();
+	const linkColor = store.options.link?.linkColor || [
 		0,
 		0,
 		255
 	];
-	e.setTextColor(...c);
-	let l = r.options.page.maxContentWidth - n - r.X, u = t.text || t.content || "", d = t.href || "", f = e.splitTextToSize(u, l);
-	if (r.isInlineLockActive) for (let t = 0; t < f.length; t++) {
-		let i = e.getTextDimensions(f[t]).w, a = m(e) / 2;
-		e.link(r.X + n, r.Y, i, a, { url: d }), e.text(f[t], r.X + n, r.Y, {
+	doc.setTextColor(...linkColor);
+	const availableWidth = store.options.page.maxContentWidth - indent - store.X;
+	const linkText = element.text || element.content || "";
+	const linkUrl = element.href || "";
+	const textLines = doc.splitTextToSize(linkText, availableWidth);
+	if (store.isInlineLockActive) for (let i = 0; i < textLines.length; i++) {
+		const textWidth = doc.getTextDimensions(textLines[i]).w;
+		const textHeight = getCharHight(doc) / 2;
+		doc.link(store.X + indent, store.Y, textWidth, textHeight, { url: linkUrl });
+		doc.text(textLines[i], store.X + indent, store.Y, {
 			baseline: "top",
-			maxWidth: l
-		}), r.updateX(i + 1, "add"), r.X + i > r.options.page.maxContentWidth - n && (r.updateY(a, "add"), r.updateX(r.options.page.xpading + n, "set")), t < f.length - 1 && (r.updateY(a, "add"), r.updateX(r.options.page.xpading + n, "set"));
+			maxWidth: availableWidth
+		});
+		store.updateX(textWidth + 1, "add");
+		if (store.X + textWidth > store.options.page.maxContentWidth - indent) {
+			store.updateY(textHeight, "add");
+			store.updateX(store.options.page.xpading + indent, "set");
+		}
+		if (i < textLines.length - 1) {
+			store.updateY(textHeight, "add");
+			store.updateX(store.options.page.xpading + indent, "set");
+		}
 	}
-	else if (f.length > 1) {
-		let t = f[0], i = f?.slice(1)?.join(" "), a = e.getTextDimensions(t).w, o = m(e) / 2;
-		e.link(r.X + n, r.Y, a, o, { url: d }), e.text(t, r.X + n, r.Y, {
+	else if (textLines.length > 1) {
+		const firstLine = textLines[0];
+		const restContent = textLines?.slice(1)?.join(" ");
+		const firstLineWidth = doc.getTextDimensions(firstLine).w;
+		const textHeight = getCharHight(doc) / 2;
+		doc.link(store.X + indent, store.Y, firstLineWidth, textHeight, { url: linkUrl });
+		doc.text(firstLine, store.X + indent, store.Y, {
 			baseline: "top",
-			maxWidth: l
-		}), r.updateX(r.options.page.xpading + n), r.updateY(o, "add");
-		let s = r.options.page.maxContentWidth - n - r.options.page.xpading;
-		e.splitTextToSize(i, s).forEach((t) => {
-			let n = e.getTextDimensions(t).w;
-			e.link(r.X + h(e), r.Y, n, o, { url: d }), e.text(t, r.X + h(e), r.Y, {
+			maxWidth: availableWidth
+		});
+		store.updateX(store.options.page.xpading + indent);
+		store.updateY(textHeight, "add");
+		const maxWidthForRest = store.options.page.maxContentWidth - indent - store.options.page.xpading;
+		doc.splitTextToSize(restContent, maxWidthForRest).forEach((line) => {
+			const lineWidth = doc.getTextDimensions(line).w;
+			doc.link(store.X + getCharWidth(doc), store.Y, lineWidth, textHeight, { url: linkUrl });
+			doc.text(line, store.X + getCharWidth(doc), store.Y, {
 				baseline: "top",
-				maxWidth: s
+				maxWidth: maxWidthForRest
 			});
 		});
 	} else {
-		let t = e.getTextDimensions(u).w, i = m(e) / 2;
-		e.link(r.X + n, r.Y, t, i, { url: d }), e.text(u, r.X + n, r.Y, {
+		const textWidth = doc.getTextDimensions(linkText).w;
+		const textHeight = getCharHight(doc) / 2;
+		doc.link(store.X + indent, store.Y, textWidth, textHeight, { url: linkUrl });
+		doc.text(linkText, store.X + indent, store.Y, {
 			baseline: "top",
-			maxWidth: l
-		}), r.updateX(t + 2, "add");
-	}
-	e.setFont(i, a), e.setFontSize(o), e.setTextColor(s);
-}, N = (e, t, n, r, i) => {
-	let a = r.options, o = n + 1, s = r.X + n * a.page.indent, c = r.Y, l = s + a.page.indent / 2, u = c, d = e.internal.getCurrentPageInfo().pageNumber;
-	t.items && t.items.length > 0 && t.items.forEach((e) => {
-		i(e, o, r);
+			maxWidth: availableWidth
+		});
+		store.updateX(textWidth + 2, "add");
+	}
+	doc.setFont(currentFont, currentFontStyle);
+	doc.setFontSize(currentFontSize);
+	doc.setTextColor(currentTextColor);
+};
+//#endregion
+//#region src/renderer/components/blockquote.ts
+const renderBlockquote = (doc, element, indentLevel, store, renderElement) => {
+	const options = store.options;
+	const blockquoteIndent = indentLevel + 1;
+	const currentX = store.X + indentLevel * options.page.indent;
+	const currentY = store.Y;
+	const barX = currentX + options.page.indent / 2;
+	const startY = currentY;
+	const startPage = doc.internal.getCurrentPageInfo().pageNumber;
+	if (element.items && element.items.length > 0) element.items.forEach((item) => {
+		renderElement(item, blockquoteIndent, store);
 	});
-	let f = r.Y, p = e.internal.getCurrentPageInfo().pageNumber;
-	e.setDrawColor(100), e.setLineWidth(1);
-	for (let t = d; t <= p; t++) {
-		e.setPage(t);
-		let n = t === d, r = t === p, i = n ? u : a.page.topmargin, o = r ? f : a.page.maxContentHeight;
-		e.line(l, i, l, o);
-	}
-	r.recordContentY(), e.setPage(p);
-}, P = (e) => {
-	if (e.data) {
-		if (e.data.startsWith("data:image/png")) return "PNG";
-		if (e.data.startsWith("data:image/jpeg") || e.data.startsWith("data:image/jpg")) return "JPEG";
-		if (e.data.startsWith("data:image/webp") || e.data.startsWith("data:image/webp")) return "WEBP";
-		if (e.data.startsWith("data:image/gif")) return "GIF";
-	}
-	if (e.src) {
-		let t = e.src.split("?")[0].split("#")[0].split(".").pop()?.toUpperCase();
-		if (t && [
+	const endY = store.Y;
+	const endPage = doc.internal.getCurrentPageInfo().pageNumber;
+	doc.setDrawColor(100);
+	doc.setLineWidth(1);
+	for (let p = startPage; p <= endPage; p++) {
+		doc.setPage(p);
+		const isStart = p === startPage;
+		const isEnd = p === endPage;
+		const lineTop = isStart ? startY : options.page.topmargin;
+		const lineBottom = isEnd ? endY : options.page.maxContentHeight;
+		doc.line(barX, lineTop, barX, lineBottom);
+	}
+	store.recordContentY();
+	doc.setPage(endPage);
+};
+//#endregion
+//#region src/renderer/components/image.ts
+/**
+* Detects the image format from element data and source.
+*/
+const detectImageFormat = (element) => {
+	if (element.data) {
+		if (element.data.startsWith("data:image/png")) return "PNG";
+		if (element.data.startsWith("data:image/jpeg") || element.data.startsWith("data:image/jpg")) return "JPEG";
+		if (element.data.startsWith("data:image/webp")) return "WEBP";
+		if (element.data.startsWith("data:image/webp")) return "WEBP";
+		if (element.data.startsWith("data:image/gif")) return "GIF";
+	}
+	if (element.src) {
+		const ext = element.src.split("?")[0].split("#")[0].split(".").pop()?.toUpperCase();
+		if (ext && [
 			"PNG",
 			"JPEG",
 			"JPG",
 			"WEBP",
 			"GIF"
-		].includes(t)) return t === "JPG" ? "JPEG" : t;
+		].includes(ext)) return ext === "JPG" ? "JPEG" : ext;
 	}
 	return "JPEG";
-}, F = (e, t, n, r) => {
-	if (!t.data) return;
-	let i = r.options, a = i.page.unit || "mm", o = n * i.page.indent, s = i.page.maxContentWidth - o, c = r.X + o, l = r.Y;
+};
+/**
+* Renders an image element into the jsPDF document with smart sizing and alignment.
+*
+* Sizing logic (in order of priority):
+* 1. If both width & height are specified by user → convert from px, use as-is
+* 2. If only width is specified → convert from px, calculate height from aspect ratio
+* 3. If only height is specified → convert from px, calculate width from aspect ratio
+* 4. If nothing specified → use intrinsic dimensions (converted from px to doc units)
+* 5. Always clamp to page bounds (scale down proportionally if needed)
+*
+* Alignment: 'left' (default) | 'center' | 'right'
+* Can be set per-image via markdown attributes or globally via RenderOption.image.defaultAlign
+*/
+const renderImage = (doc, element, indentLevel, store) => {
+	if (!element.data) return;
+	const options = store.options;
+	const docUnit = options.page.unit || "mm";
+	const indent = indentLevel * options.page.indent;
+	const maxWidth = options.page.maxContentWidth - indent;
+	const pageLeftX = store.X + indent;
+	let currentY = store.Y;
 	try {
-		let { finalWidth: n, finalHeight: o } = x(e, t, s, i.page.maxContentHeight - i.page.topmargin, a);
-		l + o > i.page.maxContentHeight && (_(e, r), l = r.Y);
-		let u = t.align || i.image?.defaultAlign || "left", d;
-		switch (u) {
+		const { finalWidth, finalHeight } = calculateImageDimensions(doc, element, maxWidth, options.page.maxContentHeight - options.page.topmargin, docUnit);
+		if (currentY + finalHeight > options.page.maxContentHeight) {
+			HandlePageBreaks(doc, store);
+			currentY = store.Y;
+		}
+		const align = element.align || options.image?.defaultAlign || "left";
+		let drawX;
+		switch (align) {
 			case "right":
-				d = c + s - n;
+				drawX = pageLeftX + maxWidth - finalWidth;
 				break;
 			case "center":
-				d = c + (s - n) / 2;
+				drawX = pageLeftX + (maxWidth - finalWidth) / 2;
 				break;
 			default:
-				d = c;
+				drawX = pageLeftX;
 				break;
 		}
-		let f = P(t);
-		n > 0 && o > 0 && e.addImage(t.data, f, d, l, n, o), r.updateY(o, "add"), r.recordContentY();
+		const imgFormat = detectImageFormat(element);
+		if (finalWidth > 0 && finalHeight > 0) doc.addImage(element.data, imgFormat, drawX, currentY, finalWidth, finalHeight);
+		store.updateY(finalHeight, "add");
+		store.recordContentY();
 	} catch (e) {
 		console.warn("Failed to render image", e);
 	}
-}, I = () => {
-	let e = t;
-	if (typeof t == "function") return t;
-	if (typeof e.default == "function") return e.default;
-	if (typeof e.autoTable == "function") return e.autoTable;
-	throw Error("Could not resolve jspdf-autotable export. Expected a callable export.");
-}, L = (e, t, n, r) => {
-	if (!t.header || !t.rows) return;
-	let i = r.options, a = i.page.xmargin + n * i.page.indent, o = [t.header.map((e) => e.content || "")], s = t.rows.map((e) => e.map((e) => e.content || "")), c = i.table || {};
-	I()(e, {
-		head: o,
-		body: s,
-		startY: r.Y,
+};
+//#endregion
+//#region src/renderer/components/table.ts
+const resolveAutoTable = () => {
+	const autoTableCandidate = autoTable;
+	if (typeof autoTable === "function") return autoTable;
+	if (typeof autoTableCandidate.default === "function") return autoTableCandidate.default;
+	if (typeof autoTableCandidate.autoTable === "function") return autoTableCandidate.autoTable;
+	throw new Error("Could not resolve jspdf-autotable export. Expected a callable export.");
+};
+const renderTable = (doc, element, indentLevel, store) => {
+	if (!element.header || !element.rows) return;
+	const options = store.options;
+	const marginLeft = options.page.xmargin + indentLevel * options.page.indent;
+	const head = [element.header.map((h) => h.content || "")];
+	const body = element.rows.map((row) => row.map((cell) => cell.content || ""));
+	const userTableOptions = options.table || {};
+	resolveAutoTable()(doc, {
+		head,
+		body,
+		startY: store.Y,
 		margin: {
-			left: a,
-			right: i.page.xmargin
+			left: marginLeft,
+			right: options.page.xmargin
 		},
-		...c,
-		didDrawPage: (e) => {
-			c.didDrawPage && c.didDrawPage(e);
+		...userTableOptions,
+		didDrawPage: (data) => {
+			if (userTableOptions.didDrawPage) userTableOptions.didDrawPage(data);
 		},
-		didDrawCell: (e) => {
-			c.didDrawCell && c.didDrawCell(e);
+		didDrawCell: (data) => {
+			if (userTableOptions.didDrawCell) userTableOptions.didDrawCell(data);
 		}
 	});
-	let l = e.lastAutoTable?.finalY;
-	typeof l == "number" && (r.updateY(l + i.page.lineSpace, "set"), r.updateX(i.page.xpading, "set"), r.recordContentY());
-}, R = class {
-	constructor(e) {
+	const finalY = doc.lastAutoTable?.finalY;
+	if (typeof finalY === "number") {
+		store.updateY(finalY + options.page.lineSpace, "set");
+		store.updateX(options.page.xpading, "set");
+		store.recordContentY();
+	}
+};
+//#endregion
+//#region src/store/renderStore.ts
+var RenderStore = class {
+	constructor(options) {
 		this.cursor = {
 			x: 0,
 			y: 0
-		}, this.lastContentY_ = 0, this.inlineLock = !1, this.options_ = e, this.cursor = {
-			x: e.cursor.x,
-			y: e.cursor.y
-		}, this.lastContentY_ = e.cursor.y;
+		};
+		this.lastContentY_ = 0;
+		this.inlineLock = false;
+		this.options_ = options;
+		this.cursor = {
+			x: options.cursor.x,
+			y: options.cursor.y
+		};
+		this.lastContentY_ = options.cursor.y;
 	}
 	getCursor() {
 		return this.cursor;
 	}
-	setCursor(e) {
-		this.cursor = e;
+	setCursor(newCursor) {
+		this.cursor = newCursor;
 	}
 	get options() {
 		return this.options_;
@@ -837,20 +1490,43 @@ var n = /* @__PURE__ */ function(e) {
 		return this.inlineLock;
 	}
 	activateInlineLock() {
-		this.inlineLock = !0;
+		this.inlineLock = true;
 	}
 	deactivateInlineLock() {
-		this.inlineLock = !1;
+		this.inlineLock = false;
 	}
-	updateX(e, t = "set") {
-		t === "set" ? this.cursor.x = e : t === "add" && (this.cursor.x += e);
+	/**
+	* Updates the x pointer of the cursor.
+	* @param value The value to set or add.
+	* @param operation 'set' to assign a new value, 'add' to increment the current value.
+	* @default operation = 'set'
+	*/
+	updateX(value, operation = "set") {
+		if (operation === "set") this.cursor.x = value;
+		else if (operation === "add") this.cursor.x += value;
 	}
-	updateY(e, t = "set") {
-		t === "set" ? this.cursor.y = e : t === "add" && (this.cursor.y += e);
+	/**
+	* Updates the y pointer of the cursor.
+	* @param value The value to set or add.
+	* @param operation 'set' to assign a new value, 'add' to increment the current value.
+	* @default operation = 'set'
+	*/
+	updateY(value, operation = "set") {
+		if (operation === "set") this.cursor.y = value;
+		else if (operation === "add") this.cursor.y += value;
 	}
-	recordContentY(e) {
-		this.lastContentY_ = e === void 0 ? this.cursor.y : e;
+	/**
+	* Records a Y position as the bottom of rendered content.
+	* This is useful for container components (like blockquotes) to know
+	* where their actual text content ends, ignoring any trailing margins.
+	* @param specificY Optional Y value to record. Defaults to current cursor Y.
+	*/
+	recordContentY(specificY) {
+		this.lastContentY_ = specificY !== void 0 ? specificY : this.cursor.y;
 	}
+	/**
+	* Gets the last Y position recorded as content bottom.
+	*/
 	get lastContentY() {
 		return this.lastContentY_;
 	}
@@ -860,7 +1536,10 @@ var n = /* @__PURE__ */ function(e) {
 	get Y() {
 		return this.cursor.y;
 	}
-}, z = {
+};
+//#endregion
+//#region src/utils/options-validation.ts
+const defaultOptions = {
 	page: {
 		indent: 10,
 		maxContentWidth: 190,
@@ -887,88 +1566,111 @@ var n = /* @__PURE__ */ function(e) {
 		light: {
 			name: "helvetica",
 			style: "light"
+		},
+		code: {
+			name: "courier",
+			style: "normal"
 		}
 	},
 	image: { defaultAlign: "left" }
-}, B = (e) => {
-	if (!e) throw Error("RenderOption is required");
-	let t = {
-		...z.page,
-		...e.page
-	}, n = {
-		...z.font,
-		...e.font
-	}, r = {
-		...z.image,
-		...e.image
+};
+const validateOptions = (options) => {
+	if (!options) throw new Error("RenderOption is required");
+	const mergedPage = {
+		...defaultOptions.page,
+		...options.page
+	};
+	const mergedFont = {
+		...defaultOptions.font,
+		...options.font
+	};
+	const mergedImage = {
+		...defaultOptions.image,
+		...options.image
 	};
-	return t.maxContentWidth ||= 190, t.maxContentHeight ||= 277, {
-		...e,
-		page: t,
-		font: n,
-		image: r
+	if (!mergedPage.maxContentWidth) mergedPage.maxContentWidth = 190;
+	if (!mergedPage.maxContentHeight) mergedPage.maxContentHeight = 277;
+	return {
+		...options,
+		page: mergedPage,
+		font: mergedFont,
+		image: mergedImage
 	};
-}, V = async (e, t, r) => {
-	let i = B(r), a = new R(i), o = await d(t);
-	await S(o);
-	let s = (t, r = 0, a, o = !1, c = 0, l = !1) => {
-		let u = r * i.page.indent;
-		switch (t.type) {
-			case n.Heading:
-				g(e, t, u, a, s);
+};
+//#endregion
+//#region src/renderer/MdTextRender.ts
+/**
+* Renders parsed markdown text into jsPDF document.
+*
+* @param doc - The jsPDF document.
+* @param text - The markdown content to render.
+* @param options - The render options (fonts, page margins, etc.).
+*/
+const MdTextRender = async (doc, text, options) => {
+	const validOptions = validateOptions(options);
+	const store = new RenderStore(validOptions);
+	const parsedElements = await MdTextParser(text);
+	await prefetchImages(parsedElements);
+	const renderElement = (element, indentLevel = 0, store, hasRawBullet = false, start = 0, ordered = false) => {
+		const indent = indentLevel * validOptions.page.indent;
+		switch (element.type) {
+			case "heading":
+				renderHeading(doc, element, indent, store, renderElement);
 				break;
-			case n.Paragraph:
-				T(e, t, u, a, s);
+			case "paragraph":
+				renderParagraph(doc, element, indent, store, renderElement);
 				break;
-			case n.List:
-				E(e, t, r, a, s);
+			case "list":
+				renderList(doc, element, indentLevel, store, renderElement);
 				break;
-			case n.ListItem:
-				D(e, t, r, a, s, c, l);
+			case "list_item":
+				renderListItem(doc, element, indentLevel, store, renderElement, start, ordered);
 				break;
-			case n.Hr:
-				k(e, a);
+			case "hr":
+				renderHR(doc, store);
 				break;
-			case n.Code:
-				A(e, t, r, a);
+			case "code":
+				renderCodeBlock(doc, element, indentLevel, store);
 				break;
-			case n.Strong:
-			case n.Em:
-			case n.CodeSpan:
-				j(e, t, u, a);
+			case "strong":
+			case "em":
+			case "codespan":
+				renderInlineText(doc, element, indent, store);
 				break;
-			case n.Link:
-				M(e, t, u, a);
+			case "link":
+				renderLink(doc, element, indent, store);
 				break;
-			case n.Blockquote:
-				N(e, t, r, a, s);
+			case "blockquote":
+				renderBlockquote(doc, element, indentLevel, store, renderElement);
 				break;
-			case n.Image:
-				F(e, t, r, a);
+			case "image":
+				renderImage(doc, element, indentLevel, store);
 				break;
-			case n.Br: {
-				a.updateX(i.page.xpading, "set");
-				let t = m(e) * i.page.defaultLineHeightFactor;
-				a.Y + t > i.page.maxContentHeight ? _(e, a) : a.updateY(t, "add"), a.recordContentY();
+			case "br": {
+				store.updateX(validOptions.page.xpading, "set");
+				const brHeight = getCharHight(doc) * validOptions.page.defaultLineHeightFactor;
+				if (store.Y + brHeight > validOptions.page.maxContentHeight) HandlePageBreaks(doc, store);
+				else store.updateY(brHeight, "add");
+				store.recordContentY();
 				break;
 			}
-			case n.Table:
-				L(e, t, r, a);
+			case "table":
+				renderTable(doc, element, indentLevel, store);
 				break;
-			case n.Raw:
-			case n.Text:
-				O(e, t, r, a, o, s, c, l, i.content?.textAlignment === "justify");
+			case "raw":
+			case "text":
+				renderRawItem(doc, element, indentLevel, store, hasRawBullet, renderElement, start, ordered, validOptions.content?.textAlignment === "justify");
 				break;
 			default:
-				console.warn(`Warning: Unsupported element type encountered: ${t.type}. 
+				console.warn(`Warning: Unsupported element type encountered: ${element.type}. 
                     If you believe this element type should be supported, please create an issue at:
                     https://github.com/JeelGajera/jspdf-md-renderer/issues
                     with details of the element and expected behavior. Thanks for helping to improve this library!`);
 				break;
 		}
 	};
-	for (let e of o) s(e, 0, a);
-	i.endCursorYHandler(a.Y);
+	for (const item of parsedElements) renderElement(item, 0, store);
+	validOptions.endCursorYHandler(store.Y);
 };
 //#endregion
-export { d as MdTextParser, V as MdTextRender };
+export { MdTextParser, MdTextRender };