sommark 1.1.1 → 2.0.0-beta.1

package/CHANGELOG.md

@@ -35,3 +35,77 @@
 ### Bug Fixes
 
 - **CLI**: Fixed a bug where passing a Mapper object in `smark.config.js` (Custom Mode) caused a crash. The CLI now correctly handles both file path strings and imported Mapper objects.
+
+
+## 1.2.0 (2026-01-14)
+
+### Bug Fixes
+
+* Fixed an issue where consecutive standalone blocks were not fully rendered when not separated by a blank line.
+
+```ini
+[Block]
+This is a test.
+[end]
+[Block]
+This is another test.
+[end]
+```
+
+* Added support for inline block content while keeping the original multiline syntax fully compatible.
+
+```yaml
+[Block]Hello World[end]
+```
+
+---
+
+### Code Improvements
+
+* Removed unnecessary code
+* Improved internal implementation
+
+---
+
+## v2.0.0-beta.1 (2026-01-17)
+
+### Breaking Changes
+
+* Replaced backtick-based escape syntax (`escape content`) with a single-character escape using backslash (`\`).
+* Escape handling is now active inside **at-blocks**, inline values, and block bodies.
+* Documents using the previous escape syntax must be updated.
+
+---
+
+### Parser & Lexer Improvements
+
+* Refactored character concatenation logic by replacing the single `concat` function with specialized handlers:
+
+  * `concatText`
+  * `concatEscape`
+  * `concatChar`
+
+  This separation eliminated multiple hidden parsing bugs and significantly improved maintainability.
+
+* Fixed an issue where **at-block endings were incorrectly treated as text** when preceded by leading spaces, which could corrupt the entire document.
+
+* Fixed errors caused by starting a new block on the same line where a previous block ended (e.g. `[end][Block]`).
+
+* Improved correctness when handling consecutive blocks without implicit line separation.
+
+---
+
+### Internal Improvements
+
+* Simplified escape handling for safer and more predictable parsing
+* Improved compatibility between escapes, inline values, and at-block bodies
+* Reduced parser complexity and improved stability
+
+---
+
+### Notes
+
+This release introduces **intentional breaking changes** to core grammar behavior.
+It is published as a **beta** to allow validation before the stable **v2.0.0** release.
+
+---

package/README.md

@@ -18,7 +18,7 @@
 
 <p align="center">
 <img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" />
-<img src="https://img.shields.io/badge/version-v1.0.0-blue?style=flat-square" />
+<img src="https://img.shields.io/npm/v/sommark?style=flat-square" />
 <img src="https://img.shields.io/badge/type-markup%20language-purple?style=flat-square" />
 <img src="https://img.shields.io/badge/html-supported-orange?style=flat-square" />
 <img src="https://img.shields.io/badge/markdown-supported-lightyellow?style=flat-square" />
@@ -28,7 +28,7 @@
 
 ---
 
-# SomMark v1
+# SomMark v2-beta
 
 SomMark is a simple and extensible markup language designed for writing documentation and structured content. It is easy to read, easy to parse, and easy to convert into formats like HTML, Markdown, and MDX.
 

package/core/lexer.js

@@ -3,11 +3,16 @@ import peek from "../helpers/peek.js";
 import { block_value, block_id, inline_id, inline_value, at_id, at_value, end_keyword } from "./names.js";
 import { lexerError } from "./validator.js";
 
-function concat(input, index, stop_at_char = [], scope_state, include_then_break = false, escapeChar = "") {
-	let str = "";
-	for (let char_index = index; char_index < input.length; char_index++) {
-		let char = input[char_index];
-		if (stop_at_char === null) {
+function concatText(input, index, scope_state) {
+	let text = "";
+	if (
+		(Array.isArray(input) || typeof input === "string") &&
+		input.length > 0 &&
+		typeof index === "number" &&
+		typeof scope_state === "boolean"
+	) {
+		for (let i = index; i < input.length; i++) {
+			const char = input[i];
 			if (char === "\n") {
 				break;
 			} else if (char === "[" && !scope_state) {
@@ -18,33 +23,75 @@ function concat(input, index, stop_at_char = [], scope_state, include_then_break
 				break;
 			} else if (char === "(" && !scope_state) {
 				break;
-			} else if (char === "-" && peek(input, char_index, 1) === ">" && !scope_state) {
+			} else if (char === "-" && peek(input, i, 1) === ">" && !scope_state) {
 				break;
-			} else if (char === "@" && peek(input, char_index, 1) === "_" && !scope_state) {
+			} else if (char === "@" && peek(input, i, 1) === "_") {
 				break;
-			} else if (char === "_" && peek(input, char_index, 1) === "@" && !scope_state) {
+			} else if (char === "_" && peek(input, i, 1) === "@") {
 				break;
 			} else if (char === "#" && !scope_state) {
 				break;
-			} else if (char === "`" && !scope_state) {
+			} else if (char === "\\") {
 				break;
 			}
