sommark 5.0.5 → 5.2.0

package/dist/sommark.parser.js

@@ -1029,6 +1029,7 @@ function makeBlockNode() {
 		structure: "Block",
 		id: "",
 		props: {},
+		directives: {},
 		body: [],
 		depth: 0,
 		range: {
@@ -1514,9 +1515,11 @@ function parseBlock(tokens, i, filename = null, placeholders = {}, variables = {
 			i = valueIndex;
 
 			// Store Argument
-			blockNode.props[String(argIndex++)] = v;
-			if (k) {
-				blockNode.props[k] = v;
+			if (k && k.startsWith("smark-")) {
+				blockNode.directives[k.slice(6)] = v; // strip "smark-" prefix
+			} else {
+				blockNode.props[String(argIndex++)] = v;
+				if (k) blockNode.props[k] = v;
 			}
 			k = "";
 			v = "";

package/esbuild.js

@@ -0,0 +1,64 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { createHash } from "node:crypto";
+
+/**
+ * esbuild plugin for SomMark.
+ *
+ * Handles QuickJS WASM assets that esbuild cannot process automatically.
+ * QuickJS loads its .wasm files via `new URL("*.wasm", import.meta.url)`
+ * inside pre-built package files. esbuild's file loader does not intercept
+ * these patterns, so this plugin rewrites the URLs and copies the .wasm
+ * files to the output directory.
+ *
+ * @example
+ * // esbuild.config.mjs
+ * import { sommarkEsbuild } from "sommark/esbuild";
+ * await esbuild.build({ plugins: [sommarkEsbuild()] });
+ */
+export function sommarkEsbuild() {
+  const collected = new Map();
+
+  return {
+    name: "sommark",
+    setup(build) {
+      build.onStart(() => collected.clear());
+
+      build.onLoad({ filter: /emscripten-module(\.browser)?\.m?js$/ }, (args) => {
+        const source = readFileSync(args.path, "utf8");
+        const dir = dirname(args.path);
+
+        const pattern = /new URL\(['"]([^'"]+\.wasm)['"]\s*,\s*import\.meta\.url\)/g;
+        let result = source;
+        let match;
+
+        while ((match = pattern.exec(source)) !== null) {
+          const [full, wasmFile] = match;
+          const wasmPath = join(dir, wasmFile);
+          if (!existsSync(wasmPath)) continue;
+
+          let outputName;
+          if (collected.has(wasmPath)) {
+            outputName = collected.get(wasmPath).name;
+          } else {
+            const content = readFileSync(wasmPath);
+            const hash = createHash("sha256").update(content).digest("hex").slice(0, 8);
+            outputName = `emscripten-module-${hash}.wasm`;
+            collected.set(wasmPath, { name: outputName, content });
+          }
+
+          result = result.replace(full, `new URL("./${outputName}", import.meta.url)`);
+        }
+
+        return result !== source ? { contents: result, loader: "js" } : undefined;
+      });
+
+      build.onEnd(({ errors }) => {
+        if (errors.length > 0) return;
+        for (const { name, content } of collected.values()) {
+          writeFileSync(join(build.initialOptions.outdir, name), content);
+        }
+      });
+    },
+  };
+}

package/index.browser.js

@@ -1,8 +1,11 @@
-import SomMark, { setDefaultFs, setDefaultCwd } from "./index.shared.js";
+import SomMark, { setDefaultFs, setDefaultCwd, setDefaultEnv, setDefaultAsyncLocalStorage } from "./index.shared.js";
+import { AsyncLocalStorage } from "./async-hooks.js";
 export * from "./index.shared.js";
 
 setDefaultFs(null);
 setDefaultCwd("/");
+setDefaultEnv(null);
+setDefaultAsyncLocalStorage(AsyncLocalStorage);
 
 /**
  * Resolves a relative path into a full URL using the current document location.

package/index.js

@@ -1,6 +1,10 @@
-import SomMark, { setDefaultFs, setDefaultCwd, setDefaultFindAndLoadConfig, setDefaultResolvePath } from "./index.shared.js";
+import SomMark, { setDefaultFs, setDefaultCwd, setDefaultFindAndLoadConfig, setDefaultResolvePath, setDefaultEnv, setDefaultAsyncLocalStorage } from "./index.shared.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { resolve } from "pathe";
 export * from "./index.shared.js";
 
+setDefaultAsyncLocalStorage(AsyncLocalStorage);
+
 // Node-specific filesystem import
 let nodeFs = null;
 if (typeof process !== "undefined" && process.versions?.node) {
@@ -9,6 +13,13 @@ if (typeof process !== "undefined" && process.versions?.node) {
 		// 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);
+		nodeFs.stat = (p) => nodeFs.promises.stat(p);
+		nodeFs.__isNodeFs = true;
+		nodeFs.glob = async (pattern, opts) => {
+			const results = [];
+			for await (const f of nodeFs.promises.glob(pattern, opts)) results.push(f);
+			return results;
+		};
 	} catch (e) {}
 }
 setDefaultFs(nodeFs);
@@ -32,4 +43,94 @@ if (typeof process !== "undefined" && process.versions?.node) {
 }
 setDefaultFindAndLoadConfig(findAndLoadConfigFn);
 
+// Load .env file from cwd and merge with process.env (process.env wins)
+{
+	let mergedEnv = { ...process.env };
+	if (nodeFs) {
+		try {
+			const dotenvPath = nodeFs.promises
+				? await nodeFs.promises.readFile(process.cwd() + "/.env", "utf8")
+				: null;
+			if (dotenvPath) {
+				for (const line of dotenvPath.split("\n")) {
+					const trimmed = line.trim();
+					if (!trimmed || trimmed.startsWith("#")) continue;
+					const eq = trimmed.indexOf("=");
+					if (eq === -1) continue;
+					const key = trimmed.slice(0, eq).trim();
+					let val = trimmed.slice(eq + 1).trim();
+					if ((val.startsWith('"') && val.endsWith('"')) ||
+						(val.startsWith("'") && val.endsWith("'"))) {
+						val = val.slice(1, -1);
+					}
+					if (!(key in mergedEnv)) mergedEnv[key] = val;
+				}
+			}
+		} catch { /* .env file is optional */ }
+	}
+	setDefaultEnv(mergedEnv);
+}
+
+export const fileHandler = {
+    async read(filePath) {
+        if (!nodeFs) {
+            throw new Error(
+                "[SomMark] fileHandler is not available in browser mode.\n" +
+                "File access is a server-side concept."
+            );
+        }
+        const cwd = process.cwd();
+        const abs = resolve(cwd, filePath);
+        if (!abs.startsWith(cwd)) {
+            throw new Error(
+                `[SomMark] fileHandler.read: path traversal outside project root is not allowed.\n` +
+                `Attempted path: ${abs}`
+            );
+        }
+        return nodeFs.readFile(abs, "utf-8");
+    },
+    async exists(filePath) {
+        if (!nodeFs) return false;
+        const cwd = process.cwd();
+        const abs = resolve(cwd, filePath);
+        if (!abs.startsWith(cwd)) return false;
+        return nodeFs.exists(abs);
+    },
+    async glob(pattern) {
+        if (!nodeFs) throw new Error("[SomMark] fileHandler.glob is not available in browser mode.\nFile access is a server-side concept.");
+        if (!nodeFs.glob) throw new Error("[SomMark] fileHandler.glob requires Node.js 22 or later.");
+        const cwd = process.cwd();
+        return nodeFs.glob(pattern, { cwd });
+    },
+    async stat(filePath) {
+        if (!nodeFs) {
+            throw new Error(
+                "[SomMark] fileHandler.stat is not available in browser mode.\n" +
+                "File access is a server-side concept."
+            );
+        }
+        const cwd = process.cwd();
+        const abs = resolve(cwd, filePath);
+        if (!abs.startsWith(cwd)) {
+            throw new Error(
+                `[SomMark] fileHandler.stat: path traversal outside project root is not allowed.\n` +
+                `Attempted path: ${abs}`
+            );
+        }
+        try {
+            const s = await nodeFs.stat(abs);
+            return {
+                size: s.size,
+                mtime: s.mtimeMs,
+                ctime: s.ctimeMs,
+                atime: s.atimeMs,
+                isFile: s.isFile(),
+                isDirectory: s.isDirectory(),
+            };
+        } catch {
+            return null;
+        }
+    },
+};
+
 export default SomMark;

package/index.shared.js

@@ -42,6 +42,14 @@ export function setDefaultFs(fs) {
 	Evaluator.setDefaultFs(fs);
 }
 
+export function setDefaultEnv(env) {
+	Evaluator.setDefaultEnv(env);
+}
+
+export function setDefaultAsyncLocalStorage(cls) {
+	Evaluator.setDefaultAsyncLocalStorage(cls);
+}
+
 export function setDefaultResolvePath(fn) {
 	defaultResolvePath = fn;
 }
@@ -74,7 +82,7 @@ class SomMark {
 	 * @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 = true, outputValidator = null, importAliases = {}, importStack = [], baseDir = null, moduleCache = null, showSpinner = true, security = {}, dualOutput = false, moduleIdentityToken = null } = options;
+		const { src, ast = null, format, mapperFile = null, filename = "anonymous", removeComments = true, placeholders = {}, customProps = [], fallbackTarget = true, outputValidator = null, importAliases = {}, importStack = [], baseDir = null, moduleCache = null, showSpinner = true, security = {}, dualOutput = false, webOutputs = false, moduleIdentityToken = null } = options;
 		this.rawSettings = options;
 		this.src = src;
 		this.ast = ast;
@@ -85,6 +93,7 @@ class SomMark {
 		this.placeholders = placeholders;
 		this.customProps = customProps;
 		this.dualOutput = dualOutput;
+		this.webOutputs = webOutputs;
 		this.cwd = options.baseDir || (options.files ? "/" : defaultCwd);
 		this.fs = options.fs
 			|| (options.files ? new VirtualFS(options.files) : null)
@@ -113,7 +122,8 @@ class SomMark {
 			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
+			allowedExtensions: Array.isArray(security?.allowedExtensions) ? security.allowedExtensions.map(e => e.toLowerCase()) : null,
+			env: Array.isArray(security?.env) ? security.env : []
 		};
 		this.warnings = [];
 		this._prepared = false;
@@ -300,6 +310,7 @@ class SomMark {
 				security: this.security,
 				settings: this.rawSettings,
 				dualOutput: this.dualOutput,
+				webOutputs: this.webOutputs,
 				instance: this
 			});
 

package/mappers/languages/markdown.js

@@ -29,28 +29,18 @@ const MARKDOWN = Mapper.define({
 	},
 
 	/**
-	 * Provides a fallback for unknown tags by using the HTML mapper instead.
-	 */
+	 * Provides a fallback for unknown tags by rendering them as HTML elements.
+	 * Passes child nodes to the transpiler, which handles all node types (such as ForEach).
+	 **/
 	getUnknownTag(node) {
-		const id = node.id.toLowerCase();
-
+		const id = node.id;
 		return {
-			render: async ({ props, ast, isSelfClosing, renderChild }) => {
+			options: { trimAndWrapBlocks: true },
+			render: ({ props, content, isSelfClosing }) => {
 				const element = this.tag(id).smartAttributes(props, this.customProps, this.options);
 				if (isSelfClosing || VOID_ELEMENTS.has(id)) return element.selfClose();
-
-				let rawContent = "";
-				for (const child of (ast.body || [])) {
-					if (child.type === TEXT) rawContent += this.text(child.text);
-					else if (child.type === BLOCK) rawContent += await renderChild(child);
-				}
-				rawContent = rawContent.trim();
-
-				const meaningful = (ast.body || []).filter(c => c.type !== TEXT || c.text.trim());
-				const finalContent = meaningful.length <= 1 ? rawContent : `\n${rawContent}\n`;
-				return element.body(finalContent);
-			},
-			options: { handleAst: true }
+				return element.body(content);
+			}
 		};
 	}
 });
@@ -62,10 +52,14 @@ registerSharedOutputs(MARKDOWN);
 /**
  * Quote - Renders blockquote content or GFM alerts.
  */
-MARKDOWN.register("quote", ({ props, content }) => {
-	const type = safeArg({ props, index: 0, key: "type", fallBack: "" });
-	return md.quote(content, type);
-}, { resolve: true });
+MARKDOWN.register(
+	"quote",
+	({ props, content }) => {
+		const type = safeArg({ props, index: 0, key: "type", fallBack: "" });
+		return md.quote(content, type);
+	},
+	{ resolve: true }
+);
 
 /**
  * Headings - Renders H1-H6 block headings.
@@ -145,12 +139,12 @@ MARKDOWN.register(
 	"link",
 	({ props, content, isSelfClosing }) => {
 		if (isSelfClosing) {
-			const text  = safeArg({ props, index: 0, key: "text",  fallBack: "" });
-			const src   = safeArg({ props, index: 1, key: "src",   fallBack: "" });
+			const text = safeArg({ props, index: 0, key: "text", fallBack: "" });
+			const src = safeArg({ props, index: 1, key: "src", fallBack: "" });
 			const title = safeArg({ props, index: 2, key: "title", fallBack: "" });
 			return md.url("link", text, src, title);
 		}
-		const src   = safeArg({ props, index: 0, key: "src",   fallBack: "" });
+		const src = safeArg({ props, index: 0, key: "src", fallBack: "" });
 		const title = safeArg({ props, index: 1, key: "title", fallBack: "" });
 		return md.url("link", content, src, title);
 	},
@@ -188,10 +182,14 @@ MARKDOWN.register(
  * Escape - Escapes special Markdown characters.
  * Self-closing: [escape = "text" !] or [escape = text: "text" !]
  */
-MARKDOWN.register(["escape", "e"], function ({ props, content, isSelfClosing }) {
-	const text = isSelfClosing ? safeArg({ props, index: 0, key: "text", fallBack: "" }) : content;
-	return this.md.escape(text);
-}, { resolve: true });
+MARKDOWN.register(
+	["escape", "e"],
+	function ({ props, content, isSelfClosing }) {
+		const text = isSelfClosing ? safeArg({ props, index: 0, key: "text", fallBack: "" }) : content;
+		return this.md.escape(text);
+	},
+	{ resolve: true }
+);
 
 const ROW_SEP = "\x1E";
 const CELL_SEP = "\x1F";
@@ -207,12 +205,16 @@ MARKDOWN.register(
 		const headers = [];
 		const rows = [];
 
-		const extractRows = async (sectionNode) => {
+		const extractRows = async sectionNode => {
 			const sectionRows = [];
-			for (const child of (sectionNode.body || [])) {
+			for (const child of sectionNode.body || []) {
 				if (child.type === BLOCK && child.id?.toLowerCase() === "row") {
 					const rendered = await renderChild(child, { inTable: true });
-					const cells = rendered.split(ROW_SEP)[0]?.split(CELL_SEP).filter(c => c !== "") ?? [];
+					const cells =
+						rendered
+							.split(ROW_SEP)[0]
+							?.split(CELL_SEP)
+							.filter(c => c !== "") ?? [];
 					if (cells.length > 0) sectionRows.push(cells);
 				} else if (child.type === FOR_EACH) {
 					const rendered = await renderChild(child, { inTable: true });
@@ -246,25 +248,29 @@ MARKDOWN.register(
  */
 MARKDOWN.register(["header", "body"], ({ content }) => content);
 
-MARKDOWN.register("row", async function ({ ast, renderChild, inTable }) {
-	if (!inTable) {
-		let result = "";
-		for (const child of ast.body) {
-			if (child.type === TEXT) result += this.text(child.text);
-			else if (child.type === BLOCK) result += await renderChild(child);
+MARKDOWN.register(
+	"row",
+	async function ({ ast, renderChild, inTable }) {
+		if (!inTable) {
+			let result = "";
+			for (const child of ast.body) {
+				if (child.type === TEXT) result += this.text(child.text);
+				else if (child.type === BLOCK) result += await renderChild(child);
+			}
+			return result;
 		}
-		return result;
-	}
-	let cells = "";
-	for (const child of ast.body) {
-		if (child.type !== BLOCK) continue;
-		const id = child.id?.toLowerCase();
-		if (id === "cell" || id === "th" || id === "td") {
-			cells += await renderChild(child, { inTable: true });
+		let cells = "";
+		for (const child of ast.body) {
+			if (child.type !== BLOCK) continue;
+			const id = child.id?.toLowerCase();
+			if (id === "cell" || id === "th" || id === "td") {
+				cells += await renderChild(child, { inTable: true });
+			}
 		}
-	}
-	return cells + ROW_SEP;
-}, { handleAst: true });
+		return cells + ROW_SEP;
+	},
+	{ handleAst: true }
+);
 
 MARKDOWN.register(["cell", "th", "td"], ({ content, inTable }) => {
 	return inTable ? content.trim() + CELL_SEP : content;
@@ -274,34 +280,42 @@ MARKDOWN.register(["cell", "th", "td"], ({ content, inTable }) => {
  * Lists - Authoritative Native AST List resolution.
  * Supports Ordered (Number) and Unordered (Dotlex) lists with deep nesting.
  */
-MARKDOWN.register(["list", "List"], async function ({ ast, props, renderChild }) {
-	const indicator = safeArg({ props, index: 0, fallBack: "dot" });
-	const isOrdered = indicator === "number" || indicator === "ol";
-	const marker = isOrdered ? "" : (indicator === "dot" ? "-" : indicator);
-	const items = [];
+MARKDOWN.register(
+	["list", "List"],
+	async function ({ ast, props, renderChild }) {
+		const indicator = safeArg({ props, index: 0, fallBack: "dot" });
+		const isOrdered = indicator === "number" || indicator === "ol";
+		const marker = isOrdered ? "" : indicator === "dot" ? "-" : indicator;
+		const items = [];
 
-	for (const node of ast.body) {
-		if (node.type !== BLOCK) continue;
-		const id = node.id?.toLowerCase();
-		if (id === "item") {
-			items.push((await renderChild(node)).trim());
+		for (const node of ast.body) {
+			if (node.type !== BLOCK) continue;
+			const id = node.id?.toLowerCase();
+			if (id === "item") {
+				items.push((await renderChild(node)).trim());
+			}
 		}
-	}
 
-	return isOrdered ? md.orderedList(items, 0) : md.unorderedList(items, 0, marker);
-}, { handleAst: true, trimAndWrapBlocks: false });
+		return isOrdered ? md.orderedList(items, 0) : md.unorderedList(items, 0, marker);
+	},
+	{ handleAst: true, trimAndWrapBlocks: false }
+);
 
 /**
  * List Helpers - Internal tags for list structural organization.
  */
-MARKDOWN.register(["item", "Item"], async function ({ ast, renderChild }) {
-	let result = "";
-	for (const child of ast.body) {
-		if (child.type === TEXT) result += this.text(child.text);
-		else if (child.type === BLOCK) result += await renderChild(child);
-	}
-	return result.trim();
-}, { handleAst: true, trimAndWrapBlocks: false });
+MARKDOWN.register(
+	["item", "Item"],
+	async function ({ ast, renderChild }) {
+		let result = "";
+		for (const child of ast.body) {
+			if (child.type === TEXT) result += this.text(child.text);
+			else if (child.type === BLOCK) result += await renderChild(child);
+		}
+		return result.trim();
+	},
+	{ handleAst: true, trimAndWrapBlocks: false }
+);
 
 /**
  * Todo - Renders task list items with status markers.
@@ -311,17 +325,21 @@ MARKDOWN.register(["item", "Item"], async function ({ ast, renderChild }) {
  *   [todo = "Add feature", "x" !]                 positional self-closing (task, status)
  *   [todo = "x"]Add feature[end]                  status in prop, task in body
  */
-MARKDOWN.register("todo", ({ props, content, isSelfClosing }) => {
-	let status, task;
+MARKDOWN.register(
+	"todo",
+	({ props, content, isSelfClosing }) => {
+		let status, task;
 
-	if (isSelfClosing) {
-		task   = safeArg({ props, index: 0, key: "task",   fallBack: "" });
-		status = safeArg({ props, index: 1, key: "status", fallBack: "" });
-	} else {
-		status = safeArg({ props, index: 0, fallBack: "" });
-		task   = content;
-	}
+		if (isSelfClosing) {
+			task = safeArg({ props, index: 0, key: "task", fallBack: "" });
+			status = safeArg({ props, index: 1, key: "status", fallBack: "" });
+		} else {
+			status = safeArg({ props, index: 0, fallBack: "" });
+			task = content;
+		}
 
-	return md.todo(status, task);
-}, { trimAndWrapBlocks: false });
+		return md.todo(status, task);
+	},
+	{ trimAndWrapBlocks: false }
+);
 export default MARKDOWN;