sommark 4.5.3 → 5.0.1

package/mappers/languages/mdx.js

@@ -28,12 +28,11 @@ const MDX = Mapper.define({
 
 		return {
 			render: (ctx) => {
-				const { args, content, isSelfClosing } = ctx;
-				const element = this.tag(tagName).jsxProps(args);
+				const { props, content, isSelfClosing } = ctx;
+				const element = this.tag(tagName).jsxProps(props);
 				return (isSelfClosing || isVoid) ? element.selfClose() : element.body(content);
 			},
 			options: {
-				type: isVoid ? "Block" : (isCodeStyleOrScript ? ["Block", "AtBlock"] : ["Block", "Inline", "AtBlock"]),
 				escape: !isCodeStyleOrScript,
 				rules: { is_empty_body: isVoid }
 			}
@@ -50,32 +49,11 @@ const MDX = Mapper.define({
 	text(text, options) {
 		let out = text;
 		if (options?.escape !== false) {
-			out = this.escapeHTML(out);
+			out = this.md.mdxEscaper(out);
 		}
 		return out;
 	},
 
-	/**
-	 * Formats inline content before rendering, respecting explicit escape flags.
-	 */
-	inlineText(text, options) {
-		let out = text;
-		if (options?.escape !== false) {
-			out = this.escapeHTML(out);
-		}
-		return out;
-	},
-
-	/**
-	 * Formats the literal content inside AtBlocks.
-	 */
-	atBlockBody(text, options) {
-		let out = text;
-		if (options?.escape !== false) {
-			out = this.escapeHTML(out);
-		}
-		return out;
-	}
 });
 
 const { tag } = MDX;
@@ -84,47 +62,14 @@ MDX.inherit(MARKDOWN);
 MDX.md = MARKDOWN.md;
 
 ["h1", "h2", "h3", "h4", "h5", "h6"].forEach(h => {
-	MDX.register(h, function ({ args, content }) {
-		const format = this.safeArg({ args, key: "format", fallBack: "" });
+	MDX.register(h, function ({ props, content }) {
+		const format = this.safeArg({ props, 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);
+		delete props.format;
+		return tag(h).jsxProps(props).body(content);
 	});
 });
 
-/**
- * mdx AtBlock - Renders raw MDX content (ESM imports, exports, or complex JSX).
- */
-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

@@ -36,30 +36,13 @@ const TEXT = Mapper.define({
 		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";
+	getUnknownTag() {
 		return {
 			render: ({ content }) => content,
-			options: {
-				type: isBlock ? "Block" : (node.type === "AtBlock" ? "AtBlock" : "Inline")
-			}
+			options: {}
 		};
 	}
 });

package/mappers/languages/toml.js

@@ -0,0 +1,231 @@
+import Mapper from "../mapper.js";
+import { safeArg } from "../../helpers/utils.js";
+import { registerSharedOutputs } from "../shared/index.js";
+import { transpilerError } from "../../core/errors.js";
+
+const isValidInt    = (v) => v !== "" && !isNaN(Number(v)) && !v.includes(".");
+const isValidFloat  = (v) => v !== "" && !isNaN(Number(v)) && v.includes(".");
+const isValidNumber = (v) => v !== "" && !isNaN(Number(v));
+
+// Escape a string value for use inside TOML basic strings
+const tomlEscapeString = (str) =>
+	String(str ?? "")
+		.replace(/\\/g, "\\\\")
+		.replace(/"/g, '\\"')
+		.replace(/\x08/g, "\\b")
+		.replace(/\f/g, "\\f")
+		.replace(/\n/g, "\\n")
+		.replace(/\r/g, "\\r")
+		.replace(/\t/g, "\\t");
+
+// Quote a bare key segment if it contains characters outside [A-Za-z0-9_-]
+const toBareKey = (k) => /^[A-Za-z0-9_-]+$/.test(k) ? k : `"${tomlEscapeString(k)}"`;
+
+// Handle dotted keys like "database.host" → database.host
+const tomlKey = (key) => String(key).split(".").map(toBareKey).join(".");
+
+const ITEM_SEP = "\x1F";
+
+const TOML = Mapper.define({
+	comment(text) {
+		return `# ${text}`;
+	},
+	text(text) {
+		return text.trim() === "" ? "" : text;
+	}
+});
+
+/**
+ * [str] / [string] — string key-value pair or array string value
+ *
+ * Key-value:  [str = "title", "My App" !]         → title = "My App"
+ * Body form:  [str = "description"]Long text[end] → description = "Long text"
+ * In array:   [str = "hello" !]                   → "hello"
+ */
+TOML.register(["str", "string"], ({ props, textContent, inArray = false }) => {
+	const value = inArray
+		? safeArg({ props, index: 0, key: "value", fallBack: textContent.trim() })
+		: safeArg({ props, index: 1, key: "value", fallBack: textContent.trim() });
+	const escaped = `"${tomlEscapeString(String(value))}"`;
+	if (inArray) return escaped + ITEM_SEP;
+	const key = safeArg({ props, index: 0, key: "key", fallBack: "" });
+	return `${tomlKey(key)} = ${escaped}\n`;
+}, { handleAst: true });
+
+/**
+ * [int] / [integer] — integer key-value pair or array integer value
+ *
+ * Key-value:  [int = "port", "5432" !]  → port = 5432
+ * In array:   [int = "5432" !]          → 5432
+ */
+TOML.register(["int", "integer"], ({ props, textContent, inArray = false }) => {
+	const raw = String(safeArg({ props, index: inArray ? 0 : 1, key: "value", fallBack: textContent.trim() })).trim();
+	if (!isValidInt(raw))
+		transpilerError(`<$yellow:[int]$> expects a whole number but got <$yellow:'${raw}'$>.{N}Use <$cyan:[float]$> for decimal numbers or <$cyan:[number]$> for either.`);
+	if (inArray) return raw + ITEM_SEP;
+	const key = safeArg({ props, index: 0, key: "key", fallBack: "" });
+	return `${tomlKey(key)} = ${raw}\n`;
+}, { handleAst: true });
+
+TOML.register("float", ({ props, textContent, inArray = false }) => {
+	const raw = String(safeArg({ props, index: inArray ? 0 : 1, key: "value", fallBack: textContent.trim() })).trim();
+	if (!isValidFloat(raw))
+		transpilerError(`<$yellow:[float]$> expects a decimal number but got <$yellow:'${raw}'$>.{N}Use <$cyan:[int]$> for whole numbers or <$cyan:[number]$> for either.`);
+	if (inArray) return raw + ITEM_SEP;
+	const key = safeArg({ props, index: 0, key: "key", fallBack: "" });
+	return `${tomlKey(key)} = ${raw}\n`;
+}, { handleAst: true });
+
+TOML.register("number", ({ props, textContent, inArray = false }) => {
+	const raw = String(safeArg({ props, index: inArray ? 0 : 1, key: "value", fallBack: textContent.trim() })).trim();
+	if (!isValidNumber(raw))
+		transpilerError(`<$yellow:[number]$> expects a numeric value but got <$yellow:'${raw}'$>.`);
+	if (inArray) return raw + ITEM_SEP;
+	const key = safeArg({ props, index: 0, key: "key", fallBack: "" });
+	return `${tomlKey(key)} = ${raw}\n`;
+}, { handleAst: true });
+
+/**
+ * [bool] / [boolean] — boolean key-value pair or array bool value
+ *
+ * Key-value:  [bool = "debug", "false" !]  → debug = false
+ * In array:   [bool = "true" !]            → true
+ */
+TOML.register(["bool", "boolean"], ({ props, textContent, inArray = false }) => {
+	const raw = String(
+		inArray
+			? safeArg({ props, index: 0, key: "value", fallBack: textContent.trim() })
+			: safeArg({ props, index: 1, key: "value", fallBack: textContent.trim() })
+	).trim().toLowerCase();
+	const value = (raw === "true" || raw === "1" || raw === "yes") ? "true" : "false";
+	if (inArray) return value + ITEM_SEP;
+	const key = safeArg({ props, index: 0, key: "key", fallBack: "" });
+	return `${tomlKey(key)} = ${value}\n`;
+}, { handleAst: true });
+
+/**
+ * [datetime] — datetime key-value pair
+ * TOML datetimes are bare (unquoted): 1979-05-27T07:32:00Z
+ *
+ * [datetime = "born", "1979-05-27T07:32:00Z" !]  → born = 1979-05-27T07:32:00Z
+ */
+TOML.register("datetime", ({ props, textContent, inArray = false }) => {
+	const raw = String(
+		inArray
+			? safeArg({ props, index: 0, key: "value", fallBack: textContent.trim() })
+			: safeArg({ props, index: 1, key: "value", fallBack: textContent.trim() })
+	).trim();
+	if (inArray) return raw + ITEM_SEP;
+	const key = safeArg({ props, index: 0, key: "key", fallBack: "" });
+	return `${tomlKey(key)} = ${raw}\n`;
+}, { handleAst: true });
+
+/**
+ * [table] / [section] — renders a TOML table header + children
+ *
+ * [table = "database"]
+ *   [str = "host", "localhost" !]
+ *   [int = "port", "5432" !]
+ * [end]
+ *
+ * →
+ *
+ * [database]
+ * host = "localhost"
+ * port = 5432
+ */
+TOML.register(["table", "section"], async ({ props, ast, renderChild }) => {
+	const name = safeArg({ props, index: 0, key: "name", fallBack: "" });
+	const parts = [];
+	for (const child of ast.body) {
+		const out = await renderChild(child);
+		if (out != null && out.trim() !== "") parts.push(out);
+	}
+	return `[${tomlKey(name)}]\n${parts.join("")}\n`;
+}, { handleAst: true });
+
+/**
+ * [array-table] — renders a TOML array of tables entry
+ *
+ * [array-table = "servers"]
+ *   [str = "name", "alpha" !]
+ *   [str = "ip", "10.0.0.1" !]
+ * [end]
+ *
+ * →
+ *
+ * [[servers]]
+ * name = "alpha"
+ * ip = "10.0.0.1"
+ */
+TOML.register("array-table", async ({ props, ast, renderChild }) => {
+	const name = safeArg({ props, index: 0, key: "name", fallBack: "" });
+	const parts = [];
+	for (const child of ast.body) {
+		const out = await renderChild(child);
+		if (out != null && out.trim() !== "") parts.push(out);
+	}
+	return `[[${tomlKey(name)}]]\n${parts.join("")}\n`;
+}, { handleAst: true });
+
+/**
+ * [array] — renders a TOML inline array
+ * Children are rendered with inArray: true so they output just their value.
+ *
+ * [array = "ports"]
+ *   [int = "8001" !][int = "8002" !][int = "8003" !]
+ * [end]
+ *
+ * → ports = [8001, 8002, 8003]
+ *
+ * Works with [for-each] for dynamic arrays:
+ * [array = "tags"]
+ *   [for-each = ${ tags }$, as: "item"][str = ${ item }$ !][end]
+ * [end]
+ */
+/**
+ * Unknown tag — tag name becomes the TOML key, first positional arg is the value.
+ * Type is inferred: number → raw integer/float, true/false → boolean, everything else → quoted string.
+ *
+ * [name = "Adam" !]    → name = "Adam"
+ * [port = 5432 !]      → port = 5432
+ * [debug = false !]    → debug = false
+ * [bio]Long text[end]  → bio = "Long text"
+ */
+TOML.getUnknownTag = function (node) {
+	const key = node.id;
+	return {
+		render({ props, textContent, inArray = false }) {
+			const raw = String(
+				safeArg({ props, index: 0, key: "value", fallBack: textContent.trim() })
+			).trim();
+
+			let val;
+			if (raw === "true" || raw === "false") {
+				val = raw;
+			} else if (raw !== "" && !isNaN(Number(raw))) {
+				val = raw;
+			} else {
+				val = `"${tomlEscapeString(raw)}"`;
+			}
+
+			if (inArray) return val + ITEM_SEP;
+			return `${tomlKey(key)} = ${val}\n`;
+		},
+		options: { handleAst: true }
+	};
+};
+
+TOML.register("array", async ({ props, ast, renderChild }) => {
+	const key = safeArg({ props, index: 0, key: "key", fallBack: "" });
+	let combined = "";
+	for (const child of ast.body) {
+		combined += await renderChild(child, { inArray: true });
+	}
+	const vals = combined.split(ITEM_SEP).filter(v => v.trim() !== "");
+	return `${tomlKey(key)} = [${vals.join(", ")}]\n`;
+}, { handleAst: true });
+
+registerSharedOutputs(TOML);
+
+export default TOML;

package/mappers/languages/xml.js

@@ -6,19 +6,19 @@ import { registerSharedOutputs } from "../shared/index.js";
  * Ensures strict attribute quoting and handles self-closing tags for empty bodies.
  * 
  * @param {string} id - The XML tag identifier (case-sensitive).
- * @param {Object} args - Key-value pairs to be rendered as XML attributes.
+ * @param {Object} props - Key-value pairs to be rendered as XML attributes.
  * @param {string} content - The rendered inner content of the tag.
  * @returns {string} The fully rendered XML tag string.
  */
-const renderXmlTag = function (id, args, content, isSelfClosing) {
+const renderXmlTag = function (id, props, content, isSelfClosing) {
     // XML is case-sensitive, so we use the exact id provided
     const element = this.tag(id);
 
     // Filter out positional indices (numeric keys) for XML attributes
     const namedArgs = {};
-    Object.keys(args).forEach(key => {
+    Object.keys(props).forEach(key => {
         if (isNaN(parseInt(key))) {
-            namedArgs[key] = args[key];
+            namedArgs[key] = props[key];
         }
     });
 
@@ -55,10 +55,8 @@ const XML = Mapper.define({
     getUnknownTag(node) {
         const id = node.id;
         return {
-            render: ({ args, content, isSelfClosing }) => renderXmlTag.call(this, id, args, content, isSelfClosing),
-            options: {
-                type: "any"
-            }
+            render: ({ props, content, isSelfClosing }) => renderXmlTag.call(this, id, props, content, isSelfClosing),
+            options: {}
         };
     }
 });
@@ -67,20 +65,20 @@ const XML = Mapper.define({
  * Registers the XML declaration as a self-closing block.
  * Usage: [xml = version: "1.0", encoding: "UTF-8"]
  */
-XML.register("xml", ({ args }) => {
-    const version = args.version || "1.0";
-    const encoding = args.encoding || "UTF-8";
+XML.register("xml", ({ props }) => {
+    const version = props.version || "1.0";
+    const encoding = props.encoding || "UTF-8";
     return `<?xml version="${version}" encoding="${encoding}"?>`;
-}, { type: "Block", rules: { is_empty_body: true } });
+}, { rules: { is_empty_body: true } });
 
 /**
  * Registers the DOCTYPE declaration.
  * Usage: [doctype = root: "note", system: "note.dtd"]
  */
-XML.register(["DOCTYPE", "doctype"], ({ args }) => {
-    const root = args.root || "root";
-    const system = args.system;
-    const pub = args.public || args.fpi;
+XML.register(["DOCTYPE", "doctype"], ({ props }) => {
+    const root = props.root || "root";
+    const system = props.system;
+    const pub = props.public || props.fpi;
 
     if (pub && system) {
         return `<!DOCTYPE ${root} PUBLIC "${pub}" "${system}">`;
@@ -88,26 +86,28 @@ XML.register(["DOCTYPE", "doctype"], ({ args }) => {
         return `<!DOCTYPE ${root} SYSTEM "${system}">`;
     }
     return `<!DOCTYPE ${root}>`;
-}, { type: "Block", rules: { is_empty_body: true } });
+}, { rules: { is_empty_body: true } });
 
 /**
  * Registers the XML stylesheet processing instruction.
  * Usage: [xml-stylesheet = href: "style.xsl"]
  */
-XML.register("xml-stylesheet", ({ args }) => {
-    const type = args.type || "text/xsl";
-    const href = args.href;
+XML.register("xml-stylesheet", ({ props }) => {
+    const type = props.type || "text/xsl";
+    const href = props.href;
     if (!href) return "";
     return `<?xml-stylesheet type="${type}" href="${href}"?>`;
-}, { type: "Block", rules: { is_self_closing: true } });
+}, { rules: { is_empty_body: true } });
 
 /**
  * Registers CDATA sections.
- * Usage: @_cdata_@: ; raw content @_end_@
+ * Body form:    [cdata]raw content[end]
+ * Self-closing: [cdata = "raw content" !] or [cdata = text: "raw content" !]
  */
-XML.register("cdata", ({ content }) => {
-    return `<![CDATA[${content}]]>`;
-}, { type: "AtBlock" });
+XML.register("cdata", ({ props, content, isSelfClosing }) => {
+    const text = isSelfClosing ? (props[0] ?? props.text ?? "") : content;
+    return `<![CDATA[${text}]]>`;
+});
 
 registerSharedOutputs(XML);