sommark 3.1.0 → 3.3.0

package/core/parser.js

@@ -1,3 +1,6 @@
+/**
+ * SomMark Parser
+ */
 import TOKEN_TYPES from "./tokenTypes.js";
 import peek from "../helpers/peek.js";
 import { parserError } from "./errors.js";
@@ -7,6 +10,8 @@ import {
 	INLINE,
 	ATBLOCK,
 	COMMENT,
+	IMPORT,
+	USE_MODULE,
 	block_id,
 	block_value,
 	inline_id,
@@ -15,6 +20,11 @@ import {
 	at_value,
 	end_keyword
 } from "./labels.js";
+import { levenshtein } from "../helpers/utils.js";
+
+// ========================================================================== //
+//  Helper Functions                                                         //
+// ========================================================================== //
 
 function current_token(tokens, i) {
 	return tokens[i] || null;
@@ -38,7 +48,11 @@ function makeBlockNode() {
 		id: "",
 		args: [],
 		body: [],
-		depth: 0
+		depth: 0,
+		range: {
+			start: { line: 0, character: 0 },
+			end: { line: 0, character: 0 }
+		}
 	};
 }
 
@@ -46,7 +60,11 @@ function makeTextNode() {
 	return {
 		type: TEXT,
 		text: "",
-		depth: 0
+		depth: 0,
+		range: {
+			start: { line: 0, character: 0 },
+			end: { line: 0, character: 0 }
+		}
 	};
 }
 
@@ -54,7 +72,11 @@ function makeCommentNode() {
 	return {
 		type: COMMENT,
 		text: "",
-		depth: 0
+		depth: 0,
+		range: {
+			start: { line: 0, character: 0 },
+			end: { line: 0, character: 0 }
+		}
 	};
 }
 
@@ -64,57 +86,82 @@ function makeInlineNode() {
 		value: "",
 		id: "",
 		args: [],
-		depth: 0
+		depth: 0,
+		range: {
+			start: { line: 0, character: 0 },
+			end: { line: 0, character: 0 }
+		}
 	};
 }
 
+// ========================================================================== //
+//  Node Creators (Factories)                                                //
+// ========================================================================== //
+
 function makeAtBlockNode() {
 	return {
 		type: ATBLOCK,
 		id: "",
 		args: [],
 		content: "",
-		depth: 0
+		depth: 0,
+		range: {
+			start: { line: 0, character: 0 },
+			end: { line: 0, character: 0 }
+		}
 	};
 }
 
+// ========================================================================== //
+//  Parser State and Error Tracking                                          //
+// ========================================================================== //
+
 let end_stack = [];
 let tokens_stack = [];
-let line = 1,
-	start = 1,
-	end = 1,
+let range = {
+	start: { line: 0, character: 0 },
+	end: { line: 0, character: 0 }
+},
 	value = "";
 
 const fallback = {
 	value: "Unknown",
-	line: "Unknown",
-	start: "Unknown",
-	end: "Unknown",
+	range: {
+		start: { line: 0, character: 0 },
+		end: { line: 0, character: 0 }
+	},
 	tokens_stack: ["--Empty--"]
 };
 const updateData = (tokens, i) => {
 	if (tokens[i]) {
 		tokens_stack.push(tokens[i].value);
-		line = tokens[i].line;
-		start = tokens[i].start;
-		end = tokens[i].end;
+		range = tokens[i].range;
 		value = tokens[i].value;
 	}
 };
 
