sommark 5.0.4 → 5.1.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,9 @@
-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";
 export * from "./index.shared.js";
 
+setDefaultAsyncLocalStorage(AsyncLocalStorage);
+
 // Node-specific filesystem import
 let nodeFs = null;
 if (typeof process !== "undefined" && process.versions?.node) {
@@ -32,4 +35,32 @@ 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 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;
 }
@@ -113,7 +121,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;

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;

package/mappers/languages/xml.js

@@ -4,100 +4,115 @@ import { registerSharedOutputs } from "../shared/index.js";
 /**
  * Renders a standard XML tag based on the provided identifier and arguments.
  * Ensures strict attribute quoting and handles self-closing tags for empty bodies.
- * 
+ *
  * @param {string} id - The XML tag identifier (case-sensitive).
  * @param {Object} props - Key-value pairs to be rendered as XML attributes.
  * @param {string} content - The rendered inner content of the tag.
  * @returns {string} The fully rendered XML tag string.
  */
 const renderXmlTag = function (id, props, content, isSelfClosing) {
-    // XML is case-sensitive, so we use the exact id provided
-    const element = this.tag(id);
+	// XML is case-sensitive, so we use the exact id provided
+	const element = this.tag(id);
 
-    // Filter out positional indices (numeric keys) for XML attributes
-    const namedArgs = {};
-    Object.keys(props).forEach(key => {
-        if (isNaN(parseInt(key))) {
-            namedArgs[key] = props[key];
-        }
-    });
+	// Filter out positional indices (numeric keys) for XML attributes
+	const namedArgs = {};
+	Object.keys(props).forEach(key => {
+		if (isNaN(parseInt(key))) {
+			namedArgs[key] = props[key];
+		}
+	});
 
-    // In XML, attributes must always have values (strict = true)
-    element.attributes(namedArgs, true);
+	// In XML, attributes must always have values (strict = true)
+	element.attributes(namedArgs, true);
 
-    const hasBody = typeof content === "string" && content.trim().length > 0;
+	const hasBody = typeof content === "string" && content.trim().length > 0;
 
-    if (isSelfClosing || !hasBody) {
-        return element.selfClose();
-    }
+	if (isSelfClosing || !hasBody) {
+		return element.selfClose();
+	}
 
-    return element.body(content);
+	return element.body(content);
 };
 
 /**
  * The XML Mapper used for creating XML pages.
  */
 const XML = Mapper.define({
-    /**
-     * Renders a comment in XML format.
-     * @param {string} text - The comment content.
-     * @returns {string}
-     */
-    comment(text) {
-        return `<!-- ${text} -->`;
-    },
+	/**
+	 * Renders a comment in XML format.
+	 * @param {string} text - The comment content.
+	 * @returns {string}
+	 */
+	comment(text) {
+		return `<!-- ${text} -->`;
+	},
 
-    /**
-     * Resolves unknown tags by preserving their original case and applying XML rules.
-     * @param {Object} node - The AST node representing the unknown tag.
-     * @returns {Object} Renderer definition for the tag.
-     */
-    getUnknownTag(node) {
-        const id = node.id;
-        return {
-            render: ({ props, content, isSelfClosing }) => renderXmlTag.call(this, id, props, content, isSelfClosing),
-            options: {}
-        };
-    }
+	/**
+	 * Resolves unknown tags by preserving their original case and applying XML rules.
+	 * @param {Object} node - The AST node representing the unknown tag.
+	 * @returns {Object} Renderer definition for the tag.
+	 */
+	getUnknownTag(node) {
+		const id = node.id;
+		return {
+			render: ({ props, content, isSelfClosing }) => renderXmlTag.call(this, id, props, content, isSelfClosing),
+			options: {}
+		};
+	},
+	options: {
+		trimAndWrapBlocks: true
+	}
 });
 
 /**
  * Registers the XML declaration as a self-closing block.
  * Usage: [xml = version: "1.0", encoding: "UTF-8"]
  */
