funcity 1.3.0 → 1.5.0

package/dist/compile-cache-D9XyNhoC.cjs

@@ -0,0 +1,4869 @@
+/*!
+ * name: funcity
+ * version: 1.5.0
+ * description: A functional language interpreter with text processing
+ * author: Kouji Matsui (@kekyo@mi.kekyo.net)
+ * license: MIT
+ * repository.url: https://github.com/kekyo/funcity
+ * git.commit.hash: e583c1a43f3a2b29f8bbbb7b7ad0cc199b0a0fca
+ */
+
+/*!
+* name: funcity
+* version: 1.5.0
+* description: A functional language interpreter with text processing
+* author: Kouji Matsui (@kekyo@mi.kekyo.net)
+* license: MIT
+* repository.url: https://github.com/kekyo/funcity
+* git.commit.hash: e583c1a43f3a2b29f8bbbb7b7ad0cc199b0a0fca
+*/
+const require_node = require("./node.cjs");
+//#region \0@oxc-project+runtime@0.121.0/helpers/typeof.js
+function _typeof$1(o) {
+	"@babel/helpers - typeof";
+	return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof$1(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.121.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof$1(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof$1(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.121.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof$1(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.121.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region src/types.ts
+/**
+* Reducer running error.
+*/
+var FunCityReducerError = class FunCityReducerError extends Error {
+	constructor(info) {
+		super(info.description);
+		_defineProperty(
+			this,
+			/**
+			* Error information.
+			*/
+			"info",
+			void 0
+		);
+		this.name = "FunCityReducerError";
+		this.info = info;
+		Object.setPrototypeOf(this, FunCityReducerError.prototype);
+	}
+};
+//#endregion
+//#region src/tokenizer.ts
+var createRange = (context, start, end) => ({
+	sourceId: context.sourceId,
+	start,
+	end
+});
+/**
+* Tokenize the string value.
+* @param context Tokenizer context
+* @returns String token
+*/
+var stringEscapeMap = {
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	",
+	v: "\v",
+	"0": "\0",
+	"'": "'",
+	"\"": "\"",
+	"`": "`",
+	"{": "{",
+	"}": "}",
+	"\\": "\\"
+};
+var tokenizeString = (context, quoteSymbol) => {
+	const start = context.cursor.location("start");
+	context.cursor.skip(quoteSymbol.length);
+	let value = "";
+	let templateTokens;
+	let textStart;
+	const appendText = (text, startLocation) => {
+		if (value.length === 0) textStart = startLocation !== null && startLocation !== void 0 ? startLocation : context.cursor.location("start");
+		value += text;
+	};
+	const flushTextToken = () => {
+		if (!templateTokens || value.length === 0 || !textStart) return;
+		templateTokens.push({
+			kind: "text",
+			text: value,
+			range: createRange(context, textStart, context.cursor.location("end"))
+		});
+		value = "";
+		textStart = void 0;
+	};
+	let closed = false;
+	while (!context.cursor.eot()) {
+		if (context.cursor.assert(quoteSymbol)) {
+			if (templateTokens) flushTextToken();
+			context.cursor.skip(quoteSymbol.length);
+			closed = true;
+			break;
+		}
+		if (context.cursor.assert("{{")) {
+			if (!templateTokens) templateTokens = [];
+			flushTextToken();
+			const tokens = tokenizeCodeBlock(context);
+			templateTokens.push(...tokens);
+			continue;
+		}
+		const ch = context.cursor.getChar();
+		if (ch === "\\") {
+			const escapeStart = context.cursor.location("start");
+			context.cursor.skip(1);
+			if (context.cursor.eot()) {
+				context.logs.push({
+					type: "error",
+					description: "invalid escape sequence: \\\\",
+					range: createRange(context, escapeStart, context.cursor.location("end"))
+				});
+				appendText("\\", escapeStart);
+				break;
+			}
+			const escape = context.cursor.getChar();
+			const mapped = stringEscapeMap[escape];
+			if (mapped !== void 0) {
+				appendText(mapped, escapeStart);
+				context.cursor.skip(1);
+				continue;
+			}
+			context.cursor.skip(1);
+			context.logs.push({
+				type: "error",
+				description: `invalid escape sequence: \\${escape}`,
+				range: createRange(context, escapeStart, context.cursor.location("end"))
+			});
+			appendText(`\\${escape}`, escapeStart);
+			continue;
+		}
+		appendText(ch);
+		context.cursor.skip(1);
+	}
+	if (!closed) {
+		const location = context.cursor.location("start");
+		context.logs.push({
+			type: "error",
+			description: "string close quote is not found",
+			range: createRange(context, location, location)
+		});
+	}
+	if (templateTokens) {
+		flushTextToken();
+		return {
+			kind: "template",
+			tokens: templateTokens,
+			range: createRange(context, start, context.cursor.location("end"))
+		};
+	}
+	return {
+		kind: "string",
+		value,
+		range: createRange(context, start, context.cursor.location("end"))
+	};
+};
+var firstNumericChars = "0123456789-+";
+var numericCharsWithDot = "0123456789.";
+var numericChars = "0123456789";
+/**
+* Tokenize the number (numeric) value.
+* @param context Tokenizer context
+* @returns Number token
+*/
+var tokenizeNumber = (context) => {
+	const start = context.cursor.location("start");
+	let index = 1;
+	while (true) {
+		if (context.cursor.eot()) return {
+			kind: "number",
+			value: Number(context.cursor.getRangeAndSkip(index)),
+			range: createRange(context, start, context.cursor.location("end"))
+		};
+		const ch = context.cursor.getChar(index);
+		if (numericCharsWithDot.indexOf(ch) < 0) {
+			if (ch === ".") break;
+			return {
+				kind: "number",
+				value: Number(context.cursor.getRangeAndSkip(index)),
+				range: createRange(context, start, context.cursor.location("end"))
+			};
+		}
+		index++;
+	}
+	while (true) {
+		if (context.cursor.eot()) return {
+			kind: "number",
+			value: Number(context.cursor.getRangeAndSkip(index)),
+			range: createRange(context, start, context.cursor.location("end"))
+		};
+		const ch = context.cursor.getChar(index);
+		if (numericChars.indexOf(ch) < 0) return {
+			kind: "number",
+			value: Number(context.cursor.getRangeAndSkip(index)),
+			range: createRange(context, start, context.cursor.location("end"))
+		};
+		index++;
+	}
+};
+var firstVariableChars = "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var variableChars = "_-?0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+/**
+* Tokenize the identity (variable name).
+* @param context Tokenizer context
+* @returns Identity token
+*/
+var tokenizeIdentity = (context) => {
+	const start = context.cursor.location("start");
+	let index = 1;
+	while (true) {
+		if (context.cursor.eot()) break;
+		const ch = context.cursor.getChar(index);
+		if (variableChars.indexOf(ch) < 0) break;
+		if (ch === "?") {
+			if (context.cursor.getChar(index + 1) === ".") break;
+			index++;
+			break;
+		}
+		index++;
+	}
+	return {
+		kind: "identity",
+		name: context.cursor.getRangeAndSkip(index),
+		range: createRange(context, start, context.cursor.location("end"))
+	};
+};
+var tokenizeCodeTokens = (context, stopOnClose, finalizeUnknownOnEot, closeSymbol = "}}") => {
+	const tokens = [];
+	let unknownStartLocation;
+	const finalizeUnknown = () => {
+		if (unknownStartLocation) {
+			context.logs.push({
+				type: "warning",
+				description: "unknown words",
+				range: createRange(context, unknownStartLocation, context.cursor.location("end"))
+			});
+			unknownStartLocation = void 0;
+		}
+	};
+	while (!context.cursor.eot()) {
+		if (stopOnClose && context.cursor.assert(closeSymbol)) {
+			finalizeUnknown();
+			return {
+				tokens,
+				closed: true
+			};
+		}
+		const ch = context.cursor.getChar();
+		if (ch === "\\") {
+			const next = context.cursor.getChar(1);
+			if (next === "\n") {
+				context.cursor.skip(2);
+				continue;
+			}
+			if (next === "\r" && context.cursor.getChar(2) === "\n") {
+				context.cursor.skip(3);
+				continue;
+			}
+			if (next === "{" || next === "}") {
+				context.cursor.skip(2);
+				continue;
+			}
+		}
+		if (ch === "/" && context.cursor.getChar(1) === "/") {
+			finalizeUnknown();
+			context.cursor.skip(2);
+			while (!context.cursor.eot()) {
+				const commentCh = context.cursor.getChar();
+				if (commentCh === "\n" || commentCh === "\r") break;
+				context.cursor.skip(1);
+			}
+			continue;
+		}
+		if (ch === "'" || ch === "\"" || ch === "`") {
+			finalizeUnknown();
+			let quoteCount = 1;
+			while (context.cursor.getChar(quoteCount) === ch) quoteCount++;
+			const quoteLength = quoteCount >= 3 ? quoteCount : 1;
+			tokens.push(tokenizeString(context, ch.repeat(quoteLength)));
+		} else if (firstNumericChars.indexOf(ch) >= 0) {
+			finalizeUnknown();
+			tokens.push(tokenizeNumber(context));
+		} else if (ch === "(") {
+			finalizeUnknown();
+			const location = context.cursor.location("start");
+			tokens.push({
+				kind: "open",
+				symbol: "(",
+				range: createRange(context, location, location)
+			});
+			context.cursor.skip(1);
+		} else if (ch === ")") {
+			finalizeUnknown();
+			const location = context.cursor.location("start");
+			tokens.push({
+				kind: "close",
+				symbol: ")",
+				range: createRange(context, location, location)
+			});
+			context.cursor.skip(1);
+		} else if (ch === "[") {
+			finalizeUnknown();
+			const location = context.cursor.location("start");
+			tokens.push({
+				kind: "open",
+				symbol: "[",
+				range: createRange(context, location, location)
+			});
+			context.cursor.skip(1);
+		} else if (ch === "]") {
+			finalizeUnknown();
+			const location = context.cursor.location("start");
+			tokens.push({
+				kind: "close",
+				symbol: "]",
+				range: createRange(context, location, location)
+			});
+			context.cursor.skip(1);
+		} else if (ch === "?" && context.cursor.getChar(1) === ".") {
+			finalizeUnknown();
+			const start = context.cursor.location("start");
+			context.cursor.skip(2);
+			tokens.push({
+				kind: "dot",
+				optional: true,
+				range: createRange(context, start, context.cursor.location("end"))
+			});
+		} else if (ch === ".") {
+			finalizeUnknown();
+			const location = context.cursor.location("start");
+			tokens.push({
+				kind: "dot",
+				optional: false,
+				range: createRange(context, location, location)
+			});
+			context.cursor.skip(1);
+		} else if (firstVariableChars.indexOf(ch) >= 0) {
+			finalizeUnknown();
+			tokens.push(tokenizeIdentity(context));
+		} else if (ch === "\n") {
+			finalizeUnknown();
+			const location = context.cursor.location("start");
+			tokens.push({
+				kind: "eol",
+				source: "newline",
+				range: createRange(context, location, location)
+			});
+			context.cursor.skip(1);
+		} else if (ch === ";") {
+			finalizeUnknown();
+			const location = context.cursor.location("start");
+			tokens.push({
+				kind: "eol",
+				source: "semicolon",
+				range: createRange(context, location, location)
+			});
+			context.cursor.skip(1);
+		} else if (ch === "\r") {
+			finalizeUnknown();
+			context.cursor.skip(1);
+		} else if (ch === " ") {
+			finalizeUnknown();
+			context.cursor.skip(1);
+		} else {
+			if (!unknownStartLocation) unknownStartLocation = context.cursor.location("start");
+			context.cursor.skip(1);
+		}
+		context.cursor.skipChars(" ");
+	}
+	if (finalizeUnknownOnEot) finalizeUnknown();
+	return {
+		tokens,
+		closed: false
+	};
+};
+/**
+* Tokenize code block.
+* @param context Tokenizer context
+* @returns The token list
+*/
+var tokenizeCodeBlock = (context) => {
+	const openStart = context.cursor.location("start");
+	let openCount = 0;
+	while (context.cursor.getChar(openCount) === "{") openCount++;
+	const openSymbol = "{".repeat(openCount);
+	const closeSymbol = "}".repeat(openCount);
+	context.cursor.skip(openCount);
+	const tokens = [{
+		kind: "open",
+		symbol: openSymbol,
+		range: createRange(context, openStart, context.cursor.location("end"))
+	}];
+	const result = tokenizeCodeTokens(context, true, false, closeSymbol);
+	tokens.push(...result.tokens);
+	if (result.closed) {
+		const location = context.cursor.location("start");
+		context.cursor.skip(openCount);
+		tokens.push({
+			kind: "close",
+			symbol: closeSymbol,
+			range: createRange(context, location, context.cursor.location("end"))
+		});
+		return tokens;
+	}
+	const causeLocation = context.cursor.location("start");
+	context.logs.push({
+		type: "error",
+		description: `required code block closer: \`${closeSymbol}\``,
+		range: createRange(context, causeLocation, causeLocation)
+	});
+	return tokens;
+};
+/**
+* Create a tonenizer cursor.
+* @param script - Input script text
+* @returns Tonenizer cursor
+*/
+var createTokenizerCursor = (script) => {
+	let currentIndex = 0;
+	let rawLine = 0;
+	let rawColumn = 0;
+	let lastLine = 0;
+	let lastColumn = 0;
+	const eot = () => currentIndex >= script.length;
+	const getChar = (index) => script[(index !== null && index !== void 0 ? index : 0) + currentIndex];
+	const skip = (length) => {
+		let lastch = "\0";
+		while (length > 0) {
+			lastColumn = rawColumn;
+			lastLine = rawLine;
+			const ch = script[currentIndex];
+			if (ch === "\r") {
+				rawColumn = 0;
+				rawLine++;
+			} else if (ch === "\n") {
+				rawColumn = 0;
+				if (lastch !== "\r") rawLine++;
+			} else rawColumn++;
+			currentIndex++;
+			length--;
+			lastch = ch;
+		}
+	};
+	const skipChars = (ch) => {
+		while (!eot()) {
+			if (getChar() !== ch) return true;
+			skip(1);
+		}
+		return false;
+	};
+	const skipUntil = (word) => {
+		while (!eot()) {
+			if (script.indexOf(word, currentIndex) === currentIndex) {
+				skip(word.length);
+				return true;
+			}
+			skip(1);
+		}
+		return false;
+	};
+	const assert = (word) => {
+		if (script.length - currentIndex < word.length) return false;
+		if (script.substring(currentIndex, currentIndex + word.length) === word) return true;
+		return false;
+	};
+	const getRangeAndSkip = (length) => {
+		const result = script.substring(currentIndex, currentIndex + length);
+		skip(result.length);
+		return result;
+	};
+	const getUntil = (word) => {
+		if (currentIndex >= script.length) return;
+		const index = script.indexOf(word, currentIndex);
+		if (index >= 0) {
+			const result = script.substring(currentIndex, index);
+			skip(index - currentIndex);
+			return result;
+		} else {
+			const result = script.substring(currentIndex, script.length);
+			skip(script.length - currentIndex);
+			return result;
+		}
+	};
+	const location = (type) => type === "end" ? {
+		line: lastLine + 1,
+		column: lastColumn + 1
+	} : {
+		line: rawLine + 1,
+		column: rawColumn + 1
+	};
+	return {
+		eot,
+		getChar,
+		skip,
+		skipChars,
+		skipUntil,
+		assert,
+		getRangeAndSkip,
+		getUntil,
+		location
+	};
+};
+/**
+* Run the tokenizer for code expressions only.
+* @param script - Input script text
+* @param logs - Will be stored detected warnings/logs into it
+* @param sourceId - Source identifier (file path, URL, etc)
+* @returns The token list
+*/
+var runCodeTokenizer = (script, logs, sourceId) => {
+	return tokenizeCodeTokens({
+		cursor: createTokenizerCursor(script),
+		sourceId,
+		logs
+	}, false, true).tokens;
+};
+/**
+* Run the tokenizer.
+* @param script - Input script text
+* @param logs - Will be stored detected warnings/logs into it
+* @param sourceId - Source identifier (file path, URL, etc)
+* @returns The token list
+*/
+var runTokenizer = (script, logs, sourceId) => {
+	const context = {
+		cursor: createTokenizerCursor(script),
+		sourceId,
+		logs
+	};
+	const tokens = [];
+	const readTextBlock = () => {
+		if (context.cursor.eot()) return;
+		let text = "";
+		while (!context.cursor.eot()) {
+			if (context.cursor.assert("{{")) return text;
+			const ch = context.cursor.getChar();
+			if (ch === "\\") {
+				const next = context.cursor.getChar(1);
+				if (next === "{" || next === "}") {
+					text += next;
+					context.cursor.skip(2);
+					continue;
+				}
+			}
+			text += ch;
+			context.cursor.skip(1);
+		}
+		return text;
+	};
+	while (!context.cursor.eot()) {
+		const start = context.cursor.location("start");
+		const text = readTextBlock();
+		if (text) tokens.push({
+			kind: "text",
+			text,
+			range: createRange(context, start, context.cursor.location("end"))
+		});
+		else tokens.push(...tokenizeCodeBlock(context));
+	}
+	return tokens;
+};
+//#endregion
+//#region src/utils.ts
+/**
+* Empty location with zeroed coordinates.
+*/
+var emptyLocation = {
+	line: 0,
+	column: 0
+};
+/**
+* Empty range with zeroed coordinates.
+*/
+var emptyRange = {
+	sourceId: "unknown.fc",
+	start: emptyLocation,
+	end: emptyLocation
+};
+var specialFunctionMarker = Symbol("$$special$$");
+/**
+* Mark a function as a funcity special function.
+* @param f - Target function.
+* @returns The same function with a marker.
+*/
+var makeFunCityFunction = (f) => {
+	f[specialFunctionMarker] = true;
+	return f;
+};
+/**
+* Check whether a function is marked as funcity special function.
+* @param f - Target function.
+* @returns True when marked.
+*/
+var isFunCityFunction = (f) => {
+	var _f$specialFunctionMar;
+	return (_f$specialFunctionMar = f[specialFunctionMarker]) !== null && _f$specialFunctionMar !== void 0 ? _f$specialFunctionMar : false;
+};
+/**
+* Evaluate value with the interpreter's conditional semantics.
+* @param v - Target value.
+* @returns True when the value should be treated as truthy.
+*/
+var isConditionalTrue = (v) => {
+	if (v === void 0 || v === null) return false;
+	switch (typeof v) {
+		case "boolean": return v;
+		case "number":
+		case "bigint": return v !== 0;
+		default: return true;
+	}
+};
+/**
+* Cast a value to iterable when it has a default iterator.
+* @param v - Target value.
+* @returns Iterable instance or undefined when not iterable.
+*/
+var asIterable = (v) => {
+	if (typeof v[Symbol.iterator] === "function") return v;
+	else return;
+};
+/**
+* Combine variable maps or records into a single variable map.
+* @param variablesList - Variable sources to merge.
+* @returns Combined variable map.
+*/
+var combineVariables = (...variablesList) => {
+	const variables = /* @__PURE__ */ new Map();
+	const appendVariables = (vs) => vs.forEach((v, k) => variables.set(k, v));
+	const appendRecord = (vs) => Object.keys(vs).forEach((k) => variables.set(k, vs[k]));
+	variablesList.forEach((vs) => {
+		if (vs["forEach"] !== void 0) appendVariables(vs);
+		else appendRecord(vs);
+	});
+	return variables;
+};
+/**
+* Convert an error object into a human-readable message.
+* @param error - Error object.
+* @returns Error message.
+*/
+var fromError = (error) => {
+	if (error.message) return error.message;
+	else if (typeof error.toString === "function") {
+		var _error$toString;
+		return (_error$toString = error.toString()) !== null && _error$toString !== void 0 ? _error$toString : "unknown";
+	} else return "unknown";
+};
+/**
+* Check whether a value is promise-like.
+* @param value - Target value.
+* @returns True when the value has a `then` method.
+*/
+var isPromiseLike = (value) => {
+	if (value === null || value === void 0) return false;
+	return typeof value.then === "function";
+};
+var widerRange = (...args) => {
+	var _primarySourceId;
+	const lastArg = args[args.length - 1];
+	const logs = Array.isArray(lastArg) ? lastArg : void 0;
+	const ranges = Array.isArray(lastArg) ? args.slice(0, -1) : args;
+	let start = emptyRange.start;
+	let end = emptyRange.end;
+	let primarySourceId;
+	const sourceIds = /* @__PURE__ */ new Set();
+	for (const range of ranges) if (range.start.line >= 1 && range.start.column >= 1) {
+		if (!primarySourceId) primarySourceId = range.sourceId;
+		sourceIds.add(range.sourceId);
+		if (start.line === 0 || start.column === 0) start = range.start;
+		else if (range.start.line < start.line) start = range.start;
+		else if (range.start.line === start.line && range.start.column < start.column) start = range.start;
+		if (end.line === 0 || end.column === 0) end = range.end;
+		else if (range.end.line > end.line) end = range.end;
+		else if (range.end.line === end.line && range.end.column > end.column) end = range.end;
+	}
+	const combinedRange = {
+		sourceId: (_primarySourceId = primarySourceId) !== null && _primarySourceId !== void 0 ? _primarySourceId : emptyRange.sourceId,
+		start,
+		end
+	};
+	if (sourceIds.size >= 2 && logs) logs.push({
+		type: "error",
+		description: "Range sourceId mismatch",
+		range: combinedRange
+	});
+	return combinedRange;
+};
+var locationEquals = (lhs, rhs) => lhs.line === rhs.line && lhs.column === rhs.column;
+var getLocationString = (range) => locationEquals(range.start, range.end) ? `${range.start.line}:${range.start.column}` : `${range.start.line}:${range.start.column}:${range.end.line}:${range.end.column}`;
+var printErrorString = (error, writer) => {
+	const sourceId = error.range.sourceId;
+	switch (error.type) {
+		case "warning":
+			writer.warn(`${sourceId}:${getLocationString(error.range)}: warning: ${error.description}`);
+			break;
+		case "error":
+			writer.error(`${sourceId}:${getLocationString(error.range)}: error: ${error.description}`);
+			return true;
+	}
+	return false;
+};
+/**
+* Output error list and return whether any error-level entry exists.
+* @param logs - Errors to output.
+* @param writer - Writer interface.
+* @returns True when an error-level entry exists.
+*/
+var outputErrors = (logs, writer) => {
+	const _writer = writer !== null && writer !== void 0 ? writer : console;
+	let isError = false;
+	for (const error of logs) {
+		const result = printErrorString(error, _writer);
+		isError || (isError = result);
+	}
+	return isError;
+};
+var iterToString = (iter, getFuncId) => {
+	const strs = [];
+	for (const item of iter) {
+		const str = internalConvertToString(item, getFuncId);
+		strs.push(str);
+	}
+	return `[${strs.join(" ")}]`;
+};
+var internalConvertToString = (v, getFuncId) => {
+	switch (v) {
+		case void 0: return "(undefined)";
+		case null: return "(null)";
+		default: switch (typeof v) {
+			case "string": return v;
+			case "boolean": return v ? "true" : "false";
+			case "number":
+			case "bigint":
+			case "symbol": return v.toString();
+			case "function": if (v.name) return `fun<${v.name}:#${getFuncId(v)}>`;
+			else return `fun<#${getFuncId(v)}>`;
+			default:
+				if (Array.isArray(v)) return iterToString(v, getFuncId);
+				const iterable = asIterable(v);
+				if (iterable) return iterToString(iterable, getFuncId);
+				else if (v instanceof Date) return v.toISOString();
+				else if (v instanceof Error) return `${v.name}: ${v.message}`;
+				else if (v instanceof URL) return v.origin;
+				else return JSON.stringify(v);
+		}
+	}
+};
+var internalCreateFunctionIdGenerator = () => {
+	const funcIds = /* @__PURE__ */ new WeakMap();
+	let nextId = 1;
+	const getFuncId = (fn) => {
+		const cached = funcIds.get(fn);
+		if (cached) return cached;
+		const id = nextId++;
+		funcIds.set(fn, id);
+		return id;
+	};
+	return getFuncId;
+};
+var getGlobalFuncId = internalCreateFunctionIdGenerator();
+/**
+* Convert to string.
+* @param v Target instance
+* @returns String
+*/
+var convertToString = (v) => internalConvertToString(v, getGlobalFuncId);
+//#endregion
+//#region src/parser.ts
+var parseNumber = (cursor, _errors) => {
+	const token = cursor.takeToken();
+	return {
+		kind: "number",
+		value: token.value,
+		range: token.range
+	};
+};
+var parseString = (cursor, _errors) => {
+	const token = cursor.takeToken();
+	return {
+		kind: "string",
+		value: token.value,
+		range: token.range
+	};
+};
+var parseTemplate = (cursor, logs) => {
+	const token = cursor.takeToken();
+	return {
+		kind: "template",
+		blocks: parseBlockCore(createParserCursor(token.tokens), logs, "script"),
+		range: token.range
+	};
+};
+var parseIdentity = (cursor, _errors) => {
+	const token = cursor.takeToken();
+	return {
+		kind: "variable",
+		name: token.name,
+		range: token.range
+	};
+};
+var unitKind = "'()'";
+var combineIntoScopeMultipleExpressions = (expressionList, logs, ...outerRanges) => {
+	switch (expressionList.length) {
+		case 0: return;
+		case 1: return expressionList[0];
+		default: return {
+			kind: "scope",
+			nodes: expressionList,
+			range: widerRange(...expressionList.map((node) => node.range), ...outerRanges, logs)
+		};
+	}
+};
+var parseDotChain = (cursor, logs, baseNode) => {
+	const segments = [];
+	const ranges = [baseNode.range];
+	while (true) {
+		const dotToken = cursor.peekToken();
+		if (!dotToken || dotToken.kind !== "dot") break;
+		const actualDotToken = cursor.takeToken();
+		ranges.push(actualDotToken.range);
+		const nextToken = cursor.peekToken();
+		if (!nextToken) {
+			logs.push({
+				type: "error",
+				description: "Could not find member identity after dot",
+				range: actualDotToken.range
+			});
+			break;
+		}
+		if (nextToken.kind !== "identity") {
+			logs.push({
+				type: "error",
+				description: "Required member identity after dot",
+				range: widerRange(actualDotToken.range, nextToken.range, logs)
+			});
+			break;
+		}
+		const memberToken = cursor.takeToken();
+		segments.push({
+			name: memberToken.name,
+			optional: actualDotToken.optional,
+			range: memberToken.range,
+			operatorRange: actualDotToken.range
+		});
+		ranges.push(memberToken.range);
+	}
+	if (segments.length === 0) return baseNode;
+	return {
+		kind: "dot",
+		base: baseNode,
+		segments,
+		range: widerRange(...ranges, logs)
+	};
+};
+var parsePartialExpression = (cursor, logs) => {
+	const token = cursor.peekToken();
+	if (!token) return;
+	switch (token.kind) {
+		case "number": return parseDotChain(cursor, logs, parseNumber(cursor, logs));
+		case "string": return parseDotChain(cursor, logs, parseString(cursor, logs));
+		case "template": return parseDotChain(cursor, logs, parseTemplate(cursor, logs));
+		case "identity": return parseDotChain(cursor, logs, parseIdentity(cursor, logs));
+		case "dot": {
+			const dotToken = cursor.takeToken();
+			logs.push({
+				type: "error",
+				description: "Invalid dot at this location",
+				range: dotToken.range
+			});
+			return;
+		}
+		case "open":
+			cursor.skipToken();
+			switch (token.symbol) {
+				case "(": {
+					const innerNodes = parseMultipleApplicationExpressions(cursor, logs);
+					const closeToken = cursor.peekToken();
+					let range;
+					if (!closeToken) {
+						range = widerRange(token.range, ...innerNodes.map((node) => node.range), logs);
+						logs.push({
+							type: "error",
+							description: "Could not find close parenthesis",
+							range: widerRange(token.range, ...innerNodes.map((node) => node.range), logs)
+						});
+					} else {
+						cursor.skipToken();
+						range = widerRange(token.range, ...innerNodes.map((node) => node.range), closeToken.range, logs);
+						if (closeToken.kind !== "close" || closeToken.symbol !== ")") logs.push({
+							type: "error",
+							description: `Mismatched close parenthesis`,
+							range
+						});
+					}
+					if (innerNodes.length === 0) return {
+						kind: unitKind,
+						range
+					};
+					else {
+						const node = combineIntoScopeMultipleExpressions(innerNodes, logs, range);
+						return node ? parseDotChain(cursor, logs, node) : node;
+					}
+				}
+				case "[": {
+					const itemNodes = parseListExpression(cursor, logs);
+					const closeToken = cursor.peekToken();
+					let range;
+					if (!closeToken) {
+						range = widerRange(token.range, ...itemNodes.map((node) => node.range), logs);
+						logs.push({
+							type: "error",
+							description: "Could not find close bracket",
+							range
+						});
+					} else {
+						cursor.skipToken();
+						range = widerRange(token.range, ...itemNodes.map((node) => node.range), closeToken.range, logs);
+						if (closeToken.kind !== "close" || closeToken.symbol !== "]") logs.push({
+							type: "error",
+							description: `Mismatched close bracket`,
+							range
+						});
+					}
+					return parseDotChain(cursor, logs, {
+						kind: "list",
+						items: itemNodes,
+						range
+					});
+				}
+				default:
+					logs.push({
+						type: "error",
+						description: `Invalid open parenthesis/bracket`,
+						range: token.range
+					});
+					return;
+			}
+	}
+};
+var normalizePartialUnitNode = (node, logs) => {
+	if (node.kind === unitKind) {
+		logs.push({
+			type: "error",
+			description: `Invalid ${unitKind} at this location`,
+			range: node.range
+		});
+		return {
+			kind: "variable",
+			name: "undefined",
+			range: node.range
+		};
+	} else return node;
+};
+var finalizeApplicationException = (partialNodes, logs) => {
+	if (partialNodes.length === 0) return;
+	if (partialNodes.length === 1) return normalizePartialUnitNode(partialNodes[0], logs);
+	const func = partialNodes[0];
+	if (func.kind === unitKind) {
+		logs.push({
+			type: "error",
+			description: `Invalid ${unitKind} at this location`,
+			range: func.range
+		});
+		return;
+	}
+	const arg0 = partialNodes[1];
+	if (arg0.kind === unitKind) return {
+		kind: "apply",
+		func,
+		args: [],
+		range: widerRange(func.range, arg0.range, logs)
+	};
+	const args = partialNodes.slice(1).map((node) => normalizePartialUnitNode(node, logs));
+	return {
+		kind: "apply",
+		func,
+		args,
+		range: widerRange(func.range, ...args.map((node) => node.range), logs)
+	};
+};
+var parseMultipleApplicationExpressions = (cursor, logs) => {
+	const expressionList = [];
+	const partialNodes = [];
+	while (true) {
+		const token = cursor.peekToken();
+		if (!token) break;
+		switch (token.kind) {
+			case "eol": {
+				cursor.skipToken();
+				const expr = finalizeApplicationException(partialNodes, logs);
+				if (expr) expressionList.push(expr);
+				partialNodes.length = 0;
+				continue;
+			}
+		}
+		const partialNode = parsePartialExpression(cursor, logs);
+		if (!partialNode) break;
+		partialNodes.push(partialNode);
+	}
+	const expr = finalizeApplicationException(partialNodes, logs);
+	if (expr) expressionList.push(expr);
+	return expressionList;
+};
+var parseListExpression = (cursor, logs) => {
+	const itemNodes = [];
+	while (true) {
+		const token = cursor.peekToken();
+		if (!token) break;
+		switch (token.kind) {
+			case "eol":
+				cursor.skipToken();
+				if (token.source === "semicolon") logs.push({
+					type: "error",
+					description: "Semicolon is not allowed in list expression",
+					range: token.range
+				});
+				continue;
+		}
+		const partialNode = parsePartialExpression(cursor, logs);
+		if (!partialNode) break;
+		itemNodes.push(normalizePartialUnitNode(partialNode, logs));
+	}
+	return itemNodes;
+};
+var drainEndOfLineAndPeek = (cursor) => {
+	let token = cursor.peekToken();
+	while (token) {
+		if (token.kind === "eol") cursor.skipToken();
+		else break;
+		token = cursor.peekToken();
+	}
+	return token;
+};
+/**
+* Parse expression in the single line.
+* @param cursor - Parser cursor
+* @param logs - Will be stored detected warnings/logs into it
+* @returns Parsed expression node when available
+*/
+var parseExpression = (cursor, logs) => {
+	let token = drainEndOfLineAndPeek(cursor);
+	if (!token) return;
+	const partialNodes = [];
+	while (true) {
+		const partialNode = parsePartialExpression(cursor, logs);
+		if (!partialNode) break;
+		partialNodes.push(partialNode);
+		token = cursor.peekToken();
+		if (!token) break;
+		if (token.kind === "eol") {
+			cursor.skipToken();
+			token = cursor.peekToken();
+			break;
+		}
+	}
+	drainEndOfLineAndPeek(cursor);
+	return finalizeApplicationException(partialNodes, logs);
+};
+var createBranchState = () => ({
+	blocks: [],
+	exprBuffer: []
+});
+var getBranchState = (statementState) => {
+	switch (statementState.kind) {
+		case "root": return statementState.branch;
+		case "if": switch (statementState.currentBlock) {
+			case "then": return statementState.then;
+			case "else": return statementState.else;
+			case "elseif": {
+				var _statementState$curre;
+				const elseIf = statementState.elseIfs[(_statementState$curre = statementState.currentElseIfIndex) !== null && _statementState$curre !== void 0 ? _statementState$curre : -1];
+				return elseIf ? elseIf.then : statementState.else;
+			}
+		}
+		case "while":
+		case "for": return statementState.repeat;
+	}
+};
+var flushExpressions = (branch, logs) => {
+	if (branch.exprBuffer.length === 0) return;
+	if (branch.exprBuffer.length === 1) branch.blocks.push(branch.exprBuffer[0]);
+	else branch.blocks.push({
+		kind: "scope",
+		nodes: branch.exprBuffer,
+		range: widerRange(...branch.exprBuffer.map((node) => node.range), logs)
+	});
+	branch.exprBuffer = [];
+};
+var flushCurrentBranch = (statementStates, logs) => {
+	const statementState = statementStates[statementStates.length - 1];
+	flushExpressions(getBranchState(statementState), logs);
+};
+var flushStatementState = (statementState, logs) => {
+	switch (statementState.kind) {
+		case "root":
+			flushExpressions(statementState.branch, logs);
+			break;
+		case "if":
+			flushExpressions(statementState.then, logs);
+			flushExpressions(statementState.else, logs);
+			statementState.elseIfs.forEach((elseIf) => flushExpressions(elseIf.then, logs));
+			break;
+		case "while":
+		case "for":
+			flushExpressions(statementState.repeat, logs);
+			break;
+	}
+};
+var pushExpressionNode = (statementStates, node) => {
+	const statementState = statementStates[statementStates.length - 1];
+	getBranchState(statementState).exprBuffer.push(node);
+};
+var pushBlockNode = (statementStates, node, logs) => {
+	const statementState = statementStates[statementStates.length - 1];
+	const branch = getBranchState(statementState);
+	flushExpressions(branch, logs);
+	branch.blocks.push(node);
+};
+var pushNode = (statementStates, node, logs) => {
+	switch (node.kind) {
+		case "text":
+		case "if":
+		case "while":
+		case "for":
+			pushBlockNode(statementStates, node, logs);
+			break;
+		default:
+			pushExpressionNode(statementStates, node);
+			break;
+	}
+};
+var parseStatementArguments = (cursor, logs) => {
+	const args = [];
+	while (true) {
+		const token = cursor.peekToken();
+		if (!token) break;
+		if (token.kind === "eol") {
+			cursor.skipToken();
+			break;
+		}
+		const partialNode = parsePartialExpression(cursor, logs);
+		if (!partialNode) break;
+		args.push(normalizePartialUnitNode(partialNode, logs));
+	}
+	return args;
+};
+var parseBlockCore = (cursor, logs, mode) => {
+	const isRepeatedSymbol = (symbol, ch, minLength) => {
+		if (symbol.length < minLength) return false;
+		for (let index = 0; index < symbol.length; index++) if (symbol[index] !== ch) return false;
+		return true;
+	};
+	const isCodeBlockOpenSymbol = (symbol) => isRepeatedSymbol(symbol, "{", 2);
+	const isCodeBlockCloseSymbol = (symbol) => isRepeatedSymbol(symbol, "}", 2);
+	const rootState = {
+		kind: "root",
+		startRange: emptyRange,
+		branch: createBranchState()
+	};
+	const statementStates = [rootState];
+	const isCodeMode = mode === "code";
+	let isInExpressionBlock = isCodeMode;
+	let expectedCloseSymbol;
+	while (true) {
+		const token = drainEndOfLineAndPeek(cursor);
+		if (!token) break;
+		switch (token.kind) {
+			case "text":
+				cursor.skipToken();
+				if (isInExpressionBlock) {
+					logs.push({
+						type: "error",
+						description: `Already opened expression block (tokenizer bug?)`,
+						range: token.range
+					});
+					break;
+				}
+				pushNode(statementStates, {
+					kind: "text",
+					text: token.text,
+					range: token.range
+				}, logs);
+				break;
+			case "open":
+				if (isCodeBlockOpenSymbol(token.symbol)) {
+					cursor.skipToken();
+					if (!isCodeMode) if (isInExpressionBlock) logs.push({
+						type: "error",
+						description: `Already opened expression block`,
+						range: token.range
+					});
+					else {
+						isInExpressionBlock = true;
+						expectedCloseSymbol = "}".repeat(token.symbol.length);
+					}
+				} else {
+					const node = parseExpression(cursor, logs);
+					if (node) pushNode(statementStates, node, logs);
+				}
+				break;
+			case "close":
+				cursor.skipToken();
+				if (isCodeBlockCloseSymbol(token.symbol) && isCodeMode) {
+					flushCurrentBranch(statementStates, logs);
+					break;
+				}
+				if (!isInExpressionBlock) {
+					logs.push({
+						type: "error",
+						description: `Mismatched close bracket`,
+						range: token.range
+					});
+					break;
+				}
+				if (isCodeMode) {
+					logs.push({
+						type: "error",
+						description: `Mismatched close bracket`,
+						range: token.range
+					});
+					break;
+				}
+				if (!expectedCloseSymbol || token.symbol !== expectedCloseSymbol) {
+					logs.push({
+						type: "error",
+						description: `Mismatched close bracket`,
+						range: token.range
+					});
+					break;
+				}
+				flushCurrentBranch(statementStates, logs);
+				isInExpressionBlock = false;
+				expectedCloseSymbol = void 0;
+				break;
+			case "identity":
+				if (!isInExpressionBlock) {
+					logs.push({
+						type: "error",
+						description: `Invalid identity (tokenizer bug?)`,
+						range: token.range
+					});
+					break;
+				}
+				switch (token.name) {
+					case "if": {
+						cursor.skipToken();
+						const args = parseStatementArguments(cursor, logs);
+						if (args.length !== 1) {
+							logs.push({
+								type: "error",
+								description: "Required `if` condition",
+								range: widerRange(token.range, ...args.map((node) => node.range), logs)
+							});
+							break;
+						}
+						const conditionNode = args[0];
+						statementStates.push({
+							kind: "if",
+							startRange: token.range,
+							condition: conditionNode,
+							elseIfs: [],
+							then: createBranchState(),
+							else: createBranchState(),
+							currentBlock: "then"
+						});
+						break;
+					}
+					case "else": {
+						cursor.skipToken();
+						const args = parseStatementArguments(cursor, logs);
+						if (args.length !== 0) logs.push({
+							type: "error",
+							description: "Could not take any arguments in `else` statement",
+							range: widerRange(token.range, ...args.map((node) => node.range), logs)
+						});
+						if (statementStates.length <= 1) {
+							logs.push({
+								type: "error",
+								description: "Cound not find pair of `if` statement",
+								range: token.range
+							});
+							break;
+						}
+						const lastState = statementStates[statementStates.length - 1];
+						if (lastState.kind !== "if") {
+							logs.push({
+								type: "error",
+								description: "Cound not find pair of `if` statement",
+								range: token.range
+							});
+							break;
+						}
+						if (lastState.currentBlock === "else") {
+							logs.push({
+								type: "error",
+								description: "Duplicated `else` statement",
+								range: token.range
+							});
+							break;
+						}
+						flushExpressions(getBranchState(lastState), logs);
+						lastState.currentBlock = "else";
+						lastState.currentElseIfIndex = void 0;
+						break;
+					}
+					case "elseif": {
+						cursor.skipToken();
+						const args = parseStatementArguments(cursor, logs);
+						if (args.length !== 1) {
+							logs.push({
+								type: "error",
+								description: "Required `elseif` condition",
+								range: widerRange(token.range, ...args.map((node) => node.range), logs)
+							});
+							break;
+						}
+						if (statementStates.length <= 1) {
+							logs.push({
+								type: "error",
+								description: "Cound not find pair of `if` statement",
+								range: token.range
+							});
+							break;
+						}
+						const lastState = statementStates[statementStates.length - 1];
+						if (lastState.kind !== "if") {
+							logs.push({
+								type: "error",
+								description: "Cound not find pair of `if` statement",
+								range: token.range
+							});
+							break;
+						}
+						if (lastState.currentBlock === "else") {
+							logs.push({
+								type: "error",
+								description: "Could not place `elseif` after `else` statement",
+								range: token.range
+							});
+							break;
+						}
+						flushExpressions(getBranchState(lastState), logs);
+						const conditionNode = args[0];
+						const elseIfIndex = lastState.elseIfs.length;
+						lastState.elseIfs.push({
+							startRange: token.range,
+							condition: conditionNode,
+							then: createBranchState()
+						});
+						lastState.currentBlock = "elseif";
+						lastState.currentElseIfIndex = elseIfIndex;
+						break;
+					}
+					case "while": {
+						cursor.skipToken();
+						const args = parseStatementArguments(cursor, logs);
+						if (args.length !== 1) {
+							logs.push({
+								type: "error",
+								description: "Required `while` condition",
+								range: widerRange(token.range, ...args.map((node) => node.range), logs)
+							});
+							break;
+						}
+						const conditionNode = args[0];
+						statementStates.push({
+							kind: "while",
+							startRange: token.range,
+							condition: conditionNode,
+							repeat: createBranchState()
+						});
+						break;
+					}
+					case "for": {
+						cursor.skipToken();
+						const args = parseStatementArguments(cursor, logs);
+						if (args.length !== 2) {
+							logs.push({
+								type: "error",
+								description: "Required `for` bind identity and iterable expression",
+								range: widerRange(token.range, ...args.map((node) => node.range), logs)
+							});
+							break;
+						}
+						const bindNode = args[0];
+						if (bindNode.kind !== "variable") {
+							logs.push({
+								type: "error",
+								description: "Required `for` bind identity",
+								range: bindNode.range
+							});
+							break;
+						}
+						const iterableNode = args[1];
+						statementStates.push({
+							kind: "for",
+							startRange: token.range,
+							bind: bindNode,
+							iterable: iterableNode,
+							repeat: createBranchState()
+						});
+						break;
+					}
+					case "end": {
+						cursor.skipToken();
+						const args = parseStatementArguments(cursor, logs);
+						if (args.length !== 0) logs.push({
+							type: "error",
+							description: "Could not take any arguments in `end` statement",
+							range: widerRange(token.range, ...args.map((node) => node.range), logs)
+						});
+						if (statementStates.length <= 1) {
+							logs.push({
+								type: "error",
+								description: "Cound not find pair of `if`,`while` or `for` statement",
+								range: token.range
+							});
+							break;
+						}
+						const lastState = statementStates.pop();
+						flushStatementState(lastState, logs);
+						switch (lastState.kind) {
+							case "if": {
+								let elseBlocks = lastState.else.blocks;
+								for (let index = lastState.elseIfs.length - 1; index >= 0; index--) {
+									const elseIf = lastState.elseIfs[index];
+									elseBlocks = [{
+										kind: "if",
+										condition: elseIf.condition,
+										then: elseIf.then.blocks,
+										else: elseBlocks,
+										range: widerRange(elseIf.startRange, elseIf.condition.range, ...elseIf.then.blocks.map((node) => node.range), ...elseBlocks.map((node) => node.range), token.range, logs)
+									}];
+								}
+								pushNode(statementStates, {
+									kind: "if",
+									condition: lastState.condition,
+									then: lastState.then.blocks,
+									else: elseBlocks,
+									range: widerRange(lastState.startRange, lastState.condition.range, ...lastState.then.blocks.map((node) => node.range), ...elseBlocks.map((node) => node.range), token.range, logs)
+								}, logs);
+								break;
+							}
+							case "while":
+								pushNode(statementStates, {
+									kind: "while",
+									condition: lastState.condition,
+									repeat: lastState.repeat.blocks,
+									range: widerRange(lastState.startRange, lastState.condition.range, ...lastState.repeat.blocks.map((node) => node.range), token.range, logs)
+								}, logs);
+								break;
+							case "for":
+								pushNode(statementStates, {
+									kind: "for",
+									bind: lastState.bind,
+									iterable: lastState.iterable,
+									repeat: lastState.repeat.blocks,
+									range: widerRange(lastState.startRange, lastState.bind.range, ...lastState.repeat.blocks.map((node) => node.range), token.range, logs)
+								}, logs);
+								break;
+						}
+						break;
+					}
+					default: {
+						const node = parseExpression(cursor, logs);
+						if (node) pushNode(statementStates, node, logs);
+						break;
+					}
+				}
+				break;
+			default: {
+				if (!isInExpressionBlock) {
+					logs.push({
+						type: "error",
+						description: `Invalid ${token.kind} (tokenizer bug?)`,
+						range: token.range
+					});
+					break;
+				}
+				const node = parseExpression(cursor, logs);
+				if (node) pushNode(statementStates, node, logs);
+				break;
+			}
+		}
+	}
+	flushStatementState(rootState, logs);
+	if (statementStates.length !== 1) logs.push({
+		type: "error",
+		description: `Could not find statement closing`,
+		range: widerRange(...statementStates.map((state) => state.startRange), logs)
+	});
+	return rootState.branch.blocks;
+};
+/**
+* Parse blocks.
+* @param cursor - Parser cursor
+* @param logs - Will be stored detected warnings/logs into it
+* @returns Parsed block nodes
+*/
+var parseBlock = (cursor, logs) => {
+	return parseBlockCore(cursor, logs, "script");
+};
+/**
+* Create a parser cursor.
+* @param tokens - Target tokens
+* @returns Parser cursor
+*/
+var createParserCursor = (tokens) => {
+	let index = 0;
+	const peekToken = () => {
+		return tokens[index];
+	};
+	const takeToken = () => {
+		if (index >= tokens.length) return;
+		const token = tokens[index];
+		index++;
+		return token;
+	};
+	const skipToken = () => {
+		if (index >= tokens.length) return;
+		index++;
+	};
+	return {
+		peekToken,
+		takeToken,
+		skipToken
+	};
+};
+/**
+* Parse expressions in code block.
+* @param tokens - Token list
+* @param logs - Will be stored detected warnings/logs into it
+* @returns Parsed node list
+*/
+var parseExpressions = (tokens, logs) => {
+	return parseBlockCore(createParserCursor(tokens), logs, "code");
+};
+/**
+* Run the parser.
+* @param tokens - Token list
+* @param logs - Will be stored detected warnings/logs into it
+* @returns Parsed node list
+*/
+var runParser = (tokens, logs) => {
+	return parseBlock(createParserCursor(tokens), logs);
+};
+//#endregion
+//#region src/reducer.ts
+var throwError$1 = (info) => {
+	throw new FunCityReducerError({
+		type: "error",
+		...info
+	});
+};
+var deconstructConditionalCombine$1 = (name) => {
+	if (name.length >= 1) {
+		if (name[name.length - 1] === "?") return {
+			name: name.substring(0, name.length - 1),
+			canIgnore: true
+		};
+	}
+	return {
+		name,
+		canIgnore: false
+	};
+};
+var resolveVariable$1 = (context, name, signal) => {
+	const result = deconstructConditionalCombine$1(name.name);
+	const valueResult = context.getValue(result.name, signal);
+	if (!valueResult.isFound) {
+		if (!result.canIgnore) throwError$1({
+			description: `variable is not bound: ${result.name}`,
+			range: name.range
+		});
+		return;
+	}
+	return valueResult.value;
+};
+var resolveDotNode = async (context, node, signal) => {
+	var _node$segments$0$opti, _node$segments$;
+	signal === null || signal === void 0 || signal.throwIfAborted();
+	const firstSegmentOptional = (_node$segments$0$opti = (_node$segments$ = node.segments[0]) === null || _node$segments$ === void 0 ? void 0 : _node$segments$.optional) !== null && _node$segments$0$opti !== void 0 ? _node$segments$0$opti : false;
+	let value;
+	if (node.base.kind === "variable") {
+		const baseResult = deconstructConditionalCombine$1(node.base.name);
+		const valueResult = context.getValue(baseResult.name, signal);
+		if (!valueResult.isFound) {
+			if (!baseResult.canIgnore && !firstSegmentOptional) throwError$1({
+				description: `variable is not bound: ${baseResult.name}`,
+				range: node.base.range
+			});
+			return;
+		}
+		value = valueResult.value;
+	} else value = await reduceExpressionNode(context, node.base, signal);
+	let parent;
+	for (const segment of node.segments) {
+		const result = deconstructConditionalCombine$1(segment.name);
+		const isOptional = segment.optional || result.canIgnore;
+		if (value !== null && (typeof value === "object" || typeof value === "function")) {
+			const record = value;
+			parent = value;
+			value = record[result.name];
+		} else {
+			if (!isOptional) throwError$1({
+				description: `variable is not bound: ${result.name}`,
+				range: segment.range
+			});
+			return;
+		}
+	}
+	if (parent && typeof value === "function" && !isFunCityFunction(value)) return context.getBoundFunction(parent, value);
+	return value;
+};
+var applyFunction = async (context, node, signal) => {
+	signal === null || signal === void 0 || signal.throwIfAborted();
+	const func = await reduceExpressionNode(context, node.func, signal);
+	if (typeof func !== "function") {
+		throwError$1({
+			description: "could not apply it for function",
+			range: node.range
+		});
+		return;
+	}
+	const args = isFunCityFunction(func) ? node.args : await Promise.all(node.args.map(async (argNode) => {
+		return await reduceExpressionNode(context, argNode, signal);
+	}));
+	try {
+		const thisProxy = context.createFunctionContext(node, signal);
+		return await func.call(thisProxy, ...args);
+	} catch (e) {
+		if (e instanceof FunCityReducerError) throw e;
+		if (e instanceof Error && e.name === "AbortError") throw e;
+		throw new FunCityReducerError({
+			type: "error",
+			description: fromError(e),
+			range: node.range
+		});
+	}
+};
+/**
+* Reduce expression node.
+* @param context - Reducer context
+* @param node - Target expression node
+* @param signal - AbortSignal
+* @returns Reduced native value
+*/
+var reduceExpressionNode = async (context, node, signal) => {
+	switch (node.kind) {
+		case "number":
+		case "string": return node.value;
+		case "template": {
+			const resultList = [];
+			for (const block of node.blocks) {
+				const results = await reduceNode(context, block, signal);
+				for (const result of results) if (result !== void 0) resultList.push(result);
+			}
+			return resultList.map((result) => context.convertToString(result)).join("");
+		}
+		case "variable": return resolveVariable$1(context, node, signal);
+		case "dot": return await resolveDotNode(context, node, signal);
+		case "apply": return await applyFunction(context, node, signal);
+		case "list": return await Promise.all(node.items.map((item) => reduceExpressionNode(context, item, signal)));
+		case "scope": {
+			if (node.nodes.length === 0) return [];
+			let result = void 0;
+			for (const childNode of node.nodes) result = await reduceExpressionNode(context, childNode, signal);
+			return result;
+		}
+	}
+};
+/**
+* Reduce a node.
+* @param context - Reducer context
+* @param node - Target node
+* @param signal - AbortSignal
+* @returns Reduced native value list
+*/
+var reduceNode = async (context, node, signal) => {
+	switch (node.kind) {
+		case "text": return [node.text];
+		case "for": {
+			const iterable = asIterable(await reduceExpressionNode(context, node.iterable, signal));
+			if (!iterable) {
+				throwError$1({
+					description: "could not apply it for function",
+					range: node.range
+				});
+				return [];
+			}
+			const resultList = [];
+			for (const item of iterable) {
+				context.setValue(node.bind.name, item, signal);
+				for (const repeat of node.repeat) {
+					const results = await reduceNode(context, repeat, signal);
+					resultList.push(...results);
+				}
+			}
+			return resultList;
+		}
+		case "while": {
+			const resultList = [];
+			while (true) {
+				if (!isConditionalTrue(await reduceExpressionNode(context, node.condition, signal))) break;
+				for (const repeat of node.repeat) {
+					const results = await reduceNode(context, repeat, signal);
+					resultList.push(...results);
+				}
+			}
+			return resultList;
+		}
+		case "if": {
+			const resultList = [];
+			if (isConditionalTrue(await reduceExpressionNode(context, node.condition, signal))) for (const then of node.then) {
+				const results = await reduceNode(context, then, signal);
+				resultList.push(...results);
+			}
+			else for (const els of node.else) {
+				const results = await reduceNode(context, els, signal);
+				resultList.push(...results);
+			}
+			return resultList;
+		}
+		default: return [await reduceExpressionNode(context, node, signal)];
+	}
+};
+var defaultReducerExecutor = {
+	reduceExpressionNodeImmediate: (context, node, signal) => reduceExpressionNode(context, node, signal),
+	reduceExpressionNode: (context, node, signal) => Promise.resolve(reduceExpressionNode(context, node, signal)),
+	reduceNodeImmediate: (context, node, signal) => reduceNode(context, node, signal),
+	reduceNode: (context, node, signal) => Promise.resolve(reduceNode(context, node, signal))
+};
+var reduceBlockImmediate = (context, nodeOrNodes, signal) => {
+	const nodes = Array.isArray(nodeOrNodes) ? nodeOrNodes : [nodeOrNodes];
+	const resultList = [];
+	for (let index = 0; index < nodes.length; index++) {
+		const results = context.reduceNodeImmediate(nodes[index], signal);
+		if (isPromiseLike(results)) return (async () => {
+			const firstResults = await results;
+			for (const result of firstResults) if (result !== void 0) resultList.push(result);
+			for (let continueIndex = index + 1; continueIndex < nodes.length; continueIndex++) {
+				const continueResults = await context.reduceNodeImmediate(nodes[continueIndex], signal);
+				for (const result of continueResults) if (result !== void 0) resultList.push(result);
+			}
+			return resultList;
+		})();
+		for (const result of results) if (result !== void 0) resultList.push(result);
+	}
+	return resultList;
+};
+var createPreparedSlotState = (slotNames, slotValues, signal) => {
+	signal === null || signal === void 0 || signal.throwIfAborted();
+	let preparedSlotIds;
+	let preparedSlotValues;
+	let preparedSlotVersion = 0;
+	if (slotNames === void 0 || slotNames.length === 0) return {
+		preparedSlotIds,
+		preparedSlotValues,
+		preparedSlotVersion
+	};
+	for (let index = 0; index < slotNames.length; index++) {
+		const name = slotNames[index];
+		const existingSlot = preparedSlotIds === null || preparedSlotIds === void 0 ? void 0 : preparedSlotIds.get(name);
+		if (existingSlot !== void 0) {
+			preparedSlotValues[existingSlot] = slotValues === null || slotValues === void 0 ? void 0 : slotValues[index];
+			continue;
+		}
+		if (!preparedSlotIds) preparedSlotIds = /* @__PURE__ */ new Map();
+		if (!preparedSlotValues) preparedSlotValues = [];
+		const slot = preparedSlotValues.length;
+		preparedSlotIds.set(name, slot);
+		preparedSlotValues.push(slotValues === null || slotValues === void 0 ? void 0 : slotValues[index]);
+		preparedSlotVersion++;
+	}
+	return {
+		preparedSlotIds,
+		preparedSlotValues,
+		preparedSlotVersion
+	};
+};
+var createScopedReducerContext = (parent, signal, executor, initialSlotNames, initialSlotValues) => {
+	signal === null || signal === void 0 || signal.throwIfAborted();
+	const preparedSlotState = createPreparedSlotState(initialSlotNames, initialSlotValues, signal);
+	let thisSlotIds = preparedSlotState.preparedSlotIds;
+	let thisSlotValues = preparedSlotState.preparedSlotValues;
+	let thisSlotVersion = preparedSlotState.preparedSlotVersion;
+	let thisContext;
+	const getSlotVersion = () => thisSlotVersion;
+	const resolveLocalSlot = (name, signal) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		return thisSlotIds === null || thisSlotIds === void 0 ? void 0 : thisSlotIds.get(name);
+	};
+	const ensureLocalSlot = (name, signal) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		let slot = thisSlotIds === null || thisSlotIds === void 0 ? void 0 : thisSlotIds.get(name);
+		if (slot !== void 0) return slot;
+		if (!thisSlotIds) thisSlotIds = /* @__PURE__ */ new Map();
+		if (!thisSlotValues) thisSlotValues = [];
+		slot = thisSlotValues.length;
+		thisSlotIds.set(name, slot);
+		thisSlotValues.push(void 0);
+		thisSlotVersion++;
+		return slot;
+	};
+	const getSlotValue = (slot, signal) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		return thisSlotValues === null || thisSlotValues === void 0 ? void 0 : thisSlotValues[slot];
+	};
+	const setSlotValue = (slot, value, signal) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		if (!thisSlotValues) thisSlotValues = [];
+		thisSlotValues[slot] = value;
+	};
+	const getValue = (name, signal) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		const slot = resolveLocalSlot(name, signal);
+		if (slot !== void 0) return {
+			value: getSlotValue(slot, signal),
+			isFound: true
+		};
+		return parent.getValue(name, signal);
+	};
+	const setValue = (name, value, signal) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		setSlotValue(ensureLocalSlot(name, signal), value, signal);
+	};
+	const createFunctionContext = (thisNode, signal) => {
+		const reduceBlock = (nodeOrNodes) => Promise.resolve(reduceBlockImmediate(thisContext, nodeOrNodes, signal));
+		return {
+			thisNode,
+			abortSignal: signal,
+			getValue: (name) => getValue(name, signal),
+			setValue: (name, value) => setValue(name, value, signal),
+			appendWarning: parent.appendWarning,
+			getBoundFunction: parent.getBoundFunction,
+			newScope: () => createScopedReducerContext(thisContext, signal, executor, void 0, void 0),
+			convertToString: parent.convertToString,
+			reduceImmediate: (node) => thisContext.reduceExpressionNodeImmediate(node, signal),
+			reduce: (node) => thisContext.reduceExpressionNode(node, signal),
+			reduceBlockImmediate: (nodeOrNodes) => reduceBlockImmediate(thisContext, nodeOrNodes, signal),
+			reduceBlock
+		};
+	};
+	thisContext = {
+		getValue,
+		setValue,
+		getBoundFunction: parent.getBoundFunction,
+		appendWarning: parent.appendWarning,
+		newScope: (signal) => createScopedReducerContext(thisContext, signal, executor, void 0, void 0),
+		newCallScope: (slotNames, slotValues, signal) => createScopedReducerContext(thisContext, signal, executor, slotNames, slotValues),
+		getSlotVersion,
+		resolveLocalSlot,
+		ensureLocalSlot,
+		getSlotValue,
+		setSlotValue,
+		convertToString: parent.convertToString,
+		reduceExpressionNode: (node, signal) => executor.reduceExpressionNode(thisContext, node, signal),
+		reduceExpressionNodeImmediate: (node, signal) => executor.reduceExpressionNodeImmediate(thisContext, node, signal),
+		reduceNode: (node, signal) => executor.reduceNode(thisContext, node, signal),
+		reduceNodeImmediate: (node, signal) => executor.reduceNodeImmediate(thisContext, node, signal),
+		isConstructable: parent.isConstructable,
+		createFunctionContext
+	};
+	return thisContext;
+};
+/**
+* Create reducer context.
+* @param variables - Predefined variables
+* @returns Reducer context
+*/
+var createReducerContext = (variables, warningLogs, executor = defaultReducerExecutor) => {
+	let thisSlotIds;
+	let thisSlotValues;
+	let thisSlotVersion = 0;
+	let thisContext;
+	const boundFunctionCache = /* @__PURE__ */ new WeakMap();
+	const getBoundFunction = (owner, fn) => {
+		let ownerCache = boundFunctionCache.get(owner);
+		if (!ownerCache) {
+			ownerCache = /* @__PURE__ */ new WeakMap();
+			boundFunctionCache.set(owner, ownerCache);
+		}
+		const cached = ownerCache.get(fn);
+		if (cached) return cached;
+		const bound = fn.bind(owner);
+		ownerCache.set(fn, bound);
+		return bound;
+	};
+	const constructorCache = /* @__PURE__ */ new WeakMap();
+	const getSlotVersion = () => thisSlotVersion;
+	const resolveLocalSlot = (name, signal) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		return thisSlotIds === null || thisSlotIds === void 0 ? void 0 : thisSlotIds.get(name);
+	};
+	const ensureLocalSlot = (name, signal) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		let slot = thisSlotIds === null || thisSlotIds === void 0 ? void 0 : thisSlotIds.get(name);
+		if (slot !== void 0) return slot;
+		if (!thisSlotIds) thisSlotIds = /* @__PURE__ */ new Map();
+		if (!thisSlotValues) thisSlotValues = [];
+		slot = thisSlotValues.length;
+		thisSlotIds.set(name, slot);
+		thisSlotValues.push(void 0);
+		thisSlotVersion++;
+		return slot;
+	};
+	const getSlotValue = (slot, signal) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		return thisSlotValues === null || thisSlotValues === void 0 ? void 0 : thisSlotValues[slot];
+	};
+	const setSlotValue = (slot, value, signal) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		if (!thisSlotValues) thisSlotValues = [];
+		thisSlotValues[slot] = value;
+	};
+	const getValue = (name, signal) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		const slot = resolveLocalSlot(name, signal);
+		if (slot !== void 0) return {
+			value: getSlotValue(slot, signal),
+			isFound: true
+		};
+		if (variables.has(name)) return {
+			value: variables.get(name),
+			isFound: true
+		};
+		return {
+			value: void 0,
+			isFound: false
+		};
+	};
+	const setValue = (name, value, signal) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		setSlotValue(ensureLocalSlot(name, signal), value, signal);
+	};
+	const appendWarning = (warning) => {
+		warningLogs.push(warning);
+	};
+	const isConstructable = (fn) => {
+		if (constructorCache.has(fn)) return constructorCache.get(fn);
+		let result = false;
+		try {
+			Reflect.construct(Object, [], fn);
+			result = true;
+		} catch (_unused) {
+			result = false;
+		}
+		constructorCache.set(fn, result);
+		return result;
+	};
+	const getFuncId = internalCreateFunctionIdGenerator();
+	const convertToString = (v) => {
+		return internalConvertToString(v, getFuncId);
+	};
+	const createFunctionContext = (thisNode, signal) => {
+		const reduceBlock = (nodeOrNodes) => Promise.resolve(reduceBlockImmediate(thisContext, nodeOrNodes, signal));
+		return {
+			thisNode,
+			abortSignal: signal,
+			getValue: (name) => getValue(name, signal),
+			setValue: (name, value) => setValue(name, value, signal),
+			appendWarning,
+			getBoundFunction,
+			newScope: () => createScopedReducerContext(thisContext, signal, executor, void 0, void 0),
+			convertToString,
+			reduceImmediate: (node) => thisContext.reduceExpressionNodeImmediate(node, signal),
+			reduce: (node) => thisContext.reduceExpressionNode(node, signal),
+			reduceBlockImmediate: (nodeOrNodes) => reduceBlockImmediate(thisContext, nodeOrNodes, signal),
+			reduceBlock
+		};
+	};
+	thisContext = {
+		getValue,
+		setValue,
+		getBoundFunction,
+		appendWarning,
+		newScope: (signal) => createScopedReducerContext(thisContext, signal, executor, void 0, void 0),
+		newCallScope: (slotNames, slotValues, signal) => createScopedReducerContext(thisContext, signal, executor, slotNames, slotValues),
+		getSlotVersion,
+		resolveLocalSlot,
+		ensureLocalSlot,
+		getSlotValue,
+		setSlotValue,
+		convertToString,
+		reduceExpressionNode: (node, signal) => executor.reduceExpressionNode(thisContext, node, signal),
+		reduceExpressionNodeImmediate: (node, signal) => executor.reduceExpressionNodeImmediate(thisContext, node, signal),
+		reduceNode: (node, signal) => executor.reduceNode(thisContext, node, signal),
+		reduceNodeImmediate: (node, signal) => executor.reduceNodeImmediate(thisContext, node, signal),
+		isConstructable,
+		createFunctionContext
+	};
+	return thisContext;
+};
+/**
+* Run the reducer.
+* @param nodes - Target nodes
+* @param variables - Predefined variables
+* @param logs - Will be stored logs
+* @param signal - Abort signal
+* @returns Reduced native values
+*/
+async function runReducer(nodes, variables, warningLogs, signal) {
+	const context = createReducerContext(variables, warningLogs);
+	const resultList = [];
+	for (const node of nodes) {
+		const results = await reduceNode(context, node, signal);
+		for (const result of results) if (result !== void 0) resultList.push(result);
+	}
+	return resultList;
+}
+//#endregion
+//#region src/variables/standard-variables.ts
+var resolveMaybePromise$1 = (value, onResolved) => {
+	if (isPromiseLike(value)) return value.then((resolved) => onResolved(resolved));
+	return onResolved(value);
+};
+var _cond = makeFunCityFunction(function(arg0, arg1, arg2) {
+	if (!arg0 || !arg1 || !arg2) throw new FunCityReducerError({
+		type: "error",
+		description: "Required `cond` condition, true and false expressions",
+		range: this.thisNode.range
+	});
+	return resolveMaybePromise$1(this.reduceImmediate(arg0), (cond) => isConditionalTrue(cond) ? this.reduceImmediate(arg1) : this.reduceImmediate(arg2));
+});
+var _defaults = makeFunCityFunction(function(arg0, arg1, ...rest) {
+	if (!arg0 || !arg1 || rest.length !== 0) throw new FunCityReducerError({
+		type: "error",
+		description: "Required `defaults` value and default expression",
+		range: this.thisNode.range
+	});
+	return resolveMaybePromise$1(this.reduceImmediate(arg0), (value) => {
+		if (value !== void 0 && value !== null) return value;
+		return this.reduceImmediate(arg1);
+	});
+});
+var _set = makeFunCityFunction(function(arg0, arg1, ...rest) {
+	if (!arg0 || !arg1 || rest.length !== 0) throw new FunCityReducerError({
+		type: "error",
+		description: "Required `set` bind identity and expression",
+		range: this.thisNode.range
+	});
+	if (arg0.kind !== "variable") throw new FunCityReducerError({
+		type: "error",
+		description: "Required `set` bind identity",
+		range: arg0.range
+	});
+	return resolveMaybePromise$1(this.reduceImmediate(arg1), (value) => {
+		this.setValue(arg0.name, value);
+	});
+});
+var isConstructable = (fn) => {
+	try {
+		Reflect.construct(Object, [], fn);
+		return true;
+	} catch (_unused) {
+		return false;
+	}
+};
+var _new = makeFunCityFunction(function(arg0, ...rest) {
+	if (!arg0) throw new FunCityReducerError({
+		type: "error",
+		description: "Required `new` constructor expression",
+		range: this.thisNode.range
+	});
+	return resolveMaybePromise$1(this.reduceImmediate(arg0), (target) => {
+		if (typeof target !== "function") throw new FunCityReducerError({
+			type: "error",
+			description: "Required `new` constructor function",
+			range: arg0.range
+		});
+		if (!isConstructable(target)) throw new FunCityReducerError({
+			type: "error",
+			description: "Required `new` constructable function",
+			range: arg0.range
+		});
+		return resolveMaybePromise$1(Promise.all(rest.map((arg) => this.reduce(arg))), (args) => Reflect.construct(target, args));
+	});
+});
+var extractParameterArguments = (namesNode, _context) => {
+	switch (namesNode.kind) {
+		case "variable": return [namesNode];
+		case "list": {
+			const nameNodes = [];
+			for (const nameNode of namesNode.items) if (nameNode.kind !== "variable") throw new FunCityReducerError({
+				type: "error",
+				description: "Required `fun` parameter identity",
+				range: nameNode.range
+			});
+			else nameNodes.push(nameNode);
+			return nameNodes;
+		}
+		default: throw new FunCityReducerError({
+			type: "error",
+			description: "Required `fun` parameter identity",
+			range: namesNode.range
+		});
+	}
+};
+var _fun = makeFunCityFunction(function(arg0, arg1, ...rest) {
+	if (!arg0 || !arg1 || rest.length !== 0) throw new FunCityReducerError({
+		type: "error",
+		description: "Required `fun` parameter identity and expression",
+		range: this.thisNode.range
+	});
+	const nameNodes = extractParameterArguments(arg0, this);
+	if (!nameNodes) return;
+	const bodyNode = arg1;
+	const lambdaRange = this.thisNode.range;
+	const createScope = this.newScope;
+	return (...args) => {
+		if (args.length < nameNodes.length) throw new FunCityReducerError({
+			type: "error",
+			description: `Arguments are not filled: ${args.length} < ${nameNodes.length}`,
+			range: lambdaRange
+		});
+		else if (args.length > nameNodes.length) this.appendWarning({
+			type: "warning",
+			description: `Too many arguments: ${args.length} > ${nameNodes.length}`,
+			range: lambdaRange
+		});
+		const newContext = createScope();
+		for (let index = 0; index < nameNodes.length; index++) newContext.setValue(nameNodes[index].name, args[index], this.abortSignal);
+		return newContext.reduceExpressionNodeImmediate(bodyNode, this.abortSignal);
+	};
+});
+var _typeof = (arg0) => {
+	if (arg0 === null) return "null";
+	else if (typeof arg0 === "string") return "string";
+	else if (Array.isArray(arg0)) return "array";
+	else if (asIterable(arg0)) return "iterable";
+	else return typeof arg0;
+};
+var _toString = (...args) => {
+	return args.map((arg0) => convertToString(arg0)).join(",");
+};
+var _toBoolean = (arg0) => {
+	return isConditionalTrue(arg0);
+};
+var _toNumber = (arg0) => {
+	return Number(arg0);
+};
+var _toBigInt = (arg0) => {
+	switch (typeof arg0) {
+		case "number":
+		case "bigint":
+		case "string":
+		case "boolean": return BigInt(arg0);
+		default: return BigInt(_toString(arg0));
+	}
+};
+var _add = (arg0, ...args) => {
+	return args.reduce((v0, v) => v0 + Number(v), Number(arg0));
+};
+var _sub = (arg0, ...args) => {
+	return args.reduce((v0, v) => v0 - Number(v), Number(arg0));
+};
+var _mul = (arg0, ...args) => {
+	return args.reduce((v0, v) => v0 * Number(v), Number(arg0));
+};
+var _div = (arg0, ...args) => {
+	return args.reduce((v0, v) => v0 / Number(v), Number(arg0));
+};
+var _mod = (arg0, ...args) => {
+	return args.reduce((v0, v) => v0 % Number(v), Number(arg0));
+};
+var _eq = (arg0, arg1) => {
+	return arg0 === arg1;
+};
+var _ne = (arg0, arg1) => {
+	return arg0 !== arg1;
+};
+var _lt = (arg0, arg1) => {
+	return arg0 < arg1;
+};
+var _gt = (arg0, arg1) => {
+	return arg0 > arg1;
+};
+var _le = (arg0, arg1) => {
+	return arg0 <= arg1;
+};
+var _ge = (arg0, arg1) => {
+	return arg0 >= arg1;
+};
+var _now = () => {
+	return /* @__PURE__ */ new Date();
+};
+var _random = makeFunCityFunction(function(arg0, arg1, ...rest) {
+	if (!arg0 || rest.length !== 0) throw new FunCityReducerError({
+		type: "error",
+		description: "Required `random` range arguments",
+		range: this.thisNode.range
+	});
+	return resolveMaybePromise$1(this.reduceImmediate(arg0), (baseValue) => {
+		return resolveMaybePromise$1(arg1 ? this.reduceImmediate(arg1) : baseValue, (resolvedSpanValue) => {
+			const base = arg1 ? Number(baseValue) : 0;
+			const span = Number(resolvedSpanValue);
+			return base + Math.floor(Math.random() * span);
+		});
+	});
+});
+var _randomf = (arg0, arg1) => {
+	if (arg0 === void 0) return Math.random();
+	const base = arg1 === void 0 ? 0 : Number(arg0);
+	const span = Number(arg1 !== null && arg1 !== void 0 ? arg1 : arg0);
+	return base + Math.random() * span;
+};
+var concatInner = (sep, args) => {
+	let v = "";
+	let f = true;
+	for (const arg of args) {
+		let as;
+		if (typeof arg === "string") as = arg;
+		else {
+			const iterable = asIterable(arg);
+			if (iterable) as = concatInner(sep, iterable);
+			else as = convertToString(arg);
+		}
+		if (f) {
+			v = v + as;
+			f = false;
+		} else v = v + sep + as;
+	}
+	return v;
+};
+var _concat = (...args) => {
+	return concatInner("", args);
+};
+var _join = (arg0, ...args) => {
+	return concatInner(convertToString(arg0), args);
+};
+var _trim = (arg0) => {
+	let v = arg0;
+	if (v === void 0 || v === null) v = "";
+	else if (typeof v !== "string") {
+		var _v$toString;
+		v = (_v$toString = v.toString()) !== null && _v$toString !== void 0 ? _v$toString : "";
+	}
+	return v.trim();
+};
+var _toUpper = (arg0) => {
+	let v = arg0;
+	if (typeof v !== "string") {
+		var _v$toString2;
+		v = (_v$toString2 = v.toString()) !== null && _v$toString2 !== void 0 ? _v$toString2 : "";
+	}
+	return v.toUpperCase();
+};
+var _toLower = (arg0) => {
+	let v = arg0;
+	if (typeof v !== "string") {
+		var _v$toString3;
+		v = (_v$toString3 = v.toString()) !== null && _v$toString3 !== void 0 ? _v$toString3 : "";
+	}
+	return v.toLowerCase();
+};
+var _length = (arg0) => {
+	if (arg0) {
+		if (typeof arg0 === "string") return arg0.length;
+		else if (Array.isArray(arg0)) return arg0.length;
+		else if (asIterable(arg0)) {
+			let count = 0;
+			for (const _item of arg0) count++;
+			return count;
+		}
+	}
+	return 0;
+};
+var _and = makeFunCityFunction(function(...args) {
+	if (args.length === 0) throw new FunCityReducerError({
+		type: "error",
+		description: "empty arguments",
+		range: this.thisNode.range
+	});
+	for (let index = 0; index < args.length; index++) {
+		const value = this.reduceImmediate(args[index]);
+		if (isPromiseLike(value)) return (async () => {
+			if (!isConditionalTrue(await value)) return false;
+			for (let continueIndex = index + 1; continueIndex < args.length; continueIndex++) if (!isConditionalTrue(await this.reduceImmediate(args[continueIndex]))) return false;
+			return true;
+		})();
+		if (!isConditionalTrue(value)) return false;
+	}
+	return true;
+});
+var _or = makeFunCityFunction(function(...args) {
+	if (args.length === 0) throw new FunCityReducerError({
+		type: "error",
+		description: "empty arguments",
+		range: this.thisNode.range
+	});
+	for (let index = 0; index < args.length; index++) {
+		const value = this.reduceImmediate(args[index]);
+		if (isPromiseLike(value)) return (async () => {
+			if (isConditionalTrue(await value)) return true;
+			for (let continueIndex = index + 1; continueIndex < args.length; continueIndex++) if (isConditionalTrue(await this.reduceImmediate(args[continueIndex]))) return true;
+			return false;
+		})();
+		if (isConditionalTrue(value)) return true;
+	}
+	return false;
+});
+var _not = (arg0) => {
+	return !isConditionalTrue(arg0);
+};
+var _at = (arg0, arg1) => {
+	const index = Number(arg0);
+	if (arg1) if (typeof arg1 === "string") return arg1[index];
+	else if (Array.isArray(arg1)) return arg1[index];
+	else {
+		const iterable = asIterable(arg1);
+		if (iterable) {
+			let current = 0;
+			for (const item of iterable) {
+				if (current >= index) return item;
+				current++;
+			}
+		}
+	}
+};
+var _first = (arg0) => {
+	if (arg0) if (typeof arg0 === "string") return arg0[0];
+	else if (Array.isArray(arg0)) return arg0[0];
+	else {
+		const iterable = asIterable(arg0);
+		if (iterable) for (const item of iterable) return item;
+	}
+};
+var _last = (arg0) => {
+	if (arg0) if (typeof arg0 === "string") return arg0[arg0.length - 1];
+	else if (Array.isArray(arg0)) return arg0[arg0.length - 1];
+	else {
+		const iterable = asIterable(arg0);
+		if (iterable) {
+			let lastItem = void 0;
+			for (const item of iterable) lastItem = item;
+			return lastItem;
+		}
+	}
+};
+var _range = (arg0, arg1) => {
+	let value = Number(arg0);
+	const count = Number(arg1);
+	const resultList = [];
+	for (let index = 0; index < count; index++) resultList.push(value++);
+	return resultList;
+};
+var sliceIterable = (iter, start, end) => {
+	const resultList = [];
+	for (const item of iter) resultList.push(item);
+	return resultList.slice(start, end);
+};
+var _slice = (arg0, arg1, arg2) => {
+	const start = arg0 === void 0 ? void 0 : Number(arg0);
+	if (arg2 === void 0) {
+		if (typeof arg1 === "string") return arg1.slice(start);
+		return sliceIterable(arg1, start, void 0);
+	}
+	const end = arg1 === void 0 ? void 0 : Number(arg1);
+	if (typeof arg2 === "string") return arg2.slice(start, end);
+	return sliceIterable(arg2, start, end);
+};
+var _reverse = (arg0) => {
+	const iter = arg0;
+	let resultList = [];
+	for (const item of iter) resultList.push(item);
+	return resultList.reverse();
+};
+var _sort = (arg0) => {
+	const iter = arg0;
+	let resultList = [];
+	for (const item of iter) resultList.push(item);
+	return resultList.sort();
+};
+var _map = async (arg0, arg1) => {
+	const predicate = arg0;
+	const iter = arg1;
+	const resultList = [];
+	for (const item of iter) {
+		const result = await predicate(item);
+		resultList.push(result);
+	}
+	return resultList;
+};
+var _flatMap = async (arg0, arg1) => {
+	const predicate = arg0;
+	const iter = arg1;
+	const resultList = [];
+	for (const item of iter) {
+		const results = await predicate(item);
+		resultList.push(...results);
+	}
+	return resultList;
+};
+var _flatten = (arg0) => {
+	const iter = arg0;
+	const resultList = [];
+	for (const item of iter) {
+		const iterable = asIterable(item);
+		if (!iterable) throw new TypeError("flatten requires nested iterable items");
+		resultList.push(...iterable);
+	}
+	return resultList;
+};
+var _filter = async (arg0, arg1) => {
+	const predicate = arg0;
+	const iter = arg1;
+	const resultList = [];
+	for (const item of iter) if (isConditionalTrue(await predicate(item))) resultList.push(item);
+	return resultList;
+};
+var _collect = (arg0) => {
+	const iter = arg0;
+	const resultList = [];
+	for (const item of iter) if (item !== void 0 && item !== null) resultList.push(item);
+	return resultList;
+};
+var _distinct = (arg0) => {
+	const iter = arg0;
+	const seen = /* @__PURE__ */ new Set();
+	const resultList = [];
+	for (const item of iter) if (!seen.has(item)) {
+		seen.add(item);
+		resultList.push(item);
+	}
+	return resultList;
+};
+var _distinctBy = async (arg0, arg1) => {
+	const selector = arg0;
+	const iter = arg1;
+	const seen = /* @__PURE__ */ new Set();
+	const resultList = [];
+	for (const item of iter) {
+		const key = await selector(item);
+		if (!seen.has(key)) {
+			seen.add(key);
+			resultList.push(item);
+		}
+	}
+	return resultList;
+};
+var _union = (arg0, arg1) => {
+	if (arg0 instanceof Set && arg1 instanceof Set) {
+		const union = arg0.union;
+		if (typeof union === "function") return Array.from(union.call(arg0, arg1));
+	}
+	const resultList = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of arg0) if (!seen.has(item)) {
+		seen.add(item);
+		resultList.push(item);
+	}
+	for (const item of arg1) if (!seen.has(item)) {
+		seen.add(item);
+		resultList.push(item);
+	}
+	return resultList;
+};
+var _unionBy = async (arg0, arg1, arg2) => {
+	const selector = arg0;
+	const iterA = arg1;
+	const iterB = arg2;
+	const resultList = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of iterA) {
+		const key = await selector(item);
+		if (!seen.has(key)) {
+			seen.add(key);
+			resultList.push(item);
+		}
+	}
+	for (const item of iterB) {
+		const key = await selector(item);
+		if (!seen.has(key)) {
+			seen.add(key);
+			resultList.push(item);
+		}
+	}
+	return resultList;
+};
+var _intersection = (arg0, arg1) => {
+	if (arg0 instanceof Set && arg1 instanceof Set) {
+		const intersection = arg0.intersection;
+		if (typeof intersection === "function") return Array.from(intersection.call(arg0, arg1));
+	}
+	const iterA = arg0;
+	const setB = new Set(arg1);
+	const seen = /* @__PURE__ */ new Set();
+	const resultList = [];
+	for (const item of iterA) if (!seen.has(item) && setB.has(item)) {
+		seen.add(item);
+		resultList.push(item);
+	}
+	return resultList;
+};
+var _intersectionBy = async (arg0, arg1, arg2) => {
+	const selector = arg0;
+	const iterA = arg1;
+	const iterB = arg2;
+	const keysB = /* @__PURE__ */ new Set();
+	for (const item of iterB) {
+		const key = await selector(item);
+		keysB.add(key);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const resultList = [];
+	for (const item of iterA) {
+		const key = await selector(item);
+		if (!seen.has(key) && keysB.has(key)) {
+			seen.add(key);
+			resultList.push(item);
+		}
+	}
+	return resultList;
+};
+var _difference = (arg0, arg1) => {
+	if (arg0 instanceof Set && arg1 instanceof Set) {
+		const difference = arg0.difference;
+		if (typeof difference === "function") return Array.from(difference.call(arg0, arg1));
+	}
+	const iterA = arg0;
+	const setB = new Set(arg1);
+	const seen = /* @__PURE__ */ new Set();
+	const resultList = [];
+	for (const item of iterA) if (!seen.has(item) && !setB.has(item)) {
+		seen.add(item);
+		resultList.push(item);
+	}
+	return resultList;
+};
+var _differenceBy = async (arg0, arg1, arg2) => {
+	const selector = arg0;
+	const iterA = arg1;
+	const iterB = arg2;
+	const keysB = /* @__PURE__ */ new Set();
+	for (const item of iterB) {
+		const key = await selector(item);
+		keysB.add(key);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const resultList = [];
+	for (const item of iterA) {
+		const key = await selector(item);
+		if (!seen.has(key) && !keysB.has(key)) {
+			seen.add(key);
+			resultList.push(item);
+		}
+	}
+	return resultList;
+};
+var _symmetricDifference = (arg0, arg1) => {
+	if (arg0 instanceof Set && arg1 instanceof Set) {
+		const symmetricDifference = arg0.symmetricDifference;
+		if (typeof symmetricDifference === "function") return Array.from(symmetricDifference.call(arg0, arg1));
+	}
+	const iterA = arg0;
+	const iterB = arg1;
+	const itemsA = [];
+	const itemsB = [];
+	const setA = /* @__PURE__ */ new Set();
+	const setB = /* @__PURE__ */ new Set();
+	for (const item of iterA) if (!setA.has(item)) {
+		setA.add(item);
+		itemsA.push(item);
+	}
+	for (const item of iterB) if (!setB.has(item)) {
+		setB.add(item);
+		itemsB.push(item);
+	}
+	const resultList = [];
+	for (const item of itemsA) if (!setB.has(item)) resultList.push(item);
+	for (const item of itemsB) if (!setA.has(item)) resultList.push(item);
+	return resultList;
+};
+var _symmetricDifferenceBy = async (arg0, arg1, arg2) => {
+	const selector = arg0;
+	const iterA = arg1;
+	const iterB = arg2;
+	const keysA = /* @__PURE__ */ new Set();
+	const keysB = /* @__PURE__ */ new Set();
+	const itemsA = [];
+	const itemsB = [];
+	for (const item of iterA) {
+		const key = await selector(item);
+		if (!keysA.has(key)) {
+			keysA.add(key);
+			itemsA.push({
+				key,
+				item
+			});
+		}
+	}
+	for (const item of iterB) {
+		const key = await selector(item);
+		if (!keysB.has(key)) {
+			keysB.add(key);
+			itemsB.push({
+				key,
+				item
+			});
+		}
+	}
+	const resultList = [];
+	for (const entry of itemsA) if (!keysB.has(entry.key)) resultList.push(entry.item);
+	for (const entry of itemsB) if (!keysA.has(entry.key)) resultList.push(entry.item);
+	return resultList;
+};
+var _isSubsetOf = (arg0, arg1) => {
+	if (arg0 instanceof Set && arg1 instanceof Set) {
+		const isSubsetOf = arg0.isSubsetOf;
+		if (typeof isSubsetOf === "function") return isSubsetOf.call(arg0, arg1);
+	}
+	const iterA = arg0;
+	const setB = new Set(arg1);
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of iterA) {
+		if (seen.has(item)) continue;
+		seen.add(item);
+		if (!setB.has(item)) return false;
+	}
+	return true;
+};
+var _isSubsetOfBy = async (arg0, arg1, arg2) => {
+	const selector = arg0;
+	const iterA = arg1;
+	const iterB = arg2;
+	const keysB = /* @__PURE__ */ new Set();
+	for (const item of iterB) {
+		const key = await selector(item);
+		keysB.add(key);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of iterA) {
+		const key = await selector(item);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		if (!keysB.has(key)) return false;
+	}
+	return true;
+};
+var _isSupersetOf = (arg0, arg1) => {
+	if (arg0 instanceof Set && arg1 instanceof Set) {
+		const isSupersetOf = arg0.isSupersetOf;
+		if (typeof isSupersetOf === "function") return isSupersetOf.call(arg0, arg1);
+	}
+	const setA = new Set(arg0);
+	for (const item of arg1) if (!setA.has(item)) return false;
+	return true;
+};
+var _isSupersetOfBy = async (arg0, arg1, arg2) => {
+	const selector = arg0;
+	const iterA = arg1;
+	const iterB = arg2;
+	const keysA = /* @__PURE__ */ new Set();
+	for (const item of iterA) {
+		const key = await selector(item);
+		keysA.add(key);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of iterB) {
+		const key = await selector(item);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		if (!keysA.has(key)) return false;
+	}
+	return true;
+};
+var _isDisjointFrom = (arg0, arg1) => {
+	if (arg0 instanceof Set && arg1 instanceof Set) {
+		const isDisjointFrom = arg0.isDisjointFrom;
+		if (typeof isDisjointFrom === "function") return isDisjointFrom.call(arg0, arg1);
+	}
+	const setB = new Set(arg1);
+	for (const item of arg0) if (setB.has(item)) return false;
+	return true;
+};
+var _isDisjointFromBy = async (arg0, arg1, arg2) => {
+	const selector = arg0;
+	const iterA = arg1;
+	const iterB = arg2;
+	const keysB = /* @__PURE__ */ new Set();
+	for (const item of iterB) {
+		const key = await selector(item);
+		keysB.add(key);
+	}
+	for (const item of iterA) {
+		const key = await selector(item);
+		if (keysB.has(key)) return false;
+	}
+	return true;
+};
+var _reduce = async (arg0, arg1, arg2) => {
+	let acc = arg0;
+	const predicate = arg1;
+	const iter = arg2;
+	for (const item of iter) acc = await predicate(acc, item);
+	return acc;
+};
+var _match = (arg0, arg1) => {
+	const re = arg0 instanceof RegExp ? arg0 : new RegExp(convertToString(arg0), "g");
+	return convertToString(arg1).match(re);
+};
+var _replace = (arg0, arg1, arg2) => {
+	const re = arg0 instanceof RegExp ? arg0 : new RegExp(convertToString(arg0), "g");
+	const replace = convertToString(arg1);
+	return convertToString(arg2).replace(re, replace);
+};
+var _regex = (arg0, arg1) => {
+	if (arg1) return new RegExp(convertToString(arg0), convertToString(arg1));
+	else return new RegExp(convertToString(arg0));
+};
+var _bind = (arg0, ...args) => {
+	return arg0.bind(void 0, ...args);
+};
+var _url = (arg0, arg1) => {
+	return new URL(convertToString(arg0), arg1 !== void 0 ? convertToString(arg1) : void 0);
+};
+var _delay = async function(ms, value) {
+	const delayMs = Number(ms);
+	const signal = this.abortSignal;
+	if (!signal) return await new Promise((resolve) => {
+		setTimeout(resolve, delayMs, value);
+	});
+	signal.throwIfAborted();
+	return await new Promise((resolve, reject) => {
+		let timer;
+		const cleanup = () => {
+			if (timer !== void 0) {
+				clearTimeout(timer);
+				timer = void 0;
+			}
+			signal.removeEventListener("abort", onAbort);
+		};
+		const onAbort = () => {
+			cleanup();
+			try {
+				signal.throwIfAborted();
+			} catch (error) {
+				reject(error);
+				return;
+			}
+			const abortError = /* @__PURE__ */ new Error("Aborted");
+			abortError.name = "AbortError";
+			reject(abortError);
+		};
+		timer = setTimeout(() => {
+			if (signal.aborted) {
+				onAbort();
+				return;
+			}
+			cleanup();
+			resolve(value);
+		}, delayMs);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+};
+var createIncludeFunction = (options) => {
+	const { resolve, logs, mode = "template", scope = "child", includeMissing = "error", tryIncludeMissing = "empty" } = options;
+	let compileCacheModulePromise;
+	const getCompileCacheModule = async () => {
+		var _compileCacheModulePr;
+		(_compileCacheModulePr = compileCacheModulePromise) !== null && _compileCacheModulePr !== void 0 || (compileCacheModulePromise = Promise.resolve().then(() => compile_cache_exports));
+		return await compileCacheModulePromise;
+	};
+	const parseScript = async (script, sourceId) => {
+		const { compileScriptCached } = await getCompileCacheModule();
+		return compileScriptCached(script, sourceId, mode, "reducer");
+	};
+	const resolveSource = async (request, context) => {
+		const resolved = await resolve(request, context);
+		if (resolved === void 0 || resolved === null) return;
+		if (typeof resolved === "string") return {
+			sourceId: request,
+			script: resolved
+		};
+		return resolved;
+	};
+	const normalizeIncludeStack = (includeStack, sourceId) => includeStack[includeStack.length - 1] === sourceId ? includeStack : [...includeStack, sourceId];
+	const throwPrimaryParseError = (parseLogs) => {
+		let primaryError;
+		for (const entry of parseLogs) if (entry.type === "error" && primaryError === void 0) primaryError = entry;
+		else logs.push(entry);
+		if ((primaryError === null || primaryError === void 0 ? void 0 : primaryError.type) === "error") throw new FunCityReducerError(primaryError);
+	};
+	const withSameScopeIncludeFunctions = async (context, includeFunctions, run) => {
+		const previousInclude = context.getValue("include");
+		const previousTryInclude = context.getValue("tryInclude");
+		context.setValue("include", includeFunctions.include);
+		context.setValue("tryInclude", includeFunctions.tryInclude);
+		try {
+			return await run();
+		} finally {
+			if (previousInclude.isFound) context.setValue("include", previousInclude.value);
+			if (previousTryInclude.isFound) context.setValue("tryInclude", previousTryInclude.value);
+		}
+	};
+	const installIncludeFunctions = (context, includeFunctions, signal) => {
+		context.setValue("include", includeFunctions.include, signal);
+		context.setValue("tryInclude", includeFunctions.tryInclude, signal);
+	};
+	const reduceWithScope = async (context, nodes, includeFunctions) => {
+		if (scope === "same") return await withSameScopeIncludeFunctions(context, includeFunctions, () => context.reduceBlock(nodes));
+		const scopedContext = context.newScope();
+		installIncludeFunctions(scopedContext, includeFunctions, context.abortSignal);
+		const resultList = [];
+		for (const node of nodes) {
+			const results = await scopedContext.reduceNode(node, context.abortSignal);
+			for (const result of results) if (result !== void 0) resultList.push(result);
+		}
+		return resultList;
+	};
+	const createIncludeFunctions = (includeStack) => {
+		const renderIncluded = async (context, arg0, missingBehavior) => {
+			if (!arg0) throw new FunCityReducerError({
+				type: "error",
+				description: "Required `include` target",
+				range: context.thisNode.range
+			});
+			const resolvedArg = await context.reduce(arg0);
+			if (resolvedArg === void 0 || resolvedArg === null) {
+				if (missingBehavior === "empty") return "";
+				throw new FunCityReducerError({
+					type: "error",
+					description: "Required `include` target",
+					range: context.thisNode.range
+				});
+			}
+			const request = String(resolvedArg);
+			const activeIncludeStack = normalizeIncludeStack(includeStack, context.thisNode.range.sourceId);
+			const source = await resolveSource(request, {
+				sourceId: context.thisNode.range.sourceId,
+				range: context.thisNode.range,
+				signal: context.abortSignal
+			});
+			if (!source) {
+				if (missingBehavior === "empty") return "";
+				throw new FunCityReducerError({
+					type: "error",
+					description: `Include source not found: ${request}`,
+					range: context.thisNode.range
+				});
+			}
+			if (activeIncludeStack.includes(source.sourceId)) throw new FunCityReducerError({
+				type: "error",
+				description: `circular include detected: ${source.sourceId}`,
+				range: context.thisNode.range
+			});
+			const parsed = await parseScript(source.script, source.sourceId);
+			if (parsed.logs.length > 0) throwPrimaryParseError(parsed.logs);
+			const nestedIncludeFunctions = createIncludeFunctions([...activeIncludeStack, source.sourceId]);
+			return (await reduceWithScope(context, parsed.nodes, nestedIncludeFunctions)).map((value) => context.convertToString(value)).join("");
+		};
+		return {
+			include: makeFunCityFunction(async function(arg0) {
+				return await renderIncluded(this, arg0, includeMissing);
+			}),
+			tryInclude: makeFunCityFunction(async function(arg0) {
+				return await renderIncluded(this, arg0, tryIncludeMissing);
+			})
+		};
+	};
+	return createIncludeFunctions([]);
+};
+/**
+* Built-in standard variables and functions.
+*/
+var standardVariables = Object.freeze({
+	undefined: void 0,
+	null: null,
+	true: true,
+	false: false,
+	cond: _cond,
+	defaults: _defaults,
+	set: _set,
+	new: _new,
+	fun: _fun,
+	toString: _toString,
+	toBoolean: _toBoolean,
+	toNumber: _toNumber,
+	toBigInt: _toBigInt,
+	typeof: _typeof,
+	add: _add,
+	sub: _sub,
+	mul: _mul,
+	div: _div,
+	mod: _mod,
+	eq: _eq,
+	ne: _ne,
+	lt: _lt,
+	gt: _gt,
+	le: _le,
+	ge: _ge,
+	now: _now,
+	random: _random,
+	randomf: _randomf,
+	concat: _concat,
+	join: _join,
+	trim: _trim,
+	toUpper: _toUpper,
+	toLower: _toLower,
+	length: _length,
+	and: _and,
+	or: _or,
+	not: _not,
+	at: _at,
+	first: _first,
+	last: _last,
+	range: _range,
+	slice: _slice,
+	sort: _sort,
+	reverse: _reverse,
+	map: _map,
+	flatMap: _flatMap,
+	flatten: _flatten,
+	filter: _filter,
+	collect: _collect,
+	distinct: _distinct,
+	distinctBy: _distinctBy,
+	union: _union,
+	unionBy: _unionBy,
+	intersection: _intersection,
+	intersectionBy: _intersectionBy,
+	difference: _difference,
+	differenceBy: _differenceBy,
+	symmetricDifference: _symmetricDifference,
+	symmetricDifferenceBy: _symmetricDifferenceBy,
+	isSubsetOf: _isSubsetOf,
+	isSubsetOfBy: _isSubsetOfBy,
+	isSupersetOf: _isSupersetOf,
+	isSupersetOfBy: _isSupersetOfBy,
+	isDisjointFrom: _isDisjointFrom,
+	isDisjointFromBy: _isDisjointFromBy,
+	reduce: _reduce,
+	match: _match,
+	replace: _replace,
+	regex: _regex,
+	bind: _bind,
+	url: _url,
+	delay: _delay,
+	console
+});
+/**
+* Build a variable map that includes standard variables.
+* @param variablesList - Additional variable sources.
+* @returns Combined variable map.
+*/
+var buildCandidateVariables = (...variablesList) => {
+	return combineVariables(standardVariables, ...variablesList);
+};
+//#endregion
+//#region src/dcodegen.ts
+var throwError = (info) => {
+	throw new FunCityReducerError({
+		type: "error",
+		...info
+	});
+};
+var deconstructConditionalCombine = (name) => {
+	if (name.length >= 1) {
+		if (name[name.length - 1] === "?") return {
+			name: name.substring(0, name.length - 1),
+			canIgnore: true
+		};
+	}
+	return {
+		name,
+		canIgnore: false
+	};
+};
+var extractLambdaParameterNames = (node) => {
+	switch (node.kind) {
+		case "variable": return [node.name];
+		case "list": {
+			const names = [];
+			for (const item of node.items) {
+				if (item.kind !== "variable") return;
+				names.push(item.name);
+			}
+			return names;
+		}
+		default: return;
+	}
+};
+var resolveVariable = (context, result, range, signal) => {
+	const valueResult = context.getValue(result.name, signal);
+	if (!valueResult.isFound) {
+		if (!result.canIgnore) throwError({
+			description: `variable is not bound: ${result.name}`,
+			range
+		});
+		return;
+	}
+	return valueResult.value;
+};
+var filterUndefined = (results) => results.filter((result) => result !== void 0);
+var resolveMaybePromise = (value, onResolved) => {
+	if (isPromiseLike(value)) return value.then((resolved) => onResolved(resolved));
+	return onResolved(value);
+};
+var specializableStandardCallTargets = Object.freeze({
+	toString: standardVariables.toString,
+	toBoolean: standardVariables.toBoolean,
+	toNumber: standardVariables.toNumber,
+	toBigInt: standardVariables.toBigInt,
+	typeof: standardVariables.typeof,
+	add: standardVariables.add,
+	sub: standardVariables.sub,
+	mul: standardVariables.mul,
+	div: standardVariables.div,
+	mod: standardVariables.mod,
+	eq: standardVariables.eq,
+	ne: standardVariables.ne,
+	lt: standardVariables.lt,
+	gt: standardVariables.gt,
+	le: standardVariables.le,
+	ge: standardVariables.ge,
+	now: standardVariables.now,
+	randomf: standardVariables.randomf,
+	concat: standardVariables.concat,
+	join: standardVariables.join,
+	trim: standardVariables.trim,
+	toUpper: standardVariables.toUpper,
+	toLower: standardVariables.toLower,
+	length: standardVariables.length,
+	not: standardVariables.not,
+	at: standardVariables.at,
+	first: standardVariables.first,
+	last: standardVariables.last,
+	range: standardVariables.range,
+	slice: standardVariables.slice,
+	sort: standardVariables.sort,
+	reverse: standardVariables.reverse,
+	map: standardVariables.map,
+	flatMap: standardVariables.flatMap,
+	flatten: standardVariables.flatten,
+	filter: standardVariables.filter,
+	collect: standardVariables.collect,
+	distinct: standardVariables.distinct,
+	distinctBy: standardVariables.distinctBy,
+	union: standardVariables.union,
+	unionBy: standardVariables.unionBy,
+	intersection: standardVariables.intersection,
+	intersectionBy: standardVariables.intersectionBy,
+	difference: standardVariables.difference,
+	differenceBy: standardVariables.differenceBy,
+	symmetricDifference: standardVariables.symmetricDifference,
+	symmetricDifferenceBy: standardVariables.symmetricDifferenceBy,
+	isSubsetOf: standardVariables.isSubsetOf,
+	isSubsetOfBy: standardVariables.isSubsetOfBy,
+	isSupersetOf: standardVariables.isSupersetOf,
+	isSupersetOfBy: standardVariables.isSupersetOfBy,
+	isDisjointFrom: standardVariables.isDisjointFrom,
+	isDisjointFromBy: standardVariables.isDisjointFromBy,
+	reduce: standardVariables.reduce,
+	match: standardVariables.match,
+	replace: standardVariables.replace,
+	regex: standardVariables.regex,
+	bind: standardVariables.bind,
+	url: standardVariables.url
+});
+var toSpecializableStandardCallTarget = (name) => {
+	return specializableStandardCallTargets[name];
+};
+var AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
+var createRawBlockRunnerImmediate = (generators) => {
+	return (context, signal) => {
+		const resultList = [];
+		for (let index = 0; index < generators.length; index++) {
+			const results = generators[index](context, signal);
+			if (isPromiseLike(results)) return (async () => {
+				resultList.push(...await results);
+				for (let continueIndex = index + 1; continueIndex < generators.length; continueIndex++) resultList.push(...await generators[continueIndex](context, signal));
+				return resultList;
+			})();
+			resultList.push(...results);
+		}
+		return resultList;
+	};
+};
+var createTextBlockRunnerImmediate = (generators) => {
+	return (context, signal) => {
+		let result = "";
+		for (let index = 0; index < generators.length; index++) {
+			const text = generators[index](context, signal);
+			if (isPromiseLike(text)) return (async () => {
+				result += await text;
+				for (let continueIndex = index + 1; continueIndex < generators.length; continueIndex++) result += await generators[continueIndex](context, signal);
+				return result;
+			})();
+			result += text;
+		}
+		return result;
+	};
+};
+var collectExpressionValues = (generators, context, signal) => {
+	const resultList = [];
+	for (let index = 0; index < generators.length; index++) {
+		const result = generators[index](context, signal);
+		if (isPromiseLike(result)) return (async () => {
+			resultList.push(await result);
+			for (let continueIndex = index + 1; continueIndex < generators.length; continueIndex++) resultList.push(await generators[continueIndex](context, signal));
+			return resultList;
+		})();
+		resultList.push(result);
+	}
+	return resultList;
+};
+var handleApplyError = (node, error) => {
+	if (error instanceof FunCityReducerError) throw error;
+	if (error instanceof Error && error.name === "AbortError") throw error;
+	throw new FunCityReducerError({
+		type: "error",
+		description: fromError(error),
+		range: node.range
+	});
+};
+var resolveSourceVariable = (context, name, canIgnore, range, signal) => {
+	const valueResult = context.getValue(name, signal);
+	if (!valueResult.isFound) {
+		if (!canIgnore) throwError({
+			description: `variable is not bound: ${name}`,
+			range
+		});
+		return;
+	}
+	return valueResult.value;
+};
+var resolveSourceDotSegments = (context, baseValue, segments) => {
+	let value = baseValue;
+	let parent;
+	for (const segment of segments) {
+		if (value !== null && (typeof value === "object" || typeof value === "function")) {
+			const record = value;
+			parent = value;
+			value = record[segment.name];
+			continue;
+		}
+		if (!segment.canIgnore) throwError({
+			description: `variable is not bound: ${segment.name}`,
+			range: segment.range
+		});
+		return;
+	}
+	if (parent && typeof value === "function" && !isFunCityFunction(value)) return context.getBoundFunction(parent, value);
+	return value;
+};
+var invokeSourceCallable = async (context, node, signal, callable, args, _isSpecial) => {
+	try {
+		const thisProxy = context.createFunctionContext(node, signal);
+		return await callable.call(thisProxy, ...args);
+	} catch (error) {
+		return handleApplyError(node, error);
+	}
+};
+var invokeSourceBuiltin = async (node, builtin, args) => {
+	try {
+		return await builtin(...args);
+	} catch (error) {
+		return handleApplyError(node, error);
+	}
+};
+/**
+* Create a dynamic code generator.
+* @returns Dynamic code generator instance.
+*/
+var createClosureDCodegen = () => {
+	const expressionImmediateCache = /* @__PURE__ */ new WeakMap();
+	const expressionCache = /* @__PURE__ */ new WeakMap();
+	const blockImmediateCache = /* @__PURE__ */ new WeakMap();
+	const blockCache = /* @__PURE__ */ new WeakMap();
+	const rawProgramImmediateCache = /* @__PURE__ */ new WeakMap();
+	const textBlockImmediateCache = /* @__PURE__ */ new WeakMap();
+	const textProgramImmediateCache = /* @__PURE__ */ new WeakMap();
+	const textProgramCache = /* @__PURE__ */ new WeakMap();
+	const programImmediateCache = /* @__PURE__ */ new WeakMap();
+	const programCache = /* @__PURE__ */ new WeakMap();
+	const generateRawProgramImmediate = (nodes) => {
+		const cached = rawProgramImmediateCache.get(nodes);
+		if (cached) return cached;
+		const generator = createRawBlockRunnerImmediate(nodes.map(generateBlockImmediate));
+		rawProgramImmediateCache.set(nodes, generator);
+		return generator;
+	};
+	const generateTextProgramImmediate = (nodes) => {
+		const cached = textProgramImmediateCache.get(nodes);
+		if (cached) return cached;
+		const generator = createTextBlockRunnerImmediate(nodes.map(generateTextBlockImmediate));
+		textProgramImmediateCache.set(nodes, generator);
+		return generator;
+	};
+	const resolveDotNode = (context, node, signal, compiledBase, baseResult) => {
+		var _node$segments$0$opti, _node$segments$;
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		const firstSegmentOptional = (_node$segments$0$opti = (_node$segments$ = node.segments[0]) === null || _node$segments$ === void 0 ? void 0 : _node$segments$.optional) !== null && _node$segments$0$opti !== void 0 ? _node$segments$0$opti : false;
+		const resolveSegments = (baseValue) => {
+			let value = baseValue;
+			let parent;
+			for (const segment of node.segments) {
+				const result = deconstructConditionalCombine(segment.name);
+				const isOptional = segment.optional || result.canIgnore;
+				if (value !== null && (typeof value === "object" || typeof value === "function")) {
+					const record = value;
+					parent = value;
+					value = record[result.name];
+				} else {
+					if (!isOptional) throwError({
+						description: `variable is not bound: ${result.name}`,
+						range: segment.range
+					});
+					return;
+				}
+			}
+			if (parent && typeof value === "function" && !isFunCityFunction(value)) return context.getBoundFunction(parent, value);
+			return value;
+		};
+		if (baseResult) {
+			const valueResult = context.getValue(baseResult.name, signal);
+			if (!valueResult.isFound) {
+				if (!baseResult.canIgnore && !firstSegmentOptional) throwError({
+					description: `variable is not bound: ${baseResult.name}`,
+					range: node.base.range
+				});
+				return;
+			}
+			return resolveSegments(valueResult.value);
+		}
+		if (!compiledBase) return;
+		return resolveMaybePromise(compiledBase(context, signal), resolveSegments);
+	};
+	const applyResolvedFunction = (context, node, signal, callable, compiledArgs) => {
+		const resolvedArgs = isFunCityFunction(callable) ? node.args : collectExpressionValues(compiledArgs, context, signal);
+		const invokeCallable = (args) => {
+			try {
+				const thisProxy = context.createFunctionContext(node, signal);
+				return callable.call(thisProxy, ...args);
+			} catch (error) {
+				handleApplyError(node, error);
+			}
+		};
+		const result = resolveMaybePromise(resolvedArgs, (args) => invokeCallable(args));
+		if (isPromiseLike(result)) return result.catch((error) => handleApplyError(node, error));
+		return result;
+	};
+	const applySpecializedStandardFunction = (context, node, signal, builtin, compiledArgs) => {
+		const invokeBuiltin = (args) => {
+			try {
+				return builtin(...args);
+			} catch (error) {
+				handleApplyError(node, error);
+			}
+		};
+		const result = resolveMaybePromise(collectExpressionValues(compiledArgs, context, signal), (args) => invokeBuiltin(args));
+		if (isPromiseLike(result)) return result.catch((error) => handleApplyError(node, error));
+		return result;
+	};
+	const applyFunction = (context, node, signal, compiledFunc, compiledArgs) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		return resolveMaybePromise(compiledFunc(context, signal), (func) => {
+			if (typeof func !== "function") throwError({
+				description: "could not apply it for function",
+				range: node.range
+			});
+			return applyResolvedFunction(context, node, signal, func, compiledArgs);
+		});
+	};
+	const generateExpressionImmediate = (node) => {
+		const cached = expressionImmediateCache.get(node);
+		if (cached) return cached;
+		let generator;
+		switch (node.kind) {
+			case "number":
+			case "string":
+				generator = () => node.value;
+				break;
+			case "template": {
+				const generatedText = generateTextProgramImmediate(node.blocks);
+				generator = (context, signal) => generatedText(context, signal);
+				break;
+			}
+			case "variable": {
+				const variableResult = deconstructConditionalCombine(node.name);
+				generator = (context, signal) => resolveVariable(context, variableResult, node.range, signal);
+				break;
+			}
+			case "dot": {
+				const compiledBase = node.base.kind === "variable" ? void 0 : generateExpressionImmediate(node.base);
+				const baseResult = node.base.kind === "variable" ? deconstructConditionalCombine(node.base.name) : void 0;
+				generator = (context, signal) => resolveDotNode(context, node, signal, compiledBase, baseResult);
+				break;
+			}
+			case "apply": {
+				const compiledFunc = generateExpressionImmediate(node.func);
+				const compiledArgs = node.args.map(generateExpressionImmediate);
+				const isIntrinsicCond = node.func.kind === "variable" && node.func.name === "cond" && node.args.length === 3;
+				const intrinsicFunParameters = node.func.kind === "variable" && node.func.name === "fun" && node.args.length === 2 ? extractLambdaParameterNames(node.args[0]) : void 0;
+				const intrinsicFunBody = intrinsicFunParameters !== void 0 ? node.args[1] : void 0;
+				const compiledIntrinsicFunBody = intrinsicFunBody !== void 0 ? generateExpressionImmediate(intrinsicFunBody) : void 0;
+				const specializedBuiltinName = node.func.kind === "variable" ? node.func.name : void 0;
+				const specializedBuiltin = specializedBuiltinName !== void 0 ? toSpecializableStandardCallTarget(specializedBuiltinName) : void 0;
+				if (isIntrinsicCond) {
+					generator = (context, signal) => {
+						const boundFunction = context.getValue("cond", signal);
+						if (boundFunction.isFound && boundFunction.value === standardVariables.cond) return resolveMaybePromise(compiledArgs[0](context, signal), (condition) => isConditionalTrue(condition) ? compiledArgs[1](context, signal) : compiledArgs[2](context, signal));
+						return applyFunction(context, node, signal, compiledFunc, compiledArgs);
+					};
+					break;
+				}
+				if (compiledIntrinsicFunBody !== void 0 && intrinsicFunParameters !== void 0) {
+					generator = (context, signal) => {
+						const boundFunction = context.getValue("fun", signal);
+						if (boundFunction.isFound && boundFunction.value === standardVariables.fun) return (...args) => {
+							if (args.length < intrinsicFunParameters.length) throwError({
+								description: `Arguments are not filled: ${args.length} < ${intrinsicFunParameters.length}`,
+								range: node.range
+							});
+							if (args.length > intrinsicFunParameters.length) context.appendWarning({
+								type: "warning",
+								description: `Too many arguments: ${args.length} > ${intrinsicFunParameters.length}`,
+								range: node.range
+							});
+							return compiledIntrinsicFunBody(context.newCallScope(intrinsicFunParameters, args, signal), signal);
+						};
+						if (specializedBuiltin === void 0) return applyFunction(context, node, signal, compiledFunc, compiledArgs);
+						const specializedFunction = context.getValue(specializedBuiltinName, signal);
+						if (specializedFunction.isFound && specializedFunction.value === specializedBuiltin) return applySpecializedStandardFunction(context, node, signal, specializedBuiltin, compiledArgs);
+						return applyFunction(context, node, signal, compiledFunc, compiledArgs);
+					};
+					break;
+				}
+				if (specializedBuiltin === void 0) {
+					generator = (context, signal) => applyFunction(context, node, signal, compiledFunc, compiledArgs);
+					break;
+				}
+				generator = (context, signal) => {
+					const boundFunction = context.getValue(specializedBuiltinName, signal);
+					if (boundFunction.isFound && boundFunction.value === specializedBuiltin) return applySpecializedStandardFunction(context, node, signal, specializedBuiltin, compiledArgs);
+					return applyFunction(context, node, signal, compiledFunc, compiledArgs);
+				};
+				break;
+			}
+			case "list": {
+				const compiledItems = node.items.map(generateExpressionImmediate);
+				generator = (context, signal) => collectExpressionValues(compiledItems, context, signal);
+				break;
+			}
+			case "scope": {
+				const compiledNodes = node.nodes.map(generateExpressionImmediate);
+				generator = (context, signal) => {
+					if (compiledNodes.length === 0) return [];
+					let result = void 0;
+					for (let index = 0; index < compiledNodes.length; index++) {
+						const current = compiledNodes[index](context, signal);
+						if (isPromiseLike(current)) return (async () => {
+							result = await current;
+							for (let continueIndex = index + 1; continueIndex < compiledNodes.length; continueIndex++) result = await compiledNodes[continueIndex](context, signal);
+							return result;
+						})();
+						result = current;
+					}
+					return result;
+				};
+				break;
+			}
+		}
+		expressionImmediateCache.set(node, generator);
+		return generator;
+	};
+	const generateExpression = (node) => {
+		const cached = expressionCache.get(node);
+		if (cached) return cached;
+		const immediate = generateExpressionImmediate(node);
+		const generator = (context, signal) => Promise.resolve(immediate(context, signal));
+		expressionCache.set(node, generator);
+		return generator;
+	};
+	const generateBlockImmediate = (node) => {
+		const cached = blockImmediateCache.get(node);
+		if (cached) return cached;
+		let generator;
+		switch (node.kind) {
+			case "text":
+				generator = () => [node.text];
+				break;
+			case "for": {
+				const iterableGenerator = generateExpressionImmediate(node.iterable);
+				const repeatGenerator = generateRawProgramImmediate(node.repeat);
+				generator = (context, signal) => resolveMaybePromise(iterableGenerator(context, signal), (result) => {
+					const iterable = asIterable(result);
+					if (!iterable) throwError({
+						description: "could not apply it for function",
+						range: node.range
+					});
+					const resolvedIterable = iterable;
+					const resultList = [];
+					const iterator = resolvedIterable[Symbol.iterator]();
+					for (let current = iterator.next(); !current.done; current = iterator.next()) {
+						context.setValue(node.bind.name, current.value, signal);
+						const repeated = repeatGenerator(context, signal);
+						if (isPromiseLike(repeated)) return (async () => {
+							resultList.push(...await repeated);
+							for (let next = iterator.next(); !next.done; next = iterator.next()) {
+								context.setValue(node.bind.name, next.value, signal);
+								resultList.push(...await repeatGenerator(context, signal));
+							}
+							return resultList;
+						})();
+						resultList.push(...repeated);
+					}
+					return resultList;
+				});
+				break;
+			}
+			case "while": {
+				const conditionGenerator = generateExpressionImmediate(node.condition);
+				const repeatGenerator = generateRawProgramImmediate(node.repeat);
+				generator = (context, signal) => {
+					const resultList = [];
+					while (true) {
+						const condition = conditionGenerator(context, signal);
+						if (isPromiseLike(condition)) return (async () => {
+							let currentCondition = await condition;
+							while (isConditionalTrue(currentCondition)) {
+								resultList.push(...await repeatGenerator(context, signal));
+								currentCondition = await conditionGenerator(context, signal);
+							}
+							return resultList;
+						})();
+						if (!isConditionalTrue(condition)) return resultList;
+						const repeated = repeatGenerator(context, signal);
+						if (isPromiseLike(repeated)) return (async () => {
+							resultList.push(...await repeated);
+							while (true) {
+								if (!isConditionalTrue(await conditionGenerator(context, signal))) break;
+								resultList.push(...await repeatGenerator(context, signal));
+							}
+							return resultList;
+						})();
+						resultList.push(...repeated);
+					}
+				};
+				break;
+			}
+			case "if": {
+				const conditionGenerator = generateExpressionImmediate(node.condition);
+				const thenGenerator = generateRawProgramImmediate(node.then);
+				const elseGenerator = generateRawProgramImmediate(node.else);
+				generator = (context, signal) => resolveMaybePromise(conditionGenerator(context, signal), (condition) => isConditionalTrue(condition) ? thenGenerator(context, signal) : elseGenerator(context, signal));
+				break;
+			}
+			default: {
+				const expressionGenerator = generateExpressionImmediate(node);
+				generator = (context, signal) => resolveMaybePromise(expressionGenerator(context, signal), (result) => [result]);
+				break;
+			}
+		}
+		blockImmediateCache.set(node, generator);
+		return generator;
+	};
+	const generateBlock = (node) => {
+		const cached = blockCache.get(node);
+		if (cached) return cached;
+		const immediate = generateBlockImmediate(node);
+		const generator = (context, signal) => Promise.resolve(immediate(context, signal));
+		blockCache.set(node, generator);
+		return generator;
+	};
+	const generateTextBlockImmediate = (node) => {
+		const cached = textBlockImmediateCache.get(node);
+		if (cached) return cached;
+		let generator;
+		switch (node.kind) {
+			case "text":
+				generator = () => node.text;
+				break;
+			case "for": {
+				const iterableGenerator = generateExpressionImmediate(node.iterable);
+				const repeatGenerator = generateTextProgramImmediate(node.repeat);
+				generator = (context, signal) => resolveMaybePromise(iterableGenerator(context, signal), (result) => {
+					const iterable = asIterable(result);
+					if (!iterable) throwError({
+						description: "could not apply it for function",
+						range: node.range
+					});
+					const iterator = iterable[Symbol.iterator]();
+					let text = "";
+					for (let current = iterator.next(); !current.done; current = iterator.next()) {
+						context.setValue(node.bind.name, current.value, signal);
+						const repeated = repeatGenerator(context, signal);
+						if (isPromiseLike(repeated)) return (async () => {
+							text += await repeated;
+							for (let next = iterator.next(); !next.done; next = iterator.next()) {
+								context.setValue(node.bind.name, next.value, signal);
+								text += await repeatGenerator(context, signal);
+							}
+							return text;
+						})();
+						text += repeated;
+					}
+					return text;
+				});
+				break;
+			}
+			case "while": {
+				const conditionGenerator = generateExpressionImmediate(node.condition);
+				const repeatGenerator = generateTextProgramImmediate(node.repeat);
+				generator = (context, signal) => {
+					let text = "";
+					while (true) {
+						const condition = conditionGenerator(context, signal);
+						if (isPromiseLike(condition)) return (async () => {
+							let currentCondition = await condition;
+							while (isConditionalTrue(currentCondition)) {
+								text += await repeatGenerator(context, signal);
+								currentCondition = await conditionGenerator(context, signal);
+							}
+							return text;
+						})();
+						if (!isConditionalTrue(condition)) return text;
+						const repeated = repeatGenerator(context, signal);
+						if (isPromiseLike(repeated)) return (async () => {
+							text += await repeated;
+							while (true) {
+								if (!isConditionalTrue(await conditionGenerator(context, signal))) break;
+								text += await repeatGenerator(context, signal);
+							}
+							return text;
+						})();
+						text += repeated;
+					}
+				};
+				break;
+			}
+			case "if": {
+				const conditionGenerator = generateExpressionImmediate(node.condition);
+				const thenGenerator = generateTextProgramImmediate(node.then);
+				const elseGenerator = generateTextProgramImmediate(node.else);
+				generator = (context, signal) => resolveMaybePromise(conditionGenerator(context, signal), (condition) => isConditionalTrue(condition) ? thenGenerator(context, signal) : elseGenerator(context, signal));
+				break;
+			}
+			default: {
+				const expressionGenerator = generateExpressionImmediate(node);
+				generator = (context, signal) => resolveMaybePromise(expressionGenerator(context, signal), (result) => result === void 0 ? "" : context.convertToString(result));
+				break;
+			}
+		}
+		textBlockImmediateCache.set(node, generator);
+		return generator;
+	};
+	const generateProgramImmediate = (nodes) => {
+		const cached = programImmediateCache.get(nodes);
+		if (cached) return cached;
+		const generatedBlocks = generateRawProgramImmediate(nodes);
+		const generator = (context, signal) => resolveMaybePromise(generatedBlocks(context, signal), (results) => filterUndefined(results));
+		programImmediateCache.set(nodes, generator);
+		return generator;
+	};
+	const generateProgram = (nodes) => {
+		const cached = programCache.get(nodes);
+		if (cached) return cached;
+		const immediate = generateProgramImmediate(nodes);
+		const generator = (context, signal) => Promise.resolve(immediate(context, signal));
+		programCache.set(nodes, generator);
+		return generator;
+	};
+	const generateTextProgram = (nodes) => {
+		const cached = textProgramCache.get(nodes);
+		if (cached) return cached;
+		const immediate = generateTextProgramImmediate(nodes);
+		const generator = (context, signal) => Promise.resolve(immediate(context, signal));
+		textProgramCache.set(nodes, generator);
+		return generator;
+	};
+	const createExecutor = () => {
+		const reduceExpressionNodeImmediate = (context, node, signal) => generateExpressionImmediate(node)(context, signal);
+		const reduceNodeImmediate = (context, node, signal) => generateBlockImmediate(node)(context, signal);
+		return {
+			reduceExpressionNode: (context, node, signal) => Promise.resolve(reduceExpressionNodeImmediate(context, node, signal)),
+			reduceExpressionNodeImmediate,
+			reduceNode: (context, node, signal) => Promise.resolve(reduceNodeImmediate(context, node, signal)),
+			reduceNodeImmediate
+		};
+	};
+	return {
+		generateExpression,
+		generateBlock,
+		generateProgram,
+		generateTextProgram,
+		createExecutor
+	};
+};
+var createSourceRunner = (body) => {
+	return new AsyncFunction("context", "signal", "runtime", `'use strict';\n${body}`);
+};
+var stripAbortChecksFromSource = (body) => {
+	return body.replace(/(^|\n)signal\?\.throwIfAborted\(\);\n?/g, "$1");
+};
+var createAdaptiveSourceRunner = (body) => {
+	const runnerWithSignal = createSourceRunner(body);
+	const runnerWithoutSignal = createSourceRunner(stripAbortChecksFromSource(body));
+	return (context, signal, runtime) => signal === void 0 ? runnerWithoutSignal(context, void 0, runtime) : runnerWithSignal(context, signal, runtime);
+};
+var createSourceDCodegen = (options) => {
+	var _options$aggressiveOp;
+	const closureExecutor = createClosureDCodegen().createExecutor();
+	const aggressiveOptimize = (_options$aggressiveOp = options === null || options === void 0 ? void 0 : options.aggressiveOptimize) !== null && _options$aggressiveOp !== void 0 ? _options$aggressiveOp : false;
+	const expressionCache = /* @__PURE__ */ new WeakMap();
+	const blockCache = /* @__PURE__ */ new WeakMap();
+	const programCache = /* @__PURE__ */ new WeakMap();
+	const textProgramCache = /* @__PURE__ */ new WeakMap();
+	const addConstant = (state, value) => {
+		const index = state.constants.length;
+		state.constants.push(value);
+		return index;
+	};
+	const allocateTemp = (state, prefix) => {
+		return `__${prefix}${state.nextTempId++}`;
+	};
+	const emptyCompileScope = {
+		localSlots: /* @__PURE__ */ new Map(),
+		directBindings: /* @__PURE__ */ new Map(),
+		selfBindings: /* @__PURE__ */ new Map()
+	};
+	const extendCompileScope = (scope, name, slotVar) => {
+		return {
+			localSlots: new Map(scope.localSlots).set(name, slotVar),
+			directBindings: scope.directBindings,
+			selfBindings: scope.selfBindings
+		};
+	};
+	const extendDirectBindingCompileScope = (scope, name, bindingRef) => {
+		return {
+			localSlots: scope.localSlots,
+			directBindings: new Map(scope.directBindings).set(name, bindingRef),
+			selfBindings: scope.selfBindings
+		};
+	};
+	const extendSelfBindingCompileScope = (scope, name, bindingRef) => {
+		return {
+			localSlots: scope.localSlots,
+			directBindings: scope.directBindings,
+			selfBindings: new Map(scope.selfBindings).set(name, bindingRef)
+		};
+	};
+	const resolveLocalSlotRef = (scope, name) => {
+		return scope.localSlots.get(name);
+	};
+	const resolveSelfBindingRef = (scope, name) => {
+		return scope.selfBindings.get(name);
+	};
+	const resolveDirectBindingRef = (scope, name) => {
+		return scope.directBindings.get(name);
+	};
+	const createLookupResultSource = (scope, name) => {
+		const localSlotRef = resolveLocalSlotRef(scope, name);
+		return localSlotRef !== void 0 ? `{ isFound: true, value: context.getSlotValue(${localSlotRef}, signal) }` : `context.getValue(${JSON.stringify(name)}, signal)`;
+	};
+	const resolveAggressiveVariableSource = (state, name) => {
+		if (!state.aggressiveOptimize) return;
+		switch (name) {
+			case "undefined": return "undefined";
+			case "null": return "null";
+			case "true": return "true";
+			case "false": return "false";
+			case "cond": return "runtime.standardIntrinsics.cond";
+			case "fun": return "runtime.standardIntrinsics.fun";
+			case "set": return "runtime.standardIntrinsics.set";
+			case "add":
+			case "sub":
+			case "mul":
+			case "div":
+			case "mod":
+			case "eq":
+			case "ne":
+			case "lt":
+			case "gt":
+			case "le":
+			case "ge":
+			case "not": return `runtime.standardBuiltins.${name}`;
+			case "and":
+			case "or": return `runtime.constants[${addConstant(state, standardVariables[name])}]`;
+			case "range":
+			case "map":
+			case "filter":
+			case "reduce": return `runtime.standardBuiltins.${name}`;
+			default: return;
+		}
+	};
+	const canExpressionSuspend = (node) => {
+		switch (node.kind) {
+			case "number":
+			case "string":
+			case "variable": return false;
+			case "template": return canBlockListSuspend(node.blocks);
+			case "dot": return canExpressionSuspend(node.base);
+			case "apply": return true;
+			case "list": return node.items.some((item) => canExpressionSuspend(item));
+			case "scope": return node.nodes.some((childNode) => canExpressionSuspend(childNode));
+		}
+	};
+	const canBlockSuspend = (node) => {
+		switch (node.kind) {
+			case "text": return false;
+			case "for": return canExpressionSuspend(node.iterable) || canBlockListSuspend(node.repeat);
+			case "while": return canExpressionSuspend(node.condition) || canBlockListSuspend(node.repeat);
+			case "if": return canExpressionSuspend(node.condition) || canBlockListSuspend(node.then) || canBlockListSuspend(node.else);
+			default: return canExpressionSuspend(node);
+		}
+	};
+	const canBlockListSuspend = (nodes) => {
+		return nodes.some((node) => canBlockSuspend(node));
+	};
+	const expressionContainsSetForName = (node, name) => {
+		switch (node.kind) {
+			case "number":
+			case "string":
+			case "variable": return false;
+			case "template": return blockListContainsSetForName(node.blocks, name);
+			case "dot": return expressionContainsSetForName(node.base, name);
+			case "apply":
+				var _node$args$;
+				if (node.func.kind === "variable" && node.func.name === "set" && ((_node$args$ = node.args[0]) === null || _node$args$ === void 0 ? void 0 : _node$args$.kind) === "variable" && node.args[0].name === name) return true;
+				if (expressionContainsSetForName(node.func, name)) return true;
+				return node.args.some((arg) => expressionContainsSetForName(arg, name));
+			case "list": return node.items.some((item) => expressionContainsSetForName(item, name));
+			case "scope": return node.nodes.some((childNode) => blockContainsSetForName(childNode, name));
+		}
+	};
+	const blockContainsSetForName = (node, name) => {
+		switch (node.kind) {
+			case "text": return false;
+			case "for": return expressionContainsSetForName(node.iterable, name) || blockListContainsSetForName(node.repeat, name);
+			case "while": return expressionContainsSetForName(node.condition, name) || blockListContainsSetForName(node.repeat, name);
+			case "if": return expressionContainsSetForName(node.condition, name) || blockListContainsSetForName(node.then, name) || blockListContainsSetForName(node.else, name);
+			default: return expressionContainsSetForName(node, name);
+		}
+	};
+	const blockListContainsSetForName = (nodes, name) => {
+		return nodes.some((node) => blockContainsSetForName(node, name));
+	};
+	const wrapAwaitedSource = (source, canSuspend) => {
+		return canSuspend ? `await (${source})` : `(${source})`;
+	};
+	const wrapSourceClosure = (body, canSuspend) => {
+		return canSuspend ? `(async () => {\n${body}\n})()` : `(() => {\n${body}\n})()`;
+	};
+	const getBuiltinArgSource = (argVars, index) => {
+		var _argVars$index;
+		return (_argVars$index = argVars[index]) !== null && _argVars$index !== void 0 ? _argVars$index : "undefined";
+	};
+	const compileNumericFoldSource = (argVars, operator) => {
+		const initial = `Number(${getBuiltinArgSource(argVars, 0)})`;
+		return argVars.slice(1).reduce((expression, argVar) => `(${expression} ${operator} Number(${argVar}))`, initial);
+	};
+	const compileInlineStandardBuiltinSource = (name, argVars) => {
+		switch (name) {
+			case "toString": return `[${argVars.map((argVar) => `context.convertToString(${argVar})`).join(", ")}].join(',')`;
+			case "toBoolean": return `runtime.isConditionalTrue(${getBuiltinArgSource(argVars, 0)})`;
+			case "toNumber": return `Number(${getBuiltinArgSource(argVars, 0)})`;
+			case "toBigInt": return `(() => {
+const __value = ${getBuiltinArgSource(argVars, 0)};
+switch (typeof __value) {
+case 'number':
+case 'bigint':
+case 'string':
+case 'boolean':
+return BigInt(__value);
+default:
+return BigInt(context.convertToString(__value));
+}
+})()`;
+			case "typeof": return `(() => {
+const __value = ${getBuiltinArgSource(argVars, 0)};
+if (__value === null) {
+return 'null';
+}
+if (typeof __value === 'string') {
+return 'string';
+}
+if (Array.isArray(__value)) {
+return 'array';
+}
+if (runtime.asIterable(__value)) {
+return 'iterable';
+}
+return typeof __value;
+})()`;
+			case "add": return compileNumericFoldSource(argVars, "+");
+			case "sub": return compileNumericFoldSource(argVars, "-");
+			case "mul": return compileNumericFoldSource(argVars, "*");
+			case "div": return compileNumericFoldSource(argVars, "/");
+			case "mod": return compileNumericFoldSource(argVars, "%");
+			case "eq": return `(${getBuiltinArgSource(argVars, 0)} === ${getBuiltinArgSource(argVars, 1)})`;
+			case "ne": return `(${getBuiltinArgSource(argVars, 0)} !== ${getBuiltinArgSource(argVars, 1)})`;
+			case "lt": return `(${getBuiltinArgSource(argVars, 0)} < ${getBuiltinArgSource(argVars, 1)})`;
+			case "gt": return `(${getBuiltinArgSource(argVars, 0)} > ${getBuiltinArgSource(argVars, 1)})`;
+			case "le": return `(${getBuiltinArgSource(argVars, 0)} <= ${getBuiltinArgSource(argVars, 1)})`;
+			case "ge": return `(${getBuiltinArgSource(argVars, 0)} >= ${getBuiltinArgSource(argVars, 1)})`;
+			case "not": return `(!runtime.isConditionalTrue(${getBuiltinArgSource(argVars, 0)}))`;
+			case "trim": return `(() => {
+let __value = ${getBuiltinArgSource(argVars, 0)};
+if (__value === undefined || __value === null) {
+__value = '';
+} else if (typeof __value !== 'string') {
+__value = __value.toString() ?? '';
+}
+return __value.trim();
+})()`;
+			case "toUpper": return `(() => {
+let __value = ${getBuiltinArgSource(argVars, 0)};
+if (typeof __value !== 'string') {
+__value = __value.toString() ?? '';
+}
+return __value.toUpperCase();
+})()`;
+			case "toLower": return `(() => {
+let __value = ${getBuiltinArgSource(argVars, 0)};
+if (typeof __value !== 'string') {
+__value = __value.toString() ?? '';
+}
+return __value.toLowerCase();
+})()`;
+			case "length": return `(() => {
+const __value = ${getBuiltinArgSource(argVars, 0)};
+if (!__value) {
+return 0;
+}
+if (typeof __value === 'string' || Array.isArray(__value)) {
+return __value.length;
+}
+const __iterable = runtime.asIterable(__value);
+if (!__iterable) {
+return 0;
+}
+let __count = 0;
+for (const __item of __iterable) {
+__count++;
+}
+return __count;
+})()`;
+			case "at": return `(() => {
+const __index = Number(${getBuiltinArgSource(argVars, 0)});
+const __value = ${getBuiltinArgSource(argVars, 1)};
+if (!__value) {
+return undefined;
+}
+if (typeof __value === 'string' || Array.isArray(__value)) {
+return __value[__index];
+}
+const __iterable = runtime.asIterable(__value);
+if (!__iterable) {
+return undefined;
+}
+let __current = 0;
+for (const __item of __iterable) {
+if (__current >= __index) {
+return __item;
+}
+__current++;
+}
+return undefined;
+})()`;
+			case "first": return `(() => {
+const __value = ${getBuiltinArgSource(argVars, 0)};
+if (!__value) {
+return undefined;
+}
+if (typeof __value === 'string' || Array.isArray(__value)) {
+return __value[0];
+}
+const __iterable = runtime.asIterable(__value);
+if (!__iterable) {
+return undefined;
+}
+for (const __item of __iterable) {
+return __item;
+}
+return undefined;
+})()`;
+			case "last": return `(() => {
+const __value = ${getBuiltinArgSource(argVars, 0)};
+if (!__value) {
+return undefined;
+}
+if (typeof __value === 'string' || Array.isArray(__value)) {
+return __value[__value.length - 1];
+}
+const __iterable = runtime.asIterable(__value);
+if (!__iterable) {
+return undefined;
+}
+let __lastItem = undefined;
+for (const __item of __iterable) {
+__lastItem = __item;
+}
+return __lastItem;
+})()`;
+			case "slice": {
+				const startSource = getBuiltinArgSource(argVars, 0);
+				const middleSource = getBuiltinArgSource(argVars, 1);
+				const tailSource = getBuiltinArgSource(argVars, 2);
+				return `(() => {
+const __start = ${startSource} === undefined ? undefined : Number(${startSource});
+if (${tailSource} === undefined) {
+const __value = ${middleSource};
+if (typeof __value === 'string') {
+return __value.slice(__start);
+}
+return Array.from(__value).slice(__start, undefined);
+}
+const __end = ${middleSource} === undefined ? undefined : Number(${middleSource});
+const __value = ${tailSource};
+if (typeof __value === 'string') {
+return __value.slice(__start, __end);
+}
+return Array.from(__value).slice(__start, __end);
+})()`;
+			}
+			default: return;
+		}
+	};
+	const compileDirectInlineBuiltinApplySource = (state, node, scope, name) => {
+		const builtinArgVars = node.args.map(() => allocateTemp(state, "arg"));
+		const inlineBuiltinSource = compileInlineStandardBuiltinSource(name, builtinArgVars);
+		if (inlineBuiltinSource === void 0) return;
+		return wrapSourceClosure(`signal?.throwIfAborted();
+${node.args.map((arg, index) => {
+			const argSource = compileExpressionSource(state, arg, scope);
+			return `const ${builtinArgVars[index]} = ${wrapAwaitedSource(argSource, canExpressionSuspend(arg))};`;
+		}).join("\n")}
+return ${inlineBuiltinSource};`, node.args.some((arg) => canExpressionSuspend(arg)));
+	};
+	const compileDirectLogicalApplySource = (state, node, scope, kind) => {
+		const rangeIndex = addConstant(state, node.range);
+		if (node.args.length === 0) return wrapSourceClosure(`signal?.throwIfAborted();
+runtime.throwError({ description: 'empty arguments', range: runtime.constants[${rangeIndex}] });`, false);
+		const valueVars = node.args.map(() => allocateTemp(state, "value"));
+		return wrapSourceClosure(`signal?.throwIfAborted();
+${node.args.map((arg, index) => {
+			const valueVar = valueVars[index];
+			const argSource = compileExpressionSource(state, arg, scope);
+			const condition = kind === "and" ? `!runtime.isConditionalTrue(${valueVar})` : `runtime.isConditionalTrue(${valueVar})`;
+			const result = kind === "and" ? "false" : "true";
+			return `const ${valueVar} = ${wrapAwaitedSource(argSource, canExpressionSuspend(arg))};
+if (${condition}) {
+return ${result};
+}`;
+		}).join("\n")}
+return ${kind === "and" ? "true" : "false"};`, node.args.some((arg) => canExpressionSuspend(arg)));
+	};
+	const compileDirectRangeApplySource = (state, node, scope) => {
+		const startVar = allocateTemp(state, "start");
+		const countVar = allocateTemp(state, "count");
+		const resultVar = allocateTemp(state, "range");
+		const indexVar = allocateTemp(state, "index");
+		return wrapSourceClosure(`signal?.throwIfAborted();
+let ${startVar} = Number(${node.args[0] === void 0 ? "undefined" : wrapAwaitedSource(compileExpressionSource(state, node.args[0], scope), canExpressionSuspend(node.args[0]))});
+const ${countVar} = Number(${node.args[1] === void 0 ? "undefined" : wrapAwaitedSource(compileExpressionSource(state, node.args[1], scope), canExpressionSuspend(node.args[1]))});
+const ${resultVar} = [];
+for (let ${indexVar} = 0; ${indexVar} < ${countVar}; ${indexVar}++) {
+${resultVar}.push(${startVar}++);
+}
+return ${resultVar};`, node.args[0] !== void 0 && canExpressionSuspend(node.args[0]) || node.args[1] !== void 0 && canExpressionSuspend(node.args[1]));
+	};
+	const compileDirectCollectionApplySource = (state, node, scope, name) => {
+		if (name === "map") {
+			const mapperVar = allocateTemp(state, "mapper");
+			const iterableVar = allocateTemp(state, "iterable");
+			const resultVar = allocateTemp(state, "mapped");
+			const itemVar = allocateTemp(state, "item");
+			return wrapSourceClosure(`signal?.throwIfAborted();
+const ${mapperVar} = ${node.args[0] === void 0 ? "undefined" : wrapAwaitedSource(compileExpressionSource(state, node.args[0], scope), canExpressionSuspend(node.args[0]))};
+const ${iterableVar} = ${node.args[1] === void 0 ? "undefined" : wrapAwaitedSource(compileExpressionSource(state, node.args[1], scope), canExpressionSuspend(node.args[1]))};
+const ${resultVar} = [];
+for (const ${itemVar} of ${iterableVar}) {
+${resultVar}.push(await ${mapperVar}(${itemVar}));
+}
+return ${resultVar};`, true);
+		}
+		if (name === "filter") {
+			const predicateVar = allocateTemp(state, "predicate");
+			const iterableVar = allocateTemp(state, "iterable");
+			const resultVar = allocateTemp(state, "filtered");
+			const itemVar = allocateTemp(state, "item");
+			return wrapSourceClosure(`signal?.throwIfAborted();
+const ${predicateVar} = ${node.args[0] === void 0 ? "undefined" : wrapAwaitedSource(compileExpressionSource(state, node.args[0], scope), canExpressionSuspend(node.args[0]))};
+const ${iterableVar} = ${node.args[1] === void 0 ? "undefined" : wrapAwaitedSource(compileExpressionSource(state, node.args[1], scope), canExpressionSuspend(node.args[1]))};
+const ${resultVar} = [];
+for (const ${itemVar} of ${iterableVar}) {
+if (runtime.isConditionalTrue(await ${predicateVar}(${itemVar}))) {
+${resultVar}.push(${itemVar});
+}
+}
+return ${resultVar};`, true);
+		}
+		const accVar = allocateTemp(state, "acc");
+		const reducerVar = allocateTemp(state, "reducer");
+		const iterableVar = allocateTemp(state, "iterable");
+		const itemVar = allocateTemp(state, "item");
+		return wrapSourceClosure(`signal?.throwIfAborted();
+let ${accVar} = ${node.args[0] === void 0 ? "undefined" : wrapAwaitedSource(compileExpressionSource(state, node.args[0], scope), canExpressionSuspend(node.args[0]))};
+const ${reducerVar} = ${node.args[1] === void 0 ? "undefined" : wrapAwaitedSource(compileExpressionSource(state, node.args[1], scope), canExpressionSuspend(node.args[1]))};
+const ${iterableVar} = ${node.args[2] === void 0 ? "undefined" : wrapAwaitedSource(compileExpressionSource(state, node.args[2], scope), canExpressionSuspend(node.args[2]))};
+for (const ${itemVar} of ${iterableVar}) {
+${accVar} = await ${reducerVar}(${accVar}, ${itemVar});
+}
+return ${accVar};`, true);
+	};
+	const compileAggressiveApplySource = (state, node, scope) => {
+		if (!state.aggressiveOptimize || node.func.kind !== "variable") return;
+		switch (node.func.name) {
+			case "add":
+			case "sub":
+			case "mul":
+			case "div":
+			case "mod":
+			case "eq":
+			case "ne":
+			case "lt":
+			case "gt":
+			case "le":
+			case "ge":
+			case "not": return compileDirectInlineBuiltinApplySource(state, node, scope, node.func.name);
+			case "and":
+			case "or": return compileDirectLogicalApplySource(state, node, scope, node.func.name);
+			case "range": return compileDirectRangeApplySource(state, node, scope);
+			case "map":
+			case "filter":
+			case "reduce": return compileDirectCollectionApplySource(state, node, scope, node.func.name);
+			default: return;
+		}
+	};
+	const deconstructAggressiveRangeLoop = (state, node) => {
+		if (!state.aggressiveOptimize || node.kind !== "apply") return;
+		if (node.func.kind !== "variable" || node.func.name !== "range") return;
+		return {
+			startNode: node.args[0],
+			countNode: node.args[1]
+		};
+	};
+	const toNumberLiteral = (state, value) => {
+		if (Object.is(value, -0)) return "-0";
+		if (Number.isFinite(value)) return String(value);
+		return `runtime.constants[${addConstant(state, value)}]`;
+	};
+	const createRuntime = (constants) => {
+		return {
+			constants,
+			standardBuiltins: specializableStandardCallTargets,
+			standardIntrinsics: {
+				cond: standardVariables.cond,
+				fun: standardVariables.fun,
+				set: standardVariables.set
+			},
+			asIterable,
+			isConditionalTrue,
+			isFunCityFunction,
+			throwError,
+			handleApplyError,
+			resolveVariable: resolveSourceVariable,
+			resolveDotSegments: resolveSourceDotSegments,
+			invokeCallable: invokeSourceCallable,
+			invokeBuiltin: invokeSourceBuiltin
+		};
+	};
+	const compileBlockStatements = (state, node, targetVar, filterUndefinedValues, scope) => {
+		switch (node.kind) {
+			case "text": return `${targetVar}.push(${JSON.stringify(node.text)});\n`;
+			case "for": {
+				const iterableVar = allocateTemp(state, "iterable");
+				const slotVar = allocateTemp(state, "slot");
+				const itemVar = allocateTemp(state, "item");
+				const rangeIndex = addConstant(state, node.range);
+				return `{
+const ${iterableVar} = runtime.asIterable(${wrapAwaitedSource(compileExpressionSource(state, node.iterable, scope), canExpressionSuspend(node.iterable))});
+if (!${iterableVar}) {
+runtime.throwError({ description: 'could not apply it for function', range: runtime.constants[${rangeIndex}] });
+}
+const ${slotVar} = context.ensureLocalSlot(${JSON.stringify(node.bind.name)}, signal);
+for (const ${itemVar} of ${iterableVar}) {
+context.setSlotValue(${slotVar}, ${itemVar}, signal);
+${compileBlockListStatements(state, node.repeat, targetVar, filterUndefinedValues, extendCompileScope(scope, node.bind.name, slotVar))}
+}
+}\n`;
+			}
+			case "while": return `while (runtime.isConditionalTrue(${wrapAwaitedSource(compileExpressionSource(state, node.condition, scope), canExpressionSuspend(node.condition))})) {
+${compileBlockListStatements(state, node.repeat, targetVar, filterUndefinedValues, scope)}
+}\n`;
+			case "if": return `if (runtime.isConditionalTrue(${wrapAwaitedSource(compileExpressionSource(state, node.condition, scope), canExpressionSuspend(node.condition))})) {
+${compileBlockListStatements(state, node.then, targetVar, filterUndefinedValues, scope)}
+} else {
+${compileBlockListStatements(state, node.else, targetVar, filterUndefinedValues, scope)}
+}\n`;
+			default: {
+				const valueVar = allocateTemp(state, "value");
+				return `{
+const ${valueVar} = ${wrapAwaitedSource(compileExpressionSource(state, node, scope), canExpressionSuspend(node))};
+${filterUndefinedValues ? `if (${valueVar} !== undefined) { ${targetVar}.push(${valueVar}); }` : `${targetVar}.push(${valueVar});`}
+}\n`;
+			}
+		}
+	};
+	const compileBlockListStatements = (state, nodes, targetVar, filterUndefinedValues, scope) => {
+		return nodes.map((node) => compileBlockStatements(state, node, targetVar, filterUndefinedValues, scope)).join("");
+	};
+	const compileTextBlockStatements = (state, node, targetVar, scope) => {
+		switch (node.kind) {
+			case "text": return `${targetVar} += ${JSON.stringify(node.text)};\n`;
+			case "for": {
+				const aggressiveRangeLoop = deconstructAggressiveRangeLoop(state, node.iterable);
+				if (aggressiveRangeLoop !== void 0) {
+					const startVar = allocateTemp(state, "start");
+					const countVar = allocateTemp(state, "count");
+					const indexVar = allocateTemp(state, "index");
+					const itemVar = allocateTemp(state, "item");
+					const startSource = aggressiveRangeLoop.startNode === void 0 ? "undefined" : wrapAwaitedSource(compileExpressionSource(state, aggressiveRangeLoop.startNode, scope), canExpressionSuspend(aggressiveRangeLoop.startNode));
+					const countSource = aggressiveRangeLoop.countNode === void 0 ? "undefined" : wrapAwaitedSource(compileExpressionSource(state, aggressiveRangeLoop.countNode, scope), canExpressionSuspend(aggressiveRangeLoop.countNode));
+					if (!blockListContainsSetForName(node.repeat, node.bind.name)) return `{
+let ${startVar} = Number(${startSource});
+const ${countVar} = Number(${countSource});
+for (let ${indexVar} = 0; ${indexVar} < ${countVar}; ${indexVar}++) {
+const ${itemVar} = ${startVar}++;
+${compileTextBlockListStatements(state, node.repeat, targetVar, extendDirectBindingCompileScope(scope, node.bind.name, itemVar))}
+}
+}\n`;
+					const slotVar = allocateTemp(state, "slot");
+					return `{
+let ${startVar} = Number(${startSource});
+const ${countVar} = Number(${countSource});
+const ${slotVar} = context.ensureLocalSlot(${JSON.stringify(node.bind.name)}, signal);
+for (let ${indexVar} = 0; ${indexVar} < ${countVar}; ${indexVar}++) {
+const ${itemVar} = ${startVar}++;
+context.setSlotValue(${slotVar}, ${itemVar}, signal);
+${compileTextBlockListStatements(state, node.repeat, targetVar, extendCompileScope(scope, node.bind.name, slotVar))}
+}
+}\n`;
+				}
+				const iterableVar = allocateTemp(state, "iterable");
+				const slotVar = allocateTemp(state, "slot");
+				const itemVar = allocateTemp(state, "item");
+				const rangeIndex = addConstant(state, node.range);
+				return `{
+const ${iterableVar} = runtime.asIterable(${wrapAwaitedSource(compileExpressionSource(state, node.iterable, scope), canExpressionSuspend(node.iterable))});
+if (!${iterableVar}) {
+runtime.throwError({ description: 'could not apply it for function', range: runtime.constants[${rangeIndex}] });
+}
+const ${slotVar} = context.ensureLocalSlot(${JSON.stringify(node.bind.name)}, signal);
+for (const ${itemVar} of ${iterableVar}) {
+context.setSlotValue(${slotVar}, ${itemVar}, signal);
+${compileTextBlockListStatements(state, node.repeat, targetVar, extendCompileScope(scope, node.bind.name, slotVar))}
+}
+}\n`;
+			}
+			case "while": return `while (runtime.isConditionalTrue(${wrapAwaitedSource(compileExpressionSource(state, node.condition, scope), canExpressionSuspend(node.condition))})) {
+${compileTextBlockListStatements(state, node.repeat, targetVar, scope)}
+}\n`;
+			case "if": return `if (runtime.isConditionalTrue(${wrapAwaitedSource(compileExpressionSource(state, node.condition, scope), canExpressionSuspend(node.condition))})) {
+${compileTextBlockListStatements(state, node.then, targetVar, scope)}
+} else {
+${compileTextBlockListStatements(state, node.else, targetVar, scope)}
+}\n`;
+			default: {
+				const valueVar = allocateTemp(state, "value");
+				const valueSource = compileExpressionSource(state, node, scope);
+				if (state.aggressiveOptimize) return `{
+const ${valueVar} = ${wrapAwaitedSource(valueSource, canExpressionSuspend(node))};
+if (${valueVar} !== undefined) {
+if (${valueVar} === null) {
+${targetVar} += '(null)';
+} else {
+switch (typeof ${valueVar}) {
+case 'string':
+${targetVar} += ${valueVar};
+break;
+case 'boolean':
+case 'number':
+case 'bigint':
+case 'symbol':
+${targetVar} += ${valueVar}.toString();
+break;
+default:
+${targetVar} += context.convertToString(${valueVar});
+break;
+}
+}
+}
+}\n`;
+				return `{
+const ${valueVar} = ${wrapAwaitedSource(valueSource, canExpressionSuspend(node))};
+if (${valueVar} !== undefined) {
+${targetVar} += context.convertToString(${valueVar});
+}
+}\n`;
+			}
+		}
+	};
+	const compileTextBlockListStatements = (state, nodes, targetVar, scope) => {
+		return nodes.map((node) => compileTextBlockStatements(state, node, targetVar, scope)).join("");
+	};
+	const compileIntrinsicLambdaSource = (state, lambdaRange, parameterNames, bodyNode, scope, selfBinding) => {
+		const lambdaArgsVar = allocateTemp(state, "args");
+		const lambdaContextVar = allocateTemp(state, "context");
+		const rangeIndex = addConstant(state, lambdaRange);
+		const parameterNamesIndex = addConstant(state, [...parameterNames]);
+		const parameterSlotRefs = /* @__PURE__ */ new Map();
+		for (const parameterName of parameterNames) if (!parameterSlotRefs.has(parameterName)) parameterSlotRefs.set(parameterName, String(parameterSlotRefs.size));
+		const bodySource = compileExpressionSource(state, bodyNode, Array.from(parameterSlotRefs.entries()).reduce((currentScope, [parameterName, slotRef]) => extendCompileScope(currentScope, parameterName, slotRef), selfBinding === void 0 ? scope : extendSelfBindingCompileScope(scope, selfBinding.name, selfBinding.bindingRef)));
+		return `(...${lambdaArgsVar}) => {
+if (${lambdaArgsVar}.length < ${parameterNames.length}) {
+runtime.throwError({ description: 'Arguments are not filled: ' + ${lambdaArgsVar}.length + ' < ${parameterNames.length}', range: runtime.constants[${rangeIndex}] });
+}
+if (${lambdaArgsVar}.length > ${parameterNames.length}) {
+context.appendWarning({ type: 'warning', description: 'Too many arguments: ' + ${lambdaArgsVar}.length + ' > ${parameterNames.length}', range: runtime.constants[${rangeIndex}] });
+}
+const ${lambdaContextVar} = context.newCallScope(runtime.constants[${parameterNamesIndex}], ${lambdaArgsVar}, signal);
+return ((context) => {
+return ${bodySource};
+})(${lambdaContextVar});
+}`;
+	};
+	const compileGenericApplySource = (state, node, scope) => {
+		const applyNodeIndex = addConstant(state, node);
+		const rangeIndex = addConstant(state, node.range);
+		const argsNodeIndex = addConstant(state, node.args);
+		const argArraySource = `[${node.args.map((arg) => wrapAwaitedSource(compileExpressionSource(state, arg, scope), canExpressionSuspend(arg))).join(", ")}]`;
+		if (node.func.kind === "variable") {
+			if (toSpecializableStandardCallTarget(node.func.name) !== void 0) {
+				const bindingVar = allocateTemp(state, "binding");
+				const funcVar = allocateTemp(state, "func");
+				const callArgsVar = allocateTemp(state, "args");
+				const builtinArgVars = node.args.map(() => allocateTemp(state, "arg"));
+				const inlineBuiltinSource = compileInlineStandardBuiltinSource(node.func.name, builtinArgVars);
+				const builtinArgStatements = node.args.map((arg, index) => {
+					const argSource = compileExpressionSource(state, arg, scope);
+					return `const ${builtinArgVars[index]} = ${wrapAwaitedSource(argSource, canExpressionSuspend(arg))};`;
+				}).join("\n");
+				return `(async () => {
+signal?.throwIfAborted();
+const ${bindingVar} = ${createLookupResultSource(scope, node.func.name)};
+if (${bindingVar}.isFound && ${bindingVar}.value === runtime.standardBuiltins.${node.func.name}) {
+${builtinArgStatements}
+try {
+return ${inlineBuiltinSource !== null && inlineBuiltinSource !== void 0 ? inlineBuiltinSource : `await runtime.standardBuiltins.${node.func.name}(${builtinArgVars.join(", ")})`};
+} catch (error) {
+return runtime.handleApplyError(runtime.constants[${applyNodeIndex}], error);
+}
+}
+const ${funcVar} = ${bindingVar}.isFound
+? ${bindingVar}.value
+: runtime.resolveVariable(context, ${JSON.stringify(node.func.name)}, false, runtime.constants[${addConstant(state, node.func.range)}], signal);
+if (typeof ${funcVar} !== 'function') {
+runtime.throwError({ description: 'could not apply it for function', range: runtime.constants[${rangeIndex}] });
+}
+if (runtime.isFunCityFunction(${funcVar})) {
+return runtime.invokeCallable(context, runtime.constants[${applyNodeIndex}], signal, ${funcVar}, runtime.constants[${argsNodeIndex}], true);
+}
+const ${callArgsVar} = ${argArraySource};
+return runtime.invokeCallable(context, runtime.constants[${applyNodeIndex}], signal, ${funcVar}, ${callArgsVar}, false);
+})()`;
+			}
+		}
+		const funcVar = allocateTemp(state, "func");
+		const argsVar = allocateTemp(state, "args");
+		return `(async () => {
+signal?.throwIfAborted();
+const ${funcVar} = ${wrapAwaitedSource(compileExpressionSource(state, node.func, scope), canExpressionSuspend(node.func))};
+if (typeof ${funcVar} !== 'function') {
+runtime.throwError({ description: 'could not apply it for function', range: runtime.constants[${rangeIndex}] });
+}
+if (runtime.isFunCityFunction(${funcVar})) {
+return runtime.invokeCallable(context, runtime.constants[${applyNodeIndex}], signal, ${funcVar}, runtime.constants[${argsNodeIndex}], true);
+}
+const ${argsVar} = ${argArraySource};
+return runtime.invokeCallable(context, runtime.constants[${applyNodeIndex}], signal, ${funcVar}, ${argsVar}, false);
+})()`;
+	};
+	const compileExpressionSource = (state, node, scope) => {
+		switch (node.kind) {
+			case "number": return toNumberLiteral(state, node.value);
+			case "string": return JSON.stringify(node.value);
+			case "template": {
+				const textVar = allocateTemp(state, "text");
+				return wrapSourceClosure(`let ${textVar} = '';
+${compileTextBlockListStatements(state, node.blocks, textVar, scope)}
+return ${textVar};`, canBlockListSuspend(node.blocks));
+			}
+			case "variable": {
+				const variableResult = deconstructConditionalCombine(node.name);
+				const aggressiveSource = resolveAggressiveVariableSource(state, variableResult.name);
+				if (aggressiveSource !== void 0) return aggressiveSource;
+				const localSlotRef = resolveLocalSlotRef(scope, variableResult.name);
+				if (localSlotRef !== void 0) return `context.getSlotValue(${localSlotRef}, signal)`;
+				const directBindingRef = resolveDirectBindingRef(scope, variableResult.name);
+				if (directBindingRef !== void 0) return directBindingRef;
+				const selfBindingRef = resolveSelfBindingRef(scope, variableResult.name);
+				if (selfBindingRef !== void 0) return selfBindingRef;
+				const rangeIndex = addConstant(state, node.range);
+				return `runtime.resolveVariable(context, ${JSON.stringify(variableResult.name)}, ${variableResult.canIgnore ? "true" : "false"}, runtime.constants[${rangeIndex}], signal)`;
+			}
+			case "dot": {
+				const segmentsIndex = addConstant(state, node.segments.map((segment) => {
+					const result = deconstructConditionalCombine(segment.name);
+					return {
+						name: result.name,
+						canIgnore: segment.optional || result.canIgnore,
+						range: segment.range
+					};
+				}));
+				if (node.base.kind === "variable") {
+					var _node$segments$0$opti2, _node$segments$2;
+					const baseResult = deconstructConditionalCombine(node.base.name);
+					const localSlotRef = resolveLocalSlotRef(scope, baseResult.name);
+					const baseRangeIndex = addConstant(state, node.base.range);
+					const baseValueVar = allocateTemp(state, "base");
+					return wrapSourceClosure(`signal?.throwIfAborted();
+const ${baseValueVar} = ${localSlotRef !== void 0 ? `{ isFound: true, value: context.getSlotValue(${localSlotRef}, signal) }` : createLookupResultSource(scope, baseResult.name)};
+if (!${baseValueVar}.isFound) {
+${baseResult.canIgnore || ((_node$segments$0$opti2 = (_node$segments$2 = node.segments[0]) === null || _node$segments$2 === void 0 ? void 0 : _node$segments$2.optional) !== null && _node$segments$0$opti2 !== void 0 ? _node$segments$0$opti2 : false) ? "return undefined;" : `runtime.throwError({ description: ${JSON.stringify(`variable is not bound: ${baseResult.name}`)}, range: runtime.constants[${baseRangeIndex}] });`}
+}
+return runtime.resolveDotSegments(context, ${baseValueVar}.value, runtime.constants[${segmentsIndex}]);`, false);
+				}
+				return wrapSourceClosure(`signal?.throwIfAborted();
+return runtime.resolveDotSegments(
+context,
+${wrapAwaitedSource(compileExpressionSource(state, node.base, scope), canExpressionSuspend(node.base))},
+runtime.constants[${segmentsIndex}]
+);`, canExpressionSuspend(node.base));
+			}
+			case "apply": {
+				if (node.func.kind === "variable" && resolveLocalSlotRef(scope, node.func.name) === void 0) {
+					const selfBindingRef = resolveSelfBindingRef(scope, node.func.name);
+					if (selfBindingRef !== void 0) return wrapSourceClosure(`signal?.throwIfAborted();
+return ${selfBindingRef}(${node.args.map((arg) => wrapAwaitedSource(compileExpressionSource(state, arg, scope), canExpressionSuspend(arg))).join(", ")});`, node.args.some((arg) => canExpressionSuspend(arg)));
+				}
+				if (node.func.kind === "variable" && node.func.name === "set" && node.args.length === 2 && node.args[0].kind === "variable" && node.args[1].kind === "apply" && node.args[1].func.kind === "variable" && node.args[1].func.name === "fun" && node.args[1].args.length === 2) {
+					const parameterNames = extractLambdaParameterNames(node.args[1].args[0]);
+					if (parameterNames !== void 0) {
+						const boundName = node.args[0].name;
+						const lambdaVar = allocateTemp(state, "lambda");
+						const lambdaSource = compileIntrinsicLambdaSource(state, node.args[1].range, parameterNames, node.args[1].args[1], scope, {
+							name: boundName,
+							bindingRef: lambdaVar
+						});
+						if (state.aggressiveOptimize) return wrapSourceClosure(`signal?.throwIfAborted();
+const ${lambdaVar} = ${lambdaSource};
+context.setValue(${JSON.stringify(boundName)}, ${lambdaVar}, signal);
+return undefined;`, true);
+						const setBindingVar = allocateTemp(state, "binding");
+						const funBindingVar = allocateTemp(state, "binding");
+						return wrapSourceClosure(`signal?.throwIfAborted();
+const ${setBindingVar} = ${createLookupResultSource(scope, "set")};
+const ${funBindingVar} = ${createLookupResultSource(scope, "fun")};
+if (${setBindingVar}.isFound && ${setBindingVar}.value === runtime.standardIntrinsics.set && ${funBindingVar}.isFound && ${funBindingVar}.value === runtime.standardIntrinsics.fun) {
+const ${lambdaVar} = ${lambdaSource};
+context.setValue(${JSON.stringify(boundName)}, ${lambdaVar}, signal);
+return undefined;
+}
+return ${compileGenericApplySource(state, node, scope)};`, true);
+					}
+				}
+				if (node.func.kind === "variable" && state.aggressiveOptimize && node.func.name === "set" && node.args.length === 2 && node.args[0].kind === "variable") {
+					const valueSource = compileExpressionSource(state, node.args[1], scope);
+					return wrapSourceClosure(`signal?.throwIfAborted();
+context.setValue(${JSON.stringify(node.args[0].name)}, ${wrapAwaitedSource(valueSource, canExpressionSuspend(node.args[1]))}, signal);
+return undefined;`, canExpressionSuspend(node.args[1]));
+				}
+				if (node.func.kind === "variable" && node.func.name === "cond" && node.args.length === 3) {
+					const conditionNode = node.args[0];
+					const thenNode = node.args[1];
+					const elseNode = node.args[2];
+					const bindingVar = allocateTemp(state, "binding");
+					const conditionVar = allocateTemp(state, "condition");
+					const conditionSource = compileExpressionSource(state, conditionNode, scope);
+					const thenSource = compileExpressionSource(state, thenNode, scope);
+					const elseSource = compileExpressionSource(state, elseNode, scope);
+					if (state.aggressiveOptimize) return wrapSourceClosure(`signal?.throwIfAborted();
+const ${conditionVar} = ${wrapAwaitedSource(conditionSource, canExpressionSuspend(conditionNode))};
+if (runtime.isConditionalTrue(${conditionVar})) {
+return ${wrapAwaitedSource(thenSource, canExpressionSuspend(thenNode))};
+}
+return ${wrapAwaitedSource(elseSource, canExpressionSuspend(elseNode))};`, true);
+					return wrapSourceClosure(`signal?.throwIfAborted();
+const ${bindingVar} = ${createLookupResultSource(scope, "cond")};
+if (${bindingVar}.isFound && ${bindingVar}.value === runtime.standardIntrinsics.cond) {
+const ${conditionVar} = ${wrapAwaitedSource(conditionSource, canExpressionSuspend(conditionNode))};
+if (runtime.isConditionalTrue(${conditionVar})) {
+return ${wrapAwaitedSource(thenSource, canExpressionSuspend(thenNode))};
+}
+return ${wrapAwaitedSource(elseSource, canExpressionSuspend(elseNode))};
+}
+return ${compileGenericApplySource(state, node, scope)};`, true);
+				}
+				if (node.func.kind === "variable" && node.func.name === "fun" && node.args.length === 2) {
+					const parameterNames = extractLambdaParameterNames(node.args[0]);
+					if (parameterNames !== void 0) {
+						const lambdaSource = compileIntrinsicLambdaSource(state, node.range, parameterNames, node.args[1], scope, void 0);
+						if (state.aggressiveOptimize) return lambdaSource;
+						const bindingVar = allocateTemp(state, "binding");
+						return wrapSourceClosure(`signal?.throwIfAborted();
+const ${bindingVar} = ${createLookupResultSource(scope, "fun")};
+if (${bindingVar}.isFound && ${bindingVar}.value === runtime.standardIntrinsics.fun) {
+return ${lambdaSource};
+}
+return ${compileGenericApplySource(state, node, scope)};`, true);
+					}
+				}
+				const aggressiveApplySource = compileAggressiveApplySource(state, node, scope);
+				if (aggressiveApplySource !== void 0) return aggressiveApplySource;
+				return compileGenericApplySource(state, node, scope);
+			}
+			case "list": return `[${node.items.map((item) => wrapAwaitedSource(compileExpressionSource(state, item, scope), canExpressionSuspend(item))).join(", ")}]`;
+			case "scope": {
+				if (node.nodes.length === 0) return "[]";
+				const resultVar = allocateTemp(state, "result");
+				return wrapSourceClosure(`let ${resultVar} = undefined;
+${node.nodes.map((childNode) => {
+					return `${resultVar} = ${wrapAwaitedSource(compileExpressionSource(state, childNode, scope), canExpressionSuspend(childNode))};`;
+				}).join("\n")}
+return ${resultVar};`, node.nodes.some((childNode) => canExpressionSuspend(childNode)));
+			}
+		}
+	};
+	const createExpressionRunner = (node) => {
+		const cached = expressionCache.get(node);
+		if (cached) return cached;
+		const state = {
+			nextTempId: 0,
+			constants: [],
+			aggressiveOptimize
+		};
+		const runner = createAdaptiveSourceRunner(`const {
+constants,
+standardBuiltins,
+asIterable,
+isConditionalTrue,
+isFunCityFunction,
+throwError,
+resolveVariable,
+resolveDotSegments,
+invokeCallable,
+invokeBuiltin
+} = runtime;
+return ${compileExpressionSource(state, node, emptyCompileScope)};`);
+		const runtime = createRuntime(state.constants);
+		const generated = (context, signal) => runner(context, signal, runtime);
+		expressionCache.set(node, generated);
+		return generated;
+	};
+	const createBlockRunner = (node) => {
+		const cached = blockCache.get(node);
+		if (cached) return cached;
+		const state = {
+			nextTempId: 0,
+			constants: [],
+			aggressiveOptimize
+		};
+		const resultVar = allocateTemp(state, "result");
+		const runner = createAdaptiveSourceRunner(`const {
+constants,
+standardBuiltins,
+asIterable,
+isConditionalTrue,
+isFunCityFunction,
+throwError,
+resolveVariable,
+resolveDotSegments,
+invokeCallable,
+invokeBuiltin
+} = runtime;
+const ${resultVar} = [];
+${compileBlockStatements(state, node, resultVar, false, emptyCompileScope)}
+return ${resultVar};`);
+		const runtime = createRuntime(state.constants);
+		const generated = (context, signal) => runner(context, signal, runtime);
+		blockCache.set(node, generated);
+		return generated;
+	};
+	const createProgramRunner = (nodes) => {
+		const cached = programCache.get(nodes);
+		if (cached) return cached;
+		const state = {
+			nextTempId: 0,
+			constants: [],
+			aggressiveOptimize
+		};
+		const resultVar = allocateTemp(state, "result");
+		const runner = createAdaptiveSourceRunner(`const {
+constants,
+standardBuiltins,
+asIterable,
+isConditionalTrue,
+isFunCityFunction,
+throwError,
+resolveVariable,
+resolveDotSegments,
+invokeCallable,
+invokeBuiltin
+} = runtime;
+const ${resultVar} = [];
+${compileBlockListStatements(state, nodes, resultVar, true, emptyCompileScope)}
+return ${resultVar};`);
+		const runtime = createRuntime(state.constants);
+		const generated = (context, signal) => runner(context, signal, runtime);
+		programCache.set(nodes, generated);
+		return generated;
+	};
+	const createTextProgramRunner = (nodes) => {
+		const cached = textProgramCache.get(nodes);
+		if (cached) return cached;
+		const state = {
+			nextTempId: 0,
+			constants: [],
+			aggressiveOptimize
+		};
+		const textVar = allocateTemp(state, "text");
+		const runner = createAdaptiveSourceRunner(`const {
+constants,
+standardBuiltins,
+asIterable,
+isConditionalTrue,
+isFunCityFunction,
+throwError,
+resolveVariable,
+resolveDotSegments,
+invokeCallable,
+invokeBuiltin
+} = runtime;
+let ${textVar} = '';
+${compileTextBlockListStatements(state, nodes, textVar, emptyCompileScope)}
+return ${textVar};`);
+		const runtime = createRuntime(state.constants);
+		const generated = (context, signal) => runner(context, signal, runtime);
+		textProgramCache.set(nodes, generated);
+		return generated;
+	};
+	const createExecutor = () => {
+		return {
+			reduceExpressionNode: (context, node, signal) => createExpressionRunner(node)(context, signal),
+			reduceExpressionNodeImmediate: closureExecutor.reduceExpressionNodeImmediate,
+			reduceNode: (context, node, signal) => createBlockRunner(node)(context, signal),
+			reduceNodeImmediate: closureExecutor.reduceNodeImmediate
+		};
+	};
+	return {
+		generateExpression: createExpressionRunner,
+		generateBlock: createBlockRunner,
+		generateProgram: createProgramRunner,
+		generateTextProgram: createTextProgramRunner,
+		createExecutor
+	};
+};
+/**
+* Create a dynamic code generator.
+* @param options - Generator options.
+* @returns Dynamic code generator instance.
+*/
+var createDCodegen = (options) => {
+	switch (options === null || options === void 0 ? void 0 : options.backend) {
+		case "source": return createSourceDCodegen(options);
+		case "closure":
+		case void 0: return createClosureDCodegen();
+	}
+};
+/**
+* Run a node list with the dynamic code generator.
+* @param nodes - Target nodes.
+* @param variables - Predefined variables.
+* @param warningLogs - Warning sink.
+* @param signal - AbortSignal when available.
+* @returns Reduced native values.
+*/
+var runDCodegen = async (nodes, variables, warningLogs, signal) => {
+	const dcodegen = createDCodegen();
+	const context = createReducerContext(variables, warningLogs, dcodegen.createExecutor());
+	return await dcodegen.generateProgram(nodes)(context, signal);
+};
+//#endregion
+//#region src/compile-cache.ts
+var compile_cache_exports = /* @__PURE__ */ require_node.__exportAll({
+	compileScriptCached: () => compileScriptCached,
+	createSharedDCodegenExecutor: () => createSharedDCodegenExecutor
+});
+var compilationCacheLimit = 64;
+var sharedSourceDCodegen = createDCodegen({ backend: "source" });
+var sharedAggressiveSourceDCodegen = createDCodegen({
+	backend: "source",
+	aggressiveOptimize: true
+});
+var sharedClosureDCodegen = createDCodegen({ backend: "closure" });
+var compiledScriptCache = /* @__PURE__ */ new Map();
+var defaultExecutionBackend = "source";
+var resolveExecutionBackend = (backend) => backend !== null && backend !== void 0 ? backend : defaultExecutionBackend;
+var isDynamicCodegenBackend = (backend) => backend !== "reducer";
+var resolveAggressiveOptimize = (backend, aggressiveOptimize) => backend === "source" ? aggressiveOptimize !== null && aggressiveOptimize !== void 0 ? aggressiveOptimize : false : false;
+var getSharedDCodegen = (backend, aggressiveOptimize) => {
+	if (backend === "closure") return sharedClosureDCodegen;
+	return resolveAggressiveOptimize(backend, aggressiveOptimize) ? sharedAggressiveSourceDCodegen : sharedSourceDCodegen;
+};
+var toCompilationCacheKey = (script, sourceId, mode, backend, aggressiveOptimize) => `${mode}\u0000${backend}\u0000${aggressiveOptimize ? "aggr1" : "aggr0"}\u0000${sourceId}\u0000${script}`;
+var setCompiledScriptCache = (key, compiled) => {
+	compiledScriptCache.set(key, compiled);
+	if (compiledScriptCache.size <= compilationCacheLimit) return;
+	const firstKey = compiledScriptCache.keys().next().value;
+	if (firstKey !== void 0) compiledScriptCache.delete(firstKey);
+};
+/**
+* Create a reducer executor backed by the shared dynamic code generator.
+* @param backend - Dynamic code generator backend.
+* @returns Reducer executor.
+*/
+var createSharedDCodegenExecutor = (backend, aggressiveOptimize) => {
+	return getSharedDCodegen(backend !== null && backend !== void 0 ? backend : defaultExecutionBackend, aggressiveOptimize).createExecutor();
+};
+var createReducerBackedProgram = (nodes) => {
+	return async (context, signal) => {
+		const resultList = [];
+		for (const node of nodes) {
+			const results = await context.reduceNode(node, signal);
+			for (const result of results) if (result !== void 0) resultList.push(result);
+		}
+		return resultList;
+	};
+};
+var createReducerBackedTextProgram = (nodes) => {
+	const reducerProgram = createReducerBackedProgram(nodes);
+	return async (context, signal) => {
+		return (await reducerProgram(context, signal)).map((value) => context.convertToString(value)).join("");
+	};
+};
+/**
+* Compile a script with cache.
+* @param script - Source text.
+* @param sourceId - Source identifier.
+* @param mode - Parse mode.
+* @param backend - Execution backend.
+* @returns Cached compilation result.
+*/
+var compileScriptCached = (script, sourceId, mode, backend, aggressiveOptimize) => {
+	var _sharedDCodegen$gener, _sharedDCodegen$gener2;
+	const resolvedBackend = resolveExecutionBackend(backend);
+	const resolvedAggressiveOptimize = resolveAggressiveOptimize(resolvedBackend, aggressiveOptimize);
+	const cacheKey = toCompilationCacheKey(script, sourceId, mode, resolvedBackend, resolvedAggressiveOptimize);
+	const cached = compiledScriptCache.get(cacheKey);
+	if (cached) {
+		compiledScriptCache.delete(cacheKey);
+		compiledScriptCache.set(cacheKey, cached);
+		return cached;
+	}
+	const logs = [];
+	const tokens = mode === "code" ? runCodeTokenizer(script, logs, sourceId) : runTokenizer(script, logs, sourceId);
+	const nodes = mode === "code" ? parseExpressions(tokens, logs) : runParser(tokens, logs);
+	const sharedDCodegen = isDynamicCodegenBackend(resolvedBackend) ? getSharedDCodegen(resolvedBackend, resolvedAggressiveOptimize) : void 0;
+	const compiled = {
+		sourceId,
+		mode,
+		nodes,
+		logs: logs.slice(),
+		program: (_sharedDCodegen$gener = sharedDCodegen === null || sharedDCodegen === void 0 ? void 0 : sharedDCodegen.generateProgram(nodes)) !== null && _sharedDCodegen$gener !== void 0 ? _sharedDCodegen$gener : createReducerBackedProgram(nodes),
+		textProgram: (_sharedDCodegen$gener2 = sharedDCodegen === null || sharedDCodegen === void 0 ? void 0 : sharedDCodegen.generateTextProgram(nodes)) !== null && _sharedDCodegen$gener2 !== void 0 ? _sharedDCodegen$gener2 : createReducerBackedTextProgram(nodes)
+	};
+	setCompiledScriptCache(cacheKey, compiled);
+	return compiled;
+};
+//#endregion
+Object.defineProperty(exports, "FunCityReducerError", {
+	enumerable: true,
+	get: function() {
+		return FunCityReducerError;
+	}
+});
+Object.defineProperty(exports, "buildCandidateVariables", {
+	enumerable: true,
+	get: function() {
+		return buildCandidateVariables;
+	}
+});
+Object.defineProperty(exports, "combineVariables", {
+	enumerable: true,
+	get: function() {
+		return combineVariables;
+	}
+});
+Object.defineProperty(exports, "compileScriptCached", {
+	enumerable: true,
+	get: function() {
+		return compileScriptCached;
+	}
+});
+Object.defineProperty(exports, "compile_cache_exports", {
+	enumerable: true,
+	get: function() {
+		return compile_cache_exports;
+	}
+});
+Object.defineProperty(exports, "convertToString", {
+	enumerable: true,
+	get: function() {
+		return convertToString;
+	}
+});
+Object.defineProperty(exports, "createDCodegen", {
+	enumerable: true,
+	get: function() {
+		return createDCodegen;
+	}
+});
+Object.defineProperty(exports, "createIncludeFunction", {
+	enumerable: true,
+	get: function() {
+		return createIncludeFunction;
+	}
+});
+Object.defineProperty(exports, "createParserCursor", {
+	enumerable: true,
+	get: function() {
+		return createParserCursor;
+	}
+});
+Object.defineProperty(exports, "createReducerContext", {
+	enumerable: true,
+	get: function() {
+		return createReducerContext;
+	}
+});
+Object.defineProperty(exports, "createSharedDCodegenExecutor", {
+	enumerable: true,
+	get: function() {
+		return createSharedDCodegenExecutor;
+	}
+});
+Object.defineProperty(exports, "emptyLocation", {
+	enumerable: true,
+	get: function() {
+		return emptyLocation;
+	}
+});
+Object.defineProperty(exports, "emptyRange", {
+	enumerable: true,
+	get: function() {
+		return emptyRange;
+	}
+});
+Object.defineProperty(exports, "isConditionalTrue", {
+	enumerable: true,
+	get: function() {
+		return isConditionalTrue;
+	}
+});
+Object.defineProperty(exports, "isFunCityFunction", {
+	enumerable: true,
+	get: function() {
+		return isFunCityFunction;
+	}
+});
+Object.defineProperty(exports, "makeFunCityFunction", {
+	enumerable: true,
+	get: function() {
+		return makeFunCityFunction;
+	}
+});
+Object.defineProperty(exports, "outputErrors", {
+	enumerable: true,
+	get: function() {
+		return outputErrors;
+	}
+});
+Object.defineProperty(exports, "parseBlock", {
+	enumerable: true,
+	get: function() {
+		return parseBlock;
+	}
+});
+Object.defineProperty(exports, "parseExpression", {
+	enumerable: true,
+	get: function() {
+		return parseExpression;
+	}
+});
+Object.defineProperty(exports, "parseExpressions", {
+	enumerable: true,
+	get: function() {
+		return parseExpressions;
+	}
+});
+Object.defineProperty(exports, "reduceExpressionNode", {
+	enumerable: true,
+	get: function() {
+		return reduceExpressionNode;
+	}
+});
+Object.defineProperty(exports, "reduceNode", {
+	enumerable: true,
+	get: function() {
+		return reduceNode;
+	}
+});
+Object.defineProperty(exports, "runCodeTokenizer", {
+	enumerable: true,
+	get: function() {
+		return runCodeTokenizer;
+	}
+});
+Object.defineProperty(exports, "runDCodegen", {
+	enumerable: true,
+	get: function() {
+		return runDCodegen;
+	}
+});
+Object.defineProperty(exports, "runParser", {
+	enumerable: true,
+	get: function() {
+		return runParser;
+	}
+});
+Object.defineProperty(exports, "runReducer", {
+	enumerable: true,
+	get: function() {
+		return runReducer;
+	}
+});
+Object.defineProperty(exports, "runTokenizer", {
+	enumerable: true,
+	get: function() {
+		return runTokenizer;
+	}
+});
+Object.defineProperty(exports, "standardVariables", {
+	enumerable: true,
+	get: function() {
+		return standardVariables;
+	}
+});
+
+//# sourceMappingURL=compile-cache-D9XyNhoC.cjs.map