-			str += char;
+			text += char;
+		}
+		return text;
+	} else {
+		lexerError([
+			"{line}<$red:Invalid Arguments:$> <$yellow:Assign arguments to their correct types, ",
+			"'input' must be an array and have to be not empty, 'index' must be a number value, and 'scope_state' ",
+			"must be a boolean.$>{line}."
+		]);
+	}
+}
+
+function concatEscape(input, index) {
+	if ((Array.isArray(input) || typeof input === "string") && input.length > 0 && typeof index === "number") {
+		let str = "";
+		if (input[index] === "\\" && peek(input, index, 1)) {
+			str += "\\" + peek(input, index, 1);
 		} else {
-			if (char === escapeChar && peek(input, char_index, 1) === "`") {
-				str += char + peek(input, char_index, 1);
-				break;
-			} else if (char === escapeChar && peek(input, char_index, 1) !== "`") {
-				break;
-			} else if (char !== escapeChar && Array.isArray(stop_at_char) && stop_at_char.includes(char)) {
-				include_then_break ? (str += char) : null;
-				break;
-			}
-			str += char;
+			lexerError(["{line}<$red:Next character is not found:$> <$yellow:There is no character after escape character!$>{line}"]);
 		}
+		return str;
+	} else {
+		lexerError([
+			"{line}<$red:Invalid Arguments:$> <$yellow:Assign arguments to their correct types, ",
+			"'input' must be an array and have to be not empty, and 'index' must be a number value.$>{line}"
+		]);
 	}
+}
 