-XML.register("xml", ({ props }) => {
-    const version = props.version || "1.0";
-    const encoding = props.encoding || "UTF-8";
-    return `<?xml version="${version}" encoding="${encoding}"?>`;
-}, { rules: { is_empty_body: true } });
+XML.register(
+	"xml",
+	({ props }) => {
+		const version = props.version || "1.0";
+		const encoding = props.encoding || "UTF-8";
+		return `<?xml version="${version}" encoding="${encoding}"?>`;
+	},
+	{ rules: { is_empty_body: true } }
+);
 
 /**
  * Registers the DOCTYPE declaration.
  * Usage: [doctype = root: "note", system: "note.dtd"]
  */
-XML.register(["DOCTYPE", "doctype"], ({ props }) => {
-    const root = props.root || "root";
-    const system = props.system;
-    const pub = props.public || props.fpi;
+XML.register(
+	["DOCTYPE", "doctype"],
+	({ props }) => {
+		const root = props.root || "root";
+		const system = props.system;
+		const pub = props.public || props.fpi;
 
-    if (pub && system) {
-        return `<!DOCTYPE ${root} PUBLIC "${pub}" "${system}">`;
-    } else if (system) {
-        return `<!DOCTYPE ${root} SYSTEM "${system}">`;
-    }
-    return `<!DOCTYPE ${root}>`;
-}, { rules: { is_empty_body: true } });
+		if (pub && system) {
+			return `<!DOCTYPE ${root} PUBLIC "${pub}" "${system}">`;
+		} else if (system) {
+			return `<!DOCTYPE ${root} SYSTEM "${system}">`;
+		}
+		return `<!DOCTYPE ${root}>`;
+	},
+	{ rules: { is_empty_body: true } }
+);
 
 /**
  * Registers the XML stylesheet processing instruction.
  * Usage: [xml-stylesheet = href: "style.xsl"]
  */
-XML.register("xml-stylesheet", ({ props }) => {
-    const type = props.type || "text/xsl";
-    const href = props.href;
-    if (!href) return "";
-    return `<?xml-stylesheet type="${type}" href="${href}"?>`;
-}, { rules: { is_empty_body: true } });
+XML.register(
+	"xml-stylesheet",
+	({ props }) => {
+		const type = props.type || "text/xsl";
+		const href = props.href;
+		if (!href) return "";
+		return `<?xml-stylesheet type="${type}" href="${href}"?>`;
+	},
+	{ rules: { is_empty_body: true } }
+);
 
 /**
  * Registers CDATA sections.
@@ -105,8 +120,8 @@ XML.register("xml-stylesheet", ({ props }) => {
  * Self-closing: [cdata = "raw content" !] or [cdata = text: "raw content" !]
  */
 XML.register("cdata", ({ props, content, isSelfClosing }) => {
-    const text = isSelfClosing ? (props[0] ?? props.text ?? "") : content;
-    return `<![CDATA[${text}]]>`;
+	const text = isSelfClosing ? (props[0] ?? props.text ?? "") : content;
+	return `<![CDATA[${text}]]>`;
 });
 
 registerSharedOutputs(XML);

package/mappers/shared/index.js

@@ -1,8 +1,17 @@
 /**
  * Registers universal utility blocks shared across all SomMark mappers.
- * These blocks are considered "Format Agnostic."
  *
  * @param {Mapper} mapper - The mapper instance to register tags on.
  */
 export function registerSharedOutputs(mapper) {
+	mapper.register(
+		["raw", "Raw"],
+		({ content }) => {
+			return content;
+		},
+    {
+      escape: false, rules: {
+      required_directives: ["raw"]
+		} }
+	);
 }

package/package.json

@@ -1,12 +1,16 @@
 {
 	"name": "sommark",
-	"version": "5.0.4",
+	"version": "5.1.0",
 	"description": "SomMark is a template language that compiles to multiple output formats — HTML, JSON, YAML, TOML, CSV, Markdown, XML, and more.",
 	"main": "index.js",
 	"files": [
 		"index.js",
 		"index.browser.js",
 		"index.shared.js",
+		"async-hooks.js",
+		"vite.js",
+		"rollup.js",
+		"esbuild.js",
 		"core/",
 		"mappers/",
 		"helpers/",
@@ -25,7 +29,10 @@
 	"type": "module",
 	"exports": {
 		".": "./index.js",
-		"./browser": "./index.browser.js"
+		"./browser": "./index.browser.js",
+		"./vite": "./vite.js",
+		"./rollup": "./rollup.js",
+		"./esbuild": "./esbuild.js"
 	},
 	"scripts": {
 		"test": "vitest",