sommark 4.0.2 → 4.1.0

package/mappers/languages/jsonc.js

@@ -0,0 +1,82 @@
+import Json, { renderNode, getIndent, renderMember } from "./json.js";
+
+/**
+ * JSONC Mapper - Creates JSON output with comments.
+ * It inherits from the standard JSON mapper and adds comment support.
+ */
+
+async function renderChildren(node, mapper, depth = 0, inArray = false) {
+	let results = [];
+	const childIndent = getIndent(depth + 1);
+
+	for (const child of node.body) {
+		if (child.type === "Block") {
+			const output = await renderNode(child, mapper, depth + 1, inArray);
+			if (output) {
+				results.push({ type: "Block", value: childIndent + output });
+			}
+		} else if (child.type === "Comment") {
+			if (!mapper.options?.removeComments) {
+				results.push({ type: "Comment", value: childIndent + mapper.comment(child.text) });
+			}
+		} else if (child.type === "CommentBlock") {
+			if (!mapper.options?.removeComments) {
+				results.push({ type: "CommentBlock", value: childIndent + mapper.commentBlock(child.text, childIndent) });
+			}
+		}
+	}
+
+	let finalOutput = "";
+	for (let i = 0; i < results.length; i++) {
+		const current = results[i];
+		finalOutput += current.value;
+
+		if (current.type === "Block") {
+			// Add comma if there is another Block later
+			let hasNextBlock = false;
+			for (let j = i + 1; j < results.length; j++) {
+				if (results[j].type === "Block") {
+					hasNextBlock = true;
+					break;
+				}
+			}
+			if (hasNextBlock) finalOutput += ",";
+		}
+
+		if (i < results.length - 1) {
+			finalOutput += "\n";
+		}
+	}
+	return finalOutput;
+}
+
+const Jsonc = Json.clone();
+
+Jsonc.comment = function (text) {
+	return `// ${text}`;
+};
+
+Jsonc.commentBlock = function (text, indent = "  ") {
+	if (text.includes("\n")) {
+		const lines = text.split("\n");
+		return `/*\n${lines.map(line => indent + line).join("\n")}\n${indent}*/`;
+	}
+	return `/* ${text} */`;
+};
+
+// Re-register Object and Array to use the new renderChildren logic
+Jsonc.register(["Object", "object"], async function ({ args, ast, depth = 0, inArray = false }) {
+	if (ast.body.length === 0) return renderMember(args, "{}", inArray);
+	const content = await renderChildren(ast, this, depth, false);
+	const val = `{\n${content}\n${getIndent(depth)}}`;
+	return renderMember(args, val, inArray);
+}, { type: "Block", handleAst: true });
+
+Jsonc.register(["Array", "array"], async function ({ args, ast, depth = 0, inArray = false }) {
+	if (ast.body.length === 0) return renderMember(args, "[]", inArray);
+	const content = await renderChildren(ast, this, depth, true);
+	const val = `[\n${content}\n${getIndent(depth)}]`;
+	return renderMember(args, val, inArray);
+}, { type: "Block", handleAst: true });
+
+export default Jsonc;

package/mappers/languages/markdown.js

@@ -1,9 +1,68 @@
 import Mapper from "../mapper.js";
 import HTML from "./html.js";
 import { registerSharedOutputs } from "../shared/index.js";
-import { BLOCK, TEXT} from "../../core/labels.js";
-import transpiler from "../../core/transpiler.js";
+import { BLOCK, TEXT, INLINE, STATIC_LOGIC } from "../../core/labels.js";
 import { VOID_ELEMENTS } from "../../constants/void_elements.js";
