sommark 4.0.3 → 4.2.0

package/core/tokenTypes.js

@@ -19,12 +19,15 @@
  * @property {string} COMMA - ',' char.
  * @property {string} SEMICOLON - ';' char (At-Block separator).
  * @property {string} COMMENT - '#' comments.
+ * @property {string} COMMENT_BLOCK - '###' comments.
  * @property {string} ESCAPE - '\' char. Used for literalizing structural chars like '\"' or '\['.
  * @property {string} QUOTE - '"' delimiter.
+ * @property {string} EXCLAMATION_MARK - '!' char.
  * @property {string} IMPORT - 'import' keyword.
  * @property {string} USE_MODULE - '$use-module' keyword.
  * @property {string} PREFIX_JS - 'js{}' prefix layer.
  * @property {string} PREFIX_P - 'p{}' placeholder layer.
+ * @property {string} PREFIX_V - 'v{}' local variable layer.
  * @property {string} EOF - End of File indicator.
  */
 const TOKEN_TYPES = {
@@ -39,6 +42,7 @@ const TOKEN_TYPES = {
   QUOTE: "QUOTE",
   PREFIX_JS: "PREFIX_JS",
   PREFIX_P: "PREFIX_P",
+  PREFIX_V: "PREFIX_V",
   TEXT: "TEXT",
   THIN_ARROW: "THIN_ARROW",
   OPEN_PAREN: "OPEN_PAREN",
@@ -49,9 +53,16 @@ const TOKEN_TYPES = {
   COMMA: "COMMA",
   SEMICOLON: "SEMICOLON",
   COMMENT: "COMMENT",
+  COMMENT_BLOCK: "COMMENT_BLOCK",
   ESCAPE: "ESCAPE",
+  EXCLAMATION_MARK: "EXCLAMATION_MARK",
+  SLOT_KEYWORD: "SLOT_KEYWORD",
   KEY: "KEY",
   WHITESPACE: "WHITESPACE",
+  STATIC_KEYWORD: "STATIC_KEYWORD",
+  RUNTIME_KEYWORD: "RUNTIME_KEYWORD",
+  LOGIC: "LOGIC",
+  FOR_EACH: "FOR_EACH",
   EOF: "EOF"
 };
 

package/core/transpiler.js

@@ -1,16 +1,18 @@
-import { BLOCK, TEXT, INLINE, ATBLOCK, COMMENT } from "./labels.js";
+import { BLOCK, TEXT, INLINE, ATBLOCK, COMMENT, COMMENT_BLOCK, STATIC_LOGIC, RUNTIME_LOGIC, FOR_EACH } from "./labels.js";
 import { transpilerError } from "./errors.js";
-import { textFormat, htmlFormat, markdownFormat, mdxFormat, xmlFormat } from "./formats.js";
+import evaluator from "./evaluator.js";
 import { matchedValue } from "../helpers/utils.js";
 import { dedentBy } from "../helpers/dedent.js";
+import { preprocessRuntimeLogic } from "./helpers/preprocessor.js";
+import { wrapRuntimeLogic } from "./helpers/runtimeOutput.js";
 
-/**
- * SomMark Transpiler
- * This engine converts the AST into its final text format (like HTML or Markdown)
- * using rules provided by a mapper.
- */
+const randomBytesHex = (size) => {
+	const arr = new Uint8Array(size);
+	globalThis.crypto.getRandomValues(arr);
+	return Array.from(arr).map(b => b.toString(16).padStart(2, "0")).join("");
+};
 
-const BODY_PLACEHOLDER = `SOMMARKBODYPLACEHOLDER${Math.random().toString(36).slice(2)}SOMMARK`;
+const BODY_PLACEHOLDER = `SOMMARKBODYPLACEHOLDER${randomBytesHex(8)}SOMMARK`;
 
 /** 
  * Extracts all plain text from a node and its children.
@@ -27,7 +29,7 @@ function getNodeText(node) {
 			if (child.type === TEXT) text += child.text || "";
 			else if (child.type === INLINE) text += child.value || "";
 			else if (child.type === ATBLOCK) text += child.content || "";
-			else if (child.type === BLOCK) text += getNodeText(child);
+			else if (child.type === BLOCK || child.type === FOR_EACH) text += getNodeText(child);
 		}
 	}
 	return text;
@@ -43,7 +45,7 @@ function getNodeText(node) {
  * @param {Object} mapper_file - The rules for how to convert each node.
  * @returns {Promise<string>} - The final text for this node.
  */
-async function generateOutput(ast, i, format, mapper_file) {
+async function generateOutput(ast, i, format, mapper_file, security = {}, parentId = null, generateRuntimeOutput = false, hideRuntimeOutput = false, instance = null) {
 	const node = Array.isArray(ast) ? ast[i] : ast;
 	if (!node) return "";
 
@@ -56,28 +58,157 @@ async function generateOutput(ast, i, format, mapper_file) {
 		mapper_file.options.filename = node.args?.filename || oldFilename;
 		let bodyOutput = "";
 		if (node.body) {
+			evaluator.pushScope();
 			for (let j = 0; j < node.body.length; j++) {
-				bodyOutput += await generateOutput(node.body, j, format, mapper_file);
+				bodyOutput += await generateOutput(node.body, j, format, mapper_file, security, parentId, generateRuntimeOutput, hideRuntimeOutput, instance);
 			}
+			await evaluator.popScope();
 		}
 		mapper_file.options.filename = oldFilename;
 		return bodyOutput;
 	}
 
 	if (node.type === TEXT) {
+		if (generateRuntimeOutput) return "";
 		const text = String(node.text || "");
 		return mapper_file ? mapper_file.text(text) : text;
 	}
 
 	if (node.type === COMMENT) {
-		if (mapper_file?.options?.removeComments) return "";
-		const cleanComment = String(node.text || "").replace(/^#/, "").trim();
-		return " ".repeat(node.depth) + `${mapper_file?.comment(cleanComment) || ""}`;
+		if (generateRuntimeOutput || mapper_file?.options?.removeComments) return "";
+		return " ".repeat(node.depth) + `${mapper_file?.comment(node.text) || ""}`;
+	}
+
+	if (node.type === COMMENT_BLOCK) {
+		if (generateRuntimeOutput || mapper_file?.options?.removeComments) return "";
+		return " ".repeat(node.depth) + `${mapper_file?.commentBlock(node.text) || ""}`;
+	}
+
+	if (node.type === RUNTIME_LOGIC) {
+		const preprocessed = await preprocessRuntimeLogic(node.code, mapper_file?.options?.filename, security, instance);
+		if (hideRuntimeOutput) {
+			return "";
+		}
+		if (generateRuntimeOutput) {
+			return wrapRuntimeLogic(preprocessed, format, parentId, node.depth === 1);
+		}
+		return mapper_file ? mapper_file.runtimeLogic(preprocessed, node.depth === 1, parentId) : "";
+	}
+
+	if (node.type === STATIC_LOGIC) {
+		try {
+			const result = await evaluator.execute(node.code);
+			if (generateRuntimeOutput) return "";
+			if (result && typeof result === "object" && result.__raw !== undefined) {
+				if (security?.allowRaw === false) {
+					return mapper_file ? mapper_file.text(String(result.__raw)) : String(result.__raw);
+				}
+				const rawVal = String(result.__raw);
+				return (security?.sanitize && typeof security.sanitize === "function") ? security.sanitize(rawVal) : rawVal;
+			}
+			// Hide objects (like module exports) from the final output
+			const out = (result !== undefined && typeof result !== "object") ? String(result) : "";
+			return mapper_file ? mapper_file.text(out) : out;
+		} catch (err) {
+			transpilerError([
+				`<$red:Logic Error:$> ${err.message}{line}`,
+				`<$yellow:Code:$> <$blue:${node.code}$>{line}`
+			]);
+		}
+	}
+
+	if (node.type === FOR_EACH) {
+		const transpiledArgs = await transpileArgs(node.args);
+		const items = mapper_file ? mapper_file.safeArg({ args: transpiledArgs, index: 0, key: "items", fallBack: [] }) : [];
+
+		if (!Array.isArray(items)) {
+			const line = node.range?.start?.line + 1 || 1;
+			transpilerError([
+				`<$red:Type Error in [for-each]:$>{line}`,
+				`Expected an <$green:Array$> for 'items', but received <$yellow:${typeof items}$>:<$cyan: ${JSON.stringify(items)}$>{line}`,
+				`at line <$yellow:${line}$>{line}`
+			]);
+			return "";
+		}
+
+		const asVar = transpiledArgs.as || "item";
+		const indexVar = `${asVar}_index`;
+
+		// Trim structural whitespace/newlines at start and end of loop body for formatting clean output
+		let cleanedBody = [];
+		if (node.body) {
+			cleanedBody = [...node.body];
+
+			// Trim ALL leading pure-whitespace Text nodes
+			while (cleanedBody.length > 0 && cleanedBody[0].type === TEXT && /^\s*$/.test(cleanedBody[0].text)) {
+				cleanedBody.shift();
+			}
+			// If the now-first node is a Text node, trim its leading whitespace/newlines
+			if (cleanedBody.length > 0 && cleanedBody[0].type === TEXT) {
+				cleanedBody[0] = { ...cleanedBody[0], text: cleanedBody[0].text.replace(/^\s+/, "") };
+			}
+
+			// Trim ALL trailing pure-whitespace Text nodes
+			while (cleanedBody.length > 0 && cleanedBody[cleanedBody.length - 1].type === TEXT && /^\s*$/.test(cleanedBody[cleanedBody.length - 1].text)) {
+				cleanedBody.pop();
+			}
+			// If the now-last node is a Text node, trim its trailing whitespace/newlines
+			if (cleanedBody.length > 0 && cleanedBody[cleanedBody.length - 1].type === TEXT) {
+				cleanedBody[cleanedBody.length - 1] = { ...cleanedBody[cleanedBody.length - 1], text: cleanedBody[cleanedBody.length - 1].text.replace(/\s+$/, "") };
+			}
+		}
+
+		let output = "";
+		let idx = 0;
+		for (const item of items) {
+			evaluator.pushScope();
+			evaluator.inject({
+				[asVar]: item,
+				[indexVar]: idx++
+			});
+
+			for (let j = 0; j < cleanedBody.length; j++) {
+				output += await generateOutput(cleanedBody, j, format, mapper_file, security, parentId, generateRuntimeOutput, hideRuntimeOutput, instance);
+			}
+
+			await evaluator.popScope();
+		}
+		return output;
 	}
 
-	let target = mapper_file ? matchedValue(mapper_file.outputs, node.id) : null;
-	if (!target && mapper_file) {
-		target = mapper_file.getUnknownTag(node);
+	let secretId = null;
+	if (node.type === BLOCK) {
+		if (node.args) {
+			for (const key of Object.keys(node.args)) {
+				if (key.toLowerCase().startsWith("data-sommark")) {
+					transpilerError([
+						`<$red:Reserved Attribute Error:$> The attribute name '<$yellow:${key}$>' is reserved for SomMark's internal runtime compiler logic.{line}`,
+						`Please use a different attribute name.`
+					]);
+				}
+			}
+		}
+
+		const hasRuntime = node.body?.some(child => child.type === RUNTIME_LOGIC);
+		if (hasRuntime) {
+			secretId = `sommark-${node.id.toLowerCase()}-${randomBytesHex(4)}`;
+		}
+	}
+
+	let target = null;
+	if (evaluator.active && evaluator.active.hasDynamicTag(node.id)) {
+		target = {
+			id: node.id,
+			options: evaluator.active.getDynamicTagOptions(node.id) || {},
+			render: async function (payload) {
+				return await evaluator.active.executeDynamicTag(node.id, payload);
+			}
+		};
+	} else {
+		target = mapper_file ? matchedValue(mapper_file.outputs, node.id) : null;
+		if (!target && mapper_file) {
+			target = mapper_file.getUnknownTag(node);
+		}
 	}
 
 	if (target) {
@@ -94,6 +225,11 @@ async function generateOutput(ast, i, format, mapper_file) {
 			content = mapper_file ? mapper_file.inlineText(content, target.options) : content;
 		}
 
+		if (node.type === ATBLOCK) {
+			content = String(content || "");
+			content = mapper_file ? mapper_file.atBlockBody(content, target.options) : content;
+		}
+
 		// 1. Determine if this is a parent block that needs newline wrapping (Trim-and-Wrap)
 		// Priority: Target options > Mapper global options
 		const effectiveTrimAndWrap = (target.options?.trimAndWrapBlocks !== undefined)
@@ -109,23 +245,59 @@ async function generateOutput(ast, i, format, mapper_file) {
 
 		if (shouldResolveImmediate && node.body) {
 			let resolvedBody = "";
+			evaluator.pushScope();
 			for (let j = 0; j < node.body.length; j++) {
-				resolvedBody += await generateOutput(node.body, j, format, mapper_file);
+				resolvedBody += await generateOutput(node.body, j, format, mapper_file, security, parentId, generateRuntimeOutput, hideRuntimeOutput, instance);
+			}
+			await evaluator.popScope();
+			content = dedentBy(resolvedBody, node.range?.start?.character || 0);
+		}
+
+		if (generateRuntimeOutput) {
+			let childrenOutput = "";
+			if (node.body) {
+				for (let j = 0; j < node.body.length; j++) {
+					childrenOutput += await generateOutput(node.body, j, format, mapper_file, security, secretId || parentId, generateRuntimeOutput, hideRuntimeOutput, instance);
+				}
 			}
-			content = resolvedBody;
+			return childrenOutput;
 		}
 
-		result += await target.render.call(mapper_file, { nodeType: node.type, args: node.args, content, textContent, ast: node });
-		if (isParentBlock) result = "\n" + result + "\n";
+		const isManualMode = target.options?.handleAst === true;
+
+		const transpiledArgs = await transpileArgs(node.args);
+		if (secretId) {
+			transpiledArgs["data-sommark-id"] = secretId;
+		}
+		result += await target.render.call(mapper_file, {
+			nodeType: node.type,
+			args: transpiledArgs,
+			content,
+			textContent,
+			ast: isManualMode ? node : new Proxy({}, {
+				get(target, prop) {
+					if (prop === "then" || prop === "toJSON" || typeof prop === "symbol" || prop === "constructor" || prop === "inspect" || prop === "valueOf" || prop === "toString") {
+						return undefined;
+					}
+					transpilerError([
+						`<$red:Access Error:$> Attempted to access '<$yellow:ast.${String(prop)}$>', but '<$yellow:ast$>' is undefined because '<$cyan:handleAst$>' is false or not specified in this tag's registration options.{N}{N}`,
+						`Please set '<$green:handleAst: true$>' in the options object of your tag registration to get the actual AST node.`
+					]);
+				}
+			}),
+			isSelfClosing: node.type === BLOCK ? (node.isSelfClosing || false) : undefined
+		});
+		// if (isParentBlock) result = "\n" + result;
 
 		if (shouldResolveImmediate) {
 			return result;
 		}
 
-		const isManualMode = target.options?.handleAst === true;
-
 		if (!isManualMode && node.body) {
 			let prev_body_node = null;
+			let prev_was_silent = false;
+			const parentEscape = (security?.allowRaw === false) ? true : (target.options?.escape !== false);
+			evaluator.pushScope();
 			for (let j = 0; j < node.body.length; j++) {
 				const body_node = node.body[j];
 				let bodyOutput = "";
@@ -133,9 +305,13 @@ async function generateOutput(ast, i, format, mapper_file) {
 				switch (body_node.type) {
 					case TEXT:
 						const text = String(body_node.text || "");
-						// Dedent text relative to the parent block's indentation
-						const localDedentedText = dedentBy(text, node.range?.start?.character || 0);
-						bodyOutput = mapper_file ? mapper_file.text(localDedentedText, target?.options) : localDedentedText;
+						// Only dedent multi-line text — inline spaces (no newlines) are separators, not indentation
+						const localDedentedText = text.includes("\n") ? dedentBy(text, node.range?.start?.character || 0) : text;
+						let bodyTextVal = mapper_file ? mapper_file.text(localDedentedText, { ...target?.options, escape: parentEscape }) : localDedentedText;
+						if (parentEscape === false && security?.sanitize && typeof security.sanitize === "function") {
+							bodyTextVal = security.sanitize(bodyTextVal);
+						}
+						bodyOutput = bodyTextVal;
 						break;
 
 					case INLINE:
@@ -175,54 +351,95 @@ async function generateOutput(ast, i, format, mapper_file) {
 						}
 
 						// Removed multiline injection since atBlockBody handles formatting
+						const transpiledAtArgs = await transpileArgs(body_node.args);
 						bodyOutput = atTarget
-							? await atTarget.render.call(mapper_file, { nodeType: body_node.type, args: body_node.args, content: atContent, ast: body_node })
+							? await atTarget.render.call(mapper_file, { nodeType: body_node.type, args: transpiledAtArgs, content: atContent, ast: body_node })
 							: atContent;
 						break;
 
 					case COMMENT:
 						if (mapper_file?.options?.removeComments) break;
-						const cleanComment = String(body_node.text || "").replace(/^#/, "").trim();
-						bodyOutput = " ".repeat(body_node.depth) + `${mapper_file.comment(cleanComment)}`;
+						bodyOutput = " ".repeat(body_node.depth) + `${mapper_file.comment(body_node.text)}`;
+						break;
+
+					case COMMENT_BLOCK:
+						if (mapper_file?.options?.removeComments) break;
+						bodyOutput = " ".repeat(body_node.depth) + `${mapper_file.commentBlock(body_node.text)}`;
 						break;
 
+					case FOR_EACH:
 					case BLOCK:
-						bodyOutput = await generateOutput(body_node, 0, format, mapper_file);
+						bodyOutput = await generateOutput(body_node, 0, format, mapper_file, security, secretId || parentId, generateRuntimeOutput, hideRuntimeOutput, instance);
 						break;
+
+					case RUNTIME_LOGIC:
+						const preprocessedBody = await preprocessRuntimeLogic(body_node.code, mapper_file?.options?.filename, security, instance);
+						if (hideRuntimeOutput) {
+							bodyOutput = "";
+						} else {
+							bodyOutput = mapper_file ? mapper_file.runtimeLogic(preprocessedBody, body_node.depth === 1, secretId || parentId) : "";
+						}
+						break;
+
+					case STATIC_LOGIC:
+						try {
+							const result = await evaluator.execute(body_node.code);
+							if (result && typeof result === "object" && result.__raw !== undefined) {
+								if (security?.allowRaw === false) {
+									bodyOutput = mapper_file ? mapper_file.text(String(result.__raw)) : String(result.__raw);
+								} else {
+									const rawVal = String(result.__raw);
+									bodyOutput = (security?.sanitize && typeof security.sanitize === "function") ? security.sanitize(rawVal) : rawVal;
+								}
+							} else {
+								const out = (result !== undefined && typeof result !== "object") ? String(result) : "";
+								bodyOutput = mapper_file ? mapper_file.text(out, { ...target?.options, escape: parentEscape }) : out;
+							}
+						} catch (err) {
+							transpilerError([
+								`<$red:Logic Error:$> ${err.message}{line}`,
+								`<$yellow:Code:$> <$blue:${body_node.code}$>{line}`
+							]);
+						}
+						break;
+				}
+
+				if (prev_was_silent && body_node.type === TEXT) {
+					bodyOutput = bodyOutput.replace(/^\n/, "");
 				}
 
 				if (bodyOutput) {
 					context += bodyOutput;
+					prev_was_silent = false;
+				} else {
+					prev_was_silent = true;
 				}
 			}
+			await evaluator.popScope();
 		}
 
 		const finalContext = effectiveTrimAndWrap ? context.replace(/^\s*[\r\n]+|[\r\n]+\s*$/g, "") : context;
 
 		if (result.includes(BODY_PLACEHOLDER)) {
-			result = result.replaceAll(BODY_PLACEHOLDER, finalContext);
-		} else if (finalContext.trim()) {
-			result += finalContext;
-		}
-	}
-	else if (format === textFormat) {
-		if (node.type === ATBLOCK) {
-			result = node.content || "";
-		} else if (node.type === INLINE) {
-			result = node.value || "";
-		} else if (node.body) {
-			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 || "").trimEnd() + "\n"; break;
-					case BLOCK:
-						const textBlockOutput = await generateOutput(body_node, 0, format, mapper_file);
-						context = context.trim() ? context.trimEnd() + "\n" + textBlockOutput : context + textBlockOutput;
-						break;
-				}
+			if (finalContext === "") {
+				result = result
+					.replaceAll(`\n${BODY_PLACEHOLDER}\n`, "")
+					.replaceAll(`\r\n${BODY_PLACEHOLDER}\r\n`, "")
+					.replaceAll(BODY_PLACEHOLDER, "");
+			} else {
+				result = result.replaceAll(BODY_PLACEHOLDER, finalContext);
+			}
+		} else {
+			if (result.toLowerCase().includes(BODY_PLACEHOLDER.toLowerCase())) {
+				transpilerError([
+					`{line}<$red:Placeholder Corruption Error:$> Attempted to modify the '<$yellow:content$>' placeholder under '<$cyan:resolve: false$>' mode in tag '<$blue:${node.id}$>'.{line}`,
+					`This corrupts SomMark's internal compilation tokens and is not allowed.{line}`,
+					`If you need to read or alter the literal inner text, please use '<$green:textContent$>' instead.{line}`
+				]);
+			}
+			if (finalContext.trim()) {
+				result += finalContext;
 			}
-			result += context;
 		}
 	} else {
 		transpilerError([
@@ -247,6 +464,7 @@ export async function transpiler(optionsOrAst, format, mapperFile) {
 	let body = null;
 	let targetFormat = format;
 	let targetMapper = mapperFile;
+	const security = (optionsOrAst && optionsOrAst.security) ? optionsOrAst.security : {};
 
 	if (typeof optionsOrAst === "object" && !Array.isArray(optionsOrAst) && (optionsOrAst.ast || Array.isArray(optionsOrAst))) {
 		if (optionsOrAst.ast) {
@@ -263,28 +481,96 @@ export async function transpiler(optionsOrAst, format, mapperFile) {
 
 	if (!body || !Array.isArray(body)) return "";
 
+	const settings = optionsOrAst?.settings || { format: targetFormat || "html" };
+	const instance = optionsOrAst?.instance;
+	if (instance) {
+		settings.instance = instance;
+		settings.fs = instance.fs;
+	}
+
+	// Initialize Logic Sandbox
+	await evaluator.init(null, security, settings, targetMapper);
+	// Inject global data
+	const placeholders = optionsOrAst?.placeholders || settings?.placeholders || {};
+	const variables = optionsOrAst?.variables || settings?.variables || {};
+	evaluator.inject(placeholders);
+	evaluator.inject(variables);
+
 	let output = "";
 	let prev_body_node = null;
-	for (let i = 0; i < body.length; i++) {
-		const node = body[i];
-		const blockOutput = await generateOutput(body, i, targetFormat, targetMapper);
-
-		if (blockOutput) {
-			output += blockOutput;
-			if (node.type !== TEXT || node.text.trim().length > 0) {
-				prev_body_node = node;
+	let prev_was_silent = false;
+	const generateRuntimeOutput = optionsOrAst?.generateRuntimeOutput || false;
+	const hideRuntimeOutput = optionsOrAst?.hideRuntimeOutput || false;
+	try {
+		for (let i = 0; i < body.length; i++) {
+			const node = body[i];
+			const blockOutput = await generateOutput(body, i, targetFormat, targetMapper, security, null, generateRuntimeOutput, hideRuntimeOutput, instance);
+
+			let finalBlockOutput = blockOutput;
+			if (prev_was_silent && node.type === TEXT) {
+				finalBlockOutput = finalBlockOutput.replace(/^\n/, "");
 			}
-		} else if (node.type === COMMENT && targetMapper?.options?.removeComments) {
-			// If a comment is removed, check the next node.
-			// If it's just a blank line, skip it so we don't have extra gaps in the output.
-			const nextNode = body[i + 1];
-			if (nextNode && nextNode.type === TEXT && (nextNode.text === "\n" || nextNode.text === "\r\n")) {
-				i++; // Skip the next newline node
+
+			if (finalBlockOutput) {
+				output += finalBlockOutput;
+				prev_was_silent = false;
+				if (node.type !== TEXT || node.text.trim().length > 0) {
+					prev_body_node = node;
+				}
+			} else {
+				prev_was_silent = true;
+				if ((node.type === COMMENT || node.type === COMMENT_BLOCK) && targetMapper?.options?.removeComments) {
+					// If a comment is removed, check the next node.
+					// If it's just a blank line, skip it so we don't have extra gaps in the output.
+					const nextNode = body[i + 1];
+					if (nextNode && nextNode.type === TEXT && (nextNode.text === "\n" || nextNode.text === "\r\n")) {
+						i++; // Skip the next newline node
+					}
+				}
 			}
 		}
+	} finally {
+		evaluator.destroy();
 	}
 
 	return output.trim();
 }
 
+/**
+ * Transpiles block arguments, resolving logic or variables.
+ */
+async function transpileArgs(args) {
+	const result = {};
+	if (!args) return result;
+
+	for (const [key, value] of Object.entries(args)) {
+		if (key.toLowerCase().startsWith("data-sommark") && key.toLowerCase() !== "data-sommark-id") {
+			transpilerError([
+				`<$red:Reserved Attribute Error:$> The attribute name '<$yellow:${key}$>' is reserved for SomMark's internal runtime compiler logic.{line}`,
+				`Please use a different attribute name.`
+			]);
+		}
+		if (value && typeof value === "object") {
+			if (value.type === RUNTIME_LOGIC) {
+				// Discard runtime logic for security
+				result[key] = "";
+			} else if (value.type === STATIC_LOGIC) {
+				try {
+					result[key] = await evaluator.execute(value.code);
+				} catch (err) {
+					transpilerError([
+						`<$red:Logic Error (Argument):$> ${err.message}{line}`,
+						`<$yellow:Code:$> <$blue:${value.code}$>{line}`
+					]);
+				}
+			} else {
+				result[key] = value;
+			}
+		} else {
+			result[key] = value;
+		}
+	}
+	return result;
+}
+
 export default transpiler;