sommark 5.0.2 → 5.0.4

package/core/evaluator.js

@@ -1,9 +1,21 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { getQuickJS } from "quickjs-emscripten";
 import path from "pathe";
 import * as acorn from "acorn";
 import SomMark, { registerHostCompile, registerHostSettings } from "./helpers/lib.js";
 import { formatMessage } from "./errors.js";
 
+// Each transpile() call gets its own isolated EvaluatorState stack via async context.
+const evaluatorStorage = new AsyncLocalStorage();
+
+/**
+ * Runs fn inside an isolated evaluator context.
+ * Concurrent transpile() calls each get their own stack — no cross-contamination.
+ */
+export function withEvaluator(fn) {
+    return evaluatorStorage.run([], fn);
+}
+
 // Global tracker to ensure deep recursive Smark compilation never exceeds safe boundaries
 let globalCompilationDepth = 0;
 
@@ -730,8 +742,10 @@ class EvaluatorState {
         this.expose(vars);
     }
 
-    async execute(code) {
+    async execute(code, baseDir = null) {
         if (!this.context) throw new Error("Evaluator not initialized");
+        const prevBaseDir = this.baseDir;
+        if (baseDir) this.baseDir = baseDir;
 
         const timeout = this.security?.timeout ?? 5000;
         this.deadline = Date.now() + timeout;
@@ -965,6 +979,7 @@ class EvaluatorState {
         } finally {
             this.deadline = 0;
             clearInterval(interval);
+            if (baseDir) this.baseDir = prevBaseDir;
         }
     }
 
@@ -1001,30 +1016,42 @@ class EvaluatorState {
 
 class Evaluator {
     constructor() {
-        this.instances = [];
+        // Fallback stack for callers that use init() outside withEvaluator() (e.g. tests).
+        this._fallbackStack = [];
     }
 
+    _getStack() {
+        return evaluatorStorage.getStore() ?? this._fallbackStack;
+    }
+
+    // Expose the active stack so tests can check .instances.length
+    get instances() { return this._getStack(); }
+
     setDefaultFs(fs) {
         defaultFs = fs;
     }
 
     get active() {
-        if (this.instances.length === 0) {
+        const stack = this._getStack();
+        if (stack.length === 0) {
             throw new Error("No active EvaluatorState instance. Did you call init()?");
         }
-        return this.instances[this.instances.length - 1];
+        return stack[stack.length - 1];
     }
 
+    // Forward .runtime to the active state so tests can assert on it
+    get runtime() { return this.active?.runtime ?? null; }
+
     async init(baseDir = null, security = {}, settings = {}, mapperFile = null) {
         const state = new EvaluatorState();
         await state.init(baseDir, security, settings, mapperFile);
-        this.instances.push(state);
+        this._getStack().push(state);
     }
 
     destroy() {
-        if (this.instances.length > 0) {
-            const state = this.instances.pop();
-            state.destroy();
+        const stack = this._getStack();
+        if (stack.length > 0) {
+            stack.pop().destroy();
         }
     }
 
@@ -1040,8 +1067,8 @@ class Evaluator {
         this.active.inject(vars);
     }
 
-    async execute(code) {
-        return await this.active.execute(code);
+    async execute(code, baseDir = null) {
+        return await this.active.execute(code, baseDir);
     }
 
     hasDynamicTag(id) {

package/core/evaluator.stub.js

@@ -6,6 +6,7 @@ const LITE_ERROR =
     "Use the full SomMark bundle to enable JS evaluation.";
 
 export function setCompilerClass(_cls) {}
+export function withEvaluator(fn) { return fn(); }
 
 class EvaluatorStub {
     setDefaultFs(_fs) {}

package/core/helpers/lib.js

@@ -18,7 +18,7 @@ export function registerHostSettings(settings) {
     hostSettings = settings || {};
 }
 
-const version = "5.0.2";
+const version = "5.0.4";
 
 const SomMark = {
     version,

package/core/lexer.js

@@ -346,13 +346,6 @@ function lexer(src, filename = "anonymous") {
 		// LOGIC BLOCKS (${ ... }$) — explicit: static/runtime ${ }$  shorthand: ${ }$ = static ${ }$
 		if (char === "$" && next === "{") {
 			{
-				const hasExplicitKeyword = last_non_junk_type === TOKEN_TYPES.STATIC_KEYWORD || last_non_junk_type === TOKEN_TYPES.RUNTIME_KEYWORD;
-				if (!hasExplicitKeyword) {
-						// Zero-width: synthetic token has no source presence, must not shift position
-						tokens.push({ type: TOKEN_TYPES.STATIC_KEYWORD, value: "static", source: filename, range: { start: { line, character }, end: { line, character } } });
-						prev_type = TOKEN_TYPES.STATIC_KEYWORD;
-						last_non_junk_type = TOKEN_TYPES.STATIC_KEYWORD;
-					}
 				addToken(TOKEN_TYPES.LOGIC_OPEN, "${");
 				i += 2;
 

package/core/modules.js

@@ -1,7 +1,7 @@
 import path from "pathe";
 import { fileURLToPath } from "./helpers/url.js";
 import { runtimeError } from "./errors.js";
-import { IMPORT, USE_MODULE, TEXT, BLOCK, COMMENT, SLOT } from "./labels.js";
+import { IMPORT, USE_MODULE, TEXT, BLOCK, COMMENT, SLOT, STATIC_LOGIC, RUNTIME_LOGIC } from "./labels.js";
 
 /**
  * Resolves a module path relative to a base directory.
@@ -52,7 +52,10 @@ const resolveAstVariables = (nodes, variables) => {
 	for (const node of nodes) {
 		if (node.type === TEXT) {
 			if (node.text.includes(VAR_PREFIX)) {
-				node.text = node.text.replace(VAR_PATTERN, (match, key) => {
+				node.text = node.text.replace(VAR_PATTERN, (match, keyAndFallback) => {
+					const pipeIdx = keyAndFallback.indexOf('|');
+					const key = pipeIdx >= 0 ? keyAndFallback.slice(0, pipeIdx) : keyAndFallback;
+					const fallback = pipeIdx >= 0 ? keyAndFallback.slice(pipeIdx + 1) : undefined;
 					if (variables[key] !== undefined) {
 						if (!variables.__consumed__) {
 							Object.defineProperty(variables, "__consumed__", {
@@ -65,14 +68,21 @@ const resolveAstVariables = (nodes, variables) => {
 						variables.__consumed__.add(key);
 						return String(variables[key]);
 					}
+					if (fallback !== undefined) return fallback;
 					return match;
 				});
 			}
 		} else if (node.type === BLOCK) {
 			// Resolve any unresolved variables in block arguments
 			for (const [argKey, argVal] of Object.entries(node.props)) {
-				if (typeof argVal === "string" && argVal.startsWith(VAR_PREFIX) && argVal.endsWith(VAR_SUFFIX)) {
-					const varKey = argVal.slice(VAR_PREFIX.length, -VAR_SUFFIX.length);
+				if (typeof argVal !== "string" || !argVal.includes(VAR_PREFIX)) continue;
+
+				if (argVal.startsWith(VAR_PREFIX) && argVal.endsWith(VAR_SUFFIX)) {
+					// Entire value is an envelope — resolve to scalar or fallback
+					const keyAndFallback = argVal.slice(VAR_PREFIX.length, -VAR_SUFFIX.length);
+					const pipeIdx = keyAndFallback.indexOf('|');
+					const varKey = pipeIdx >= 0 ? keyAndFallback.slice(0, pipeIdx) : keyAndFallback;
+					const fallback = pipeIdx >= 0 ? keyAndFallback.slice(pipeIdx + 1) : undefined;
 					if (variables[varKey] !== undefined) {
 						node.props[argKey] = variables[varKey];
 						if (!variables.__consumed__) {
@@ -84,7 +94,31 @@ const resolveAstVariables = (nodes, variables) => {
 							});
 						}
 						variables.__consumed__.add(varKey);
+					} else if (fallback !== undefined) {
+						node.props[argKey] = fallback;
 					}
+				} else {
+					// Envelope embedded inside a larger string — replace in-place.
+					// Unresolved envelopes become "" so they don't pollute class names etc.
+					node.props[argKey] = argVal.replace(VAR_PATTERN, (match, keyAndFallback) => {
+						const pipeIdx = keyAndFallback.indexOf('|');
+						const key = pipeIdx >= 0 ? keyAndFallback.slice(0, pipeIdx) : keyAndFallback;
+						const fallback = pipeIdx >= 0 ? keyAndFallback.slice(pipeIdx + 1) : undefined;
+						if (variables[key] !== undefined) {
+							if (!variables.__consumed__) {
+								Object.defineProperty(variables, "__consumed__", {
+									value: new Set(),
+									writable: true,
+									enumerable: false,
+									configurable: true
+								});
+							}
+							variables.__consumed__.add(key);
+							return String(variables[key]);
+						}
+						if (fallback !== undefined) return fallback;
+						return "";
+					});
 				}
 			}
 			if (node.body) {
@@ -114,6 +148,7 @@ const cloneAst = (nodes) => {
 		if (node.id !== undefined) nodeCopy.id = node.id;
 		if (node.code !== undefined) nodeCopy.code = node.code;
 		if (node.isSelfClosing !== undefined) nodeCopy.isSelfClosing = node.isSelfClosing;
+		if (node.baseDir !== undefined) nodeCopy.baseDir = node.baseDir;
 		if (node.props !== undefined) {
 			nodeCopy.props = { ...node.props };
 		}
@@ -125,6 +160,20 @@ const cloneAst = (nodes) => {
 	return copy;
 };
 
+/**
+ * Tags all STATIC_LOGIC and RUNTIME_LOGIC nodes in a subtree with their
+ * source module's baseDir so the evaluator can resolve imports correctly.
+ */
+const tagLogicNodes = (nodes, baseDir) => {
+	if (!nodes) return;
+	for (const node of nodes) {
+		if ((node.type === STATIC_LOGIC || node.type === RUNTIME_LOGIC) && !node.baseDir) {
+			node.baseDir = baseDir;
+		}
+		if (node.body) tagLogicNodes(node.body, baseDir);
+	}
+};
+
 /**
  * Handles all [import] and [$use-module] blocks in your code.
  * It loads the requested files, checks for errors, and puts the content into the main document.
@@ -298,6 +347,7 @@ export async function resolveModules(ast, context) {
 						format: context.format,
 						filename: mod.path,
 						baseDir: path.dirname(mod.localPath),
+						fs: context.instance.fs,
 						mapperFile: context.instance.mapperFile,
 						placeholders: context.instance.placeholders,
 						variables: {},
@@ -313,6 +363,7 @@ export async function resolveModules(ast, context) {
 					});
 
 					const subAst = await subSmark.parse();
+					tagLogicNodes(subAst, path.dirname(mod.localPath));
 					context.instance.moduleCache.set(mod.localPath, subAst);
 					expandedNodes = trimAst(subAst);
 				}
@@ -356,6 +407,7 @@ export async function resolveModules(ast, context) {
 						format: context.format,
 						filename: mod.path,
 						baseDir: path.dirname(mod.localPath),
+						fs: context.instance.fs,
 						mapperFile: context.instance.mapperFile,
 						placeholders: context.instance.placeholders,
 						variables: {}, // Parse without variables to keep the cached AST pure
@@ -371,6 +423,7 @@ export async function resolveModules(ast, context) {
 					});
 
 					subAst = await subSmark.parse();
+					tagLogicNodes(subAst, path.dirname(mod.localPath));
 					context.instance.moduleCache.set(mod.localPath, subAst);
 					subAst = cloneAst(subAst);
 				}
@@ -441,3 +494,10 @@ export async function resolveModules(ast, context) {
 
 	return ast;
 }
+
+/**
+ * After full transpilation of the top-level file, apply any v{} fallbacks that
+ * remain unresolved. Envelopes with no fallback are kept as-is (debugging signal).
+ * Must NOT be called on sub-module ASTs — only on the final top-level AST.
+ */
+export const applyVariableFallbacks = (ast) => resolveAstVariables(ast, {});

package/core/parser.js

@@ -389,6 +389,22 @@ function parseValue(tokens, i, placeholders = {}, variables = {}, allowLogic = t
 			nextI++;
 		}
 
+		return [node, nextI, false];
+	} else if (current_token(tokens, i).type === TOKEN_TYPES.LOGIC_OPEN) {
+		if (!allowLogic) {
+			parserError(errorMessage(tokens, i, "literal value", "", "Logic blocks are not allowed in this context."));
+		}
+		let nextI = i + 1;
+		const logicToken = current_token(tokens, nextI);
+		const node = makeLogicNode(STATIC_LOGIC);
+		node.code = logicToken ? logicToken.value : "";
+		node.range = logicToken ? logicToken.range : current_token(tokens, i).range;
+		nextI++;
+
+		if (current_token(tokens, nextI) && current_token(tokens, nextI).type === TOKEN_TYPES.LOGIC_CLOSE) {
+			nextI++;
+		}
+
 		return [node, nextI, false];
 	} else if (current_token(tokens, i).type === TOKEN_TYPES.PREFIX_V) {
 		i++; // consume PREFIX_V keyword
@@ -405,7 +421,9 @@ function parseValue(tokens, i, placeholders = {}, variables = {}, allowLogic = t
 			}
 			variables.__consumed__.add(vKey);
 		} else {
-			val = vFallback !== undefined ? vFallback : getPrefixValue('v', vKey);
+			// Encode fallback in the envelope key so resolveAstVariables can apply it
+			// at instantiation time instead of baking it in now.
+			val = getPrefixValue('v', vFallback !== undefined ? `${vKey}|${vFallback}` : vKey);
 		}
 		return [val, i, false];
 	} else if (current_token(tokens, i).type === TOKEN_TYPES.PREFIX_P) {
@@ -838,7 +856,8 @@ function parseText(tokens, i, placeholders = {}, variables = {}, depth = 0, opti
 				}
 				variables.__consumed__.add(tvKey);
 			} else {
-				textNode.text += tvFallback !== undefined ? tvFallback : getPrefixValue('v', tvKey);
+				// Encode fallback in envelope so resolveAstVariables can apply it later.
+				textNode.text += getPrefixValue('v', tvFallback !== undefined ? `${tvKey}|${tvFallback}` : tvKey);
 			}
 		} else {
 			break;
@@ -938,6 +957,28 @@ function parseNode(tokens, i, filename = null, placeholders = {}, variables = {}
 		return [node, nextI];
 	}
 	// ========================================================================== //
+	//  Bare Logic Block (${ }$ without explicit static/runtime — defaults to static)
+	// ========================================================================== //
+	else if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.LOGIC_OPEN) {
+		global_static_logic_count++;
+		let nextI = i + 1;
+		const logicToken = current_token(tokens, nextI);
+		const node = makeLogicNode(STATIC_LOGIC);
+		node.code = logicToken ? logicToken.value : "";
+		node.depth = depth;
+		node.range = {
+			start: current_token(tokens, i).range.start,
+			end: logicToken ? logicToken.range.end : current_token(tokens, i).range.end
+		};
+		nextI++;
+
+		if (current_token(tokens, nextI) && current_token(tokens, nextI).type === TOKEN_TYPES.LOGIC_CLOSE) {
+			nextI++;
+		}
+
+		return [node, nextI];
+	}
+	// ========================================================================== //
 	//  Text or Placeholder                                                       //
 	// ========================================================================== //
 	else if (

package/core/transpiler.js

@@ -1,6 +1,6 @@
 import { BLOCK, TEXT, COMMENT, COMMENT_BLOCK, STATIC_LOGIC, RUNTIME_LOGIC, FOR_EACH } from "./labels.js";
 import { transpilerError } from "./errors.js";
-import evaluator from "./evaluator.js";
+import evaluator, { withEvaluator } from "./evaluator.js";
 import { matchedValue } from "../helpers/utils.js";
 import { dedentBy } from "../helpers/dedent.js";
 import { preprocessRuntimeLogic } from "./helpers/preprocessor.js";
@@ -107,7 +107,7 @@ async function generateOutput(ast, i, format, mapper_file, security = {}, parent
 
 	if (node.type === STATIC_LOGIC) {
 		try {
-			const result = await evaluator.execute(node.code);
+			const result = await evaluator.execute(node.code, node.baseDir || null);
 			if (generateRuntimeOutput) return "";
 			if (result && typeof result === "object" && result.__raw !== undefined) {
 				if (security?.allowRaw === false) {
@@ -313,7 +313,7 @@ async function generateOutput(ast, i, format, mapper_file, security = {}, parent
 						}
 					} else if (child.type === STATIC_LOGIC) {
 						try {
-							const val = await evaluator.execute(child.code);
+							const val = await evaluator.execute(child.code, child.baseDir || null);
 							if (val !== undefined && typeof val !== "object") richText += String(val);
 						} catch (err) {
 							transpilerError([
@@ -431,7 +431,7 @@ async function generateOutput(ast, i, format, mapper_file, security = {}, parent
 
 					case STATIC_LOGIC:
 						try {
-							const result = await evaluator.execute(body_node.code);
+							const result = await evaluator.execute(body_node.code, body_node.baseDir || null);
 							if (result && typeof result === "object" && result.__raw !== undefined) {
 								if (security?.allowRaw === false) {
 									bodyOutput = mapper_file ? mapper_file.text(String(result.__raw)) : String(result.__raw);
@@ -545,109 +545,108 @@ export async function transpiler(optionsOrAst, format, mapperFile) {
 	})();
 
 	const dualOutput = optionsOrAst?.dualOutput || false;
-
-	// Initialize Logic Sandbox
-	await evaluator.init(fileBaseDir, security, settings, targetMapper);
-	// Inject global data
 	const placeholders = optionsOrAst?.placeholders || settings?.placeholders || {};
 	const variables = optionsOrAst?.variables || settings?.variables || {};
 	warnDroppedVariables(variables);
-	evaluator.inject(placeholders);
-	evaluator.inject(variables);
 
-	let output = "";
-	let prev_body_node = null;
-	let prev_was_silent = false;
+	return withEvaluator(async () => {
+		// Initialize Logic Sandbox inside isolated async context
+		await evaluator.init(fileBaseDir, security, settings, targetMapper);
+		evaluator.inject(placeholders);
+		evaluator.inject(variables);
 
-	if (dualOutput) {
-		const idState = { mode: 'record', ids: [], idx: 0 };
+		let output = "";
+		let prev_body_node = null;
+		let prev_was_silent = false;
 
-		// HTML pass — generate HTML, record element IDs for runtime blocks
-		let htmlOutput = "";
-		try {
-			for (let i = 0; i < body.length; i++) {
-				const node = body[i];
-				const blockOutput = await generateOutput(body, i, targetFormat, targetMapper, security, null, false, true, instance, idState);
-				let finalBlockOutput = blockOutput;
-				if (prev_was_silent && node.type === TEXT) finalBlockOutput = finalBlockOutput.replace(/^\n/, "");
-				if (finalBlockOutput) {
-					htmlOutput += finalBlockOutput;
-					prev_was_silent = false;
-				} else {
-					prev_was_silent = true;
-					if ((node.type === COMMENT || node.type === COMMENT_BLOCK) && targetMapper?.options?.removeComments) {
-						const nextNode = body[i + 1];
-						if (nextNode && nextNode.type === TEXT && (nextNode.text === "\n" || nextNode.text === "\r\n")) i++;
+		if (dualOutput) {
+			const idState = { mode: 'record', ids: [], idx: 0 };
+
+			// HTML pass — generate HTML, record element IDs for runtime blocks
+			let htmlOutput = "";
+			try {
+				for (let i = 0; i < body.length; i++) {
+					const node = body[i];
+					const blockOutput = await generateOutput(body, i, targetFormat, targetMapper, security, null, false, true, instance, idState);
+					let finalBlockOutput = blockOutput;
+					if (prev_was_silent && node.type === TEXT) finalBlockOutput = finalBlockOutput.replace(/^\n/, "");
+					if (finalBlockOutput) {
+						htmlOutput += finalBlockOutput;
+						prev_was_silent = false;
+					} else {
+						prev_was_silent = true;
+						if ((node.type === COMMENT || node.type === COMMENT_BLOCK) && targetMapper?.options?.removeComments) {
+							const nextNode = body[i + 1];
+							if (nextNode && nextNode.type === TEXT && (nextNode.text === "\n" || nextNode.text === "\r\n")) i++;
+						}
 					}
 				}
+			} finally {
+				evaluator.destroy();
 			}
-		} finally {
-			evaluator.destroy();
-		}
 
-		// JS pass — replay the same IDs so querySelector targets match HTML
-		idState.mode = 'replay';
-		idState.idx = 0;
-		prev_was_silent = false;
+			// JS pass — replay the same IDs so querySelector targets match HTML
+			idState.mode = 'replay';
+			idState.idx = 0;
+			prev_was_silent = false;
 
-		await evaluator.init(fileBaseDir, security, settings, targetMapper);
-		evaluator.inject(placeholders);
-		evaluator.inject(variables);
+			await evaluator.init(fileBaseDir, security, settings, targetMapper);
+			evaluator.inject(placeholders);
+			evaluator.inject(variables);
+
+			let jsOutput = "";
+			try {
+				for (let i = 0; i < body.length; i++) {
+					const node = body[i];
+					const blockOutput = await generateOutput(body, i, targetFormat, targetMapper, security, null, true, false, instance, idState);
+					let finalBlockOutput = blockOutput;
+					if (prev_was_silent && node.type === TEXT) finalBlockOutput = finalBlockOutput.replace(/^\n/, "");
+					if (finalBlockOutput) {
+						jsOutput += finalBlockOutput;
+						prev_was_silent = false;
+					} else {
+						prev_was_silent = true;
+					}
+				}
+			} finally {
+				evaluator.destroy();
+			}
+
+			return [htmlOutput.trim(), jsOutput.trim()];
+		}
 
-		let jsOutput = "";
 		try {
 			for (let i = 0; i < body.length; i++) {
 				const node = body[i];
-				const blockOutput = await generateOutput(body, i, targetFormat, targetMapper, security, null, true, false, instance, idState);
+				const blockOutput = await generateOutput(body, i, targetFormat, targetMapper, security, null, false, false, instance);
+
 				let finalBlockOutput = blockOutput;
-				if (prev_was_silent && node.type === TEXT) finalBlockOutput = finalBlockOutput.replace(/^\n/, "");
+				if (prev_was_silent && node.type === TEXT) {
+					finalBlockOutput = finalBlockOutput.replace(/^\n/, "");
+				}
+
 				if (finalBlockOutput) {
-					jsOutput += finalBlockOutput;
+					output += finalBlockOutput;
 					prev_was_silent = false;
+					if (node.type !== TEXT || node.text.trim().length > 0) {
+						prev_body_node = node;
+					}
 				} else {
 					prev_was_silent = true;
+					if ((node.type === COMMENT || node.type === COMMENT_BLOCK) && targetMapper?.options?.removeComments) {
+						const nextNode = body[i + 1];
+						if (nextNode && nextNode.type === TEXT && (nextNode.text === "\n" || nextNode.text === "\r\n")) {
+							i++;
+						}
+					}
 				}
 			}
 		} finally {
 			evaluator.destroy();
 		}
 
-		return [htmlOutput.trim(), jsOutput.trim()];
-	}
-
-	try {
-		for (let i = 0; i < body.length; i++) {
-			const node = body[i];
-			const blockOutput = await generateOutput(body, i, targetFormat, targetMapper, security, null, false, false, instance);
-
-			let finalBlockOutput = blockOutput;
-			if (prev_was_silent && node.type === TEXT) {
-				finalBlockOutput = finalBlockOutput.replace(/^\n/, "");
-			}
-
-			if (finalBlockOutput) {
-				output += finalBlockOutput;
-				prev_was_silent = false;
-				if (node.type !== TEXT || node.text.trim().length > 0) {
-					prev_body_node = node;
-				}
-			} else {
-				prev_was_silent = true;
-				if ((node.type === COMMENT || node.type === COMMENT_BLOCK) && targetMapper?.options?.removeComments) {
-					// If a comment is removed, check the next node.
-					// If it's just a blank line, skip it so we don't have extra gaps in the output.
-					const nextNode = body[i + 1];
-					if (nextNode && nextNode.type === TEXT && (nextNode.text === "\n" || nextNode.text === "\r\n")) {
-						i++; // Skip the next newline node
-					}
-				}
-			}
-		}
-	} finally {
-		evaluator.destroy();
-	}
-
-	return output.trim();
+		return output.trim();
+	});
 }
 
 /**
@@ -670,7 +669,7 @@ async function transpileArgs(props) {
 				result[key] = "";
 			} else if (value.type === STATIC_LOGIC) {
 				try {
-					result[key] = await evaluator.execute(value.code);
+					result[key] = await evaluator.execute(value.code, value.baseDir || null);
 				} catch (err) {
 					transpilerError([
 						`<$red:Logic Error (Argument):$> ${err.message}{line}`,