sommark 3.1.0 → 3.3.0

package/core/transpiler.js

@@ -3,11 +3,17 @@ import escapeHTML from "../helpers/escapeHTML.js";
 import { transpilerError } from "./errors.js";
 import { textFormat, htmlFormat, markdownFormat, mdxFormat, jsonFormat } from "./formats.js";
 
+/**
+ * SomMark Transpiler
+ */
+
 const BODY_PLACEHOLDER = `__SOMMARK_BODY_PLACEHOLDER_${Math.random().toString(36).slice(2)}__`;
 
 // ========================================================================== //
-//  Extracting target identifier                                              //
+//  Helpers                                                                  //
 // ========================================================================== //
+
+// Finds the matching output definition for a tag identifier
 function matchedValue(outputs, targetId) {
 	if (!outputs || !targetId) return undefined;
 	return outputs.find(output => {
@@ -18,6 +24,24 @@ function matchedValue(outputs, targetId) {
 	});
 }
 
+// Recursively collects all plain text from a node and its children
+function getNodeText(node) {
+	if (!node.body) return "";
+	let text = "";
+	for (const child of node.body) {
+		if (child.type === TEXT) text += child.text;
+		else if (child.type === INLINE) text += child.value;
+		else if (child.type === ATBLOCK) text += child.content;
+		else if (child.type === BLOCK) text += getNodeText(child);
+	}
+	return text;
+}
+
+// ========================================================================== //
+//  Core Rendering Logic                                                     //
+// ========================================================================== //
+
+// Processes an individual node and its body to produce formatted output
 async function generateOutput(ast, i, format, mapper_file) {
 	const node = Array.isArray(ast) ? ast[i] : ast;
 	let result = "";
@@ -33,12 +57,13 @@ async function generateOutput(ast, i, format, mapper_file) {
 		//  Always use placeholders for blocks to support wrapping                      //
 		// ========================================================================== //
 		const placeholder = format === mdxFormat && node.body.length > 0 ? `\n${BODY_PLACEHOLDER}\n` : BODY_PLACEHOLDER;
-		
-		result += target.render.call(mapper_file, { args: node.args, content: placeholder, ast: node });
+		const textContent = getNodeText(node);
+
+		result += target.render.call(mapper_file, { args: node.args, content: placeholder, textContent, ast: node });
 		if (format === mdxFormat) result = "\n" + result + "\n";
 
 		// ========================================================================== //
-		//  Body nodes                                                                //
+		//  Process body nodes recursively                                           //
 		// ========================================================================== //
 		for (let j = 0; j < node.body.length; j++) {
 			const body_node = node.body[j];
@@ -116,13 +141,50 @@ async function generateOutput(ast, i, format, mapper_file) {
 	return result.trimEnd() + "\n";
 }
 
+// ========================================================================== //
+//  Main Transpiler Entry Point                                              //
+// ========================================================================== //
+
 async function transpiler({ ast, format, mapperFile, includeDocument = true }) {
 	let output = "";
 	for (let i = 0; i < ast.length; i++) {
-		if (ast[i].type === BLOCK) {
-			output += await generateOutput(ast, i, format, mapperFile);
-		} else if (ast[i].type === COMMENT) {
-			output += mapperFile.comment(ast[i].text);
+		const node = ast[i];
+		switch (node.type) {
+			case BLOCK:
+				output += await generateOutput(ast, i, format, mapperFile);
+				break;
+			case COMMENT:
+				output += mapperFile.comment(node.text);
+				break;
+			case TEXT:
+				const shouldEscapeText = (format === htmlFormat || format === mdxFormat);
+				output += shouldEscapeText ? escapeHTML(node.text) : node.text;
+				break;
+			case INLINE:
+				let inlineTarget = matchedValue(mapperFile.outputs, node.id);
+				if (!inlineTarget) inlineTarget = mapperFile.getUnknownTag(node);
+				if (inlineTarget) {
+					const shouldEscapeInline = inlineTarget.options?.escape !== false;
+					output += inlineTarget.render.call(mapperFile, {
+						args: node.args.length > 0 ? node.args : [],
+						content: (format === htmlFormat || format === mdxFormat) && shouldEscapeInline ? escapeHTML(node.value) : node.value,
+						ast: node
+					}) + (format === mdxFormat ? "\n" : "");
+				}
+				break;
+			case ATBLOCK:
+				let atTarget = matchedValue(mapperFile.outputs, node.id);
+				if (!atTarget) atTarget = mapperFile.getUnknownTag(node);
+				if (atTarget) {
+					const shouldEscapeAt = atTarget.options?.escape !== false;
+					let content = node.content;
+					if (shouldEscapeAt && (format === htmlFormat || format === mdxFormat)) {
+						content = escapeHTML(content);
+					}
+					const rendered = atTarget.render.call(mapperFile, { args: node.args, content, ast: node }).trimEnd() + "\n";
+					output = output.trim() ? output.trimEnd() + "\n" + rendered : output + rendered;
+				}
+				break;
 		}
 	}
 	// ========================================================================== //

package/coverage_test.js

@@ -0,0 +1,21 @@
+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/helpers/utils.js

@@ -62,6 +62,33 @@ export function safeArg(args, index, key, type = null, setType = null, fallBack
     return fallBack;
 }
 
+/**
+ * Calculates the Levenshtein distance between two strings.
+ * @param {string} a 
+ * @param {string} b 
+ * @returns {number}
+ */
+export function levenshtein(a, b) {
+	const matrix = [];
+	for (let i = 0; i <= b.length; i++) matrix[i] = [i];
+	for (let j = 0; j <= a.length; j++) matrix[0][j] = j;
+
+	for (let i = 1; i <= b.length; i++) {
+		for (let j = 1; j <= a.length; j++) {
+			if (b.charAt(i - 1) === a.charAt(j - 1)) {
+				matrix[i][j] = matrix[i - 1][j - 1];
+			} else {
+				matrix[i][j] = Math.min(
+					matrix[i - 1][j - 1] + 1,
+					matrix[i][j - 1] + 1,
+					matrix[i - 1][j] + 1
+				);
+			}
+		}
+	}
+	return matrix[b.length][a.length];
+}
+
 /**
  * Renders an HTML table.
  */

package/index.js

@@ -13,7 +13,6 @@ import FORMATS, { textFormat, htmlFormat, markdownFormat, mdxFormat, jsonFormat
 import TOKEN_TYPES from "./core/tokenTypes.js";
 import * as labels from "./core/labels.js";
 import PluginManager from "./core/pluginManager.js";
-import QuoteEscaper from "./core/plugins/quote-escaper.js";
 import ModuleSystem from "./core/plugins/module-system.js";
 import RawContentPlugin from "./core/plugins/raw-content-plugin.js";
 import CommentRemover from "./core/plugins/comment-remover.js";
@@ -23,17 +22,18 @@ import { enableColor } from "./helpers/colorize.js";
 import { htmlTable, list, parseList, safeArg, todo } from "./helpers/utils.js";
 
 
-export const BUILT_IN_PLUGINS = [QuoteEscaper, ModuleSystem, RawContentPlugin, CommentRemover, RulesValidationPlugin, SomMarkFormat];
+export const BUILT_IN_PLUGINS = [ModuleSystem, RawContentPlugin, CommentRemover, RulesValidationPlugin, SomMarkFormat];
 
 class SomMark {
-	constructor({ src, format, mapperFile = null, includeDocument = true, plugins = [], excludePlugins = [], priority = [] }) {
+	constructor({ src, format, mapperFile = null, includeDocument = true, plugins = [], excludePlugins = [], priority = [], filename = "anonymous" }) {
 		this.src = src;
 		this.format = format;
 		this.mapperFile = mapperFile;
 		this.priority = priority;
+		this.filename = filename;
+		this.warnings = [];
 
 		// 1. Identify which built-in plugins should be active by default
-		// For now, QuoteEscaper is active, others are inactive (require manual activation)
 		const inactiveByDefault = ["raw-content", "sommark-format"];
 		let activeBuiltIns = BUILT_IN_PLUGINS.filter(p =>
 			!inactiveByDefault.includes(p.name) && !excludePlugins.includes(p.name)
@@ -142,8 +142,12 @@ class SomMark {
 		}
 	}
 
+	reportWarning(message) {
+		this.warnings.push(message);
+	}
+
 	async _applyScopedPreprocessors(src) {
-		let processed = await this.pluginManager.runPreprocessor(src, "top-level");
+		let processed = await this.pluginManager.runPreprocessor(src, "top-level", this);
 
 		// Helper for async regex replacement
 		const asyncReplace = async (str, regex, scope) => {
@@ -160,7 +164,7 @@ class SomMark {
 					if (scope === "content") contentToProcess = match[2];
 
 					if (contentToProcess !== undefined) {
-						const processedContent = await this.pluginManager.runPreprocessor(contentToProcess, scope);
+						const processedContent = await this.pluginManager.runPreprocessor(contentToProcess, scope, this);
 						// Reconstruct the match with processed content
 						if (scope === "arguments") return match[0].replace(match[2], processedContent);
 						if (scope === "content") return match[0].replace(match[2], processedContent);
@@ -188,15 +192,20 @@ class SomMark {
 	async lex(src = this.src) {
 		if (src !== this.src) this.src = src;
 		const processedSrc = await this._applyScopedPreprocessors(this.src);
-		let tokens = lexer(processedSrc);
+		let tokens = lexer(processedSrc, this.filename);
 		tokens = await this.pluginManager.runAfterLex(tokens);
 		return tokens;
 	}
 
 	async parse(src = this.src) {
 		const tokens = await this.lex(src);
-		let ast = parser(tokens);
-		ast = await this.pluginManager.runOnAst(ast, { mapperFile: this.mapperFile });
+		let ast = parser(tokens, this.filename);
+		ast = await this.pluginManager.runOnAst(ast, { 
+			mapperFile: this.mapperFile, 
+			filename: this.filename,
+			format: this.format,
+			instance: this
+		});
 		return ast;
 	}
 
@@ -254,23 +263,23 @@ class SomMark {
 	}
 }
 
-const lex = async (src, plugins = [], excludePlugins = []) => {
-	return await new SomMark({ src, plugins, format: htmlFormat, excludePlugins }).lex();
+const lex = async (src, filename = "anonymous", plugins = [], excludePlugins = []) => {
+	return await new SomMark({ src, filename, plugins, format: htmlFormat, excludePlugins }).lex();
 };
 
-async function parse(src, plugins = [], excludePlugins = []) {
+async function parse(src, filename = "anonymous", plugins = [], excludePlugins = []) {
 	if (!src) {
 		runtimeError([`{line}<$red:Missing Source:$> <$yellow:The 'src' argument is required for parsing.$>{line}`]);
 	}
-	return await new SomMark({ src, plugins, format: htmlFormat, excludePlugins }).parse();
+	return await new SomMark({ src, filename, plugins, format: htmlFormat, excludePlugins }).parse();
 }
 
 async function transpile(options = {}) {
-	const { src, format = htmlFormat, mapperFile = null, includeDocument = true, plugins = [], excludePlugins = [], priority = [] } = options;
+	const { src, format = htmlFormat, filename = "anonymous", mapperFile = null, includeDocument = true, plugins = [], excludePlugins = [], priority = [] } = options;
 	if (typeof options !== "object" || options === null) {
 		runtimeError([`{line}<$red:Invalid Options:$> <$yellow:The options argument must be a non-null object.$>{line}`]);
 	}
-	const knownProps = ["src", "format", "mapperFile", "includeDocument", "plugins", "excludePlugins", "priority"];
+	const knownProps = ["src", "format", "filename", "mapperFile", "includeDocument", "plugins", "excludePlugins", "priority"];
 	Object.keys(options).forEach(key => {
 		if (!knownProps.includes(key)) {
 			runtimeError([
@@ -282,7 +291,7 @@ async function transpile(options = {}) {
 		runtimeError([`{line}<$red:Missing Source:$> <$yellow:The 'src' argument is required for transpilation.$>{line}`]);
 	}
 
-	const sm = new SomMark({ src, format, mapperFile, includeDocument, plugins, excludePlugins, priority });
+	const sm = new SomMark({ src, format, filename, mapperFile, includeDocument, plugins, excludePlugins, priority });
 	return await sm.transpile();
 }
 

package/mappers/languages/html.js

@@ -108,6 +108,10 @@ HTML.register(
 HTML.register(["quote", "blockquote"], function ({ content }) {
 	return this.tag("blockquote").body(content);
 }, { type: "Block" });
+// Raw Content Blocks
+HTML.register(["raw", "mdx"], function ({ content }) {
+	return content;
+}, { type: "Block" });
 // Bold
 HTML.register("bold", function ({ content }) {
 	return this.tag("strong").body(content);
@@ -190,19 +194,10 @@ HTML_TAGS.forEach(tagName => {
 
 		HTML.register(
 			id,
-			function ({ args, content }) {
+			function ({ args, content, textContent }) {
 				const element = this.tag(id);
 				let inline_style = args.style ? (args.style.endsWith(";") ? args.style : args.style + ";") : "";
 
-				// Auto-ID for Headings
-				if (/^h[1-6]$/i.test(id) && !args.id && content) {
-					const idAttr = content
-						.toString()
-						.toLowerCase()
-						.replace(/[^\w\s-]/g, "")
-						.replace(/\s+/g, "-");
-					element.attributes({ id: idAttr });
-				}
 
 				const keys = Object.keys(args).filter(arg => isNaN(arg));
 				keys.forEach(key => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sommark",
-	"version": "3.1.0",
+	"version": "3.3.0",
 	"description": "SomMark is a declarative, extensible markup language for structured content that can be converted to HTML, Markdown, MDX, JSON, and more.",
 	"main": "index.js",
 	"directories": {

package/v3-todo.smark

@@ -2,74 +2,72 @@
 (SomMark v3 Goals)->(h1)
 
 # Completed Features & Fixes
-(done)->(todo: Full HTML5 support)
-(done)->(todo: Full Markdown and MDX support)
-(done)->(todo: Safe custom overrides for component mappers)
-(done)->(todo: Fix lexer infinite loops and crashes)
-(done)->(todo: Fix block spacing and paragraph newlines)
-(done)->(todo: Allow -, _, and $ in identifiers)
-(done)->(todo: Prevent generic HTML tags from overwriting custom components)
-(done)->(todo: Add 'lex' and 'parse' CLI options)
-(done)->(todo: Fix --text format error in CLI)
-(done)->(todo: Fix comma handling in inline components)
-(done)->(todo: Fix void element nesting in examples)
-(done)->(todo: CSS variable support like color: --primary)
-(done)->(todo: More showcase examples for docs)
-(done)->(todo: Auto-generate anchor IDs for headings)
-(done)->(todo: Fix lexer '=' bug for literal equal signs)
-(done)->(todo: Fix newline tokenization for multi-line blocks)
-(done)->(todo: Fix multi-line prefixing in Markdown output)
-(done)->(todo: Smart MDX mapper with JSX and style conversion)
-(done)->(todo: Scoped plugin system with instance isolation)
-(done)->(todo: Configure built-in and external plugins via 'options' prop)
-(done)->(todo: Consistent identifier rules for $, _, and - in lexer and parser)
-(done)->(todo: Reserve 'end' as a keyword)
-(done)->(todo: Enforce registration types: Block, Inline, AtBlock, or any)
-(done)->(todo: Consistent internal property names like 'is_self_closing')
-(done)->(todo: Multi-stage plugin pipeline: beforeLex, onAst, afterTranspile)
-(done)->(todo: Priority-based PluginManager)
-(done)->(todo: Built-in 'comment-remover' plugin using AST transforms)
-(done)->(todo: 'self-closing' plugin with indentation-aware detection)
-(done)->(todo: CLI uses unified SomMark API with plugin support)
-(done)->(todo: Local smark.config.js takes priority over global config)
-(done)->(todo: Add register\(\) and inherit\(\) methods to SomMark instance)
-(done)->(todo: Release SomMark Version 3)
-(done)->(todo: Case-insensitive target matching and BODY_PLACEHOLDER in transpiler)
-(done)->(todo: Mapper base class: clone, clear, extraProps, and type deprecation)
-(done)->(todo: Class-based HTML and Markdown mappers with type hints)
-(done)->(todo: Rewrite MDX mapper for better JSX and style handling)
-(done)->(todo: Broader JSON mapper output support)
-(done)->(todo: Built-in plugins: QuoteEscaper, ModuleSystem, RawContentPlugin, RulesValidationPlugin)
-(done)->(todo: Plugin activation with merged defaults and user plugins)
-(done)->(todo: validateIdentifier helper in lexer)
-(done)->(todo: Better parser argument trimming and quote stripping)
-(done)->(todo: CLI passes plugins and priority from config to SomMark)
-(done)->(todo: Clean up old test files)
-(done)->(todo: smark list plugins and smark list pipeline commands)
-(done)->(todo: smark show config command for configuration introspection)
-(done)->(todo: smark color command for CLI color management)
-(done)->(todo: getUnknownTag\(node\) method in Mapper system for generic tag handling)
-(done)->(todo: Placeholder Injection Security fix to prevent <%smark> bypass)
-(done)->(todo: safeArg utility in Mapper for robust argument parsing)
-(done)->(todo: Consistent CLI error formatting with sommarkError and cliError)
-(done)->(todo: Enforce semicolon in AtBlock header start)
-(done)->(todo: 100% API documentation coverage in docs/api)
-(done)->(todo: Consolidated deprecated APIs into deprecated-apis.md)
-(done)->(todo: Removed loadCss and unused properties from Mapper.js)
-(done)->(todo: Standardized HTML comment formatting to <!-- comment -->)
-(done)->(todo: Extracted common formatters to helpers/utils.js)
-(done)->(todo: Modernized all core documentation guides for v3 best practices)
-(done)->(todo: Created dedicated Plugin System and Built-in Plugins guides)
-(done)->(todo: Activated comment-remover and module-system plugins by default)
-(done)->(todo: Fixed escaped comma handling in Markdown table builder)
-(done)->(todo: Deprecated Mapper.highlightCode in favor of plugins)
-(done)->(todo: Deprecated Mapper.themes and currentTheme)
-(done)->(todo: Deprecated Mapper.enable_highlightTheme and enable_table_styles)
-(done)->(todo: Deprecated Mapper.env and loadCss)
-(done)->(todo: Deprecated Mapper.registerHighlightTheme and selectHighlightTheme)
-(done)->(todo: Relocated Mapper.htmlTable to helpers/utils.js)
-(done)->(todo: Relocated Mapper.list and parseList to helpers/utils.js)
-(done)->(todo: Relocated Mapper.todo to helpers/utils.js)
-(done)->(todo: Relocated Mapper.code to specialized mappers)
-(done)->(todo: Fixed todo mapper bug regarding placeholder detection and dynamic status)
+(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]

package/core/plugins/quote-escaper.js

@@ -1,37 +0,0 @@
-/**
- * Quote Escaper Plugin for SomMark
- * 
- * Scope: arguments
- * 
- * Automatically escapes special characters within double quotes in arguments.
- */
-const QuoteEscaper = {
-	name: "quote-escaper",
-	type: "preprocessor",
-	author: "Adam-Elmi",
-	description: "Automatically escapes special characters within double-quoted string arguments.",
-	scope: "arguments",
-	beforeLex(args) {
-		return args.replace(/"([^"]*)"/g, (match, content) => {
-			const options = this.options || {};
-
-			const escapedContent = content
-				.replace(/\\/g, "\\\\")
-				.replace(/\[/g, "\\[")
-				.replace(/\]/g, "\\]")
-				.replace(/=/g, "\\=")
-				.replace(/->/g, "\\->")
-				.replace(/\(/g, "\\(")
-				.replace(/\)/g, "\\)")
-				.replace(/@_/g, "\\@_")
-				.replace(/_@/g, "\\_@")
-				.replace(/:/g, "\\:")
-				.replace(/,/g, "\\,")
-				.replace(/;/g, "\\;")
-				.replace(/#/g, "\\#");
-			return `"${escapedContent}"`;
-		});
-	}
-};
-
-export default QuoteEscaper;

package/format.js

@@ -1,23 +0,0 @@
-import fs from "node:fs/promises";
-import SomMark from "./index.js"; 
-const rawSource = await fs.readFile("./unformatted.smark", "utf8");
-
-const smark = new SomMark({
-	src: rawSource,
-	format: "html",
-	plugins: [
-		{ 
-			name: "sommark-format", 
-			options: { indentString: "  " } // 2 spaces instead of default "\t"
-		}
-	]
-});
-
-// 1. Run parse() 
-await smark.parse();
-
-// 2. Get the formatted string from the "sommark-format" plugin
-const formatPlugin = smark.plugins.find(p => p.name === "sommark-format");
-
-console.log("--- Formatted Output ---");
-console.log(formatPlugin.formattedSource);

package/unformatted.smark

@@ -1,90 +0,0 @@
-[  Document =  version:1.0, type: article ]
-#    Starting the document with messy comments   
-  ( Welcome )->(Strong) to the test document!
-[ Section = id: intro ]
-[ Paragraph ]
-This is [Block][end] the first paragraph. It has      some weird spaces    and
-attached.[Block][end]
-[ end ]
-[ Paragraph ]
-Another paragraph with [ nested ] text that is not a real block, wait, [ nested ] is a block!
-[ end ]
-[end]
-[end]
-[ Section = id: content ][ List = type: bullet ][ Item ]( Apple )->(Bold)
-[ end ]
-[ Item ]
-Banana[ end ][ Item ]Cherry
-[ end ]
-[ end ]
-@_  CodeSnippet _@ : javascript;
-function doSomething() {
-  let x = 10;
-    return x * 2;
-}
-@_ end _@
-[ Paragraph ]
-Some text after the code snippet.
-[ end ]
-[ Subsection = title: "Deep Nesting" ]
-[ Level1 ][ Level2 ][ Level3 ]
-[ Level4 ]
-[ Level5 ]
-( Deeply )->( Nested )
-[ end ]
-[ end ]
-[ end ]
-[ end ]
-[ end ]
-[ end ]
-[ Subsection = title: "Mix and Match" ]
-[ Paragraph ]
-( Start )->( A ) ( Middle )->( B ) ( End )->( C )
-[ end ]
-[ end ]
-[ Section = id: outro ]
-[ Paragraph ]
-Thank you for reading!
-# A wild comment appears
-[ end ]
-@_ RawText _@ : plain ;
-Just some raw text.
-   It should preserve its internal spacing.
-   
-But the at-block itself will be properly indented.
-@_ end _@
-[ end ]
-[ Section = id: footer ]
-[ Paragraph ]
-( Copyright )->( Small ) 2023. All rights reserved.
-[ end ]
-[ end ]
-[ Section = empty ]
-[ end ]
-[ Section = single_line ]
-Single line content.
-[ end ]
-[ Section = messy_arguments , another_arg: value ]
-Content here.
-[ end ]
-[ Section = id: mixed_content ]
-Text before block.
-[ Paragraph ]
-Inside block.
-[ end ]
-Text after block.
-[ end ]
-[ Section = id: last_one ]
-[ Paragraph ]
-( The )->(bold)
-[ end ]
-[ end ]
-[ Section = id: extra ]
-[ Paragraph ]
-( Extra )->( One )text glued to an inline!
-( Extra )->( Two )
-[ end ]
-[ end ]
-[end]
-[end]
-[end]