sommark 3.3.4 → 4.0.1

package/mappers/shared/index.js

@@ -0,0 +1,22 @@
+/**
+ * Registers shared utility tags across HTML, Markdown, and MDX mappers.
+ * @param {Mapper} mapper - The mapper instance to register tags on.
+ */
+export function registerSharedOutputs(mapper) {
+    // 1. 'raw' - AtBlock that return the raw, unparsed content.
+    mapper.register("raw", ({ content }) => content, { 
+        type: "AtBlock",
+        escape: false 
+    });
+
+    // 2. 'css' - An Inline tag that applies inline styles to its content.
+    // Usage: (text)->(css: "color: red")
+    mapper.register("css", ({ args, content }) => {
+        let style = mapper.safeArg({ args, index: 0, key: "style", fallBack: "" });
+        style = style.split(";").map(s => s.trim().split(":").map(s => s.trim()).join(":")).join(";");
+        return mapper.tag("span").attributes({ style }).body(content);
+    }, { 
+        type: "Inline" 
+    });
+
+}

package/package.json

@@ -1,8 +1,21 @@
 {
 	"name": "sommark",
-	"version": "3.3.4",
-	"description": "SomMark is a declarative, extensible markup language for structured content that can be converted to HTML, Markdown, MDX, JSON, and more.",
+	"version": "4.0.1",
+	"description": "SomMark is a declarative, extensible markup language for structured content that can be converted to HTML, Markdown, MDX, JSON, XML, and more.",
 	"main": "index.js",
+	"files": [
+		"index.js",
+		"core/",
+		"mappers/",
+		"helpers/",
+		"formatter/",
+		"constants/",
+		"cli/",
+		"assets/",
+		"grammar.ebnf",
+		"README.md",
+		"LICENSE"
+	],
 	"directories": {
 		"test": "tests"
 	},
@@ -12,10 +25,9 @@
 	},
 	"scripts": {
 		"test": "vitest",
-		"test:run": "vitest run",
+		"test:run": "vitest run --pool=forks --maxWorkers=1",
 		"test:watch": "vitest watch",
-		"release": "bash scripts/release.sh",
-		"publish": "bash scripts/publish.sh"
+		"test:html": "vitest run tests/html"
 	},
 	"bin": {
 		"sommark": "cli/cli.mjs"
@@ -34,6 +46,8 @@
 		"html",
 		"markdown",
 		"mdx",
+		"xml",
+		"json",
 		"dsl",
 		"mapper",
 		"mapping"
@@ -45,6 +59,12 @@
 	},
 	"homepage": "https://github.com/Adam-Elmi/SomMark#readme",
 	"devDependencies": {
+		"@mdx-js/mdx": "^3.1.1",
+		"fast-xml-parser": "^5.5.11",
+		"jsdom": "^29.0.2",
+		"remark": "^15.0.1",
+		"remark-gfm": "^4.0.1",
+		"remark-parse": "^11.0.0",
 		"vitest": "^4.0.16"
 	}
-}
+}

package/SOMMARK-SPEC.md

