@coldsmirk/abacus-core 0.4.1 → 0.5.0

package/dist/index.js

@@ -1,4 +1,3 @@
-//#region src/engine/errors.ts
 var ExpressionError = class extends Error {
 	expression;
 	constructor(message, expression, cause) {
@@ -13,8 +12,42 @@ var ExpressionNotReadyError = class extends ExpressionError {
 		this.name = "ExpressionNotReadyError";
 	}
 };
-//#endregion
-//#region src/internal/predicates.ts
+function isAscii(source) {
+	for (let index = 0; index < source.length; index += 1) if (source.codePointAt(index) > 127) return false;
+	return true;
+}
+function utf8ByteLength(codePoint) {
+	if (codePoint < 128) return 1;
+	if (codePoint < 2048) return 2;
+	return codePoint < 65536 ? 3 : 4;
+}
+function utf8OffsetConverter(source) {
+	if (isAscii(source)) return (byteOffset) => Math.max(0, Math.min(byteOffset, source.length));
+	const byteStarts = [];
+	const unitStarts = [];
+	let bytes = 0;
+	let units = 0;
+	for (const char of source) {
+		byteStarts.push(bytes);
+		unitStarts.push(units);
+		bytes += utf8ByteLength(char.codePointAt(0));
+		units += char.length;
+	}
+	byteStarts.push(bytes);
+	unitStarts.push(units);
+	return (byteOffset) => {
+		if (byteOffset <= 0) return 0;
+		if (byteOffset >= bytes) return source.length;
+		let low = 0;
+		let high = byteStarts.length - 1;
+		while (low < high) {
+			const middle = low + high + 1 >> 1;
+			if (byteStarts[middle] <= byteOffset) low = middle;
+			else high = middle - 1;
+		}
+		return unitStarts[low];
+	};
+}
 function isUndefined(value) {
 	return value === void 0;
 }
@@ -30,13 +63,13 @@ function isNullish(value) {
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-//#endregion
-//#region src/engine/loader.ts
 let enginePromise = null;
 let engineSync = null;
 let engineError = null;
 let configuredInput;
 let typeContextCache = null;
+let loadEpoch = 0;
+let lastLoad = null;
 function evaluateSafely(expression, run) {
 	try {
 		return run();
@@ -56,9 +89,13 @@ function configureEngine(options) {
 function loadEngine() {
 	if (enginePromise) return enginePromise;
 	engineError = null;
-	enginePromise = (async () => {
+	const epoch = loadEpoch;
+	const predecessor = lastLoad;
+	const input = configuredInput;
+	const load = (async () => {
+		if (predecessor) await predecessor.catch(() => void 0);
 		const zen = await import("@gorules/zen-engine-wasm");
-		await zen.default(isUndefined(configuredInput) ? void 0 : { module_or_path: configuredInput });
+		await zen.default(isUndefined(input) ? void 0 : { module_or_path: input });
 		const toVariableType = (type) => zen.VariableType.fromJson(type);
 		const ensureTypeContext = (variables) => {
 			if (typeContextCache && typeContextCache.variables === variables) return typeContextCache;
@@ -87,9 +124,19 @@ function loadEngine() {
 			analyze: (variables, source, unary) => {
 				const context = ensureTypeContext(variables);
 				const rawSpans = unary ? context.handle.typeCheckUnary(source) : context.handle.typeCheck(source);
+				if (!Array.isArray(rawSpans)) return {
+					rootKind: context.rootKind,
+					spans: []
+				};
+				const toUtf16 = utf8OffsetConverter(source);
 				return {
 					rootKind: context.rootKind,
-					spans: Array.isArray(rawSpans) ? rawSpans : []
+					spans: rawSpans.map((span) => {
+						return {
+							...span,
+							span: [toUtf16(span.span[0]), toUtf16(span.span[1])]
+						};
+					})
 				};
 			},
 			satisfies: (actual, expected) => {
@@ -107,12 +154,17 @@ function loadEngine() {
 			},
 			isReady: () => zen.isReady()
 		});
-		engineSync = engine;
+		if (epoch === loadEpoch) engineSync = engine;
 		return engine;
-	})().catch((error) => {
-		enginePromise = null;
-		engineError = new ExpressionError(loadFailureMessage(), void 0, error);
-		throw engineError;
+	})();
+	lastLoad = load;
+	enginePromise = load.catch((error) => {
+		const failure = new ExpressionError(loadFailureMessage(), void 0, error);
+		if (epoch === loadEpoch) {
+			enginePromise = null;
+			engineError = failure;
+		}
+		throw failure;
 	});
 	return enginePromise;
 }
@@ -127,6 +179,7 @@ function getEngineSync() {
 	return engineSync;
 }
 function resetEngine() {
+	loadEpoch += 1;
 	typeContextCache?.handle.free();
 	typeContextCache = null;
 	enginePromise = null;
@@ -134,16 +187,178 @@ function resetEngine() {
 	engineError = null;
 	configuredInput = void 0;
 }
-//#endregion
-//#region src/internal/env.ts
 const isDev = detectDev();
 function detectDev() {
 	if (typeof process === "undefined") return false;
 	return process.env ? process.env.NODE_ENV !== "production" : false;
 }
-//#endregion
-//#region src/condition/subject.ts
+const U64_MAX = 18446744073709551615n;
+const I64_MIN_MAGNITUDE = 9223372036854775808n;
+const ZEN_DECIMAL_MANTISSA_LIMIT = 2n ** 96n;
+const ZEN_DECIMAL_MANTISSA_LIMIT_TEXT = String(ZEN_DECIMAL_MANTISSA_LIMIT);
+const DECIMAL_SIGN_BIT = 2n ** 95n;
+const EXCESS_PRECISION_LIMIT = 2n ** 52n;
+const NUMBER_TEXT_PATTERN = /^(?<integer>\d+)(?:\.(?<fraction>\d+))?(?:e(?<exponent>[+-]\d+))?$/;
+const UNSIGNED_INTEGER_TEXT_PATTERN = /^\d+$/;
+function isZenUnsignedIntegerText(value) {
+	if (!UNSIGNED_INTEGER_TEXT_PATTERN.test(value)) return false;
+	const normalized = value.replace(/^0+(?=\d)/, "");
+	return normalized.length < ZEN_DECIMAL_MANTISSA_LIMIT_TEXT.length || normalized.length === ZEN_DECIMAL_MANTISSA_LIMIT_TEXT.length && normalized < ZEN_DECIMAL_MANTISSA_LIMIT_TEXT;
+}
+function powerOfTen(exponent) {
+	return Number(`1e${exponent}`);
+}
+function normalize(digits, exponent) {
+	let d = digits;
+	let e = exponent;
+	while (d !== 0n && d % 10n === 0n) {
+		d /= 10n;
+		e += 1;
+	}
+	return d === 0n ? {
+		digits: 0n,
+		exponent: 0
+	} : {
+		digits: d,
+		exponent: e
+	};
+}
+function parseAsSerdeJson(text) {
+	const match = NUMBER_TEXT_PATTERN.exec(text);
+	if (match?.groups === void 0) return null;
+	const { integer, fraction, exponent } = match.groups;
+	let significand = 0n;
+	let scale = 0;
+	let overflowed = false;
+	for (const digit of integer) {
+		if (!overflowed && significand * 10n + BigInt(digit) > U64_MAX) overflowed = true;
+		if (overflowed) scale += 1;
+		else significand = significand * 10n + BigInt(digit);
+	}
+	if (fraction === void 0 && exponent === void 0 && !overflowed) return {
+		kind: "int",
+		int: significand,
+		f64: 0
+	};
+	if (fraction !== void 0) for (const digit of fraction) {
+		if (overflowed || significand * 10n + BigInt(digit) > U64_MAX) break;
+		significand = significand * 10n + BigInt(digit);
+		scale -= 1;
+	}
+	if (exponent !== void 0) scale += Number(exponent);
+	let value = Number(significand);
+	let remaining = scale;
+	for (;;) {
+		if (Math.abs(remaining) <= 308) {
+			value = remaining >= 0 ? value * powerOfTen(remaining) : value / powerOfTen(-remaining);
+			break;
+		}
+		if (value === 0) break;
+		if (remaining >= 0) return null;
+		value /= 1e308;
+		remaining += 308;
+	}
+	return Number.isFinite(value) ? {
+		kind: "f64",
+		int: 0n,
+		f64: value
+	} : null;
+}
+function decimalFromF64(value) {
+	if (value === 0) return {
+		digits: 0n,
+		exponent: 0
+	};
+	const view = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+	view.setFloat64(0, value);
+	const raw = view.getBigUint64(0);
+	const biasedExponent = Number(raw >> 52n & 2047n);
+	const fractionBits = raw & 4503599627370495n;
+	let bits = biasedExponent === 0 ? fractionBits : fractionBits | 1n << 52n;
+	const exponent2 = (biasedExponent === 0 ? 1 : biasedExponent) - 1023 - 52;
+	let exponent5 = -exponent2;
+	let exponent10 = exponent2;
+	while (exponent5 > 0) if ((bits & 1n) === 0n) {
+		exponent10 += 1;
+		exponent5 -= 1;
+		bits >>= 1n;
+	} else {
+		exponent5 -= 1;
+		const timesFive = bits * 5n;
+		if (timesFive < ZEN_DECIMAL_MANTISSA_LIMIT) bits = timesFive;
+		else {
+			exponent10 += 1;
+			bits >>= 1n;
+		}
+	}
+	while (exponent5 < 0) if ((bits & DECIMAL_SIGN_BIT) === 0n) {
+		exponent10 -= 1;
+		exponent5 += 1;
+		bits <<= 1n;
+	} else if (exponent10 * 2 > -exponent5) return null;
+	else {
+		exponent5 += 1;
+		bits /= 5n;
+	}
+	while (exponent10 > 0) {
+		const timesTen = bits * 10n;
+		if (timesTen >= ZEN_DECIMAL_MANTISSA_LIMIT) return null;
+		bits = timesTen;
+		exponent10 -= 1;
+	}
+	while (exponent10 < -28) {
+		const remainder = bits % 10n;
+		bits /= 10n;
+		exponent10 += 1;
+		if (bits === 0n) exponent10 = 0;
+		else if (remainder >= 5n) bits += 1n;
+	}
+	while (exponent10 < 0 && bits >= EXCESS_PRECISION_LIMIT) {
+		const remainder = bits % 10n;
+		bits /= 10n;
+		exponent10 += 1;
+		if (remainder >= 5n) bits += 1n;
+	}
+	while (exponent10 < 0 && bits % 10n === 0n) {
+		bits /= 10n;
+		exponent10 += 1;
+	}
+	return {
+		digits: bits,
+		exponent: exponent10
+	};
+}
+function contextDecimal(value) {
+	const magnitude = Math.abs(value);
+	if (magnitude === 0) return {
+		digits: 0n,
+		exponent: 0
+	};
+	const parsed = parseAsSerdeJson(String(magnitude));
+	if (parsed === null) return null;
+	if (parsed.kind === "int") {
+		if (value >= 0 || parsed.int <= I64_MIN_MAGNITUDE) return normalize(parsed.int, 0);
+		const viaF64 = decimalFromF64(Number(parsed.int));
+		return viaF64 === null ? null : normalize(viaF64.digits, viaF64.exponent);
+	}
+	const converted = decimalFromF64(parsed.f64);
+	return converted === null ? null : normalize(converted.digits, converted.exponent);
+}
+function literalDecimal(value) {
+	const match = NUMBER_TEXT_PATTERN.exec(String(Math.abs(value)));
+	if (match?.groups === void 0) return null;
+	const { integer, fraction = "", exponent = "0" } = match.groups;
+	return normalize(BigInt(integer + fraction), Number(exponent) - fraction.length);
+}
+function isZenConsistentNumber(value) {
+	if (!Number.isFinite(value)) return false;
+	const literal = literalDecimal(value);
+	if (literal === null || literal.digits >= ZEN_DECIMAL_MANTISSA_LIMIT) return false;
+	const context = contextDecimal(value);
+	return context !== null && literal.digits === context.digits && literal.exponent === context.exponent;
+}
 const SUBJECT_PATTERN = /^[A-Z_$][\w$]*(?:\.[A-Z_$][\w$]*|\[\d+\])*$/i;
+const SUBJECT_INDEX_PATTERN = /\[(?<index>\d+)\]/g;
 const ZEN_RESERVED_WORDS = new Set([
 	"and",
 	"or",
@@ -154,17 +369,24 @@ const ZEN_RESERVED_WORDS = new Set([
 	"null"
 ]);
 function isIdentifierPath(subject) {
-	return SUBJECT_PATTERN.test(subject) && (subject.match(/[A-Z_$][\w$]*/gi) ?? []).every((segment) => !ZEN_RESERVED_WORDS.has(segment));
+	if (!SUBJECT_PATTERN.test(subject) || (subject.match(/[A-Z_$][\w$]*/gi) ?? []).some((segment) => ZEN_RESERVED_WORDS.has(segment))) return false;
+	for (const match of subject.matchAll(SUBJECT_INDEX_PATTERN)) if (match.groups?.index === void 0 || !isZenUnsignedIntegerText(match.groups.index)) return false;
+	return true;
+}
+function isZenRepresentableNumber(value) {
+	return isZenConsistentNumber(value);
 }
-//#endregion
-//#region src/condition/compile.ts
 function toZenLiteral(value) {
 	if (isNullish(value)) return "null";
 	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new ExpressionError(`Number ${String(value)} has no ZEN literal representation`);
+		if (!isZenRepresentableNumber(value)) throw new ExpressionError(`Number ${String(value)} has no faithful ZEN literal representation`);
+		return String(value);
+	}
+	if (typeof value === "bigint") {
+		if (value >= ZEN_DECIMAL_MANTISSA_LIMIT || -value >= ZEN_DECIMAL_MANTISSA_LIMIT) throw new ExpressionError(`Bigint ${String(value)} has no ZEN literal representation`);
 		return String(value);
 	}
-	if (typeof value === "boolean" || typeof value === "bigint") return String(value);
+	if (typeof value === "boolean") return String(value);
 	if (isString(value)) return encodeZenString(value);
 	if (isArray(value)) return `[${value.map((item) => toZenLiteral(item)).join(", ")}]`;
 	throw new ExpressionError(`Value of type "${typeof value}" has no ZEN literal representation`);
@@ -260,8 +482,6 @@ function reportEvaluationFailure(engine, expression, error) {
 async function selectBranch(branches, context) {
 	return selectBranchWith(branches, context, await loadEngine());
 }
-//#endregion
-//#region src/condition/types.ts
 const CONDITION_OPERATORS = [
 	"eq",
 	"ne",
@@ -297,9 +517,83 @@ const CONDITION_OPERATOR_ARITIES = {
 function conditionOperatorArity(operator) {
 	return CONDITION_OPERATOR_ARITIES[operator];
 }
-//#endregion
-//#region src/condition/compile-tree.ts
+const MAX_CONDITION_TREE_DEPTH = 64;
+const CONDITION_TREE_OPERATORS = CONDITION_OPERATORS;
+const nodeIdRealm = Math.random().toString(36).slice(2, 7);
+let nodeIdCounter = 0;
+function newConditionNodeId() {
+	nodeIdCounter += 1;
+	return `cn-${nodeIdRealm}-${nodeIdCounter}`;
+}
+function emptyConditionGroup() {
+	return {
+		kind: "group",
+		id: newConditionNodeId(),
+		op: "and",
+		items: []
+	};
+}
+function assertConditionTreeStructure(tree) {
+	if (!isRecord(tree) || tree.kind !== "group") throw new ExpressionError("Condition tree root must be a group");
+	const ancestors = /* @__PURE__ */ new Set();
+	const stack = [{
+		group: tree,
+		depth: 0,
+		leaving: false
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		const { group } = frame;
+		if (frame.leaving) {
+			ancestors.delete(group);
+			continue;
+		}
+		if (frame.depth > 64) throw new ExpressionError(`Condition tree exceeds the maximum depth of 64`);
+		if (ancestors.has(group)) throw new ExpressionError("Condition tree contains a cycle");
+		if (group.op !== "and" && group.op !== "or") throw new ExpressionError(`Unsupported group operator: ${String(group.op)}`);
+		if (!isArray(group.items)) throw new ExpressionError("Condition tree group items must be an array");
+		ancestors.add(group);
+		stack.push({
+			...frame,
+			leaving: true
+		});
+		for (let index = group.items.length - 1; index >= 0; index -= 1) {
+			const node = group.items[index];
+			if (!isRecord(node) || node.kind !== "group" && node.kind !== "rule") throw new ExpressionError("Condition tree contains an invalid node");
+			if (node.kind === "group") stack.push({
+				group: node,
+				depth: frame.depth + 1,
+				leaving: false
+			});
+		}
+	}
+}
+function withRuleId(rule) {
+	return rule.id === void 0 ? {
+		...rule,
+		id: newConditionNodeId()
+	} : rule;
+}
+function withGroupIds(group) {
+	const items = group.items.map((item) => item.kind === "group" ? withGroupIds(item) : withRuleId(item));
+	if (group.id !== void 0 && items.every((item, index) => item === group.items[index])) return group;
+	return {
+		...group,
+		id: group.id ?? newConditionNodeId(),
+		items
+	};
+}
+const normalizedTrees = /* @__PURE__ */ new WeakMap();
+function ensureConditionNodeIds(tree) {
+	assertConditionTreeStructure(tree);
+	const cached = normalizedTrees.get(tree);
+	if (cached) return cached;
+	const normalized = withGroupIds(tree);
+	normalizedTrees.set(tree, normalized);
+	return normalized;
+}
 function compileConditionTree(tree) {
+	assertConditionTreeStructure(tree);
 	const normalized = normalizeNode(tree);
 	return normalized === null ? "" : emitNode(normalized, true);
 }
@@ -316,9 +610,16 @@ function normalizeNode(node) {
 }
 function emitNode(node, topLevel) {
 	if (node.kind === "rule") return compileRule(node);
-	const joined = node.items.map((item) => emitNode(item, false)).join(node.op === "and" ? " and " : " or ");
+	const joined = node.items.map((item) => emitNode(item, false)).join(groupJoiner(node.op));
 	return topLevel ? joined : `(${joined})`;
 }
+function groupJoiner(op) {
+	switch (op) {
+		case "and": return " and ";
+		case "or": return " or ";
+		default: throw new ExpressionError(`Unsupported group operator: ${String(op)}`);
+	}
+}
 function compileRule(rule) {
 	if (!matchesOperatorArity(rule)) return null;
 	return compileCondition({
@@ -341,8 +642,6 @@ function isConditionScalar(value) {
 function isScalarArray(value) {
 	return isArray(value) && value.every((item) => isConditionScalar(item));
 }
-//#endregion
-//#region src/condition/lift-tree.ts
 const TWO_CHAR_PUNCTUATION = new Set([
 	"==",
 	"!=",
@@ -365,6 +664,10 @@ const IDENT_PART = /[\w$]/;
 const DIGIT = /\d/;
 const NUMBER_PATTERN = /^\d+(?:\.\d+)?(?:e[+-]?\d+)?/i;
 const INTEGER_PATTERN = /^\d+$/;
+function parseCanonicalNumber(text) {
+	const value = Number(text);
+	return String(value) === text && isZenRepresentableNumber(value) ? value : null;
+}
 const COMPARISON_OPERATORS = {
 	"==": "eq",
 	"!=": "ne",
@@ -378,7 +681,6 @@ const CALL_OPERATORS = {
 	startsWith: "starts_with",
 	endsWith: "ends_with"
 };
-const MAX_GROUP_DEPTH = 64;
 function liftConditionTree(expression) {
 	const tokens = tokenize(expression);
 	if (tokens === null || tokens.length === 0) return null;
@@ -424,8 +726,10 @@ function liftConditionTree(expression) {
 			return token.value;
 		}
 		if (token.kind === "number") {
+			const value = parseCanonicalNumber(token.value);
+			if (value === null) return null;
 			pos += 1;
-			return Number(token.value);
+			return value;
 		}
 		if (token.kind === "ident") {
 			if (token.value === "true") {
@@ -441,8 +745,10 @@ function liftConditionTree(expression) {
 		if (token.kind === "punct" && token.value === "-") {
 			const digits = peek(1);
 			if (digits === void 0 || digits.kind !== "number") return null;
+			const value = parseCanonicalNumber(digits.value);
+			if (value === null || value === 0 || !isZenRepresentableNumber(-value)) return null;
 			pos += 2;
-			return -Number(digits.value);
+			return -value;
 		}
 		return null;
 	}
@@ -471,6 +777,7 @@ function liftConditionTree(expression) {
 		if (right === null || !consumePunct(")")) return null;
 		return {
 			kind: "rule",
+			id: newConditionNodeId(),
 			left,
 			operator,
 			right
@@ -483,6 +790,7 @@ function liftConditionTree(expression) {
 		if (right === null || !consumePunct(")")) return null;
 		return {
 			kind: "rule",
+			id: newConditionNodeId(),
 			left,
 			operator: "not_in",
 			right
@@ -514,6 +822,7 @@ function liftConditionTree(expression) {
 		pos += expected.length;
 		return {
 			kind: "rule",
+			id: newConditionNodeId(),
 			left: read.path,
 			operator
 		};
@@ -549,6 +858,7 @@ function liftConditionTree(expression) {
 			const right = parseArray();
 			return right === null ? null : {
 				kind: "rule",
+				id: newConditionNodeId(),
 				left,
 				operator: "in",
 				right
@@ -561,6 +871,7 @@ function liftConditionTree(expression) {
 			const right = parseLiteral();
 			return right === null ? null : {
 				kind: "rule",
+				id: newConditionNodeId(),
 				left,
 				operator,
 				right
@@ -572,7 +883,7 @@ function liftConditionTree(expression) {
 		const emptiness = tryEmptiness();
 		if (emptiness !== null) return emptiness;
 		if (isPunct(peek(), "(")) {
-			if (depth >= MAX_GROUP_DEPTH) return null;
+			if (depth >= 64) return null;
 			pos += 1;
 			const inner = parseGroup(depth + 1);
 			if (inner === null || !consumePunct(")")) return null;
@@ -602,6 +913,7 @@ function liftConditionTree(expression) {
 		}
 		return items.length === 1 ? items[0] : {
 			kind: "group",
+			id: newConditionNodeId(),
 			op: op ?? "and",
 			items
 		};
@@ -640,6 +952,7 @@ function readPath(tokens, from) {
 function asGroup(node) {
 	return node.kind === "group" ? node : {
 		kind: "group",
+		id: newConditionNodeId(),
 		op: "and",
 		items: [node]
 	};
@@ -707,11 +1020,6 @@ function tokenize(input) {
 	}
 	return tokens;
 }
-//#endregion
-//#region src/condition/tree-types.ts
-const CONDITION_TREE_OPERATORS = CONDITION_OPERATORS;
-//#endregion
-//#region src/engine/evaluate.ts
 async function evaluate(expression, context) {
 	await loadEngine();
 	return evaluateSync(expression, context);
@@ -726,8 +1034,6 @@ function evaluateSync(expression, context) {
 function evaluateUnarySync(expression, context) {
 	return getEngineSync().evaluateUnary(expression, context);
 }
-//#endregion
-//#region src/engine/messages.ts
 const COMPLETION_INFO_ZH = {
 	"Returns the length of variable": "返回变量的长度",
 	"Checks if variable contains a needle": "检查变量是否包含指定元素",
@@ -860,8 +1166,6 @@ function configureExpressionMessages({ locale, messages }) {
 function getExpressionMessages() {
 	return activeMessages;
 }
-//#endregion
-//#region src/engine/intellisense.ts
 function parseOffset(text) {
 	const trimmed = text?.trim();
 	return trimmed ? Number(trimmed) : NaN;
@@ -880,7 +1184,9 @@ function normalizeDiagnostic(raw, source) {
 	if (raw === null || raw === void 0) return null;
 	const errorType = isRecord(raw) && typeof raw.type === "string" ? raw.type : void 0;
 	const message = isRecord(raw) && typeof raw.source === "string" ? raw.source : String(raw);
-	const [from, to] = extractPosition(message) ?? [0, source.length];
+	const bytePosition = extractPosition(message);
+	const toUtf16 = utf8OffsetConverter(source);
+	const [from, to] = bytePosition === null ? [0, source.length] : [toUtf16(bytePosition[0]), toUtf16(bytePosition[1])];
 	return {
 		from,
 		to,
@@ -932,8 +1238,6 @@ async function satisfiesType(actual, expected) {
 function satisfiesTypeSync(actual, expected) {
 	return getEngineSync().satisfies(actual, expected);
 }
-//#endregion
-//#region src/engine/template.ts
 const HOLE_PATTERN = /\{\{(?<expression>[^{}]*)\}\}/g;
 function parseTemplateHoles(source) {
 	const holes = [];
@@ -994,5 +1298,4 @@ async function getTemplateDiagnostics(source) {
 	await loadEngine();
 	return getTemplateDiagnosticsSync(source);
 }
-//#endregion
-export { CONDITION_OPERATORS, CONDITION_TREE_OPERATORS, ExpressionError, ExpressionNotReadyError, analyzeTemplate, analyzeTemplateSync, analyzeTypes, analyzeTypesSync, compileBranch, compileCondition, compileConditionTree, compileGroup, conditionOperatorArity, configureEngine, configureExpressionMessages, enMessages, evaluate, evaluateSync, evaluateUnary, evaluateUnarySync, getCompletionItems, getCompletionItemsSync, getDiagnostics, getDiagnosticsSync, getEngineError, getEngineSync, getExpressionMessages, getTemplateDiagnostics, getTemplateDiagnosticsSync, isEngineReady, liftConditionTree, loadEngine, parseTemplateHoles, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, selectBranch, selectBranchWith, templateHoleAt, toZenLiteral, zhCNMessages };
+export { CONDITION_OPERATORS, CONDITION_TREE_OPERATORS, ExpressionError, ExpressionNotReadyError, MAX_CONDITION_TREE_DEPTH, analyzeTemplate, analyzeTemplateSync, analyzeTypes, analyzeTypesSync, compileBranch, compileCondition, compileConditionTree, compileGroup, conditionOperatorArity, configureEngine, configureExpressionMessages, emptyConditionGroup, enMessages, ensureConditionNodeIds, evaluate, evaluateSync, evaluateUnary, evaluateUnarySync, getCompletionItems, getCompletionItemsSync, getDiagnostics, getDiagnosticsSync, getEngineError, getEngineSync, getExpressionMessages, getTemplateDiagnostics, getTemplateDiagnosticsSync, isEngineReady, isZenRepresentableNumber, liftConditionTree, loadEngine, newConditionNodeId, parseTemplateHoles, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, selectBranch, selectBranchWith, templateHoleAt, toZenLiteral, zhCNMessages };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/abacus-core",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Framework-agnostic ZEN expression engine: compile, evaluate, and type-analyze expressions over the GoRules ZEN WASM engine.",
   "keywords": [
     "zen",
@@ -46,7 +46,7 @@
     "@gorules/zen-engine-wasm": "^0.23.1"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "publishConfig": {
     "access": "public"