@coldsmirk/abacus-core 0.3.1 → 0.4.0

package/dist/index.cjs

@@ -1,1385 +1,2 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/engine/errors.ts
-/**
-* Error raised when the ZEN engine fails to load or an expression cannot be
-* evaluated. The original failure is preserved on {@link cause} and the
-* offending expression (if any) on {@link expression}.
-*/
-var ExpressionError = class extends Error {
-	expression;
-	constructor(message, expression, cause) {
-		super(message, { cause });
-		this.name = "ExpressionError";
-		this.expression = expression;
-	}
-};
-/**
-* Raised by the synchronous evaluation helpers when the engine has not finished
-* initializing yet. Await {@link loadEngine} (or render under
-* `<ExpressionEngineProvider>`) before evaluating synchronously.
-*/
-var ExpressionNotReadyError = class extends ExpressionError {
-	constructor(message = "Expression engine is not initialized. Await loadEngine() or render under <ExpressionEngineProvider>.") {
-		super(message);
-		this.name = "ExpressionNotReadyError";
-	}
-};
-//#endregion
-//#region src/internal/predicates.ts
-/**
-* Minimal internal type predicates. Inlined so the engine stays dependency-free
-* (no shared-utility package), keeping `@coldsmirk/abacus-core` framework- and
-* ecosystem-agnostic.
-*/
-function isUndefined(value) {
-	return value === void 0;
-}
-function isString(value) {
-	return typeof value === "string";
-}
-function isArray(value) {
-	return Array.isArray(value);
-}
-function isNullish(value) {
-	return value === null || value === void 0;
-}
-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;
-function evaluateSafely(expression, run) {
-	try {
-		return run();
-	} catch (error) {
-		throw new ExpressionError(`Failed to evaluate expression: ${expression}`, expression, error);
-	}
-}
-function loadFailureMessage() {
-	const base = "Failed to load the ZEN expression engine";
-	if (typeof window === "undefined") return `${base}. In a non-browser or non-DOM host (Node, SSR, Web Worker) the wasm cannot be auto-resolved; call configureEngine({ wasmInput }) with the wasm bytes or URL before loading.`;
-	return base;
-}
-/**
-* Configure how the wasm binary is located, before the engine loads. Must be
-* called before the first {@link loadEngine} (or any evaluation), so that the
-* configured input is the one actually used — calling it after the engine has
-* started loading throws, rather than silently taking no effect.
-*/
-function configureEngine(options) {
-	if (enginePromise || engineSync) throw new ExpressionError("configureEngine() must be called before the engine loads.");
-	configuredInput = options.wasmInput;
-}
-/**
-* Load and initialize the ZEN expression engine exactly once. Concurrent and
-* subsequent calls share the same in-flight promise / resolved instance. Set a
-* custom wasm source up front with {@link configureEngine}.
-*
-* The GoRules wasm dependency is reached via a dynamic `import()` on purpose: it
-* keeps this module usable from the package's CommonJS build (the dep is
-* ESM-only, so a static `require` would throw) and defers the multi-megabyte
-* wasm download until the engine is actually needed. Do NOT convert this to a
-* static import.
-*
-* A failed load is not cached: the rejected promise is dropped (the error is
-* latched on {@link getEngineError} for inspection), so calling `loadEngine()`
-* again retries from scratch. This is the clear-and-reload retry primitive after
-* a transient failure — an error boundary should call it before resetting.
-*/
-function loadEngine() {
-	if (enginePromise) return enginePromise;
-	engineError = null;
-	enginePromise = (async () => {
-		const zen = await import("@gorules/zen-engine-wasm");
-		await zen.default(isUndefined(configuredInput) ? void 0 : { module_or_path: configuredInput });
-		const toVariableType = (type) => zen.VariableType.fromJson(type);
-		const ensureTypeContext = (variables) => {
-			if (typeContextCache && typeContextCache.variables === variables) return typeContextCache;
-			const stale = typeContextCache;
-			typeContextCache = null;
-			stale?.handle.free();
-			const handle = toVariableType(variables);
-			try {
-				typeContextCache = {
-					variables,
-					handle,
-					rootKind: handle.toJson()
-				};
-			} catch (error) {
-				handle.free();
-				throw error;
-			}
-			return typeContextCache;
-		};
-		const engine = Object.freeze({
-			evaluate: (expression, context = {}) => evaluateSafely(expression, () => zen.evaluateExpression(expression, context)),
-			evaluateUnary: (expression, context = {}) => evaluateSafely(expression, () => zen.evaluateUnaryExpression(expression, context)),
-			validate: (expression) => zen.validateExpression(expression),
-			validateUnary: (expression) => zen.validateUnaryExpression(expression),
-			getCompletions: () => zen.getCompletions(),
-			analyze: (variables, source, unary) => {
-				const context = ensureTypeContext(variables);
-				const rawSpans = unary ? context.handle.typeCheckUnary(source) : context.handle.typeCheck(source);
-				return {
-					rootKind: context.rootKind,
-					spans: Array.isArray(rawSpans) ? rawSpans : []
-				};
-			},
-			satisfies: (actual, expected) => {
-				const actualType = toVariableType(actual);
-				try {
-					const expectedType = toVariableType(expected);
-					try {
-						return actualType.satisfies(expectedType);
-					} finally {
-						expectedType.free();
-					}
-				} finally {
-					actualType.free();
-				}
-			},
-			isReady: () => zen.isReady()
-		});
-		engineSync = engine;
-		return engine;
-	})().catch((error) => {
-		enginePromise = null;
-		engineError = new ExpressionError(loadFailureMessage(), void 0, error);
-		throw engineError;
-	});
-	return enginePromise;
-}
-/**
-* Whether the engine has finished initializing and is ready for sync use.
-*/
-function isEngineReady() {
-	return engineSync?.isReady() ?? false;
-}
-/**
-* The error from the last failed {@link loadEngine} attempt, or `null`. Used by
-* the React provider to surface a wasm-load failure to an error boundary rather
-* than suspending forever, and by imperative pollers to tell "failed" apart from
-* "still loading". Cleared when a new load starts or {@link resetEngine}.
-*/
-function getEngineError() {
-	return engineError;
-}
-/**
-* Return the already-initialized engine synchronously, or throw
-* {@link ExpressionNotReadyError} if {@link loadEngine} has not resolved yet.
-*/
-function getEngineSync() {
-	if (!engineSync) throw new ExpressionNotReadyError();
-	return engineSync;
-}
-/**
-* Reset the engine singleton — drops the loaded engine, the cached type context,
-* the latched error, and the configured wasm input. Mainly for tests, but also the
-* way to re-run {@link configureEngine} after a load (configure throws once the
-* engine has started loading).
-*/
-function resetEngine() {
-	typeContextCache?.handle.free();
-	typeContextCache = null;
-	enginePromise = null;
-	engineSync = null;
-	engineError = null;
-	configuredInput = void 0;
-}
-//#endregion
-//#region src/internal/env.ts
-/**
-* Best-effort development-mode flag for diagnostic-only code paths.
-*
-* Detected from `process.env.NODE_ENV` (defined by Node, test runners, webpack,
-* and Vite's SSR/`define`). The `typeof` guard is load-bearing: in a plain
-* browser bundle `process` is not declared at all, and any bare reference would
-* throw a ReferenceError while this module is being imported. Hosts without a
-* `process` default to "production" — the safe choice, since `isDev` only gates
-* extra developer-facing warnings.
-*/
-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
-/**
-* Shared subject-path guard for the condition compilers. A subject / left-hand
-* path is emitted **verbatim** into ZEN source, so both {@link compileCondition}
-* (which writes that source) and {@link liftConditionTree} (which reads it back)
-* gate paths through this one predicate — a single definition of "what is a safe
-* field path" that cannot drift between the writer and the reader, which matters
-* because the guard is also the compiler's injection defense.
-*/
-const SUBJECT_PATTERN = /^[A-Z_$][\w$]*(?:\.[A-Z_$][\w$]*|\[\d+\])*$/i;
-const ZEN_RESERVED_WORDS = new Set([
-	"and",
-	"or",
-	"not",
-	"in",
-	"true",
-	"false",
-	"null"
-]);
-/**
-* Whether `subject` is a plain identifier path safe to emit verbatim into ZEN
-* source: dotted/indexed segments only, none of which is a ZEN reserved word.
-*/
-function isIdentifierPath(subject) {
-	return SUBJECT_PATTERN.test(subject) && (subject.match(/[A-Z_$][\w$]*/gi) ?? []).every((segment) => !ZEN_RESERVED_WORDS.has(segment));
-}
-//#endregion
-//#region src/condition/compile.ts
-/**
-* Serialize a JavaScript value into a ZEN literal. Nullish becomes `null`;
-* numbers / booleans / bigints are emitted verbatim; strings are quoted via
-* {@link encodeZenString}; arrays become `[a, b, ...]`.
-*
-* Throws {@link ExpressionError} for a value with no faithful ZEN
-* representation — an object, symbol, or function, or a string containing both
-* quote styles. Callers that need a sentinel instead of a throw go through
-* {@link compileCondition}, which degrades such a value to a non-compiling
-* (null) condition.
-*/
-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`);
-		return String(value);
-	}
-	if (typeof value === "boolean" || typeof value === "bigint") 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`);
-}
-/**
-* Encode a string as a ZEN literal. ZEN string literals are **raw** between
-* matching quotes and honor no backslash escapes (`'a\nb'` is the four
-* characters `a \ n b`), so the encoder must not escape — it picks a delimiter
-* the value does not contain. A value containing both quote styles cannot be
-* represented as a raw ZEN literal and throws.
-*/
-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}'`;
-}
-function toArrayLiteral(value) {
-	return isArray(value) ? toZenLiteral(value) : `[${toZenLiteral(value)}]`;
-}
-/**
-* Emit the ZEN emptiness test matching the backend field evaluator's
-* `isEmptyValue`: null, blank (whitespace-only) text, and empty arrays are
-* empty; numbers and booleans never are. ZEN's `or` short-circuits, so the
-* type-guarded branches never evaluate against a null subject. The backend
-* additionally treats an empty map as empty for totality, but form values —
-* the only subjects this compiler targets — are never objects, and ZEN's
-* `len()` does not accept one.
-*/
-function zenIsEmpty(subject) {
-	return `(${subject} == null or (type(${subject}) == 'string' and len(trim(${subject})) == 0) or (type(${subject}) == 'array' and len(${subject}) == 0))`;
-}
-function compileFieldCondition(subject, operator, value) {
-	switch (operator) {
-		case "eq": return `${subject} == ${toZenLiteral(value)}`;
-		case "ne": return `${subject} != ${toZenLiteral(value)}`;
-		case "gt": return `${subject} > ${toZenLiteral(value)}`;
-		case "gte": return `${subject} >= ${toZenLiteral(value)}`;
-		case "lt": return `${subject} < ${toZenLiteral(value)}`;
-		case "lte": return `${subject} <= ${toZenLiteral(value)}`;
-		case "contains": return `contains(${subject}, ${toZenLiteral(value)})`;
-		case "not_contains": return `not contains(${subject}, ${toZenLiteral(value)})`;
-		case "starts_with": return `startsWith(${subject}, ${toZenLiteral(value)})`;
-		case "ends_with": return `endsWith(${subject}, ${toZenLiteral(value)})`;
-		case "in": return `${subject} in ${toArrayLiteral(value)}`;
-		case "not_in": return `not (${subject} in ${toArrayLiteral(value)})`;
-		case "is_empty": return zenIsEmpty(subject);
-		case "is_not_empty": return `not ${zenIsEmpty(subject)}`;
-		default: throw new ExpressionError(`Unsupported operator: ${String(operator)}`);
-	}
-}
-/**
-* Compile a single condition into a ZEN boolean expression. Field conditions map
-* their operator to ZEN; expression conditions are wrapped in parentheses to
-* preserve their grouping. Returns `null` when the condition is empty, its
-* subject is not an identifier path, or its value has no ZEN representation.
-*/
-function compileCondition(condition) {
-	if (condition.kind === "expression") {
-		const expression = condition.expression.trim();
-		return expression === "" ? null : `(${expression})`;
-	}
-	const subject = condition.subject.trim();
-	if (!isIdentifierPath(subject)) return null;
-	try {
-		return compileFieldCondition(subject, condition.operator, condition.value);
-	} catch {
-		return null;
-	}
-}
-/**
-* Compile a condition group (its conditions joined with AND). Returns `null`
-* when the group has no compilable conditions.
-*/
-function compileGroup(group) {
-	const parts = group.conditions.map((condition) => compileCondition(condition)).filter((part) => part !== null);
-	return parts.length === 0 ? null : parts.join(" and ");
-}
-/**
-* Compile a branch's condition groups into a single ZEN expression (groups
-* joined with OR). Returns `null` when the branch has no compilable groups
-* (e.g. a default branch).
-*/
-function compileBranch(branch) {
-	const groups = (branch.conditionGroups ?? []).map((group) => compileGroup(group)).filter((group) => group !== null);
-	return groups.length === 0 ? null : groups.map((group) => `(${group})`).join(" or ");
-}
-/**
-* Pick the matching branch for the given context using a pre-loaded engine.
-* Non-default branches are tested in ascending `priority` order; the first whose
-* compiled expression evaluates to `true` wins. Falls back to the default
-* branch, or a `null` id when neither matches.
-*
-* A branch whose expression throws for the given context (e.g. ZEN's `>`
-* throws when the subject is missing or non-numeric) is treated as not matching
-* rather than propagating — so a missing field degrades to the default branch
-* instead of crashing the caller.
-*/
-function selectBranchWith(branches, context, engine) {
-	const ordered = branches.toSorted((a, b) => a.priority - b.priority);
-	for (const branch of ordered) {
-		if (branch.isDefault) continue;
-		const expression = compileBranch(branch);
-		if (expression === null) {
-			if (isDev) console.warn(`[expression] branch "${branch.id}" has no compilable condition and can never match`);
-			continue;
-		}
-		if (evaluatesTrue(engine, expression, context)) return {
-			branchId: branch.id,
-			matched: true
-		};
-	}
-	return {
-		branchId: ordered.find((branch) => branch.isDefault)?.id ?? null,
-		matched: false
-	};
-}
-function evaluatesTrue(engine, expression, context) {
-	try {
-		return engine.evaluate(expression, context) === true;
-	} catch (error) {
-		if (isDev) reportEvaluationFailure(engine, expression, error);
-		return false;
-	}
-}
-function reportEvaluationFailure(engine, expression, error) {
-	let diagnostic;
-	try {
-		diagnostic = engine.validate(expression);
-	} catch {
-		return;
-	}
-	if (!isNullish(diagnostic)) console.warn(`[expression] compiled branch expression failed to parse: ${expression}`, diagnostic, error);
-}
-/**
-* Pick the matching branch for the given context, loading the ZEN engine on
-* first use. See {@link selectBranchWith} for the selection semantics.
-*/
-async function selectBranch(branches, context) {
-	return selectBranchWith(branches, context, await loadEngine());
-}
-//#endregion
-//#region src/condition/types.ts
-/**
-* Structural shapes for the visual condition model compiled to ZEN. They mirror
-* the condition types used in the form and flow editors so a host can map those
-* definitions to {@link compileCondition} / {@link selectBranch} without this
-* package depending on either editor. The editors keep a flat working model for
-* form ergonomics (a row can hold both a half-typed field triple and an
-* expression while the author toggles between them); this discriminated input is
-* the narrowed, compiler-facing shape where each kind carries only what it uses.
-*/
-/**
-* The closed operator vocabulary understood by {@link compileCondition}, as a
-* runtime constant so validators can build allow-lists from it instead of
-* re-declaring the set. The {@link ConditionOperator} type derives from this
-* array — one definition site for both the type and the runtime list.
-*/
-const CONDITION_OPERATORS = [
-	"eq",
-	"ne",
-	"gt",
-	"gte",
-	"lt",
-	"lte",
-	"contains",
-	"not_contains",
-	"starts_with",
-	"ends_with",
-	"in",
-	"not_in",
-	"is_empty",
-	"is_not_empty"
-];
-const CONDITION_OPERATOR_ARITIES = {
-	eq: "scalar",
-	ne: "scalar",
-	gt: "scalar",
-	gte: "scalar",
-	lt: "scalar",
-	lte: "scalar",
-	contains: "scalar",
-	not_contains: "scalar",
-	starts_with: "scalar",
-	ends_with: "scalar",
-	in: "array",
-	not_in: "array",
-	is_empty: "none",
-	is_not_empty: "none"
-};
-/**
-* The arity of `operator`'s right-hand operand (see
-* {@link ConditionOperatorArity}). One definition site next to
-* {@link CONDITION_OPERATORS}, so the tree compiler's arity enforcement and a
-* condition editor's operand controls classify operators identically instead of
-* each keeping a drift-prone copy.
-*/
-function conditionOperatorArity(operator) {
-	return CONDITION_OPERATOR_ARITIES[operator];
-}
-//#endregion
-//#region src/condition/compile-tree.ts
-/**
-* Compile a condition tree to a canonical ZEN expression, or `""` when no rule in
-* the tree is compilable (see the module note for the drop semantics).
-*/
-function compileConditionTree(tree) {
-	const normalized = normalizeNode(tree);
-	return normalized === null ? "" : emitNode(normalized, true);
-}
-/**
-* Prune a node to its compilable core: drop rules {@link compileRule} rejects, drop
-* emptied groups, and collapse a single-surviving-item group to that item (so the
-* emitted shape carries no redundant parentheses). Returns `null` when nothing in
-* the node survives.
-*/
-function normalizeNode(node) {
-	if (node.kind === "rule") return compileRule(node) === null ? null : node;
-	const items = node.items.map((item) => normalizeNode(item)).filter((item) => item !== null);
-	if (items.length === 0) return null;
-	if (items.length === 1) return items[0];
-	return {
-		kind: "group",
-		op: node.op,
-		items
-	};
-}
-/**
-* Render a normalized node. A rule emits its lowered ZEN; a group joins its items
-* with ` and ` / ` or ` and, unless it is the top-level group, wraps them in
-* parentheses so the tree structure survives ZEN's operator precedence on lift.
-*/
-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 ");
-	return topLevel ? joined : `(${joined})`;
-}
-/**
-* Lower a leaf rule to ZEN via {@link compileCondition}, or `null` for a rule the
-* compiler cannot represent. The rule's `right` must match its operator's arity —
-* a single scalar for the comparison / string operators, an array of scalars for
-* `in` / `not_in`, absent for the emptiness operators (the contract
-* {@link ConditionTreeValue} documents); an off-arity rule is non-compilable and
-* drops. Enforcing arity here, not just relying on `compileCondition`, is what
-* keeps every emitted expression liftable: the flat compiler's lax value handling
-* would happily serialize e.g. a missing `right` as a `null` literal, which is not
-* part of the canonical grammar.
-*/
-function compileRule(rule) {
-	if (!matchesOperatorArity(rule)) return null;
-	return compileCondition({
-		kind: "field",
-		subject: rule.left,
-		operator: rule.operator,
-		value: rule.right
-	});
-}
-function matchesOperatorArity(rule) {
-	switch (conditionOperatorArity(rule.operator)) {
-		case "scalar": return isConditionScalar(rule.right);
-		case "array": return isScalarArray(rule.right);
-		case "none": return rule.right === void 0;
-	}
-}
-function isConditionScalar(value) {
-	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-function isScalarArray(value) {
-	return isArray(value) && value.every((item) => isConditionScalar(item));
-}
-//#endregion
-//#region src/condition/lift-tree.ts
-const TWO_CHAR_PUNCTUATION = new Set([
-	"==",
-	"!=",
-	"<=",
-	">="
-]);
-const ONE_CHAR_PUNCTUATION = new Set([
-	"(",
-	")",
-	"[",
-	"]",
-	",",
-	".",
-	"<",
-	">",
-	"-"
-]);
-const IDENT_START = /[a-z_$]/i;
-const IDENT_PART = /[\w$]/;
-const DIGIT = /\d/;
-const NUMBER_PATTERN = /^\d+(?:\.\d+)?(?:e[+-]?\d+)?/i;
-const INTEGER_PATTERN = /^\d+$/;
-const COMPARISON_OPERATORS = {
-	"==": "eq",
-	"!=": "ne",
-	">": "gt",
-	">=": "gte",
-	"<": "lt",
-	"<=": "lte"
-};
-const CALL_OPERATORS = {
-	contains: "contains",
-	startsWith: "starts_with",
-	endsWith: "ends_with"
-};
-const MAX_GROUP_DEPTH = 64;
-/**
-* Lift a ZEN expression to a condition tree, or `null` when it is not in the
-* canonical form {@link compileConditionTree} produces (the consumer then keeps the
-* raw expression). Groups nested deeper than 64 parenthesized levels are refused as
-* non-canonical rather than risking parser-stack overflow on adversarial input. The
-* returned root is always a group.
-*/
-function liftConditionTree(expression) {
-	const tokens = tokenize(expression);
-	if (tokens === null || tokens.length === 0) return null;
-	let pos = 0;
-	function peek(offset = 0) {
-		return tokens[pos + offset];
-	}
-	function consumePunct(value) {
-		const token = peek();
-		if (token !== void 0 && token.kind === "punct" && token.value === value) {
-			pos += 1;
-			return true;
-		}
-		return false;
-	}
-	function consumeIdent(value) {
-		const token = peek();
-		if (token !== void 0 && token.kind === "ident" && token.value === value) {
-			pos += 1;
-			return true;
-		}
-		return false;
-	}
-	function tokensMatchAt(from, expected) {
-		for (const [index, element] of expected.entries()) {
-			const actual = tokens[from + index];
-			const want = element;
-			if (actual === void 0 || actual.kind !== want.kind || actual.value !== want.value) return false;
-		}
-		return true;
-	}
-	function parsePath() {
-		const read = readPath(tokens, pos);
-		if (read === null) return null;
-		pos = read.next;
-		return read.path;
-	}
-	function parseLiteral() {
-		const token = peek();
-		if (token === void 0) return null;
-		if (token.kind === "string") {
-			pos += 1;
-			return token.value;
-		}
-		if (token.kind === "number") {
-			pos += 1;
-			return Number(token.value);
-		}
-		if (token.kind === "ident") {
-			if (token.value === "true") {
-				pos += 1;
-				return true;
-			}
-			if (token.value === "false") {
-				pos += 1;
-				return false;
-			}
-			return null;
-		}
-		if (token.kind === "punct" && token.value === "-") {
-			const digits = peek(1);
-			if (digits === void 0 || digits.kind !== "number") return null;
-			pos += 2;
-			return -Number(digits.value);
-		}
-		return null;
-	}
-	function parseArray() {
-		if (!consumePunct("[")) return null;
-		if (isPunct(peek(), "]")) {
-			pos += 1;
-			return [];
-		}
-		const first = parseLiteral();
-		if (first === null) return null;
-		const items = [first];
-		while (isPunct(peek(), ",")) {
-			pos += 1;
-			const next = parseLiteral();
-			if (next === null) return null;
-			items.push(next);
-		}
-		return consumePunct("]") ? items : null;
-	}
-	function parseCall(operator) {
-		if (!consumePunct("(")) return null;
-		const left = parsePath();
-		if (left === null || !consumePunct(",")) return null;
-		const right = parseLiteral();
-		if (right === null || !consumePunct(")")) return null;
-		return {
-			kind: "rule",
-			left,
-			operator,
-			right
-		};
-	}
-	function parseNotIn() {
-		const left = parsePath();
-		if (left === null || !consumeIdent("in")) return null;
-		const right = parseArray();
-		if (right === null || !consumePunct(")")) return null;
-		return {
-			kind: "rule",
-			left,
-			operator: "not_in",
-			right
-		};
-	}
-	function tryEmptiness() {
-		const first = peek();
-		if (first === void 0) return null;
-		let operator;
-		let pathIndex;
-		if (first.kind === "ident" && first.value === "not" && isPunct(peek(1), "(")) {
-			operator = "is_not_empty";
-			pathIndex = pos + 2;
-		} else if (first.kind === "punct" && first.value === "(") {
-			operator = "is_empty";
-			pathIndex = pos + 1;
-		} else return null;
-		const read = readPath(tokens, pathIndex);
-		if (read === null) return null;
-		const canonical = compileCondition({
-			kind: "field",
-			subject: read.path,
-			operator,
-			value: void 0
-		});
-		if (canonical === null) return null;
-		const expected = tokenize(canonical);
-		if (expected === null || !tokensMatchAt(pos, expected)) return null;
-		pos += expected.length;
-		return {
-			kind: "rule",
-			left: read.path,
-			operator
-		};
-	}
-	function parseRule() {
-		const token = peek();
-		if (token === void 0 || token.kind !== "ident") return null;
-		if (token.value === "not") {
-			const next = peek(1);
-			if (next === void 0) return null;
-			if (next.kind === "ident" && next.value === "contains" && isPunct(peek(2), "(")) {
-				pos += 2;
-				return parseCall("not_contains");
-			}
-			if (next.kind === "punct" && next.value === "(") {
-				pos += 2;
-				return parseNotIn();
-			}
-			return null;
-		}
-		if (isPunct(peek(1), "(")) {
-			const operator = CALL_OPERATORS[token.value];
-			if (operator === void 0) return null;
-			pos += 1;
-			return parseCall(operator);
-		}
-		const left = parsePath();
-		if (left === null) return null;
-		const operatorToken = peek();
-		if (operatorToken === void 0) return null;
-		if (operatorToken.kind === "ident" && operatorToken.value === "in") {
-			pos += 1;
-			const right = parseArray();
-			return right === null ? null : {
-				kind: "rule",
-				left,
-				operator: "in",
-				right
-			};
-		}
-		if (operatorToken.kind === "punct") {
-			const operator = COMPARISON_OPERATORS[operatorToken.value];
-			if (operator === void 0) return null;
-			pos += 1;
-			const right = parseLiteral();
-			return right === null ? null : {
-				kind: "rule",
-				left,
-				operator,
-				right
-			};
-		}
-		return null;
-	}
-	function parseItem(depth) {
-		const emptiness = tryEmptiness();
-		if (emptiness !== null) return emptiness;
-		if (isPunct(peek(), "(")) {
-			if (depth >= MAX_GROUP_DEPTH) return null;
-			pos += 1;
-			const inner = parseGroup(depth + 1);
-			if (inner === null || !consumePunct(")")) return null;
-			return asGroup(inner);
-		}
-		return parseRule();
-	}
-	function peekJoin() {
-		const token = peek();
-		if (token !== void 0 && token.kind === "ident" && (token.value === "and" || token.value === "or")) return token.value;
-		return null;
-	}
-	function parseGroup(depth) {
-		const first = parseItem(depth);
-		if (first === null) return null;
-		const items = [first];
-		let op = null;
-		let join = peekJoin();
-		while (join !== null) {
-			if (op === null) op = join;
-			else if (op !== join) return null;
-			pos += 1;
-			const next = parseItem(depth);
-			if (next === null) return null;
-			items.push(next);
-			join = peekJoin();
-		}
-		return items.length === 1 ? items[0] : {
-			kind: "group",
-			op: op ?? "and",
-			items
-		};
-	}
-	const parsed = parseGroup(0);
-	if (parsed === null || pos !== tokens.length) return null;
-	return asGroup(parsed);
-}
-/**
-* Read a dotted/indexed identifier path starting at `from`, validated through
-* {@link isIdentifierPath}. Pure over the token array (no cursor) so it can probe a
-* candidate path — the emptiness oracle reads the blob's subject without committing
-* the cursor. Returns the path and the index just past it, or `null`.
-*/
-function readPath(tokens, from) {
-	const head = tokens[from];
-	if (head === void 0 || head.kind !== "ident") return null;
-	let path = head.value;
-	let index = from + 1;
-	let segment = tokens[index];
-	while (segment !== void 0 && segment.kind === "punct" && (segment.value === "." || segment.value === "[")) {
-		if (segment.value === ".") {
-			const name = tokens[index + 1];
-			if (name === void 0 || name.kind !== "ident") return null;
-			path += `.${name.value}`;
-			index += 2;
-		} else {
-			const inner = tokens[index + 1];
-			if (inner === void 0 || inner.kind !== "number" || !INTEGER_PATTERN.test(inner.value)) return null;
-			const close = tokens[index + 2];
-			if (close === void 0 || close.kind !== "punct" || close.value !== "]") return null;
-			path += `[${inner.value}]`;
-			index += 3;
-		}
-		segment = tokens[index];
-	}
-	return isIdentifierPath(path) ? {
-		path,
-		next: index
-	} : null;
-}
-function asGroup(node) {
-	return node.kind === "group" ? node : {
-		kind: "group",
-		op: "and",
-		items: [node]
-	};
-}
-function isPunct(token, value) {
-	return token !== void 0 && token.kind === "punct" && token.value === value;
-}
-/**
-* Split a ZEN expression into tokens, or `null` on an unexpected character or an
-* unterminated string. Whitespace is dropped, so the parser (and the emptiness
-* oracle's token match) is insensitive to spacing. String literals are read raw
-* between matching quotes — ZEN honors no backslash escapes, mirroring the encoder
-* in {@link compileCondition}.
-*/
-function tokenize(input) {
-	const tokens = [];
-	let index = 0;
-	while (index < input.length) {
-		const char = input[index];
-		if (char === " " || char === "	" || char === "\n" || char === "\r") {
-			index += 1;
-			continue;
-		}
-		if (char === "'" || char === "\"") {
-			const end = input.indexOf(char, index + 1);
-			if (end === -1) return null;
-			tokens.push({
-				kind: "string",
-				value: input.slice(index + 1, end)
-			});
-			index = end + 1;
-			continue;
-		}
-		const pair = input.slice(index, index + 2);
-		if (TWO_CHAR_PUNCTUATION.has(pair)) {
-			tokens.push({
-				kind: "punct",
-				value: pair
-			});
-			index += 2;
-			continue;
-		}
-		if (ONE_CHAR_PUNCTUATION.has(char)) {
-			tokens.push({
-				kind: "punct",
-				value: char
-			});
-			index += 1;
-			continue;
-		}
-		if (DIGIT.test(char)) {
-			const match = NUMBER_PATTERN.exec(input.slice(index));
-			if (match === null) return null;
-			tokens.push({
-				kind: "number",
-				value: match[0]
-			});
-			index += match[0].length;
-			continue;
-		}
-		if (IDENT_START.test(char)) {
-			let end = index + 1;
-			while (end < input.length && IDENT_PART.test(input[end])) end += 1;
-			tokens.push({
-				kind: "ident",
-				value: input.slice(index, end)
-			});
-			index = end;
-			continue;
-		}
-		return null;
-	}
-	return tokens;
-}
-//#endregion
-//#region src/condition/tree-types.ts
-/**
-* The visual condition **tree** model: an arbitrarily nested and/or tree of typed
-* comparison rules that {@link compileConditionTree} serializes to a single ZEN
-* boolean expression and {@link liftConditionTree} reconstructs from one. It is a
-* distinct, self-contained shape from the compiler's flat {@link ConditionInput} —
-* the tree is what a structured builder UI edits, whereas `ConditionInput` is the
-* narrowed per-condition shape the compiler consumes. The two meet only at the
-* leaf: a {@link ConditionTreeRule} lowers to a field {@link ConditionInput} so the
-* operator vocabulary, literal encoding, and injection guard have one owner.
-*/
-/**
-* The tree's operator vocabulary as a runtime list — the compiler's full
-* {@link CONDITION_OPERATORS} set under the tree name. An alias, not a second
-* hand-maintained list, so the tree vocabulary can never drift from the compiler's;
-* it gives tree code and the builder UI one tree-named import for the operators they
-* support.
-*/
-const CONDITION_TREE_OPERATORS = CONDITION_OPERATORS;
-//#endregion
-//#region src/engine/evaluate.ts
-/**
-* Evaluate a standard ZEN expression, loading the engine on first use.
-*
-* `T` is an **unchecked** assertion — the value is returned as `T` with no
-* runtime validation, and ZEN's result type depends on the expression and
-* context. Prefer the `unknown` default and narrow at the call site.
-*/
-async function evaluate(expression, context) {
-	await loadEngine();
-	return evaluateSync(expression, context);
-}
-/**
-* Evaluate a ZEN unary (test) expression, loading the engine on first use.
-*/
-async function evaluateUnary(expression, context) {
-	await loadEngine();
-	return evaluateUnarySync(expression, context);
-}
-/**
-* Evaluate a standard ZEN expression synchronously. Throws
-* {@link ExpressionNotReadyError} when the engine has not loaded yet — use this
-* only behind a readiness gate (e.g. under `<ExpressionEngineProvider>`).
-*/
-function evaluateSync(expression, context) {
-	return getEngineSync().evaluate(expression, context);
-}
-/**
-* Evaluate a ZEN unary (test) expression synchronously. Throws
-* {@link ExpressionNotReadyError} when the engine has not loaded yet.
-*/
-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": "检查变量是否包含指定元素",
-	"Flattens an array": "将数组扁平化",
-	"Merges multiple objects into one.": "将多个对象合并为一个。",
-	"Deeply merges multiple objects into one.": "将多个对象深度合并为一个。",
-	"Converts all characters in a string to uppercase": "将字符串中所有字符转换为大写",
-	"Converts all characters in a string to lowercase": "将字符串中所有字符转换为小写",
-	"Returns the string with leading and trailing whitespace removed": "返回去除首尾空白后的字符串",
-	"Returns true if the string starts with the specified prefix": "若字符串以指定前缀开头则返回 true",
-	"Returns true if the string ends with the specified suffix": "若字符串以指定后缀结尾则返回 true",
-	"Returns true if the string matches the specified pattern": "若字符串匹配指定模式则返回 true",
-	"Extracts matching substrings according to a pattern": "按模式提取匹配的子串",
-	"Performs a fuzzy search of the needle in the haystack, and returns the match score(s).": "在目标中对关键字进行模糊搜索，并返回匹配得分。",
-	"Splits a string into an array of substrings using the specified delimiter.": "使用指定分隔符将字符串拆分为子串数组。",
-	"Returns the absolute value of a number": "返回数字的绝对值",
-	"Returns the sum of all elements in the input array.": "返回输入数组中所有元素之和。",
-	"Calculates the average of all elements in the input array.": "计算输入数组中所有元素的平均值。",
-	"Returns the smallest of the elements in the input array.": "返回输入数组中的最小元素。",
-	"Returns the largest of the elements in the input array.": "返回输入数组中的最大元素。",
-	"Generates a random number between 0 (inclusive) and max (inclusive).": "生成 0 到 max（均包含）之间的随机数。",
-	"Calculates the median value of all elements in the input array.": "计算输入数组中所有元素的中位数。",
-	"Finds the mode(s) of the input array, which are the most frequent element(s).": "求输入数组的众数，即出现最频繁的元素。",
-	"Rounds a number down to the nearest integer.": "向下取整到最接近的整数。",
-	"Rounds a number up to the nearest integer.": "向上取整到最接近的整数。",
-	"Rounds a number to a specified number of decimal places.": "将数字四舍五入到指定的小数位数。",
-	"Truncates a number to a specified number of decimal places.": "将数字截断到指定的小数位数。",
-	"Checks if the given value is of a numeric type.": "检查给定值是否为数值类型。",
-	"Converts the given value to a string.": "将给定值转换为字符串。",
-	"Converts the given value to a number.": "将给定值转换为数字。",
-	"Converts the given value to a boolean.": "将给定值转换为布尔值。",
-	"Returns a string representing the data type of the value.": "返回表示该值数据类型的字符串。",
-	"Returns an array of a given object's own enumerable property names.": "返回由给定对象自身可枚举属性名组成的数组。",
-	"Returns an array of a given object's own enumerable property values.": "返回由给定对象自身可枚举属性值组成的数组。",
-	"Returns a new date time instance.": "返回一个新的日期时间实例。",
-	"Converts a numeric timestamp to a unix timestamp.": "将数值时间戳转换为 Unix 时间戳。",
-	"Extracts the time from a numeric timestamp and returns it as a seconds from beginning of day.": "从数值时间戳中提取时间，以当天起始的秒数返回。",
-	"e.g. 1h30min": "例如 1h30min",
-	"Extracts the year from a given timestamp.": "从给定时间戳中提取年份。",
-	"Gets the day of the week from a given timestamp, where Sunday might be 0.": "获取给定时间戳的星期几（周日可能为 0）。",
-	"Extracts the day of the month from a given timestamp.": "从给定时间戳中提取当月的日期。",
-	"Gets the day of the year from a given timestamp.": "获取给定时间戳在一年中的第几天。",
-	"Calculates the week of the year from a given timestamp.": "计算给定时间戳在一年中的第几周。",
-	"Extracts the month from a given timestamp, typically with January as 1.": "从给定时间戳中提取月份（通常 1 月为 1）。",
-	"Converts the month from a given timestamp into its string representation (e.g., 'Jan').": "将给定时间戳的月份转换为字符串表示（例如 'Jan'）。",
-	"Converts a timestamp to a human-readable date string.": "将时间戳转换为人类可读的日期字符串。",
-	"Converts the day of the week from a given timestamp into its string representation (e.g., 'Mon').": "将给定时间戳的星期几转换为字符串表示（例如 'Mon'）。",
-	"Returns the timestamp representing the start of a specified unit (e.g., day, month, year) based on a given timestamp.": "返回给定时间戳在指定单位（如日、月、年）起始处的时间戳。",
-	"Returns the timestamp representing the end of a specified unit (e.g., day, month, year) based on a given timestamp.": "返回给定时间戳在指定单位（如日、月、年）结束处的时间戳。",
-	"Checks if all elements in the array satisfy the condition defined in the callback.": "检查数组中所有元素是否都满足回调中定义的条件。",
-	"Checks if no elements in the array satisfy the condition defined in the callback.": "检查数组中是否没有任何元素满足回调中定义的条件。",
-	"Checks if at least one element in the array satisfies the condition defined in the callback.": "检查数组中是否至少有一个元素满足回调中定义的条件。",
-	"Checks if exactly one element in the array satisfies the condition defined in the callback.": "检查数组中是否恰好有一个元素满足回调中定义的条件。",
-	"Creates a new array with all elements that satisfy the condition defined in the callback.": "创建一个仅包含满足回调中定义条件的元素的新数组。",
-	"Creates a new array populated with the results of calling the provided function on every element in the calling array.": "创建一个新数组，其元素为对原数组每个元素调用所提供函数的结果。",
-	"First maps each element using a mapping function, then flattens the result into a new array.": "先用映射函数处理每个元素，再将结果扁平化为新数组。",
-	"Counts the number of elements in the array that satisfy the condition defined in the callback.": "统计数组中满足回调中定义条件的元素个数。",
-	"Adds time to a date": "为日期增加时间",
-	"Subtracts time from a date": "从日期中减去时间",
-	"Sets a specific unit of time on a date": "设置日期的某个时间单位",
-	"Formats a date into a string representation": "将日期格式化为字符串",
-	"Returns the start of a specified time unit for a date": "返回日期在指定时间单位上的起始",
-	"Returns the end of a specified time unit for a date": "返回日期在指定时间单位上的结束",
-	"Calculates the difference between two dates": "计算两个日期之间的差值",
-	"Converts a date to a different timezone": "将日期转换到不同的时区",
-	"Checks if two dates are the same": "检查两个日期是否相同",
-	"Checks if a date is before another date": "检查日期是否早于另一个日期",
-	"Checks if a date is after another date": "检查日期是否晚于另一个日期",
-	"Checks if a date is the same as or before another date": "检查日期是否等于或早于另一个日期",
-	"Checks if a date is the same as or after another date": "检查日期是否等于或晚于另一个日期",
-	"Gets the seconds of a date": "获取日期的秒",
-	"Gets the minutes of a date": "获取日期的分钟",
-	"Gets the hours of a date": "获取日期的小时",
-	"Gets the day of the month for a date": "获取日期在当月的第几天",
-	"Gets the day of the year for a date": "获取日期在当年的第几天",
-	"Gets the week of the year for a date": "获取日期在当年的第几周",
-	"Gets the day of the week for a date": "获取日期的星期几",
-	"Gets the month for a date": "获取日期的月份",
-	"Gets the quarter for a date": "获取日期所在的季度",
-	"Gets the year for a date": "获取日期的年份",
-	"Gets the Unix timestamp for a date": "获取日期的 Unix 时间戳",
-	"Gets the timezone offset name for a date": "获取日期的时区偏移名称",
-	"Checks if a date is valid": "检查日期是否有效",
-	"Checks if a date is yesterday": "检查日期是否为昨天",
-	"Checks if a date is today": "检查日期是否为今天",
-	"Checks if a date is tomorrow": "检查日期是否为明天",
-	"Checks if the year of a date is a leap year": "检查日期所在年份是否为闰年"
-};
-const EN_SOURCE_LABELS = {
-	lexerError: "Lexer error",
-	parserError: "Parser error",
-	compilerError: "Compiler error",
-	vmError: "VM error"
-};
-const ZH_SOURCE_LABELS = {
-	lexerError: "词法错误",
-	parserError: "语法错误",
-	compilerError: "编译错误",
-	vmError: "运行时错误"
-};
-function sourceLabelFrom(table, fallback, type) {
-	return (type === void 0 ? void 0 : table[type]) ?? fallback;
-}
-/**
-* Built-in English message catalog (the default).
-*/
-const enMessages = {
-	sourceLabel: (type) => sourceLabelFrom(EN_SOURCE_LABELS, "Error", type),
-	completionInfo: (info) => info,
-	typeCheckSource: "Type check",
-	expectedBoolean: (actualType) => `Expected a boolean test expression, received \`${actualType}\`.`,
-	expectedType: (expectedType, actualType) => `Expected \`${expectedType}\`, received \`${actualType}\`.`
-};
-/**
-* Built-in Simplified Chinese message catalog.
-*/
-const zhCNMessages = {
-	sourceLabel: (type) => sourceLabelFrom(ZH_SOURCE_LABELS, "错误", type),
-	completionInfo: (info) => info === "" ? "" : COMPLETION_INFO_ZH[info] ?? info,
-	typeCheckSource: "类型检查",
-	expectedBoolean: (actualType) => `期望布尔测试表达式，实际类型为 \`${actualType}\`。`,
-	expectedType: (expectedType, actualType) => `期望 \`${expectedType}\`，实际为 \`${actualType}\`。`
-};
-const localeRegistry = new Map([["en-US", enMessages], ["zh-CN", zhCNMessages]]);
-let activeMessages = enMessages;
-/**
-* Register (or replace) the message catalog for a locale key, making it selectable
-* via {@link configureExpressionMessages}. This is how a host adds a language the
-* library does not ship — the built-in locales are registered the same way, so
-* there is no privileged path.
-*/
-function registerExpressionLocale(locale, messages) {
-	localeRegistry.set(locale, messages);
-}
-/**
-* Configure the active message catalog. Pass a `locale`, a partial `messages`
-* override, or both (overrides win). Idempotent and module-global, so a host
-* configures it once (e.g. through `ExpressionConfigProvider`).
-*/
-function configureExpressionMessages({ locale, messages }) {
-	const base = locale === void 0 ? activeMessages : localeRegistry.get(locale) ?? activeMessages;
-	activeMessages = messages === void 0 ? base : {
-		...base,
-		...messages
-	};
-}
-/**
-* The active {@link ExpressionMessages} catalog (English by default).
-*/
-function getExpressionMessages() {
-	return activeMessages;
-}
-//#endregion
-//#region src/engine/intellisense.ts
-function parseOffset(text) {
-	const trimmed = text?.trim();
-	return trimmed ? Number(trimmed) : NaN;
-}
-/**
-* Parse a trailing `... at (from, to)` / `... at pos` position out of a ZEN error
-* message. Returns a `[from, to]` range — a single offset collapses to
-* `[pos, pos]` — or `null` when no position is present.
-*/
-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];
-}
-/**
-* Normalize the wasm validate payload (`null` or `{ type, source }`) into a
-* positioned {@link ExpressionDiagnostic}, or `null` when the expression is valid.
-*/
-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];
-	return {
-		from,
-		to,
-		message,
-		source: getExpressionMessages().sourceLabel(errorType)
-	};
-}
-/**
-* Normalize the wasm `getCompletions` payload into a typed list, dropping
-* malformed entries and stripping the backtick markers ZEN wraps type names in.
-*/
-function normalizeCompletions(raw) {
-	if (!Array.isArray(raw)) return [];
-	const messages = getExpressionMessages();
-	return raw.flatMap((entry) => {
-		if (!isRecord(entry) || typeof entry.label !== "string" || entry.label === "") return [];
-		return [{
-			type: entry.type === "method" || entry.type === "variable" ? entry.type : "function",
-			label: entry.label,
-			detail: typeof entry.detail === "string" ? entry.detail.replaceAll("`", "") : "",
-			info: messages.completionInfo(typeof entry.info === "string" ? entry.info : ""),
-			boost: typeof entry.boost === "number" ? entry.boost : null,
-			methodFor: typeof entry.methodFor === "string" ? entry.methodFor : null
-		}];
-	});
-}
-/**
-* Validate an expression, loading the engine on first use. Resolves to `null`
-* when the expression is valid, or a positioned diagnostic otherwise.
-*/
-async function getDiagnostics(expression, mode) {
-	await loadEngine();
-	return getDiagnosticsSync(expression, mode);
-}
-/**
-* Synchronous {@link getDiagnostics}. Throws `ExpressionNotReadyError` if the
-* engine has not loaded yet — use only behind a readiness gate.
-*/
-function getDiagnosticsSync(expression, mode) {
-	const engine = getEngineSync();
-	return normalizeDiagnostic(mode === "unary" ? engine.validateUnary(expression) : engine.validate(expression), expression);
-}
-/**
-* Return the ZEN built-in completion list, loading the engine on first use.
-*/
-async function getCompletionItems() {
-	await loadEngine();
-	return getCompletionItemsSync();
-}
-/**
-* Synchronous {@link getCompletionItems}. Throws `ExpressionNotReadyError` if the
-* engine has not loaded yet.
-*/
-function getCompletionItemsSync() {
-	return normalizeCompletions(getEngineSync().getCompletions());
-}
-/**
-* Type-check an expression against a `variables` context, loading the engine on
-* first use. See {@link ExpressionAnalysis}.
-*/
-async function analyzeTypes(variables, source, mode) {
-	await loadEngine();
-	return analyzeTypesSync(variables, source, mode);
-}
-/**
-* Synchronous {@link analyzeTypes}. Throws `ExpressionNotReadyError` if the
-* engine has not loaded yet.
-*/
-function analyzeTypesSync(variables, source, mode) {
-	return getEngineSync().analyze(variables, source, mode === "unary");
-}
-/**
-* Whether `actual` satisfies (is assignable to) `expected`, loading the engine on
-* first use. Used for expected-return-type validation.
-*/
-async function satisfiesType(actual, expected) {
-	await loadEngine();
-	return satisfiesTypeSync(actual, expected);
-}
-/**
-* Synchronous {@link satisfiesType}. Throws `ExpressionNotReadyError` if the
-* engine has not loaded yet.
-*/
-function satisfiesTypeSync(actual, expected) {
-	return getEngineSync().satisfies(actual, expected);
-}
-//#endregion
-//#region src/engine/template.ts
-const HOLE_PATTERN = /\{\{(?<expression>[^{}]*)\}\}/g;
-/**
-* Extract every `{{ expression }}` hole from a template document, in source
-* order. Literal text outside holes is ignored. Pure string scan — no engine
-* required — matching the `@gorules/lezer-zen-template` hole grammar, so it is
-* consistent with the editor's highlighting and completion gating.
-*/
-function parseTemplateHoles(source) {
-	const holes = [];
-	HOLE_PATTERN.lastIndex = 0;
-	for (let match = HOLE_PATTERN.exec(source); match !== null; match = HOLE_PATTERN.exec(source)) {
-		const inner = match.groups?.expression ?? "";
-		const from = match.index + 2;
-		holes.push({
-			from,
-			to: from + inner.length,
-			expression: inner
-		});
-	}
-	return holes;
-}
-/**
-* The template hole whose inner expression range contains `pos` (boundaries
-* included, so a caret sitting right after `{{` or right before `}}` counts as
-* inside), or `null` when `pos` is in literal text. Drives the editor's
-* hole-scoped completion and hover: intelligence fires inside a hole, nothing in
-* the surrounding literal text.
-*/
-function templateHoleAt(source, pos) {
-	return parseTemplateHoles(source).find((hole) => pos >= hole.from && pos <= hole.to) ?? null;
-}
-function hasExpression(hole) {
-	return hole.expression.trim().length > 0;
-}
-/**
-* Type-check every hole of a template against a `variables` context and merge the
-* results into one {@link ExpressionAnalysis} whose spans are offset onto the
-* template document. Each hole is a standard ZEN value expression; literal text
-* contributes nothing. `rootKind` is the context itself (shared by every hole),
-* so top-level completion works even in an empty hole.
-*
-* Best-effort: a hole that fails to analyze (e.g. mid-edit syntax) is skipped
-* rather than discarding the spans of its siblings. Throws
-* {@link ExpressionNotReadyError} if the engine has not loaded — use only behind
-* a readiness gate.
-*/
-function analyzeTemplateSync(variables, source) {
-	if (!isEngineReady()) throw new ExpressionNotReadyError();
-	const spans = [];
-	for (const hole of parseTemplateHoles(source)) {
-		if (!hasExpression(hole)) continue;
-		try {
-			for (const span of analyzeTypesSync(variables, hole.expression, "standard").spans) spans.push({
-				...span,
-				span: [span.span[0] + hole.from, span.span[1] + hole.from]
-			});
-		} catch {}
-	}
-	return {
-		rootKind: variables,
-		spans
-	};
-}
-/**
-* Async {@link analyzeTemplateSync}, loading the engine on first use.
-*/
-async function analyzeTemplate(variables, source) {
-	await loadEngine();
-	return analyzeTemplateSync(variables, source);
-}
-/**
-* Validate every hole of a template and return their syntax diagnostics, each
-* offset onto the template document (empty holes and literal text produce none).
-* The single-expression {@link getDiagnosticsSync} yields at most one diagnostic
-* per hole, so a template with several broken holes surfaces each one.
-*
-* Throws {@link ExpressionNotReadyError} if the engine has not loaded — use only
-* behind a readiness gate.
-*/
-function getTemplateDiagnosticsSync(source) {
-	if (!isEngineReady()) throw new ExpressionNotReadyError();
-	const diagnostics = [];
-	for (const hole of parseTemplateHoles(source)) {
-		if (!hasExpression(hole)) continue;
-		const diagnostic = getDiagnosticsSync(hole.expression, "standard");
-		if (diagnostic) diagnostics.push({
-			...diagnostic,
-			from: diagnostic.from + hole.from,
-			to: diagnostic.to + hole.from
-		});
-	}
-	return diagnostics;
-}
-/**
-* Async {@link getTemplateDiagnosticsSync}, loading the engine on first use.
-*/
-async function getTemplateDiagnostics(source) {
-	await loadEngine();
-	return getTemplateDiagnosticsSync(source);
-}
-//#endregion
-exports.CONDITION_OPERATORS = CONDITION_OPERATORS;
-exports.CONDITION_TREE_OPERATORS = CONDITION_TREE_OPERATORS;
-exports.ExpressionError = ExpressionError;
-exports.ExpressionNotReadyError = ExpressionNotReadyError;
-exports.analyzeTemplate = analyzeTemplate;
-exports.analyzeTemplateSync = analyzeTemplateSync;
-exports.analyzeTypes = analyzeTypes;
-exports.analyzeTypesSync = analyzeTypesSync;
-exports.compileBranch = compileBranch;
-exports.compileCondition = compileCondition;
-exports.compileConditionTree = compileConditionTree;
-exports.compileGroup = compileGroup;
-exports.conditionOperatorArity = conditionOperatorArity;
-exports.configureEngine = configureEngine;
-exports.configureExpressionMessages = configureExpressionMessages;
-exports.enMessages = enMessages;
-exports.evaluate = evaluate;
-exports.evaluateSync = evaluateSync;
-exports.evaluateUnary = evaluateUnary;
-exports.evaluateUnarySync = evaluateUnarySync;
-exports.getCompletionItems = getCompletionItems;
-exports.getCompletionItemsSync = getCompletionItemsSync;
-exports.getDiagnostics = getDiagnostics;
-exports.getDiagnosticsSync = getDiagnosticsSync;
-exports.getEngineError = getEngineError;
-exports.getEngineSync = getEngineSync;
-exports.getExpressionMessages = getExpressionMessages;
-exports.getTemplateDiagnostics = getTemplateDiagnostics;
-exports.getTemplateDiagnosticsSync = getTemplateDiagnosticsSync;
-exports.isEngineReady = isEngineReady;
-exports.liftConditionTree = liftConditionTree;
-exports.loadEngine = loadEngine;
-exports.parseTemplateHoles = parseTemplateHoles;
-exports.registerExpressionLocale = registerExpressionLocale;
-exports.resetEngine = resetEngine;
-exports.satisfiesType = satisfiesType;
-exports.satisfiesTypeSync = satisfiesTypeSync;
-exports.selectBranch = selectBranch;
-exports.selectBranchWith = selectBranchWith;
-exports.templateHoleAt = templateHoleAt;
-exports.toZenLiteral = toZenLiteral;
-exports.zhCNMessages = zhCNMessages;
-
-//# sourceMappingURL=index.cjs.map
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=class extends Error{expression;constructor(e,t,n){super(e,{cause:n}),this.name=`ExpressionError`,this.expression=t}},t=class extends e{constructor(e=`Expression engine is not initialized. Await loadEngine() or render under <ExpressionEngineProvider>.`){super(e),this.name=`ExpressionNotReadyError`}};function n(e){return e===void 0}function r(e){return typeof e==`string`}function i(e){return Array.isArray(e)}function a(e){return e==null}function o(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}let s=null,c=null,l=null,u,d=null;function f(t,n){try{return n()}catch(n){throw new e(`Failed to evaluate expression: ${t}`,t,n)}}function p(){let e=`Failed to load the ZEN expression engine`;return typeof window>`u`?`${e}. In a non-browser or non-DOM host (Node, SSR, Web Worker) the wasm cannot be auto-resolved; call configureEngine({ wasmInput }) with the wasm bytes or URL before loading.`:e}function m(t){if(s||c)throw new e(`configureEngine() must be called before the engine loads.`);u=t.wasmInput}function h(){return s||(l=null,s=(async()=>{let e=await import(`@gorules/zen-engine-wasm`);await e.default(n(u)?void 0:{module_or_path:u});let t=t=>e.VariableType.fromJson(t),r=e=>{if(d&&d.variables===e)return d;let n=d;d=null,n?.handle.free();let r=t(e);try{d={variables:e,handle:r,rootKind:r.toJson()}}catch(e){throw r.free(),e}return d},i=Object.freeze({evaluate:(t,n={})=>f(t,()=>e.evaluateExpression(t,n)),evaluateUnary:(t,n={})=>f(t,()=>e.evaluateUnaryExpression(t,n)),validate:t=>e.validateExpression(t),validateUnary:t=>e.validateUnaryExpression(t),getCompletions:()=>e.getCompletions(),analyze:(e,t,n)=>{let i=r(e),a=n?i.handle.typeCheckUnary(t):i.handle.typeCheck(t);return{rootKind:i.rootKind,spans:Array.isArray(a)?a:[]}},satisfies:(e,n)=>{let r=t(e);try{let e=t(n);try{return r.satisfies(e)}finally{e.free()}}finally{r.free()}},isReady:()=>e.isReady()});return c=i,i})().catch(t=>{throw s=null,l=new e(p(),void 0,t),l}),s)}function g(){return c?.isReady()??!1}function _(){return l}function v(){if(!c)throw new t;return c}function ee(){d?.handle.free(),d=null,s=null,c=null,l=null,u=void 0}const y=te();function te(){return typeof process>`u`?!1:process.env?process.env.NODE_ENV!==`production`:!1}const ne=/^[A-Z_$][\w$]*(?:\.[A-Z_$][\w$]*|\[\d+\])*$/i,re=new Set([`and`,`or`,`not`,`in`,`true`,`false`,`null`]);function b(e){return ne.test(e)&&(e.match(/[A-Z_$][\w$]*/gi)??[]).every(e=>!re.has(e))}function x(t){if(a(t))return`null`;if(typeof t==`number`){if(!Number.isFinite(t))throw new e(`Number ${String(t)} has no ZEN literal representation`);return String(t)}if(typeof t==`boolean`||typeof t==`bigint`)return String(t);if(r(t))return ie(t);if(i(t))return`[${t.map(e=>x(e)).join(`, `)}]`;throw new e(`Value of type "${typeof t}" has no ZEN literal representation`)}function ie(t){let n=t.includes(`'`),r=t.includes(`"`);if(n&&r)throw new e(`String contains both single and double quotes and has no ZEN literal representation`);return n?`"${t}"`:`'${t}'`}function S(e){return i(e)?x(e):`[${x(e)}]`}function C(e){return`(${e} == null or (type(${e}) == 'string' and len(trim(${e})) == 0) or (type(${e}) == 'array' and len(${e}) == 0))`}function ae(t,n,r){switch(n){case`eq`:return`${t} == ${x(r)}`;case`ne`:return`${t} != ${x(r)}`;case`gt`:return`${t} > ${x(r)}`;case`gte`:return`${t} >= ${x(r)}`;case`lt`:return`${t} < ${x(r)}`;case`lte`:return`${t} <= ${x(r)}`;case`contains`:return`contains(${t}, ${x(r)})`;case`not_contains`:return`not contains(${t}, ${x(r)})`;case`starts_with`:return`startsWith(${t}, ${x(r)})`;case`ends_with`:return`endsWith(${t}, ${x(r)})`;case`in`:return`${t} in ${S(r)}`;case`not_in`:return`not (${t} in ${S(r)})`;case`is_empty`:return C(t);case`is_not_empty`:return`not ${C(t)}`;default:throw new e(`Unsupported operator: ${String(n)}`)}}function w(e){if(e.kind===`expression`){let t=e.expression.trim();return t===``?null:`(${t})`}let t=e.subject.trim();if(!b(t))return null;try{return ae(t,e.operator,e.value)}catch{return null}}function T(e){let t=e.conditions.map(e=>w(e)).filter(e=>e!==null);return t.length===0?null:t.join(` and `)}function E(e){let t=(e.conditionGroups??[]).map(e=>T(e)).filter(e=>e!==null);return t.length===0?null:t.map(e=>`(${e})`).join(` or `)}function D(e,t,n){let r=e.toSorted((e,t)=>e.priority-t.priority);for(let e of r){if(e.isDefault)continue;let r=E(e);if(r===null){y&&console.warn(`[expression] branch "${e.id}" has no compilable condition and can never match`);continue}if(oe(n,r,t))return{branchId:e.id,matched:!0}}return{branchId:r.find(e=>e.isDefault)?.id??null,matched:!1}}function oe(e,t,n){try{return e.evaluate(t,n)===!0}catch(n){return y&&se(e,t,n),!1}}function se(e,t,n){let r;try{r=e.validate(t)}catch{return}a(r)||console.warn(`[expression] compiled branch expression failed to parse: ${t}`,r,n)}async function ce(e,t){return D(e,t,await h())}const O=[`eq`,`ne`,`gt`,`gte`,`lt`,`lte`,`contains`,`not_contains`,`starts_with`,`ends_with`,`in`,`not_in`,`is_empty`,`is_not_empty`],le={eq:`scalar`,ne:`scalar`,gt:`scalar`,gte:`scalar`,lt:`scalar`,lte:`scalar`,contains:`scalar`,not_contains:`scalar`,starts_with:`scalar`,ends_with:`scalar`,in:`array`,not_in:`array`,is_empty:`none`,is_not_empty:`none`};function k(e){return le[e]}function ue(e){let t=A(e);return t===null?``:j(t,!0)}function A(e){if(e.kind===`rule`)return M(e)===null?null:e;let t=e.items.map(e=>A(e)).filter(e=>e!==null);return t.length===0?null:t.length===1?t[0]:{kind:`group`,op:e.op,items:t}}function j(e,t){if(e.kind===`rule`)return M(e);let n=e.items.map(e=>j(e,!1)).join(e.op===`and`?` and `:` or `);return t?n:`(${n})`}function M(e){return de(e)?w({kind:`field`,subject:e.left,operator:e.operator,value:e.right}):null}function de(e){switch(k(e.operator)){case`scalar`:return N(e.right);case`array`:return fe(e.right);case`none`:return e.right===void 0}}function N(e){return typeof e==`string`||typeof e==`number`||typeof e==`boolean`}function fe(e){return i(e)&&e.every(e=>N(e))}const pe=new Set([`==`,`!=`,`<=`,`>=`]),me=new Set([`(`,`)`,`[`,`]`,`,`,`.`,`<`,`>`,`-`]),he=/[a-z_$]/i,ge=/[\w$]/,_e=/\d/,ve=/^\d+(?:\.\d+)?(?:e[+-]?\d+)?/i,ye=/^\d+$/,be={"==":`eq`,"!=":`ne`,">":`gt`,">=":`gte`,"<":`lt`,"<=":`lte`},xe={contains:`contains`,startsWith:`starts_with`,endsWith:`ends_with`};function Se(e){let t=L(e);if(t===null||t.length===0)return null;let n=0;function r(e=0){return t[n+e]}function i(e){let t=r();return t!==void 0&&t.kind===`punct`&&t.value===e?(n+=1,!0):!1}function a(e){let t=r();return t!==void 0&&t.kind===`ident`&&t.value===e?(n+=1,!0):!1}function o(e,n){for(let[r,i]of n.entries()){let n=t[e+r],a=i;if(n===void 0||n.kind!==a.kind||n.value!==a.value)return!1}return!0}function s(){let e=P(t,n);return e===null?null:(n=e.next,e.path)}function c(){let e=r();if(e===void 0)return null;if(e.kind===`string`)return n+=1,e.value;if(e.kind===`number`)return n+=1,Number(e.value);if(e.kind===`ident`)return e.value===`true`?(n+=1,!0):e.value===`false`?(n+=1,!1):null;if(e.kind===`punct`&&e.value===`-`){let e=r(1);return e===void 0||e.kind!==`number`?null:(n+=2,-Number(e.value))}return null}function l(){if(!i(`[`))return null;if(I(r(),`]`))return n+=1,[];let e=c();if(e===null)return null;let t=[e];for(;I(r(),`,`);){n+=1;let e=c();if(e===null)return null;t.push(e)}return i(`]`)?t:null}function u(e){if(!i(`(`))return null;let t=s();if(t===null||!i(`,`))return null;let n=c();return n===null||!i(`)`)?null:{kind:`rule`,left:t,operator:e,right:n}}function d(){let e=s();if(e===null||!a(`in`))return null;let t=l();return t===null||!i(`)`)?null:{kind:`rule`,left:e,operator:`not_in`,right:t}}function f(){let e=r();if(e===void 0)return null;let i,a;if(e.kind===`ident`&&e.value===`not`&&I(r(1),`(`))i=`is_not_empty`,a=n+2;else if(e.kind===`punct`&&e.value===`(`)i=`is_empty`,a=n+1;else return null;let s=P(t,a);if(s===null)return null;let c=w({kind:`field`,subject:s.path,operator:i,value:void 0});if(c===null)return null;let l=L(c);return l===null||!o(n,l)?null:(n+=l.length,{kind:`rule`,left:s.path,operator:i})}function p(){let e=r();if(e===void 0||e.kind!==`ident`)return null;if(e.value===`not`){let e=r(1);return e===void 0?null:e.kind===`ident`&&e.value===`contains`&&I(r(2),`(`)?(n+=2,u(`not_contains`)):e.kind===`punct`&&e.value===`(`?(n+=2,d()):null}if(I(r(1),`(`)){let t=xe[e.value];return t===void 0?null:(n+=1,u(t))}let t=s();if(t===null)return null;let i=r();if(i===void 0)return null;if(i.kind===`ident`&&i.value===`in`){n+=1;let e=l();return e===null?null:{kind:`rule`,left:t,operator:`in`,right:e}}if(i.kind===`punct`){let e=be[i.value];if(e===void 0)return null;n+=1;let r=c();return r===null?null:{kind:`rule`,left:t,operator:e,right:r}}return null}function m(e){let t=f();if(t!==null)return t;if(I(r(),`(`)){if(e>=64)return null;n+=1;let t=g(e+1);return t===null||!i(`)`)?null:F(t)}return p()}function h(){let e=r();return e!==void 0&&e.kind===`ident`&&(e.value===`and`||e.value===`or`)?e.value:null}function g(e){let t=m(e);if(t===null)return null;let r=[t],i=null,a=h();for(;a!==null;){if(i===null)i=a;else if(i!==a)return null;n+=1;let t=m(e);if(t===null)return null;r.push(t),a=h()}return r.length===1?r[0]:{kind:`group`,op:i??`and`,items:r}}let _=g(0);return _===null||n!==t.length?null:F(_)}function P(e,t){let n=e[t];if(n===void 0||n.kind!==`ident`)return null;let r=n.value,i=t+1,a=e[i];for(;a!==void 0&&a.kind===`punct`&&(a.value===`.`||a.value===`[`);){if(a.value===`.`){let t=e[i+1];if(t===void 0||t.kind!==`ident`)return null;r+=`.${t.value}`,i+=2}else{let t=e[i+1];if(t===void 0||t.kind!==`number`||!ye.test(t.value))return null;let n=e[i+2];if(n===void 0||n.kind!==`punct`||n.value!==`]`)return null;r+=`[${t.value}]`,i+=3}a=e[i]}return b(r)?{path:r,next:i}:null}function F(e){return e.kind===`group`?e:{kind:`group`,op:`and`,items:[e]}}function I(e,t){return e!==void 0&&e.kind===`punct`&&e.value===t}function L(e){let t=[],n=0;for(;n<e.length;){let r=e[n];if(r===` `||r===`	`||r===`
+`||r===`\r`){n+=1;continue}if(r===`'`||r===`"`){let i=e.indexOf(r,n+1);if(i===-1)return null;t.push({kind:`string`,value:e.slice(n+1,i)}),n=i+1;continue}let i=e.slice(n,n+2);if(pe.has(i)){t.push({kind:`punct`,value:i}),n+=2;continue}if(me.has(r)){t.push({kind:`punct`,value:r}),n+=1;continue}if(_e.test(r)){let r=ve.exec(e.slice(n));if(r===null)return null;t.push({kind:`number`,value:r[0]}),n+=r[0].length;continue}if(he.test(r)){let r=n+1;for(;r<e.length&&ge.test(e[r]);)r+=1;t.push({kind:`ident`,value:e.slice(n,r)}),n=r;continue}return null}return t}const Ce=O;async function we(e,t){return await h(),R(e,t)}async function Te(e,t){return await h(),z(e,t)}function R(e,t){return v().evaluate(e,t)}function z(e,t){return v().evaluateUnary(e,t)}const Ee={"Returns the length of variable":`返回变量的长度`,"Checks if variable contains a needle":`检查变量是否包含指定元素`,"Flattens an array":`将数组扁平化`,"Merges multiple objects into one.":`将多个对象合并为一个。`,"Deeply merges multiple objects into one.":`将多个对象深度合并为一个。`,"Converts all characters in a string to uppercase":`将字符串中所有字符转换为大写`,"Converts all characters in a string to lowercase":`将字符串中所有字符转换为小写`,"Returns the string with leading and trailing whitespace removed":`返回去除首尾空白后的字符串`,"Returns true if the string starts with the specified prefix":`若字符串以指定前缀开头则返回 true`,"Returns true if the string ends with the specified suffix":`若字符串以指定后缀结尾则返回 true`,"Returns true if the string matches the specified pattern":`若字符串匹配指定模式则返回 true`,"Extracts matching substrings according to a pattern":`按模式提取匹配的子串`,"Performs a fuzzy search of the needle in the haystack, and returns the match score(s).":`在目标中对关键字进行模糊搜索，并返回匹配得分。`,"Splits a string into an array of substrings using the specified delimiter.":`使用指定分隔符将字符串拆分为子串数组。`,"Returns the absolute value of a number":`返回数字的绝对值`,"Returns the sum of all elements in the input array.":`返回输入数组中所有元素之和。`,"Calculates the average of all elements in the input array.":`计算输入数组中所有元素的平均值。`,"Returns the smallest of the elements in the input array.":`返回输入数组中的最小元素。`,"Returns the largest of the elements in the input array.":`返回输入数组中的最大元素。`,"Generates a random number between 0 (inclusive) and max (inclusive).":`生成 0 到 max（均包含）之间的随机数。`,"Calculates the median value of all elements in the input array.":`计算输入数组中所有元素的中位数。`,"Finds the mode(s) of the input array, which are the most frequent element(s).":`求输入数组的众数，即出现最频繁的元素。`,"Rounds a number down to the nearest integer.":`向下取整到最接近的整数。`,"Rounds a number up to the nearest integer.":`向上取整到最接近的整数。`,"Rounds a number to a specified number of decimal places.":`将数字四舍五入到指定的小数位数。`,"Truncates a number to a specified number of decimal places.":`将数字截断到指定的小数位数。`,"Checks if the given value is of a numeric type.":`检查给定值是否为数值类型。`,"Converts the given value to a string.":`将给定值转换为字符串。`,"Converts the given value to a number.":`将给定值转换为数字。`,"Converts the given value to a boolean.":`将给定值转换为布尔值。`,"Returns a string representing the data type of the value.":`返回表示该值数据类型的字符串。`,"Returns an array of a given object's own enumerable property names.":`返回由给定对象自身可枚举属性名组成的数组。`,"Returns an array of a given object's own enumerable property values.":`返回由给定对象自身可枚举属性值组成的数组。`,"Returns a new date time instance.":`返回一个新的日期时间实例。`,"Converts a numeric timestamp to a unix timestamp.":`将数值时间戳转换为 Unix 时间戳。`,"Extracts the time from a numeric timestamp and returns it as a seconds from beginning of day.":`从数值时间戳中提取时间，以当天起始的秒数返回。`,"e.g. 1h30min":`例如 1h30min`,"Extracts the year from a given timestamp.":`从给定时间戳中提取年份。`,"Gets the day of the week from a given timestamp, where Sunday might be 0.":`获取给定时间戳的星期几（周日可能为 0）。`,"Extracts the day of the month from a given timestamp.":`从给定时间戳中提取当月的日期。`,"Gets the day of the year from a given timestamp.":`获取给定时间戳在一年中的第几天。`,"Calculates the week of the year from a given timestamp.":`计算给定时间戳在一年中的第几周。`,"Extracts the month from a given timestamp, typically with January as 1.":`从给定时间戳中提取月份（通常 1 月为 1）。`,"Converts the month from a given timestamp into its string representation (e.g., 'Jan').":`将给定时间戳的月份转换为字符串表示（例如 'Jan'）。`,"Converts a timestamp to a human-readable date string.":`将时间戳转换为人类可读的日期字符串。`,"Converts the day of the week from a given timestamp into its string representation (e.g., 'Mon').":`将给定时间戳的星期几转换为字符串表示（例如 'Mon'）。`,"Returns the timestamp representing the start of a specified unit (e.g., day, month, year) based on a given timestamp.":`返回给定时间戳在指定单位（如日、月、年）起始处的时间戳。`,"Returns the timestamp representing the end of a specified unit (e.g., day, month, year) based on a given timestamp.":`返回给定时间戳在指定单位（如日、月、年）结束处的时间戳。`,"Checks if all elements in the array satisfy the condition defined in the callback.":`检查数组中所有元素是否都满足回调中定义的条件。`,"Checks if no elements in the array satisfy the condition defined in the callback.":`检查数组中是否没有任何元素满足回调中定义的条件。`,"Checks if at least one element in the array satisfies the condition defined in the callback.":`检查数组中是否至少有一个元素满足回调中定义的条件。`,"Checks if exactly one element in the array satisfies the condition defined in the callback.":`检查数组中是否恰好有一个元素满足回调中定义的条件。`,"Creates a new array with all elements that satisfy the condition defined in the callback.":`创建一个仅包含满足回调中定义条件的元素的新数组。`,"Creates a new array populated with the results of calling the provided function on every element in the calling array.":`创建一个新数组，其元素为对原数组每个元素调用所提供函数的结果。`,"First maps each element using a mapping function, then flattens the result into a new array.":`先用映射函数处理每个元素，再将结果扁平化为新数组。`,"Counts the number of elements in the array that satisfy the condition defined in the callback.":`统计数组中满足回调中定义条件的元素个数。`,"Adds time to a date":`为日期增加时间`,"Subtracts time from a date":`从日期中减去时间`,"Sets a specific unit of time on a date":`设置日期的某个时间单位`,"Formats a date into a string representation":`将日期格式化为字符串`,"Returns the start of a specified time unit for a date":`返回日期在指定时间单位上的起始`,"Returns the end of a specified time unit for a date":`返回日期在指定时间单位上的结束`,"Calculates the difference between two dates":`计算两个日期之间的差值`,"Converts a date to a different timezone":`将日期转换到不同的时区`,"Checks if two dates are the same":`检查两个日期是否相同`,"Checks if a date is before another date":`检查日期是否早于另一个日期`,"Checks if a date is after another date":`检查日期是否晚于另一个日期`,"Checks if a date is the same as or before another date":`检查日期是否等于或早于另一个日期`,"Checks if a date is the same as or after another date":`检查日期是否等于或晚于另一个日期`,"Gets the seconds of a date":`获取日期的秒`,"Gets the minutes of a date":`获取日期的分钟`,"Gets the hours of a date":`获取日期的小时`,"Gets the day of the month for a date":`获取日期在当月的第几天`,"Gets the day of the year for a date":`获取日期在当年的第几天`,"Gets the week of the year for a date":`获取日期在当年的第几周`,"Gets the day of the week for a date":`获取日期的星期几`,"Gets the month for a date":`获取日期的月份`,"Gets the quarter for a date":`获取日期所在的季度`,"Gets the year for a date":`获取日期的年份`,"Gets the Unix timestamp for a date":`获取日期的 Unix 时间戳`,"Gets the timezone offset name for a date":`获取日期的时区偏移名称`,"Checks if a date is valid":`检查日期是否有效`,"Checks if a date is yesterday":`检查日期是否为昨天`,"Checks if a date is today":`检查日期是否为今天`,"Checks if a date is tomorrow":`检查日期是否为明天`,"Checks if the year of a date is a leap year":`检查日期所在年份是否为闰年`},De={lexerError:`Lexer error`,parserError:`Parser error`,compilerError:`Compiler error`,vmError:`VM error`},Oe={lexerError:`词法错误`,parserError:`语法错误`,compilerError:`编译错误`,vmError:`运行时错误`};function B(e,t,n){return(n===void 0?void 0:e[n])??t}const V={sourceLabel:e=>B(De,`Error`,e),completionInfo:e=>e,typeCheckSource:`Type check`,expectedBoolean:e=>`Expected a boolean test expression, received \`${e}\`.`,expectedType:(e,t)=>`Expected \`${e}\`, received \`${t}\`.`},H={sourceLabel:e=>B(Oe,`错误`,e),completionInfo:e=>e===``?``:Ee[e]??e,typeCheckSource:`类型检查`,expectedBoolean:e=>`期望布尔测试表达式，实际类型为 \`${e}\`。`,expectedType:(e,t)=>`期望 \`${e}\`，实际为 \`${t}\`。`},U=new Map([[`en-US`,V],[`zh-CN`,H]]);let W=V;function ke(e,t){U.set(e,t)}function Ae({locale:e,messages:t}){let n=e===void 0?W:U.get(e)??W;W=t===void 0?n:{...n,...t}}function G(){return W}function K(e){let t=e?.trim();return t?Number(t):NaN}function je(e){let t=e.split(` at `),n=t.length<=1?void 0:t.at(-1);if(n===void 0)return null;let[r,i]=n.replace(`(`,``).replace(`)`,``).split(`, `),a=K(r);if(Number.isNaN(a))return null;let o=K(i);return[a,Number.isNaN(o)?a:o]}function Me(e,t){if(e==null)return null;let n=o(e)&&typeof e.type==`string`?e.type:void 0,r=o(e)&&typeof e.source==`string`?e.source:String(e),[i,a]=je(r)??[0,t.length];return{from:i,to:a,message:r,source:G().sourceLabel(n)}}function Ne(e){if(!Array.isArray(e))return[];let t=G();return e.flatMap(e=>!o(e)||typeof e.label!=`string`||e.label===``?[]:[{type:e.type===`method`||e.type===`variable`?e.type:`function`,label:e.label,detail:typeof e.detail==`string`?e.detail.replaceAll("`",``):``,info:t.completionInfo(typeof e.info==`string`?e.info:``),boost:typeof e.boost==`number`?e.boost:null,methodFor:typeof e.methodFor==`string`?e.methodFor:null}])}async function Pe(e,t){return await h(),q(e,t)}function q(e,t){let n=v();return Me(t===`unary`?n.validateUnary(e):n.validate(e),e)}async function Fe(){return await h(),J()}function J(){return Ne(v().getCompletions())}async function Ie(e,t,n){return await h(),Y(e,t,n)}function Y(e,t,n){return v().analyze(e,t,n===`unary`)}async function Le(e,t){return await h(),X(e,t)}function X(e,t){return v().satisfies(e,t)}const Z=/\{\{(?<expression>[^{}]*)\}\}/g;function Q(e){let t=[];Z.lastIndex=0;for(let n=Z.exec(e);n!==null;n=Z.exec(e)){let e=n.groups?.expression??``,r=n.index+2;t.push({from:r,to:r+e.length,expression:e})}return t}function Re(e,t){return Q(e).find(e=>t>=e.from&&t<=e.to)??null}function ze(e){return e.expression.trim().length>0}function Be(e,n){if(!g())throw new t;let r=[];for(let t of Q(n))if(ze(t))try{for(let n of Y(e,t.expression,`standard`).spans)r.push({...n,span:[n.span[0]+t.from,n.span[1]+t.from]})}catch{}return{rootKind:e,spans:r}}async function Ve(e,t){return await h(),Be(e,t)}function $(e){if(!g())throw new t;let n=[];for(let t of Q(e)){if(!ze(t))continue;let e=q(t.expression,`standard`);e&&n.push({...e,from:e.from+t.from,to:e.to+t.from})}return n}async function He(e){return await h(),$(e)}exports.CONDITION_OPERATORS=O,exports.CONDITION_TREE_OPERATORS=Ce,exports.ExpressionError=e,exports.ExpressionNotReadyError=t,exports.analyzeTemplate=Ve,exports.analyzeTemplateSync=Be,exports.analyzeTypes=Ie,exports.analyzeTypesSync=Y,exports.compileBranch=E,exports.compileCondition=w,exports.compileConditionTree=ue,exports.compileGroup=T,exports.conditionOperatorArity=k,exports.configureEngine=m,exports.configureExpressionMessages=Ae,exports.enMessages=V,exports.evaluate=we,exports.evaluateSync=R,exports.evaluateUnary=Te,exports.evaluateUnarySync=z,exports.getCompletionItems=Fe,exports.getCompletionItemsSync=J,exports.getDiagnostics=Pe,exports.getDiagnosticsSync=q,exports.getEngineError=_,exports.getEngineSync=v,exports.getExpressionMessages=G,exports.getTemplateDiagnostics=He,exports.getTemplateDiagnosticsSync=$,exports.isEngineReady=g,exports.liftConditionTree=Se,exports.loadEngine=h,exports.parseTemplateHoles=Q,exports.registerExpressionLocale=ke,exports.resetEngine=ee,exports.satisfiesType=Le,exports.satisfiesTypeSync=X,exports.selectBranch=ce,exports.selectBranchWith=D,exports.templateHoleAt=Re,exports.toZenLiteral=x,exports.zhCNMessages=H;