sommark 4.0.2 → 4.1.0

package/index.js

@@ -2,21 +2,24 @@ 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, xmlFormat } from "./core/formats.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 { formatAST } from "./core/formatter.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.
@@ -33,28 +36,60 @@ class SomMark {
 	 * @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 {placeholders}.
+	 * @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({ src, format, mapperFile = null, filename = "anonymous", removeComments = true, placeholders = {}, customProps = [], importStack = [] }) {
+	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 = `$_SM_MOD_${Math.random().toString(36).slice(2, 7)}_$`;
+		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, [xmlFormat]: XML, [textFormat]: new 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];
@@ -70,6 +105,9 @@ class SomMark {
 			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];
@@ -161,6 +199,13 @@ class SomMark {
 		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.
@@ -170,7 +215,7 @@ class SomMark {
 	 */
 	async parse(src = this.src) {
 		const tokens = await this.lex(src);
-		let ast = parser(tokens, this.filename, this.placeholders);
+		let ast = parser(tokens, this.filename, this.placeholders, {});
 
 		ast = await resolveModules(ast, {
 			mapperFile: this.mapperFile,
@@ -191,7 +236,7 @@ class SomMark {
 		this._ensurePrepared();
 		if (src !== this.src) this.src = src;
 		const tokens = lexer(this.src, this.filename);
-		let ast = parser(tokens, this.filename, this.placeholders);
+		let ast = parser(tokens, this.filename, this.placeholders, {});
 
 		if (this.mapperFile) {
 			validateAST(ast, this.mapperFile, this);
@@ -210,24 +255,30 @@ class SomMark {
 		if (src !== this.src) this.src = src;
 		this._ensurePrepared();
 
-		const ast = await this.parse(src);
-		let result = await transpiler({ ast, format: this.targetFormat, mapperFile: this.mapperFile });
+		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;
+			return result;
+		} finally {
+			if (this.showSpinner) stopSpinner();
+		}
 	}
 
 
-	async format(options = {}) {
-		const tokens = await this.lex();
-		const ast = parser(tokens, this.filename);
-		return formatAST(ast, options);
-	}
-
-	formatSync(options = {}) {
-		const tokens = lexer(this.src, this.filename);
-		const ast = parser(tokens, this.filename);
-		return formatAST(ast, options);
-	}
 }
 
 /**
@@ -239,7 +290,13 @@ class SomMark {
  * @returns {Promise<Array<Object>>} - The list of tokens.
  */
 const lex = async (src, filename = "anonymous") => {
-	return await new SomMark({ src, filename, format: htmlFormat }).lex();
+	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);
 };
 
 /**
@@ -251,14 +308,17 @@ const lex = async (src, filename = "anonymous") => {
  * @returns {Promise<Array<Object>>} - The final code tree.
  */
 async function parse(src, filename = "anonymous") {
-	if (!src) {
+	if (src === undefined || src === null) {
 		runtimeError([`{line}<$red:Missing Source:$> <$yellow:The 'src' argument is required for parsing.$>{line}`]);
 	}
-	return await new SomMark({ src, filename, format: htmlFormat }).parse();
+	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();
 }
 
 /**
- * The easiest way to process SomMark code.
+ * Transpiles SomMark code to a target format.
  * 
  * @param {Object} options - Transpilation options.
  * @param {string} options.src - Raw source code.
@@ -268,14 +328,16 @@ async function parse(src, filename = "anonymous") {
  * @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 = {}) {
-	const { src, format = htmlFormat, filename = "anonymous", mapperFile = null, removeComments = true, placeholders = {}, customProps = [] } = options;
 	if (typeof options !== "object" || options === null) {
 		runtimeError([`{line}<$red:Invalid Options:$> <$yellow:The options argument must be a non-null object.$>{line}`]);
 	}
-	const knownProps = ["src", "format", "filename", "mapperFile", "removeComments", "placeholders", "customProps"];
+	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([
@@ -283,11 +345,16 @@ async function transpile(options = {}) {
 			]);
 		}
 	});
-	if (!src) {
-		runtimeError([`{line}<$red:Missing Source:$> <$yellow:The 'src' argument is required for transpilation.$>{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({ src, format, filename, mapperFile, removeComments, placeholders, customProps });
+	const sm = new SomMark(options);
 	return await sm.transpile();
 }
 
@@ -295,9 +362,18 @@ async function transpile(options = {}) {
  * 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 => lexer(src);
+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.
@@ -306,18 +382,28 @@ const lexSync = src => lexer(src);
  * @param {Object} [options={}] - Parsing options.
  * @returns {Array<Object>} - The code tree.
  */
-const parseSync = (src, options = {}) => {
-	const { format = htmlFormat, filename = "anonymous", mapperFile = null, removeComments = true, placeholders = {}, customProps = [] } = options;
-	return new SomMark({ src, format, filename, mapperFile, removeComments, placeholders, customProps }).parseSync();
+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,
@@ -326,11 +412,12 @@ export {
 	transpile,
 	lexSync,
 	parseSync,
-	formatAST,
 	TOKEN_TYPES,
 	labels,
 	enableColor,
 	safeArg,
-	findAndLoadConfig
+	findAndLoadConfig,
+	Evaluator,
+	preprocessRuntimeLogic
 };
 export default SomMark;

package/mappers/languages/html.js

@@ -1,6 +1,7 @@
 import Mapper from "../mapper.js";
 import { VOID_ELEMENTS } from "../../constants/void_elements.js";
 import { registerSharedOutputs } from "../shared/index.js";
+import kebabize from "../../helpers/kebabize.js";
 
 /**
  * Helper to format an HTML tag with attributes and content.
@@ -10,17 +11,17 @@ import { registerSharedOutputs } from "../shared/index.js";
  * @param {string} content - The text or tags inside this tag.
  * @returns {string} - The finished HTML string.
  */
-const renderHtmlTag = function (id, args, content) {
+const renderHtmlTag = function (id, args, content, isSelfClosing) {
 	const element = this.tag(id);
 
-	element.smartAttributes(args, this.customProps);
+	element.smartAttributes(args, this.customProps, this.options);
 
 	let finalContent = content;
 	if (id.toLowerCase() === "script" && args.scoped === true) {
 		finalContent = `(function(){\n${content}\n})();`;
 	}
 
-	if (VOID_ELEMENTS.has(id.toLowerCase())) {
+	if (VOID_ELEMENTS.has(id.toLowerCase()) || isSelfClosing) {
 		return element.selfClose();
 	}
 
@@ -40,6 +41,22 @@ const HTML = Mapper.define({
 		return `<!-- ${text} -->`;
 	},
 
+	/**
+	 * Natively formats runtime logic for HTML.
+	 * Global logic is placed in a raw script tag.
+	 * Block-level logic is wrapped in a self-executing function to isolate scope and provide `self` reference.
+	 */
+	runtimeLogic(code, isGlobal, parentId) {
+		if (isGlobal) {
+			return this.tag("script").body(`\n${code.split("\n").filter(line => line.trim() !== "").join("\n")}\n`);
+		} else {
+			const selfDefinition = parentId
+				? `const self = document.querySelector('[data-sommark-id="${parentId}"]');`
+				: `const self = document.currentScript.parentElement;`;
+			return this.tag("script").body(`\n(async function(){${selfDefinition}\nif (self) {\n${code.split("\n").filter(line => line.trim() !== "").join("\n")}\n}\n})();\n`);
+		}
+	},
+
 	/**
 	 * Formats plain text and makes sure it's safe for HTML if needed.
 	 */
@@ -66,9 +83,6 @@ const HTML = Mapper.define({
 		if (options?.escape !== false) {
 			out = this.escapeHTML(out);
 		}
-		if (out.includes('\n')) {
-			out = '\n' + out + '\n';
-		}
 		return out;
 	},
 
@@ -83,7 +97,7 @@ const HTML = Mapper.define({
 		const isCodeStyleOrScript = ["code", "style", "script"].includes(id);
 
 		return {
-			render: function ({ args, content }) { return renderHtmlTag.call(this, id, args, content); },
+			render: function ({ args, content, isSelfClosing }) { return renderHtmlTag.call(this, id, args, content, isSelfClosing); },
 			options: {
 				type: isCodeStyleOrScript ? ["Block", "AtBlock"] : ["Block", "Inline"],
 				escape: !isCodeStyleOrScript,
@@ -91,9 +105,9 @@ const HTML = Mapper.define({
 			}
 		};
 	},
-	
+
 	options: {
-		// trimAndWrapBlocks: false // Default to false for high-fidelity
+		trimAndWrapBlocks: true
 	}
 });
 
@@ -127,7 +141,34 @@ HTML.register(
 		type: "Block"
 	}
 );
+// Inline CSS tag (Moved from shared)
+HTML.register("css", ({ args, content }) => {
+	// Compile style from named arguments (keys that are not numeric digits)
+	const namedStyle = Object.keys(args)
+		.filter(k => isNaN(parseInt(k)))
+		.map(k => `${kebabize(k)}:${args[k]}`)
+		.join(";");
+
+	// Fetch positional style string (index 0) or "style" key if present
+	let positionalStyle = HTML.safeArg({ args, index: 0, key: "style", fallBack: "" });
+
+	// Filter out positional styles that are just duplicates of named arguments
+	const hasDuplicateNamed = Object.keys(args)
+		.filter(k => isNaN(parseInt(k)))
+		.some(k => args[k] === positionalStyle);
+
+	if (hasDuplicateNamed) {
+		positionalStyle = "";
+	}
 
+	// Combine both together
+	let style = [positionalStyle, namedStyle].filter(s => s.trim()).join(";");
+
+	style = style.split(";").filter(s => s.trim()).map(s => s.trim().split(":").map(s => s.trim()).join(":")).join(";");
+	return HTML.tag("span").attributes({ style }).body(content);
+}, {
+	type: "Inline"
+});
 registerSharedOutputs(HTML);
 
 export default HTML;

package/mappers/languages/json.js

@@ -9,7 +9,7 @@ import { getPositionalArgs, matchedValue, safeArg } from "../../helpers/utils.js
 /**
  * Returns a string representing the specified indentation level.
  */
-function getIndent(depth) {
+export function getIndent(depth) {
 	return "  ".repeat(depth);
 }
 
@@ -18,21 +18,35 @@ function getIndent(depth) {
  * @param {string} str - The string to escape.
  * @param {boolean} [trim=false] - Whether to trim the string.
  */
-function escapeString(str, trim = false) {
+export function escapeString(str, trim = false) {
 	let out = String(str);
 	if (trim) out = out.trim();
 	return JSON.stringify(out);
 }
 
+import evaluator from "../../core/evaluator.js";
+
 /**
  * Recursively extracts text content from a node, ignoring structural metadata.
+ * Evaluates StaticLogic nodes using the Evaluator to inject build-time values.
  */
-function getNodeText(node) {
+async function getNodeText(node) {
 	if (!node.body) return "";
 	let text = "";
 	for (const child of node.body) {
-		if (child.type === "Text") text += child.text;
-		else if (child.type === "Block") text += getNodeText(child);
+		if (child.type === "Text") text += child.text || "";
+		else if (child.type === "StaticLogic") {
+			try {
+				const result = await evaluator.execute(child.code);
+				if (result !== undefined && typeof result !== "object") {
+					text += String(result);
+				}
+			} catch (err) {
+				console.error(`\x1b[31mLogic Error in JSON mapper:\x1b[0m ${err.message}`);
+				console.error(`\x1b[33mCode:\x1b[0m \x1b[34m${child.code}\x1b[0m`);
+			}
+		}
+		else if (child.type === "Block") text += await getNodeText(child);
 	}
 	return text;
 }
@@ -40,7 +54,9 @@ function getNodeText(node) {
 /**
  * Resolves the key-value pairing for a JSON member.
  */
-function renderMember(args, value) {
+export function renderMember(args, value, inArray = false) {
+	if (inArray) return value;
+
 	const posArgs = getPositionalArgs(args);
 	const key = args.key || posArgs[0]; // The 'key' rule determines the member name
 
@@ -53,37 +69,63 @@ function renderMember(args, value) {
 /**
  * Formats a given node and tracks its indentation.
  */
-async function renderNode(node, mapper, depth = 0) {
+export async function renderNode(node, mapper, depth = 0, inArray = false) {
 	const target = matchedValue(mapper.outputs, node.id) || mapper.getUnknownTag(node);
 	if (!target) return "";
 
-	const textContent = getNodeText(node);
-	return await target.render.call(mapper, {
+	evaluator.pushScope();
+	const textContent = await getNodeText(node);
+	const output = await target.render.call(mapper, {
 		nodeType: node.type,
 		args: node.args,
 		content: "",
 		textContent,
 		ast: node,
-		depth
+		depth,
+		inArray
 	});
+	await evaluator.popScope();
+	return output;
 }
 
 /**
  * Formats the children of a node into a neat list.
  */
-async function renderChildren(node, mapper, depth = 0) {
+export async function renderChildren(node, mapper, depth = 0, inArray = false) {
 	let results = [];
 	const childIndent = getIndent(depth + 1);
 
 	for (const child of node.body) {
 		if (child.type === "Block") {
-			const output = await renderNode(child, mapper, depth + 1);
+			const output = await renderNode(child, mapper, depth + 1, inArray);
 			if (output) {
-				results.push(childIndent + output);
+				results.push({ type: "Block", value: childIndent + output });
+			}
+		}
+	}
+
+	let finalOutput = "";
+	for (let i = 0; i < results.length; i++) {
+		const current = results[i];
+		finalOutput += current.value;
+
+		if (current.type === "Block") {
+			// Add comma if there is another Block later
+			let hasNextBlock = false;
+			for (let j = i + 1; j < results.length; j++) {
+				if (results[j].type === "Block") {
+					hasNextBlock = true;
+					break;
+				}
 			}
+			if (hasNextBlock) finalOutput += ",";
+		}
+
+		if (i < results.length - 1) {
+			finalOutput += "\n";
 		}
 	}
-	return results.join(",\n");
+	return finalOutput;
 }
 
 const Json = Mapper.define({});
@@ -91,52 +133,53 @@ const Json = Mapper.define({});
 /**
  * The JSON object node rule.
  */
-Json.register(["Object", "object"], async ({ args, ast, depth = 0 }) => {
-	if (ast.body.length === 0) return renderMember(args, "{}");
-	const content = await renderChildren(ast, Json, depth);
+Json.register(["Object", "object"], async ({ args, ast, depth = 0, inArray = false }) => {
+	if (ast.body.length === 0) return renderMember(args, "{}", inArray);
+	const content = await renderChildren(ast, Json, depth, false);
 	const val = `{\n${content}\n${getIndent(depth)}}`;
-	return renderMember(args, val);
+	return renderMember(args, val, inArray);
 }, { type: "Block", handleAst: true });
 
 /**
  * The JSON array node rule.
  */
-Json.register(["Array", "array"], async ({ args, ast, depth = 0 }) => {
-	if (ast.body.length === 0) return renderMember(args, "[]");
-	const content = await renderChildren(ast, Json, depth);
+Json.register(["Array", "array"], async ({ args, ast, depth = 0, inArray = false }) => {
+	if (ast.body.length === 0) return renderMember(args, "[]", inArray);
+	const content = await renderChildren(ast, Json, depth, true);
 	const val = `[\n${content}\n${getIndent(depth)}]`;
-	return renderMember(args, val);
+	return renderMember(args, val, inArray);
 }, { type: "Block", handleAst: true });
 
 /**
  * JSON Primitives
  */
-Json.register("string", ({ args, textContent }) => {
-	const trim = safeArg({ 
-		args, 
-		key: "trim", 
-		type: "boolean", 
+Json.register("string", ({ args, textContent, inArray }) => {
+	const trim = safeArg({
+		args,
+		key: "trim",
+		type: "boolean",
 		setType: v => v === "true" || v === true,
-		fallBack: false 
+		fallBack: false
 	});
-	const val = escapeString(textContent, trim);
-	return renderMember(args, val);
+	const raw = safeArg({ args, index: inArray ? 0 : undefined, key: "value", fallBack: textContent });
+	const val = escapeString(raw, trim);
+	return renderMember(args, val, inArray);
 }, { type: "Block", handleAst: true });
 
-Json.register("number", ({ args, textContent }) => {
-	const raw = textContent.trim();
+Json.register("number", ({ args, textContent, inArray }) => {
+	const raw = String(safeArg({ args, index: inArray ? 0 : undefined, key: "value", fallBack: textContent })).trim();
 	const val = (isNaN(Number(raw)) || raw === "") ? "0" : raw;
-	return renderMember(args, val);
+	return renderMember(args, val, inArray);
 }, { type: "Block", handleAst: true });
 
-Json.register("bool", ({ args, textContent }) => {
-	const raw = textContent.trim().toLowerCase();
+Json.register("bool", ({ args, textContent, inArray }) => {
+	const raw = String(safeArg({ args, index: inArray ? 0 : undefined, key: "value", fallBack: textContent })).trim().toLowerCase();
 	const val = (raw === "true" || raw === "1") ? "true" : "false";
-	return renderMember(args, val);
+	return renderMember(args, val, inArray);
 }, { type: "Block", handleAst: true });
 
-Json.register("null", ({ args }) => {
-	return renderMember(args, "null");
+Json.register("null", ({ args, inArray }) => {
+	return renderMember(args, "null", inArray);
 }, { type: "Block", handleAst: true });
 
 export default Json;