-	return str;
+function concatChar(input, index, stop_at_char, scope_state) {
+	if (
+		(Array.isArray(input) || typeof input === "string") &&
+		input.length > 0 &&
+		typeof index === "number" &&
+		typeof scope_state === "boolean"
+	) {
+		let str = "";
+		if (Array.isArray(stop_at_char) && stop_at_char.length > 0) {
+			for (let i = index; i < input.length; i++) {
+				const char = input[i];
+				if (stop_at_char.includes(char)) {
+					break;
+				}
+				str += char;
+			}
+		} else {
+			lexerError([
+				"{line}<$red:Invalid Type:$> <$yellow:Argument 'stop_at_char' must be an array and have to be not empty array$>{line}"
+			]);
+		}
+		return str;
+	} else {
+		lexerError([
+			"{line}<$red:Invalid Arguments:$> <$yellow:Assign arguments to their correct types, ",
+			"'input' must be an array and have to be not empty, 'index' must be a number value, and 'scope_state' ",
+			"must be a boolean.$>{line}"
+		]);
+	}
 }
 
 function lexer(src) {
@@ -77,7 +124,7 @@ function lexer(src) {
 					end = start;
 				}
 				// Push to depth if next token is not end_keyword
-				temp_str = concat(src, i + 1, ["]"], scope_state);
+				temp_str = concatChar(src, i + 1, ["]"], scope_state);
 				if (temp_str && temp_str.length > 0) {
 					if (temp_str.trim() !== end_keyword) {
 						depth_stack.push("Block");
@@ -171,21 +218,19 @@ function lexer(src) {
 				addToken(TOKEN_TYPES.NEWLINE, current_char);
 			}
 			// Escape character
-			else if (current_char === "`" && !scope_state) {
-				temp_str = current_char + concat(src, i + 1, ["`"], scope_state, true);
-				if (temp_str && temp_str.length > 0) {
+			else if (current_char === "\\") {
+				temp_str = concatEscape(src, i, scope_state);
+				if (temp_str.trim() && temp_str.length > 0) {
 					i += temp_str.length - 1;
-					if (previous_value === "(") {
-						addToken(TOKEN_TYPES.VALUE, temp_str);
-					} else {
-						addToken(TOKEN_TYPES.TEXT, temp_str);
-					}
+					addToken(TOKEN_TYPES.ESCAPE, temp_str);
 				}
 			}
-			// Token: Block Identifier OR Token: Block Value OR Token: End Keyword
+			// Token: Block Identifier
+			// Token: Block Value
+			// Token: End Keyword
 			else {
 				if (previous_value === "[" || (previous_value === "=" && !scope_state)) {
-					temp_str = concat(src, i, ["=", "]", "\n"], scope_state);
+					temp_str = concatChar(src, i, ["=", "]", "\n"], scope_state);
 					i += temp_str.length - 1;
 					// Update Column
 					start = end !== undefined ? end : 1;
@@ -211,9 +256,10 @@ function lexer(src) {
 						}
 					}
 				}
-				// Token: Inline Value OR Token: Inline Identifier
+				// Token: Inline Value
+				// Token: Inline Identifier
 				else if (previous_value === "(" || (previous_value === "->" && !scope_state)) {
-					temp_str = concat(src, i, [")", "["], scope_state, true, ")");
+					temp_str = concatChar(src, i, [")", "[", "\\"], scope_state);
 					i += temp_str.length - 1;
 					// Update Column
 					start = end !== undefined ? end : 1;
@@ -230,9 +276,11 @@ function lexer(src) {
 						}
 					}
 				}
-				// Token: At Identifier OR Token: At Value OR Token: End Keyword
+				// Token: At Identifier
+				// Token: At Value
+				// Token: End Keyword
 				else if (previous_value === "@_" || previous_value === ":") {
-					temp_str = concat(src, i, ["_", "\n"], scope_state);
+					temp_str = concatChar(src, i, ["_", "\n"], scope_state);
 					i += temp_str.length - 1;
 					if (temp_str.trim()) {
 						// Update Column
@@ -260,7 +308,7 @@ function lexer(src) {
 				}
 				// Token: Comment
 				else if (current_char === "#") {
-					temp_str = concat(src, i, ["\n"], scope_state);
+					temp_str = concatChar(src, i, ["\n"], scope_state);
 					// Update Column
 					start = previous_value === "\n" ? end : end !== undefined ? end + 1 : 1;
 					end = start + temp_str.length;
@@ -271,7 +319,7 @@ function lexer(src) {
 				}
 				// Token: Text
 				else {
-					context = concat(src, i, null, scope_state);
+					context = concatText(src, i, scope_state);
 					i += context.length - 1;
 					// Update Column
 					start = previous_value === "\n" ? end : end !== undefined ? end + 1 : 1;

package/core/parser.js

@@ -111,9 +111,10 @@ function parseBlock(tokens, i) {
 	block_stack.push(1);
 	end_stack.pop();
 	const blockNode = makeBlockNode();
+	// consume '['
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (current_token(tokens, i).type === TOKEN_TYPES.IDENTIFIER) {
 		const id = current_token(tokens, i).value.trim();
 		validateId(id);
@@ -122,13 +123,15 @@ function parseBlock(tokens, i) {
 	} else {
 		parserError(errorMessage(tokens, i, block_id, "["));
 	}
+	// consume Block identifier
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.EQUAL) {
+		// consume '='
+		i++;
 		// Update Data
 		updateData(tokens, i);
-		i++;
 		if (current_token(tokens, i).type === TOKEN_TYPES.VALUE) {
 			current_token(tokens, i)
 				.value.split(",")
@@ -138,9 +141,10 @@ function parseBlock(tokens, i) {
 		} else {
 			parserError(errorMessage(tokens, i, block_value, "="));
 		}
+		// consume Block value
+		i++;
 		// Update Data
 		updateData(tokens, i);
-		i++;
 	}
 	if (current_token(tokens, i) && current_token(tokens, i).type !== TOKEN_TYPES.CLOSE_BRACKET) {
 		if (peek(tokens, i, -1) && peek(tokens, i, -1).type === TOKEN_TYPES.VALUE) {
@@ -149,20 +153,22 @@ function parseBlock(tokens, i) {
 			parserError(errorMessage(tokens, i, "]", block_id));
 		}
 	}
-	// Update Data
-	updateData(tokens, i);
+	// consume ']'
 	i++;
-	if (!current_token(tokens, i) || current_token(tokens, i).value !== "\n") {
-		parserError(errorMessage(tokens, i, "\\n", "]"));
-	}
 	// Update Data
 	updateData(tokens, i);
-	i++;
+	if (current_token(tokens, i) && current_token(tokens, i).type == TOKEN_TYPES.NEWLINE) {
+		// consume '\n'
+		i++;
+		// Update Data
+		updateData(tokens, i);
+	}
 	tokens_stack.length = 0;
 	while (i < tokens.length) {
 		if (current_token(tokens, i).value === "[" && peek(tokens, i, 1).value !== "end") {
 			const [childNode, nextIndex] = parseBlock(tokens, i);
 			blockNode.body.push(childNode);
+			// consume child node
 			i = nextIndex;
 			// Update Data
 			updateData(tokens, i);
@@ -170,20 +176,17 @@ function parseBlock(tokens, i) {
 			current_token(tokens, i).type === TOKEN_TYPES.OPEN_BRACKET &&
 			peek(tokens, i, 1).type === TOKEN_TYPES.END_KEYWORD
 		) {
+			// consume end keyword
+			i++;
 			// Update Data
 			updateData(tokens, i);
-			i++;
 			if (current_token(tokens, i).type === TOKEN_TYPES.END_KEYWORD) {
-				// Update Data
-				updateData(tokens, i);
-				if (peek(tokens, i, 1) && peek(tokens, i, 1).type === TOKEN_TYPES.CLOSE_BRACKET) {
-					// Update Data
-					updateData(tokens, i + 1);
-				} else {
+				if (peek(tokens, i, 1) && peek(tokens, i, 1).type !== TOKEN_TYPES.CLOSE_BRACKET) {
 					parserError(errorMessage(tokens, i, "]", end_keyword));
 				}
 			}
 			block_stack.pop();
+			// consume end keyword and ']'
 			i += 2;
 			// Update Data
 			updateData(tokens, i);
@@ -195,49 +198,69 @@ function parseBlock(tokens, i) {
 				continue;
 			}
 			blockNode.body.push(childNode);
-			if (blockNode.body[0].value === "\n") {
-				blockNode.body.splice(0, 1);
-			}
 			i = nextIndex;
 		}
 	}
-	i++;
 	return [blockNode, i];
 }
 
 // Parse Inline Statements
 function parseInline(tokens, i) {
 	const inlineNode = makeInlineNode();
+	// consume '('
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (current_token(tokens, i).type === TOKEN_TYPES.VALUE) {
 		inlineNode.value = current_token(tokens, i).value;
 		inlineNode.depth = current_token(tokens, i).depth;
 	} else {
 		parserError(errorMessage(tokens, i, inline_value, "("));
 	}
+	// consume Inline Value
+	i++;
+	// Edge case
+	let escape_characters = "";
+	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.ESCAPE) {
+		while (i < tokens.length) {
+			if (current_token(tokens, i).type === TOKEN_TYPES.ESCAPE || current_token(tokens, i).type === TOKEN_TYPES.TEXT) {
+				switch (current_token(tokens, i).type) {
+					case TOKEN_TYPES.ESCAPE:
+						inlineNode.value += current_token(tokens, i).value.slice(1);
+						break;
+					case TOKEN_TYPES.TEXT:
+						inlineNode.value += current_token(tokens, i).value;
+						break;
+				}
+				i++;
+			} else {
+				break;
+			}
+		}
+	}
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.CLOSE_PAREN) {
 		parserError(errorMessage(tokens, i, ")", inline_value));
 	}
+	// consume ')'
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.THIN_ARROW) {
 		parserError(errorMessage(tokens, i, "->", ")"));
 	}
+	// consume '->'
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.OPEN_PAREN) {
 		parserError(errorMessage(tokens, i, "(", "->"));
 	}
+	// consume '('
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.IDENTIFIER) {
 		for (const id of PREDEFINED_IDS) {
 			if (current_token(tokens, i).value.includes(`${id}:`)) {
@@ -260,16 +283,18 @@ function parseInline(tokens, i) {
 	} else {
 		parserError(errorMessage(tokens, i, inline_id, "("));
 	}
+	// consume Inline Identifier
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.CLOSE_PAREN) {
 		parserError(errorMessage(tokens, i, ")", inline_id));
 	}
+	// consume ')'
+	i++;
 	// Update Data
 	updateData(tokens, i);
 	tokens_stack.length = 0;
-	i++;
 	return [inlineNode, i];
 }
 
@@ -280,18 +305,23 @@ function parseText(tokens, i) {
 		textNode.text = current_token(tokens, i).value;
 		textNode.depth = current_token(tokens, i).depth;
 	}
+	// consume TEXT
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	return [textNode, i];
 }
 
 // Parse At_Block
 function parseAtBlock(tokens, i) {
 	const atBlockNode = makeAtBlockNode();
+	// consume '@_'
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
+	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.END_KEYWORD) {
+		parserError(errorMessage(tokens, i, at_id, "@_"));
+	}
 	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.IDENTIFIER) {
 		const id = current_token(tokens, i).value.trim();
 		validateId(id);
@@ -300,28 +330,32 @@ function parseAtBlock(tokens, i) {
 	} else {
 		parserError(errorMessage(tokens, i, at_id, "@_"));
 	}
+	// consume Atblock Identifier
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.CLOSE_AT) {
 		parserError(errorMessage(tokens, i, "_@", at_id));
 	}
+	// consume '_@'
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.COLON) {
+		// consume ':'
+		i++;
 		// Update Data
 		updateData(tokens, i);
-		i++;
 		if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.VALUE) {
 			current_token(tokens, i)
 				.value.split(",")
 				.forEach(value => {
 					atBlockNode.args.push(value.trim());
 				});
+			// consume Atblock Value
+			i++;
 			// Update Data
 			updateData(tokens, i);
-			i++;
 		} else {
 			parserError(errorMessage(tokens, i, at_value, ":"));
 		}
@@ -329,55 +363,65 @@ function parseAtBlock(tokens, i) {
 	if (current_token(tokens, i) && current_token(tokens, i).type !== TOKEN_TYPES.NEWLINE) {
 		parserError(errorMessage(tokens, i, "\\n", "_@"));
 	}
+	// consume '\n'
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (current_token(tokens, i) && current_token(tokens, i).type !== TOKEN_TYPES.TEXT) {
 		parserError(errorMessage(tokens, i, "Text", "\\n"));
 	}
 	while (i < tokens.length) {
 		if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.TEXT) {
 			atBlockNode.content.push(current_token(tokens, i).value);
+			// consume TEXT
+			i++;
 			// Update Data
 			updateData(tokens, i);
-			i++;
 		} else if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.NEWLINE) {
+			// consume '\n'
+			i++;
 			// Update Data
 			updateData(tokens, i);
-			i++;
 			continue;
 		} else {
 			break;
 		}
 	}
 	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.NEWLINE) {
+		// consume '\n'
+		i++;
 		// Update Data
 		updateData(tokens, i);
-		i++;
 	}
 	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.OPEN_AT) {
 		parserError(errorMessage(tokens, i, "@_", "\\n"));
 	}
+	// consume '@_'
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.END_KEYWORD) {
 		parserError(errorMessage(tokens, i, end_keyword, "@_"));
 	}
+	// console end keyword
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.CLOSE_AT) {
 		parserError(errorMessage(tokens, i, "_@", end_keyword));
 	}
+	// consume '_@'
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	if (!current_token(tokens, i) || current_token(tokens, i).value !== "\n") {
 		parserError(errorMessage(tokens, i, "\\n", "_@"));
 	}
-	tokens_stack.length = 0;
+	// consume '\n'
 	i++;
+	// Update Data
+	updateData(tokens, i);
+	tokens_stack.length = 0;
 	return [atBlockNode, i];
 }
 
