sommark 2.3.1 → 3.0.0

package/core/transpiler.js

@@ -3,210 +3,106 @@ import escapeHTML from "../helpers/escapeHTML.js";
 import { transpilerError } from "./errors.js";
 import { textFormat, htmlFormat, markdownFormat, mdxFormat, jsonFormat } from "./formats.js";
 
-const expose_for_fmts = [jsonFormat];
+const BODY_PLACEHOLDER = `__SOMMARK_BODY_PLACEHOLDER_${Math.random().toString(36).slice(2)}__`;
 
 // ========================================================================== //
 //  Extracting target identifier                                              //
 // ========================================================================== //
 function matchedValue(outputs, targetId) {
-	let result;
-	for (const outputValue of outputs) {
-		if (typeof outputValue.id === "string") {
-			if (outputValue.id === targetId) {
-				result = outputValue;
-				break;
-			}
-		} else if (Array.isArray(outputValue.id)) {
-			for (const id of outputValue.id) {
-				if (id === targetId) {
-					result = outputValue;
-					break;
-				}
-			}
+	if (!outputs || !targetId) return undefined;
+	return outputs.find(output => {
+		if (Array.isArray(output.id)) {
+			return output.id.some(id => id === targetId);
 		}
-	}
-	return result;
+		return typeof output.id === "string" && output.id === targetId;
+	});
 }
 
-function validateRules(target, args, content, type = null) {
-	if (!target || !target.options || !target.options.rules) {
-		return;
-	}
-	const { rules } = target.options;
-	const { id } = target;
-
-	// Validate Args
-	if (args && rules.args) {
-		const { min, max, required, includes } = rules.args;
-		const argKeys = Object.keys(args).filter(key => isNaN(parseInt(key))); // Get named keys
-		const argValues = Object.values(args);
-		const argCount = args.length;
-
-		// Min Check
-		if (min && argCount < min) {
-			transpilerError([
-				"{line}<$red:Validation Error:$> ",
-				`<$yellow:Identifier$> <$blue:'${Array.isArray(id) ? id.join(" | ") : id}'$> <$yellow:requires at least$> <$green:${min}$> <$yellow:argument(s). Found$> <$red:${argCount}$>{line}`
-			]);
-		}
-		// Max Check
-		if (max && argCount > max) {
-			transpilerError([
-				"{line}<$red:Validation Error:$> ",
-				`<$yellow:Identifier$> <$blue:'${Array.isArray(id) ? id.join(" | ") : id}'$> <$yellow:accepts at most$> <$green:${max}$> <$yellow:argument(s). Found$> <$red:${argCount}$>{line}`
-			]);
-		}
-		// Required Keys Check
-		if (required && Array.isArray(required)) {
-			const missingKeys = required.filter(key => !Object.prototype.hasOwnProperty.call(args, key));
-			if (missingKeys.length > 0) {
-				transpilerError([
-					"{line}<$red:Validation Error:$> ",
-					`<$yellow:Identifier$> <$blue:'${Array.isArray(id) ? id.join(" | ") : id}'$> <$yellow:is missing required argument(s):$> <$red:${missingKeys.join(", ")}$>{line}`
-				]);
-			}
-		}
-		// Includes Keys Check
-		if (includes && Array.isArray(includes)) {
-			const invalidKeys = argKeys.filter(key => !includes.includes(key));
-			if (invalidKeys.length > 0) {
-				transpilerError([
-					"{line}<$red:Validation Error:$> ",
-					`<$yellow:Identifier$> <$blue:'${Array.isArray(id) ? id.join(" | ") : id}'$> <$yellow:contains invalid argument key(s):$> <$red:${invalidKeys.join(", ")}$>`,
-					`{N}<$yellow:Allowed keys are:$> <$green:${includes.join(", ")}$>{line}`
-				]);
-			}
-		}
-	}
-
-	// Validate Content
-	if (content && rules.content) {
-		const { maxLength } = rules.content;
-		if (maxLength && content.length > maxLength) {
-			transpilerError([
-				"{line}<$red:Validation Error:$> ",
-				`<$yellow:Identifier$> <$blue:'${Array.isArray(id) ? id.join(" | ") : id}'$> <$yellow:content exceeds maximum length of$> <$green:${maxLength}$> <$yellow:characters. Found$> <$red:${content.length}$>{line}`
-			]);
-		}
-	}
-	// Validate is_Self_closing
-	if (id && rules.is_Self_closing) {
-		if (content) {
-			transpilerError([
-				"{line}<$red:Validation Error:$> ",
-				`<$yellow:Identifier$> <$blue:'${Array.isArray(id) ? id.join(" | ") : id}'$> <$yellow:is self-closing tag and is not allowed to have a content | children$>{line}`
-			]);
-		}
-	}
-	// Validate element type
-	if (id && rules.type && type) {
-		if (rules.type !== type) {
-			transpilerError([
-				"{line}<$red:Validation Error:$> ",
-				`<$yellow:Identifier$> <$blue:'${Array.isArray(id) ? id.join(" | ") : id}'$> <$yellow:is expected to be type$> <$green:'${rules.type}'$>{N}<$cyan:Received type: $> <$magenta:'${type}'$>{line}`
-			]);
-		}
-	}
-}
-// ========================================================================== //
-//  +++++++++++++++++++++++++++++                                             //
-// ========================================================================== //
 async function generateOutput(ast, i, format, mapper_file) {
 	const node = Array.isArray(ast) ? ast[i] : ast;
 	let result = "";
 	let context = "";
 	let target = mapper_file ? matchedValue(mapper_file.outputs, node.id) : null;
-	const block_formats = [htmlFormat, mdxFormat, jsonFormat];
+	
+	if (!target) {
+		target = mapper_file.getUnknownTag(node);
+	}
+
 	if (target) {
-		validateRules(target, node.args, "", node.type);
-		const placeholder = format === mdxFormat && node.body.length > 0 ? "\n<%smark>\n" : "<%smark>";
-		result += block_formats.includes(format)
-			? `${format === mdxFormat ? "\n" : ""}${target.render({ args: node.args, content: placeholder, ast: expose_for_fmts.includes(format) ? ast[i] : null }) + (format === mdxFormat ? "\n" : "")}`
-			: target.render({ args: node.args, content: "" }) + (format === mdxFormat ? "\n" : "");
-		// Body nodes
+		// ========================================================================== //
+		//  Always use placeholders for blocks to support wrapping                      //
+		// ========================================================================== //
+		const placeholder = format === mdxFormat && node.body.length > 0 ? `\n${BODY_PLACEHOLDER}\n` : BODY_PLACEHOLDER;
+		
+		result += target.render.call(mapper_file, { args: node.args, content: placeholder, ast: node });
+		if (format === mdxFormat) result = "\n" + result + "\n";
+
+		// ========================================================================== //
+		//  Body nodes                                                                //
+		// ========================================================================== //
 		for (let j = 0; j < node.body.length; j++) {
 			const body_node = node.body[j];
 			switch (body_node.type) {
-				// ========================================================================== //
-				//  Text                                                                      //
-				// ========================================================================== //
 				case TEXT:
-					validateRules(target, body_node.args, body_node.text);
-					const shouldEscape = target && target.options && target.options.escape === false ? false : true;
-					context += [htmlFormat, mdxFormat].includes(format) && shouldEscape ? escapeHTML(body_node.text) : body_node.text;
+					const shouldEscapeText = target.options?.escape !== false;
+					context += (format === htmlFormat || format === mdxFormat) && shouldEscapeText ? escapeHTML(body_node.text) : body_node.text;
 					break;
-				// ========================================================================== //
-				//  Inline                                                                    //
-				// ========================================================================== //
+
 				case INLINE:
-					target = matchedValue(mapper_file.outputs, body_node.id);
-					if (target) {
-						validateRules(target, body_node.args, body_node.value, body_node.type);
+					let inlineTarget = matchedValue(mapper_file.outputs, body_node.id);
+					if (!inlineTarget) {
+						inlineTarget = mapper_file.getUnknownTag(body_node);
+					}
+
+					if (inlineTarget) {
+						const shouldEscapeInline = inlineTarget.options?.escape !== false;
 						context +=
-							target.render({
+							inlineTarget.render.call(mapper_file, {
 								args: body_node.args.length > 0 ? body_node.args : [],
-								content: format === htmlFormat || format === mdxFormat ? escapeHTML(body_node.value) : body_node.value
+								content: (format === htmlFormat || format === mdxFormat) && shouldEscapeInline ? escapeHTML(body_node.value) : body_node.value,
+								ast: body_node
 							}) + (format === mdxFormat ? "\n" : "");
 					}
 					break;
-				// ========================================================================== //
-				//  Atblock                                                                   //
-				// ========================================================================== //
+
 				case ATBLOCK:
-					target = matchedValue(mapper_file.outputs, body_node.id);
-					if (target) {
-						validateRules(target, body_node.args, body_node.content, body_node.type);
-						// Escape logic: fallback to options.escape, default true
-						const shouldEscape = target.options?.escape ?? true;
-						if (shouldEscape) {
-							body_node.content = escapeHTML(body_node.content);
+					let atTarget = matchedValue(mapper_file.outputs, body_node.id);
+					if (!atTarget) {
+						atTarget = mapper_file.getUnknownTag(body_node);
+					}
+					if (atTarget) {
+						const shouldEscapeAt = atTarget.options?.escape !== false;
+						let content = body_node.content;
+						if (shouldEscapeAt && (format === htmlFormat || format === mdxFormat)) {
+							content = escapeHTML(content);
 						}
-						context += target.render({ args: body_node.args, content: body_node.content }) + (format === mdxFormat ? "\n" : "");
+						const rendered = atTarget.render.call(mapper_file, { args: body_node.args, content, ast: body_node }).trimEnd() + "\n";
+						context = context.trim() ? context.trimEnd() + "\n" + rendered : context + rendered;
 					}
 					break;
-				// ========================================================================== //
-				//  Comment                                                                   //
-				// ========================================================================== //
+
 				case COMMENT:
-					if (format === htmlFormat || format === markdownFormat) {
-						context += " ".repeat(body_node.depth) + `\n<!--${body_node.text.replace("#", "")}-->\n`;
-					} else if (format === mdxFormat) {
-						context += " ".repeat(body_node.depth) + `\n{/*${body_node.text.replace("#", "")} */}\n`;
-					}
+					context += " ".repeat(body_node.depth) + `\n${mapper_file.comment(body_node.text)}\n`;
 					break;
-				// ========================================================================== //
-				//  Block                                                                     //
-				// ========================================================================== //
+
 				case BLOCK:
-					target = matchedValue(mapper_file.outputs, body_node.id);
-					context += await generateOutput(body_node, i, format, mapper_file);
+					const blockOutput = await generateOutput(body_node, i, format, mapper_file);
+					context = context.trim() ? context.trimEnd() + "\n" + blockOutput : context + blockOutput;
 					break;
 			}
 		}
 
-		if (format === htmlFormat || format === mdxFormat || format === jsonFormat) {
-			result = result.replace("<%smark>", context);
-		} else {
-			result += context;
-		}
+		result = result.replaceAll(BODY_PLACEHOLDER, context);
 	}
-	// ========================================================================== //
-	// Text                                                                       //
-	// ========================================================================== //
 	else if (format === textFormat) {
 		for (const body_node of node.body) {
 			switch (body_node.type) {
-				case TEXT:
-					context += body_node.text;
-					break;
-				case INLINE:
-					context += body_node.value + " ";
-					break;
-				case ATBLOCK:
-					context += body_node.content;
-					break;
+				case TEXT: context += body_node.text; break;
+				case INLINE: context += body_node.value + " "; break;
+				case ATBLOCK: context += body_node.content.trimEnd() + "\n"; break;
 				case BLOCK:
-					context += await generateOutput(body_node, i, format, mapper_file);
+					const textBlockOutput = await generateOutput(body_node, i, format, mapper_file);
+					context = context.trim() ? context.trimEnd() + "\n" + textBlockOutput : context + textBlockOutput;
 					break;
 			}
 		}
@@ -217,7 +113,7 @@ async function generateOutput(ast, i, format, mapper_file) {
 			`<$yellow:Identifier$> <$blue:'${node.id}'$> <$yellow: is not found in mapping outputs$>{line}`
 		]);
 	}
-	return result;
+	return result.trimEnd() + "\n";
 }
 
 async function transpiler({ ast, format, mapperFile, includeDocument = true }) {
@@ -226,42 +122,13 @@ async function transpiler({ ast, format, mapperFile, includeDocument = true }) {
 		if (ast[i].type === BLOCK) {
 			output += await generateOutput(ast, i, format, mapperFile);
 		} else if (ast[i].type === COMMENT) {
-			if (format === htmlFormat || format === markdownFormat) {
-				output += `<!--${ast[i].text.replace("#", "")}-->\n`;
-			} else if (format === mdxFormat) {
-				output += `{/*${ast[i].text.replace("#", "")} */}\n`;
-			}
+			output += mapperFile.comment(ast[i].text);
 		}
 	}
-	if (includeDocument && format === htmlFormat) {
-		let finalHeader = mapperFile.header;
-		let styleContent = "";
-		const updateStyleTag = style => {
-			if (style) {
-				const styleTag = `<style>\n${style}\n</style>`;
-				if (!finalHeader.includes(styleTag)) {
-					finalHeader += styleTag + "\n";
-				}
-			}
-		};
-
-		// Inject Style Tag if code blocks exist
-		if (mapperFile.enable_highlightTheme && (output.includes("<pre") || output.includes("<code"))) {
-			mapperFile.addStyle(mapperFile.themes[mapperFile.currentTheme]);
-			styleContent = mapperFile.styles.join("\n");
-			updateStyleTag(styleContent);
-		} else {
-			styleContent = mapperFile.styles.join("\n");
-			updateStyleTag(styleContent);
-		}
-
-		const document = `<!DOCTYPE html>\n<html>\n${finalHeader}\n<body>\n${output}\n</body>\n</html>\n`;
-		return document;
-	}
-	if (format === jsonFormat) {
-		output = JSON.parse(JSON.stringify(output));
-	}
-	return output;
+	// ========================================================================== //
+	//  Final Post-Processing (Dynamic Formats)                                   //
+	// ========================================================================== //
+	return mapperFile.formatOutput(output, includeDocument);
 }
 
 export default transpiler;

package/debug.js

@@ -1,10 +1,15 @@
 import fs from "node:fs/promises";
 import SomMark from "./index.js";
 
-const buffer = await fs.readFile("./example.smark");
+const buffer = await fs.readFile("./examples/markdown/tasks.smark");
 const file_content = buffer.toString();
-let smark = new SomMark({ src: file_content, format: "html", includeDocument: true });
+let smark = new SomMark({ 
+    src: file_content, 
+    format: "markdown", 
+    includeDocument: true,
+});
 
-// console.log(JSON.stringify(smark.parse(), null, 2));
-// console.log(smark.lex());
+
+// console.log(JSON.stringify(await smark.parse(), null, 2));
+// console.log(await smark.lex());
 console.log(await smark.transpile());

package/format.js

@@ -0,0 +1,23 @@
+import fs from "node:fs/promises";
+import SomMark from "./index.js"; 
+const rawSource = await fs.readFile("./unformatted.smark", "utf8");
+
+const smark = new SomMark({
+	src: rawSource,
+	format: "html",
+	plugins: [
+		{ 
+			name: "sommark-format", 
+			options: { indentString: "  " } // 2 spaces instead of default "\t"
+		}
+	]
+});
+
+// 1. Run parse() 
+await smark.parse();
+
+// 2. Get the formatted string from the "sommark-format" plugin
+const formatPlugin = smark.plugins.find(p => p.name === "sommark-format");
+
+console.log("--- Formatted Output ---");
+console.log(formatPlugin.formattedSource);

package/formatter/mark.js

@@ -1,5 +1,5 @@
 class MarkdownBuilder {
-	constructor() {}
+	constructor() { }
 	// ========================================================================== //
 	//  Headings                                                                  //
 	// ========================================================================== //
@@ -119,9 +119,9 @@ class MarkdownBuilder {
 			rows = rows.map(row => {
 				let columns;
 				if (typeof row === "string") {
-					columns = row.split(",").map(c => c.trim());
+					columns = row.split(/(?<!\\),/).map(c => c.trim().replace(/\\(.)/g, "$1"));
 				} else if (Array.isArray(row)) {
-					columns = row.map(c => String(c).trim());
+					columns = row.map(c => String(c).trim().replace(/\\(.)/g, "$1"));
 				} else {
 					return "";
 				}

package/formatter/tag.js

@@ -21,7 +21,11 @@ class TagBuilder {
 				if (value === true) {
 					this.#attr.push(`${key}`);
 				} else if (value !== false) {
-					this.#attr.push(`${key}="${escapeHTML(value ?? "")}"`);
+					let val = value ?? "";
+					if (key === "style" && typeof val === "string") {
+						val = val.replace(/(^|[^\w\-_$])(--[\w\-_$]+)(?![\w\-_$]|:)/g, "$1var($2)");
+					}
+					this.#attr.push(`${key}="${escapeHTML(val)}"`);
 				}
 			});
 		}
@@ -38,7 +42,7 @@ class TagBuilder {
 	props(propsList) {
 		const list = Array.isArray(propsList) ? propsList : [propsList];
 		if (list.length > 0) {
-      for (const propEntry of list) {
+			for (const propEntry of list) {
 				if (typeof propEntry !== "object" || propEntry === null) {
 					throw new TypeError("prop expects an object with property { __type__ }");
 				}

package/grammar.ebnf

@@ -5,12 +5,12 @@ WhiteSpace     = " " | "\t" | "\n" | "\r";
 Digit          = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
 Letter         = "A" | ... | "Z" | "a" | ... | "z";
 SpecialChar    = "[" | "]" | "(" | ")" | ":" | "-" | ">" | "@" | "_" | "=" | "," | ";";
-Identifier     = (Letter | Digit), { Letter | Digit };
+Identifier     = (Letter | Digit | "_" | "$" | "-"), { Letter | Digit | "_" | "$" | "-" };
 EscapeChar     = "\";
 
 (* General Rules *)
-(* 1. Identifiers can be only letters and numbers. *)
-(* 2. Semi-colon is only recognized in Atblock arguments. *)
+(* 1. Identifiers can include letters, numbers, underscores (_), dollar signs ($), and hyphens (-). *)
+(* 2. Semi-colon is mandatory for ending Atblock headers. *)
 (* 3. Colon is a separator in Block and Atblock arguments; must be escaped if part of value. *)
 
 (* Comments *)
@@ -61,7 +61,7 @@ InlineArg       = { ? any char except ",", ")" ? | EscapedChar };
 (* ========================================== *)
 
 AtBlock        = AtBlockStart, AtBlockContent, AtBlockEnd;
-AtBlockStart   = "@_", Identifier, "_@", [ ":", AtBlockArgs, ";" ];
+AtBlockStart   = "@_", Identifier, "_@", [ ":", AtBlockArgs ], ";";
 AtBlockEnd     = "@_", "end", "_@";
 
 (* Atblock Arguments: Key-Value or Value only, terminated by semicolon *)
@@ -72,7 +72,7 @@ AtBlockValue   = { ? any char except ",", ";" ? | EscapedChar };
 AtBlockContent = { ? any character ? };
 
 (* Example: @_Identifier_@: arg1, arg2; Content... @_end_@ *)
-(* Example: @_Identifier_@ Content... @_end_@ *)
+(* Example: @_Identifier_@; Content... @_end_@ *)
 
 
 (* Text Content *)

package/helpers/camelize.js

@@ -0,0 +1,2 @@
+const camelize = str => str.replace(/-./g, x => x[1].toUpperCase());
+export default camelize;

package/helpers/colorize.js

@@ -1,17 +1,23 @@
+const colors = {
+	red: "\x1b[31m",
+	green: "\x1b[32m",
+	yellow: "\x1b[33m",
+	blue: "\x1b[34m",
+	magenta: "\x1b[35m",
+	cyan: "\x1b[36m",
+	reset: "\x1b[0m"
+};
+
+export let useColor = false;
+
+export function enableColor(enabled = true) {
+	useColor = enabled;
+}
+
 export default function colorize(color, text) {
-	const colors = {
-		red: "\x1b[31m",
-		green: "\x1b[32m",
-		yellow: "\x1b[33m",
-		blue: "\x1b[34m",
-		magenta: "\x1b[35m",
-		cyan: "\x1b[36m",
-		reset: "\x1b[0m"
-	};
-	if (!text) throw new Error(`${colors["red"]}argument 'text' is not defined.${colors["reset"]}`);
-	if (color) {
+	if (!text) throw new Error("argument 'text' is not defined.");
+	if (useColor && color && colors[color]) {
 		return colors[color] + text + colors["reset"];
-	} else {
-		return text;
 	}
-}
+	return text;
+}

package/helpers/kebabize.js

@@ -0,0 +1,2 @@
+const kebabize = str => str.replace(/[A-Z]/g, m => `-${m.toLowerCase()}`);
+export default kebabize;

package/helpers/utils.js

@@ -0,0 +1,161 @@
+import { sommarkError } from "../core/errors.js";
+
+/**
+ * Checks if a todo item should be checked.
+ * @param {string} status 
+ * @returns {boolean}
+ */
+export function todo(status = "") {
+    return (status || "").trim() === "x" || (status || "").trim().toLowerCase() === "done";
+}
+
+/**
+ * Matches a target ID within an array of output registration objects.
+ */
+export function matchedValue(outputs, targetId) {
+	let result;
+	for (const outputValue of outputs) {
+		if (typeof outputValue.id === "string") {
+			if (outputValue.id === targetId) {
+				result = outputValue;
+				break;
+			}
+		} else if (Array.isArray(outputValue.id)) {
+			for (const id of outputValue.id) {
+				if (id === targetId) {
+					result = outputValue;
+					break;
+				}
+			}
+		}
+	}
+	return result;
+}
+
+/**
+ * Safe argument retrieval with validation.
+ */
+export function safeArg(args, index, key, type = null, setType = null, fallBack = null) {
+    if (!Array.isArray(args)) {
+        sommarkError([`{line}<$red:TypeError:$> <$yellow:args must be an array$>{line}`]);
+    }
+
+    if (index === undefined && key === undefined) {
+        sommarkError([`{line}<$red:ReferenceError:> <$yellow:At least one of 'index' or 'key' must be provided$>{line}`]);
+    }
+
+    const validate = value => {
+        if (value === undefined) return false;
+        if (!type) return true;
+        const evaluated = setType ? setType(value) : value;
+        return typeof evaluated === type;
+    };
+
+    if (index !== undefined && validate(args[index])) {
+        return args[index];
+    }
+
+    if (key !== undefined && validate(args[key])) {
+        return args[key];
+    }
+
+    return fallBack;
+}
+
+/**
+ * Renders an HTML table.
+ */
+export function htmlTable(data, headers, escapeFn = (t) => t) {
+    if (!data) return "";
+
+    if (typeof data === "string") {
+        data = data.split(/\r?\n/);
+    } else if (!Array.isArray(data) || data.length === 0) {
+        return "";
+    }
+
+    let tableHTML = `<table class="sommark-table">\n<thead>\n<tr>`;
+    for (const header of headers) {
+        tableHTML += `<th>${escapeFn(header)}</th>`;
+    }
+    tableHTML += "</tr>\n</thead>\n<tbody>\n";
+
+    for (const row of data) {
+        const trimmedRow = row.trim();
+        if (!trimmedRow) continue;
+
+        const rowData = trimmedRow.split(/(?<!\\),/).map(cell => {
+            let text = cell.trim();
+            if (text.endsWith(";")) text = text.slice(0, -1);
+            return text.replace(/\\(.)/g, "$1");
+        });
+
+        tableHTML += "<tr>";
+        for (const cell of rowData) {
+            tableHTML += `<td>${escapeFn(cell.trim())}</td>`;
+        }
+        tableHTML += "</tr>\n";
+    }
+
+    tableHTML += "</tbody>\n</table>";
+    return tableHTML;
+}
+
+/**
+ * Parses a hierarchical list.
+ */
+export function parseList(data, indentSize = 2) {
+    if (typeof data === "string") {
+        data = data.split("\n");
+    }
+    const root = { level: -1, children: [] };
+    const stack = [root];
+
+    const getLevel = line => {
+        const spaces = line.match(/^\s*/)[0].length;
+        return Math.floor(spaces / indentSize);
+    };
+
+    for (const raw of data) {
+        if (!raw.trim()) continue;
+        const level = getLevel(raw);
+        const text = raw.trim();
+
+        const node = { text, children: [] };
+
+        while (stack.length && stack[stack.length - 1].level >= level) {
+            stack.pop();
+        }
+
+        stack[stack.length - 1].children.push(node);
+        stack.push({ ...node, level });
+    }
+
+    return root.children;
+}
+
+/**
+ * Renders a list (ul/ol).
+ */
+export function list(data, as = "ul", escapeFn = (t) => t) {
+    const nodes = parseList(data);
+    if (!Array.isArray(nodes) || nodes.length === 0) return "";
+
+    const tag = as === "ol" ? "ol" : "ul";
+
+    const renderItems = items => {
+        let html = `<${tag}>`;
+        for (const item of items) {
+            html += `<li>`;
+            html += escapeFn(item.text);
+            if (item.children && item.children.length > 0) {
+                html += renderItems(item.children);
+            }
+            html += `</li>`;
+        }
+        html += `</${tag}>`;
+        return html;
+    };
+
+    return renderItems(nodes);
+}