sommark 4.5.2 → 5.0.0

package/formatter/mark.js

@@ -188,8 +188,42 @@ class MarkdownBuilder {
 		return result;
 	}
 
+	/**
+	 * Escapes Markdown trigger characters for MDX output using HTML entities instead of
+	 * backslashes. Backslash escapes render literally inside JSX text children, so entities
+	 * are the only reliable way to neutralise Markdown symbols in MDX.
+	 */
+	mdxEscaper(text) {
+		if (!text) return "";
+
+		// 1. HTML tags → entities (before & escaping to avoid double-encoding)
+		let result = text.replace(/<([a-zA-Z\/][^>]*?)>/g, "&lt;$1&gt;");
+
+		// 2. Ampersands and quotes
+		result = result
+			.replace(/&(?!lt;|gt;)/g, "&amp;")
+			.replace(/"/g, "&quot;")
+			.replace(/'/g, "&#39;");
 
+		// 3. Unordered list triggers: -, *, + at start of line followed by space
+		result = result.replace(/^([-*+])(\s+)/gm, (_, c, sp) => `&#${c.codePointAt(0)};${sp}`);
 
+		// 4. Ordered list triggers: 1. at start of line — encode the dot
+		result = result.replace(/^(\d+)\.(\s+)/gm, (_, n, sp) => `${n}&#46;${sp}`);
+
+		// 5. Emphasis triggers: *text*, **text**, _text_, ~~text~~
+		result = result.replace(/(\*+|_+|~~)(\S[\s\S]*?\S)\1/g, (_, prefix, content) => {
+			const enc = prefix.split("").map(c => `&#${c.codePointAt(0)};`).join("");
+			return enc + content + enc;
+		});
+
+		// 6. Horizontal rule triggers: ---, ***, ___ on their own line
+		result = result.replace(/^([*_-]{3,})\s*$/gm, (m) =>
+			m.replace(/[*_-]/g, c => `&#${c.codePointAt(0)};`)
+		);
+
+		return result;
+	}
 
 	/**
 	 * Formats data as a Markdown table.

package/formatter/tag.js

@@ -69,10 +69,8 @@ class TagBuilder {
 		const id = this.tagName.toLowerCase();
 		const isCodeStyleOrScript = ["style", "script"].includes(id);
 		let inline_style = "";
-		const useClassFallback = options.fallbackTarget === "class";
-		const classSet = new Set();
 
-		// 1. Initial CSS Variable/Style processing
+		// 1. Initial style processing
 		if (!isCodeStyleOrScript && args.style) {
 			if (typeof args.style === "object") {
 				inline_style = Object.entries(args.style)
@@ -85,20 +83,11 @@ class TagBuilder {
 			}
 		}
 
-		// 2. Pre-collect native classes if using class fallback
-		if (useClassFallback) {
-			if (args.class) {
-				String(args.class).split(/\s+/).filter(Boolean).forEach(c => classSet.add(c));
-			}
-		}
-
-		// 3. Attribute Dispatching
+		// 2. Attribute dispatching
 		const keys = Object.keys(args).filter(arg => isNaN(parseInt(arg)));
 		keys.forEach(key => {
-			if (!isNaN(parseInt(key))) return; // Skip numeric positional arguments
 			if (key === "style") return;
 			if (isCodeStyleOrScript && key === "scoped") return;
-			if (useClassFallback && key === "class") return;
 
 			const isDimensionAttributeSupported = ["img", "video", "svg", "canvas", "iframe", "object", "embed"].includes(id);
 			const isWidthOrHeight = key === "width" || key === "height";
@@ -108,38 +97,23 @@ class TagBuilder {
 			const isDataOrAria = kebabize(key).startsWith("data-") || kebabize(key).startsWith("aria-");
 
 			const k = isEvent ? key.toLowerCase() : (isNative || isCustom) ? key : kebabize(key);
+			const val = typeof args[key] === "object" ? JSON.stringify(args[key]) : args[key];
 
 			if (isCodeStyleOrScript || options.fallbackTarget === false) {
-				// Specialized tags or fallback disabled: render standard attributes, no styling fallback
-				const val = typeof args[key] === "object" ? JSON.stringify(args[key]) : args[key];
+				// Specialized tags or fallback disabled: render as standard attributes
 				this.#attr.push(`${k}="${escapeHTML(String(val))}"`);
 			} else {
-				// Standard elements: process smart fallbacks
 				if (isEvent || ((isNative || isCustom) && (!isWidthOrHeight || isDimensionAttributeSupported)) || isDataOrAria) {
-					const val = typeof args[key] === "object" ? JSON.stringify(args[key]) : args[key];
 					this.#attr.push(`${k}="${escapeHTML(String(val))}"`);
 				} else {
-					if (useClassFallback) {
-						const val = args[key];
-						if (val === true || val === "true") {
-							classSet.add(k);
-						} else if (val !== false && val !== "false" && val !== null && val !== undefined) {
-							classSet.add(`${k}-${val}`);
-						}
-					} else {
-						const val = typeof args[key] === "object" ? JSON.stringify(args[key]) : args[key];
-						inline_style += `${k}:${val};`;
-					}
+					// Unknown attribute: fall through to inline style
+					inline_style += `${k}:${val};`;
 				}
 			}
 		});
 
-		if (useClassFallback && classSet.size > 0) {
-			this.#attr.push(`class="${escapeHTML([...classSet].join(" "))}"`);
-		}
-
 		if (inline_style) {
-			// V4 DYNAMIC CSS: Automatically wrap CSS variables in var()
+			// Wrap CSS variables in var()
 			const processedStyle = inline_style.replace(/(^|[^\w\-_$])(--[\w\-_$]+)(?![\w\-_$]|:)/g, "$1var($2)");
 			this.#attr.push(`style="${escapeHTML(processedStyle)}"`);
 		}

package/helpers/utils.js

@@ -90,9 +90,9 @@ export function matchedValue(outputs, targetId) {
  * @param {any} [options.fallBack=null] - Value to return if resolution or validation fails.
  * @returns {any} - The resolved argument value or the fallback.
  */
-export function safeArg({ args, index, key, type = null, setType = null, fallBack = null }) {
-        if (typeof args !== 'object' || args === null) {
-                sommarkError([`{line}<$red:TypeError:$> <$yellow:args must be an object$>{line}`]);
+export function safeArg({ props, index, key, type = null, setType = null, fallBack = null }) {
+        if (typeof props !== 'object' || props === null) {
+                sommarkError([`{line}<$red:TypeError:$> <$yellow:props must be an object$>{line}`]);
         }
 
         if (index === undefined && key === undefined) {
@@ -102,7 +102,6 @@ export function safeArg({ args, index, key, type = null, setType = null, fallBac
         const validate = value => {
                 if (value === undefined) return false;
 
-                // Handle explicit type check functions (e.g., isObject, isArray)
                 if (typeof type === 'function') {
                         return type(value);
                 }
@@ -112,30 +111,30 @@ export function safeArg({ args, index, key, type = null, setType = null, fallBac
                 return typeof evaluated === type;
         };
 
-        if (index !== undefined && validate(args[index])) {
-                return args[index];
+        if (index !== undefined && validate(props[index])) {
+                return props[index];
         }
 
-        if (key !== undefined && validate(args[key])) {
-                return args[key];
+        if (key !== undefined && validate(props[key])) {
+                return props[key];
         }
 
         return fallBack;
 }
 
 /**
- * Extracts and returns all positional arguments from the Object-based 'args' structure of V4.
- * 
- * @param {Object} args - The AST node's argument object.
- * @returns {Array<any>} - An ordered array of positional argument values.
+ * Extracts positional props from a block node's props object.
+ *
+ * @param {Object} props - The block node's props object.
+ * @returns {Array<any>} - An ordered array of positional prop values.
  */
-export function getPositionalArgs(args) {
-        if (!args) return [];
-        const keys = Object.keys(args);
+export function getPositionalArgs(props) {
+        if (!props) return [];
+        const keys = Object.keys(props);
         const result = keys
                 .filter(k => !isNaN(parseInt(k)))
                 .sort((a, b) => parseInt(a) - parseInt(b))
-                .map(k => args[k]);
+                .map(k => props[k]);
 
         return result;
 }

package/index.js

@@ -1,4 +1,4 @@
-import SomMark, { setDefaultFs, setDefaultCwd, setDefaultFindAndLoadConfig } from "./index.shared.js";
+import SomMark, { setDefaultFs, setDefaultCwd, setDefaultFindAndLoadConfig, setDefaultResolvePath } from "./index.shared.js";
 export * from "./index.shared.js";
 
 // Node-specific filesystem import
@@ -14,6 +14,14 @@ if (typeof process !== "undefined" && process.versions?.node) {
 setDefaultFs(nodeFs);
 if (typeof process !== "undefined" && process.cwd) setDefaultCwd(process.cwd());
 
+// Resolve filenames to absolute paths for clear error messages
+if (typeof process !== "undefined" && process.versions?.node) {
+	try {
+		const nodePath = await import("node:path");
+		setDefaultResolvePath(nodePath.resolve.bind(nodePath));
+	} catch (e) {}
+}
+
 // Node-specific config-loader import
 let findAndLoadConfigFn = async () => ({});
 if (typeof process !== "undefined" && process.versions?.node) {

package/index.shared.js

@@ -11,9 +11,12 @@ import MDX from "./mappers/languages/mdx.js";
 import Json from "./mappers/languages/json.js";
 import Jsonc from "./mappers/languages/jsonc.js";
 import XML from "./mappers/languages/xml.js";
+import CSV from "./mappers/languages/csv.js";
+import TOML from "./mappers/languages/toml.js";
+import YAML from "./mappers/languages/yaml.js";
 import TEXT from "./mappers/languages/text.js";
 import { runtimeError } from "./core/errors.js";
-import FORMATS, { textFormat, htmlFormat, markdownFormat, mdxFormat, jsonFormat, jsoncFormat, xmlFormat } from "./core/formats.js";
+import FORMATS, { textFormat, htmlFormat, markdownFormat, mdxFormat, jsonFormat, jsoncFormat, xmlFormat, csvFormat, tomlFormat, yamlFormat } from "./core/formats.js";
 import TOKEN_TYPES from "./core/tokenTypes.js";
 import * as labels from "./core/labels.js";
 import { resolveModules } from "./core/modules.js";
@@ -26,6 +29,7 @@ import { preprocessRuntimeLogic } from "./core/helpers/preprocessor.js";
 let defaultFs = null;
 let defaultCwd = "/";
 let defaultFindAndLoadConfig = async () => ({});
+let defaultResolvePath = (p) => p; // identity in browser; overridden to path.resolve in Node.js
 
 const isURL = (s) => typeof s === "string" && /^https?:\/\//.test(s);
 
@@ -38,6 +42,12 @@ export function setDefaultFs(fs) {
 	Evaluator.setDefaultFs(fs);
 }
 
+export function setDefaultResolvePath(fn) {
+	defaultResolvePath = fn;
+}
+
+const resolveFilename = (f) => (f && f !== "anonymous") ? defaultResolvePath(f) : f;
+
 export function setDefaultFindAndLoadConfig(fn) {
 	defaultFindAndLoadConfig = fn;
 }
@@ -64,18 +74,16 @@ class SomMark {
 	 * @param {string} [options.baseDir=null] - The base directory for resolving relative paths.
 	 */
 	constructor(options = {}) {
-		const { src, ast = null, format, mapperFile = null, filename = "anonymous", removeComments = true, placeholders = {}, customProps = [], fallbackTarget = "style", outputValidator = null, importAliases = {}, importStack = [], baseDir = null, moduleCache = null, showSpinner = true, security = {}, generateRuntimeOutput = false, hideRuntimeOutput = false, dualOutput = false, moduleIdentityToken = null } = options;
+		const { src, ast = null, format, mapperFile = null, filename = "anonymous", removeComments = true, placeholders = {}, customProps = [], fallbackTarget = "style", outputValidator = null, importAliases = {}, importStack = [], baseDir = null, moduleCache = null, showSpinner = true, security = {}, dualOutput = false, moduleIdentityToken = null } = options;
 		this.rawSettings = options;
 		this.src = src;
 		this.ast = ast;
 		this.targetFormat = format;
 		this.mapperFile = mapperFile;
-		this.filename = filename;
+		this.filename = resolveFilename(filename);
 		this.removeComments = removeComments;
 		this.placeholders = placeholders;
 		this.customProps = customProps;
-		this.generateRuntimeOutput = generateRuntimeOutput;
-		this.hideRuntimeOutput = hideRuntimeOutput;
 		this.dualOutput = dualOutput;
 		this.cwd = options.baseDir || (options.files ? "/" : defaultCwd);
 		this.fs = options.fs
@@ -115,7 +123,7 @@ class SomMark {
 
 		this.Mapper = Mapper;
 
-		const mapperFiles = { [htmlFormat]: HTML, [markdownFormat]: MARKDOWN, [mdxFormat]: MDX, [jsonFormat]: Json, [jsoncFormat]: Jsonc, [xmlFormat]: XML, [textFormat]: TEXT };
+		const mapperFiles = { [htmlFormat]: HTML, [markdownFormat]: MARKDOWN, [mdxFormat]: MDX, [jsonFormat]: Json, [jsoncFormat]: Jsonc, [xmlFormat]: XML, [csvFormat]: CSV, [tomlFormat]: TOML, [yamlFormat]: YAML, [textFormat]: TEXT };
 
 		if (!this.mapperFile && this.targetFormat) {
 			const DefaultMapper = mapperFiles[this.targetFormat];
@@ -290,8 +298,6 @@ class SomMark {
 				mapperFile: this.mapperFile,
 				security: this.security,
 				settings: this.rawSettings,
-				generateRuntimeOutput: this.generateRuntimeOutput,
-				hideRuntimeOutput: this.hideRuntimeOutput,
 				dualOutput: this.dualOutput,
 				instance: this
 			});
@@ -324,7 +330,7 @@ const lex = async (src, filename = "anonymous") => {
 	if (typeof src !== "string") {
 		runtimeError([`{line}<$red:Invalid Source Type:$> <$yellow:The 'src' argument must be a string, received ${typeof src}.$>{line}`]);
 	}
-	return lexer(src, filename);
+	return lexer(src, resolveFilename(filename));
 };
 
 /**
@@ -391,7 +397,7 @@ const lexSync = (src, filename = "anonymous") => {
 	if (typeof src !== "string") {
 		runtimeError([`{line}<$red:Invalid Source Type:$> <$yellow:The 'src' argument must be a string, received ${typeof src}.$>{line}`]);
 	}
-	return lexer(src, filename);
+	return lexer(src, resolveFilename(filename));
 };
 
 /**
@@ -408,8 +414,9 @@ const parseSync = (src, filename = "anonymous") => {
 	if (typeof src !== "string") {
 		runtimeError([`{line}<$red:Invalid Source Type:$> <$yellow:The 'src' argument must be a string, received ${typeof src}.$>{line}`]);
 	}
-	const tokens = lexer(src, filename);
-	return parser(tokens, filename);
+	const resolved = resolveFilename(filename);
+	const tokens = lexer(src, resolved);
+	return parser(tokens, resolved);
 };
 
 async function findAndLoadConfig(targetPath) {
@@ -427,6 +434,9 @@ export {
 	Json,
 	Jsonc,
 	XML,
+	CSV,
+	TOML,
+	YAML,
 	Mapper,
 	FORMATS,
 	lex,

package/mappers/languages/csv.js

@@ -0,0 +1,62 @@
+import Mapper from "../mapper.js";
+import { registerSharedOutputs } from "../shared/index.js";
+
+const csvEscape = (value) => {
+	const str = String(value ?? "").trim();
+	if (str.includes(",") || str.includes('"') || str.includes("\n") || str.includes("\r")) {
+		return `"${str.replace(/"/g, '""')}"`;
+	}
+	return str;
+};
+
+const rowFromProps = (props) =>
+	Object.keys(props)
+		.filter(k => !isNaN(parseInt(k)))
+		.sort((a, b) => parseInt(a) - parseInt(b))
+		.map(k => csvEscape(props[k]))
+		.join(",");
+
+const renderRow = async ({ props, ast, isSelfClosing, renderChild }) => {
+	if (isSelfClosing) return rowFromProps(props) + "\n";
+	const cells = [];
+	for (const child of ast.body.filter(c => c.type === "Block")) {
+		const out = await renderChild(child);
+		if (out != null && out !== "") cells.push(out);
+	}
+	return cells.join(",") + "\n";
+};
+
+const CSV = Mapper.define({
+	comment(text) {
+		return `# ${text}`;
+	},
+	text(text) {
+		return text.trim() === "" ? "" : text;
+	}
+});
+
+/**
+ * [header] — header row
+ * Self-closing: [header = "name", "age", "city" !]
+ * Body form:    [header][col]name[end][col]age[end][end]
+ */
+CSV.register(["header", "thead"], renderRow, { handleAst: true });
+
+/**
+ * [row] / [tr] — data row
+ * Self-closing: [row = "Alice", "30", "New York" !]
+ * Body form:    [row][col]Alice[end][col]30[end][end]
+ */
+CSV.register(["row", "tr"], renderRow, { handleAst: true });
+
+/**
+ * [col] / [cell] / [td] — single cell, used inside body-form rows
+ * [col]New York, NY[end]
+ */
+CSV.register(["col", "cell", "td"], ({ textContent }) => {
+	return csvEscape(textContent);
+}, { handleAst: true, trimAndWrapBlocks: false });
+
+registerSharedOutputs(CSV);
+
+export default CSV;

package/mappers/languages/html.js

@@ -1,27 +1,32 @@
 import Mapper from "../mapper.js";
 import { VOID_ELEMENTS } from "../../constants/void_elements.js";
+import { SVG_ELEMENTS } from "../../constants/svg_elements.js";
 import { registerSharedOutputs } from "../shared/index.js";
-import kebabize from "../../helpers/kebabize.js";
 
 /**
  * Helper to format an HTML tag with attributes and content.
  * 
  * @param {string} id - The name of the HTML tag.
- * @param {Object} args - The attributes for the tag.
+ * @param {Object} props - The attributes for the tag.
  * @param {string} content - The text or tags inside this tag.
  * @returns {string} - The finished HTML string.
  */
-const renderHtmlTag = function (id, args, content, isSelfClosing) {
+const renderHtmlTag = function (id, props, content, isSelfClosing) {
 	const element = this.tag(id);
+	const idLower = id.toLowerCase();
 
-	element.smartAttributes(args, this.customProps, this.options);
+	if (SVG_ELEMENTS.has(idLower)) {
+		element.attributes(props);
+	} else {
+		element.smartAttributes(props, this.customProps, this.options);
+	}
 
 	let finalContent = content;
-	if (id.toLowerCase() === "script" && args.scoped === true) {
+	if (idLower === "script" && props.scoped === true) {
 		finalContent = `(function(){\n${content}\n})();`;
 	}
 
-	if (VOID_ELEMENTS.has(id.toLowerCase()) || isSelfClosing) {
+	if (VOID_ELEMENTS.has(idLower) || isSelfClosing) {
 		return element.selfClose();
 	}
 
@@ -65,43 +70,21 @@ const HTML = Mapper.define({
 		return this.escapeHTML(text);
 	},
 
-	/**
-	 * Formats text inside inline tags (like bold or links).
-	 */
-	inlineText(text, options) {
-		if (options?.escape !== false) {
-			return this.escapeHTML(text);
-		}
-		return text;
-	},
-
-	/**
-	 * Formats the content inside AtBlocks.
-	 */
-	atBlockBody(text, options) {
-		let out = String(text);
-		if (options?.escape !== false) {
-			out = this.escapeHTML(out);
-		}
-		return out;
-	},
-
 	/**
 	 * Provides high-fidelity fallback for unknown ids by rendering them as HTML elements.
 	 * @param {Object} node - The unknown AST node.
 	 * @returns {Object} - A virtual id registration for fallback rendering.
 	 */
 	getUnknownTag(node) {
-		const id = node.id.toLowerCase();
-		const isVoid = VOID_ELEMENTS.has(id);
-		const isCodeStyleOrScript = ["code", "style", "script"].includes(id);
+		const idLower = node.id.toLowerCase();
+		const isVoid = VOID_ELEMENTS.has(idLower);
+		const isCodeStyleOrScript = ["code", "style", "script"].includes(idLower);
 
 		return {
-			render: function ({ args, content, isSelfClosing }) { return renderHtmlTag.call(this, id, args, content, isSelfClosing); },
+			render: function ({ props, content, isSelfClosing }) { return renderHtmlTag.call(this, node.id, props, content, isSelfClosing); },
 			options: {
-				type: isCodeStyleOrScript ? ["Block", "AtBlock"] : ["Block", "Inline"],
 				escape: !isCodeStyleOrScript,
-				rules: { is_self_closing: isVoid }
+				rules: { is_empty_body: isVoid }
 			}
 		};
 	},
@@ -114,7 +97,7 @@ const HTML = Mapper.define({
 // DOCTYPE tag
 HTML.register(["DOCTYPE", "doctype"], () => {
 	return "<!DOCTYPE html>";
-}, { type: "Block", rules: { is_self_closing: true } });
+}, { rules: { is_empty_body: true } });
 
 // head tag
 HTML.register("head", function ({ content }) {
@@ -123,52 +106,21 @@ HTML.register("head", function ({ content }) {
 		varsStyle = `<style>:root { ${this.cssVariables} }</style>\n`;
 	}
 	return this.tag("head").body(`${varsStyle}${content}`);
-}, { type: "Block", escape: false });
+}, { escape: false });
 
 // Root tag for Metadata and CSS Variables (Collector)
 HTML.register(
 	["Root", "root"],
-	function ({ args }) {
+	function ({ props }) {
 		this.cssVariables = this.cssVariables || "";
-		Object.keys(args).forEach(key => {
+		Object.keys(props).forEach(key => {
 			if (key.startsWith("--")) {
-				this.cssVariables += `${key}:${args[key]};`;
+				this.cssVariables += `${key}:${props[key]};`;
 			}
 		});
 		return "";
 	},
-	{
-		type: "Block"
-	}
 );
-// Inline CSS tag (Moved from shared)
-HTML.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 => `${kebabize(k)}:${args[k]}`)
-		.join(";");
-
-	// Fetch positional style string (index 0) or "style" key if present
-	let positionalStyle = HTML.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(";");
-
-	style = style.split(";").filter(s => s.trim()).map(s => s.trim().split(":").map(s => s.trim()).join(":")).join(";");
-	return HTML.tag("span").attributes({ style }).body(content);
-}, {
-	type: "Inline"
-});
 registerSharedOutputs(HTML);
 
 export default HTML;