+import evaluator from "../../core/evaluator.js";
+import { matchedValue } from "../../helpers/utils.js";
+
+/**
+ * Helper to manually render AST children inside handleAst blocks,
+ * avoiding the need to call the core transpiler recursively.
+ */
+async function renderNodeAst(astArray, mapperFile) {
+	if (!astArray || !Array.isArray(astArray)) return "";
+	let result = "";
+	for (const node of astArray) {
+		if (node.type === TEXT) {
+			const text = String(node.text || "");
+			result += mapperFile.text(text);
+		} else if (node.type === INLINE) {
+			let target = matchedValue(mapperFile.outputs, node.id) || mapperFile.getUnknownTag(node);
+			if (target) {
+				let inlineValue = String(node.value || "").trim();
+				inlineValue = mapperFile.inlineText(inlineValue, target.options);
+				result += await target.render.call(mapperFile, {
+					nodeType: node.type,
+					args: node.args || {},
+					content: inlineValue,
+					ast: node
+				});
+			} else {
+				result += mapperFile.inlineText(node.value || "", {});
+			}
+		} else if (node.type === STATIC_LOGIC) {
+			try {
+				const val = await evaluator.execute(node.code);
+				if (val !== undefined && typeof val !== "object") {
+					result += mapperFile.text(String(val));
+				}
+			} catch (e) {
+				console.error(`\x1b[31mLogic Error in Markdown mapper:\x1b[0m ${e.message}`);
+			}
+		} else if (node.type === BLOCK) {
+			let target = matchedValue(mapperFile.outputs, node.id) || mapperFile.getUnknownTag(node);
+			if (target) {
+				const isSelfClosing = node.isSelfClosing || false;
+				let content = "";
+				evaluator.pushScope();
+				if (!target.options?.handleAst && node.body) {
+					content = await renderNodeAst(node.body, mapperFile);
+				}
+				const output = await target.render.call(mapperFile, {
+					nodeType: node.type,
+					args: node.args || {},
+					content,
+					ast: node,
+					isSelfClosing
+				});
+				await evaluator.popScope();
+				result += output;
+			}
+		}
+	}
+	return result;
+}
 
 /**
  * The Markdown Mapper used for generating Markdown text.
@@ -62,11 +121,11 @@ const MARKDOWN = Mapper.define({
 
 		return {
 			render: async (ctx) => {
-				const { args, ast } = ctx;
+				const { args, ast, isSelfClosing } = ctx;
 				const body = ast && ast.body ? ast.body : [];
 				const meaningful = body.filter(c => c.type !== TEXT || c.text.trim());
 				const childCount = meaningful.length;
-				const element = this.tag(id).smartAttributes(args, this.customProps);
+				const element = this.tag(id).smartAttributes(args, this.customProps, this.options);
 
 				// Use the transpiler to format the children if any, otherwise use direct content
 				let rawContent;
@@ -77,10 +136,10 @@ const MARKDOWN = Mapper.define({
 					rawContent = node.value || "";
 					rawContent = this.inlineText(rawContent, ctx);
 				} else {
-					rawContent = (await transpiler({ ast: body, mapperFile: this })).trim();
+					rawContent = (await renderNodeAst(body, this)).trim();
 				}
 
-				if (VOID_ELEMENTS.has(id)) {
+				if (isSelfClosing || VOID_ELEMENTS.has(id)) {
 					return element.selfClose();
 				}
 
@@ -115,45 +174,20 @@ MARKDOWN.register("quote", ({ args, content }) => {
 	return md.quote(content, type);
 }, { type: "Block", resolve: true });
 
-/**
- * Unified heading renderer for Markdown and MDX mappers.
- * @param {Object} options - Mapper context and args.
- * @param {string} defaultFormat - Default format ("markdown" or "html").
- * @returns {string} - Rendered heading.
- */
-export function renderHeading({ args, content, ast }, defaultFormat = "markdown") {
-	const heading = ast.id;
-	const format = safeArg({ args, index: 0, key: "format", type: "string", fallBack: defaultFormat });
-	const lvl = heading[1] && !isNaN(Number(heading[1])) ? Number(heading[1]) : 1;
-
-	// Remove formatting arguments before checking for attributes
-	const cleanArgs = { ...args };
-	delete cleanArgs.format;
-	delete cleanArgs["0"]; // Clean positional 'format'
-
-	const hasAttributes = Object.keys(cleanArgs).length > 0;
-
-	// Hybrid Dispatch: Switch to HTML if format is requested OR if attributes are present
-	if (format === "html" || hasAttributes) {
-		let htmlTarget = HTML.get(heading);
-		if (!htmlTarget) {
-			htmlTarget = HTML.getUnknownTag(ast);
-		}
-
-		if (htmlTarget) {
-			return htmlTarget.render.call(this, { args: cleanArgs, content, ast, nodeType: ast.type });
-		}
-	}
-
-	return md.heading(content, lvl);
-}
-
 /**
  * Headings - Renders H1-H6 block headings.
  */
 ["h1", "h2", "h3", "h4", "h5", "h6"].forEach(heading => {
-	MARKDOWN.register(heading, function (ctx) {
-		return renderHeading.call(this, ctx, "markdown");
+	MARKDOWN.register(heading, function ({ args, content, isSelfClosing }) {
+		const format = safeArg({ args, key: "format", type: "string", fallBack: "" });
+		const lvl = heading[1] && !isNaN(Number(heading[1])) ? Number(heading[1]) : 1;
+		if (format.toLowerCase() === "html") {
+			delete args.format;
+			const el = this.tag(heading).smartAttributes(args);
+			if (isSelfClosing) return el.selfClose();
+			return el.body(content);
+		}
+		return this.md.heading(content, lvl);
 	}, { type: "Block" });
 });
 
@@ -215,7 +249,7 @@ MARKDOWN.register(
 	},
 	{
 		type: ["Block", "Inline"],
-		rules: { is_self_closing: false }
+		rules: { is_empty_body: false }
 	}
 );
 
@@ -232,7 +266,7 @@ MARKDOWN.register(
 	},
 	{
 		type: "Block",
-		rules: { is_self_closing: true }
+		rules: { is_empty_body: true }
 	}
 );
 
