@coldsmirk/abacus-core 0.4.0 → 0.4.1

package/dist/index.cjs

@@ -1,2 +1,1040 @@
-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;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/engine/errors.ts
+var ExpressionError = class extends Error {
+	expression;
+	constructor(message, expression, cause) {
+		super(message, { cause });
+		this.name = "ExpressionError";
+		this.expression = expression;
+	}
+};
+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
+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;
+}
+function configureEngine(options) {
+	if (enginePromise || engineSync) throw new ExpressionError("configureEngine() must be called before the engine loads.");
+	configuredInput = options.wasmInput;
+}
+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;
+}
+function isEngineReady() {
+	return engineSync?.isReady() ?? false;
+}
+function getEngineError() {
+	return engineError;
+}
+function getEngineSync() {
+	if (!engineSync) throw new ExpressionNotReadyError();
+	return engineSync;
+}
+function resetEngine() {
+	typeContextCache?.handle.free();
+	typeContextCache = null;
+	enginePromise = null;
+	engineSync = null;
+	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 SUBJECT_PATTERN = /^[A-Z_$][\w$]*(?:\.[A-Z_$][\w$]*|\[\d+\])*$/i;
+const ZEN_RESERVED_WORDS = new Set([
+	"and",
+	"or",
+	"not",
+	"in",
+	"true",
+	"false",
+	"null"
+]);
+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
+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`);
+}
+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)}]`;
+}
+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)}`);
+	}
+}
+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;
+	}
+}
+function compileGroup(group) {
+	const parts = group.conditions.map((condition) => compileCondition(condition)).filter((part) => part !== null);
+	return parts.length === 0 ? null : parts.join(" and ");
+}
+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 ");
+}
+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);
+}
+async function selectBranch(branches, context) {
+	return selectBranchWith(branches, context, await loadEngine());
+}
+//#endregion
+//#region src/condition/types.ts
+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"
+};
+function conditionOperatorArity(operator) {
+	return CONDITION_OPERATOR_ARITIES[operator];
+}
+//#endregion
+//#region src/condition/compile-tree.ts
+function compileConditionTree(tree) {
+	const normalized = normalizeNode(tree);
+	return normalized === null ? "" : emitNode(normalized, true);
+}
+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
+	};
+}
+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})`;
+}
+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;
+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);
+}
+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;
+}
+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
+const CONDITION_TREE_OPERATORS = CONDITION_OPERATORS;
+//#endregion
+//#region src/engine/evaluate.ts
+async function evaluate(expression, context) {
+	await loadEngine();
+	return evaluateSync(expression, context);
+}
+async function evaluateUnary(expression, context) {
+	await loadEngine();
+	return evaluateUnarySync(expression, context);
+}
+function evaluateSync(expression, context) {
+	return getEngineSync().evaluate(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": "检查变量是否包含指定元素",
+	"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;
+}
+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}\`.`
+};
+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;
+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 : {
+		...base,
+		...messages
+	};
+}
+function getExpressionMessages() {
+	return activeMessages;
+}
+//#endregion
+//#region src/engine/intellisense.ts
+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];
+}
+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)
+	};
+}
+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
+		}];
+	});
+}
+async function getDiagnostics(expression, mode) {
+	await loadEngine();
+	return getDiagnosticsSync(expression, mode);
+}
+function getDiagnosticsSync(expression, mode) {
+	const engine = getEngineSync();
+	return normalizeDiagnostic(mode === "unary" ? engine.validateUnary(expression) : engine.validate(expression), expression);
+}
+async function getCompletionItems() {
+	await loadEngine();
+	return getCompletionItemsSync();
+}
+function getCompletionItemsSync() {
+	return normalizeCompletions(getEngineSync().getCompletions());
+}
+async function analyzeTypes(variables, source, mode) {
+	await loadEngine();
+	return analyzeTypesSync(variables, source, mode);
+}
+function analyzeTypesSync(variables, source, mode) {
+	return getEngineSync().analyze(variables, source, mode === "unary");
+}
+async function satisfiesType(actual, expected) {
+	await loadEngine();
+	return satisfiesTypeSync(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 = [];
+	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;
+}
+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;
+}
+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 function analyzeTemplate(variables, source) {
+	await loadEngine();
+	return analyzeTemplateSync(variables, source);
+}
+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 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;