@@ -388,9 +432,10 @@ function parseCommentNode(tokens, i) {
 		commentNode.text = current_token(tokens, i).value;
 		commentNode.depth = current_token(tokens, i).depth;
 	}
+	// consume Comment
+	i++;
 	// Update Data
 	updateData(tokens, i);
-	i++;
 	return [commentNode, i];
 }
 
@@ -415,7 +460,7 @@ function parseNode(tokens, i) {
 		return parseText(tokens, i);
 	}
 	// At_Block
-	else if (current_token(tokens, i).value === "@_" && peek(tokens, i, 1).type !== TOKEN_TYPES.END_KEYWORD) {
+	else if (current_token(tokens, i).value === "@_") {
 		return parseAtBlock(tokens, i);
 	}
 	// Newline
@@ -462,4 +507,4 @@ function parser(tokens) {
 	return ast;
 }
 
-export default parser;
+export default parser;

package/core/tokenTypes.js

@@ -14,7 +14,8 @@ const TOKEN_TYPES = {
   CLOSE_AT: "CLOSE_AT",
   COLON: "COLON",
   COMMENT: "COMMENT",
-  NEWLINE: "NEWLINE"
+  NEWLINE: "NEWLINE",
+  ESCAPE: "ESCAPE"
 };
 
 export default TOKEN_TYPES;

package/custom_output.html

@@ -0,0 +1,83 @@
+<!DOCTYPE html>
+<html>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <title>SomMark Page</title>
+
+<link rel="stylesheet" href="node_modules/highlight.js/styles/atom-one-dark.min.css">
+<body>
+
+Title: Example Block — Python
+This is a block of text in a .smark file. &gt;
+
+<h2>Heading</h2>
+This block shows a simple Python example.
+<pre><code class="hljs language-python"><span class="hljs-keyword">def</span> <span class="hljs-title function_">greet</span>(<span class="hljs-params">name</span>):
+    <span class="hljs-keyword">return</span> <span class="hljs-string">f&quot;Hello, <span class="hljs-subst">{name}</span>!&quot;</span>
+<span class="hljs-built_in">print</span>(greet(<span class="hljs-string">&quot;World&quot;</span>))</code></pre>
+
+Title: Example Block — JavaScript
+This is another block of text in a .smark file.
+
+<h2>Heading</h2>
+This block shows a simple JavaScript example.
+<pre><code class="hljs language-javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">greet</span>(<span class="hljs-params">name</span>) {
+    <span class="hljs-keyword">return</span> <span class="hljs-string">`Hello, <span class="hljs-subst">${name}</span>!`</span>;
+}
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">greet</span>(<span class="hljs-string">&quot;World&quot;</span>));</code></pre>
+
+Title: Example Block — Ruby
+Nested block content and a Ruby example.
+
+<h2>Heading</h2>
+This block shows a simple Ruby example.
+<pre><code class="hljs language-ruby"><span class="hljs-keyword">def</span> <span class="hljs-title function_">greet</span>(<span class="hljs-params">name</span>)
+    <span class="hljs-string">&quot;Hello, <span class="hljs-subst">#{name}</span>!&quot;</span>
+<span class="hljs-keyword">end</span>
+puts greet(<span class="hljs-string">&quot;World&quot;</span>)</code></pre>
+
+Title: Parent Block with Nested Children
+This parent block contains nested child blocks to demonstrate nesting.
+
+<h1>Heading</h1>
+
+  
+Title: Child Block — Python Utility
+Child block 1: a small utility function.
+<pre><code class="hljs language-python"><span class="hljs-keyword">def</span> <span class="hljs-title function_">repeat</span>(<span class="hljs-params">msg, n=<span class="hljs-number">3</span></span>):
+    <span class="hljs-keyword">return</span> <span class="hljs-string">&quot; &quot;</span>.join([msg] * n)
+<span class="hljs-built_in">print</span>(repeat(<span class="hljs-string">&quot;Echo&quot;</span>))</code></pre>  
+
+
+  
+Title: Child Block — JavaScript Utility
+Child block 2: a small utility function.
+<pre><code class="hljs language-javascript"><span class="hljs-keyword">const</span> <span class="hljs-title function_">repeat</span> = (<span class="hljs-params">msg, n = <span class="hljs-number">3</span></span>) =&gt; <span class="hljs-title class_">Array</span>(n).<span class="hljs-title function_">fill</span>(msg).<span class="hljs-title function_">join</span>(<span class="hljs-string">&quot; &quot;</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">repeat</span>(<span class="hljs-string">&quot;Echo&quot;</span>));</code></pre>  
+
+
+  
+Title: Child Block — Nested Grandchild Example
+This child contains a deeper nested block.
+<pre><code class="hljs language-markdown"><span class="hljs-bullet">-</span> parent: Child Block
+<span class="hljs-bullet">-</span> note: contains a grandchild block below</code></pre>  
+
+
+  
+Title: Grandchild Block — Inline Note
+Deeper nested block grandchild.
+This illustrates multi-level nesting.
+<pre><code class="hljs language-text">This is a grandchild block inside a child block.</code></pre>  
+
+
+
+
+Title: Final Organized Block
+Summary and notes about the examples above.
+
+<h3>Heading</h3>
+Use these blocks as templates for adding more nested content.
+
+</body>
+</html>

package/formatter/tag.js

@@ -36,7 +36,7 @@ class TagBuilder {
 							this.#attr.push(`${key2}="${escapeHTML(value)}"`);
 							break;
 						case "other":
-							this.#attr.push(`${key2}={${value}}`); // React/MDX props might need different handling, but usually raw JS expression?
+							this.#attr.push(`${key2}={${value}}`); // [NEEDS IMPROVEMENT]
 							break;
 					}
 				}

package/mappers/default_mode/smark.html.js

@@ -2,7 +2,6 @@ import Mapper from "../mapper.js";
 const html = new Mapper();
 const { tag, code, list } = html;
 
-html.selectedTheme = "paraiso-dark";
 html.env = "browser";
 
 // Block

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sommark",
-	"version": "1.1.1",
+	"version": "2.0.0-beta.1",
 	"description": "SomMark is a structural markup language for writing structured documents and converting them into HTML or Markdown or MDX(only ready components).",
 	"main": "index.js",
 	"directories": {
@@ -16,7 +16,7 @@
 		"test:watch": "vitest watch"
 	},
 	"bin": {
-		"smark": "./cli/cli.mjs"
+		"smark": "cli/cli.mjs"
 	},
 	"repository": {
 		"type": "git",
@@ -48,4 +48,4 @@
 	"devDependencies": {
 		"vitest": "^4.0.16"
 	}
-}
+}