@@ -247,7 +281,7 @@ MARKDOWN.register(
 	},
 	{
 		type: "Block",
-		rules: { is_self_closing: true }
+		rules: { is_empty_body: true }
 	}
 );
 
@@ -277,7 +311,7 @@ MARKDOWN.register(
 
 			for (const child of cellAst) {
 				if (child.type === BLOCK && (child.id.toLowerCase() === "cell" || child.id.toLowerCase() === "th" || child.id.toLowerCase() === "td")) {
-					const cellContent = await transpiler({ ast: child.body, mapperFile: this });
+					const cellContent = await renderNodeAst(child.body, this);
 					cells.push(cellContent.trim());
 				}
 			}
@@ -294,6 +328,8 @@ MARKDOWN.register(
 				if (rowNode.type === BLOCK && rowNode.id.toLowerCase() === "row") {
 					const rowData = await extractCells(rowNode);
 					if (rowData.length > 0) sectionRows.push(rowData);
+				} else if (rowNode.type === STATIC_LOGIC) {
+					try { await evaluator.execute(rowNode.code); } catch (e) { console.error(`Logic Error: ${e.message}`); }
 				}
 			}
 			return sectionRows;
@@ -303,6 +339,10 @@ MARKDOWN.register(
 			// Remove empty text blocks
 			const tableNodes = ast.body.filter(n => n.type !== TEXT || n.text.trim());
 			for (const node of tableNodes) {
+				if (node.type === STATIC_LOGIC) {
+					try { await evaluator.execute(node.code); } catch (e) { console.error(`Logic Error: ${e.message}`); }
+					continue;
+				}
 				if (node.type !== BLOCK) continue;
 
 				const id = node.id.toLowerCase();
@@ -361,12 +401,12 @@ MARKDOWN.register(["list", "List"], async function ({ ast, args }) {
 			// Trim spaces inside the list item
 			const itemBody = node.body.map(n => n.type === TEXT ? { ...n, text: n.text.replace(/^[ ]+|[ ]+$/gm, "") } : n)
 				.filter(n => n.type !== TEXT || n.text);
-			const itemContent = await transpiler({ ast: itemBody, mapperFile: this });
+			const itemContent = await renderNodeAst(itemBody, this);
 			items.push(itemContent.trim());
 		} else if (node.type === BLOCK && (id === "list")) {
 			// Add nested lists to the latest item
 			if (items.length > 0) {
-				const listContent = await transpiler({ ast: [node], mapperFile: this });
+				const listContent = await renderNodeAst([node], this);
 				items[items.length - 1] += "\n" + listContent;
 			}
 		}
@@ -386,7 +426,7 @@ MARKDOWN.register(["item", "Item"], async function ({ ast }) {
 	// Trim whitespace but keep line breaks
 	const bodyAst = ast.body.map(n => n.type === TEXT ? { ...n, text: n.text.replace(/^[ ]+|[ ]+$/gm, "") } : n)
 		.filter(n => n.type !== TEXT || n.text);
-	return await transpiler({ ast: bodyAst, mapperFile: this });
+	return await renderNodeAst(bodyAst, this);
 }, { type: "Block", handleAst: true, trimAndWrapBlocks: false });
 
 /**

package/mappers/languages/mdx.js

@@ -1,5 +1,5 @@
 import Mapper from "../mapper.js";
-import MARKDOWN, { renderHeading } from "./markdown.js";
+import MARKDOWN from "./markdown.js";
 import { VOID_ELEMENTS } from "../../constants/void_elements.js";
 
 /**
@@ -28,14 +28,14 @@ const MDX = Mapper.define({
 
 		return {
 			render: (ctx) => {
-				const { args, content } = ctx;
+				const { args, content, isSelfClosing } = ctx;
 				const element = this.tag(tagName).jsxProps(args);
-				return isVoid ? element.selfClose() : element.body(content);
+				return (isSelfClosing || isVoid) ? element.selfClose() : element.body(content);
 			},
 			options: {
 				type: isVoid ? "Block" : (isCodeStyleOrScript ? ["Block", "AtBlock"] : ["Block", "Inline", "AtBlock"]),
 				escape: !isCodeStyleOrScript,
-				rules: { is_self_closing: isVoid }
+				rules: { is_empty_body: isVoid }
 			}
 		};
 	},
@@ -48,14 +48,22 @@ const MDX = Mapper.define({
 	 * Formats a plain text node with Markdown escaping.
 	 */
 	text(text, options) {
-		return MARKDOWN.text.call(this, text, options);
+		let out = text;
+		if (options?.escape !== false) {
+			out = this.escapeHTML(out);
+		}
+		return out;
 	},
 
 	/**
 	 * Formats inline content before rendering, respecting explicit escape flags.
 	 */
 	inlineText(text, options) {
-		return MARKDOWN.inlineText.call(this, text, options);
+		let out = text;
+		if (options?.escape !== false) {
+			out = this.escapeHTML(out);
+		}
+		return out;
 	},
 
 	/**
@@ -66,9 +74,6 @@ const MDX = Mapper.define({
 		if (options?.escape !== false) {
 			out = this.escapeHTML(out);
 		}
-		if (out.includes('\n')) {
-			out = '\n' + out + '\n';
-		}
 		return out;
 	}
 });
@@ -76,13 +81,17 @@ const MDX = Mapper.define({
 const { tag } = MDX;
 
 MDX.inherit(MARKDOWN);
-MDX.md = MARKDOWN.md; // Provide the Markdown escaping tool
+MDX.md = MARKDOWN.md;
 
-// MDX defaults to HTML tags for headings to ensure high-fidelity JSX output
-["h1", "h2", "h3", "h4", "h5", "h6"].forEach(heading => {
-	MDX.register(heading, function (ctx) {
-		return renderHeading.call(this, ctx, "html");
-	}, { type: "Block" });
+["h1", "h2", "h3", "h4", "h5", "h6"].forEach(h => {
+	MDX.register(h, function ({ args, content }) {
+		const format = this.safeArg({ args, key: "format", fallBack: "" });
+		if (format === "md" || format === "markdown") {
+			return this.md.heading(content, h.slice(1) || 1);
+		}
+		delete args.format;
+		return tag(h).jsxProps(args).body(content);
+	});
 });
 
 /**
@@ -92,4 +101,30 @@ MDX.register("mdx", ({ content }) => {
 	return content;
 }, { escape: false, type: "AtBlock" });
 
+// Inline CSS tag (Moved from shared)
+MDX.register("css", ({ args, content }) => {
+	// Compile style from named arguments (keys that are not numeric digits)
+	const namedStyle = Object.keys(args)
+		.filter(k => isNaN(parseInt(k)))
+		.map(k => `${k}:${args[k]}`)
+		.join(";");
+
+	// Fetch positional style string (index 0) or "style" key if present
+	let positionalStyle = MDX.safeArg({ args, index: 0, key: "style", fallBack: "" });
+
+	// Filter out positional styles that are just duplicates of named arguments
+	const hasDuplicateNamed = Object.keys(args)
+		.filter(k => isNaN(parseInt(k)))
+		.some(k => args[k] === positionalStyle);
+
+	if (hasDuplicateNamed) {
+		positionalStyle = "";
+	}
+
+	// Combine both together
+	let style = [positionalStyle, namedStyle].filter(s => s.trim()).join(";");
+
+	return MDX.tag("span").jsxProps({ style }).body(content);
+}, { type: "Inline" });
+
 export default MDX;

package/mappers/languages/text.js

@@ -0,0 +1,67 @@
+import Mapper from "../mapper.js";
+
+/**
+ * The Text Mapper used for plain-text extraction.
+ */
+const TEXT = Mapper.define({
+	options: {
+		trimAndWrapBlocks: false
+	},
+
+	/**
+	 * Comments are discarded in plain-text output.
+	 */
+	comment() {
+		return "";
+	},
+
+	/**
+	 * Comment blocks are discarded in plain-text output.
+	 */
+	commentBlock() {
+		return "";
+	},
+
+	/**
+	 * Runtime logic is discarded in plain-text output.
+	 */
+	runtimeLogic() {
+		return "";
+	},
+
+	/**
+	 * Returns plain text literally.
+	 */
+	text(text) {
+		return text;
+	},
+
+	/**
+	 * Returns inline text literally.
+	 */
+	inlineText(text) {
+		return text;
+	},
+
+	/**
+	 * Returns at-block body text literally.
+	 */
+	atBlockBody(text) {
+		return text;
+	},
+
+	/**
+	 * Fallback for all tags - extracts inner content.
+	 */
+	getUnknownTag(node) {
+		const isBlock = node.type === "Block" || node.type === "ForEach";
+		return {
+			render: ({ content }) => content,
+			options: {
+				type: isBlock ? "Block" : (node.type === "AtBlock" ? "AtBlock" : "Inline")
+			}
+		};
+	}
+});
+
+export default TEXT;

package/mappers/languages/xml.js

@@ -10,7 +10,7 @@ import { registerSharedOutputs } from "../shared/index.js";
  * @param {string} content - The rendered inner content of the tag.
  * @returns {string} The fully rendered XML tag string.
  */
-const renderXmlTag = function (id, args, content) {
+const renderXmlTag = function (id, args, content, isSelfClosing) {
     // XML is case-sensitive, so we use the exact id provided
     const element = this.tag(id);
 
@@ -27,7 +27,7 @@ const renderXmlTag = function (id, args, content) {
 
     const hasBody = typeof content === "string" && content.trim().length > 0;
 
-    if (!hasBody) {
+    if (isSelfClosing || !hasBody) {
         return element.selfClose();
     }
 
@@ -55,7 +55,7 @@ const XML = Mapper.define({
     getUnknownTag(node) {
         const id = node.id;
         return {
-            render: ({ args, content }) => renderXmlTag.call(this, id, args, content),
+            render: ({ args, content, isSelfClosing }) => renderXmlTag.call(this, id, args, content, isSelfClosing),
             options: {
                 type: "any"
             }
@@ -71,13 +71,13 @@ XML.register("xml", ({ args }) => {
     const version = args.version || "1.0";
     const encoding = args.encoding || "UTF-8";
     return `<?xml version="${version}" encoding="${encoding}"?>`;
-}, { type: "Block", rules: { is_self_closing: true } });
+}, { type: "Block", rules: { is_empty_body: true } });
 
 /**
  * Registers the DOCTYPE declaration.
  * Usage: [doctype = root: "note", system: "note.dtd"]
  */
-XML.register("doctype", ({ args }) => {
+XML.register(["DOCTYPE", "doctype"], ({ args }) => {
     const root = args.root || "root";
     const system = args.system;
     const pub = args.public || args.fpi;
@@ -88,7 +88,7 @@ XML.register("doctype", ({ args }) => {
         return `<!DOCTYPE ${root} SYSTEM "${system}">`;
     }
     return `<!DOCTYPE ${root}>`;
-}, { type: "Block", rules: { is_self_closing: true } });
+}, { type: "Block", rules: { is_empty_body: true } });
 
 /**
  * Registers the XML stylesheet processing instruction.

package/mappers/mapper.js

@@ -32,7 +32,13 @@ class Mapper {
 	 * Registers a new tag rule. It needs a name and a function that says how to format it.
 	 * 
 	 * @param {string|Array<string>} id - The name of the tag (like 'Person' or ['p', 'para']).
-	 * @param {Function} renderOutput - The function that formats this tag.
+	 * @param {Function} renderOutput - The function that formats this tag. It receives:
+	 *    - `args`: Tag attributes.
+	 *    - `content`: Formatted inner content.
+	 *    - `textContent`: Raw inner text.
+	 *    - `nodeType`: Type of node (Block, Inline, etc.).
+	 *    - `isSelfClosing`: (Blocks only) True if marked with !.
+	 *    - `ast`: The full AST node.
 	 * @param {Object} [options={ escape: true }] - Settings for this tag.
 	 * @param {boolean} [options.escape=true] - If true, the content will be made safe for HTML automatically.
 	 */
@@ -48,12 +54,18 @@ class Mapper {
 		if (typeof renderOutput !== "function") {
 			throw new TypeError("argument 'renderOutput' expected to be a function");
 		}
-		
+
 		const render = renderOutput;
 
-		// Prevent duplicate IDs by removing any existing overlap before registering
+		// -- RESERVED KEYWORD PROTECTION --
+		// We protect core engine keywords that would cause syntax errors if used as tag names.
+		const RESERVED = new Set(["end", "import", "slot", "$use-module", "for-each"]);
 		const ids = Array.isArray(id) ? id : [id];
+
 		for (const singleId of ids) {
+			if (RESERVED.has(singleId.toLowerCase())) {
+				sommarkError(`<$red:Reserved Keyword Error:$> Cannot register mapper for <$yellow:${singleId}$>. This is a protected SomMark engine keyword.`);
+			}
 			this.removeOutput(singleId);
 		}
 
@@ -85,6 +97,10 @@ class Mapper {
 	 * @param {string} id - The output identifier to remove.
 	 */
 	removeOutput(id) {
+		if (typeof id !== "string") {
+			throw new TypeError("argument 'id' expected to be a string");
+		}
+
 		this.outputs = this.outputs
 			.map(output => {
 				if (Array.isArray(output.id)) {
@@ -120,6 +136,15 @@ class Mapper {
 		return "";
 	}
 
+	/**
+	 * Placeholder for block comment rendering. Should be overridden by specific mappers.
+	 * @param {string} text - The raw comment text.
+	 * @returns {string} - The formatted block comment string.
+	 */
+	commentBlock(text, indent = "") {
+		return this.comment(text);
+	}
+
 	/**
 	 * Formats a plain text node.
 	 * @param {string} text - The raw text content.
@@ -150,6 +175,13 @@ class Mapper {
 		return text;
 	}
 
+	/**
+	 * Formats runtime logic blocks natively.
+	 * By default, this returns an empty string to discard logic for formats like JSON/MDX.
+	 */
+	runtimeLogic(code, isGlobal) {
+		return "";
+	}
 
 	/**
 	 * Handles unknown tags. Should be overridden by specific mappers to provide fallback behavior.
@@ -245,7 +277,7 @@ class Mapper {
 		}));
 
 		newMapper.customProps = new Set(this.customProps);
-		
+
 		return newMapper;
 	}
 

package/mappers/shared/index.js

@@ -1,22 +1,21 @@
+import { runtimeError } from "../../core/errors.js";
+
 /**
- * Registers shared utility tags across HTML, Markdown, and MDX mappers.
+ * Registers universal utility tags shared across all SomMark mappers.
+ * These tags are considered "Format Agnostic."
+ * 
  * @param {Mapper} mapper - The mapper instance to register tags on.
  */
 export function registerSharedOutputs(mapper) {
     // 1. 'raw' - AtBlock that return the raw, unparsed content.
-    mapper.register("raw", ({ content }) => content, { 
+    mapper.register("raw", ({ content, nodeType }) => {
+        if (nodeType === "Block") {
+            return String(content);
+        }
+        return content;
+    }, {
         type: "AtBlock",
-        escape: false 
-    });
-
-    // 2. 'css' - An Inline tag that applies inline styles to its content.
-    // Usage: (text)->(css: "color: red")
-    mapper.register("css", ({ args, content }) => {
-        let style = mapper.safeArg({ args, index: 0, key: "style", fallBack: "" });
-        style = style.split(";").map(s => s.trim().split(":").map(s => s.trim()).join(":")).join(";");
-        return mapper.tag("span").attributes({ style }).body(content);
-    }, { 
-        type: "Inline" 
+        escape: false
     });
 
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sommark",
-	"version": "4.0.2",
+	"version": "4.1.0",
 	"description": "SomMark is a declarative, extensible markup language for structured content that can be converted to HTML, Markdown, MDX, JSON, XML, and more.",
 	"main": "index.js",
 	"files": [
@@ -61,10 +61,15 @@
 	"devDependencies": {
 		"@mdx-js/mdx": "^3.1.1",
 		"fast-xml-parser": "^5.5.11",
+		"isomorphic-dompurify": "^3.14.0",
 		"jsdom": "^29.0.2",
 		"remark": "^15.0.1",
 		"remark-gfm": "^4.0.1",
 		"remark-parse": "^11.0.0",
 		"vitest": "^4.0.16"
+	},
+	"dependencies": {
+		"@sebastianwessel/quickjs": "^1.1.1",
+		"acorn": "^8.15.0"
 	}
 }