sommark 3.3.4 → 4.0.0

package/core/plugins/rules-validation-plugin.js

@@ -1,231 +0,0 @@
-import { transpilerError } from "../errors.js";
-
-/**
- * Rules Validation Plugin
- * Validates rules defined in mapper files.
- * Supports rules for arguments (key, value) and content.
- */
-const RulesValidationPlugin = {
-	name: "rules-validation",
-	type: "on-ast",
-	author: "Adam-Elmi",
-	description: "Checks your document to make sure all tags and arguments follow the rules set in the mapper.",
-	onAst(ast, { mapperFile, instance }) {
-		if (!mapperFile) return ast;
-
-		const validateNode = (node, parentTarget = null) => {
-			if (!node) return;
-
-			// ========================================================================== //
-			//  1. TEXT nodes validation                                                  //
-			// ========================================================================== //
-			if (node.type === "Text" && parentTarget) {
-				this.runValidations(node, parentTarget, null, node.text, "Text", mapperFile, instance);
-			}
-
-			// ========================================================================== //
-			//  2. Identifier nodes validation (Block, Inline, AtBlock)                   //
-			// ========================================================================== //
-			if (node.id) {
-				const target = mapperFile.get(node.id);
-				if (target) {
-					this.runValidations(node, target, node.args, this.getContent(node), node.type, mapperFile, instance);
-				}
-			}
-
-			// ========================================================================== //
-			//  Recursive traversal                                                       //
-			// ========================================================================== //
-			if (node.body && Array.isArray(node.body)) {
-				const currentTarget = node.id ? mapperFile.get(node.id) : parentTarget;
-				node.body.forEach(child => validateNode(child, currentTarget));
-			}
-		};
-
-		const root = Array.isArray(ast) ? ast : [ast];
-		root.forEach(node => validateNode(node));
-
-		return ast;
-	},
-
-	getContent(node) {
-		if (node.type === "Inline") return node.value;
-		if (node.type === "AtBlock") return node.content;
-		return "";
-	},
-
-	runValidations(node, target, args, content, type, mapperFile, instance) {
-		if (!target.options) return;
-		const rules = target.options.rules || {};
-		const id = Array.isArray(target.id) ? target.id.join(" | ") : target.id;
-		const context = instance ? { src: instance.src, range: node.range, filename: instance.filename } : null;
-
-		// ========================================================================== //
-		//  1. Validate Args Count & Keys                                             //
-		// ========================================================================== //
-		if (args && rules.args) {
-			const { min, max, required, includes } = rules.args;
-			const argKeys = Object.keys(args).filter(key => isNaN(parseInt(key)));
-			const argCount = args.length;
-
-			if (min !== undefined && argCount < min) {
-				transpilerError(
-					[
-						"<$red:Validation Error:$> ",
-						`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:requires at least$> <$green:${min}$> <$yellow:argument(s). Found$> <$red:${argCount}$>`
-					],
-					context
-				);
-			}
-			if (max !== undefined && argCount > max) {
-				transpilerError(
-					[
-						"<$red:Validation Error:$> ",
-						`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:accepts at most$> <$green:${max}$> <$yellow:argument(s). Found$> <$red:${argCount}$>`
-					],
-					context
-				);
-			}
-			if (required && Array.isArray(required)) {
-				const missingKeys = required.filter(key => !Object.prototype.hasOwnProperty.call(args, key));
-				if (missingKeys.length > 0) {
-					transpilerError(
-						[
-							"<$red:Validation Error:$> ",
-							`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:is missing required argument(s):$> <$red:${missingKeys.join(", ")}$>`
-						],
-						context
-					);
-				}
-			}
-			if (includes && Array.isArray(includes)) {
-				const invalidKeys = argKeys.filter(key => {
-					return !includes.includes(key) && !mapperFile.extraProps.has(key);
-				});
-				if (invalidKeys.length > 0) {
-					transpilerError(
-						[
-							"<$red:Validation Error:$> ",
-							`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:contains invalid argument key(s):$> <$red:${invalidKeys.join(", ")}$>`,
-							`{N}<$yellow:Allowed keys are:$> <$green:${includes.join(", ")}$>`
-						],
-						context
-					);
-				}
-			}
-		}
-
-		// ========================================================================== //
-		//  2. Validation on Keys and Values                                          //
-		// ========================================================================== //
-		if (args) {
-			const argKeys = Object.keys(args).filter(key => isNaN(parseInt(key)));
-
-			// Validate keys pattern
-			if (rules.keys) {
-				const keyPattern = rules.keys instanceof RegExp ? rules.keys : null;
-				if (keyPattern) {
-					const invalidKeys = argKeys.filter(key => !keyPattern.test(key));
-					if (invalidKeys.length > 0) {
-						transpilerError(
-							[
-								"<$red:Validation Error:$> ",
-								`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:contains argument keys that do not match pattern $> <$green:${keyPattern.toString()}$>: <$red:${invalidKeys.join(", ")}$>`
-							],
-							context
-						);
-					}
-				}
-			}
-
-			// ========================================================================== //
-			//  Validate specific values                                                  //
-			// ========================================================================== //
-			if (rules.values) {
-				for (const [key, value] of Object.entries(args)) {
-					if (isNaN(parseInt(key))) {
-						const valueRule = rules.values[key];
-						if (valueRule) {
-							if (valueRule instanceof RegExp && !valueRule.test(value)) {
-								transpilerError(
-									[
-										"<$red:Validation Error:$> ",
-										`<$yellow:Argument key$> <$blue:'${key}'$> <$yellow:in$> <$blue:'${id}'$> <$yellow:has invalid value:$> <$red:'${value}'$>{N}<$yellow:Expected to match pattern:$> <$green:${valueRule.toString()}$>`
-									],
-									context
-								);
-							} else if (typeof valueRule === "function" && !valueRule(value)) {
-								transpilerError(
-									[
-										"<$red:Validation Error:$> ",
-										`<$yellow:Argument key$> <$blue:'${key}'$> <$yellow:in$> <$blue:'${id}'$> <$yellow:failed custom validation for value:$> <$red:'${value}'$>`
-									],
-									context
-								);
-							}
-						}
-					}
-				}
-			}
-		}
-
-		// ========================================================================== //
-		//  3. Content Validation                                                     //
-		// ========================================================================== //
-		if (content !== undefined && rules.content) {
-			const { maxLength, match } = rules.content;
-			if (maxLength && content.length > maxLength) {
-				transpilerError(
-					[
-						"<$red:Validation Error:$> ",
-						`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:content exceeds maximum length of$> <$green:${maxLength}$> <$yellow:characters. Found$> <$red:${content.length}$>`
-					],
-					context
-				);
-			}
-			if (match && match instanceof RegExp && !match.test(content)) {
-				transpilerError(
-					[
-						"<$red:Validation Error:$> ",
-						`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:content does not match required pattern:$> <$green:${match.toString()}$>`
-					],
-					context
-				);
-			}
-		}
-
-		// ========================================================================== //
-		//  4. self-closing                                                           //
-		// ========================================================================== //
-		if (rules.is_self_closing && (type === "Block" || content)) {
-			if (content) {
-				transpilerError(
-					[
-						"<$red:Validation Error:$> ",
-						`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:is self-closing tag and is not allowed to have a content | children$>`
-					],
-					context
-				);
-			}
-		}
-
-		// ========================================================================== //
-		//  5. Type Validation (Block, Inline, AtBlock)                               //
-		// ========================================================================== //
-		const typeToValidate = target.options.type;
-		if (typeToValidate && type !== "Text") {
-			const allowedTypes = Array.isArray(typeToValidate) ? typeToValidate : [typeToValidate];
-			if (!allowedTypes.includes("any") && !allowedTypes.includes(type)) {
-				transpilerError(
-					[
-						"<$red:Validation Error:$> ",
-						`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:is expected to be type$> <$green:'${allowedTypes.join(" | ")}'$>{N}<$cyan:Received type: $> <$magenta:'${type}'$>`
-					],
-					context
-				);
-			}
-		}
-	}
-};
-
-export default RulesValidationPlugin;

