sommark 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Adam Elmi Eid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,155 @@
+
+<img width="2000" height="491" alt="SomMark Cover" src="https://raw.githubusercontent.com/Adam-Elmi/SomMark/master/assets/smark_bg.png" />
+
+
+
+<p align="center">
+  SomMark is a lightweight, custom documentation markup language designed to be simple, readable, and easy to process.
+</p>
+
+<p align="center">
+  <span>Website (Coming Soon)</span>
+  ·
+  <span>Docs (Coming Soon)</span>
+  ·
+  <span>Community (Coming Soon)</span>
+</p>
+
+
+<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/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" />
+<img src="https://img.shields.io/badge/mdx-supported-lightblue?style=flat-square" />
+
+</p>
+
+---
+
+# SomMark v1
+
+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.
+
+SomMark is built around **clear syntax**, **explicit structure**, and a **mapping-based output system**.
+
+---
+
+## Core Syntax
+
+SomMark has **three main syntax types**.
+
+---
+
+## 1. Block
+
+A **Block** is a container.
+It holds arguments and child content.
+
+```ini
+[Block = arg1, arg2, arg3]
+This is the body.
+These texts are considered as children.
+[end]
+```
+
+* `Block` is the block name
+* Arguments are optional
+* Everything inside is treated as block content
+
+---
+
+## 2. Inline Statement
+
+An **Inline Statement** is used inside text to apply formatting or behavior such as color, links, or styles.
+
+```ini
+[Block]
+This is the (text)->(color:red).
+These words are (important)->(bold).
+[end]
+```
+
+Inline statements modify specific parts of text without breaking the flow.
+
+---
+
+## 3. At Block
+
+Sometimes inline statements are not enough.
+**At Blocks** are used for complex structures like tables, lists, code blocks, and custom content.
+
+```ini
+[Block]
+@_table_@: month, revenue, expenses
+- January, 1200, 400
+- February, 1400, 600
+- March, 2000, 800
+@_end_@
+
+@_code_@: lua
+function add(a, b)
+  return a + b
+end
+@_end_@
+[end]
+```
+
+At Blocks give you full control over how structured data is handled.
+
+---
+
+## Modes
+
+SomMark has **two modes**:
+
+### Default Mode
+
+* Comes with predefined identifiers such as `table`, `code`, `list`, and more
+* Can be directly transpiled to HTML or Markdown
+* Ideal for documentation
+
+### Custom Mode
+
+* You define your own identifiers
+* Full control over behavior and output
+* Useful for custom formats or tools
+
+---
+
+## Mapping Concept
+
+SomMark uses a **mapping system**.
+
+* You define how each block, inline statement, or at-block should be converted
+* Output is not fixed
+* The same SomMark file can generate different results (HTML, MD, MDX, etc.)
+
+This makes SomMark highly extensible and future-proof.
+
+---
+
+## Escape Character
+
+To prevent SomMark from parsing syntax, use the escape character (`` ` ``):
+
+```ini
+[Block]
+This is a text `[Hello]` not a block.
+Also this `(world)` is not inline syntax.
+[end]
+```
+
+Escaped content is treated as plain text.
+
+---
+
+## Purpose
+
+SomMark is designed for:
+
+* Documentation
+* Structured writing
+* Tooling and transpilation
+* Extensible content systems

package/cli/cli.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+import projectJson from "../package.json" with { type: "json" };
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { cliError, formatMessage } from "../core/validator.js";
+import lexer from "../core/lexer.js";
+import parser from "../core/parser.js";
+import transpiler from "../core/transpiler.js";
+import html from "../mappers/default_mode/smark.html.js";
+import md from "../mappers/default_mode/smark.md.js";
+import mdx from "../mappers/default_mode/smark.mdx.js";
+
+const options = ["-v", "--version", "-h", "--help", "--html", "--md", "--mdx"];
+
+function getHelp(unknown_option = true) {
+	const msg = [
+		`${unknown_option && process.argv[2] ? `<$red:Unrecognized option$> <$blue: '${process.argv[2]}'$>` : "<$cyan:[Help]$>"}`,
+		"{N}<$yellow:Usage:$> <$blue:smark [options] [targetFile] [option] [outputFile] [outputDir]$>",
+		"{N}<$yellow:Available options are:$>",
+		"{N}  <$green:-h or --help$>      <$cyan: show help message$>",
+		"{N}  <$green:-v or --version$>   <$cyan: show version information$>",
+		"{N}  <$green:--html$>            <$cyan: transpile to html$>",
+		"{N}  <$green:--md$>              <$cyan: transpile to markdown$>",
+		"{N}  <$green:--mdx>              <$cyan: transpile to mdx>"
+	].join("");
+	const help_msg = formatMessage(msg);
+	if (!options.includes(process.argv[2]) && unknown_option) {
+		console.log(help_msg);
+		process.exit(0);
+	} else if (process.argv[2] === "-h" || process.argv[2] === "--help") {
+		console.log(help_msg);
+		process.exit(0);
+	}
+}
+
+if (process.argv[2] && (process.argv[2] === "-h" || process.argv[2] === "--help")) {
+	getHelp(false);
+} else {
+	getHelp();
+}
+
+if (process.argv.length <= 2) {
+	console.log(
+		[
+			projectJson.version && typeof parseFloat(projectJson.version) === "number" ? projectJson.version : "",
+			"SomMark is a structural markup language for writing structured documents.",
+			"Copyright (C) Adam Elmi",
+			"Github: https://github.com/Adam-Elmi/SomMark"
+		]
+			.filter(value => value !== "")
+			.join("\n")
+	);
+}
+
+if (projectJson && projectJson.version !== undefined && (process.argv[2] === "-v" || process.argv[2] === "--version")) {
+	console.log(projectJson.version);
+}
+
+const isExist = async path => {
+	try {
+		if (path) {
+			await fs.access(path);
+			return true;
+		} else {
+			throw new Error("Path is not found");
+		}
+	} catch (_) {
+		return false;
+	}
+};
+
+async function createFile(folder, file, content) {
+	if (!(await isExist(folder))) {
+		await fs.mkdir(folder, { recursive: true });
+	}
+	await fs.writeFile(path.join(folder, file), content);
+}
+
+async function readContent(path) {
+	const content = await fs.readFile(path);
+	return content;
+}
+
+const CONFIG_FILE_NAME = "smark.config.js";
+const currentDir = process.cwd();
+const configPath = path.join(currentDir, CONFIG_FILE_NAME);
+
+let config = {
+	outputFile: "output",
+	outputDir: "",
+	mode: "default",
+	mappingFile: ""
+};
+
+async function loadConfig() {
+	if (isExist(configPath)) {
+		try {
+			const configURL = pathToFileURL(configPath).href;
+			const loadedModule = await import(configURL);
+			config = loadedModule.default;
+		} catch (error) {
+			console.error(`Error loading configuration file ${CONFIG_FILE_NAME}:`, error.message);
+		}
+	} else {
+		console.log(`${CONFIG_FILE_NAME} not found. Using default configuration.`);
+	}
+
+	if (!config.outputDir) {
+		config.outputDir = process.cwd();
+	}
+	return config;
+}
+
+async function transpile({ src, format, mappingFile = "" }) {
+	if ((await loadConfig()).mode === "default") {
+		return transpiler({ ast: parser(lexer(src)), format, mapperFile: format === "html" ? html : format === "md" ? md : mdx });
+	} else if (mappingFile && isExist(mappingFile)) {
+		return transpiler({ ast: parser(lexer(src)), format, mappingFile });
+	} else {
+		cliError([`{line}<$red:File$> <$blue:'${mappingFile}'$> <$red: is not found$>{line}`]);
+	}
+}
+
+async function generateOutput(outputDir, outputFile, format) {
+	let source_code = await readContent(process.argv[3]);
+	source_code = source_code.toString();
+	const output = await transpile({ src: source_code, format, mappingFile: config.mappingFile });
+	await createFile(outputDir, `${outputFile}.${format}`, output);
+}
+async function generateFile() {
+	try {
+		const format_option = process.argv[2] ?? "";
+		const format = format_option.replaceAll("-", "") ?? "";
+		if (format && ["html", "md", "mdx"].includes(format)) {
+			if (Array.isArray(process.argv) && process.argv.length > 0) {
+				const targetFile = process.argv[3] ? path.parse(process.argv[3]) : "";
+				if (await isExist(process.argv[3])) {
+					const file = path.parse(process.argv[3]);
+					if (file.ext === ".smark") {
+						const config = await loadConfig();
+						const success_msg = (outputDir, outputFile) => {
+							return formatMessage(
+								[
+									`{line}[<$yellow: STATUS$> : <$green: SUCCESS$>]{line}<$blue: File$> <$yellow:'${outputFile}.${format}'$> <$blue: is successfully created`,
+									` in directory$> <$yellow: '${outputDir}'$>{line}`
+								].join("")
+							);
+						};
+						if (process.argv[4] === undefined) {
+							if (config.mode === "default") {
+								config.mappingFile = format === "html" ? html : format === "md" ? md : format === "mdx" ? mdx : null;
+							}
+							await generateOutput(config.outputDir, config.outputFile, format);
+							console.log(success_msg(config.outputDir, config.outputFile));
+						} else if (process.argv[4] === "-o") {
+							if (process.argv[5] !== undefined) {
+								config.outputFile = path.parse(process.argv[5]).name;
+								config.outputDir = process.argv[6] !== undefined ? process.argv[6] : config.outputDir;
+								generateOutput(config.outputDir, config.outputFile, format);
+								console.log(success_msg(config.outputDir, config.outputFile));
+							}
+						}
+					} else {
+						cliError([
+							`{line}<$red:Unrecognized file extension$> <$blue: '${file.ext}'$> , <$red: only files with file extension$> <$green:'.smark'$> <$red: are accepted.$>{line}`
+						]);
+					}
+				} else {
+					cliError([
+						`{line}<$magenta:File$> <$blue:'${process.argv[3] ? targetFile.name + targetFile.ext : "Unknown"}'$> <$magenta: is not found$>${(await isExist(targetFile.dir)) ? ` <$magenta: in directory$> <$yellow:${targetFile.dir}$>` : "."}`,
+						`${process.argv[3] ? "" : "{N}<$magenta:<Unknown>$> -> <$yellow:means you did not define the file path.$>"}{line}`
+					]);
+				}
+			}
+		}
+	} catch (err) {
+		console.error(err);
+	}
+}
+generateFile();

package/core/ids.js

@@ -0,0 +1,2 @@
+const PREDEFINED_IDS = ["link", "image", "color"];
+export default PREDEFINED_IDS;

package/core/lexer.js

@@ -0,0 +1,293 @@
+import TOKEN_TYPES from "./tokenTypes.js";
+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) {
+			if (char === "\n") {
+				break;
+			} else if (char === "[" && !scope_state) {
+				break;
+			} else if (char === "=" && !scope_state) {
+				break;
+			} else if (char === "]" && !scope_state) {
+				break;
+			} else if (char === "(" && !scope_state) {
+				break;
+			} else if (char === "-" && peek(input, char_index, 1) === ">" && !scope_state) {
+				break;
+			} else if (char === "@" && peek(input, char_index, 1) === "_" && !scope_state) {
+				break;
+			} else if (char === "_" && peek(input, char_index, 1) === "@" && !scope_state) {
+				break;
+			} else if (char === "#" && !scope_state) {
+				break;
+			} else if (char === "`" && !scope_state) {
+				break;
+			}
+			str += char;
+		} 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;
+		}
+	}
+
+	return str;
+}
+
+function lexer(src) {
+	if (src && typeof src === "string") {
+		const tokens = [];
+		let scope_state = false;
+		let line = 1;
+		let start;
+		let end;
+		let depth_stack = [];
+		let context = "",
+			temp_str = "",
+			previous_value = "";
+
+		function addToken(type, value) {
+			tokens.push({ type, value, line, start, end, depth: depth_stack.length });
+		}
+
+		for (let i = 0; i < src.length; i++) {
+			let current_char = src[i];
+			// Token: Open Bracket
+			if (current_char === "[" && !scope_state) {
+				if (i === 0) {
+					// Update Column
+					start = 1;
+					end = start;
+				} else {
+					// Update Column
+					start = end !== undefined ? end : 1;
+					end = start;
+				}
+				// Push to depth if next token is not end_keyword
+				temp_str = concat(src, i + 1, ["]"], scope_state);
+				if (temp_str && temp_str.length > 0) {
+					if (temp_str.trim() !== end_keyword) {
+						depth_stack.push("Block");
+					}
+				}
+				addToken(TOKEN_TYPES.OPEN_BRACKET, current_char);
+				previous_value = current_char;
+			}
+			// Token: Equal Sign
+			else if (current_char === "=" && !scope_state) {
+				// Update Column
+				start = end !== undefined ? end : 1;
+				end = start;
+				addToken(TOKEN_TYPES.EQUAL, current_char);
+				previous_value = current_char;
+			}
+			// Token: Close Bracket
+			else if (current_char === "]" && !scope_state) {
+				// Update Column
+				start = end !== undefined ? end : 1;
+				end = start;
+				addToken(TOKEN_TYPES.CLOSE_BRACKET, current_char);
+				if (previous_value === end_keyword) {
+					depth_stack.pop();
+				}
+				previous_value = current_char;
+			}
+			// Token: Open Parenthesis
+			else if (current_char === "(" && !scope_state) {
+				// Update Column
+				start = previous_value === "\n" ? end : end !== undefined ? end + 1 : 1;
+				end = start;
+				addToken(TOKEN_TYPES.OPEN_PAREN, current_char);
+				if (previous_value !== "->") {
+					previous_value = current_char;
+				}
+			}
+			// Token: Thin Arrow
+			else if (current_char === "-" && peek(src, i, 1) === ">") {
+				temp_str = current_char + peek(src, i, 1);
+				i += temp_str.length - 1;
+				// Update Column
+				start = end !== undefined ? end : 1;
+				end = start + temp_str.length;
+				addToken(TOKEN_TYPES.THIN_ARROW, temp_str);
+				previous_value = temp_str;
+			}
+			// Token: Close Parenthesis
+			else if (current_char === ")" && !scope_state) {
+				// Update Column
+				start = end !== undefined ? end : 1;
+				end = start;
+				addToken(TOKEN_TYPES.CLOSE_PAREN, current_char);
+				previous_value = current_char;
+			}
+			// Token: Open At (@_)
+			else if (current_char === "@" && peek(src, i, 1) === "_") {
+				temp_str = current_char + peek(src, i, 1);
+				i += temp_str.length - 1;
+				// Update Column
+				start = end !== undefined ? end : 1;
+				end = start + temp_str.length;
+				scope_state = true;
+				addToken(TOKEN_TYPES.OPEN_AT, temp_str);
+				previous_value = temp_str;
+			}
+			// Token: Close At (_@)
+			else if (current_char === "_" && peek(src, i, 1) === "@") {
+				temp_str = current_char + peek(src, i, 1);
+				i += temp_str.length - 1;
+				// Update Column
+				start = end !== undefined ? end + 1 : 1;
+				end = start + temp_str.length;
+				addToken(TOKEN_TYPES.CLOSE_AT, temp_str);
+				previous_value = temp_str;
+			}
+			// Token: Colon
+			else if (current_char === ":" && previous_value === "_@") {
+				// Update Column
+				start = end !== undefined ? end : 1;
+				end = start;
+				addToken(TOKEN_TYPES.COLON, current_char);
+				previous_value = current_char;
+			}
+			// Token: Newline
+			else if (current_char === "\n") {
+				line++;
+				start = 0;
+				end = 0;
+				previous_value = current_char;
+				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) {
+					i += temp_str.length - 1;
+					if (previous_value === "(") {
+						addToken(TOKEN_TYPES.VALUE, temp_str);
+					} else {
+						addToken(TOKEN_TYPES.TEXT, temp_str);
+					}
+				}
+			}
+			// Token: Block Identifier OR Token: Block Value OR Token: End Keyword
+			else {
+				if (previous_value === "[" || (previous_value === "=" && !scope_state)) {
+					temp_str = concat(src, i, ["=", "]", "\n"], scope_state);
+					i += temp_str.length - 1;
+					// Update Column
+					start = end !== undefined ? end : 1;
+					end = start + temp_str.length;
+					if (temp_str.trim()) {
+						if (previous_value === "[") {
+							// Token: End Keyword
+							if (temp_str.trim() === end_keyword) {
+								addToken(TOKEN_TYPES.END_KEYWORD, temp_str);
+								previous_value = temp_str.trim();
+								scope_state = false;
+							}
+							// Token: Block Identifier
+							else {
+								addToken(TOKEN_TYPES.IDENTIFIER, temp_str);
+								previous_value = block_id;
+							}
+						}
+						// Token: Block Value
+						else if (previous_value === "=") {
+							addToken(TOKEN_TYPES.VALUE, temp_str);
+							previous_value = block_value;
+						}
+					}
+				}
+				// Token: Inline Value OR Token: Inline Identifier
+				else if (previous_value === "(" || (previous_value === "->" && !scope_state)) {
+					temp_str = concat(src, i, [")", "["], scope_state, true, ")");
+					i += temp_str.length - 1;
+					// Update Column
+					start = end !== undefined ? end : 1;
+					end = start + temp_str.length;
+					if (temp_str.trim()) {
+						if (previous_value === "(") {
+							// Token: Inline Value
+							addToken(TOKEN_TYPES.VALUE, temp_str);
+							previous_value = inline_value;
+						} else if (previous_value === "->") {
+							// Token: Inline Identifier
+							addToken(TOKEN_TYPES.IDENTIFIER, temp_str);
+							previous_value = inline_id;
+						}
+					}
+				}
+				// Token: At Identifier OR Token: At Value OR Token: End Keyword
+				else if (previous_value === "@_" || previous_value === ":") {
+					temp_str = concat(src, i, ["_", "\n"], scope_state);
+					i += temp_str.length - 1;
+					if (temp_str.trim()) {
+						// Update Column
+						start = end !== undefined ? end + 1 : 1;
+						end = start + temp_str.length;
+						if (previous_value === "@_") {
+							// Token: End Keyword
+							if (temp_str.trim() === end_keyword) {
+								addToken(TOKEN_TYPES.END_KEYWORD, temp_str);
+								previous_value = temp_str.trim();
+								scope_state = false;
+							}
+							// Token: At Identifier
+							else {
+								addToken(TOKEN_TYPES.IDENTIFIER, temp_str);
+								previous_value = at_id;
+							}
+						}
+						// Token: At Value
+						else if (previous_value === ":") {
+							addToken(TOKEN_TYPES.VALUE, temp_str);
+							previous_value = at_value;
+						}
+					}
+				}
+				// Token: Comment
+				else if (current_char === "#") {
+					temp_str = concat(src, i, ["\n"], scope_state);
+					// Update Column
+					start = previous_value === "\n" ? end : end !== undefined ? end + 1 : 1;
+					end = start + temp_str.length;
+					if (temp_str.trim()) {
+						i += temp_str.length - 1;
+						addToken(TOKEN_TYPES.COMMENT, temp_str);
+					}
+				}
+				// Token: Text
+				else {
+					context = concat(src, i, null, scope_state);
+					i += context.length - 1;
+					// Update Column
+					start = previous_value === "\n" ? end : end !== undefined ? end + 1 : 1;
+					end = start + context.length;
+					if (context.trim()) {
+						addToken(TOKEN_TYPES.TEXT, context);
+					}
+				}
+			}
+			context = "";
+			temp_str = "";
+		}
+		return tokens;
+	} else {
+		lexerError(["{line}<$red:Invalid Source Code:$> <$yellow:Source code is not a string or is empty.$>{line}"]);
+	}
+}
+
+export default lexer;

package/core/names.js

@@ -0,0 +1,13 @@
+export const BLOCK = "Block",
+	TEXT = "Text",
+	INLINE = "Inline",
+	ATBLOCK = "AtBlock",
+	NEWLINE = "Newline",
+	COMMENT = "Comment",
+	block_id = "Block Identifier",
+	block_value = "Block Value",
+	inline_id = "Inline Identifier",
+	inline_value = "Inline Value",
+	at_id = "At Identifier",
+	at_value = "At Value",
+	end_keyword = "end";