sommark 4.1.0 → 4.3.0

package/helpers/fetch-fs.js

@@ -0,0 +1,37 @@
+export class FetchFS {
+    constructor(baseURL) {
+        this.baseURL = baseURL.endsWith("/") ? baseURL : baseURL + "/";
+        this._cache = new Map();
+    }
+
+    _resolve(p) {
+        if (p.startsWith("http://") || p.startsWith("https://")) return p;
+        return this.baseURL + p.replace(/^\//, "");
+    }
+
+    async readFile(p, encoding) {
+        const url = this._resolve(p);
+        if (this._cache.has(url)) return this._cache.get(url);
+        const res = await fetch(url);
+        if (!res.ok) throw new Error(`File not found: ${p} (${res.status})`);
+        const text = await res.text();
+        this._cache.set(url, text);
+        return text;
+    }
+
+    async exists(p) {
+        try { await this.readFile(p); return true; }
+        catch { return false; }
+    }
+
+    // Sync versions — backed by cache, only valid after readFile has been called for that path
+    existsSync(p) {
+        return this._cache.has(this._resolve(p));
+    }
+
+    readFileSync(p, encoding) {
+        const cached = this._cache.get(this._resolve(p));
+        if (cached !== undefined) return cached;
+        throw new Error(`Not in cache: ${p}. Call readFile first.`);
+    }
+}

package/helpers/spinner.js

@@ -9,7 +9,11 @@ let originalStderrWrite = null;
 let redrawTimeout = null;
 
 export function startSpinner() {
-	if (process.stdout.isTTY && !activeSpinner) {
+	if (typeof process === "undefined" || !process.stdout?.isTTY) {
+		spinnerDepth++;
+		return;
+	}
+	if (!activeSpinner) {
 		// Hide terminal cursor for a clean premium visual feel
 		process.stdout.write("\x1b[?25l");
 
@@ -84,8 +88,10 @@ export function stopSpinner() {
 				originalStderrWrite = null;
 			}
 
+		if (typeof process !== "undefined" && process.stdout) {
 			// Clear the spinner line and restore the terminal cursor
 			process.stdout.write("\r\x1b[K\x1b[?25h");
 		}
+		}
 	}
 }

package/helpers/virtual-fs.js

@@ -0,0 +1,29 @@
+import path from "pathe";
+
+/**
+ * Avoids any dependency on Node.js built-in modules (like buffer, path, stream).
+ */
+export class VirtualFS {
+    constructor(files = {}) {
+        this.files = {};
+        for (const [key, value] of Object.entries(files)) {
+            this.files[path.normalize(key)] = value;
+        }
+    }
+
+    existsSync(p) {
+        const normalized = path.normalize(p);
+        return normalized in this.files;
+    }
+
+    readFileSync(p, encoding) {
+        const normalized = path.normalize(p);
+        if (normalized in this.files) {
+            return this.files[normalized];
+        }
+        throw new Error(`File not found: ${p}`);
+    }
+
+    async exists(p) { return this.existsSync(p); }
+    async readFile(p, encoding) { return this.readFileSync(p, encoding); }
+}

package/index.browser.js

@@ -0,0 +1,87 @@
+import SomMark, { setDefaultFs, setDefaultCwd } from "./index.shared.js";
+export * from "./index.shared.js";
+
+setDefaultFs(null);
+setDefaultCwd("/");
+
+/**
+ * Resolves a relative path into a full URL using the current document location.
+ * Use this to set `baseDir` when loading .smark modules via fetch in the browser.
+ *
+ * @param {string} relativePath - Path relative to the HTML document (e.g. "./templates/").
+ * @returns {string} Absolute URL string suitable for use as `baseDir`.
+ *
+ * @example
+ * import SomMark, { resolveBaseDir } from "sommark/browser";
+ * const engine = new SomMark({ src, format: "html", baseDir: resolveBaseDir("./templates/") });
+ */
+export function resolveBaseDir(relativePath = "./") {
+    if (typeof document === "undefined") {
+        throw new Error(
+            "[SomMark] resolveBaseDir() can only be called in a browser environment.\n" +
+            "In Node.js, pass a file path directly as 'baseDir' instead."
+        );
+    }
+
+    if (typeof relativePath !== "string" || relativePath.trim() === "") {
+        throw new Error(
+            "[SomMark] resolveBaseDir() expects a non-empty string path, " +
+            `but received: ${JSON.stringify(relativePath)}`
+        );
+    }
+
+    try {
+        return new URL(relativePath, document.baseURI).href;
+    } catch (err) {
+        throw new Error(
+            `[SomMark] resolveBaseDir() could not resolve path '${relativePath}' ` +
+            `against document URL '${document.baseURI}'.\n${err.message}`
+        );
+    }
+}
+
+/**
+ * Injects compiled HTML into a container and activates any <script> tags inside it.
+ * Browsers intentionally skip scripts inserted via innerHTML — this re-creates each
+ * one as a live DOM element so they execute normally.
+ *
+ * @param {HTMLElement} container - The element to render into.
+ * @param {string} html - The compiled HTML string.
+ *
+ * @example
+ * import SomMark, { renderCompiledHTML } from "sommark/browser";
+ * const html = await new SomMark({ src, format: "html" }).transpile();
+ * renderCompiledHTML(document.getElementById("output"), html);
+ */
+export function renderCompiledHTML(container, html) {
+    if (typeof document === "undefined") {
+        throw new Error(
+            "[SomMark] renderCompiledHTML() can only be called in a browser environment."
+        );
+    }
+    if (!(container instanceof HTMLElement)) {
+        throw new TypeError(
+            "[SomMark] renderCompiledHTML() expects an HTMLElement as the first argument, " +
+            `but received: ${Object.prototype.toString.call(container)}`
+        );
+    }
+    if (typeof html !== "string") {
+        throw new TypeError(
+            "[SomMark] renderCompiledHTML() expects a string as the second argument, " +
+            `but received: ${Object.prototype.toString.call(html)}`
+        );
+    }
+
+    container.innerHTML = html;
+
+    for (const inertScript of container.querySelectorAll("script")) {
+        const liveScript = document.createElement("script");
+        for (const { name, value } of inertScript.attributes) {
+            liveScript.setAttribute(name, value);
+        }
+        liveScript.textContent = inertScript.textContent;
+        inertScript.replaceWith(liveScript);
+    }
+}
+
+export default SomMark;

package/index.js

@@ -1,423 +1,27 @@
-import lexer from "./core/lexer.js";
-import parser from "./core/parser.js";
-import transpiler from "./core/transpiler.js";
-import Mapper from "./mappers/mapper.js";
-import { registerSharedOutputs } from "./mappers/shared/index.js";
-import HTML from "./mappers/languages/html.js";
-import MARKDOWN from "./mappers/languages/markdown.js";
-import MDX from "./mappers/languages/mdx.js";
-import Json from "./mappers/languages/json.js";
-import Jsonc from "./mappers/languages/jsonc.js";
-import XML from "./mappers/languages/xml.js";
-import TEXT from "./mappers/languages/text.js";
-import { runtimeError } from "./core/errors.js";
-import FORMATS, { textFormat, htmlFormat, markdownFormat, mdxFormat, jsonFormat, jsoncFormat, xmlFormat } from "./core/formats.js";
-import TOKEN_TYPES from "./core/tokenTypes.js";
-import * as labels from "./core/labels.js";
-import { resolveModules } from "./core/modules.js";
-import { validateAST } from "./core/validator.js";
-import { enableColor } from "./helpers/colorize.js";
-import { safeArg } from "./helpers/utils.js";
-import { startSpinner, stopSpinner } from "./helpers/spinner.js";
-import { preprocessRuntimeLogic } from "./core/helpers/preprocessor.js";
-
-/**
- * The SomMark Core Engine.
- * Processes SomMark code and turns it into different formats.
- */
-class SomMark {
-	static Mapper = Mapper;
-	/**
-	 * Creates a new SomMark engine.
-	 * 
-	 * @param {Object} options - Settings for the engine.
-	 * @param {string} options.src - The SomMark code to process.
-	 * @param {string} options.format - The final format you want (like 'html' or 'markdown').
-	 * @param {Mapper|null} [options.mapperFile=null] - Custom rules for formatting.
-	 * @param {string} [options.filename="anonymous"] - The name of the file, used for errors and settings.
-	 * @param {boolean} [options.removeComments=true] - If true, comments will be removed from the final code.
-	 * @param {Object} [options.placeholders={}] - Values to use for p{placeholders}.
-	 * @param {Array<string>} [options.customProps=[]] - Allowed custom HTML attributes.
-	 * @param {Object} [options.importAliases={}] - Custom path aliases for modules.
-	 * @param {Array<string>} [options.importStack=[]] - Tracking for circular dependencies.
-	 * @param {string} [options.baseDir=null] - The base directory for resolving relative paths.
-	 */
-	constructor(options = {}) {
-		const { src, ast = null, format, mapperFile = null, filename = "anonymous", removeComments = true, placeholders = {}, customProps = [], fallbackTarget = "style", outputValidator = null, importAliases = {}, importStack = [], baseDir = null, moduleCache = null, showSpinner = true, security = {}, generateRuntimeOutput = false, hideRuntimeOutput = false, moduleIdentityToken = null } = options;
-		this.rawSettings = options;
-		this.src = src;
-		this.ast = ast;
-		this.targetFormat = format;
-		this.mapperFile = mapperFile;
-		this.filename = filename;
-		this.removeComments = removeComments;
-		this.placeholders = placeholders;
-		this.customProps = customProps;
-		this.generateRuntimeOutput = generateRuntimeOutput;
-		this.hideRuntimeOutput = hideRuntimeOutput;
-
-		// Validate fallbackTarget
-		const VALID_FALLBACK_TARGETS = new Set(["style", "class", false]);
-		if (!VALID_FALLBACK_TARGETS.has(fallbackTarget)) {
-			runtimeError([
-				`{line}<$red:Invalid fallbackTarget$>: <$green:'${fallbackTarget}'$> <$yellow:is not a valid value.$>`,
-				`{N}<$yellow:Use$> <$green:'style'$><$yellow:,$> <$green:'class'$><$yellow:, or$> <$green:false$><$yellow:.$>{line}`
-			]);
-		}
-		this.fallbackTarget = fallbackTarget;
-		this.outputValidator = outputValidator;
-		this.importAliases = importAliases;
-		this.importStack = importStack;
-		this.baseDir = baseDir;
-		this.moduleCache = moduleCache || new Map();
-		this.showSpinner = showSpinner;
-		this.security = {
-			allowRaw: security?.allowRaw !== false,
-			maxDepth: security?.maxDepth ?? 5,
-			timeout: security?.timeout ?? 5000,
-			sanitize: typeof security?.sanitize === "function" ? security.sanitize : null,
-			allowFetch: security?.allowFetch !== false,
-			allowHttp: security?.allowHttp === true,
-			allowedOrigins: Array.isArray(security?.allowedOrigins) ? security.allowedOrigins.map(o => o.toLowerCase()) : null,
-			allowedExtensions: Array.isArray(security?.allowedExtensions) ? security.allowedExtensions.map(e => e.toLowerCase()) : null
-		};
-		this.warnings = [];
-		this._prepared = false;
-
-		// Create a random token to safely wrap data
-		this.moduleIdentityToken = moduleIdentityToken || `$_SM_MOD_${Math.random().toString(36).slice(2, 7)}_$`;
-
-		this.Mapper = Mapper;
-
-		const mapperFiles = { [htmlFormat]: HTML, [markdownFormat]: MARKDOWN, [mdxFormat]: MDX, [jsonFormat]: Json, [jsoncFormat]: Jsonc, [xmlFormat]: XML, [textFormat]: TEXT };
-
-		if (!this.mapperFile && this.targetFormat) {
-			const DefaultMapper = mapperFiles[this.targetFormat];
-			if (DefaultMapper) {
-				this.mapperFile = DefaultMapper.clone();
-			}
-		} else if (this.mapperFile) {
-			this.mapperFile = this.mapperFile.clone();
-		}
-
-		if (this.mapperFile) {
-			this.mapperFile.options.removeComments = this.removeComments;
-			this.mapperFile.options.moduleIdentityToken = this.moduleIdentityToken;
-			this.mapperFile.options.filename = this.filename;
-
-			this.mapperFile.options.usePrivateAttributes = this.usePrivateAttributes;
-			this.mapperFile.options.fallbackTarget = this.fallbackTarget;
-
-			// Initialize custom props whitelist
-			if (this.customProps && this.customProps.length > 0) {
-				const props = Array.isArray(this.customProps) ? this.customProps : [this.customProps];
-				props.forEach(prop => this.mapperFile.customProps.add(prop));
-			}
-		}
-
-		this._initializeMappers();
-	}
-
-
-	/**
-	 * Adds a new rule or changes an existing one.
-	 * 
-	 * @param {string} id - The name of the tag.
-	 * @param {Function} render - The function that formats the tag.
-	 * @param {Object} [options] - Extra settings for the tag.
-	 */
-	register = (id, render, options) => {
-		this.mapperFile.register(id, render, options);
-	};
-
-	/**
-	 * Copies rules from other mappers.
-	 * 
-	 * @param {...Mapper} mappers - The mappers to copy from.
-	 */
-	inherit = (...mappers) => {
-		this.mapperFile.inherit(...mappers);
-	};
-
-	/**
-	 * Gets a rule by its name.
-	 * 
-	 * @param {string} id - The tag name.
-	 * @returns {Object|null}
-	 */
-	get = id => {
-		return this.mapperFile.get(id);
-	};
-
-	removeOutput = id => {
-		this.mapperFile.removeOutput(id);
-	};
-
-	clear = () => {
-		this.mapperFile.clear();
-	};
-
-	_initializeMappers() {
-		if (!this.targetFormat) {
-			runtimeError(["{line}<$red:Undefined Format$>: <$yellow:Format argument is not defined.$>{line}"]);
-		}
-
-		if (!this.mapperFile && this.targetFormat) {
-			runtimeError([`{line}<$red:Unknown Format$>: <$yellow:Mapper for format '${this.targetFormat}' not found.$>{line}`]);
-		}
-	}
-
-	reportWarning(message) {
-		this.warnings.push(message);
-	}
-
-
-	_ensurePrepared() {
-		if (this._prepared) return;
-
-		// Final check
-		if (!this.mapperFile) {
-			runtimeError([
-				`{line}<$red:Unknown Format$>: <$yellow:No mapper found for format:$> <$green:'${this.targetFormat}'$>`,
-				`{N}<$yellow:Make sure you have registered format mapper correctly.$>{line}`
-			]);
-		}
-
-		this._prepared = true;
-	}
-
-	/**
-	 * Breaks the code into small pieces called tokens.
-	 * 
-	 * @param {string} [src=this.src] - The code to break apart.
-	 * @returns {Promise<Array<Object>>} - The list of tokens.
-	 */
-	async lex(src = this.src) {
-		this._ensurePrepared();
-		if (src !== this.src) this.src = src;
-		let tokens = lexer(this.src, this.filename);
-		return tokens;
-	}
-
-	lexSync(src = this.src) {
-		this._ensurePrepared();
-		if (src !== this.src) this.src = src;
-		let tokens = lexer(this.src, this.filename);
-		return tokens;
-	}
-
-	/**
-	 * Organizes the code into a tree structure.
-	 * Also handles modules and checks for errors.
-	 * 
-	 * @param {string} [src=this.src] - Optional source override.
-	 * @returns {Promise<Array<Object>>} - The final code tree.
-	 */
-	async parse(src = this.src) {
-		const tokens = await this.lex(src);
-		let ast = parser(tokens, this.filename, this.placeholders, {});
-
-		ast = await resolveModules(ast, {
-			mapperFile: this.mapperFile,
-			filename: this.filename,
-			format: this.targetFormat,
-			instance: this,
-			importStack: this.importStack
-		});
-
-		if (this.mapperFile) {
-			validateAST(ast, this.mapperFile, this);
-		}
-
-		return ast;
-	}
-
-	parseSync(src = this.src) {
-		this._ensurePrepared();
-		if (src !== this.src) this.src = src;
-		const tokens = lexer(this.src, this.filename);
-		let ast = parser(tokens, this.filename, this.placeholders, {});
-
-		if (this.mapperFile) {
-			validateAST(ast, this.mapperFile, this);
-		}
-
-		return ast;
-	}
-
-	/**
-	 * Turns the SomMark code into the final format.
-	 * 
-	 * @param {string} [src=this.src] - Optional source override.
-	 * @returns {Promise<string>} - The finished code.
-	 */
-	async transpile(src = this.src) {
-		if (src !== this.src) this.src = src;
-		this._ensurePrepared();
-
-		if (this.showSpinner) startSpinner();
-		try {
-			const ast = this.ast || await this.parse(src);
-			let result = await transpiler({
-				ast,
-				format: this.targetFormat,
-				mapperFile: this.mapperFile,
-				security: this.security,
-				settings: this.rawSettings,
-				generateRuntimeOutput: this.generateRuntimeOutput,
-				hideRuntimeOutput: this.hideRuntimeOutput
-			});
-
-			if (this.outputValidator && typeof this.outputValidator === "function") {
-				await this.outputValidator(result);
-			}
-
-			return result;
-		} finally {
-			if (this.showSpinner) stopSpinner();
-		}
-	}
-
-
+import SomMark, { setDefaultFs, setDefaultCwd, setDefaultFindAndLoadConfig } from "./index.shared.js";
+export * from "./index.shared.js";
+
+// Node-specific filesystem import
+let nodeFs = null;
+if (typeof process !== "undefined" && process.versions?.node) {
+	try {
+		nodeFs = await import("node:fs").then(m => m.default || m);
+		// Add async interface so modules.js can use await fs.exists / await fs.readFile
+		nodeFs.exists = (p) => nodeFs.promises.access(p).then(() => true).catch(() => false);
+		nodeFs.readFile = (p, enc) => nodeFs.promises.readFile(p, enc);
+	} catch (e) {}
 }
-
-/**
- * A quick way to break code into tokens.
- * Uses HTML settings by default.
- * 
- * @param {string} src - The raw SomMark source.
- * @param {string} [filename="anonymous"] - Filename for error context.
- * @returns {Promise<Array<Object>>} - The list of tokens.
- */
-const lex = async (src, filename = "anonymous") => {
-	if (src === undefined || src === null) {
-		runtimeError([`{line}<$red:Missing Source:$> <$yellow:The 'src' argument is required for tokenization.$>{line}`]);
-	}
-	if (typeof src !== "string") {
-		runtimeError([`{line}<$red:Invalid Source Type:$> <$yellow:The 'src' argument must be a string, received ${typeof src}.$>{line}`]);
-	}
-	return lexer(src, filename);
-};
-
-/**
- * A quick way to organize code into a tree.
- * Uses HTML settings by default.
- * 
- * @param {string} src - The raw SomMark source.
- * @param {string} [filename="anonymous"] - Filename for error context.
- * @returns {Promise<Array<Object>>} - The final code tree.
- */
-async function parse(src, filename = "anonymous") {
-	if (src === undefined || src === null) {
-		runtimeError([`{line}<$red:Missing Source:$> <$yellow:The 'src' argument is required for parsing.$>{line}`]);
-	}
-	if (typeof src !== "string") {
-		runtimeError([`{line}<$red:Invalid Source Type:$> <$yellow:The 'src' argument must be a string, received ${typeof src}.$>{line}`]);
-	}
-	return await new SomMark({ src, filename, format: textFormat }).parse();
-}
-
-/**
- * Transpiles SomMark code to a target format.
- * 
- * @param {Object} options - Transpilation options.
- * @param {string} options.src - Raw source code.
- * @param {string} [options.format="html"] - Target format.
- * @param {string} [options.filename="anonymous"] - Filename for context.
- * @param {Mapper|null} [options.mapperFile=null] - Custom rules for formatting.
- * @param {boolean} [options.removeComments=true] - Strip comments.
- * @param {Object} [options.placeholders={}] - Global placeholders.
- * @param {Array<string>} [options.customProps=[]] - Custom attribute whitelist.
- * @param {Object} [options.importAliases={}] - Custom path aliases for modules.
- * @returns {Promise<string>} - Transpiled output.
- */
-async function transpile(options = {}) {
-	if (typeof options !== "object" || options === null) {
-		runtimeError([`{line}<$red:Invalid Options:$> <$yellow:The options argument must be a non-null object.$>{line}`]);
-	}
-	const { src, ast, format } = options;
-
-	const knownProps = ["src", "ast", "format", "filename", "mapperFile", "removeComments", "placeholders", "customProps", "importAliases", "fallbackTarget", "usePrivateAttributes", "outputValidator", "showSpinner", "security"];
-	Object.keys(options).forEach(key => {
-		if (!knownProps.includes(key)) {
-			runtimeError([
-				`{line}<$red:Unknown Property:$> <$yellow:The property $> <$green:'${key}'$> <$yellow:is not recognized.$>{line}`
-			]);
-		}
-	});
-
-	if (format === undefined || format === null) {
-		runtimeError([`{line}<$red:Missing Target Format:$> <$yellow:The 'format' parameter is required for transpilation (e.g. 'html', 'markdown', 'xml', 'mdx', 'json', etc.).$>{line}`]);
-	}
-
-	if ((src === undefined || src === null) && (ast === undefined || ast === null)) {
-		runtimeError([`{line}<$red:Missing Input:$> <$yellow:Either 'src' or 'ast' must be provided for transpilation.$>{line}`]);
-	}
-
-	const sm = new SomMark(options);
-	return await sm.transpile();
+setDefaultFs(nodeFs);
+if (typeof process !== "undefined" && process.cwd) setDefaultCwd(process.cwd());
+
+// Node-specific config-loader import
+let findAndLoadConfigFn = async () => ({});
+if (typeof process !== "undefined" && process.versions?.node) {
+	try {
+		const loader = await import("./core/helpers/config-loader.js");
+		findAndLoadConfigFn = loader.findAndLoadConfig;
+	} catch (e) {}
 }
+setDefaultFindAndLoadConfig(findAndLoadConfigFn);
 
-/**
- * A quick, synchronous way to get tokens.
- * 
- * @param {string} src - Raw source code.
- * @param {string} [filename="anonymous"] - Filename for error context.
- * @returns {Array<Object>} - The list of tokens.
- */
-const lexSync = (src, filename = "anonymous") => {
-	if (src === undefined || src === null) {
-		runtimeError([`{line}<$red:Missing Source:$> <$yellow:The 'src' argument is required for tokenization.$>{line}`]);
-	}
-	if (typeof src !== "string") {
-		runtimeError([`{line}<$red:Invalid Source Type:$> <$yellow:The 'src' argument must be a string, received ${typeof src}.$>{line}`]);
-	}
-	return lexer(src, filename);
-};
-
-/**
- * A quick, synchronous way to get the code tree.
- * 
- * @param {string} src - Raw source code.
- * @param {Object} [options={}] - Parsing options.
- * @returns {Array<Object>} - The code tree.
- */
-const parseSync = (src, filename = "anonymous") => {
-	if (src === undefined || src === null) {
-		runtimeError([`{line}<$red:Missing Source:$> <$yellow:The 'src' argument is required for parsing.$>{line}`]);
-	}
-	if (typeof src !== "string") {
-		runtimeError([`{line}<$red:Invalid Source Type:$> <$yellow:The 'src' argument must be a string, received ${typeof src}.$>{line}`]);
-	}
-	const tokens = lexer(src, filename);
-	return parser(tokens, filename);
-};
-
-import { findAndLoadConfig } from "./core/helpers/config-loader.js";
-
-import Evaluator from "./core/evaluator.js";
-
-export {
-	registerSharedOutputs,
-	HTML,
-	MARKDOWN,
-	MDX,
-	Json,
-	Jsonc,
-	XML,
-	Mapper,
-	FORMATS,
-	lex,
-	parse,
-	transpile,
-	lexSync,
-	parseSync,
-	TOKEN_TYPES,
-	labels,
-	enableColor,
-	safeArg,
-	findAndLoadConfig,
-	Evaluator,
-	preprocessRuntimeLogic
-};
 export default SomMark;