package/core/plugins/sommark-format.js

@@ -1,244 +0,0 @@
-/**
- * SomMark Format Plugin
- * Cleans up and formats your SomMark code into a neat and readable style.
- */
-export default {
-	name: "sommark-format",
-	type: "on-ast",
-	author: "Adam-Elmi",
-	description: "Cleans up and formats your SomMark code into a neat and readable style.",
-	options: {
-		indentString: "\t"
-	},
-	onAst(ast) {
-		const indentStr = this.options?.indentString || "\t";
-		// ========================================================================== //
-		//  1. Escaping Helpers                                                      //
-		// ========================================================================== //
-
-		const escapeArg = (val, type) => {
-			let escaped = String(val)
-				.replace(/\\/g, "\\\\")
-				.replace(/,/g, "\\,");
-
-			if (type === "Block" || type === "AtBlock") {
-				escaped = escaped.replace(/:/g, "\\:");
-			}
-			if (type === "AtBlock") {
-				escaped = escaped.replace(/;/g, "\\;");
-			}
-			if (type === "Block" && escaped.startsWith("=")) {
-				escaped = escaped.replace(/^=/, "\\=");
-			}
-			return escaped;
-		};
-
-		const escapeInlineValue = (val) => {
-			return String(val)
-				.replace(/\\/g, "\\\\")
-				.replace(/\)/g, "\\)");
-		};
-
-		const escapeText = (str) => {
-			return String(str)
-				.replace(/\\/g, "\\\\")
-				.replace(/\[/g, "\\[")
-				.replace(/\]/g, "\\]")
-				.replace(/\(/g, "\\(")
-				.replace(/\)/g, "\\)")
-				.replace(/->/g, "\\->")
-				.replace(/@_/g, "\\@_")
-				.replace(/_@/g, "\\_@")
-				.replace(/#/g, "\\#");
-		};
-		// ========================================================================== //
-		//  2. Formatting Logic                                                      //
-		// ========================================================================== //
-		const shouldQuote = (val) => {
-			if (typeof val !== "string") return false;
-			return /[ \t\n\r,:[\]()@#]/.test(val);
-		};
-
-		const formatArgs = (args, type) => {
-			if (!args || args.length === 0) return "";
-			let usedKeys = new Set();
-			let formattedArgs = [];
-
-			for (let i = 0; i < args.length; i++) {
-				let val = args[i];
-				let matchedKey = null;
-				if (type !== "Inline") {
-					for (let key of Object.keys(args)) {
-						if (isNaN(parseInt(key)) && args[key] === val && !usedKeys.has(key)) {
-							matchedKey = key;
-							usedKeys.add(key);
-							break;
-						}
-					}
-				}
-
-				let escapedVal = escapeArg(val, type);
-				if (shouldQuote(val)) {
-					const quotedVal = String(val)
-						.replace(/\\/g, "\\\\")
-						.replace(/"/g, '\\"');
-					escapedVal = `"${quotedVal}"`;
-				}
-
-				if (matchedKey) {
-					formattedArgs.push(`${matchedKey}: ${escapedVal}`);
-				} else {
-					formattedArgs.push(escapedVal);
-				}
-			}
-
-			let res = formattedArgs.join(", ");
-			if (!res) return "";
-
-			if (type === "Block") return " = " + res;
-			if (type === "AtBlock") return ": " + res + ";";
-			if (type === "Inline") return ": " + res;
-
-			return res;
-		};
-
-		const formatBody = (body, depth) => {
-			if (!body || !Array.isArray(body)) return "";
-			const innerIndentStr = depth >= 0 ? indentStr.repeat(depth) : "";
-			let result = "";
-			let currentText = "";
-
-			const flushText = () => {
-				if (!currentText) return;
-				let cleanText = currentText
-					.replace(/[ \t]+/g, " ")             // collapse horizontal spaces
-					.replace(/\n([ \t]*\n)+/g, "\n\n")   // preserve max 1 empty line (paragraphs)
-					.trim();
-
-				if (cleanText) {
-					const indentedText = cleanText.split('\n').map(line => {
-						return line.trim() ? innerIndentStr + line.trim() : "";
-					}).join('\n');
-					result += `${indentedText}\n`;
-				}
-				currentText = "";
-			};
-
-			for (let i = 0; i < body.length; i++) {
-				const child = body[i];
-				if (child.type === "Text") {
-					let textStr = escapeText(child.text);
-
-					// ========================================================================== //
-					//  Separate Text from a preceding Inline statement                   //
-					// ========================================================================== //
-					if (i > 0 && body[i - 1].type === "Inline") {
-						// Don't add space if the text starts with punctuation or already starts with whitespace
-						if (textStr.length > 0 && !/^\s/.test(textStr) && !/^[.,!?;:\])}>"']/.test(textStr)) {
-							textStr = " " + textStr;
-						}
-					}
-					currentText += textStr;
-				} else if (child.type === "Inline") {
-					const argsStr = formatArgs(child.args, "Inline");
-					const inlineVal = child.value ? String(child.value).trim() : "";
-					const inlineStr = `(${escapeInlineValue(inlineVal)})->(${child.id}${argsStr})`;
-
-					if (i > 0) {
-						const prev = body[i - 1];
-						if (prev.type === "Inline") {
-							if (!/[ \t\n\r]$/.test(currentText)) currentText += " ";
-						} else if (prev.type === "Text") {
-							if (currentText.length > 0 && !/[ \t\n\r]$/.test(currentText)) {
-								// Don't add space if text ends with opening punctuation/quotes
-								if (!/[({\[<"']$/.test(currentText)) currentText += " ";
-							}
-						}
-					}
-					currentText += inlineStr;
-				} else {
-					// ========================================================================== //
-					//  Helper: check if a block has no meaningful body content           //
-					// ========================================================================== //
-					const isEmptyBlock = (node) => {
-						if (node.type !== "Block") return false;
-						if (!node.body || node.body.length === 0) return true;
-						// Body with only whitespace text nodes
-						return node.body.every(
-							n => n.type === "Text" && !n.text.trim()
-						);
-					};
-
-					if (child.type === "Block" && isEmptyBlock(child)) {
-						// Keep empty blocks inline with surrounding text
-						const argsStr = formatArgs(child.args, "Block");
-						const blockStr = `[${child.id}${argsStr}][end]`;
-
-						if (i > 0) {
-							const prev = body[i - 1];
-							if (prev.type === "Text" || prev.type === "Inline") {
-								if (currentText.length > 0 && !/[ \t\n\r]$/.test(currentText)) {
-									if (!/[({\[<"']$/.test(currentText)) currentText += " ";
-								}
-							}
-						}
-						currentText += blockStr;
-					} else {
-						// ========================================================================== //
-						//  Process Block, AtBlock, and Comment nodes                         //
-						// ========================================================================== //
-						flushText();
-						if (child.type === "Block") {
-							const argsStr = formatArgs(child.args, "Block");
-							result += `${innerIndentStr}[${child.id}${argsStr}]\n`;
-							result += formatBody(child.body, depth + 1);
-							result += `${innerIndentStr}[end]\n`;
-						} else if (child.type === "AtBlock") {
-							const argsStr = formatArgs(child.args, "AtBlock");
-							const atHeader = argsStr ? `@_${child.id}_@${argsStr}` : `@_${child.id}_@;`;
-							result += `${innerIndentStr}${atHeader}\n`;
-							if (child.content) {
-								// ========================================================================== //
-								//  Remove leading spaces from messy text block and re-indent         //
-								// ========================================================================== //
-								const lines = child.content.replace(/\r\n/g, '\n').split('\n');
-								while (lines.length && !lines[0].trim()) lines.shift();
-								while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
-
-								let minIndent = Infinity;
-								for (const line of lines) {
-									if (line.trim()) {
-										const leadingSpaces = line.match(/^[ \t]*/)[0].length;
-										if (leadingSpaces < minIndent) minIndent = leadingSpaces;
-									}
-								}
-								if (minIndent === Infinity) minIndent = 0;
-
-								const indentedContent = lines.map(line => {
-									if (!line.trim()) return "";
-									return innerIndentStr + indentStr + line.substring(minIndent);
-								}).join('\n');
-
-								result += indentedContent + "\n";
-							}
-							result += `${innerIndentStr}@_end_@\n`;
-						} else if (child.type === "Comment") {
-							result += `${innerIndentStr}# ${child.text.replace(/^#+\s*/, "").trim()}\n`;
-						}
-					}
-				}
-			}
-			flushText();
-			return result;
-		};
-
-		const rootNodes = Array.isArray(ast) ? ast : [ast];
-
-		// ========================================================================== //
-		//  The formatted string is available via `plugin.formattedSource`            //
-		// ========================================================================== //
-		this.formattedSource = formatBody(rootNodes, 0).trim() + "\n";
-
-		return ast; // Return original AST
-	}
-};

package/coverage_test.js

@@ -1,21 +0,0 @@
-import lexer from "./core/lexer.js";
-
-const src = "  [Block]\n    content\n  [end]";
-console.log(`Source length: ${src.length}`);
-
-const tokens = lexer(src);
-let totalCovered = 0;
-
-tokens.forEach((t, idx) => {
-    if (t.type === "EOF") return;
-    const len = t.value.length;
-    totalCovered += len;
-    console.log(`Token ${idx}: type=${t.type.padEnd(15)} structural=${(!!t.isStructural).toString().padEnd(6)} val=${JSON.stringify(t.value).padEnd(20)} range:(${t.range.start.line},${t.range.start.character}) - (${t.range.end.line},${t.range.end.character})`);
-});
-
-console.log(`Total covered length: ${totalCovered}`);
-if (totalCovered !== src.length) {
-    console.log(`GAP DETECTED: missing ${src.length - totalCovered} characters.`);
-} else {
-    console.log("SUCCESS: 100% Coverage.");
-}

package/debug.js

@@ -1,15 +0,0 @@
-import fs from "node:fs/promises";
-import SomMark from "./index.js";
-
-const buffer = await fs.readFile("./examples/markdown/tasks.smark");
-const file_content = buffer.toString();
-let smark = new SomMark({ 
-    src: file_content, 
-    format: "markdown", 
-    includeDocument: true,
-});
-
-
-// console.log(JSON.stringify(await smark.parse(), null, 2));
-// console.log(await smark.lex());
-console.log(await smark.transpile());

package/helpers/camelize.js

@@ -1,2 +0,0 @@
-const camelize = str => str.replace(/-./g, x => x[1].toUpperCase());
-export default camelize;

package/helpers/defaultTheme.js

@@ -1,3 +0,0 @@
-const atomOneDark = `pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}.hljs{color:#abb2bf;background:#282c34}.hljs-comment,.hljs-quote{color:#5c6370;font-style:italic}.hljs-doctag,.hljs-formula,.hljs-keyword{color:#c678dd}.hljs-deletion,.hljs-name,.hljs-section,.hljs-selector-tag,.hljs-subst{color:#e06c75}.hljs-literal{color:#56b6c2}.hljs-addition,.hljs-attribute,.hljs-meta .hljs-string,.hljs-regexp,.hljs-string{color:#98c379}.hljs-attr,.hljs-number,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-pseudo,.hljs-template-variable,.hljs-type,.hljs-variable{color:#d19a66}.hljs-bullet,.hljs-link,.hljs-meta,.hljs-selector-id,.hljs-symbol,.hljs-title{color:#61aeee}.hljs-built_in,.hljs-class .hljs-title,.hljs-title.class_{color:#e6c07b}.hljs-emphasis{font-style:italic}.hljs-strong{font-weight:700}.hljs-link{text-decoration:underline}`;
-
-export default atomOneDark;

package/test_format_fix.js

@@ -1,42 +0,0 @@
-import SomMark from './index.js';
-
-async function test() {
-    const text = '[Block = attr: "val with space"]\n  Content\n[end]\n';
-    const sm = new SomMark({
-        src: text,
-        format: 'html',
-        plugins: ['sommark-format']
-    });
-    await sm.parse();
-    const formatPlugin = sm.plugins.find(p => p.name === 'sommark-format');
-    const formatted = formatPlugin.formattedSource;
-    console.log("Original:\n", text);
-    console.log("Formatted:\n", formatted);
-    
-    if (formatted.includes('"val with space"')) {
-        console.log("PASS: Quotes preserved for space-containing value.");
-    } else {
-        console.error("FAIL: Quotes LOST!");
-        process.exit(1);
-    }
-    
-    const text2 = 'Text at top level\n(inline)->(bold)\n@_AtBlock_@;\n  content\n@_end_@\n';
-    const sm2 = new SomMark({
-        src: text2,
-        format: 'html',
-        plugins: ['sommark-format']
-    });
-    await sm2.parse();
-    const formatted2 = sm2.plugins.find(p => p.name === 'sommark-format').formattedSource;
-    console.log("Top-level Original:\n", text2);
-    console.log("Top-level Formatted:\n", formatted2);
-    
-    if (formatted2.includes('Text at top level') && formatted2.includes('(inline)->(bold)')) {
-        console.log("PASS: Top-level content preserved.");
-    } else {
-        console.error("FAIL: Top-level content LOST or corrupted!");
-        process.exit(1);
-    }
-}
-
-test();

package/v3-todo.smark

@@ -1,73 +0,0 @@
-[Block = v3-todo-list]
-(SomMark v3 Goals)->(h1)
-
-# Completed Features & Fixes
-(done)->(todo: Full support for all HTML5 tags)
-(done)->(todo: Full support for Markdown and MDX)
-(done)->(todo: Safe way to override how components look)
-(done)->(todo: Fixed crashes and infinite loops)
-(done)->(todo: Fixed block spacing and new lines)
-(done)->(todo: Allowed using -, _, and $ in names)
-(done)->(todo: Stopped generic tags from breaking custom ones)
-(done)->(todo: Added 'lex' and 'parse' commands to the tool)
-(done)->(todo: Fixed text output errors)
-(done)->(todo: Fixed commas in small inline tags)
-(done)->(todo: Fixed nested tags in examples)
-(done)->(todo: Added CSS variable support like color: --primary)
-(done)->(todo: Added more examples to the guide)
-(done)->(todo: Auto-made ID links for headings)
-(done)->(todo: Fixed the equal sign bug in the reader)
-(done)->(todo: Fixed new line handling for big blocks)
-(done)->(todo: Fixed start-of-line marks in Markdown)
-(done)->(todo: Smart MDX tool for better styles and React)
-(done)->(todo: Better plugin system with isolated parts)
-(done)->(todo: Control plugins with easy 'options' settings)
-(done)->(todo: Better naming rules for $, _, and -)
-(done)->(todo: Made 'end' a special reserved word)
-(done)->(todo: Organized tags into types: Block, Inline, and AtBlock)
-(done)->(todo: Cleaned up internal code property names)
-(done)->(todo: Multi-step plugin pipeline: before, during, after)
-(done)->(todo: Sorted plugins by importance automatically)
-(done)->(todo: Built-in tool to remove comments)
-(done)->(todo: Tool to detect missing end tags)
-(done)->(todo: The command tool now uses the core engine for everything)
-(done)->(todo: Your local settings now take priority)
-(done)->(todo: Added easy ways to add new mappers to the system)
-(done)->(todo: Released Version 3)
-(done)->(todo: Support for custom body placement in templates)
-(done)->(todo: Better foundation for building new mappers)
-(done)->(todo: Cleaner HTML and Markdown code builders)
-(done)->(todo: Improved MDX support for better styles)
-(done)->(todo: Better JSON output support)
-(done)->(todo: Built-in tools: Quotes, Modules, Raw, and Validation)
-(done)->(todo: Better plugin loading and merged settings)
-(done)->(todo: Improved name checker in the reader)
-(done)->(todo: Better cleanup for names and quotes)
-(done)->(todo: Command tool now shares all settings with the core engine)
-(done)->(todo: Cleaned up all old test files)
-(done)->(todo: Added commands to see plugins and how they run)
-(done)->(todo: Added command to see your current settings)
-(done)->(todo: Added command to change tool colors)
-(done)->(todo: Better way to handle unknown HTML tags automatically)
-(done)->(todo: Security fix for template bypass tricks)
-(done)->(todo: Safer and more robust way to read arguments)
-(done)->(todo: Cleaner and more consistent error messages)
-(done)->(todo: Forced semicolons at the start of AtBlocks)
-(done)->(todo: Full guide for all tools and features)
-(done)->(todo: List of all old and removed features)
-(done)->(todo: Removed unused CSS and code pieces)
-(done)->(todo: Standardized HTML comment style)
-(done)->(todo: Moved common tools to a helper file)
-(done)->(todo: Modernized all user documentation)
-(done)->(todo: Created new guides for the plugin system)
-(done)->(todo: Enabled essential tools by default)
-(done)->(todo: Fixed commas in Markdown tables)
-(done)->(todo: Improved the code highlighting system)
-(done)->(todo: Cleaned up old and deprecated style settings)
-(done)->(todo: Fixed the todo list checkmark bug)
-(done)->(todo: Native quote support built into the engine)
-(done)->(todo: Optimized for speed and instant startup)
-(done)->(todo: Fixed structural bugs with nested blocks)
-(done)->(todo: SomMark core now fully supports LSP for code editors)
-(done)->(todo: You can now use Text, Inline tags, and AtBlocks at the top level without a Block)
-[end]