-const errorMessage = (tokens, i, expectedValue, behindValue, frontText) => {
-	const current = tokens[i] ?? fallback;
-	const errorLineNumber = current.line;
+const errorMessage = (tokens, i, expectedValue, behindValue, frontText, filename = null) => {
+	const current = tokens[i] || fallback;
+	const errorLineNumber = current.range.start.line;
+	const errorCharNumber = current.range.start.character;
+	const source = current.source || filename;
+	const sourceLabel = source ? ` [${source}]` : "";
 
-	// Find starting index of the error line
 	let lineStartIndex = i;
-	while (lineStartIndex > 0 && tokens[lineStartIndex - 1].line === errorLineNumber) {
+	while (
+		lineStartIndex > 0 &&
+		tokens[lineStartIndex - 1].range.start.line === errorLineNumber &&
+		(tokens[lineStartIndex - 1].source || filename) === source
+	) {
 		lineStartIndex--;
 	}
 
-	// Find ending index of the error line
 	let lineEndIndex = i;
-	while (lineEndIndex < tokens.length - 1 && tokens[lineEndIndex + 1].line === errorLineNumber) {
+	while (
+		lineEndIndex < tokens.length - 1 &&
+		tokens[lineEndIndex + 1].range.start.line === errorLineNumber &&
+		(tokens[lineEndIndex + 1].source || filename) === source
+	) {
 		lineEndIndex++;
 	}
 
@@ -125,16 +172,19 @@ const errorMessage = (tokens, i, expectedValue, behindValue, frontText) => {
 	// Get content on the line before the error token
 	const tokensBeforeErrorOnLine = tokens.slice(lineStartIndex, i);
 	const contentBeforeErrorOnLine = tokensBeforeErrorOnLine.map(t => t.value).join('');
-	
+
 	const pointerPadding = " ".repeat(contentBeforeErrorOnLine.length);
+	const rangeInfo = current.range.start.line === current.range.end.line
+		? `from column <$yellow:${current.range.start.character}$> to <$yellow:${current.range.end.character}$>`
+		: `from line <$yellow:${current.range.start.line + 1}$>, column <$yellow:${current.range.start.character}$> to line <$yellow:${current.range.end.line + 1}$>, column <$yellow:${current.range.end.character}$>`;
 
 	return [
-		`<$blue:{line}$><$red:Here where error occurred:$>{N}${lineContent}{N}${pointerPadding}<$yellow:^$>{N}{N}`,
-		`<$red:${frontText ? frontText : "Expected token"}$> <$blue:'${expectedValue}'$> ${behindValue ? "after <$blue:'" + behindValue + "'$>" : ""} at line <$yellow:${line}$>,`,
-		` from column <$yellow: ${start}$> to <$yellow: ${end}$>`,
-		`{N}<$yellow:Received:$> <$blue:'${value === "\n" ? "\\n' (newline)" : value}'$>`,
-		` at line <$yellow:${current.line}$>,`,
-		` from column <$yellow: ${current.start}$> to <$yellow: ${current.end}$>{N}`,
+		`<$blue:{line}$><$red:Here where error occurred${sourceLabel}:$>{N}${lineContent}{N}${pointerPadding}<$yellow:^$>{N}{N}`,
+		`<$red:${frontText ? frontText : "Expected token"}$>${!frontText ? " <$blue:'" + expectedValue + "'$>" : ""} ${behindValue ? "after <$blue:'" + behindValue + "'$>" : ""} at line <$yellow:${current.range.start.line + 1}$>,`,
+		` ${rangeInfo}`,
+		`{N}<$yellow:Received:$> <$blue:'${current.value === "\n" ? "\\n' (newline)" : current.value}'$>`,
+		` at line <$yellow:${current.range.start.line + 1}$>,`,
+		` ${rangeInfo}{N}`,
 		"<$blue:{line}$>"
 	];
 };
@@ -231,23 +281,34 @@ function parseSemiColon(tokens, i, afterChar = "") {
 // ========================================================================== //
 //  Parse Block                                                               //
 // ========================================================================== //
-function parseBlock(tokens, i) {
+function parseBlock(tokens, i, filename = null) {
 	const blockNode = makeBlockNode();
+	const openBracketToken = current_token(tokens, i);
 	// ========================================================================== //
 	//  consume '['                                                               //
 	// ========================================================================== //
 	i++;
 	updateData(tokens, i);
-	if (!current_token(tokens, i) || (current_token(tokens, i) && current_token(tokens, i).type !== TOKEN_TYPES.IDENTIFIER)) {
-		parserError(errorMessage(tokens, i, block_id, "["));
+	const idToken = current_token(tokens, i);
+	if (!idToken || idToken.type === TOKEN_TYPES.EOF) {
+		parserError(errorMessage(tokens, i, "Block ID", "[", "Missing Block Identifier"));
 	}
-	const id = current_token(tokens, i).value;
+	const id = idToken.value;
 	if (id.trim() === end_keyword) {
 		parserError(errorMessage(tokens, i, id, "", `'${id.trim()}' is a reserved keyword and cannot be used as an identifier.`));
 	}
 	blockNode.id = id.trim();
+	if (!blockNode.id) {
+		parserError(errorMessage(tokens, i, "Block ID", "[", "Block identifier cannot be empty"));
+	}
+	if (blockNode.id === "import") {
+		blockNode.type = IMPORT;
+	} else if (blockNode.id === "$use-module") {
+		blockNode.type = USE_MODULE;
+	}
 	validateName(blockNode.id);
-	blockNode.depth = current_token(tokens, i).depth;
+	blockNode.depth = idToken.depth;
+	blockNode.range.start = openBracketToken.range.start;
 	end_stack.push(id);
 	// ========================================================================== //
 	//  consume Block Identifier                                                  //
@@ -369,7 +430,7 @@ function parseBlock(tokens, i) {
 			peek(tokens, i, 1) &&
 			peek(tokens, i, 1).type !== TOKEN_TYPES.END_KEYWORD
 		) {
-			const [childNode, nextIndex] = parseBlock(tokens, i);
+			const [childNode, nextIndex] = parseBlock(tokens, i, filename);
 			blockNode.body.push(childNode);
 			// ========================================================================== //
 			//  consume child node                                                        //
@@ -385,8 +446,16 @@ function parseBlock(tokens, i) {
 			//  consume '['                                                               //
 			// ========================================================================== //
 			i++;
-			if (!current_token(tokens, i) || (current_token(tokens, i) && current_token(tokens, i).type !== TOKEN_TYPES.END_KEYWORD && current_token(tokens, i).value.trim() !== end_keyword)) {
-				parserError(errorMessage(tokens, i, "end", "["));
+			const current = current_token(tokens, i);
+			if (!current || (current.type !== TOKEN_TYPES.END_KEYWORD && current.value.trim() !== end_keyword)) {
+				let extraInfo = "";
+				if (current && current.value) {
+					const dist = levenshtein(current.value.trim().toLowerCase(), "end");
+					if (dist <= 2) {
+						extraInfo = ` (Did you mean <$cyan:'[end]'$>?)`;
+					}
+				}
+				parserError(errorMessage(tokens, i, "end", "[", extraInfo));
 			}
 			// ========================================================================== //
 			//  consume End Keyword                                                       //
@@ -403,17 +472,19 @@ function parseBlock(tokens, i) {
 			// ========================================================================== //
 			//  consume ']'                                                               //
 			// ========================================================================== //
+			const closeBracketToken = current_token(tokens, i);
 			i++;
 			updateData(tokens, i);
+			blockNode.range.end = closeBracketToken.range.end;
 			break;
 		} else {
-			const [childNode, nextIndex] = parseNode(tokens, i);
-			if (!childNode) {
-				i += 1;
-				continue;
+			const [childNode, nextIndex] = parseNode(tokens, i, filename);
+			if (childNode) {
+				blockNode.body.push(childNode);
+				i = nextIndex;
+			} else {
+				i++; // Should not happen with current parseNode fallback but good for safety
 			}
-			blockNode.body.push(childNode);
-			i = nextIndex;
 		}
 	}
 	return [blockNode, i];
@@ -423,6 +494,8 @@ function parseBlock(tokens, i) {
 // ========================================================================== //
 function parseInline(tokens, i) {
 	const inlineNode = makeInlineNode();
+	const openParenToken = current_token(tokens, i);
+	inlineNode.range.start = openParenToken.range.start;
 	// ========================================================================== //
 	//  consume '('                                                               //
 	// ========================================================================== //
@@ -569,8 +642,10 @@ function parseInline(tokens, i) {
 	// ========================================================================== //
 	//  consume ')'                                                               //
 	// ========================================================================== //
+	const finalParenToken = current_token(tokens, i);
 	i++;
 	updateData(tokens, i);
+	inlineNode.range.end = finalParenToken.range.end;
 	tokens_stack.length = 0;
 	return [inlineNode, i];
 }
@@ -579,7 +654,9 @@ function parseInline(tokens, i) {
 // ========================================================================== //
 function parseText(tokens, i, options = {}) {
 	const textNode = makeTextNode();
-	textNode.depth = current_token(tokens, i).depth;
+	const startToken = current_token(tokens, i);
+	textNode.range.start = startToken.range.start;
+	textNode.depth = startToken.depth;
 	const { selectiveUnescape = false } = options;
 
 	while (i < tokens.length) {
@@ -604,14 +681,17 @@ function parseText(tokens, i, options = {}) {
 		} else {
 			break;
 		}
+		textNode.range.end = current_token(tokens, i - 1).range.end;
 	}
 	return [textNode, i];
 }
 // ========================================================================== //
 //  Parse AtBlock                                                             //
 // ========================================================================== //
-function parseAtBlock(tokens, i) {
+function parseAtBlock(tokens, i, filename = null) {
 	const atBlockNode = makeAtBlockNode();
+	const openAtToken = current_token(tokens, i);
+	atBlockNode.range.start = openAtToken.range.start;
 	// ========================================================================== //
 	//  consume '@_'                                                              //
 	// ========================================================================== //
@@ -712,7 +792,7 @@ function parseAtBlock(tokens, i) {
 		}
 	}
 	if (!current_token(tokens, i) || (current_token(tokens, i) && current_token(tokens, i).type !== TOKEN_TYPES.SEMICOLON)) {
-		parserError(errorMessage(tokens, i, ";", at_value));
+		parserError(errorMessage(tokens, i, ";", at_value, "A semicolon (;) is required after the AtBlock identifier or its arguments (e.g., '@_Table_@:' or '@_Table_@: key, val;').", filename));
 	}
 	i = parseSemiColon(tokens, i, at_value);
 	if (
@@ -754,8 +834,10 @@ function parseAtBlock(tokens, i) {
 	// ========================================================================== //
 	//  consume '_@'                                                              //
 	// ========================================================================== //
+	const closeAtToken = current_token(tokens, i);
 	i++;
 	updateData(tokens, i);
+	atBlockNode.range.end = closeAtToken.range.end;
 	tokens_stack.length = 0;
 	return [atBlockNode, i];
 }
@@ -764,9 +846,11 @@ function parseAtBlock(tokens, i) {
 // ========================================================================== //
 function parseCommentNode(tokens, i) {
 	const commentNode = makeCommentNode();
-	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.COMMENT) {
-		commentNode.text = current_token(tokens, i).value;
-		commentNode.depth = current_token(tokens, i).depth;
+	const token = current_token(tokens, i);
+	if (token && token.type === TOKEN_TYPES.COMMENT) {
+		commentNode.text = token.value;
+		commentNode.depth = token.depth;
+		commentNode.range = token.range;
 	}
 	// ========================================================================== //
 	//  consume Comment '#'                                                       //
@@ -776,7 +860,11 @@ function parseCommentNode(tokens, i) {
 	return [commentNode, i];
 }
 
-function parseNode(tokens, i) {
+// ========================================================================== //
+//  Main Node Dispatcher                                                     //
+// ========================================================================== //
+
+function parseNode(tokens, i, filename = null) {
 	if (!current_token(tokens, i) || (current_token(tokens, i) && !current_token(tokens, i).value)) {
 		return [null, i];
 	}
@@ -797,10 +885,31 @@ function parseNode(tokens, i) {
 		return parseBlock(tokens, i);
 	}
 	// ========================================================================== //
-	//  Inline Statement                                                          //
+	//  Inline Statement or Text                                                  //
 	// ========================================================================== //
 	else if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.OPEN_PAREN) {
-		return parseInline(tokens, i);
+		// Look ahead to see if this is an inline statement: (...) -> (...)
+		let j = i + 1;
+		let foundClose = false;
+		while (j < tokens.length) {
+			if (tokens[j].type === TOKEN_TYPES.CLOSE_PAREN) {
+				foundClose = true;
+				break;
+			}
+			// Avoid going too far if it's definitely not an inline (not matching the value part structure)
+			if (tokens[j].type === TOKEN_TYPES.OPEN_PAREN || tokens[j].type === TOKEN_TYPES.OPEN_BRACKET) break;
+			j++;
+		}
+
+		if (foundClose && tokens[j + 1] && tokens[j + 1].type === TOKEN_TYPES.THIN_ARROW) {
+			return parseInline(tokens, i);
+		}
+
+		// Treat as text if not an inline
+		const textNode = makeTextNode();
+		textNode.text = current_token(tokens, i).value;
+		textNode.range = current_token(tokens, i).range;
+		return [textNode, i + 1];
 	}
 	// ========================================================================== //
 	//  Text                                                                      //
@@ -815,36 +924,63 @@ function parseNode(tokens, i) {
 	//  Atblock                                                                   //
 	// ========================================================================== //
 	else if (current_token(tokens, i) && (current_token(tokens, i).type === TOKEN_TYPES.OPEN_AT)) {
-		return parseAtBlock(tokens, i);
+		return parseAtBlock(tokens, i, filename);
 	} else {
-		parserError(errorMessage(tokens, i, current_token(tokens, i).value, "", "Syntax Error:"));
+		// FALLBACK: Treat any other token as TEXT to avoid infinite loops and allow literal content
+		const textNode = makeTextNode();
+		textNode.text = current_token(tokens, i).value;
+		textNode.range = current_token(tokens, i).range;
+		return [textNode, i + 1];
 	}
-	return [null, i + 1];
 }
 
-function parser(tokens) {
+// ========================================================================== //
+//  Main Parser Entry Point                                                  //
+// ========================================================================== //
+
+function parser(tokens, filename = null) {
+	// Filter out structural whitespace (junk) that was emitted for highlighting purposes
+	tokens = tokens.filter(t => !t.isStructural);
 	end_stack = [];
 	tokens_stack = [];
-	line = 1;
-	start = 1;
-	end = 1;
+	range = {
+		start: { line: 0, character: 0 },
+		end: { line: 0, character: 0 }
+	};
 	value = "";
 	let ast = [];
 	let i = 0;
 	while (i < tokens.length) {
-		let [nodes, nextIndex] = parseNode(tokens, i);
-		if (nodes && nodes.type !== "Comment" && nodes.depth === 0) {
-			parserError(errorMessage(tokens, i, "Top-level Block", "", "Top-level content must be wrapped in a block. Found:"));
-		}
-		if (nodes) {
-			ast.push(nodes);
+		let [node, nextIndex] = parseNode(tokens, i, filename);
+		if (node) {
+			ast.push(node);
 			i = nextIndex;
 		} else {
 			i++;
 		}
 	}
 	if (end_stack.length !== 0) {
-		parserError(errorMessage(tokens, tokens.length - 1, "[end]", "", "Missing"));
+		let extraInfo = "";
+
+		const checkTypo = (token) => {
+			if (token && token.value) {
+				const val = token.value.trim().toLowerCase();
+				if (val === "") return "";
+				const dist = levenshtein(val, "end");
+				if (dist > 0 && dist <= 2) return ` (Did you mean <$cyan:'[end]'$>?)`;
+			}
+			return "";
+		};
+
+		// Check last few tokens for a typo
+		for (let j = 1; j <= 5; j++) {
+			const token = tokens[tokens.length - j];
+			if (!token) break;
+			extraInfo = checkTypo(token);
+			if (extraInfo) break;
+		}
+
+		parserError(errorMessage(tokens, tokens.length - 1, "[end]", "", extraInfo ? `Missing '[end]'${extraInfo}` : "Missing '[end]'", filename));
 	}
 	return ast;
 }

package/core/pluginManager.js

@@ -1,10 +1,14 @@
+/**
+ * Plugin Manager
+ * Handles sorting by priority and running hooks at various stages.
+ */
 export default class PluginManager {
 	constructor(plugins = [], priority = []) {
+		// ========================================================================== //
+		//  Plugin Sorting by Priority                                               //
+		// ========================================================================== //
 		this.plugins = [...plugins].sort((a, b) => {
 			const getIndex = (p) => {
-				// ========================================================================== //
-				// Priority array can contain plugin objects or plugin names (for built-ins)
-				// ========================================================================== //
 				const index = priority.findIndex(item => {
 					if (typeof item === "string") {
 						return item === p.name;
@@ -17,29 +21,13 @@ export default class PluginManager {
 			const indexA = getIndex(a);
 			const indexB = getIndex(b);
 
-			// ========================================================================== //
-			// 1. Both have a priority index
-			// ========================================================================== //
-			if (indexA !== -1 && indexB !== -1) {
-				return indexA - indexB;
-			}
-
-			// ========================================================================== //
-			// 2. Only A has a priority
-			// ========================================================================== //
+			if (indexA !== -1 && indexB !== -1) return indexA - indexB;
 			if (indexA !== -1) return -1;
-
-			// ========================================================================== //
-			// 3. Only B has a priority
-			// ========================================================================== //
 			if (indexB !== -1) return 1;
 
-			// ========================================================================== //
-			// 4. Neither have a priority
 			// Default rule: built-ins first, then external/user-defined
-			// ========================================================================== //
-			const isBuiltInA = ["module-system", "quote-escaper", "raw-content", "comment-remover", "rules-validation", "sommark-format"].includes(a.name); // Hardcoded for now based on current project
-			const isBuiltInB = ["module-system", "quote-escaper", "raw-content", "comment-remover", "rules-validation", "sommark-format"].includes(b.name);
+			const isBuiltInA = ["module-system", "raw-content", "comment-remover", "rules-validation", "sommark-format"].includes(a.name);
+			const isBuiltInB = ["module-system", "raw-content", "comment-remover", "rules-validation", "sommark-format"].includes(b.name);
 
 			if (isBuiltInA && !isBuiltInB) return -1;
 			if (!isBuiltInA && isBuiltInB) return 1;
@@ -48,7 +36,10 @@ export default class PluginManager {
 		});
 	}
 
-	async runPreprocessor(src, scope) {
+	// ========================================================================== //
+	//  Preprocessing Hooks (Before Lexing)                                      //
+	// ========================================================================== //
+	async runPreprocessor(src, scope, context) {
 		let processedSrc = src;
 		const preprocessors = this.plugins.filter(p => {
 			const types = Array.isArray(p.type) ? p.type : [p.type];
@@ -57,12 +48,16 @@ export default class PluginManager {
 
 		for (const plugin of preprocessors) {
 			if (typeof plugin.beforeLex === "function") {
+				plugin.context = context;
 				processedSrc = await plugin.beforeLex.call(plugin, processedSrc);
 			}
 		}
 		return processedSrc;
 	}
 
+	// ========================================================================== //
+	//  Post-Lexing Hooks (Token Transformation)                                  //
+	// ========================================================================== //
 	async runAfterLex(tokens) {
 		let processedTokens = tokens;
 		const afterLexers = this.plugins.filter(p => {
@@ -76,6 +71,9 @@ export default class PluginManager {
 		return processedTokens;
 	}
 
+	// ========================================================================== //
+	//  AST Transformation Hooks (After Parsing)                                 //
+	// ========================================================================== //
 	async runOnAst(ast, context = {}) {
 		let processedAst = ast;
 		const astPlugins = this.plugins.filter(p => {
@@ -89,6 +87,9 @@ export default class PluginManager {
 		return processedAst;
 	}
 
+	// ========================================================================== //
+	//  Mapper Extensions (Tag Definitions and Rules)                            //
+	// ========================================================================== //
 	getMapperExtensions() {
 		const extensions = { outputs: [], rules: {} };
 		const mapperPlugins = this.plugins.filter(p => {
@@ -107,6 +108,9 @@ export default class PluginManager {
 		return extensions;
 	}
 
+	// ========================================================================== //
+	//  Registration Hooks                                                       //
+	// ========================================================================== //
 	runRegisterHooks(sm) {
 		for (const plugin of this.plugins) {
 			const registerFn = plugin.registerOutput || plugin.register;
@@ -116,6 +120,9 @@ export default class PluginManager {
 		}
 	}
 
+	// ========================================================================== //
+	//  Post-Processing Hooks (Final Output Transformation)                      //
+	// ========================================================================== //
 	async runTransformers(output) {
 		let processedOutput = output;
 		const transformers = this.plugins.filter(p => {
@@ -132,6 +139,9 @@ export default class PluginManager {
 		return processedOutput;
 	}
 
+	// ========================================================================== //
+	//  Format-Specific Mapper Retrieval                                         //
+	// ========================================================================== //
 	getFormatMapper(formatName) {
 		const plugin = this.plugins.find(p => p.format === formatName && p.mapper);
 		return plugin ? plugin.mapper : null;

package/core/plugins/comment-remover.js

@@ -1,14 +1,14 @@
 import { COMMENT } from "../labels.js";
 
 /**
- * Built-in plugin to remove all comments from the AST.
- * Active by default.
+ * Comment Remover Plugin
+ * Removes all comments from the document so they don't appear in the final output.
  */
 export default {
     name: "comment-remover",
     type: "on-ast",
     author: "Adam-Elmi",
-    description: "Removes all comment nodes from the AST during the parsing phase.",
+    description: "Removes all comments from the document so they don't appear in the final output.",
     onAst: function (ast) {
         // ========================================================================== //
         //  Recursive function to filter out comments                               //