lilact 0.0.0

package/src/jsx.js

@@ -0,0 +1,1168 @@
+/*
+
+	Lilact
+	Copyright (C) 2024-2026 Arash Kazemi <contact.arash.kazemi@gmail.com>
+	All rights reserved.
+
+	BSD-2-Clause
+
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+	ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+	DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+	LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+	ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+// This is a JSX transpiler that covers all the standard with some 
+// additional features like a nice preprocessor. It doesn't rely on any other 
+// library, even Lilact itself. It also generates sourcemap internally!
+// It is not very fast, the xml look-ahead can be quite expensive, but it is not 
+// slow at all.
+
+// Check the webpack config and also the transpiler.js helper script for
+// usage outside Lilact. Also make sure to check the default configuration.
+
+// There are some situations that are solved with tricks, as some aspects of
+// javascripts import a complete parser and I didn't want to get into that!
+// Works almosr perfectly so far (all observed bugs except 1 are fixed), works  
+// even on nasty things like the compressed version of tensorflow.js! Feel free   
+// to report any bugs, and please include a testable example. Thanks! :)
+//
+// note: until an efficient fix is found, make sure the slashes inside
+// 		 a regexp are escaped, even if they work without escaping.
+
+
+// todo: injected string try catchs should be generated by a function
+
+import * as jsxAddons from './jsx.addons.js';
+
+export const transpilerConfig = {
+	addons: jsxAddons,
+	setFunctionLabels: true,
+	enableLabelStack: false,
+	injectLabels: true,
+	// todo: alt+shift+7 on apple abc extended layout is better i think, 
+	// but my current editor doesn't support syntax highlighting with it.
+	preprocessorDelimiter: 'ʔ', // alt+shift+. on apple abc extended layout   
+
+
+	required: {},
+	func_labels: {},
+	func_num: Math.floor(Math.random()*10000)
+}
+
+
+const TRANSPILER_OUTPUT = Symbol.for("LILACT:TRANSPILER_OUTPUT");
+
+import * as vlq from './vlq.js';
+
+let raiseError;
+let tab=0;
+
+function lookAhead(f, code, index, ...args)
+{
+	const b = f(code, index, ...args);
+	if(b) {
+		return [b.end, b];
+	}
+	return [index];
+}
+
+function parseRegex(code, index, container)
+{
+	// previous token can only be(end with) ;=,([{}!^~&|:?*-+\\/<> or directive or 
+	// the slash can only be the first character
+	// the backward scan automatically passes for i=0
+
+	// todo: i have doubts about including preprocessorDelimiter
+
+	let i = index;
+	const dels = `;=,([{}!^~&|:?*-+\\/<>${transpilerConfig.preprocessorDelimiter}`;
+	while(--i>0) { 
+		if( ' \t\n\r'.indexOf(code[i])!==-1 ) continue;
+		if( dels.indexOf(code[i])!==-1 ) break;
+		return;
+	}
+
+	const b = {
+		type: "regex",
+		begin: index++
+	};
+
+	while(index<code.length) {
+		const ch = code[index];
+		switch(ch) {
+		case '\n':
+			return;
+		case '/':
+			b.end = index+1;
+			if(container) container.children.push(b);
+			return b;
+		case '\\':
+			index++;
+		default:
+			index++;
+		}
+	}	
+}
+
+function parseComment(code, index, container)
+{
+	const b = {
+		type: "comment",
+		begin: index++
+	};
+
+	if(code[index]!=='*' && code[index]!=='/') {
+		return parseRegex(code, index-1, container);
+	}
+
+	const is_multiline = code[index]==='*';
+
+	index++;
+
+	while(index<code.length) {
+
+		const ch = code[index];
+		switch(ch) {
+
+		case '*':
+			if(is_multiline && code[index+1]==='/') {
+				b.end=index+2;
+				if(container) container.children.push(b);
+				return b;
+			}
+			break;
+
+		case '\n':
+			if(!is_multiline) {
+				b.end = index+1;
+				if(container) container.children.push(b);
+				return b;
+			}
+			break;
+
+		}
+
+		index++;
+	}
+
+	raiseError(`unterminated comment`, index);
+}
+
+
+function parseDirective(code, index, container)
+{	
+	let i=index+1;
+	while(	code[i] && 
+			(code[i]!=='\n' && code[i]!==transpilerConfig.preprocessorDelimiter) || 
+			code[i-1]==='\\') 
+	{
+		i++;
+	}
+
+	const is_exp = code[i]===transpilerConfig.preprocessorDelimiter;
+
+	if(is_exp) {
+		const b = {
+			type: "directive",
+			begin: index,
+			cbegin: index,
+			end: i+1,
+
+			expression: code.slice(index+1,i).replace(/\\(.)/gs, '$1'),
+			value: ''
+		};
+
+		if(container) container.children.push(b);	
+		return b;
+
+	}
+	else {
+		let j=index;
+
+		while(j-->=0 && (code[j]===' ' || code[j]==='\t'));
+		const is_first = j===-1 || code[j]==='\n';
+
+		if(is_first) {
+			const b = {
+				type: "directive",
+				begin: index,
+				cbegin: index,
+				end: i+1,
+
+				pragma: code.slice(index+1,i+1).replace(/\\(.)/gs, '$1'),
+				value: ''
+			};
+			if(container) container.children.push(b);	
+			return b;
+		}
+	}
+
+	raiseError('error in preprocessor statement.')
+}
+
+
+// note: pragma blocks should begin and end in same block main trunk (not its children).
+// note: preprocessor code must be JS, not JSX.
+
+function preprocessPragmas(node, context)
+{
+	const all_nodes = [];
+
+	var segments = ["const {" + Object.keys(jsxAddons).join(', ') + "} = transpilerConfig.addons;"];
+
+	var scope_stack = [];
+	var last_block = null;
+
+	const clone_block = (i, val)=>{ 
+		last_block = typeof(all_nodes[i])==='object'? 
+						structuredClone(
+								{ ...all_nodes[i], children: undefined, attributes: {} }
+							)
+						:all_nodes[i];
+
+		if(last_block.type==='directive') {
+			last_block.value = val;
+		}
+
+		scope_stack[0].out ??= [];
+		scope_stack[0].out.push(last_block);
+
+		return last_block;
+	};
+
+	const clone_attr = (i, name)=>{ 
+		last_block = typeof(all_nodes[i])==='object'? 
+						structuredClone(
+								{ ...all_nodes[i], children: undefined, attributes: {} }
+							)
+						:all_nodes[i];
+
+		scope_stack[0].attributes[name] = last_block;
+
+		return last_block;
+	};
+
+	const push_scope = ()=>{ scope_stack = [last_block, scope_stack]; };
+	const pop_scope = ()=>{ scope_stack = scope_stack[1]; };
+
+	const vine_traverse = (nd)=> {
+		
+		if(typeof(nd)!=='object') return segments;
+
+		segments.push(`push_scope();`);
+
+		if(nd.attributes) {
+			for(const attr in nd.attributes) {
+				const ch = nd.attributes[attr];
+
+				all_nodes.push(ch);
+
+				segments.push(`clone_attr(${all_nodes.length-1}, "${attr}");`);
+				vine_traverse(ch);
+
+			}
+		}
+		if(nd.children) {
+			for(const ch of nd.children) {
+				all_nodes.push(ch);
+
+				if(ch.type==='directive' && ch.expression===undefined) {
+					segments.push(ch.pragma);
+				}
+				else {
+					if(ch.expression)
+						segments.push(`clone_block(${all_nodes.length-1}, ${ch.expression});`);
+					else
+						segments.push(`clone_block(${all_nodes.length-1});`);
+					vine_traverse(ch);
+				}
+			}
+		}
+
+		segments.push(`pop_scope();`);
+
+		return segments;
+	}
+
+
+	node.out = [];
+	last_block = node;
+	push_scope();
+	vine_traverse(node);
+
+	const cmd = segments.join('\n');
+	eval(cmd);
+
+	return segments;
+}
+
+
+function parseString(code, index, q, container)
+{
+	const b = {
+		type: "string",
+		begin: index++,
+		cbegin: index
+	};
+
+	while(index<code.length) {
+
+		const ch = code[index];
+
+		switch(ch) {
+
+		case q:
+			b.cend=index;
+			b.end=index+1;
+			if(container) container.children.push(b);
+			return b;
+
+		case '\n':
+			if(q!=='\`') raiseError(`unterminated string`, index);
+			break;
+
+		case '$':
+			if(q==='`') {
+				index++;
+				if(code[index]==='{') {
+					[index] = lookAhead( parseJS, code, index, true, container );
+					index--;
+				}
+			}
+			break;
+
+		case '\\':
+			index++;
+			break;
+		}
+
+		index++;
+	}
+
+	raiseError(`unterminated string`, index);
+}
+
+
+function parseXMLContent(code, index, container, eols)
+{
+	let i = index;
+	let cur = index;
+
+	while(i<code.length) {
+		switch(code[i]) {
+
+		case '<':
+			if(code[i+1]==='/') {
+
+				i+=2;
+
+				let j=i;
+
+				while(j<code.length && code[j]!=='>') {
+					j++;
+				}
+
+				if(j===code.length) {
+					return null; //throw `ill-formed xml (slash) ${j}`;
+				}
+
+				const tag = code.substring(i,j).trim();
+
+				if(container.tag!==tag) {
+					throw `ill-formed xml (close tag) [${container.tag},${tag}] ${j}`;
+				}
+
+				container.end = j+1;
+
+				container.cbegin = index+1; // content begin index
+				container.cend = i-2; // content end index
+
+				return j;
+			}
+			else {
+				[i] = lookAhead( parseXML, code, i, container );
+
+				if(i>cur) {
+					cur = i;
+					i--;
+				}
+				else cur++;
+				
+			}
+			break;
+
+		case '{':
+			const j=i;
+			[i] = lookAhead( parseJS, code, i, true, container );
+			i--;
+			break;
+
+		}
+		i++;
+	}
+
+	return cur;
+}
+
+
+function parseXML(code, index, container)
+{
+	// delimiters
+	const delims =  [ ' ','\t','\n', '/','&','^','%','|','!','~','+','*','?',
+					'<','>',';',',','=','{','}','(',')','[',']','\'','\"',
+					'\`', '\\', '', undefined ]; 
+
+	const skip_spaces = 
+		()=> { while( code[index]===' ' || code[index]==='\t'  || code[index]==='\n' ) index++; };
+
+	const b = { // block
+		type: "xml",
+		begin: index++,
+		children: [],
+		attributes: {},
+		self_closing: false,
+		js_attributes: []
+	};
+
+	skip_spaces();
+	
+	let i = index;
+	while(i<code.length && delims.indexOf(code[i])===-1) i++;
+	if(i===code.length) return;
+
+	b.tag = code.substring(index,i);
+
+	index = i;
+
+
+	let last_attr = undefined;
+
+	while(index<code.length) {
+		i = index;
+
+		while( i<code.length && delims.indexOf(code[i])===-1 ) {
+			i++;
+		}
+		if(i===code.length) return;
+
+		const tok = code.substring(index,i);
+		if(tok.length) {
+			last_attr = tok;
+			b.attributes[tok] = true;
+		}
+
+		index = i;
+
+		switch(code[index]) {
+
+		case '=':
+
+			if(last_attr) {
+				index++;
+				skip_spaces();
+
+				if(code[index]==='/') { // todo: comment after =, should be tested
+					[i] = lookAhead( parseComment, code, index );
+					if(i>index) index = i;
+					else index++;
+				}
+
+				let av; // attribute value
+
+				switch(code[index]) {
+				case '\'':
+				case '\"':
+					//case '\`':
+					[index, av] = lookAhead( parseString, code, index, code[index] );
+					b.attributes[last_attr] = av;
+					last_attr = undefined;
+					break;
+
+				case '{':
+					[index, av] = lookAhead( parseJS, code, index, true );
+					b.attributes[last_attr] = av;
+					last_attr = undefined;
+					break;					
+
+				default: 
+					{
+						i = index;
+						while( i<code.length && delims.indexOf(code[i])===-1 ) {
+							i++;
+						}
+
+						if(i===code.length) {
+							return; // not xml
+						}
+
+						const tok = code.substring(index,i);
+						index = i;
+
+						b.attributes[last_attr] = tok;
+						last_attr = undefined;
+					}
+				}
+			}
+			else {
+				//console.log(`ill-formed xml (attribute)`, index);
+				return; // not xml
+			}
+
+			break;
+
+		case '{':
+			let jsc;
+			[index, jsc] = lookAhead( parseJS, code, index, true );
+			jsc.is_xml_js = true;
+			b.js_attributes.push(jsc);
+			break;					
+
+		case '/':
+			if(code[index+1]==='>') {
+				b.end = index+2;
+				b.cbegin = b.begin;
+				b.cend = b.end;
+
+				//b.children = undefined;
+				b.self_closing = true;
+
+				if(container) container.children.push(b);
+				return b;
+			}
+
+			[i] = lookAhead( parseComment, code, index );
+			if(i>index) index = i;
+			else index++;
+
+			break;
+
+		case '>':
+			const i = parseXMLContent(code, index, b);
+
+			// not xml
+			// todo: side effects must be checked
+			if(i===null) return;
+
+			if(i>index) index = i;
+			else index++;
+
+			if(b.end) {
+				if(container) container.children.push(b);
+				return b;
+			}
+			else {
+				index++;
+			}
+			break;
+
+		case ' ':
+		case '\t':
+		case '\n':
+			skip_spaces();
+			break;
+
+		default:
+			return;
+
+		}
+	}
+}
+
+
+function parseParanthesis(code, index, container)
+{
+	const b = { // block
+		type: "paranthesis",
+		begin: index,
+		cbegin: ++index,
+		children: [],
+		self_closing: false
+	};
+
+	while(index<code.length) {
+		const ch = code[index];
+
+		switch(ch) {
+
+		case '<':{
+			let [i] = lookAhead( parseXML, code, index, b );
+			if(i>index) index = i;
+			else index++;
+			break;
+		}
+		case '\"':
+		case '\'':
+		case '\`': 
+			[index] = lookAhead( parseString, code, index, ch );
+			break;
+
+		case '{':
+			[index] = lookAhead( parseJS, code, index, true, b );
+			break;
+
+		case '(':
+			[index] = lookAhead( parseParanthesis, code, index, b );
+			break;
+
+		case '}':
+			raiseError(`unmatched curly bracket`, index);
+			break;
+
+		case ')':
+			b.end = index+1;
+			b.cend = index;
+			if(container) container.children.push(b);
+			return b;
+
+		case '/':
+			const [i] = lookAhead( parseComment, code, index, b );
+			if(i>index) index = i;
+			else index++;
+			break;
+
+		case '\\':
+			index++;
+		default:
+			index++;
+			break;
+		}
+	}
+
+	raiseError(`unterminated paranthesis block (started at ${b.begin})`, index);
+}
+
+
+function parseJS(code, index=0, is_block=false, container)
+{
+	const b = { // block
+		type: "js",
+		begin: index,
+		cbegin: index+=(is_block?1:0),
+		children: []
+	};
+
+	while(index<code.length) {
+		const ch = code[index];
+
+		switch(ch) {
+
+		case '<': {
+			let [i] = lookAhead( parseXML, code, index, b );
+
+			if(i>index) index = i;
+			else index++;
+			break;
+		}
+
+		case '\"':
+		case '\'':
+		case '\`': 
+			[index] = lookAhead( parseString, code, index, ch );
+			break;
+
+		case '{':  {
+			const i = index;
+			[index] = lookAhead( parseJS, code, index, true, b );
+			break;
+		}
+
+		case '(': // this is only for function detection
+			[index] = lookAhead( parseParanthesis, code, index, b );
+			break;
+
+		case ')': // this is only for function detection
+			raiseError(`unmatched paranthesis ${index} [from ${b.begin}]`, index);
+			break;
+
+		case '}':
+			if(is_block) {
+				b.end = index+1;
+				b.cend = index;
+				if(container) container.children.push(b);
+				return b;
+			}
+			raiseError(`unmatched curly bracket`, index);
+			break;
+
+		case '/':
+			{
+				let [i] = lookAhead( parseComment, code, index, b );
+				if(i>index) index = i;
+				else index++;
+				break;
+			}
+
+		case transpilerConfig.preprocessorDelimiter:
+			{
+				let [i] = lookAhead( parseDirective, code, index, b );
+				if(i>index) index = i;
+				else index++;
+				break;
+			}
+
+		case '\\':
+			index++;
+
+		default:
+			index++;
+		}
+	}
+
+	if(is_block) raiseError(`unterminated js block at ${index} (started at ${b.begin})`);
+
+	b.end = index;
+	b.cend = index;
+	if(container) container.children.push(b);
+	return b;
+}
+
+
+// this is for lilact internal use, it is a workaround for approximating error location
+// in eval when transpiling and running jsx directly in browser.
+
+function labelFunctions(node, eols)
+{
+
+	node.already_labeled = true;
+
+	function getNext(i, step=1)
+	{
+		while( (i+=step) < node.children.length && i>=0) {
+			const ch = node.children[i];
+
+			if(typeof(ch)==='string') {
+				const t = ch.trim();
+				if(t.length) return [i, t];
+			}
+			if(typeof(ch)==='object' && ch.type!=='comment') {
+				return [i,ch];
+			}
+		}
+		return [null,null];
+	}
+
+	let i, nxt, prev;
+	for(let chi=0; chi<node.children.length; chi++) {
+
+		if(typeof(node.children[chi])==='object' && node.children[chi].type==='paranthesis') {
+
+			[i, prev] = getNext(chi, -1);
+			if(prev===null) continue;
+
+			if(typeof(prev)!=='string' || ['switch', 'catch', 'try', 'class'].find((x)=>prev.trim().endsWith(x))!==undefined) continue;
+			let label = prev;
+
+			[i, prev] = getNext(i, -1);
+			if(prev===null) continue;
+			if(typeof(prev)==='string' && ['extern', 'class'].indexOf(prev)!==-1) continue;
+
+
+			[i, nxt] = getNext(chi);
+
+			if(nxt===null) continue;
+
+			if(transpilerConfig.injectTraceLabels && typeof(nxt)==='object' && nxt.type==='js') {
+				const begin = getRowCol(eols, chi); // begin is always the location of function args paranthesis
+				nxt.children.splice(1,0, `/*LILACTBLOCK${++transpilerConfig.func_num}:${begin}:${label}*/try{`);
+				if(transpilerConfig.enableLabelStack) {
+					nxt.children.splice(nxt.children.length-1, 0, `} catch(e){ if(typeof(e)!=='object') e=new Error(e);e.lilact_trace=[${transpilerConfig.func_num},e.lilact_trace];throw e}`);
+				}
+				else {
+					nxt.children.splice(nxt.children.length-1, 0, `} catch(e){ if(typeof(e)!=='object') e=new Error(e);e.lilact_trace=${transpilerConfig.func_num};throw e}`);
+				}
+				chi += 2;				
+			}
+		}
+
+		else if(node.children[chi]==='=>') {
+			[i, prev] = getNext(chi, -1);
+
+			if(typeof(prev)==='object' && prev.type==='paranthesis') {
+
+				const begin = getRowCol(eols, prev.begin); // begin is always the location of function args paranthesis
+
+				[i, nxt] = getNext(chi);
+
+				if(typeof(nxt)==='object' && nxt.type==='js') {
+
+					if(transpilerConfig.injectTraceLabels) {
+
+						nxt.children.splice(1,0, 
+							`/*LILACTBLOCK${++transpilerConfig.func_num}:${begin}:<ARROW>*/try {`);
+
+						if(transpilerConfig.enableLabelStack) {
+							nxt.children.splice(nxt.children.length-1, 0, 
+								`} catch(e){if(typeof(e)!=='object') e=new Error(e);e.lilact_trace=[${transpilerConfig.func_num},e.lilact_trace];throw e}`);
+						}
+						else {
+							nxt.children.splice(nxt.children.length-1, 0, 
+								`} catch(e){if(typeof(e)!=='object') e=new Error(e);e.lilact_trace=${transpilerConfig.func_num};throw e}`);
+						}
+
+					}					
+					chi += 2;
+				}
+			}
+		}
+
+	}			
+
+}
+
+function scanEOLs(code)
+{
+	const endlines = [0];
+
+	for(let i in code) {
+		if(code[i]==='\n') {
+			endlines.push(parseInt(i));
+		}
+	}
+	endlines.push(code.length);
+
+	return endlines;
+}
+
+function getRowCol(eols, i)
+{
+	if(!eols.last) eols.last=1;
+
+	while(i>eols[eols.last]) {
+		eols.last++;
+		if(eols.last===eols.length) {
+			eols.last=eols.length-1;
+			break;
+		}
+	}
+	while(i<eols[eols.last-1] && eols.last>1) {
+		eols.last--;
+	}
+
+	return [eols.last-1, i-eols[eols.last-1]];
+}
+
+
+function generateSourceMap(json, path, jsx_eols, out_eols, mappings=[])
+{
+	let mpps = [];
+
+	const sourcemap = {
+		"version":3,
+		"file":path,
+		"sourceRoot":"",
+		"sources":[path],
+		"names":[],
+		"mappings":""
+	};
+
+
+	const scan_leaves = (node)=>{
+		if(!!node.children) {
+
+			for(const ch of node.children) {
+				scan_leaves(ch);
+			}
+		}
+		if(node.begin!==undefined && node.out_index!==undefined) {
+			mpps.push( [ ...getRowCol(out_eols,node.out_index), ...getRowCol(jsx_eols,node.begin), node ] );
+		}
+	}
+
+	scan_leaves(json);
+
+	mpps = mpps.sort( 	(a,b)=>{ 
+		if (a[0] == b[0]) {
+			return a[1] - b[1];
+		}
+		return a[0] - b[0];
+	}
+	);
+
+	mappings.push(...mpps);
+
+	let mstr = "";
+	let r=0, oc=0;
+
+	let lr = 0, lc=0;
+
+	for(let i=0; i<mpps.length;i++) {
+		const m = mpps[i];
+
+		while(r<m[0]) {
+			oc=0;
+			mstr+=(";");
+			r++;
+		}
+
+		mstr+=',';
+
+		mstr+=( vlq.encode(m[1]-oc,0,m[2]-lr,m[3]-lc) );
+
+		oc = m[1];
+		lr = m[2];
+		lc = m[3];
+	}
+
+	sourcemap.mappings = mstr.substring(1).replace(/;,/g, ";"); 
+
+	return "\n\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,"+btoa(JSON.stringify(sourcemap));
+
+}
+
+
+/**
+ * This is the function that transpiles jsx code to js. It is not recommended to use directly.
+ * 
+ * Use `Lilact.require` instead, or `Lilact.run` available in `run`, or add a `<scirpt type="text/jsx" .../>` to your html.
+ * 
+ * Lilact jsx parser doesn't rely on the Lilact itself, and can be used by other engines. The easiest way
+ * is using the `bin/transpile.js` script. It has its own help.
+ *
+ * @returns The transpiled javascript code.
+ */
+
+export function transpileJSX( jsx, { 
+	factory = "Lilact.createComponent", 
+	path = "anonymous", 
+	appendSourcemap = true,
+	mappings = [], 
+	injectTraceLabels = false,
+	discardComments = false
+} = {} )
+{
+
+	// func_num is shared so consecutive transpilations create new ids each time.
+	transpilerConfig.func_num ??= 0;
+	transpilerConfig.preprocessorDelimiter ??= 'ʔ'; // alt+shift+. on apple abc extended layout  
+	
+	transpilerConfig.injectTraceLabels ??= injectTraceLabels; // alt+shift+. on apple abc extended layout  
+
+	const eols = scanEOLs(jsx);
+
+	raiseError = ((eols, msg, index)=>{
+		const er = new Error(msg);
+		er.name = 'JSXParseError';
+		[er.lineNumber, er.columnNumber] = getRowCol(eols, index);
+		er.lilact_trace = 'parse';
+		throw er;
+	}).bind(null, eols);
+
+	const tokenize_re = /([\{\}\(\),;\[\]\n]|[\s^\n]+)/g; 
+
+	const json = parseJS(jsx);
+	json.data = jsx;
+
+	const prepare = (node)=>{
+
+		if(node.attributes!==undefined) {
+			for(const attr in node.attributes) {
+				if(typeof(node.attributes[attr])==='object') {
+					prepare(node.attributes[attr]);
+				}
+			}
+		}
+
+		if(node.children!==undefined && !node.self_closing) {
+
+			let i = node.type==='js'? node.begin : (node.cbegin || node.begin);
+			for(let chi=0; chi<node.children.length; chi++) {
+				const ch = node.children[chi];
+
+				if(ch.begin>i) {
+					let s = jsx.substring(i, ch.begin);
+
+					if(node.type==='xml') s = s.trim();
+					if(s.length) {
+						if(node.type==='xml') {
+							node.children.splice(chi, 0, '"'+s.replaceAll("\n", "\\\n")+'"');
+						}
+						else {
+							node.children.splice(chi, 0, ...s.split(tokenize_re)); 
+						}
+						chi++;
+					}
+				}
+				i = ch.end;
+
+				prepare(ch);
+			}
+
+			const e = node.type==='js'? node.end : (node.cend || node.end);
+
+			if(i<e && !node.self_closing) {
+				let s = jsx.substring(i, e);
+				if(node.type==='xml') s = s.trim();
+				if(s.length) {
+					if(node.type==='xml') {
+						node.children.push( '"'+s.replaceAll("\n", "\\\n")+'"' );
+					}
+					else {
+						node.children.push( ...s.split(tokenize_re) );
+					}
+				}
+			}
+
+			node.children = node.children.filter( (x)=>x!=="" );
+
+			if(transpilerConfig.setFunctionLabels && !node.already_labeled) {
+				labelFunctions(node,eols);
+			}
+		}
+	}
+
+	prepare(json);
+
+	preprocessPragmas(json);
+
+	const codify = (outlen, node, is_attr=false, is_xml=false)=> {
+
+		if(typeof(node)!=='object') return node;
+
+		node.out_index = outlen;
+
+		if(node.type==='string') return jsx.substring(node.begin, node.end);
+		if(node.type==='regex') return jsx.substring(node.begin, node.end);
+		if(node.type==='comment') return (discardComments || is_attr)?'':jsx.substring(node.begin, node.end);
+		if(node.type==='directive') return node.value;
+
+
+		if(node.type==='paranthesis') {
+			let out = "(";
+
+			if(node.out) {
+				for(const ch of node.out) {
+					out+=codify(outlen+out.length-1, ch);
+				}
+			}
+			return out + ")";
+		}
+
+		if(node.type==='js') {
+			let out = "";
+
+			if(node.out) {
+				for(const ch of node.out) {
+					if(is_xml && ch.type==='comment') continue;
+					out+=codify( outlen + out.length - (is_attr?1:0), ch);
+				}
+			}
+
+			if(is_attr) {
+				return out.substring(1, out.length-1);
+			}
+
+			// todo: this is very simple, it should parse recursively
+			if(node?.is_xml_js) {
+				return jsx.substring(node.begin+1, node.end-1);
+			}
+
+			return out;
+		}
+
+		if(node.type==='xml') {
+
+			if(node.tag.length===0) {
+				node.tag = "null";
+			}
+			else if(node.tag[0]!==node.tag[0].toUpperCase()) {
+				node.tag = `"${node.tag}"`;
+			}
+
+			let out = '';
+
+
+			let is_first=true;
+
+			for(const a of node.js_attributes) {
+				let oo = codify(outlen + out.length, a, false);
+
+				out+=`${is_first?'':', '}${oo}`
+				is_first=false;
+			}
+
+
+			if(node.attributes) {
+				for(const a in node.attributes) {
+					out+=`${is_first?'':', '}"${a}": ${codify(outlen + out.length, node.attributes[a], true)}`
+					is_first=false;
+				}
+			}
+
+			out+=" }";
+
+			if(node.out) {
+				for(const ch of node.out) {
+					const o = codify(outlen + out.length, ch, true, true);
+					if(o.length>0) {
+						out+=`, ${o}`
+						is_first=false;
+					}
+				}
+			}
+
+			const loc = getRowCol(eols,node.begin);
+			out = `${factory}( ${node.tag}, { ${out} )`; //lilact_jsx_loc:["${path}", ${loc}]
+
+			return out;
+		}
+	}
+
+	let out = '';
+	if(injectTraceLabels) {
+		out=`/*LILACTBLOCK${++transpilerConfig.func_num}:0,0:<EXEC>*/try{`
+
+		transpilerConfig.func_labels[transpilerConfig.func_num] = {
+			path,
+			row: 1,
+			col: 1,
+			label: transpilerConfig.func_num,
+			required: transpilerConfig.required[path]
+		};
+
+	}
+	out+=codify(0, json);
+
+	if(injectTraceLabels) {
+		if(transpilerConfig.enableLabelStack) {
+			out += `}catch(e){ if(typeof(e)!=='object') e=new Error(e);e.lilact_trace=[${transpilerConfig.func_num},e.lilact_trace];throw e}`;
+		}
+		else {
+			out += `}catch(e){ if(typeof(e)!=='object') e=new Error(e);e.lilact_trace=${transpilerConfig.func_num};throw e}`;
+		}
+	}
+
+	const inline_sm = generateSourceMap(json, path, eols, scanEOLs(out), mappings);
+	if(appendSourcemap) {
+		out += inline_sm;
+	}
+
+	if(globalThis[TRANSPILER_OUTPUT]) {
+		try {
+			const fs = import('fs');
+			fs.writeFileSync(globalThis[TRANSPILER_OUTPUT], out);	
+		}
+		catch(e) {}
+		globalThis[TRANSPILER_OUTPUT] = undefined;
+	}
+	//console.log(out);
+
+	return out;
+}
+