@@ -1,481 +0,0 @@
-# SomMark Specification
-
-**SomMark** is a lightweight structured markup language designed to support hierarchical content, inline transformations, and raw text embedding.
-
-SomMark provides three primary constructs:
-
-1. **Blocks** – hierarchical containers that support nesting
-2. **Inline Statements** – inline value transformations
-3. **AtBlocks** – raw text containers where parsing is disabled
-
-Additionally, SomMark supports **comments** and **escape sequences**.
-
----
-
-# 1. Identifiers
-
-Identifiers are used to name **Blocks**, **Inline Statements**, and **AtBlocks**.
-
-## Allowed Characters
-
-Identifiers may contain:
-
-* Letters (`a-z`, `A-Z`)
-* Numbers (`0-9`)
-* Dollar sign (`$`)
-* Underscore (`_`)
-* Hyphen (`-`)
-
-Example valid identifiers:
-
-```
-Block
-section-1
-user_profile
-$template
-note-2
-```
-
-Example invalid identifiers:
-
-```
-my block
-test@
-hello!
-```
-
-Identifiers **must not contain spaces**.
-
----
-
-# 2. Blocks
-
-
-Blocks are hierarchical containers that can contain other blocks, inline statements, or plain text.
-
-Blocks are the primary structural element of SomMark.
-
-## Block Syntax
-
-### Block with Arguments
-
-```
-[Identifier = arg1, arg2, key:value]
-Block body content...
-[end]
-```
-
-Example:
-
-```
-[Note = important, level:2]
-This is a note block.
-[end]
-```
-
----
-
-### Block without Arguments
-
-```
-[Identifier]
-Block body content...
-[end]
-```
-
-Example:
-
-```
-[Section]
-This is a section.
-[end]
-```
-
----
-
-## Block Behavior
-
-* Blocks **support nesting**.
-* Blocks can contain:
-
-  * plain text
-  * inline statements
-  * other blocks
-* Arguments are optional.
-* Arguments may be:
-
-  * **positional values**
-  * **key-value pairs**
-
-Example:
-
-```
-[Article = author:Adam]
-
-Welcome to the article.
-
-[Section = title:Intro]
-This is the introduction.
-[end]
-
-[end]
-```
-
----
-
-# 3. Inline Statements
-
-Inline statements transform or process a **value** within text.
-
-Inline statements **do not allow nested SomMark syntax**.
-
----
-
-## Inline Syntax
-
-### Inline with Arguments
-
-```
-(Value)->(Identifier: arg1, arg2, arg3)
-```
-
-Example:
-
-```
-(hello world)->(uppercase)
-```
-
----
-
-### Inline without Arguments
-
-```
-(Value)->(Identifier)
-```
-
-Example:
-
-```
-(hello)->(bold)
-```
-
----
-
-## Inline Behavior
-
-* `(Value)` is the **input value**.
-* `(Identifier)` specifies the operation.
-* Inline arguments **cannot use key:value syntax**.
-* Inline statements **cannot contain nested syntax**.
-
-Example:
-
-```
-(This text)->(highlight: yellow)
-```
-
----
-
-# 4. AtBlocks (Raw Text Blocks)
-
-AtBlocks are used when content must be treated as **plain text**.
-
-No SomMark syntax inside an AtBlock is parsed.
-
----
-
-## AtBlock Syntax
-
-### AtBlock with Arguments
-
-```
-@_Identifier_@: arg1, arg2, key:value;
-Raw content here.
-Everything is treated as plain text.
-@_end_@
-```
-
-Example:
-
-```
-@_Code_@: lang:js;
-
-function hello(){
-    console.log("hello");
-}
-
-@_end_@
-```
-
----
-
-### AtBlock without Arguments
-
-```
-@_Identifier_@;
-content...
-@_end_@
-```
-
-Example:
-
-```
-@_Raw_@;
-[This will not be parsed]
-(Value)->(test)
-@_end_@
-```
-
----
-
-## AtBlock Behavior
-
-* Content inside AtBlocks is **not parsed**.
-* All characters inside are treated as **plain text**.
-* Nested SomMark syntax is ignored.
-* The AtBlock header **MUST end with a semicolon (`;`)**, even if no arguments are provided.
-
-Example:
-
-```
-@_Template_@: engine:handlebars;
-
-{{ user.name }}
-
-@_end_@
-```
-
----
-
-# 5. Arguments
-
-Arguments are used in **Blocks** and **AtBlocks**.
-
-## Argument Types
-
-### Positional Arguments
-
-```
-arg1, arg2, arg3
-```
-
-Example:
-
-```
-[Block = first, second]
-```
-
----
-
-### Key-Value Arguments
-
-```
-key:value
-```
-
-Example:
-
-```
-[Block = title:Intro, level:2]
-```
-
----
-
-## Argument Restrictions
-
-Arguments may contain most characters including:
-
-```
-[
-]
-(
-)
-```
-
-However the following characters are restricted:
-
-### Colon (`:`)
-
-Colon is used to separate **key-value pairs**.
-
-Example:
-
-```
-key:value
-```
-
-If a colon must appear in a value, it must be escaped.
-
-Example:
-
-```
-x\:y
-```
-
-Example block:
-
-```
-[Block = path:x\:y]
-content
-[end]
-```
-
----
-
-### Semicolon (`;`)
-
-Semicolon is used **only in AtBlock arguments**.
-
-It indicates the **end of the argument list**.
-
-Example:
-
-```
-@_Code_@: lang:js, theme:dark;
-```
-
-Semicolons **have no special meaning** in Blocks or Inline Statements.
-
----
-
-# 6. Escape Character
-
-SomMark uses the **backslash (`\`)** as the escape character.
-
-Escaping works similarly to JavaScript string escaping.
-
-Example:
-
-```
-\[
-```
-
-This prevents a block from being parsed.
-
-Example:
-
-```
-\[Not a block\]
-```
-
-Escaping can also be used inside arguments.
-
-Example:
-
-```
-[Block = x\:y]
-```
-
----
-
-# 7. Comments
-
-SomMark supports **single-line comments**.
-
-## Syntax
-
-```
-# this is a comment
-```
-
-Everything following `#` until the end of the line is ignored by the parser.
-
----
-
-## Comment Rules
-
-Comments may appear:
-
-* on their own line
-* between blocks
-* after statements
-
-Example:
-
-```
-# Article metadata
-
-[Article = author:Adam]
-
-# introduction
-[Section = title:Intro]
-Welcome to SomMark.
-[end]
-
-[end]
-```
-
----
-
-## Comments Inside AtBlocks
-
-Inside AtBlocks, comments are treated as **plain text**.
-
-Example:
-
-```
-@_Code_@: lang:js;
-
-# This line is not treated as a comment
-console.log("Hello")
-
-@_end_@
-```
-
----
-
-# 8. Non-Empty Content Rules
-
-The following elements **must not be empty**:
-
-* Block body
-* AtBlock body
-* Inline value
-
-Invalid examples:
-
-```
-()->(Identifier)
-```
-
----
-
-# 9. Flexible Formatting
-
-SomMark allows flexible formatting and whitespace.
-
-The following are equivalent.
-
-## Compact Format
-
-```
-[Block]Hello World[end]
-```
-
-## Expanded Format
-
-```
-[
-Block
-]
-
-Hello World
-
-[
-end
-]
-```
-
-Inline and AtBlocks follow similar whitespace flexibility.
-
----
-
-# 10. Construct Summary
-
-| Construct        | Nesting | Arguments | Key-Value Args | Parsing    |
-| ---------------- | ------- | --------- | -------------- | ---------- |
-| Block            | Yes     | Optional  | Yes            | Parsed     |
-| Inline Statement | No      | Optional  | No             | Parsed     |
-| AtBlock          | No      | Optional  | Yes            | Not parsed (Header ends with `;`) |
-| Comment          | No      | No        | No             | Parsed but ignored by built-in "comment-remover" plugin during AST |
-

package/cli/commands/list.js

@@ -1,124 +0,0 @@
-import SomMark, { BUILT_IN_PLUGINS } from "../../index.js";
-import { loadConfig } from "../helpers/config.js";
-import { formatMessage } from "../../core/errors.js";
-
-/**
- * List Plugins Command
- * smark list plugins
- * smark list --internal plugins
- * smark list --external plugins
- */
-export async function runListPlugins(args) {
-    const config = await loadConfig();
-
-    const sm = new SomMark({
-        src: "",
-        format: "html",
-        plugins: config.plugins,
-        excludePlugins: config.excludePlugins,
-        priority: config.priority
-    });
-
-    const enabledPlugins = sm.plugins;
-
-    // Filter flags
-    const showInternal = args.includes("--internal") || args.includes("-i");
-    const showExternal = args.includes("--external") || args.includes("-e");
-    const showAll = (!showInternal && !showExternal) || (args.length === 1 && args[0] === "plugins");
-
-    console.log(formatMessage(`{N}<$yellow:SomMark Enabled Plugins:$>{N}`));
-
-    let found = false;
-
-    // 1. Internal Plugins
-    if (showInternal || showAll) {
-        const internal = enabledPlugins.filter(p => {
-            return BUILT_IN_PLUGINS.some(bp => bp.name === p.name);
-        });
-
-        if (internal.length > 0) {
-            console.log(formatMessage(`  <$magenta:Internal Plugins (Built-in):$>{N}`));
-            internal.forEach(p => {
-                const pluginObj = BUILT_IN_PLUGINS.find(bp => bp.name === p.name);
-                printPluginInfo(p.name, pluginObj);
-            });
-            found = true;
-        }
-    }
-
-    // 2. External Plugins
-    if (showExternal || showAll) {
-        const external = enabledPlugins.filter(p => {
-            return !BUILT_IN_PLUGINS.some(bp => bp.name === p.name);
-        });
-
-        if (external.length > 0) {
-            console.log(formatMessage(`${found ? "{N}" : ""}  <$magenta:External Plugins (User-defined):$>{N}`));
-            external.forEach(p => {
-                printPluginInfo(p.name || "Unknown", p);
-            });
-            found = true;
-        }
-    }
-
-    if (!found) {
-        console.log(formatMessage(`  <$red:No plugins enabled or matching the filter.$>{N}`));
-    } else {
-        console.log("");
-    }
-}
-
-/**
- * List Pipeline Command
- * smark list pipeline
- */
-export async function runListPipeline() {
-    const config = await loadConfig();
-    const sm = new SomMark({
-        src: "",
-        format: "html", // Default format
-        plugins: config.plugins,
-        priority: config.priority
-    });
-
-    const pipeline = sm.pluginManager.plugins;
-
-    console.log(formatMessage(`{N}<$yellow:SomMark Execution Pipeline:$>{N}`));
-
-    const phases = [
-        { name: "1. Preprocessors (Global)", type: "preprocessor", scope: "top-level" },
-        { name: "2. Preprocessors (Scoped)", type: "preprocessor", scope: "arguments" },
-        { name: "3. After Lexer (Tokens)", type: ["lexer", "after-lexer"] },
-        { name: "4. AST Handlers (Parser Hooks)", type: ["parser", "on-ast"] },
-        { name: "5. Mapper Extensions (Rules)", type: "mapper" },
-        { name: "6. Output Transformers (Final)", type: ["transform", "postprocessor"] }
-    ];
-
-    phases.forEach((phase, index) => {
-        const types = Array.isArray(phase.type) ? phase.type : [phase.type];
-        const matched = pipeline.filter(p => {
-            const pTypes = Array.isArray(p.type) ? p.type : [p.type];
-            const typeMatch = pTypes.some(t => types.includes(t));
-            const scopeMatch = !phase.scope || p.scope === phase.scope;
-            return typeMatch && scopeMatch;
-        });
-
-        console.log(formatMessage(`  <$magenta:${phase.name}$>`));
-        if (matched.length > 0) {
-            matched.forEach(p => {
-                console.log(formatMessage(`    <$green:└── ${p.name}$> <$cyan:[${Array.isArray(p.type) ? p.type.join(", ") : p.type}]$>`));
-            });
-        } else {
-            console.log(formatMessage(`    <$yellow: (None registered)$>`));
-        }
-        if (index < phases.length - 1) console.log("");
-    });
-    console.log("");
-}
-
-function printPluginInfo(name, pluginObj) {
-    const author = pluginObj?.author || "Unknown";
-    const desc = pluginObj?.description || "No description provided.";
-    console.log(formatMessage(`    <$green:└── ${name}$> - <$cyan:by ${author}$>`));
-    console.log(formatMessage(`      <$yellow:${desc}$>`));
-}