@coldsmirk/abacus-core 0.4.1 → 0.6.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,17 +187,180 @@ 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 ZEN_RESERVED_WORDS = new Set([
+const SUBJECT_IDENTIFIER_PATTERN = /[A-Z_$][\w$]*/gi;
+const SUBJECT_INDEX_PATTERN = /\[(?<index>\d+)\]/g;
+const ZEN_ROOT_RESERVED_WORDS = new Set([
 	"and",
 	"or",
 	"not",
@@ -153,18 +369,28 @@ const ZEN_RESERVED_WORDS = new Set([
 	"false",
 	"null"
 ]);
+const ZEN_MEMBER_RESERVED_WORDS = new Set(["true", "false"]);
 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)) return false;
+	const [root, ...members] = subject.match(SUBJECT_IDENTIFIER_PATTERN) ?? [];
+	if (root === void 0 || ZEN_ROOT_RESERVED_WORDS.has(root) || members.some((member) => ZEN_MEMBER_RESERVED_WORDS.has(member))) 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`);
@@ -172,14 +398,17 @@ function toZenLiteral(value) {
 function encodeZenString(value) {
 	const hasSingle = value.includes("'");
 	const hasDouble = value.includes("\"");
-	if (hasSingle && hasDouble) throw new ExpressionError("String contains both single and double quotes and has no ZEN literal representation");
-	return hasSingle ? `"${value}"` : `'${value}'`;
+	const hasBacktick = value.includes("`");
+	if (!hasSingle) return `'${value}'`;
+	if (!hasDouble) return `"${value}"`;
+	if (!hasBacktick) return `\`${value}\``;
+	throw new ExpressionError("String contains every ZEN raw-string delimiter and has no literal representation");
 }
 function toArrayLiteral(value) {
 	return isArray(value) ? toZenLiteral(value) : `[${toZenLiteral(value)}]`;
 }
 function zenIsEmpty(subject) {
-	return `(${subject} == null or (type(${subject}) == 'string' and len(trim(${subject})) == 0) or (type(${subject}) == 'array' and len(${subject}) == 0))`;
+	return `(${subject} == null or (type(${subject}) == 'string' and len(trim(${subject})) == 0) or (type(${subject}) == 'array' and len(${subject}) == 0) or (type(${subject}) == 'object' and len(keys(${subject})) == 0))`;
 }
 function compileFieldCondition(subject, operator, value) {
 	switch (operator) {
@@ -260,8 +489,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 +524,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 +617,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 +649,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 +671,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 +688,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 +733,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 +752,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 +784,7 @@ function liftConditionTree(expression) {
 		if (right === null || !consumePunct(")")) return null;
 		return {
 			kind: "rule",
+			id: newConditionNodeId(),
 			left,
 			operator,
 			right
@@ -483,6 +797,7 @@ function liftConditionTree(expression) {
 		if (right === null || !consumePunct(")")) return null;
 		return {
 			kind: "rule",
+			id: newConditionNodeId(),
 			left,
 			operator: "not_in",
 			right
@@ -514,6 +829,7 @@ function liftConditionTree(expression) {
 		pos += expected.length;
 		return {
 			kind: "rule",
+			id: newConditionNodeId(),
 			left: read.path,
 			operator
 		};
@@ -549,6 +865,7 @@ function liftConditionTree(expression) {
 			const right = parseArray();
 			return right === null ? null : {
 				kind: "rule",
+				id: newConditionNodeId(),
 				left,
 				operator: "in",
 				right
@@ -561,6 +878,7 @@ function liftConditionTree(expression) {
 			const right = parseLiteral();
 			return right === null ? null : {
 				kind: "rule",
+				id: newConditionNodeId(),
 				left,
 				operator,
 				right
@@ -572,7 +890,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 +920,7 @@ function liftConditionTree(expression) {
 		}
 		return items.length === 1 ? items[0] : {
 			kind: "group",
+			id: newConditionNodeId(),
 			op: op ?? "and",
 			items
 		};
@@ -640,6 +959,7 @@ function readPath(tokens, from) {
 function asGroup(node) {
 	return node.kind === "group" ? node : {
 		kind: "group",
+		id: newConditionNodeId(),
 		op: "and",
 		items: [node]
 	};
@@ -656,7 +976,7 @@ function tokenize(input) {
 			index += 1;
 			continue;
 		}
-		if (char === "'" || char === "\"") {
+		if (char === "'" || char === "\"" || char === "`") {
 			const end = input.indexOf(char, index + 1);
 			if (end === -1) return null;
 			tokens.push({
@@ -707,11 +1027,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 +1041,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": "检查变量是否包含指定元素",
@@ -846,41 +1159,53 @@ const zhCNMessages = {
 	expectedType: (expectedType, actualType) => `期望 \`${expectedType}\`，实际为 \`${actualType}\`。`
 };
 const localeRegistry = new Map([["en-US", enMessages], ["zh-CN", zhCNMessages]]);
+let activeBaseMessages = enMessages;
 let activeMessages = enMessages;
+const messageListeners = /* @__PURE__ */ new Set();
 function registerExpressionLocale(locale, messages) {
 	localeRegistry.set(locale, messages);
 }
 function configureExpressionMessages({ locale, messages }) {
-	const base = locale === void 0 ? activeMessages : localeRegistry.get(locale) ?? activeMessages;
-	activeMessages = messages === void 0 ? base : {
+	const base = locale === void 0 ? activeBaseMessages : localeRegistry.get(locale) ?? activeBaseMessages;
+	const nextMessages = messages === void 0 ? base : {
 		...base,
 		...messages
 	};
+	activeBaseMessages = base;
+	if (nextMessages === activeMessages) return;
+	activeMessages = nextMessages;
+	for (const listener of messageListeners) listener(activeMessages);
 }
 function getExpressionMessages() {
 	return activeMessages;
 }
-//#endregion
-//#region src/engine/intellisense.ts
+function subscribeExpressionMessages(listener) {
+	messageListeners.add(listener);
+	return () => {
+		messageListeners.delete(listener);
+	};
+}
 function parseOffset(text) {
 	const trimmed = text?.trim();
 	return trimmed ? Number(trimmed) : NaN;
 }
 function extractPosition(message) {
-	const segments = message.split(" at ");
-	const last = segments.length <= 1 ? void 0 : segments.at(-1);
-	if (last === void 0) return null;
-	const [left, right] = last.replace("(", "").replace(")", "").split(", ");
-	const from = parseOffset(left);
-	if (Number.isNaN(from)) return null;
-	const to = parseOffset(right);
-	return [from, Number.isNaN(to) ? from : to];
+	const positionPattern = / at (?:\(\s*(?<rangeFrom>\d+)\s*,\s*(?<rangeTo>\d+)\s*\)|(?<point>\d+))(?=\s*(?:;|$))/g;
+	let position = null;
+	for (const match of message.matchAll(positionPattern)) {
+		const from = parseOffset(match.groups?.rangeFrom ?? match.groups?.point);
+		const to = parseOffset(match.groups?.rangeTo);
+		position = [from, Number.isNaN(to) ? from : to];
+	}
+	return position;
 }
 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 +1257,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 +1317,293 @@ 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 };
+function fieldType(field) {
+	switch (field.type) {
+		case "string": return "String";
+		case "number": return "Number";
+		case "integer": return "Number";
+		case "boolean": return "Bool";
+		case "object": return { Object: fieldRecord(field.children) };
+		case "array": return { Array: field.items === null ? "Any" : fieldType(field.items) };
+		case "any": return "Any";
+	}
+}
+function fieldRecord(fields) {
+	return Object.fromEntries(fields.filter((field) => field.name.trim() !== "" || field.preserveBlankName === true).map((field) => [field.name, fieldType(field)]));
+}
+function schemaTreeToExpressionType(tree) {
+	return { Object: fieldRecord(tree.fields) };
+}
+function mergeSchemas(a, b) {
+	if (a.type === "object" && b.type === "object") {
+		const left = a.properties ?? {};
+		const right = b.properties ?? {};
+		const entries = [];
+		const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+		for (const key of keys) {
+			const hasLeft = Object.hasOwn(left, key);
+			const hasRight = Object.hasOwn(right, key);
+			entries.push([key, hasLeft && hasRight ? mergeSchemas(left[key], right[key]) : hasLeft ? left[key] : right[key]]);
+		}
+		const properties = Object.fromEntries(entries);
+		return Object.keys(properties).length > 0 ? {
+			type: "object",
+			properties
+		} : { type: "object" };
+	}
+	if (a.type === "array" && b.type === "array") return a.items !== void 0 && b.items !== void 0 ? {
+		type: "array",
+		items: mergeSchemas(a.items, b.items)
+	} : { type: "array" };
+	return JSON.stringify(a) === JSON.stringify(b) ? a : {};
+}
+function inferSchema(sample) {
+	if (sample === null) return {};
+	if (Array.isArray(sample)) {
+		if (sample.length === 0) return { type: "array" };
+		return {
+			type: "array",
+			items: sample.map((element) => inferSchema(element)).reduce((left, right) => mergeSchemas(left, right))
+		};
+	}
+	if (typeof sample === "string") return { type: "string" };
+	if (typeof sample === "number") return { type: "number" };
+	if (typeof sample === "boolean") return { type: "boolean" };
+	const properties = Object.fromEntries(Object.entries(sample).map(([key, value]) => [key, inferSchema(value)]));
+	return Object.keys(properties).length > 0 ? {
+		type: "object",
+		properties
+	} : { type: "object" };
+}
+const SCHEMA_DIALECT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
+const fieldIdRealm = Math.random().toString(36).slice(2, 7);
+let fieldIdCounter = 0;
+function newSchemaTreeField(overrides = {}) {
+	fieldIdCounter += 1;
+	return {
+		id: `sf-${fieldIdRealm}-${fieldIdCounter}`,
+		name: "",
+		type: "string",
+		required: false,
+		description: "",
+		children: [],
+		items: null,
+		...overrides
+	};
+}
+const SCALAR_TYPES = new Set([
+	"string",
+	"number",
+	"integer",
+	"boolean"
+]);
+const ROOT_KEYS = new Set([
+	"$schema",
+	"type",
+	"properties",
+	"required",
+	"description"
+]);
+const SUBSCHEMA_KEYS = new Set([
+	"type",
+	"properties",
+	"required",
+	"items",
+	"description"
+]);
+var Unsupported = class extends Error {
+	issue;
+	constructor(issue) {
+		super(issue.code);
+		this.issue = issue;
+	}
+};
+function asPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function checkKeys(schema, allowed) {
+	for (const key of Object.keys(schema)) if (!allowed.has(key)) throw new Unsupported({
+		code: "unsupported-keyword",
+		keyword: key
+	});
+}
+function parseObjectFields(schema) {
+	const properties = schema.properties === void 0 ? null : asPlainObject(schema.properties);
+	if (schema.properties !== void 0 && properties === null) throw new Unsupported({ code: "invalid-properties" });
+	const fields = [];
+	const entries = Object.entries(properties ?? {});
+	for (const [name, subschema] of entries) fields.push({
+		...parseSubschema(subschema, name),
+		name,
+		...name.trim() === "" && { preserveBlankName: true }
+	});
+	if (schema.required !== void 0) {
+		if (!Array.isArray(schema.required)) throw new Unsupported({ code: "invalid-required" });
+		for (const entry of schema.required) {
+			if (typeof entry !== "string") throw new Unsupported({ code: "invalid-required" });
+			const field = fields.find((candidate) => candidate.name === entry);
+			if (field === void 0) throw new Unsupported({
+				code: "unknown-required-field",
+				field: entry
+			});
+			field.required = true;
+		}
+	}
+	return fields;
+}
+function parseDescription(schema) {
+	if (schema.description === void 0) return "";
+	if (typeof schema.description !== "string") throw new Unsupported({ code: "invalid-description" });
+	return schema.description;
+}
+function ensureAbsent(schema, key, holder) {
+	if (schema[key] !== void 0) throw new Unsupported({
+		code: "misplaced-keyword",
+		keyword: key,
+		holder
+	});
+}
+function parseSubschema(value, name) {
+	const schema = asPlainObject(value);
+	if (schema === null) throw new Unsupported({
+		code: "invalid-field-definition",
+		field: name
+	});
+	checkKeys(schema, SUBSCHEMA_KEYS);
+	const { type } = schema;
+	if (type !== void 0 && typeof type !== "string") throw new Unsupported({
+		code: "invalid-field-type",
+		field: name
+	});
+	const description = parseDescription(schema);
+	if (type === "object" || type === void 0 && (schema.properties !== void 0 || schema.required !== void 0)) {
+		ensureAbsent(schema, "items", "array");
+		return newSchemaTreeField({
+			type: "object",
+			description,
+			children: parseObjectFields(schema),
+			explicitType: type === "object"
+		});
+	}
+	if (type === "array" || type === void 0 && schema.items !== void 0) {
+		ensureAbsent(schema, "properties", "object");
+		ensureAbsent(schema, "required", "object");
+		return newSchemaTreeField({
+			type: "array",
+			description,
+			items: schema.items === void 0 ? null : parseSubschema(schema.items, name),
+			explicitType: type === "array"
+		});
+	}
+	if (type === void 0) {
+		ensureAbsent(schema, "items", "array");
+		return newSchemaTreeField({
+			type: "any",
+			description
+		});
+	}
+	if (!SCALAR_TYPES.has(type)) throw new Unsupported({
+		code: "unsupported-field-type",
+		field: name,
+		type
+	});
+	ensureAbsent(schema, "properties", "object");
+	ensureAbsent(schema, "required", "object");
+	ensureAbsent(schema, "items", "array");
+	return newSchemaTreeField({
+		type,
+		description
+	});
+}
+function parseSchemaTree(text) {
+	if (text.trim() === "") return {
+		ok: true,
+		tree: {
+			fields: [],
+			dialect: false,
+			description: ""
+		}
+	};
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return {
+			ok: false,
+			issue: { code: "invalid-json" }
+		};
+	}
+	try {
+		const root = asPlainObject(parsed);
+		if (root === null) throw new Unsupported({ code: "root-not-object" });
+		checkKeys(root, ROOT_KEYS);
+		const dialect = root.$schema !== void 0;
+		if (dialect && root.$schema !== "https://json-schema.org/draft/2020-12/schema") throw new Unsupported({ code: "unsupported-dialect" });
+		if (root.type !== void 0 && root.type !== "object") throw new Unsupported({ code: "root-not-object" });
+		return {
+			ok: true,
+			tree: {
+				fields: parseObjectFields(root),
+				dialect,
+				description: parseDescription(root),
+				explicitType: root.type === "object"
+			}
+		};
+	} catch (error) {
+		if (error instanceof Unsupported) return {
+			ok: false,
+			issue: error.issue
+		};
+		throw error;
+	}
+}
+function serializeObjectBody(fields) {
+	const named = fields.filter((field) => field.name.trim() !== "" || field.preserveBlankName === true);
+	const finalByName = /* @__PURE__ */ new Map();
+	const finalFields = [];
+	const body = {};
+	for (const field of named) finalByName.set(field.name, field);
+	finalByName.forEach((field) => {
+		finalFields.push(field);
+	});
+	if (finalFields.length > 0) body.properties = Object.fromEntries(finalFields.map((field) => [field.name, serializeField(field)]));
+	const required = finalFields.filter((field) => field.required).map((field) => field.name);
+	if (required.length > 0) body.required = required;
+	return body;
+}
+function serializeField(field) {
+	const description = field.description === "" ? {} : { description: field.description };
+	switch (field.type) {
+		case "any": return { ...description };
+		case "object": return {
+			...field.explicitType !== false && { type: "object" },
+			...description,
+			...serializeObjectBody(field.children)
+		};
+		case "array": {
+			const type = field.explicitType === false ? {} : { type: "array" };
+			return field.items === null || field.items.type === "any" && field.items.description === "" ? {
+				...type,
+				...description
+			} : {
+				...type,
+				...description,
+				items: serializeField(field.items)
+			};
+		}
+		default: return {
+			type: field.type,
+			...description
+		};
+	}
+}
+function serializeSchemaTree(tree) {
+	const root = {
+		...tree.dialect && { $schema: "https://json-schema.org/draft/2020-12/schema" },
+		...tree.explicitType !== false && { type: "object" },
+		...tree.description !== "" && { description: tree.description },
+		...serializeObjectBody(tree.fields)
+	};
+	return `${JSON.stringify(root, null, 2)}\n`;
+}
+export { CONDITION_OPERATORS, CONDITION_TREE_OPERATORS, ExpressionError, ExpressionNotReadyError, MAX_CONDITION_TREE_DEPTH, SCHEMA_DIALECT_2020_12, 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, inferSchema, isEngineReady, isZenRepresentableNumber, liftConditionTree, loadEngine, newConditionNodeId, newSchemaTreeField, parseSchemaTree, parseTemplateHoles, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, schemaTreeToExpressionType, selectBranch, selectBranchWith, serializeSchemaTree, subscribeExpressionMessages, templateHoleAt, toZenLiteral, zhCNMessages };