solve-engine 2.24.0 → 2.25.0

package/dist/chunk-PWWQZFAE.js

@@ -1,2 +0,0 @@
-import {a}from'./chunk-XFJABR3B.js';import {c}from'./chunk-IJMNVBIS.js';import {c as c$1}from'./chunk-BDF4VCQX.js';var N=32,L=2;function I(a){return a.shape!==void 0?a.shape:a.startTokenTypes!==void 0?[{types:a.startTokenTypes}]:[]}var x=class{constructor(e){this.rules=e;let r=e.length,t=Math.max(1,Math.ceil(r/N));this.words=t,this.scratch=new Uint32Array(t);let s=e.map(I),n=0;for(let l of s)for(let c$1 of l)for(let f of c$1.types??[])n=Math.max(n,c(f));this.typeRows=n+1;let i=0;for(let l of s)i=Math.max(i,l.length);i=Math.min(i,L),this.allRules=new Uint32Array(t);for(let l=0;l<r;l++)this.allRules[l/N|0]|=1<<l%N;let u=[];for(let l=0;l<i;l++)u.push(this.buildPlane(s,l,t));this.planes=u;}buildPlane(e,r,t){let s={byType:new Uint32Array(this.typeRows*t),typeAny:new Uint32Array(t),atEnd:new Uint32Array(t),typeHasValues:new Uint8Array(this.typeRows),byValue:new Map,valueAny:new Uint32Array(t)};for(let n=0;n<e.length;n++){let i=e[n][r],u=n/N|0,l=1<<n%N,c$1=i?.types;if(c$1===void 0)s.typeAny[u]|=l,s.atEnd[u]|=l;else for(let p of c$1)s.byType[c(p)*t+u]|=l;let f=i?.values;if(f===void 0)s.valueAny[u]|=l;else {for(let p of f){let h=p.toLowerCase(),o=s.byValue.get(h);o===void 0&&(o=new Uint32Array(t),s.byValue.set(h,o)),o[u]|=l;}if(c$1===void 0)s.typeHasValues.fill(1);else for(let p of c$1){let h=c(p);h<this.typeRows&&(s.typeHasValues[h]=1);}}}return s}get size(){return this.rules.length}get depth(){return this.planes.length}candidates(e,r){let t=this.words,s=this.scratch,n=this.planes,i=e.length;if(n.length===0)return s.set(this.allRules),s;for(let u=0;u<n.length;u++){let l=n[u],c=r+u;if(c>=i){if(u===0)s.set(l.atEnd);else for(let o=0;o<t;o++)s[o]&=l.atEnd[o];continue}let f=e[c],p=f.typeId,h=p>=0&&p<this.typeRows?p*t:-1;if(u===0)if(h>=0)for(let o=0;o<t;o++)s[o]=l.byType[h+o]|l.typeAny[o];else s.set(l.typeAny);else if(h>=0)for(let o=0;o<t;o++)s[o]&=l.byType[h+o]|l.typeAny[o];else for(let o=0;o<t;o++)s[o]&=l.typeAny[o];if(h>=0&&l.typeHasValues[p]===1){let o=f.value,R=O(o)?o.toLowerCase():o,g=l.byValue.get(R);for(let T=0;T<t;T++)s[T]&=(g===void 0?0:g[T])|l.valueAny[T];}if(C(s))return s}return s}};function C(a){for(let e=0;e<a.length;e++)if(a[e]!==0)return  false;return  true}function O(a){for(let e=0;e<a.length;e++){let r=a.charCodeAt(e);if(r>=65&&r<=90)return  true}return  false}var B={maxPasses:100,maxTokens:1e4,onFusion:()=>{},ignoreRuleIndex:false};function S(a$1,e,r){let t=r[0],s=r[r.length-1],n=new a(a$1,c(a$1),e,e,t.offset,t.lineBreaks??0,t.line,t.col);return n.sourceEnd=s.sourceEnd??s.offset+s.text.length,n}function z(a,e){let r=e[e.length-1];r&&(a.sourceEnd=r.sourceEnd??r.offset+r.text.length);}var _=["NUMBER","HEX","BIGINT","FLOAT","LSHIFT","RSHIFT","BIT_AND","BIT_OR","BIT_XOR","LPAREN","RPAREN","LBRACKET","RBRACKET","COMMA","COLON","EQUALS","THEREFORE","PIPE","AMPERSAND","AT","SEMICOLON","QUESTION","EXCLAMATION","EOF","WS","NEWLINE"],M=(()=>{let a=_.map(t=>c(t)),e=Math.max(...a)+1,r=new Uint8Array(e);for(let t of a)r[t]=1;return r})(),P=new Set;function D(a){a.shape!==void 0&&a.shape.length>0||a.startTokenTypes===void 0&&a.unshapedReason===void 0&&(P.has(a.name)||(P.add(a.name),console.warn(`[TokenNormalizer] Rule "${a.name}" declares no \`shape\`, so it is tried at every token of every line and slows down documents that never use it. Declare the tokens it can start at, e.g. shape: [{ types: ["IDENT"], values: ["myword"] }, { types: ["LPAREN"] }]. If it genuinely cannot be described that way, set \`unshapedReason\` to say why and this warning will stop.`)));}var U=class{constructor(e={}){this.rules=[];this.sortedRulesCache=null;this.rulesByTokenType=new Map;this.ruleIndexCache=null;this.candidateBuffer=[];this.normalizeCalls=0;this.phraseTrie=new w;this.ruleShapesCache=null;this.options={...B,...e};}register(e){D(e),this.rules.push(e),this.sortedRulesCache=null,this.rulesByTokenType.clear(),this.ruleIndexCache=null,this.ruleShapesCache=null;}unregister(e){this.rules=this.rules.filter(r=>r.name!==e),this.sortedRulesCache=null,this.rulesByTokenType.clear(),this.ruleIndexCache=null,this.ruleShapesCache=null;}clear(){this.rules=[],this.sortedRulesCache=null,this.rulesByTokenType.clear(),this.ruleIndexCache=null,this.ruleShapesCache=null,this.phraseTrie=new w;}getSortedRules(){return this.sortedRulesCache===null&&(this.sortedRulesCache=[...this.rules].sort((e,r)=>r.priority-e.priority)),this.sortedRulesCache}getRuleIndex(){return this.ruleIndexCache===null&&(this.ruleIndexCache=new x(this.getSortedRules())),this.ruleIndexCache}rulesAt(e,r){let t=this.candidateBuffer;if(t.length=0,e===null){let n=this.rulesForTokenType(r);for(let i=0;i<n.length;i++)t.push(n[i]);return t}let s=this.getRuleIndex().rules;for(let n=0;n<e.length;n++){let i=e[n]>>>0,u=n*32;for(;i!==0;)(i&1)!==0&&t.push(s[u]),i>>>=1,u++;}return t}rulesForTokenType(e){let r=this.rulesByTokenType.get(e);return r===void 0&&(r=this.getSortedRules().filter(t=>t.startTokenTypes===void 0||t.startTokenTypes.includes(e)),this.rulesByTokenType.set(e,r)),r}get ruleCount(){return this.rules.length}getRuleShapes(){if(this.ruleShapesCache!==null)return this.ruleShapesCache;let e=this.getRuleIndex();return this.ruleShapesCache=this.getSortedRules().map(r=>{let t=I(r);return {name:r.name,priority:r.priority,shape:t,unshapedReason:r.unshapedReason,indexedSlots:Math.min(t.length,e.depth)}}),this.ruleShapesCache}getCandidateCounts(e){let r=this.getRuleIndex(),t=[];for(let s=0;s<e.length;s++){let n=r.candidates(e,s),i=0;for(let u=0;u<n.length;u++){let l=n[u]>>>0;for(;l!==0;)i+=l&1,l>>>=1;}t.push(i);}return t}addPhrase(e,r){this.phraseTrie.addPhrase(e,r);}getPhrases(){return this.phraseTrie.getAllPhrases()}canStartPhrase(e){return this.phraseTrie.canStart(e)}normalize(e,r){if(e.length===0)return e;let t=r??this.options.onFusion,s=this.options.maxPasses,n=this.options.maxTokens,i=this.normalizeCalls>0;i||(this.normalizeCalls=1);let u=i&&!this.options.ignoreRuleIndex,l=u?this.getRuleIndex():null,c=e,f=true,p=0;for(;f&&p<s;){f=false,p++;let h=null,o=0;for(;o<c.length;){let g=false,T=c[o].typeId;if(T>=M.length||M[T]===0){let m=this.phraseTrie.matchAt(c,o);if(m){let d=c.slice(o,o+m.consumed);h===null&&(h=c.slice(0,o));for(let A of m.replacement)h.push(A);m.consumed>1&&m.replacement.length===1&&(z(m.replacement[0],d),t({rule:m.ruleName??"phrase-trie",sourceTokens:d,fusedToken:m.replacement[0]})),o+=m.consumed,f=true;continue}}let v=u?l.candidates(c,o):null;if(v!==null&&C(v)){h!==null&&h.push(c[o]),o++;continue}for(let m of this.rulesAt(v,c[o].type)){let d=m.match(c,o);if(d){let A=c.slice(o,o+d.consumed);h===null&&(h=c.slice(0,o));for(let b of d.replacement)h.push(b);if(d.consumed>1&&d.replacement.length===1)z(d.replacement[0],A),t({rule:m.name,sourceTokens:A,fusedToken:d.replacement[0]});else if(d.consumed>1&&d.replacement.length<d.consumed)for(let b of d.replacement)t({rule:m.name,sourceTokens:A,fusedToken:b});o+=d.consumed,f=true,g=true;break}}g||(h!==null&&h.push(c[o]),o++);}if(h===null)break;let R=h;if(R.length>n)throw c$1.validation("NORMALIZED_TOKEN_LIMIT_EXCEEDED",`Normalized token count (${R.length}) exceeds safety limit (${n})`,{tokenCount:R.length,maxTokens:n});c=R;}return c}};var w=class{constructor(){this.startWords=new Set;this.root=new Map;}addPhrase(e,r){let t=e.toLowerCase().trim().split(/\s+/);if(t.length===0||t[0]==="")return;this.startWords.add(t[0]);let s=t[0],n;if(this.root.has(s)?n=this.root.get(s):(n={children:new Map,terminal:null},this.root.set(s,n)),t.length===1){n.terminal={tokenType:r,phrase:e,consumed:1};return}for(let i=1;i<t.length;i++){let u=t[i];n.children.has(u)||n.children.set(u,{children:new Map,terminal:null}),n=n.children.get(u);}n.terminal={tokenType:r,phrase:e,consumed:t.length};}matchAt(e,r){if(r>=e.length)return null;let t=e[r].type;if(t==="TAG"||t.startsWith("TAG_"))return null;let s=e[r].value.toLowerCase();if(!this.startWords.has(s))return null;let n=this.root.get(s);if(!n)return null;let i=null,u=1;if(n.terminal){let l=e.slice(r,r+1);i={consumed:1,replacement:[S(n.terminal.tokenType,n.terminal.phrase,l)],ruleName:n.terminal.phrase};}for(let l=r+1;l<e.length&&n?.children;l++){let c=e[l].type;if(c==="TAG"||c.startsWith("TAG_"))break;let f=e[l].value.toLowerCase();if(n=n.children.get(f),!n)break;if(u++,n.terminal){let p=e.slice(r,r+u);i={consumed:u,replacement:[S(n.terminal.tokenType,n.terminal.phrase,p)],ruleName:n.terminal.phrase};}}return i}get size(){return this.root.size}getAllPhrases(){let e={},r=(t,s)=>{t.terminal&&(e[s.join(" ")]=t.terminal.tokenType);for(let[n,i]of t.children)r(i,[...s,n]);};for(let[t,s]of this.root)r(s,[t]);return e}canStart(e){return this.startWords.has(e.toLowerCase())}};var F=new Set(["per","a","an","each","every"]),W=new Set(["to","power","increase","decrease","times","multiply","divide","by"]);function H(a$1=50,e){let r=e??(t=>W.has(t.toLowerCase()));return {name:"implicit:multiply",priority:a$1,shape:[{types:["NUMBER","RPAREN"]},{types:["IDENT","LPAREN","PI","E"]}],match(t,s){if(s+1>=t.length)return null;let n=t[s],i=t[s+1];if(!((n.type==="NUMBER"||n.type==="RPAREN")&&(i.type==="IDENT"||i.type==="LPAREN"||i.type==="PI"||i.type==="E")))return null;let l=i.value.toLowerCase();if(r(l)||F.has(l)&&t[s+2]?.type==="UNIT")return null;let c$1=new a("STAR",c("STAR"),"*","*",i.offset,0,i.line,i.col);return {consumed:1,replacement:[n,c$1]}}}}function ne(a,e){let r=[];for(let t=0;t<e;t++){let s=a[t];if(s.type==="LBRACKET")r.push(true);else if(s.type==="LPAREN"){let n=a[t-1],i=!!n&&(n.type==="MAP"||n.type==="REDUCE"||n.type==="SUM_FN"||n.type==="PROD_FN"||n.type==="IDENT"&&(n.value.toLowerCase()==="map"||n.value.toLowerCase()==="reduce"||n.value.toLowerCase()==="sum"||n.value.toLowerCase()==="prod"));r.push(i);}else (s.type==="RBRACKET"||s.type==="RPAREN")&&r.pop();}return r.length>0&&r[r.length-1]}function re(){return [H()]}export{w as a,S as b,U as c,H as d,ne as e,re as f};//# sourceMappingURL=chunk-PWWQZFAE.js.map
-//# sourceMappingURL=chunk-PWWQZFAE.js.map

package/dist/chunk-PWWQZFAE.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/normalizer/RuleIndex.ts","../src/normalizer/TokenNormalizer.ts","../src/normalizer/PhraseTrie.ts","../src/normalizer/BuiltinNormalizerRules.ts"],"names":["WORD_BITS","MAX_PLANES","effectiveShape","rule","RuleIndex","sortedRules","n","w","shapes","maxTypeId","shape","slot","t","tokenTypeId","depth","i","planes","k","plane","word","bit","types","values","raw","value","mask","id","tokens","pos","scratch","len","at","token","typeId","base","lowered","hasUpper","named","isEmptyMask","c","DEFAULT_OPTIONS","createFusedToken","type","text","sourceTokens","first","last","LexerToken","recordSourceSpan","fused","NON_WORD_NAMES","NON_WORD_TABLE","ids","table","warnedUnshapedRules","warnIfUnshaped","TokenNormalizer","options","PhraseTrie","ruleName","a","b","buffer","list","rules","bits","index","counts","phrase","tokenType","onFusion","fusionHandler","maxPasses","maxTokens","warmedUp","useIndex","ruleIndex","current","changed","passCount","result","matched","tid","trieMatch","rt","candidates","match","passResult","ErrorFactory","words","firstWord","node","startType","best","contType","collect","path","child","RATE_DENOMINATOR_WORDS","PHRASE_START_WORDS","implicitMultiplyRule","priority","canStart","phraseGuard","next","nextValue","starToken","isInsideRangeContext","safeStack","prev","opensMapReduceCall","createBuiltinNormalizerRules"],"mappings":"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","file":"chunk-PWWQZFAE.js","sourcesContent":["//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * RuleIndex, a conjunctive bitmask prefilter over the normalizer's rules.\n *\n * ## Problem\n * The normalizer tries every rule eligible at a position, at every position.\n * The `startTokenTypes` hint buckets rules by the type of the token they start\n * at, which helps only where that type is selective. It is not: the thirteen\n * call-fusion rules all declare `[\"IDENT\"]`, the commonest token in prose, and\n * the rules firing on a bare `NUMBER` all share that one type too. Measured\n * against the built-in package set, the `IDENT` bucket held 53 of 57 rules and\n * the `NUMBER` bucket 45, because a rule declaring no hint has to be tried\n * everywhere.\n *\n * ## Solution\n * Rules discriminate on different things, so no single axis separates them.\n * A rule declares its leading {@link RuleSlot} shape, and this builds one\n * lookup plane per slot: a flat `Uint32Array` of rule bitmasks indexed by token\n * type id, so a lookup is an array load rather than a hash. A position ANDs the\n * planes together and iterates only the surviving bits, which for most\n * positions is none at all.\n *\n * Rejecting a position therefore costs a few loads and ANDs instead of\n * forty-odd closure calls, and one AND tests 32 rules at once. That the common\n * answer is \"no rule can fire here\" is the point.\n *\n * ## Why planes rather than a fingerprint\n * A superimposed code (OR the hashed types of a window into one word, AND\n * against a per-rule required fingerprint) looks like the cheaper way to reach\n * depth, but it is a per-RULE test with no way to invert it into a lookup, so\n * it stays O(rules) per position. These planes are the same conjunctive test\n * done exactly, at O(rules / 32) and with no false positives. Token types\n * number a couple of hundred, small enough to table, so there is nothing to\n * gain by approximating.\n *\n * ## Ordering\n * Bit `i` is the rule at index `i` of the priority-sorted rule list, so\n * iterating bits from low to high visits rules in exactly the order the\n * unindexed scan did. Ties keep registration order, because the sort is stable.\n * This is what makes the index a pure filter rather than a behaviour change,\n * and `NormalizerIndexFidelity.spec` pins it.\n *\n * ## Safety\n * The contract runs one way: a slot admitting MORE than the rule can match\n * costs a `match()` that returns null, which is what happens today; a slot\n * admitting LESS makes the rule unreachable, a silent bug. So indexing fewer\n * planes than were declared is always safe, which is why {@link MAX_PLANES}\n * can be tuned on evidence rather than being a correctness decision. Only\n * over-narrow declarations are dangerous, and those are what the fidelity spec\n * hunts for.\n *\n * @module RuleIndex\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { NormalizerRule, RuleSlot } from \"./NormalizerRule\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\n\n//#endregion\n//#region ─── Constants ────────────────────────────────────────────────────────\n\n/** Bits per word in the masks below. */\nconst WORD_BITS = 32;\n\n/**\n * How many leading slots are indexed, however many a rule declares.\n *\n * Each plane costs a load and an AND at every position, unconditionally, while\n * only positions surviving the earlier planes can benefit from a later one.\n * After two planes most positions have no candidates left, so a third would tax\n * every token to save a couple of `match()` calls on the few that reach it.\n *\n * Two is a measured default, not a limit of the design: raising it is a\n * one-line change, and lowering it can never break a rule (see this module's\n * Safety note). Rules may declare deeper shapes freely; the extra slots simply\n * go unindexed and are checked by `match()` as before.\n */\nconst MAX_PLANES = 2;\n\n//#endregion\n//#region ─── Shape normalisation ──────────────────────────────────────────────\n\n/**\n * A rule's effective shape, folding the older {@link NormalizerRule.startTokenTypes}\n * into the general form. `shape` wins when both are present.\n */\nexport function effectiveShape(rule: NormalizerRule): readonly RuleSlot[] {\n\tif (rule.shape !== undefined) return rule.shape;\n\tif (rule.startTokenTypes !== undefined) return [{ types: rule.startTokenTypes }];\n\treturn [];\n}\n\n//#endregion\n//#region ─── RuleIndex ────────────────────────────────────────────────────────\n\n/** One indexed slot position: the type plane, plus the value axis for it. */\ninterface Plane {\n\t/** `[typeId * words + w]`, rules whose slot admits `typeId`. */\n\treadonly byType: Uint32Array;\n\t/** Rules constraining no type here, admitted at a type with no row. */\n\treadonly typeAny: Uint32Array;\n\t/**\n\t * Rules constraining no type here, and so the only ones still admissible\n\t * when the stream ends before this slot.\n\t */\n\treadonly atEnd: Uint32Array;\n\t/** `[typeId]`, 1 when a value-constraining rule admits this type here. */\n\treadonly typeHasValues: Uint8Array;\n\t/** Lower-cased word to the rules naming it at this slot. */\n\treadonly byValue: Map<string, Uint32Array>;\n\t/** Rules constraining no value here. */\n\treadonly valueAny: Uint32Array;\n}\n\n/**\n * A conjunctive bitmask prefilter over a priority-sorted rule list.\n *\n * Built once per rule-set mutation (registration time), then read only. See\n * this module's overview for the shape and the ordering guarantee.\n */\nexport class RuleIndex {\n\t/** The priority-sorted rules. Bit `i` of every mask refers to `rules[i]`. */\n\treadonly rules: readonly NormalizerRule[];\n\n\t/** Words per mask, `ceil(rules.length / 32)`. */\n\treadonly words: number;\n\n\t/** Number of token type ids with their own row, exclusive upper bound. */\n\tprivate readonly typeRows: number;\n\n\t/** One per indexed slot, at most {@link MAX_PLANES}. */\n\tprivate readonly planes: readonly Plane[];\n\n\t/** Reused across positions so the hot path allocates nothing. */\n\tprivate readonly scratch: Uint32Array;\n\n\t/**\n\t * Every rule's bit set.\n\t *\n\t * Returned when there are no planes at all, which happens when no rule\n\t * declares a shape. Without it {@link candidates} would hand back an\n\t * unwritten scratch buffer, i.e. \"no rule can fire anywhere\", and every\n\t * rule would silently stop running. The all-admitted answer is the correct\n\t * one: a rule that constrains nothing can match anywhere.\n\t */\n\tprivate readonly allRules: Uint32Array;\n\n\tconstructor(sortedRules: readonly NormalizerRule[]) {\n\t\tthis.rules = sortedRules;\n\t\tconst n = sortedRules.length;\n\t\tconst w = Math.max(1, Math.ceil(n / WORD_BITS));\n\t\tthis.words = w;\n\t\tthis.scratch = new Uint32Array(w);\n\n\t\tconst shapes = sortedRules.map(effectiveShape);\n\n\t\t// Size the type-indexed rows to cover every type any rule names. A token\n\t\t// whose id lands past this (a plugin type minted after the index was\n\t\t// built, say) falls back to the \"constrains nothing\" masks, which is\n\t\t// correct rather than merely safe: a rule naming types cannot match a\n\t\t// type it did not name, and a rule naming none can match anywhere.\n\t\tlet maxTypeId = 0;\n\t\tfor (const shape of shapes) {\n\t\t\tfor (const slot of shape) {\n\t\t\t\tfor (const t of slot.types ?? []) maxTypeId = Math.max(maxTypeId, tokenTypeId(t));\n\t\t\t}\n\t\t}\n\t\tthis.typeRows = maxTypeId + 1;\n\n\t\tlet depth = 0;\n\t\tfor (const shape of shapes) depth = Math.max(depth, shape.length);\n\t\tdepth = Math.min(depth, MAX_PLANES);\n\n\t\tthis.allRules = new Uint32Array(w);\n\t\tfor (let i = 0; i < n; i++) {\n\t\t\tthis.allRules[(i / WORD_BITS) | 0] |= 1 << (i % WORD_BITS);\n\t\t}\n\n\t\tconst planes: Plane[] = [];\n\t\tfor (let k = 0; k < depth; k++) {\n\t\t\tplanes.push(this.buildPlane(shapes, k, w));\n\t\t}\n\t\tthis.planes = planes;\n\t}\n\n\t/** Build the lookup plane for slot `k`. */\n\tprivate buildPlane(shapes: readonly (readonly RuleSlot[])[], k: number, w: number): Plane {\n\t\tconst plane: Plane = {\n\t\t\tbyType: new Uint32Array(this.typeRows * w),\n\t\t\ttypeAny: new Uint32Array(w),\n\t\t\tatEnd: new Uint32Array(w),\n\t\t\ttypeHasValues: new Uint8Array(this.typeRows),\n\t\t\tbyValue: new Map<string, Uint32Array>(),\n\t\t\tvalueAny: new Uint32Array(w),\n\t\t};\n\n\t\tfor (let i = 0; i < shapes.length; i++) {\n\t\t\tconst slot: RuleSlot | undefined = shapes[i][k];\n\t\t\tconst word = (i / WORD_BITS) | 0;\n\t\t\tconst bit = 1 << (i % WORD_BITS);\n\n\t\t\t// ── Types ──\n\t\t\tconst types = slot?.types;\n\t\t\tif (types === undefined) {\n\t\t\t\t// Constrains nothing here, so admitted at every type, at a type\n\t\t\t\t// with no row, and past the end of the stream.\n\t\t\t\t//\n\t\t\t\t// Deliberately NOT written into every row of `byType`. Doing that\n\t\t\t\t// made construction O(rules x tokenTypes), tens of thousands of\n\t\t\t\t// writes for a table most of which is the same bit, and the\n\t\t\t\t// engine builds an index per instance: a cold parse of a short\n\t\t\t\t// document paid for it without ever amortising it. The lookup\n\t\t\t\t// ORs `typeAny` in instead, which is one extra operation per word\n\t\t\t\t// on a path that already does several.\n\t\t\t\tplane.typeAny[word] |= bit;\n\t\t\t\tplane.atEnd[word] |= bit;\n\t\t\t} else {\n\t\t\t\tfor (const t of types) plane.byType[tokenTypeId(t) * w + word] |= bit;\n\t\t\t}\n\n\t\t\t// ── Values ──\n\t\t\tconst values = slot?.values;\n\t\t\tif (values === undefined) {\n\t\t\t\tplane.valueAny[word] |= bit;\n\t\t\t} else {\n\t\t\t\tfor (const raw of values) {\n\t\t\t\t\tconst value = raw.toLowerCase();\n\t\t\t\t\tlet mask = plane.byValue.get(value);\n\t\t\t\t\tif (mask === undefined) {\n\t\t\t\t\t\tmask = new Uint32Array(w);\n\t\t\t\t\t\tplane.byValue.set(value, mask);\n\t\t\t\t\t}\n\t\t\t\t\tmask[word] |= bit;\n\t\t\t\t}\n\t\t\t\t// The value axis is only worth a map lookup at a type some\n\t\t\t\t// value-constraining rule admits here.\n\t\t\t\tif (types === undefined) {\n\t\t\t\t\tplane.typeHasValues.fill(1);\n\t\t\t\t} else {\n\t\t\t\t\tfor (const t of types) {\n\t\t\t\t\t\tconst id = tokenTypeId(t);\n\t\t\t\t\t\tif (id < this.typeRows) plane.typeHasValues[id] = 1;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn plane;\n\t}\n\n\t/** Number of indexed rules. */\n\tget size(): number { return this.rules.length; }\n\n\t/** How many slot positions are indexed. */\n\tget depth(): number { return this.planes.length; }\n\n\t/**\n\t * The candidate mask for a position, written into a reused scratch buffer\n\t * and returned. Bits are rule indices, ascending bit order being descending\n\t * priority. The buffer is overwritten by the next call, so read it before\n\t * calling again.\n\t *\n\t * @param tokens - The stream being walked\n\t * @param pos    - The position to test\n\t */\n\tcandidates(tokens: readonly { typeId: number; value: string }[], pos: number): Uint32Array {\n\t\tconst w = this.words;\n\t\tconst scratch = this.scratch;\n\t\tconst planes = this.planes;\n\t\tconst len = tokens.length;\n\n\t\tif (planes.length === 0) {\n\t\t\tscratch.set(this.allRules);\n\t\t\treturn scratch;\n\t\t}\n\n\t\tfor (let k = 0; k < planes.length; k++) {\n\t\t\tconst plane = planes[k];\n\t\t\tconst at = pos + k;\n\n\t\t\tif (at >= len) {\n\t\t\t\t// The stream ends before this slot, so only rules that constrain\n\t\t\t\t// nothing here remain admissible.\n\t\t\t\tif (k === 0) { scratch.set(plane.atEnd); }\n\t\t\t\telse { for (let i = 0; i < w; i++) scratch[i] &= plane.atEnd[i]; }\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst token = tokens[at];\n\t\t\tconst typeId = token.typeId;\n\t\t\tconst base = typeId >= 0 && typeId < this.typeRows ? typeId * w : -1;\n\n\t\t\t// `typeAny` holds the rules that constrain no type at this slot, so\n\t\t\t// they are admitted whatever the token is; see the construction note.\n\t\t\tif (k === 0) {\n\t\t\t\tif (base >= 0) { for (let i = 0; i < w; i++) scratch[i] = plane.byType[base + i] | plane.typeAny[i]; }\n\t\t\t\telse { scratch.set(plane.typeAny); }\n\t\t\t} else {\n\t\t\t\tif (base >= 0) { for (let i = 0; i < w; i++) scratch[i] &= plane.byType[base + i] | plane.typeAny[i]; }\n\t\t\t\telse { for (let i = 0; i < w; i++) scratch[i] &= plane.typeAny[i]; }\n\t\t\t}\n\n\t\t\t// The value axis costs a map lookup and possibly a lower-casing, so\n\t\t\t// it is consulted only at a type some value-constraining rule names.\n\t\t\tif (base >= 0 && plane.typeHasValues[typeId] === 1) {\n\t\t\t\tconst value = token.value;\n\t\t\t\tconst lowered = hasUpper(value) ? value.toLowerCase() : value;\n\t\t\t\tconst named = plane.byValue.get(lowered);\n\t\t\t\tfor (let i = 0; i < w; i++) {\n\t\t\t\t\tscratch[i] &= (named === undefined ? 0 : named[i]) | plane.valueAny[i];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (isEmptyMask(scratch)) return scratch;\n\t\t}\n\n\t\treturn scratch;\n\t}\n}\n\n/** Whether every bit of a mask returned by {@link RuleIndex.candidates} is clear. */\nexport function isEmptyMask(mask: Uint32Array): boolean {\n\tfor (let i = 0; i < mask.length; i++) if (mask[i] !== 0) return false;\n\treturn true;\n}\n\n/**\n * Whether a string contains an ASCII upper-case letter.\n *\n * `toLowerCase()` allocates even when it changes nothing, and identifiers in\n * running prose are overwhelmingly already lower case, so this scan pays for\n * itself by skipping the allocation in the common case.\n */\nfunction hasUpper(value: string): boolean {\n\tfor (let i = 0; i < value.length; i++) {\n\t\tconst c = value.charCodeAt(i);\n\t\tif (c >= 65 && c <= 90) return true;\n\t}\n\treturn false;\n}\n\n//#endregion\n","//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * TokenNormalizer, post-lexer token normalization pass.\n *\n * ## Purpose\n * Applies domain-specific {@link NormalizerRule | NormalizerRules} to the raw\n * token stream produced by the {@link ExpressionLexer}. This keeps the lexer\n * slim and focused on single-token production, while multi-token pattern\n * matching (phrases, implicit operators, domain merges) lives here.\n *\n * ## What rules can do\n * - **Phrase fusion**: Merge consecutive words into compound tokens\n *   (e.g., `IDENT + ... + IDENT` → `CARET`)\n * - **Implicit operator insertion**: Insert missing operators between tokens\n *   (e.g., `NUMBER IDENT` → `NUMBER STAR IDENT`)\n * - **Domain-specific transformations**: Coalesce item names, currency pairs,\n *   percentage syntax, etc.\n *\n * ## Architecture\n * Providers register NormalizerRules alongside Parselets and OpCode handlers\n * via {@link IEnginePackage.normalizerRules}. The normalizer applies them\n * greedily left-to-right in multiple passes with safety limits.\n *\n * @module TokenNormalizer\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { Token } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { LexerToken } from \"@solve-js/lexer/ExpressionLexer\";\nimport type { NormalizerRule, RuleSlot, TokenFusion } from \"./NormalizerRule\";\nimport { PhraseTrie } from \"./PhraseTrie\";\nimport { RuleIndex, isEmptyMask, effectiveShape } from \"./RuleIndex\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n//#endregion\n//#region ─── NormalizerOptions, Configuration ────────────────────────────────\n\n/**\n * Configuration options for the normalization pass.\n *\n * These control safety limits and diagnostic callbacks. The defaults\n * are chosen to be generous enough for any realistic expression while\n * preventing runaway token expansion from recursive rules.\n */\nexport interface NormalizerOptions {\n  /**\n   * Maximum number of full passes over the token stream before bailing out.\n   * Prevents infinite loops from recursive rule chains.\n   * @default 100\n   */\n  maxPasses?: number;\n\n  /**\n   * Maximum number of tokens allowed after normalization.\n   * If exceeded, an Error is thrown rather than passing a bloated stream\n   * to the parser.\n   * @default 10000\n   */\n  maxTokens?: number;\n\n  /**\n   * Callback invoked for each fusion event during normalization.\n   * Used by diagnostic mode to populate {@link NormalizerOutput.fusions}.\n   * When `undefined`, fusions are still tracked internally but no callbacks fire.\n   */\n  onFusion?: (fusion: TokenFusion) => void;\n\n  /**\n   * Try every registered rule at every position, ignoring the shape index.\n   *\n   * Diagnostic only, and much slower. It exists so the indexed walk can be\n   * compared against the unindexed one over a corpus: the index is a pure\n   * filter, so the two must agree token for token, and a rule whose declared\n   * {@link NormalizerRule.shape} is too narrow shows up as a difference rather\n   * than as a feature that quietly stopped working.\n   * `NormalizerIndexFidelity.spec` is the consumer.\n   *\n   * @default false\n   */\n  ignoreRuleIndex?: boolean;\n}\n\n//#endregion\n//#region ─── Default Options ──────────────────────────────────────────────────\n\n/** Sensible defaults that catch infinite loops without limiting real expressions. */\nconst DEFAULT_OPTIONS: Required<NormalizerOptions> = {\n  maxPasses: 100,\n  maxTokens: 10000,\n  onFusion: () => {},\n  ignoreRuleIndex: false,\n};\n\n//#endregion\n//#region ─── createFusedToken, Token Factory ──────────────────────────────────\n\n/**\n * Creates a new normalized token from fused source tokens.\n *\n * The fused token inherits position information (offset, line, column)\n * from the first source token, which preserves source-map accuracy\n * for error messages and diagnostic highlighting.\n *\n * It also records where the source text ENDS, on `sourceEnd`. The start alone\n * is not enough to describe the span a fusion covers, because `text` is the\n * replacement rather than the original: `10 frames` fuses into a FRAME_COUNT\n * whose text is `10`, and a timecode fuses into a token whose text is a\n * comma-separated tuple that appears nowhere in the line. Anything painting the\n * line needs both ends, and only this function is in a position to know them.\n *\n * @param type         - The new token type (e.g., \"CARET\", \"TIMES_BY\")\n * @param text         - The combined text representation (e.g., \"to the power of\")\n * @param sourceTokens - The original tokens being fused (at least 2)\n * @returns A new {@link LexerToken} with the fused type and combined text\n */\nexport function createFusedToken(\n  type: string,\n  text: string,\n  sourceTokens: Token[]\n): Token {\n  const first = sourceTokens[0];\n  const last = sourceTokens[sourceTokens.length - 1];\n  const token = new LexerToken(\n    type,\n    tokenTypeId(type),\n    text,\n    text,\n    first.offset,\n    first.lineBreaks ?? 0,\n    first.line,\n    first.col,\n  );\n  // `text`, not `value`: this is where the SOURCE ended, and the two differ\n  // for a string literal, whose value is the payload without its quotes.\n  token.sourceEnd = last.sourceEnd ?? last.offset + last.text.length;\n  return token;\n}\n\n/**\n * Record, on a token that replaced several, where its source text ended.\n *\n * Called centrally rather than left to each rule. A rule that builds its\n * replacement by hand rather than through {@link createFusedToken} is doing\n * nothing wrong, and several do: the date-literal rule needs a token whose\n * value is an epoch and whose text is the source, which that factory cannot\n * express. Stamping here means every fusion carries its span, including ones\n * written after this was.\n *\n * Reads `sourceEnd` off the last source token when it has one, so a fusion of\n * a fusion still describes the original text rather than the intermediate.\n *\n * @param fused - The single token the rule produced.\n * @param sourceTokens - The tokens it consumed.\n */\nfunction recordSourceSpan(fused: Token, sourceTokens: Token[]): void {\n  const last = sourceTokens[sourceTokens.length - 1];\n  if (!last) return;\n  fused.sourceEnd = last.sourceEnd ?? last.offset + last.text.length;\n}\n\n//#endregion\n//#region ─── NON_WORD_TOKEN_TYPES, Type-guard skip set ────────────────────────\n\n/**\n * Token types that can NEVER start a multi-word phrase.\n *\n * Used by {@link normalize} to skip the PhraseTrie walk entirely at\n * positions where the token type makes phrase matching impossible.\n * This avoids even the O(1) {@link PhraseTrie.canStart} check.\n *\n * Types NOT in this set (IDENT, KEYWORD, FUNC, UNIT, and any custom\n * types registered by packages) still pass through to the trie for\n * a full match attempt.\n */\n// ── Non-word type ID lookup table (flat Uint8Array, true O(1) array index) ──\n//\n// Index = token typeId, value = 1 if non-word (skip trie), 0 otherwise.\n// Array indexing avoids ALL hashing: no Set.has(), no Map.get(), no string ops.\n//\n// Custom types from packages get IDs beyond the table length, so the bounds\n// check `tid < TABLE.length` safely passes them through to the trie.\n//\n// Arithmetic operators (PLUS, MINUS, STAR, SLASH, CARET, MOD, PERCENT) are\n// intentionally excluded: in keyword locales the lexer maps \"times\"→STAR,\n// \"divide\"→SLASH etc., and those tokens CAN start phrases like \"times by\".\n/**\n * Token type names that can NEVER start a multi-word phrase.\n *\n * Exported for testing only, consumers should use the type-guard behavior\n * of {@link TokenNormalizer.normalize} rather than this list directly.\n */\nexport const NON_WORD_NAMES = [\n\t\"NUMBER\", \"HEX\", \"BIGINT\", \"FLOAT\",\n\t\"LSHIFT\", \"RSHIFT\", \"BIT_AND\", \"BIT_OR\", \"BIT_XOR\",\n\t\"LPAREN\", \"RPAREN\", \"LBRACKET\", \"RBRACKET\",\n\t\"COMMA\", \"COLON\", \"EQUALS\", \"THEREFORE\", \"PIPE\", \"AMPERSAND\", \"AT\",\n\t\"SEMICOLON\", \"QUESTION\", \"EXCLAMATION\",\n\t\"EOF\", \"WS\", \"NEWLINE\",\n] as const;\n\n/**\n * Flat Uint8Array lookup table: index = token typeId, value = 1 if non-word.\n *\n * Exported for testing only, consumers should not depend on the internal\n * table layout, as the set of non-word types may change.\n */\nexport const NON_WORD_TABLE: Uint8Array = (() => {\n\t// Resolve all non-word type names to their numeric IDs\n\tconst ids = NON_WORD_NAMES.map(n => tokenTypeId(n));\n\t// Size the table to cover the largest ID + 1\n\tconst len = Math.max(...ids) + 1;\n\tconst table = new Uint8Array(len);\n\t// Mark non-word type positions\n\tfor (const id of ids) table[id] = 1;\n\treturn table;\n})();\n\n//#endregion\n//#region ─── TokenNormalizer Class ─────────────────────────────────────────────\n\n/**\n * Rule names already warned about, so a rule registered into many engines\n * says it once rather than once per engine.\n */\nconst warnedUnshapedRules = new Set<string>();\n\n/**\n * Warn when a rule declares neither a shape nor a reason for not having one.\n *\n * An unshaped rule is tried at every position of every line, so its cost is\n * paid by every document rather than only by the feature it implements. The\n * warning names the rule and points at the two ways out, and it fires once per\n * rule name per process: a warning a package author sees on every engine they\n * construct is one they learn to filter out, which would make it worse than\n * useless.\n *\n * Deliberately not an error. A rule without a shape is correct, only slower,\n * and refusing to register it would break every package written before the\n * field existed.\n */\nfunction warnIfUnshaped(rule: NormalizerRule): void {\n  if (rule.shape !== undefined && rule.shape.length > 0) return;\n  if (rule.startTokenTypes !== undefined) return;\n  if (rule.unshapedReason !== undefined) return;\n  if (warnedUnshapedRules.has(rule.name)) return;\n  warnedUnshapedRules.add(rule.name);\n  console.warn(\n    `[TokenNormalizer] Rule \"${rule.name}\" declares no \\`shape\\`, so it is tried at every ` +\n    `token of every line and slows down documents that never use it. Declare the tokens it ` +\n    `can start at, e.g. shape: [{ types: [\"IDENT\"], values: [\"myword\"] }, { types: [\"LPAREN\"] }]. ` +\n    `If it genuinely cannot be described that way, set \\`unshapedReason\\` to say why and this ` +\n    `warning will stop.`,\n  );\n}\n\n/**\n * Token normalizer: applies {@link NormalizerRule | NormalizerRules} to a token stream.\n *\n * ## Lifecycle\n * 1. **Registration**: Rules are added via {@link register} and sorted by priority\n * 2. **Normalization**: {@link normalize} applies rules greedily left-to-right\n * 3. **Cleanup**: {@link clear} or {@link unregister} removes rules\n *\n * ## Normalization algorithm\n * The normalizer uses a greedy left-to-right multi-pass algorithm:\n * - At each token position, rules are tried in priority order (highest first)\n * - When a rule matches, matched tokens are consumed and replaced\n * - Processing continues from the replacement position\n * - Multiple passes handle cascading matches (one rule's output triggers another)\n * - Safety limits ({@link NormalizerOptions.maxPasses}) prevent infinite loops\n *\n * @example\n * ```ts\n * const normalizer = new TokenNormalizer();\n * normalizer.register(phraseRule);       // \"to the power of\" → CARET\n * normalizer.register(implicitMultRule); // \"2 x\" → \"2 * x\"\n * const normalized = normalizer.normalize(rawTokens);\n * ```\n */\nexport class TokenNormalizer {\n  /** Registered rules, unsorted, the source of truth. */\n  private rules: NormalizerRule[] = [];\n\n  /**\n   * Priority-sorted copy of {@link rules}, rebuilt lazily on the next\n   * {@link normalize} call after a mutation. Rules are registered once at\n   * engine/package-registration time and essentially never change during a\n   * session, but normalize() runs on every keystroke-driven evaluation, an\n   * earlier version re-sorted a fresh copy of `rules` on every single call,\n   * which meant every keystroke paid for an allocation + sort of a list that\n   * had usually not changed since the last one. `null` means \"stale, rebuild\n   * on next use\"; {@link register}/{@link unregister}/{@link clear} all\n   * invalidate it.\n   */\n  private sortedRulesCache: NormalizerRule[] | null = null;\n\n  /**\n   * Per-token-type view of the priority-sorted rules: for a token type, the\n   * rules that could match a token of that type (those with no\n   * {@link NormalizerRule.startTokenTypes} hint, plus those that list the type),\n   * in the same priority order {@link getSortedRules} produces. Built lazily on\n   * the first token of each type and cached, so a document of many number and\n   * operator tokens never re-tries the many rules that only fire on an\n   * identifier. Invalidated alongside {@link sortedRulesCache}.\n   */\n  private rulesByTokenType = new Map<string, NormalizerRule[]>();\n\n  /**\n   * Shape index over the priority-sorted rules, rebuilt alongside\n   * {@link sortedRulesCache}. `null` means \"stale, rebuild on next use\".\n   *\n   * This is what turns the per-position scan from \"try every rule that could\n   * fire on this token type\" into \"AND a few lookup planes and try what\n   * survives\", which is usually nothing. See {@link RuleIndex}.\n   */\n  private ruleIndexCache: RuleIndex | null = null;\n\n  /** Reused by {@link rulesAt} so a position's candidate list costs no allocation. */\n  private candidateBuffer: NormalizerRule[] = [];\n\n  /**\n   * How many times {@link normalize} has run, capped once the index is in use.\n   *\n   * The index costs a few tens of microseconds to build and pays that back\n   * within a line or two, but an engine that normalises exactly once, which is\n   * what evaluating a single expression on a fresh engine does, would never\n   * reach the payback. Skipping the build on the first call keeps that case at\n   * the cost it had before the index existed, and a document reaches line two\n   * immediately.\n   */\n  private normalizeCalls = 0;\n\n  /**\n   * Phrase trie for single-pass multi-word phrase fusion.\n   * Tried at each token position BEFORE other rules, the trie walk\n   * is O(depth) vs O(R × W) for separate rule matching.\n   */\n  private phraseTrie = new PhraseTrie();\n\n  /** Merged options with defaults applied. */\n  private options: Required<NormalizerOptions>;\n\n  // ── Constructor ──────────────────────────────────────────────────────────\n\n  /**\n   * @param options - Configuration overrides for safety limits and diagnostic callbacks\n   */\n  constructor(options: NormalizerOptions = {}) {\n    this.options = { ...DEFAULT_OPTIONS, ...options };\n  }\n\n  // ── Rule Management ──────────────────────────────────────────────────────\n\n  /**\n   * Register a normalization rule.\n   *\n   * Rules are sorted by priority (descending) on each {@link normalize} call.\n   * Multiple rules can share the same priority, they are tried in registration\n   * order when priorities are equal.\n   *\n   * @param rule - The rule to register\n   */\n  register(rule: NormalizerRule): void {\n    warnIfUnshaped(rule);\n    this.rules.push(rule);\n    this.sortedRulesCache = null;\n    this.rulesByTokenType.clear();\n    this.ruleIndexCache = null;\n    this.ruleShapesCache = null;\n  }\n\n  /**\n   * Unregister a normalization rule by its {@link NormalizerRule.name | name}.\n   *\n   * If multiple rules share the same name, all are removed. This is safe to\n   * call with a name that doesn't match any rule, it simply has no effect.\n   *\n   * @param ruleName - The name of the rule to remove\n   */\n  unregister(ruleName: string): void {\n    this.rules = this.rules.filter(r => r.name !== ruleName);\n    this.sortedRulesCache = null;\n    this.rulesByTokenType.clear();\n    this.ruleIndexCache = null;\n    this.ruleShapesCache = null;\n  }\n\n  /**\n   * Remove all registered rules, resetting the normalizer to its initial state.\n   * Also clears the phrase trie.\n   */\n  clear(): void {\n    this.rules = [];\n    this.sortedRulesCache = null;\n    this.rulesByTokenType.clear();\n    this.ruleIndexCache = null;\n    this.ruleShapesCache = null;\n    this.phraseTrie = new PhraseTrie();\n  }\n\n  /**\n   * Priority-sorted view of {@link rules} (descending priority; registration\n   * order preserved for ties, since {@link Array.prototype.sort} is stable).\n   * Cached until the next mutation. See {@link sortedRulesCache}.\n   */\n  private getSortedRules(): NormalizerRule[] {\n    if (this.sortedRulesCache === null) {\n      this.sortedRulesCache = [...this.rules].sort((a, b) => b.priority - a.priority);\n    }\n    return this.sortedRulesCache;\n  }\n\n  /**\n   * The priority-sorted rules to try at a token of `type`: every rule with no\n   * {@link NormalizerRule.startTokenTypes} hint, plus those that list this type.\n   * A rule that declares a different trigger would have returned null here\n   * anyway, so omitting it is behaviour-preserving. Built once per distinct type\n   * and cached, which is what turns the per-position rule scan from \"try all R\n   * rules\" into \"try only the ones that could fire on this token\".\n   */\n  private getRuleIndex(): RuleIndex {\n    if (this.ruleIndexCache === null) {\n      this.ruleIndexCache = new RuleIndex(this.getSortedRules());\n    }\n    return this.ruleIndexCache;\n  }\n\n  /**\n   * The rules to try at a position, in priority order.\n   *\n   * With a candidate mask, walks its set bits low to high, which is descending\n   * priority because bit `i` is the rule at index `i` of the priority-sorted\n   * list.\n   *\n   * The walk shifts a bit at a time rather than jumping to the next set bit\n   * with `Math.clz32(bits & -bits)`, which is the idiomatic form and was 36x\n   * SLOWER here: 45us per line against 1.2us, measured over the built-in rule\n   * set. `clz32` is specified on uint32 and the masks come out of a\n   * `Uint32Array` as doubles above 2^31, so every call pays a conversion that\n   * swamps the handful of iterations it saves. A de Bruijn table matched the\n   * shift scan to within noise and needs a magic constant, so the plain shift\n   * wins on both counts. Worst case is 32 iterations per word of pure integer\n   * work.\n   *\n   * With `null` (the {@link NormalizerOptions.ignoreRuleIndex} path) it falls\n   * back to the type-bucketed list, which is the behaviour this replaced.\n   *\n   * Returns a buffer reused across positions, so the caller must finish with it\n   * before calling again. Copying the surviving rules out here rather than\n   * yielding them lazily is deliberate twice over: it keeps the mask's own\n   * scratch buffer from being read after the next position overwrites it, and\n   * it avoids a generator on the hottest loop in the pass.\n   */\n  private rulesAt(mask: Uint32Array | null, type: string): NormalizerRule[] {\n    const buffer = this.candidateBuffer;\n    buffer.length = 0;\n\n    if (mask === null) {\n      const list = this.rulesForTokenType(type);\n      for (let i = 0; i < list.length; i++) buffer.push(list[i]);\n      return buffer;\n    }\n\n    const rules = this.getRuleIndex().rules;\n    for (let w = 0; w < mask.length; w++) {\n      let bits = mask[w] >>> 0;\n      let index = w * 32;\n      while (bits !== 0) {\n        if ((bits & 1) !== 0) buffer.push(rules[index]);\n        bits >>>= 1;\n        index++;\n      }\n    }\n    return buffer;\n  }\n\n  private rulesForTokenType(type: string): NormalizerRule[] {\n    let list = this.rulesByTokenType.get(type);\n    if (list === undefined) {\n      list = this.getSortedRules().filter(\n        (rule) => rule.startTokenTypes === undefined || rule.startTokenTypes.includes(type),\n      );\n      this.rulesByTokenType.set(type, list);\n    }\n    return list;\n  }\n\n  /**\n   * Get the number of currently registered rules (excludes phrase trie entries).\n   */\n  get ruleCount(): number {\n    return this.rules.length;\n  }\n\n  /**\n   * Every registered rule with the shape it declared, for diagnostic display.\n   *\n   * Exposes what the index is actually working with: a rule that declares a\n   * shape is only tried where that shape can match, and one that declares none\n   * is tried at every position of every line. Which is which is invisible from\n   * the outside otherwise, and it is the difference between a package that\n   * costs the documents that use it and one that costs all of them, so the\n   * playground draws it.\n   *\n   * Returned in priority order, highest first, which is the order the\n   * normalizer tries them in.\n   */\n  private ruleShapesCache: Array<{\n    name: string;\n    priority: number;\n    shape: readonly RuleSlot[];\n    unshapedReason?: string;\n    indexedSlots: number;\n  }> | null = null;\n\n  getRuleShapes(): Array<{\n    name: string;\n    priority: number;\n    shape: readonly RuleSlot[];\n    unshapedReason?: string;\n    indexedSlots: number;\n  }> {\n    // Memoised: the answer depends only on the rule set, but the diagnostic\n    // pipeline builds a stage per LINE, so recomputing it there made a\n    // 25-line document walk every rule 25 times to produce 25 identical lists.\n    if (this.ruleShapesCache !== null) return this.ruleShapesCache;\n    const index = this.getRuleIndex();\n    this.ruleShapesCache = this.getSortedRules().map((rule) => {\n      const shape = effectiveShape(rule);\n      return {\n        name: rule.name,\n        priority: rule.priority,\n        shape,\n        unshapedReason: rule.unshapedReason,\n        indexedSlots: Math.min(shape.length, index.depth),\n      };\n    });\n    return this.ruleShapesCache;\n  }\n\n  /**\n   * How many rules could fire at each position of `tokens`, against the total.\n   *\n   * The point of the index is that most positions admit no rule at all, and\n   * this is what makes that visible rather than asserted.\n   */\n  getCandidateCounts(tokens: Token[]): number[] {\n    const index = this.getRuleIndex();\n    const counts: number[] = [];\n    for (let pos = 0; pos < tokens.length; pos++) {\n      const mask = index.candidates(tokens, pos);\n      let n = 0;\n      for (let w = 0; w < mask.length; w++) {\n        let bits = mask[w] >>> 0;\n        while (bits !== 0) { n += bits & 1; bits >>>= 1; }\n      }\n      counts.push(n);\n    }\n    return counts;\n  }\n\n  // ── Phrase Registration ────────────────────────────────────────────────\n\n  /**\n   * Register a multi-word phrase for fusion into a single compound token.\n   *\n   * This is the preferred way to add phrase patterns. It inserts into the\n   * internal {@link PhraseTrie}, which collapses all phrase rules into a\n   * single O(depth) trie walk per position, no separate rule scanning.\n   *\n   * @param phrase    - Multi-word phrase (e.g., \"to the power of\", \"abyssal whip\")\n   * @param tokenType - Target token type after fusion (e.g., \"CARET\", \"ITEM\")\n   */\n  addPhrase(phrase: string, tokenType: string): void {\n    this.phraseTrie.addPhrase(phrase, tokenType);\n  }\n\n  /**\n   * Check whether a word can start any registered phrase.\n   *\n   * Used by {@link implicitMultiplyRule} to suppress `*` insertion\n   * before phrase-starting identifiers (e.g., \"2 power of 3\" → `2 ^ 3`,\n   * not `2 * power of 3`). Delegates to {@link PhraseTrie.canStart}.\n   */\n  /**\n   * Get all registered phrases and their target token types.\n   *\n   * Exposes the full phrase trie structure for diagnostic rendering\n   * in the playground's NormalizerTab. Returns ALL registered phrases,\n   * not just the ones that matched in the last evaluation.\n   */\n  getPhrases(): Record<string, string> {\n    return this.phraseTrie.getAllPhrases();\n  }\n\n  canStartPhrase(word: string): boolean {\n    return this.phraseTrie.canStart(word);\n  }\n\n  // ── Normalization ────────────────────────────────────────────────────────\n\n  /**\n   * Normalize a token stream by applying all registered rules.\n   *\n   * ## Algorithm\n   * Applies rules greedily left-to-right in multiple passes:\n   * 1. Sort rules by priority (descending)\n   * 2. Walk the token stream left to right\n   * 3. At each position, try rules in priority order\n   * 4. On match: consume matched tokens, insert replacements, restart from insert point\n   * 5. On no match: pass token through unchanged\n   * 6. Repeat until a full pass produces no changes, or maxPasses is reached\n   *\n   * ## Fusion tracking\n   * When a rule consumes more tokens than it produces, the normalizer calls\n   * `onFusion` with a {@link TokenFusion} record for diagnostic collection.\n   * This populates {@link NormalizerOutput.fusions} in the playground pipeline view.\n   *\n   * ## Safety\n   * If the normalized token count exceeds {@link NormalizerOptions.maxTokens},\n   * an Error is thrown to prevent memory exhaustion from runaway rule expansion.\n   *\n   * @param tokens   - Raw tokens from the lexer\n   * @param onFusion - Optional fusion callback (overrides {@link NormalizerOptions.onFusion})\n   * @returns Normalized tokens ready for parsing\n   * @throws {Error} If the normalized token count exceeds maxTokens\n   */\n  normalize(tokens: Token[], onFusion?: (fusion: TokenFusion) => void): Token[] {\n    // ── Early exit: nothing to normalize ──\n    if (tokens.length === 0) return tokens;\n\n    // Rules are consulted per token type via rulesForTokenType(), which builds\n    // on the priority-sorted cache in getSortedRules().\n    const fusionHandler = onFusion ?? this.options.onFusion;\n    const maxPasses = this.options.maxPasses;\n    const maxTokens = this.options.maxTokens;\n\n    // Hoisted out of the pass loop: the rule set cannot change mid-normalize,\n    // so the index is resolved once rather than per position.\n    const warmedUp = this.normalizeCalls > 0;\n    if (!warmedUp) this.normalizeCalls = 1;\n    const useIndex = warmedUp && !this.options.ignoreRuleIndex;\n    const ruleIndex = useIndex ? this.getRuleIndex() : null;\n\n    let current = tokens;\n    let changed = true;\n    let passCount = 0;\n\n    // Multi-pass loop: rules may trigger cascading matches across passes\n    while (changed && passCount < maxPasses) {\n      changed = false;\n      passCount++;\n\n      // Built lazily: a pass that changes nothing must not allocate an array\n      // and copy every token into it only to throw the copy away. `null` means\n      // \"nothing has changed yet, `current` is still the answer\"; the first\n      // rule to fire calls ensureResult() to materialise it. A document whose\n      // lines mostly normalise to themselves is the common case, and it now\n      // costs no allocation at all.\n      let result: Token[] | null = null;\n      let pos = 0;\n\n      // Single-pass left-to-right greedy walk\n      while (pos < current.length) {\n        let matched = false;\n\n        // ── Fast path: phrase trie (O(depth) single walk vs O(R × W) per rule) ──\n        // O(1) type-guard: skip trie entirely for tokens that can't start phrases.\n        // Flat Uint8Array indexed by typeId, no hashing, no Set lookup, true O(1).\n        const tid = current[pos].typeId;\n        if (tid >= NON_WORD_TABLE.length || NON_WORD_TABLE[tid] === 0) {\n          const trieMatch = this.phraseTrie.matchAt(current, pos);\n          if (trieMatch) {\n            const sourceTokens = current.slice(pos, pos + trieMatch.consumed);\n            if (result === null) result = current.slice(0, pos);\n            for (const rt of trieMatch.replacement) {\n              result.push(rt);\n            }\n            if (trieMatch.consumed > 1 && trieMatch.replacement.length === 1) {\n              recordSourceSpan(trieMatch.replacement[0], sourceTokens);\n              fusionHandler({\n                rule: trieMatch.ruleName ?? \"phrase-trie\",\n                sourceTokens,\n                fusedToken: trieMatch.replacement[0],\n              });\n            }\n            pos += trieMatch.consumed;\n            changed = true;\n            continue; // trie matched — skip other rules at this position (no need to set matched)\n          }\n        }\n\n        // Try, in priority order, only the rules whose declared shape admits\n        // this position. The index is a pure filter: bit order is priority\n        // order, and a rule it excludes would have returned null here anyway\n        // (see RuleIndex). `ignoreRuleIndex` restores the exhaustive scan so\n        // the two can be compared.\n        const candidates = useIndex\n          ? ruleIndex!.candidates(current, pos)\n          : null;\n        if (candidates !== null && isEmptyMask(candidates)) {\n          // Nothing can fire here. This is the common case in running prose,\n          // and reaching it costs a few array loads rather than one call per\n          // registered rule.\n          if (result !== null) result.push(current[pos]);\n          pos++;\n          continue;\n        }\n        for (const rule of this.rulesAt(candidates, current[pos].type)) {\n          const match = rule.match(current, pos);\n          if (match) {\n            // Collect source tokens for fusion tracking\n            const sourceTokens = current.slice(pos, pos + match.consumed);\n\n            // Insert replacement tokens into result\n            if (result === null) result = current.slice(0, pos);\n            for (const rt of match.replacement) {\n              result.push(rt);\n            }\n\n            // Track fusion events for diagnostics:\n            // - Multiple tokens → single token: classic fusion\n            // - Multiple tokens → fewer tokens: partial fusion\n            if (match.consumed > 1 && match.replacement.length === 1) {\n              recordSourceSpan(match.replacement[0], sourceTokens);\n              fusionHandler({\n                rule: rule.name,\n                sourceTokens,\n                fusedToken: match.replacement[0],\n              });\n            } else if (match.consumed > 1 && match.replacement.length < match.consumed) {\n              for (const rt of match.replacement) {\n                fusionHandler({\n                  rule: rule.name,\n                  sourceTokens,\n                  fusedToken: rt,\n                });\n              }\n            }\n\n            // Advance position past consumed tokens\n            pos += match.consumed;\n            changed = true;\n            matched = true;\n            break; // Rule matched — restart at new position with highest-priority rules\n          }\n        }\n\n        if (!matched) {\n          // No rule matched at this position, pass token through unchanged.\n          // Only copied when an earlier position already forced the array.\n          if (result !== null) result.push(current[pos]);\n          pos++;\n        }\n      }\n\n      // Nothing fired anywhere in this pass, so the stream is already its own\n      // normal form and `changed` is false; the loop is about to end.\n      if (result === null) break;\n      const passResult: Token[] = result;\n\n      // Safety: bail if token count explodes (runaway rule expansion)\n      if (passResult.length > maxTokens) {\n        // A raw Error here would bypass ThreeTierEvaluator's DAG-preservation\n        // enrichment on compile failure (it specifically checks for\n        // EngineError). Same reasoning as ExpressionEngineSafety.ts's\n        // complexity/length checks, which this mirrors.\n        throw ErrorFactory.validation(\n          \"NORMALIZED_TOKEN_LIMIT_EXCEEDED\",\n          `Normalized token count (${passResult.length}) exceeds safety limit (${maxTokens})`,\n          { tokenCount: passResult.length, maxTokens }\n        );\n      }\n\n      current = passResult;\n    }\n\n    return current;\n  }\n}\n\n//#endregion\n","//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * PhraseTrie, optimized word-level trie for multi-word phrase fusion.\n *\n * ## Problem\n * The normalizer previously applied N separate `phraseFusionRule` instances,\n * each scanning forward from the current token position. For R phrase rules\n * and W average phrase length, this cost O(N × R × W) per pass.\n *\n * ## Solution\n * A single trie walk per position collapses all phrase rules into O(D)\n * where D ≤ longest phrase depth (typically ≤ 5 words). The trie tracks\n * the deepest terminal node reached, implementing longest-match-wins\n * without priority sorting.\n *\n * ## Optimizations\n * 1. **Set<string> quick-reject**, the `startWords` set contains the first\n *    word of every registered phrase. At each position, if the token's\n *    lowercase value isn't in the set, we bail in O(1) without touching\n *    the trie. ~80% of tokens (numbers, operators) hit this fast path.\n * 2. **Longest-match-wins**, the `matchAt()` walk continues past terminal\n *    nodes, tracking the deepest one. Shorter overlapping phrases (e.g.,\n *    \"power of\") don't need lower priority, the trie naturally prefers\n *    the longer match.\n * 3. **Map-based children**, `Map<string, TrieNode>` gives O(1) amortized\n *    child lookup per word, faster than array scanning for sparse branches.\n *\n * ## Package integration\n * Packages add phrases via {@link TokenNormalizer.addPhrase} (public API)\n * or the {@link IEnginePackage.phrases} declarative field. Each call to\n * `addPhrase()` inserts the phrase into this trie and updates `startWords`.\n *\n * @module PhraseTrie\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { Token } from \"@solve-js/lexer/Token\";\nimport type { NormalizerMatch } from \"./NormalizerRule\";\nimport { createFusedToken } from \"./TokenNormalizer\";\n\n//#endregion\n//#region ─── TrieNode ─────────────────────────────────────────────────────────\n\n/**\n * Internal trie node.\n *\n * Each node represents a matched word in a phrase. The path from root\n * to a node spells out a partial or complete phrase.\n */\ninterface TrieNode {\n\t/** Child nodes keyed by next word (all lowercase). */\n\tchildren: Map<string, TrieNode>;\n\t/**\n\t * If this node completes a phrase, the terminal metadata.\n\t * A node can be both terminal AND have children. This handles\n\t * overlapping phrases like \"power of\" and \"to the power of\".\n\t */\n\tterminal: TrieTerminal | null;\n}\n\n/** Metadata stored at terminal nodes for deferred token creation. */\ninterface TrieTerminal {\n\t/** The target token type after fusion (e.g., \"CARET\", \"TIMES_BY\"). */\n\ttokenType: string;\n\t/** The original phrase string (e.g., \"to the power of\"). */\n\tphrase: string;\n\t/** Number of tokens consumed by this phrase. */\n\tconsumed: number;\n}\n\n//#endregion\n//#region ─── PhraseTrie ─────────────────────────────────────────────────────\n\n/**\n * Word-level trie for single-pass multi-word phrase matching.\n *\n * @example\n * ```ts\n * const trie = new PhraseTrie();\n * trie.addPhrase(\"to the power of\", \"CARET\");\n * trie.addPhrase(\"power of\", \"CARET\");\n * trie.addPhrase(\"abyssal whip\", \"ITEM\");\n *\n * // At position 0 with tokens [\"to\",\"the\",\"power\",\"of\",\"3\"]\n * const match = trie.matchAt(tokens, 0);\n * // → { consumed: 4, replacement: [CARET(\"to the power of\")] }\n * ```\n */\nexport class PhraseTrie {\n\t/**\n\t * First words that can start any registered phrase (all lowercase).\n\t * O(1) quick-reject: if `tokens[pos].value.toLowerCase()` isn't here,\n\t * no phrase can match at this position.\n\t */\n\tprivate startWords = new Set<string>();\n\n\t/**\n\t * Root maps first word → child node.\n\t * Two-level root avoids an unnecessary intermediate TrieNode.\n\t */\n\tprivate root = new Map<string, TrieNode>();\n\n\t// ── Registration ──────────────────────────────────────────────────────\n\n\t/**\n\t * Register a phrase for fusion into a single compound token.\n\t *\n\t * @param phrase    - Multi-word phrase (e.g., \"to the power of\")\n\t * @param tokenType - Target token type after fusion (e.g., \"CARET\")\n\t */\n\taddPhrase(phrase: string, tokenType: string): void {\n\t\tconst words = phrase.toLowerCase().trim().split(/\\s+/);\n\t\tif (words.length === 0 || words[0] === \"\") return;\n\n\t\tthis.startWords.add(words[0]);\n\n\t\tconst firstWord = words[0];\n\t\tlet node: TrieNode;\n\n\t\tif (this.root.has(firstWord)) {\n\t\t\tnode = this.root.get(firstWord)!;\n\t\t} else {\n\t\t\tnode = { children: new Map(), terminal: null };\n\t\t\tthis.root.set(firstWord, node);\n\t\t}\n\n\t\t// Single-word phrase: terminal at root's child\n\t\tif (words.length === 1) {\n\t\t\tnode.terminal = { tokenType, phrase, consumed: 1 };\n\t\t\treturn;\n\t\t}\n\n\t\t// Walk/insert remaining words\n\t\tfor (let i = 1; i < words.length; i++) {\n\t\t\tconst word = words[i];\n\t\t\tif (!node.children.has(word)) {\n\t\t\t\tnode.children.set(word, { children: new Map(), terminal: null });\n\t\t\t}\n\t\t\tnode = node.children.get(word)!;\n\t\t}\n\n\t\tnode.terminal = { tokenType, phrase, consumed: words.length };\n\t}\n\n\t// ── Matching ──────────────────────────────────────────────────────────\n\n\t/**\n\t * Attempt to match a phrase starting at `pos` in the token stream.\n\t *\n\t * Walks the trie one token at a time, tracking the deepest terminal\n\t * node reached. Returns the longest match found, or `null` if no\n\t * phrase starts at this position.\n\t *\n\t * @param tokens - The current token stream\n\t * @param pos    - Position to attempt matching from\n\t * @returns The longest {@link NormalizerMatch}, or `null` on no match\n\t */\n\tmatchAt(tokens: Token[], pos: number): NormalizerMatch | null {\n\t\t// ── Bounds guard ──\n\t\tif (pos >= tokens.length) return null;\n\n\t\t// ── A tag token never takes part in phrase fusion (#197, #213) ──\n\t\t// A `#tag` is a typed token, not a bare word, so it must not start or\n\t\t// complete a phrase. The trie matches on written value alone, so without\n\t\t// this guard a tag whose name equals a phrase or a phrase-continuation\n\t\t// word (`1200 #assuming`, `total of #column`) is fused into that grammar\n\t\t// before the category-tag rules ever run, and the tag is lost.\n\t\t//\n\t\t// The guard also covers the fused aggregate tokens the tags package emits\n\t\t// (`TAG_SUM` / `TAG_COUNT` / `TAG_AVERAGE`), whose value is the tag NAME:\n\t\t// otherwise `total of #assuming` fuses correctly to TAG_SUM(\"assuming\"),\n\t\t// then the trie re-reads that value on the next pass and turns it back\n\t\t// into the finance ASSUMING keyword (#213). The whole `TAG` / `TAG_*`\n\t\t// namespace belongs to the tags package.\n\t\tconst startType = tokens[pos].type;\n\t\tif (startType === \"TAG\" || startType.startsWith(\"TAG_\")) return null;\n\n\t\t// ── O(1) quick-reject: first word not a phrase starter ──\n\t\tconst firstWord = tokens[pos].value.toLowerCase();\n\t\tif (!this.startWords.has(firstWord)) return null;\n\n\t\t// ── Walk trie, tracking deepest terminal ──\n\t\tlet node: TrieNode | undefined = this.root.get(firstWord);\n\t\tif (!node) return null;\n\n\t\tlet best: NormalizerMatch | null = null;\n\t\tlet depth = 1;\n\n\t\t// Check single-word phrase at first node\n\t\tif (node.terminal) {\n\t\t\tconst sourceTokens = tokens.slice(pos, pos + 1);\n\t\t\tbest = {\n\t\t\t\tconsumed: 1,\n\t\t\t\treplacement: [createFusedToken(node.terminal.tokenType, node.terminal.phrase, sourceTokens)],\n\t\t\t\truleName: node.terminal.phrase,\n\t\t\t};\n\t\t}\n\n\t\t// Walk deeper for multi-word phrases\n\t\tfor (let i = pos + 1; i < tokens.length && node?.children; i++) {\n\t\t\tconst contType = tokens[i].type;\n\t\t\tif (contType === \"TAG\" || contType.startsWith(\"TAG_\")) break; // a tag token can't continue a phrase (#197, #213)\n\t\t\tconst word = tokens[i].value.toLowerCase();\n\t\t\tnode = node.children.get(word);\n\t\t\tif (!node) break; // dead end\n\t\t\tdepth++;\n\n\t\t\tif (node.terminal) {\n\t\t\t\t// Deferred fused-token creation, only on deepest match found\n\t\t\t\tconst sourceTokens = tokens.slice(pos, pos + depth);\n\t\t\t\tbest = {\n\t\t\t\t\tconsumed: depth,\n\t\t\t\t\treplacement: [\n\t\t\t\t\t\tcreateFusedToken(node.terminal.tokenType, node.terminal.phrase, sourceTokens),\n\t\t\t\t\t],\n\t\t\t\t\truleName: node.terminal.phrase,\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\treturn best;\n\t}\n\n\t// ── Introspection ─────────────────────────────────────────────────────\n\n\t/** Number of unique first words (not total phrases). */\n\tget size(): number {\n\t\treturn this.root.size;\n\t}\n\n\t/**\n\t * Return all registered phrases and their target token types.\n\t *\n\t * Used by diagnostic mode to expose the complete trie structure to the\n\t * playground's NormalizerTab for rendering ALL registered phrases\n\t * (not just the ones that matched in this evaluation).\n\t */\n\tgetAllPhrases(): Record<string, string> {\n\t\tconst result: Record<string, string> = {};\n\n\t\tconst collect = (node: TrieNode, path: string[]): void => {\n\t\t\tif (node.terminal) {\n\t\t\t\tresult[path.join(' ')] = node.terminal.tokenType;\n\t\t\t}\n\t\t\tfor (const [word, child] of node.children) {\n\t\t\t\tcollect(child, [...path, word]);\n\t\t\t}\n\t\t};\n\n\t\tfor (const [firstWord, node] of this.root) {\n\t\t\tcollect(node, [firstWord]);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/** Check if any phrase starts with this word (case-insensitive). */\n\tcanStart(word: string): boolean {\n\t\treturn this.startWords.has(word.toLowerCase());\n\t}\n}\n\n//#endregion\n","//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * Built-in normalization rules for the {@link TokenNormalizer}.\n *\n * These rules handle common expression patterns that span multiple tokens.\n * Phrase fusion (e.g., \"to the power of\" → CARET) is handled by the\n * internal {@link PhraseTrie}. See {@link TokenNormalizer.addPhrase}.\n * This module only exports non-phrase rules like {@link implicitMultiplyRule}.\n *\n * @module BuiltinNormalizerRules\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { Token } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { LexerToken } from \"@solve-js/lexer/ExpressionLexer\";\nimport type { NormalizerRule, NormalizerMatch } from \"./NormalizerRule\";\n\n//#endregion\n//#region ─── PHRASE_START_WORDS, Implicit Multiply Guard ─────────────────────\n\n/**\n * Words that can start multi-word phrases, hardcoded fallback.\n *\n * This is ONLY used as the default fallback in {@link implicitMultiplyRule}\n * when no `canStart` predicate is provided. In the recommended pattern,\n * the {@link PhraseTrie}'s live `canStart()` set is passed instead, keeping\n * the guard in sync with package-registered phrases.\n *\n * @see {@link TokenNormalizer.canStartPhrase}\n */\n/**\n * Words that introduce a rate denominator when a unit follows.\n *\n * Kept next to the implicit-multiplication rule because that is the only\n * thing they change here; the rate itself is built in the uom package.\n */\nconst RATE_DENOMINATOR_WORDS = new Set([\"per\", \"a\", \"an\", \"each\", \"every\"]);\n\nconst PHRASE_START_WORDS = new Set([\n  \"to\", \"power\", \"increase\", \"decrease\", \"times\", \"multiply\", \"divide\", \"by\",\n]);\n\n//#endregion\n//#region ─── implicitMultiplyRule, Implicit Operator Insertion ────────────────\n\n/**\n * Creates a normalization rule that inserts an implicit multiplication operator\n * between adjacent tokens where multiplication is implied.\n *\n * ## When it fires\n * Inserts a STAR token between:\n * - `NUMBER IDENT` (e.g., \"2 x\" → \"2 * x\")\n * - `RPAREN IDENT` (e.g., \"(x+1)y\" → \"(x+1) * y\")\n * - `NUMBER LPAREN` (e.g., \"2(x+1)\" → \"2 * (x+1)\")\n * - `NUMBER PI` / `NUMBER E` (e.g., \"2π\" → \"2 * π\")\n *\n * ## When it doesn't fire\n * - When the following identifier starts a multi-word phrase\n *   (checked against {@link PHRASE_START_WORDS})\n * - When the following token is not an identifier or parenthesized expression\n *\n * ## Priority\n * Default priority is 50, below phrase fusion so phrases match first.\n *\n * @param priority - Rule priority (default 50)\n * @returns A {@link NormalizerRule} that inserts implicit multiply operators\n */\nexport function implicitMultiplyRule(\n\tpriority: number = 50,\n\tcanStart?: (word: string) => boolean\n): NormalizerRule {\n\tconst phraseGuard = canStart ?? ((word: string) => PHRASE_START_WORDS.has(word.toLowerCase()));\n\n\treturn {\n    name: \"implicit:multiply\",\n    priority,\n    // Both slots are exactly the `triggers` test below, which is the whole\n    // condition: a value or closing bracket, then something a multiplication\n    // could apply to.\n    shape: [\n      { types: [\"NUMBER\", \"RPAREN\"] },\n      { types: [\"IDENT\", \"LPAREN\", \"PI\", \"E\"] },\n    ],\n    match(tokens: Token[], pos: number): NormalizerMatch | null {\n      // ── Need at least one token after the current position ──\n      if (pos + 1 >= tokens.length) return null;\n\n      const t = tokens[pos];\n      const next = tokens[pos + 1];\n\n      // ── Check trigger conditions ──\n      // Ordered FIRST deliberately. The two guards below only ever suppress a\n      // match, so testing them after the trigger cannot change any result, and\n      // the first of them allocates a lower-cased copy of the next token's\n      // value. Running that ahead of a pair of type comparisons meant every\n      // position in the document paid a string allocation and a set lookup to\n      // reach a test that rejects nearly all of them.\n      const triggers =\n        (t.type === \"NUMBER\" || t.type === \"RPAREN\") &&\n        (next.type === \"IDENT\" || next.type === \"LPAREN\" || next.type === \"PI\" || next.type === \"E\");\n\n      if (!triggers) return null;\n\n      // ── Guard: suppress if the next identifier starts a phrase ──\n      // Uses the trie's canStart when available, falls back to hardcoded set.\n      // This prevents \"2 power of 3\" from becoming \"2 * power of 3\".\n      const nextValue = next.value.toLowerCase();\n      if (phraseGuard(nextValue)) return null;\n\n      // ── Guard: a rate denominator, not a multiplication ──\n      // \"99 per week\" is ninety-nine a week, not ninety-nine times something\n      // called per. The trie guard above cannot cover this, because these are\n      // not registered phrases; they are recognised by the uom package's\n      // bare-denominator rule, which runs after this one and then finds its\n      // fused token stranded in operand position. The slash spelling never had\n      // the problem, which is what made it hard to see.\n      if (RATE_DENOMINATOR_WORDS.has(nextValue) && tokens[pos + 2]?.type === \"UNIT\") return null;\n\n      // ── Insert a STAR token at the next token's position ──\n      const starToken = new LexerToken(\n        \"STAR\", tokenTypeId(\"STAR\"), \"*\", \"*\",\n        next.offset, 0, next.line, next.col,\n      );\n\n      // consumed = 1: only the current token is replaced with [current, STAR]\n      // The next token is NOT consumed, it stays for the next iteration\n      return { consumed: 1, replacement: [t, starToken] };\n    },\n  };\n}\n\n//#endregion\n//#region ─── isInsideRangeContext, Bracket/Call-Paren Context Guard ───────────\n\n/**\n * Whether token `pos` sits inside a context where a bare `NUMBER:NUMBER`\n * sequence means a Range, not a clock-time/laptime/video-timecode literal:\n * a matrix literal/index/slice (`[1,2,3]`, `a[0:3]`), OR a `map`/`reduce`/\n * `sum`/`prod` call's own argument-list parens (`map(f, 0:3)`, these\n * accept a bare Range argument directly, per the Calca spec's own\n * example). Scans backward from `pos` over the CURRENT pass's token array,\n * tracking `[`/`(` nesting depth, the same \"positional guard via\n * backward scan\" idiom already used elsewhere in this normalizer layer\n * (e.g. `LineRefNormalizerRule`'s previous-token check), generalized to\n * depth-tracking. An `LBRACKET` is unconditionally a range-safe opener; an\n * `LPAREN` is range-safe ONLY when immediately preceded by MAP/REDUCE/\n * SUM_FN/PROD_FN, an ordinary grouping/function-call paren is NOT, so\n * `(9:00) + 5` still means a clock time, not a range.\n *\n * Needed because the clock-time/laptime/video-timecode rules each match a\n * bare `NUMBER COLON NUMBER...` shape with ZERO context-awareness, a real\n * collision discovered when adding Range support, since e.g. \"0:3\" is\n * valid input to BOTH features. These contexts have no legitimate use for\n * a clock-time/laptime/timecode literal, so the carve-out costs the time\n * features nothing.\n *\n * IMPORTANT cross-pass-timing gotcha (a real bug found and fixed here,\n * not a hypothetical): the `LPAREN`-opener check deliberately tests the\n * RAW word text (`prev.value.toLowerCase()`), not `prev.type ===\n * \"MAP\"/\"REDUCE\"/...`. The normalizer's multi-pass loop hands every rule\n * the SAME frozen `tokens` snapshot for an entire pass, a rule scanning\n * a LATER position in that pass cannot see a fusion `mapReduceCallNormalizerRule`\n * performs at an EARLIER position in that SAME pass (fusion results only\n * become visible to other rules starting the NEXT pass). Checking the\n * fused token type here would miss exactly the case that matters most\n * `map(f, 0:3)` on its very first normalization pass, silently letting\n * `0:3` fuse into a clock time before `map(`'s own fusion ever lands.\n * Testing the raw word is immune to this: it's true from the very first\n * pass, regardless of whether `mapReduceCallNormalizerRule` has run yet.\n * (`LBRACKET` above has no equivalent issue, it's a genuine lexer token\n * from the start, never itself the product of a fusion.)\n */\nexport function isInsideRangeContext(tokens: Token[], pos: number): boolean {\n  const safeStack: boolean[] = [];\n  for (let i = 0; i < pos; i++) {\n    const t = tokens[i];\n    if (t.type === \"LBRACKET\") {\n      safeStack.push(true);\n    } else if (t.type === \"LPAREN\") {\n      const prev = tokens[i - 1];\n      const opensMapReduceCall = !!prev && (\n        prev.type === \"MAP\" || prev.type === \"REDUCE\" || prev.type === \"SUM_FN\" || prev.type === \"PROD_FN\" ||\n        (prev.type === \"IDENT\" && (prev.value.toLowerCase() === \"map\" || prev.value.toLowerCase() === \"reduce\" || prev.value.toLowerCase() === \"sum\" || prev.value.toLowerCase() === \"prod\"))\n      );\n      safeStack.push(opensMapReduceCall);\n    } else if (t.type === \"RBRACKET\" || t.type === \"RPAREN\") {\n      safeStack.pop();\n    }\n  }\n  return safeStack.length > 0 && safeStack[safeStack.length - 1];\n}\n\n//#endregion\n//#region ─── createBuiltinNormalizerRules, All Built-in Rules ─────────────────\n\n/**\n * Creates built-in non-phrase normalization rules.\n *\n * Returns implicit multiply insertion (priority 50).\n *\n * **Prefer** calling {@link implicitMultiplyRule} directly with a\n * `canStart` predicate wired to the normalizer's phrase trie:\n * ```ts\n * normalizer.register(implicitMultiplyRule(50, (w) => normalizer.canStartPhrase(w)));\n * ```\n * Without the predicate, this function falls back to a hardcoded\n * {@link PHRASE_START_WORDS} set that won't reflect package-registered phrases.\n *\n * @returns An array of {@link NormalizerRule} instances ready for registration\n */\nexport function createBuiltinNormalizerRules(): NormalizerRule[] {\n  return [\n    // ── Implicit operator insertion (priority 50) ──\n    implicitMultiplyRule(),\n  ];\n}\n\n/**\n * Built-in phrase → tokenType mappings.\n *\n * These are registered into the engine's {@link PhraseTrie} during\n * construction. Tests that create a standalone {@link TokenNormalizer}\n * should register these via {@link TokenNormalizer.addPhrase}. The table\n * itself lives in `lexer/BuiltinPhrases.ts`, shared with the lexer's token\n * lookup, and is re-exported here so existing imports keep working.\n */\nexport { BUILTIN_PHRASES } from \"@solve-js/lexer/BuiltinPhrases\";\n\n//#endregion\n"]}

package/dist/chunk-RECRD45C.cjs

@@ -1,5 +0,0 @@
-'use strict';var chunkS46R5QZP_cjs=require('./chunk-S46R5QZP.cjs'),chunkZVPZQ66D_cjs=require('./chunk-ZVPZQ66D.cjs'),chunkTTFO4YDP_cjs=require('./chunk-TTFO4YDP.cjs'),chunkRMCN5WFO_cjs=require('./chunk-RMCN5WFO.cjs'),chunkHG4NPDN5_cjs=require('./chunk-HG4NPDN5.cjs'),chunkF7QIBC4B_cjs=require('./chunk-F7QIBC4B.cjs'),chunkLTJV3VJE_cjs=require('./chunk-LTJV3VJE.cjs'),chunk5GL4SAVH_cjs=require('./chunk-5GL4SAVH.cjs'),chunk72N3ZRVE_cjs=require('./chunk-72N3ZRVE.cjs'),chunkUURM7P3P_cjs=require('./chunk-UURM7P3P.cjs'),chunkZLRJ7TDP_cjs=require('./chunk-ZLRJ7TDP.cjs'),chunkAUOE7MFI_cjs=require('./chunk-AUOE7MFI.cjs'),chunk2VE4OW4A_cjs=require('./chunk-2VE4OW4A.cjs'),chunkDA7M6H63_cjs=require('./chunk-DA7M6H63.cjs'),chunkUY3ID6JF_cjs=require('./chunk-UY3ID6JF.cjs'),chunkIHAZL4EF_cjs=require('./chunk-IHAZL4EF.cjs'),chunkY7O4D3BJ_cjs=require('./chunk-Y7O4D3BJ.cjs'),chunkUPH22K2T_cjs=require('./chunk-UPH22K2T.cjs'),chunk5IJD5L3O_cjs=require('./chunk-5IJD5L3O.cjs'),chunkS3DFU33X_cjs=require('./chunk-S3DFU33X.cjs'),chunkELQQKZN3_cjs=require('./chunk-ELQQKZN3.cjs');function Lt(n,e,t,r,i){let s=t[e],o=r[e];if(!s||!o)return;let a=new Set(Object.keys(s));for(let l of Object.keys(o))a.has(l)&&i.push({kind:n,severity:"warning",detail:`Both "${t.name}" and "${r.name}" register a ${e==="prefixParselets"?"prefix":"infix"} parselet for token type "${l}" \u2014 the later-registered one silently wins.`,packages:[t.name,r.name]});}function Ot(n,e){let t=[];if(Lt("prefixParseletTokenType","prefixParselets",n,e,t),Lt("infixParseletTokenType","infixParselets",n,e,t),n.phrases&&e.phrases)for(let[s,o]of Object.entries(e.phrases)){let a=n.phrases[s];a!==void 0&&a!==o&&t.push({kind:"phrase",severity:"warning",detail:`Both "${n.name}" (-> "${a}") and "${e.name}" (-> "${o}") fuse the phrase "${s}" to DIFFERENT token types \u2014 PhraseTrie has no collision detection of its own, so the later-registered mapping silently wins with no other signal.`,packages:[n.name,e.name]});}if(n.asConverters&&e.asConverters)for(let s of Object.keys(e.asConverters)){let o=s.toLowerCase();Object.keys(n.asConverters).some(a=>a.toLowerCase()===o)&&t.push({kind:"converterName",severity:"warning",detail:`Both "${n.name}" and "${e.name}" register an "as ${s}" converter \u2014 the later-registered handler silently wins.`,packages:[n.name,e.name]});}if(n.pluginFunctions&&e.pluginFunctions){let s=new Set(Object.keys(n.pluginFunctions));for(let o of Object.keys(e.pluginFunctions))s.has(o)&&t.push({kind:"pluginFunctionName",severity:"warning",detail:`Both "${n.name}" and "${e.name}" register a plugin function named "${o}" \u2014 the later registration wins in the engine's name-to-index map. Give each package's functions package-unique names.`,packages:[n.name,e.name]});}if(n.normalizerRules&&e.normalizerRules){let s=new Set(n.normalizerRules.map(o=>o.name));for(let o of e.normalizerRules)s.has(o.name)&&t.push({kind:"normalizerRuleName",severity:"warning",detail:`Both "${n.name}" and "${e.name}" register a normalizer rule named "${o.name}" \u2014 the normalizer unregisters rules by name, so removing either package would drop both rules. Give each package's rules a package-unique name.`,packages:[n.name,e.name]});}let r=n.lexerVocabulary,i=e.lexerVocabulary;if(r?.keywords&&i?.keywords)for(let[s,o]of Object.entries(i.keywords)){let a=r.keywords[s];a!==void 0&&a!==o&&t.push({kind:"lexerKeyword",severity:"error",detail:`Both "${n.name}" (-> "${a}") and "${e.name}" (-> "${o}") register the lexer keyword "${s}" for DIFFERENT token types \u2014 whichever package registers second wins, and the loser's grammar becomes silently unreachable for that word.`,packages:[n.name,e.name]});}if(r?.operators&&i?.operators)for(let[s,o]of Object.entries(i.operators)){let a=r.operators[s];a!==void 0&&a!==o&&t.push({kind:"lexerOperator",severity:"error",detail:`Both "${n.name}" (-> "${a}") and "${e.name}" (-> "${o}") register the lexer operator "${s}" for DIFFERENT token types.`,packages:[n.name,e.name]});}if(n.asyncResolvers&&e.asyncResolvers){let s=new Set(n.asyncResolvers.map(o=>o.namespace));for(let o of e.asyncResolvers)s.has(o.namespace)&&t.push({kind:"asyncResolverNamespace",severity:"error",detail:`Both "${n.name}" and "${e.name}" register an async resolver under the namespace "${o.namespace}" \u2014 ResolverRegistry is keyed by namespace, so one resolver's cache/preflight state will silently clobber the other's.`,packages:[n.name,e.name]});}if(n.tokenCategories&&e.tokenCategories)for(let[s,o]of Object.entries(e.tokenCategories)){let a=n.tokenCategories[s];a!==void 0&&a!==o&&t.push({kind:"tokenCategory",severity:"info",detail:`Both "${n.name}" (-> "${a}") and "${e.name}" (-> "${o}") declare a highlight category for token type "${s}" \u2014 cosmetic only, but the later registration wins.`,packages:[n.name,e.name]});}return t}function zn(n,e){let t=[];for(let r of e)r===n||r.name===n.name||t.push(...Ot(r,n));return {compatible:!t.some(r=>r.severity==="error"),conflicts:t}}var be=class{constructor(){this.prefixOwners=new Map;this.infixOwners=new Map;this.phraseOwners=new Map;this.converterOwners=new Map;this.pluginFnOwners=new Map;this.ruleOwners=new Map;this.keywordOwners=new Map;this.operatorOwners=new Map;this.resolverOwners=new Map;this.categoryOwners=new Map;}check(e){let t=new Set,r=(s,o)=>{let a=s.get(o);a&&a!==e&&a.name!==e.name&&t.add(a);};if(e.prefixParselets)for(let s of Object.keys(e.prefixParselets))r(this.prefixOwners,s);if(e.infixParselets)for(let s of Object.keys(e.infixParselets))r(this.infixOwners,s);if(e.phrases)for(let s of Object.keys(e.phrases))r(this.phraseOwners,s);if(e.asConverters)for(let s of Object.keys(e.asConverters))r(this.converterOwners,s.toLowerCase());if(e.pluginFunctions)for(let s of Object.keys(e.pluginFunctions))r(this.pluginFnOwners,s);if(e.normalizerRules)for(let s of e.normalizerRules)r(this.ruleOwners,s.name);if(e.lexerVocabulary?.keywords)for(let s of Object.keys(e.lexerVocabulary.keywords))r(this.keywordOwners,s);if(e.lexerVocabulary?.operators)for(let s of Object.keys(e.lexerVocabulary.operators))r(this.operatorOwners,s);if(e.asyncResolvers)for(let s of e.asyncResolvers)r(this.resolverOwners,s.namespace);if(e.tokenCategories)for(let s of Object.keys(e.tokenCategories))r(this.categoryOwners,s);let i=[];for(let s of t)i.push(...Ot(s,e));return i}add(e){let t=(r,i)=>{r.has(i)||r.set(i,e);};if(e.prefixParselets)for(let r of Object.keys(e.prefixParselets))t(this.prefixOwners,r);if(e.infixParselets)for(let r of Object.keys(e.infixParselets))t(this.infixOwners,r);if(e.phrases)for(let r of Object.keys(e.phrases))t(this.phraseOwners,r);if(e.asConverters)for(let r of Object.keys(e.asConverters))t(this.converterOwners,r.toLowerCase());if(e.pluginFunctions)for(let r of Object.keys(e.pluginFunctions))t(this.pluginFnOwners,r);if(e.normalizerRules)for(let r of e.normalizerRules)t(this.ruleOwners,r.name);if(e.lexerVocabulary?.keywords)for(let r of Object.keys(e.lexerVocabulary.keywords))t(this.keywordOwners,r);if(e.lexerVocabulary?.operators)for(let r of Object.keys(e.lexerVocabulary.operators))t(this.operatorOwners,r);if(e.asyncResolvers)for(let r of e.asyncResolvers)t(this.resolverOwners,r.namespace);if(e.tokenCategories)for(let r of Object.keys(e.tokenCategories))t(this.categoryOwners,r);}rebuild(e){for(let t of [this.prefixOwners,this.infixOwners,this.phraseOwners,this.converterOwners,this.pluginFnOwners,this.ruleOwners,this.keywordOwners,this.operatorOwners,this.resolverOwners,this.categoryOwners])t.clear();for(let t of e)this.add(t);}};var an=/(\d+)\.(\d+)\.(\d+)/,ln=/^\d+$/;function It(n){let e=an.exec(n.trim());return e?[Number(e[1]),Number(e[2]),Number(e[3])]:null}function cn(n,e){return n[0]-e[0]||n[1]-e[1]||n[2]-e[2]}function Ie(n){let e=n.split(".");if(e.length===0||e.length>3)return null;let t=[0,0,0];for(let r=0;r<e.length;r++){if(!ln.test(e[r]))return null;t[r]=Number(e[r]);}return [t[0],t[1],t[2]]}function un([n,e,t]){let r=n>0?[n+1,0,0]:e>0?[0,e+1,0]:[0,0,t+1];return [{op:">=",v:[n,e,t]},{op:"<",v:r}]}function pn([n,e,t]){return [{op:">=",v:[n,e,t]},{op:"<",v:[n,e+1,0]}]}function fn(n){if(n===""||n==="*"||n==="x"||n==="X")return [];if(n[0]==="^"){let i=Ie(n.slice(1));return i&&un(i)}if(n[0]==="~"){let i=Ie(n.slice(1));return i&&pn(i)}let e=/^(>=|<=|>|<|=)/.exec(n),t=e?e[1]:"=",r=Ie(e?n.slice(e[1].length):n);return r&&[{op:t,v:r}]}function Vt(n){let e=[];for(let t of n.split("||")){let r=t.trim().split(/\s+/).filter(s=>s!==""),i=[];for(let s of r){let o=fn(s);if(o===null)return null;i.push(...o);}e.push(i);}return e}function Bt(n){return Vt(n.trim())!==null}function gn(n,e){let t=cn(n,e.v);switch(e.op){case "<":return t<0;case "<=":return t<=0;case ">":return t>0;case ">=":return t>=0;case "=":return t===0}}function Mt(n,e){let t=Vt(e.trim());return t===null?false:t.some(r=>r.every(i=>gn(n,i)))}function dn(n,e=chunkUY3ID6JF_cjs.a){if(!n.engineVersion)return {compatible:true};if(!Bt(n.engineVersion))return {compatible:false,reason:"invalid-range",declaredRange:n.engineVersion,engineVersion:e};let t=It(e);return t===null||!Mt(t,n.engineVersion)?{compatible:false,reason:"range-not-satisfied",declaredRange:n.engineVersion,engineVersion:e}:{compatible:true}}function Dt(n,e=chunkUY3ID6JF_cjs.a){let t=dn(n,e);if(!t.compatible)throw t.reason==="invalid-range"?chunkELQQKZN3_cjs.c.config({code:"PACKAGE_ENGINE_VERSION_INVALID_RANGE",message:`Package "${n.name}" declares an invalid engineVersion range: "${t.declaredRange}" is not a valid semver range.`,expected:'a valid semver range string (e.g. "^0.1.0", ">=0.2.0 <1.0.0")',found:`"${t.declaredRange}"`,suggestion:`This is a range-syntax typo in "${n.name}"'s own descriptor, not a version mismatch with the running engine \u2014 check for a stray character.`,context:{packageName:n.name,declaredRange:t.declaredRange}}):chunkELQQKZN3_cjs.c.config({code:"PACKAGE_ENGINE_VERSION_MISMATCH",message:`Package "${n.name}" declares engineVersion "${t.declaredRange}", which is not satisfied by the running engine version "${t.engineVersion}".`,expected:`an engine version satisfying "${t.declaredRange}"`,found:`engine version "${t.engineVersion}"`,suggestion:`Update "${n.name}" to a version built against solve-engine ${t.engineVersion}, or pin solve-engine to a version satisfying "${t.declaredRange}".`,context:{packageName:n.name,declaredRange:t.declaredRange,engineVersion:t.engineVersion}})}var Z="solve-engine/snapshot",G=1;function $(n){return Number.isFinite(n)?n:Number.isNaN(n)?"NaN":n>0?"Infinity":"-Infinity"}function F(n){if(typeof n=="number")return n;if(n==="NaN")return NaN;if(n==="Infinity")return 1/0;if(n==="-Infinity")return  -1/0;throw chunkELQQKZN3_cjs.c.validation({code:M.SNAPSHOT_MALFORMED,message:`Snapshot holds an unrecognised number sentinel: ${JSON.stringify(n)}`,expected:'a JSON number, or one of "NaN", "Infinity", "-Infinity"',found:JSON.stringify(n)})}var M={SNAPSHOT_VERSION_MISMATCH:"SNAPSHOT_VERSION_MISMATCH",SNAPSHOT_MALFORMED:"SNAPSHOT_MALFORMED",SNAPSHOT_UNSUPPORTED_VALUE:"SNAPSHOT_UNSUPPORTED_VALUE"};function Ut(n){return {coef:n.coef.toString(),scale:n.scale}}function _t(n){return {coef:BigInt(n.coef),scale:n.scale}}function hn(n){return {n:n.n.toString(),d:n.d.toString()}}function mn(n){return {n:BigInt(n.n),d:BigInt(n.d)}}function Ft(n){return chunkDA7M6H63_cjs.g[n]??String(n)}function Ve(n,e){throw chunkELQQKZN3_cjs.c.validation({code:M.SNAPSHOT_UNSUPPORTED_VALUE,message:`A ${Ft(n)} value (${e}) cannot be included in a snapshot yet.`,expected:"a concrete number, string, boolean, unit, range, matrix, bigint, or money value",found:`${Ft(n)} value`,suggestion:"Symbolic (algebra) values are deferred to a follow-up. Evaluate the document without the symbolic line, or re-derive it after restoring.",context:{valueType:n,location:e}})}function Be(n,e){switch(n.type){case 0:{let t={t:0,v:$(n.value)};return n.exact!==void 0&&(t.exact=Ut(n.exact)),n.rational!==void 0&&(t.rational=hn(n.rational)),t}case 1:{let t=n.value;return typeof t=="bigint"?{t:1,v:t.toString(),big:true,base:n.unit}:{t:1,v:$(t),base:n.unit}}case 2:return {t:2,v:n.value.toString()};case 3:return {t:3,v:n.value};case 4:return {t:4,v:$(n.value)};case 5:return {t:5,v:$(n.value)};case 6:{let t={t:6,v:$(n.value),unit:n.unit??""};return n.exact!==void 0&&(t.exact=Ut(n.exact)),t}case 7:{let t=n.value;t.hasSymbolic&&Ve(9,`${e} (symbolic matrix cell)`);let r=t.data.map(i=>yn(i,e));return {t:7,rows:t.rows,cols:t.cols,data:r}}case 8:{let t=n.value;return {t:8,min:$(t.min),max:$(t.max)}}case 10:return {t:10,v:n.value};case 13:return {t:13,code:n.value,message:n.unit??""};default:return Ve(n.type,e)}}function yn(n,e){return typeof n=="boolean"?n:typeof n=="number"?$(n):Ve(9,`${e} (symbolic matrix cell)`)}function Me(n){switch(n.t){case 0:{let e=new chunkDA7M6H63_cjs.m(0,F(n.v));return n.exact!==void 0&&(e.exact=_t(n.exact)),n.rational!==void 0&&(e.rational=mn(n.rational)),e}case 1:{let e=n.big?BigInt(n.v):F(n.v);return new chunkDA7M6H63_cjs.m(1,e,n.base)}case 2:return new chunkDA7M6H63_cjs.m(2,BigInt(n.v));case 3:return new chunkDA7M6H63_cjs.m(3,n.v);case 4:return new chunkDA7M6H63_cjs.m(4,F(n.v));case 5:return new chunkDA7M6H63_cjs.m(5,F(n.v));case 6:{let e=new chunkDA7M6H63_cjs.m(6,F(n.v),n.unit);return n.exact!==void 0&&(e.exact=_t(n.exact)),e}case 7:{let e=n.data.map(r=>typeof r=="boolean"?r:F(r)),t={rows:n.rows,cols:n.cols,data:e,hasSymbolic:false};return new chunkDA7M6H63_cjs.m(7,t)}case 8:return new chunkDA7M6H63_cjs.m(8,{min:F(n.min),max:F(n.max)});case 10:return new chunkDA7M6H63_cjs.m(10,n.v);case 13:return new chunkDA7M6H63_cjs.m(13,n.code,n.message);default:throw chunkELQQKZN3_cjs.c.validation({code:M.SNAPSHOT_MALFORMED,message:`Snapshot holds a value with an unknown type tag: ${JSON.stringify(n.t)}`,expected:"a known SerializedValue type tag",found:JSON.stringify(n.t)})}}function ue(n){let e={opcodes:Array.from(n.opcodes),numbers:Array.from(n.numbers,$),strings:n.strings.slice(),hasAsync:n.hasAsync};return n.constants&&(e.constants=Array.from(n.constants.entries())),n.userFunctionBodies&&(e.userFunctionBodies=n.userFunctionBodies.map(De)),n.anonymousBodies&&(e.anonymousBodies=n.anonymousBodies.map(t=>({params:t.params.slice(),program:ue(t.program)}))),e}function pe(n){let e={opcodes:Uint8Array.from(n.opcodes),numbers:Float64Array.from(n.numbers,F),strings:n.strings.slice(),hasAsync:n.hasAsync};return n.constants&&(e.constants=new Map(n.constants)),n.userFunctionBodies&&(e.userFunctionBodies=n.userFunctionBodies.map(Ue)),n.anonymousBodies&&(e.anonymousBodies=n.anonymousBodies.map(t=>({params:t.params.slice(),program:pe(t.program)}))),e}function De(n){return {name:n.name,params:n.params.slice(),program:ue(n.program)}}function Ue(n){return {name:n.name,params:n.params.slice(),program:pe(n.program)}}function Wt(n){if(typeof n!="object"||n===null)throw chunkELQQKZN3_cjs.c.validation({code:M.SNAPSHOT_VERSION_MISMATCH,message:"fromJSON was given something that is not a snapshot object.",expected:`an object produced by ExpressionEngine.toJSON() with format "${Z}"`,found:n===null?"null":typeof n});let e=n;if(e.format!==Z)throw chunkELQQKZN3_cjs.c.validation({code:M.SNAPSHOT_VERSION_MISMATCH,message:`This object is not a solve-engine snapshot (its "format" is ${JSON.stringify(e.format)}).`,expected:`format "${Z}"`,found:JSON.stringify(e.format)});if(e.version!==G)throw chunkELQQKZN3_cjs.c.validation({code:M.SNAPSHOT_VERSION_MISMATCH,message:`This snapshot was written for format version ${e.version}, but this engine restores version ${G}.`,expected:`snapshot version ${G}`,found:`version ${e.version}`,suggestion:"Regenerate the snapshot with a matching engine version, or re-evaluate the document from source.",context:{snapshotVersion:e.version,readerVersion:G,engineVersion:e.engineVersion}});En(n);}var $t=32;function bn(n){return n===null?"null":Array.isArray(n)?`an array of ${n.length}`:typeof n=="object"?"an object":`${typeof n} ${JSON.stringify(n)}`.slice(0,80)}function d(n,e,t){throw chunkELQQKZN3_cjs.c.validation({code:M.SNAPSHOT_MALFORMED,message:`Snapshot is malformed at ${n}: expected ${e}.`,expected:e,found:bn(t),suggestion:"Regenerate the snapshot with ExpressionEngine.toJSON(), or re-evaluate the document from source.",context:{location:n}})}function z(n){return typeof n=="object"&&n!==null&&!Array.isArray(n)}function K(n){return typeof n=="number"||n==="NaN"||n==="Infinity"||n==="-Infinity"}function ce(n){return typeof n=="string"&&/^-?\d+$/.test(n)}function ve(n,e){(!Array.isArray(n)||!n.every(t=>typeof t=="string"))&&d(e,"an array of strings",n);}function zt(n,e){(!z(n)||!ce(n.coef)||typeof n.scale!="number")&&d(e,"a decimal as { coef: digits, scale: number }",n);}function vn(n,e){(!z(n)||!ce(n.n)||!ce(n.d))&&d(e,"a rational as { n: digits, d: digits }",n);}function jt(n,e){switch(z(n)||d(e,"a serialised value object",n),n.t){case 0:K(n.v)||d(`${e}.v`,"a number",n.v),n.exact!==void 0&&zt(n.exact,`${e}.exact`),n.rational!==void 0&&vn(n.rational,`${e}.rational`);return;case 1:(n.big?!ce(n.v):!K(n.v))&&d(`${e}.v`,n.big?"an integer string":"a number",n.v),n.base!==void 0&&typeof n.base!="string"&&d(`${e}.base`,"a base name",n.base);return;case 2:ce(n.v)||d(`${e}.v`,"an integer string",n.v);return;case 3:typeof n.v!="string"&&d(`${e}.v`,"a string",n.v);return;case 4:case 5:K(n.v)||d(`${e}.v`,"a number",n.v);return;case 6:K(n.v)||d(`${e}.v`,"a number",n.v),typeof n.unit!="string"&&d(`${e}.unit`,"a unit name",n.unit),n.exact!==void 0&&zt(n.exact,`${e}.exact`);return;case 7:{let{rows:t,cols:r,data:i}=n;(!Number.isInteger(t)||t<0)&&d(`${e}.rows`,"a non-negative integer",t),(!Number.isInteger(r)||r<0)&&d(`${e}.cols`,"a non-negative integer",r),(!Array.isArray(i)||i.length!==t*r)&&d(`${e}.data`,`an array of ${t} \xD7 ${r} cells`,i),i.every(s=>typeof s=="boolean"||K(s))||d(`${e}.data`,"numeric or boolean cells",i);return}case 8:(!K(n.min)||!K(n.max))&&d(e,"a range with numeric min and max",n);return;case 10:typeof n.v!="boolean"&&d(`${e}.v`,"a boolean",n.v);return;case 13:(typeof n.code!="string"||typeof n.message!="string")&&d(e,"an error with a string code and message",n);return;default:return}}function Ee(n,e,t){if(t>$t&&d(e,`function bodies nested at most ${$t} deep`,"deeper nesting"),z(n)||d(e,"a serialised program object",n),(!Array.isArray(n.opcodes)||!n.opcodes.every(r=>Number.isInteger(r)&&r>=0&&r<=255))&&d(`${e}.opcodes`,"an array of bytes (integers 0 to 255)",n.opcodes),(!Array.isArray(n.numbers)||!n.numbers.every(K))&&d(`${e}.numbers`,"an array of numbers",n.numbers),ve(n.strings,`${e}.strings`),typeof n.hasAsync!="boolean"&&d(`${e}.hasAsync`,"a boolean",n.hasAsync),n.constants!==void 0){let r=i=>Array.isArray(i)&&i.length===2&&typeof i[0]=="number"&&typeof i[1]=="number";(!Array.isArray(n.constants)||!n.constants.every(r))&&d(`${e}.constants`,"an array of [number, number] pairs",n.constants);}n.userFunctionBodies!==void 0&&(Array.isArray(n.userFunctionBodies)||d(`${e}.userFunctionBodies`,"an array of functions",n.userFunctionBodies),n.userFunctionBodies.forEach((r,i)=>Kt(r,`${e}.userFunctionBodies[${i}]`,t+1))),n.anonymousBodies!==void 0&&(Array.isArray(n.anonymousBodies)||d(`${e}.anonymousBodies`,"an array of bodies",n.anonymousBodies),n.anonymousBodies.forEach((r,i)=>{let s=`${e}.anonymousBodies[${i}]`;z(r)||d(s,"a body object",r),ve(r.params,`${s}.params`),Ee(r.program,`${s}.program`,t+1);}));}function Kt(n,e,t){z(n)||d(e,"a function object",n),typeof n.name!="string"&&d(`${e}.name`,"a function name",n.name),ve(n.params,`${e}.params`),Ee(n.program,`${e}.program`,t);}function En(n){n.locale!==void 0&&typeof n.locale!="string"&&d("locale","a locale code",n.locale),z(n.variables)||d("variables","an object of values by name",n.variables);for(let[e,t]of Object.entries(n.variables))jt(t,`variables.${e}`);Array.isArray(n.userFunctions)||d("userFunctions","an array of functions",n.userFunctions),n.userFunctions.forEach((e,t)=>Kt(e,`userFunctions[${t}]`,1)),Array.isArray(n.lineCache)||d("lineCache","an array of cached lines",n.lineCache),n.lineCache.forEach((e,t)=>{let r=`lineCache[${t}]`;z(e)||d(r,"a cached line",e),Number.isInteger(e.line)||d(`${r}.line`,"a line number",e.line),typeof e.expression!="string"&&d(`${r}.expression`,"the line's expression text",e.expression),jt(e.result,`${r}.result`),Ee(e.bytecode,`${r}.bytecode`,1),ve(e.reads,`${r}.reads`),e.writeVar!==null&&typeof e.writeVar!="string"&&d(`${r}.writeVar`,"a variable name or null",e.writeVar);}),Array.isArray(n.bytecodeCache)||d("bytecodeCache","an array of compiled expressions",n.bytecodeCache),n.bytecodeCache.forEach((e,t)=>{let r=`bytecodeCache[${t}]`;(!z(e)||typeof e.expression!="string")&&d(r,"an { expression, program } pair",e),Ee(e.program,`${r}.program`,1);});}var H=class{constructor(e,t,r,i){this.result=e;this.bytecode=t;this.readVariables=r;this.writeVariable=i;}},xe=class n{constructor(){this.byLine=new Map;this.count=0;}static exprKey(e){return e??""}static displayKey(e,t){return t===""?`${e}`:`${e}:${t}`}get(e,t){return this.byLine.get(e)?.get(n.exprKey(t))}getEntryForLine(e){let t=this.byLine.get(e);if(t)for(let r of t.values())return r}set(e,t,r){let i=this.byLine.get(e);i||(i=new Map,this.byLine.set(e,i));let s=n.exprKey(r);i.size>0&&!i.has(s)&&(this.count-=i.size,i.clear()),i.has(s)||this.count++,i.set(s,t);}has(e,t){return this.byLine.get(e)?.has(n.exprKey(t))??false}remove(e,t){let r=this.byLine.get(e);r&&r.delete(n.exprKey(t))&&(this.count--,r.size===0&&this.byLine.delete(e));}removeAllForLine(e){let t=this.byLine.get(e);t&&(this.count-=t.size,this.byLine.delete(e));}clearLine(e){this.removeAllForLine(e);}get size(){return this.count}clear(){this.byLine.clear(),this.count=0;}forEach(e){for(let[t,r]of this.byLine)for(let[i,s]of r)e(n.displayKey(t,i),s);}snapshotEntries(){let e=[];for(let[t,r]of this.byLine)for(let[i,s]of r)e.push({line:t,expression:i,entry:s});return e}keys(){let e=[];for(let[t,r]of this.byLine)for(let i of r.keys())e.push(n.displayKey(t,i));return e}};function _e(n){let e=new Date(n),t=String(e.getMonth()+1).padStart(2,"0"),r=String(e.getDate()).padStart(2,"0");return `${e.getFullYear()}-${t}-${r}`}function xn(n){if(n instanceof Date)return _e(n.getTime());if(typeof n=="number")return Number.isFinite(n)?_e(n):null;let e=/^(\d{4})-(\d{2})-(\d{2})/.exec(n.trim());return e?`${e[1]}-${e[2]}-${e[3]}`:null}function Ht(n){if(n===void 0)return;if(typeof n=="function")return t=>n(new Date(t));let e=new Set;for(let t of n){let r=xn(t);r!==null&&e.add(r);}return t=>e.has(_e(t))}function Sn(n,e){if(!n||n.type!==e.type||n.value!==e.value)return  true;let t=n.unit,r=e.unit;return t!==r}var Se=class n{constructor(e,t){this.dag=e;this.enqueue=t;this.entries=new Map;}get size(){return this.entries.size}static idOf(e,t){return JSON.stringify([e,t])}register(e){if(!(e.intervalMs>0))return;let t=n.idOf(e.packageId,e.queryKey);if(this.entries.has(t))return;let r=setInterval(()=>{this.tick(t);},e.intervalMs);r.unref?.(),this.entries.set(t,{...e,timer:r,lastValue:null,inFlight:false});}async tick(e){let t=this.entries.get(e);if(t&&!t.inFlight){if(this.isDead(t)){this.stop(e);return}t.inFlight=true;try{let r=await t.refetch(),i=this.entries.get(e);if(!i)return;r&&Sn(i.lastValue,r)&&(i.lastValue=r,this.enqueue(i.packageId,i.queryKey));}catch{}finally{let r=this.entries.get(e);r&&(r.inFlight=false);}}}isDead(e){return this.dag.getAffectedLinesByDataSource(e.packageId,[e.queryKey]).size===0}reconcile(){for(let[e,t]of this.entries)this.isDead(t)&&this.stop(e);}stop(e){let t=this.entries.get(e);t&&(clearInterval(t.timer),this.entries.delete(e));}clearAll(){for(let e of this.entries.values())clearInterval(e.timer);this.entries.clear();}};var _=class{static enable(){this.enabled=true;}static disable(){this.enabled=false;}static isEnabled(){return this.enabled}static track(e,t,r){if(!this.enabled)return {result:t(),alloc:null};let i=typeof process<"u"&&process.memoryUsage?process.memoryUsage():null,s=typeof process<"u"&&process.hrtime?process.hrtime():performance.now(),o=t(),a=typeof process<"u"&&process.hrtime?process.hrtime(s):void 0,l=typeof process<"u"&&process.memoryUsage?process.memoryUsage():null,c=a?a[0]*1e9+a[1]:(performance.now()-s)*1e6,u=i&&l?l.heapUsed-i.heapUsed:0,p={stage:e,allocCount:0,allocBytes:u,objectCounts:{},wallTimeNs:c,...r};return {result:o,alloc:p}}static generateReport(e,t){let r=[];r.push(t?`## ${t}`:"## Pipeline Allocation Report"),r.push(""),r.push(`**Runs:** ${e.length} | **Generated:** ${new Date().toISOString()}`),r.push("");let i=this.aggregate(e);if(i.length===0)return r.push("_No telemetry data._"),r.join(`
-`);r.push("### Per-Stage Breakdown"),r.push(""),r.push("| Stage | Count | Mean Wall (\xB5s) | Mean Alloc (bytes) | Min (\xB5s) | Max (\xB5s) | p50 (\xB5s) | p95 (\xB5s) | p99 (\xB5s) |"),r.push("|-------|:-----:|:--------------:|:------------------:|:--------:|:--------:|:--------:|:--------:|:--------:|");for(let l of i)r.push(`| ${l.stage} | ${l.count} | ${(l.meanWallTimeNs/1e3).toFixed(2)} | ${l.meanAllocBytes.toFixed(0)} | ${(l.minWallTimeNs/1e3).toFixed(2)} | ${(l.maxWallTimeNs/1e3).toFixed(2)} | ${(l.p50WallTimeNs/1e3).toFixed(2)} | ${(l.p95WallTimeNs/1e3).toFixed(2)} | ${(l.p99WallTimeNs/1e3).toFixed(2)} |`);let s=e.reduce((l,c)=>l+c.totalAllocBytes,0),o=e.reduce((l,c)=>l+c.totalWallTimeNs,0),a=e.filter(l=>l.fastPath).length;return r.push(""),r.push("### Totals"),r.push(""),r.push(`- **Total wall time:** ${(o/1e6).toFixed(2)} ms (${e.length} runs)`),r.push(`- **Total heap allocated:** ${s.toLocaleString()} bytes`),r.push(`- **Fast-path runs:** ${a}/${e.length} (${(a/e.length*100).toFixed(0)}%)`),r.push(`- **Mean per-run:** ${(o/e.length/1e3).toFixed(2)} \xB5s, ${(s/e.length).toFixed(0)} bytes`),r.join(`
-`)}static aggregate(e){let t=new Map;for(let i of e)for(let s of i.stages)t.has(s.stage)||t.set(s.stage,[]),t.get(s.stage).push(s);let r=[];for(let[i,s]of t){let o=s.map(c=>c.wallTimeNs).sort((c,u)=>c-u),a=s.map(c=>c.allocBytes),l=s.length;r.push({stage:i,count:l,meanAllocBytes:a.reduce((c,u)=>c+u,0)/l,meanWallTimeNs:o.reduce((c,u)=>c+u,0)/l,minWallTimeNs:o[0],maxWallTimeNs:o[o.length-1],p50WallTimeNs:Fe(o,50),p95WallTimeNs:Fe(o,95),p99WallTimeNs:Fe(o,99)});}return r.sort((i,s)=>i.stage.localeCompare(s.stage)),r}static createTelemetry(e,t,r=false){let i=t.reduce((o,a)=>o+a.allocBytes,0),s=t.reduce((o,a)=>o+a.wallTimeNs,0);return {expression:e,stages:t,totalAllocBytes:i,totalWallTimeNs:s,fastPath:r}}};_.enabled=false;function Fe(n,e){if(n.length===0)return 0;if(n.length===1)return n[0];let t=e/100*(n.length-1),r=Math.floor(t),i=Math.ceil(t);if(r===i)return n[r];let s=t-r;return n[r]*(1-s)+n[i]*s}function $e(n,e){if(n.length>e.maxExpressionLength){let t=chunkELQQKZN3_cjs.c.validation("EXPRESSION_TOO_LONG",`Expression exceeds max length of ${e.maxExpressionLength} characters (got ${n.length})`,{expressionLength:n.length,maxLength:e.maxExpressionLength});return {passed:false,error:{value:chunkDA7M6H63_cjs.n(0),tokens:[],program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},error:t.message,engineError:t}}}return {passed:true}}function ze(n,e){let t=0,r=0,i=0;for(let o of n)o.type==="FUNC"&&t++,(o.value==="("||o.type==="LPAREN")&&(r++,i=Math.max(i,r)),(o.value===")"||o.type==="RPAREN")&&r--;let s=n.length+t*5+i*10;if(s>e.maxComplexity){let o=chunkELQQKZN3_cjs.c.validation("EXPRESSION_TOO_COMPLEX",`Expression complexity score ${s} exceeds maximum of ${e.maxComplexity}`,{complexity:s,maxComplexity:e.maxComplexity});return {passed:false,complexityScore:s,errorMessage:o.message,engineError:o}}return {passed:true,complexityScore:s}}function fe(n){return n.type==="IDENT"||n.type==="UNIT"}function kn(n){return n.type==="NUMBER"||n.type==="TO"||n.type==="IN"||n.type==="RPAREN"}function qt(n,e){let t=0;for(let r=e;r<n.length;r++)if(n[r].type==="LPAREN")t++;else if(n[r].type==="RPAREN"&&(t--,t===0))return r;return null}function Cn(n){let e=new Set;for(let t=0;t<n.length;t++){if(!fe(n[t])||t>0&&n[t-1].type==="COLON"||n[t+1]?.type!=="LPAREN")continue;let r=qt(n,t+1);if(r!==null&&n[r+1]?.type==="EQUALS")for(let i=t+2;i<r;i++)fe(n[i])&&e.add(n[i].value);}return e}function ke(n){let e=[],t=[],r=Cn(n);for(let i=0;i<n.length;i++){let s=n[i];if(s.type==="GLOBAL"){if(i+2<n.length&&n[i+1].type==="COLON"&&fe(n[i+2])){let o=chunkAUOE7MFI_cjs.K(n[i+2].value);e.push(o),i+3<n.length&&n[i+3].type==="EQUALS"&&t.push(o);}continue}if(s.type==="COLON"){if(i>0&&n[i-1].type==="GLOBAL")continue;if(i+1<n.length&&fe(n[i+1])){let o=n[i+1].value;e.push(o),i+2<n.length&&n[i+2].type==="EQUALS"&&t.push(o);}}if(fe(s)){if(i>0&&n[i-1].type==="COLON"||s.type==="UNIT"&&i>0&&kn(n[i-1])||r.has(s.value))continue;if(n[i+1]?.type==="LPAREN"){let a=qt(n,i+1);if(a!==null&&n[a+1]?.type==="EQUALS"){e.push(s.value),t.push(s.value);continue}}e.push(s.value);let o=n[i+1]?.type;(o==="EQUALS"||o==="PLUS_EQUALS"||o==="MINUS_EQUALS")&&t.push(s.value);}}return {reads:e,writes:t}}function cr(n){return chunkIHAZL4EF_cjs.c.classifyLine(n).skip}function ur(n,e){return chunkIHAZL4EF_cjs.c.findInlineSolves(n).map(r=>({start:r.start,end:r.end,expression:r.expression,lineNumber:e,columnNumber:r.columnNumber}))}function Gt(n){let e=n[n.length-1],t=e.length>1&&e.endsWith("s")?e.slice(0,-1):e;return [...n.slice(0,-1),t].join(" ")}var Ce=class{constructor(){this.byKey=new Map;this.longestName=0;}get isEmpty(){return this.byKey.size===0}get maxWordCount(){return this.longestName}define(e,t,r){let i=Gt(e);this.byKey.set(i,{displayName:e.join(" "),ratioText:t,baseUnit:r}),e.length>this.longestName&&(this.longestName=e.length);}match(e){let t=Math.min(e.length,this.longestName);for(let r=t;r>=1;r--){let i=this.byKey.get(Gt(e.slice(0,r)));if(i!==void 0)return {definition:i,wordCount:r}}return null}clear(){this.byKey.clear(),this.longestName=0;}};function Qt(n,e=82){return {name:"uom:user-unit",priority:e,shape:[{types:["NUMBER","RPAREN"]},{types:["IDENT"]}],match(t,r){if(n.isEmpty)return null;let i=t[r];if(i.type!=="NUMBER"&&i.type!=="RPAREN")return null;let s=[],o=n.maxWordCount;for(let f=r+1;f<t.length&&s.length<o&&t[f].type==="IDENT";f++)s.push(t[f].value);if(s.length===0)return null;let a=n.match(s);if(a===null||t[r+1+a.wordCount]?.type==="EQUALS")return null;let{ratioText:c,baseUnit:u}=a.definition,p=new chunkUPH22K2T_cjs.a("STAR",chunk5IJD5L3O_cjs.c("STAR"),"*","*",i.offset,0,i.line,i.col),m=new chunkUPH22K2T_cjs.a("NUMBER",chunk5IJD5L3O_cjs.c("NUMBER"),c,c,i.offset,0,i.line,i.col),y=new chunkUPH22K2T_cjs.a("UNIT",chunk5IJD5L3O_cjs.c("UNIT"),u,u,i.offset,0,i.line,i.col);return {consumed:1+a.wordCount,replacement:[i,p,m,y],ruleName:"uom:user-unit"}}}}var Xt="engine:call-fusion";function Jt(n,e=80){return {name:Xt,priority:e,startTokenTypes:["IDENT"],match(t,r){let i=t[r];if(!i||i.type!=="IDENT"||t[r+1]?.type!=="LPAREN"||t[r-1]?.type==="COLON")return null;let s=(i.value??"").toLowerCase(),o=n.get(s);return o===void 0?null:{consumed:1,replacement:[new chunkUPH22K2T_cjs.a(o,chunk5IJD5L3O_cjs.c(o),s,i.value,i.offset,0,i.line,i.col)],ruleName:Xt}}}}var wn=30,Tn=40,Nn=50,Rn=24;function An(n){switch(n){case chunk5IJD5L3O_cjs.a.PLUS:case chunk5IJD5L3O_cjs.a.MINUS:return wn;case chunk5IJD5L3O_cjs.a.STAR:case chunk5IJD5L3O_cjs.a.SLASH:case chunk5IJD5L3O_cjs.a.MOD:case chunk5IJD5L3O_cjs.a.OF:return Tn;case chunk5IJD5L3O_cjs.a.CARET:return Nn;case chunk5IJD5L3O_cjs.a.PCT_ON:case chunk5IJD5L3O_cjs.a.PCT_OFF:return Rn;default:return 0}}function Pn(n){switch(n){case chunk5IJD5L3O_cjs.a.PLUS:return "plus";case chunk5IJD5L3O_cjs.a.MINUS:return "minus";case chunk5IJD5L3O_cjs.a.STAR:return "times";case chunk5IJD5L3O_cjs.a.SLASH:return "divided by";case chunk5IJD5L3O_cjs.a.MOD:return "mod";case chunk5IJD5L3O_cjs.a.CARET:return "to the power of";case chunk5IJD5L3O_cjs.a.OF:return "of";case chunk5IJD5L3O_cjs.a.PCT_ON:return "plus";case chunk5IJD5L3O_cjs.a.PCT_OFF:return "less";default:return n.toLowerCase()}}function Yt(n){return n.sourceEnd??n.offset+n.value.length}var Ln=new Set([chunk5IJD5L3O_cjs.a.NUMBER,chunk5IJD5L3O_cjs.a.BIGINT,chunk5IJD5L3O_cjs.a.IDENT,chunk5IJD5L3O_cjs.a.UNIT,chunk5IJD5L3O_cjs.a.PERCENT,chunk5IJD5L3O_cjs.a.PI,chunk5IJD5L3O_cjs.a.E,chunk5IJD5L3O_cjs.a.TRUE,chunk5IJD5L3O_cjs.a.FALSE,chunk5IJD5L3O_cjs.a.DOLLAR,chunk5IJD5L3O_cjs.a.POUND,chunk5IJD5L3O_cjs.a.EURO,chunk5IJD5L3O_cjs.a.YEN,chunk5IJD5L3O_cjs.a.RUBLE,chunk5IJD5L3O_cjs.a.WON,chunk5IJD5L3O_cjs.a.CURRENCY_SYMBOL]);function On(n){return !Ln.has(n)}var je=class{constructor(e){this.tokens=e;this.pos=0;}peek(){return this.tokens[this.pos]}next(){return this.tokens[this.pos++]}parseAll(){let e=this.parseExpression(0);if(this.pos!==this.tokens.length)throw new Error("explain: unconsumed tokens");return e}parseExpression(e){let t=this.parseOperand();for(;;){let r=this.peek();if(!r)break;let i=An(r.type);if(i===0||i<=e)break;this.next();let s=r.type===chunk5IJD5L3O_cjs.a.CARET?i-1:i,o=this.parseExpression(s);t={kind:"binary",op:r.type,left:t,right:o,start:t.start,end:o.end};}return t}parseOperand(){let e=this.peek();if(!e)throw new Error("explain: expected an operand");if(e.type===chunk5IJD5L3O_cjs.a.LPAREN)return this.parseGroup();let t=e.offset,r=false;for(;this.peek()&&(this.peek().type===chunk5IJD5L3O_cjs.a.PLUS||this.peek().type===chunk5IJD5L3O_cjs.a.MINUS);)this.next(),r=true;if(r&&this.peek()&&this.peek().type===chunk5IJD5L3O_cjs.a.LPAREN){let s=this.parseGroup();return {kind:"wrap",child:s,start:t,end:s.end}}let i=-1;for(;this.peek()&&!On(this.peek().type);)i=Yt(this.next());if(i===-1)throw new Error("explain: expected an operand");return {kind:"leaf",start:t,end:i}}parseGroup(){let e=this.next(),t=this.parseExpression(0),r=this.peek();if(!r||r.type!==chunk5IJD5L3O_cjs.a.RPAREN)throw new Error("explain: unbalanced parentheses");return this.next(),{kind:"wrap",child:t,start:e.offset,end:Yt(r)}}},We=class{constructor(e,t,r){this.source=e;this.evaluate=t;this.steps=[];this.cache=new Map;this.resultPrefix=chunkS3DFU33X_cjs.a(r).display.resultPrefix;}build(e){return this.emit(e),{steps:this.steps,result:this.valueOf(e)}}emit(e){if(e.kind!=="leaf"){if(e.kind==="wrap"){this.emit(e.child);return}this.emit(e.left),this.emit(e.right),this.steps.push({description:this.describe(e),value:this.valueOf(e)});}}describe(e){let t=Pn(e.op);return e.op===chunk5IJD5L3O_cjs.a.PCT_ON||e.op===chunk5IJD5L3O_cjs.a.PCT_OFF?`${this.operand(e.right)} ${t} ${this.operand(e.left)}`:`${this.operand(e.left)} ${t} ${this.operand(e.right)}`}operand(e){return e.kind==="leaf"?this.source.slice(e.start,e.end).trim():this.render(this.valueOf(e))}valueOf(e){let t=this.cache.get(e);if(t)return t;let r=this.evaluate(this.source.slice(e.start,e.end));return this.cache.set(e,r),r}render(e){let t=chunkF7QIBC4B_cjs.c(e,chunkF7QIBC4B_cjs.a);return t.startsWith(this.resultPrefix)?t.slice(this.resultPrefix.length):t}};function Ke(n){let{expression:e,tokens:t,evaluate:r,locale:i}=n,s=()=>({expression:e,steps:[],result:r(e)}),o;try{o=new je(t).parseAll();}catch{return s()}try{let{steps:a,result:l}=new We(e,r,i).build(o);return {expression:e,steps:a,result:l}}catch{return s()}}var Q=class Q{constructor(e={}){this.dag=new chunkRMCN5WFO_cjs.a;this.lineCache=new xe;this.accumulatorNames=new Set;this.scopeManager=new chunkRMCN5WFO_cjs.b;this.resolverRegistry=new chunkZVPZQ66D_cjs.a;this.packageContributions=new Map;this.registeredPackages=new Map;this.callFusions=new Map;this.compatIndex=new be;this.documentModel=null;this.goalSeekDepth=0;this.batchScanResults=null;this.batchParsedLines=null;this.packageCompletionItems=new Map;this.keystrokeSignal=null;this.backgroundRefreshSignal=new AbortController().signal;this.userUnits=new Ce;this.bytecodeCache=new Map;this.pluginFunctionIndexByName=new Map;this.builderPool=[new chunk5GL4SAVH_cjs.d(this.pluginFunctionIndexByName),new chunk5GL4SAVH_cjs.d(this.pluginFunctionIndexByName),new chunk5GL4SAVH_cjs.d(this.pluginFunctionIndexByName),new chunk5GL4SAVH_cjs.d(this.pluginFunctionIndexByName)];this.builderPoolIndex=0;this.lastTelemetry=null;let{locale:t="en",diagnostics:r=false,config:i,packages:s}=e;this.localeCode=t,this.config=chunkUY3ID6JF_cjs.c(chunkUY3ID6JF_cjs.b,i??{}),this.lexer=new chunkIHAZL4EF_cjs.b(t,chunkIHAZL4EF_cjs.d(t)),this.registry=new chunkS46R5QZP_cjs.b,this.context=chunkAUOE7MFI_cjs.x({networkEnabled:this.config.network.enabled}),r?(this.diagnosticPipeline=new chunkHG4NPDN5_cjs.a,this.timelineCollector=new chunkHG4NPDN5_cjs.b,this.diagnosticPipeline.register(this.timelineCollector)):this.diagnosticPipeline=new chunkHG4NPDN5_cjs.a,this.normalizer=new chunk72N3ZRVE_cjs.c;for(let[a,l]of Object.entries(chunkUPH22K2T_cjs.c))this.normalizer.addPhrase(a,l);this.normalizer.register(chunk72N3ZRVE_cjs.d(50,a=>this.normalizer.canStartPhrase(a))),this.normalizer.register(Qt(this.userUnits)),this.normalizer.register(Jt(this.callFusions));let o=s??[];for(let a of o)try{this.registerPackage(a);}catch(l){let c=chunkELQQKZN3_cjs.d(l);console.error(`[ExpressionEngine] Failed to register package "${a.name}" \u2014 skipping it and continuing construction with the remaining packages: ${c.format()}`);}this.registry.hasPrefix("DATETIME_LITERAL")&&this.normalizer.register(chunkLTJV3VJE_cjs.h(()=>this.config.date.inputOrder)),this.parser=new chunkS46R5QZP_cjs.a(this.registry,this.config.validation.maxNestingDepth,t,this.pluginFunctionIndexByName),this.vm=chunkRMCN5WFO_cjs.c(this.context.opRegistry,this.config.vm.maxStackDepth,this.config.vm.maxInstructions,void 0,this.config.vm.maxCollectionSize,this.config.vm.maxAllocatedElements,this.config.vm.maxFunctionCalls,this.config.date.maxOffsetYears,this.config.date.minOffsetYears,this.context,Ht(this.config.date.holidays)),this.queryClient=chunkZLRJ7TDP_cjs.c(),this.batcher=new Te(this.dag,this.lineCache,this.vm),this.backgroundRefresh=this.config.backgroundRefresh.enabled?new Se(this.dag,(a,l)=>this.batcher.add({queryKey:l,packageId:a,signal:this.backgroundRefreshSignal,isError:false})):null,e.warmup===true&&this.warmUp();}setDocumentModel(e){this.documentModel=e;}getDocumentModel(){return this.documentModel}warmUp(){let e=new chunk5GL4SAVH_cjs.d(this.pluginFunctionIndexByName);for(let t of Q.WARMUP_EXPRESSIONS)try{this.lexer.resetExpression(t);let r=[];for(let o of this.lexer)o.type!=="COMMENT"&&r.push(o);let i=this.normalizer.normalize(r);e.reset(),this.parser.load(i),this.parser.parseExpression(0,e);let s=e.build();this.vm.reset(),chunkRMCN5WFO_cjs.d(s,this.vm);}catch{}this.vm.reset();}makeLineContext(e){let t=this.documentModel,r=t?null:this.batchScanResults,i=t?null:this.batchParsedLines;return {lineIndex:e,getLineResult:t?s=>t.getLineAt(s)?.result??void 0:i?s=>i[s-1]?.result??void 0:void 0,isLineBoundary:t?s=>{let o=t.getLineAt(s);return o?o.isEmpty||/^\s*#/.test(o.text):true}:r?s=>{let o=r[s-1];return o?o.classification.skip||/^\s*#/.test(o.text):true}:void 0,getLineReads:t?s=>{let o=t.getLineAt(s);if(!(!o||o.bytecodes.length===0))return o.reads}:void 0,evaluateLineWithBinding:t?(s,o,a,l)=>this.evaluateLineWithBinding(s,o,a,l):void 0,goalSeekMaxIterations:this.config.vm.maxGoalSeekIterations,networkEnabled:this.config.network.enabled,getLineText:t?s=>t.getLineAt(s)?.text:r?s=>r[s-1]?.text:void 0}}evaluateLineWithBinding(e,t,r,i){let s=this.documentModel;if(!s)return chunkDA7M6H63_cjs.P("GOAL_SEEK_NO_DOCUMENT","Goal seek needs a document to solve against, which the single-expression entry point does not have.");if(this.goalSeekDepth>=Q.GOAL_SEEK_MAX_NESTING_DEPTH)return chunkDA7M6H63_cjs.P("GOAL_SEEK_NESTED","A goal-seek line cannot target another goal-seek line, since each already re-runs its target many times.");let o=s.getLineAt(e);if(!o||o.bytecodes.length===0)return chunkDA7M6H63_cjs.P("GOAL_SEEK_LINE_NOT_READY",`Line ${e} has no evaluated expression to solve (forward reference, out of range, or not an expression).`);if(o.isVariableDef)return chunkDA7M6H63_cjs.P("GOAL_SEEK_TARGET_IS_DEFINITION",`Line ${e} defines a variable, so re-running it would overwrite that variable. Target the line that uses ${t}, not the one that sets a value.`);let a=o.bytecodes[0];this.goalSeekDepth++;try{let l=new Map([[t,r]]),c=this.vm.getStack().length;this.vm.pushCallFrame(l);try{let u=chunkRMCN5WFO_cjs.d(a,this.vm,void 0,void 0,this.makeLineContext(e),i);return u.type==="pending"?chunkDA7M6H63_cjs.P("GOAL_SEEK_ASYNC_UNSUPPORTED",`Line ${e} depends on an async value (weather, stocks, currency, ...), which goal seek cannot re-run.`):u.type==="error"?chunkDA7M6H63_cjs.P(u.error.code??"GOAL_SEEK_TARGET_ERROR",u.error.message):u.value}finally{for(this.vm.popCallFrame();this.vm.getStack().length>c;)this.vm.pop();}}catch(l){return chunkDA7M6H63_cjs.P("GOAL_SEEK_TARGET_ERROR",chunkELQQKZN3_cjs.d(l).message)}finally{this.goalSeekDepth--;}}cacheBytecode(e,t){let r=this.config.performance.defaultCacheSize;if(this.bytecodeCache.size>=r){let i=this.bytecodeCache.keys().next().value;i!==void 0&&this.bytecodeCache.delete(i);}this.bytecodeCache.set(e,t);}getEventStream(){return this.batcher.getEventStream()}getBatcher(){return this.batcher}registerPackage(e){Dt(e),this.packageContributions.has(e.name)&&(console.warn(`[ExpressionEngine] Package "${e.name}" is already registered. Unregistering the previous registration before re-registering.`),this.unregisterPackage(e.name));let t=this.compatIndex.check(e);for(let i of t)(i.severity==="error"?console.error:console.warn)(`[ExpressionEngine] Package compatibility ${i.severity} (${i.kind}): ${i.detail}`);let r={pluginFunctionIndices:[],pluginFunctionNames:[],resolverNamespaces:[],tokenCategories:[],lexerVocabulary:e.lexerVocabulary,asConverterNames:[],normalizerRuleNames:[],callFusionNames:[]};if(e.lexerVocabulary&&this.lexer.registerVocabulary(e.lexerVocabulary),e.prefixParselets)for(let[i,s]of Object.entries(e.prefixParselets))this.registry.registerPrefix(i,s);if(e.infixParselets)for(let[i,s]of Object.entries(e.infixParselets))this.registry.registerInfix(i,s);if(e.pluginFunctions)for(let[i,s]of Object.entries(e.pluginFunctions)){let o=chunkAUOE7MFI_cjs.F(`${e.name}:${i}`);this.context.pluginFunctions[o]=s,this.context.pluginFunctionOwners[o]=e.name,this.pluginFunctionIndexByName.set(i,o),r.pluginFunctionIndices.push(o),r.pluginFunctionNames.push(i);}if(e.asyncResolvers)for(let i of e.asyncResolvers)this.resolverRegistry.register(i),r.resolverNamespaces.push(i.namespace);if(e.phrases)for(let[i,s]of Object.entries(e.phrases))this.normalizer.addPhrase(i,s);if(e.normalizerRules)for(let i of e.normalizerRules)this.normalizer.register(i),r.normalizerRuleNames.push(i.name);if(e.callFusions)for(let[i,s]of Object.entries(e.callFusions)){let o=i.toLowerCase();this.callFusions.set(o,s),r.callFusionNames.push(o);}if(e.tokenCategories)for(let[i,s]of Object.entries(e.tokenCategories))chunkY7O4D3BJ_cjs.b(i,s),r.tokenCategories.push(i);if(e.completionItems&&this.packageCompletionItems.set(e.name,e.completionItems),e.asConverters)for(let[i,s]of Object.entries(e.asConverters))chunkAUOE7MFI_cjs.H(i,s),r.asConverterNames.push(i);this.packageContributions.set(e.name,r),this.registeredPackages.set(e.name,e),this.compatIndex.add(e);}unregisterPackage(e){let t=this.packageContributions.get(e);if(!t)return  false;for(let r of t.pluginFunctionIndices)delete this.context.pluginFunctions[r],delete this.context.pluginFunctionOwners[r];for(let r of t.pluginFunctionNames)this.pluginFunctionIndexByName.delete(r);for(let r of t.resolverNamespaces)this.resolverRegistry.unregister(r);for(let r of t.tokenCategories)chunkY7O4D3BJ_cjs.c(r);t.lexerVocabulary&&this.lexer.unregisterVocabulary(t.lexerVocabulary);for(let r of t.asConverterNames)chunkAUOE7MFI_cjs.I(r);for(let r of t.normalizerRuleNames)this.normalizer.unregister(r);for(let r of t.callFusionNames)this.callFusions.delete(r);return this.packageCompletionItems.delete(e),this.packageContributions.delete(e),this.registeredPackages.delete(e),this.compatIndex.rebuild(this.registeredPackages.values()),this.bytecodeCache.clear(),true}getConfig(){return {...this.config}}getDiagnosticPipeline(){return this.diagnosticPipeline}storeLineResult(e,t,r,i,s,o){this.lineCache.set(e,new H(t,r,i,s.length>0?s[0]:null),o);}executeAndStore(e,t,r,i,s,o,a,l){let c=this.vm.getStack().length,u=new AbortController,p=()=>u.abort();this.keystrokeSignal?.addEventListener("abort",p,{once:true}),chunkTTFO4YDP_cjs.a.localControllerCreated("executeAndStore"),this.keystrokeSignal&&chunkTTFO4YDP_cjs.a.signalLinked("executeAndStore"),this.vm.activeSignal=u.signal,this.vm.abortCurrent=()=>{chunkTTFO4YDP_cjs.a.signalUnlinked("executeAndStore"),this.keystrokeSignal?.removeEventListener("abort",p),u.abort();},chunkZLRJ7TDP_cjs.a(this.queryClient);let m=chunkRMCN5WFO_cjs.d(e,this.vm,a,l,this.makeLineContext(t));for(;this.vm.getStack().length>c;)this.vm.pop();if(m.type==="pending"){this.resolveAsync(m),this.dag.registerLineDataSourceDependency(t,m.packageId||o,[m.queryKey]);let y=chunkDA7M6H63_cjs.O(m.queryKey);return this.storeLineResult(t,y,e,i,s,r),y}if(m.type==="error")throw this.keystrokeSignal?.removeEventListener("abort",p),m.error;return this.keystrokeSignal?.removeEventListener("abort",p),this.dag.registerLine(t,i,s),this.storeLineResult(t,m.value,e,i,s,r),m.value}executeRaw(e,t=-1){let r=this.vm.getStack().length,i=new AbortController,s=()=>i.abort();this.keystrokeSignal?.addEventListener("abort",s,{once:true}),chunkTTFO4YDP_cjs.a.localControllerCreated("executeRaw"),this.keystrokeSignal&&chunkTTFO4YDP_cjs.a.signalLinked("executeRaw"),this.vm.activeSignal=i.signal,this.vm.abortCurrent=()=>{chunkTTFO4YDP_cjs.a.signalUnlinked("executeRaw"),this.keystrokeSignal?.removeEventListener("abort",s),i.abort();},chunkZLRJ7TDP_cjs.a(this.queryClient);let o=chunkRMCN5WFO_cjs.d(e,this.vm,void 0,void 0,this.makeLineContext(t));for(;this.vm.getStack().length>r;)this.vm.pop();return o.type!=="pending"&&this.keystrokeSignal?.removeEventListener("abort",s),o}async resolveAsync(e){let{queryKey:t,resolver:r,packageId:i,signal:s}=e,o=i||"_engine";try{if(await r,s.aborted){chunkTTFO4YDP_cjs.a.staleDataDiscarded(t,"signal aborted after resolve");return}this.batcher.add({queryKey:t,packageId:o,signal:s,isError:!1});}catch(a){if(s.aborted){chunkTTFO4YDP_cjs.a.staleDataDiscarded(t,"signal aborted after error");return}let l=a instanceof Error?a:new Error(String(a));this.batcher.add({queryKey:t,packageId:o,signal:s,isError:true,error:l});}}registerBackgroundRefresh(e){this.backgroundRefresh&&(e.refetchIntervalMs===void 0||!e.refetch||this.backgroundRefresh.register({packageId:e.packageId||"_engine",queryKey:e.queryKey,intervalMs:e.refetchIntervalMs,refetch:e.refetch}));}getBackgroundRefreshCount(){return this.backgroundRefresh?.size??0}parseDocument(e,t={inputType:"markdown"}){let r=this.config.performance.maxDocumentLines;if(chunkUURM7P3P_cjs.b(e,r)>r)throw chunkELQQKZN3_cjs.c.execution("DOCUMENT_TOO_LARGE",`This document has more than ${r.toLocaleString("en-US")} lines, which is the most the engine will process in one pass`,{maxLines:r});this.userUnits.isEmpty||this.bytecodeCache.clear(),this.userUnits.clear(),this.resetAccumulators();let i=this.lexer.scanDocument(e),s=this.processScanResults(i),o={lines:s,totalLines:s.length,errors:[]};for(let l of s){l.error&&o.errors.push(`Line ${l.lineNumber}: ${l.error}`);for(let c of l.inlineSolves)c.error&&o.errors.push(`Line ${l.lineNumber}: ${c.error}`);}if(t.includeDiagnostics??false){let l=this.diagnosticPipeline.collectReports();l.length>0&&(o.diagnostics=l[0].toJSON());}return o}evaluateLines(e){this.userUnits.isEmpty||this.bytecodeCache.clear(),this.userUnits.clear(),this.resetAccumulators();let t=e.join(`
-`),r=this.lexer.scanDocument(t);return this.processScanResults(r)}processScanResults(e){let t=[],r=this.batchScanResults,i=this.batchParsedLines;this.batchScanResults=e,this.batchParsedLines=t;try{for(let s of e){let o=s.text,a=s.lineNumber,l=s.startOffset,c=s.endOffset,u=s.classification.skip,p=s.inlineSolves.map(f=>({start:f.start,end:f.end,expression:f.expression,lineNumber:a,columnNumber:f.columnNumber})),m=p.length>0,y={lineNumber:a,text:o,startPosition:l,endPosition:c,isEmpty:u,hasInlineSolves:m,inlineSolves:p,expression:null,result:null,error:null};if(!u){let f=o.trim().startsWith(":");if(m&&!f)for(let P of p)try{P.result=this.evaluateLine(a,P.expression);}catch(I){let V=I instanceof Error?I.message:String(I);P.error=V;}else {let P=s.classification.contentOffset,V=(P===void 0?o:o.slice(P-l)).trim();if(V)try{let x=this.evaluateLineWithPreTokenized(a,V,s.tokens);y.expression=V,y.result=x[0];}catch(x){let ne=x instanceof Error?x.message:String(x);y.error=ne;}}}t.push(y);}}finally{this.batchScanResults=r,this.batchParsedLines=i;}return t}evaluateLineWithPreTokenized(e,t,r){let i=[],s=false;for(let o of r)(o.type==="LPAREN"||o.type==="RPAREN")&&(s=true),i.push(o);return [this.evaluateWithTokens(e,t,i,s)]}parseExpression(e,t,r,i=true){this.parser.setBuilder(e),this.parser.load(t,this.config.validation.autoBalanceParens?r:false),this.parser.parseExpression(0);let s=this.parser.peek();if(s){if(s.type==="EQUALS"&&!this.parser.peekAt(1))return;for(let o=i?t.length-1:0;o>=1;o--){if(t[o].type!=="COLON"||o+1>=t.length)continue;let a=true;for(let l=0;l<o;l++){let c=t[l].type;if(c!=="NUMBER"&&c!=="COLON"){a=false;break}}if(a){let l=t.slice(0,o+2).map(c=>c.value).join("");throw chunkELQQKZN3_cjs.c.parsing("INVALID_TIME_LITERAL",`"${l}" is not a valid time`,{tokenType:t[o].type,tokenValue:l})}e.reset();try{this.parseExpression(e,t.slice(o+1),r,!1);return}catch{}}throw chunkELQQKZN3_cjs.c.parsing("UNEXPECTED_TRAILING_TOKEN",`Unexpected token after expression: "${s.value}"`,{tokenType:s.type,tokenValue:s.value})}}compileAdHoc(e){let t=new chunk5GL4SAVH_cjs.d(this.pluginFunctionIndexByName);return this.parseExpression(t,e),t.build()}executeSymbolicTolerant(e,t=-1){let r=chunkRMCN5WFO_cjs.d(e,this.vm,void 0,void 0,this.makeLineContext(t),true);if(r.type==="error")throw r.error;if(r.type==="pending")throw chunkELQQKZN3_cjs.c.execution("THEREFORE_ASYNC_UNSUPPORTED",`"=>" doesn't support expressions that call an async operation (weather/stocks/currency).`);return r.value}simplifySymbolically(e,t=-1){return this.executeSymbolicTolerant(this.compileAdHoc(e),t)}parseFactorChain(e){if(e.length===0||e.length%2===0)return null;let t=[];for(let r=0;r<e.length;r++)if(r%2===0){if(e[r].type!=="IDENT"&&e[r].type!=="UNIT")return null;t.push(e[r].value);}else if(e[r].type!=="STAR")return null;return t}solveEquation(e,t=-1){let r=[];for(let a of e.factorNames){let l=this.vm.getVar(a);if(l===void 0)return chunkDA7M6H63_cjs.P("EQUATION_FACTOR_UNDEFINED",`Cannot solve for "${e.variable}": "${a}" is not yet defined.`);if(l.type!==7)return chunkDA7M6H63_cjs.P("EQUATION_FACTOR_NOT_MATRIX",`Cannot solve for "${e.variable}": "${a}" must be a Matrix (got a different value type).`);r.push(l);}let i=r[0].value;for(let a=1;a<r.length;a++){let l=chunk2VE4OW4A_cjs._(i,r[a].value);if(l.type===13)return l;i=l.value;}let s=chunk2VE4OW4A_cjs.da(i);if(s.type===13)return s;let o=this.executeSymbolicTolerant(e.rhsProgram,t);return o.type!==7?chunkDA7M6H63_cjs.P("EQUATION_RHS_NOT_MATRIX",`Cannot solve for "${e.variable}": the right-hand side must be a Matrix.`):chunk2VE4OW4A_cjs._(s.value,o.value)}tryDefineUserUnit(e){if(e.length<5||e[0].type!=="NUMBER"||Number(e[0].value)!==1)return null;let t=1;e[t].type==="STAR"&&t++;let r=[];for(;t<e.length&&e[t].type==="IDENT";)r.push(e[t].value),t++;if(r.length===0||e[t]?.type!=="EQUALS"||(t++,e[t]?.type!=="NUMBER"))return null;let i=e[t];if(t++,e[t]?.type!=="UNIT")return null;let s=e[t];return t++,t!==e.length?null:(this.userUnits.define(r,i.value,s.value),this.bytecodeCache.clear(),chunkDA7M6H63_cjs.t(`${r.join(" ")} defined`))}tryCompoundAssignment(e,t=-1){if(e.length<2)return null;let r=e[0],i=e[1],s=r.type==="IDENT"||r.type==="UNIT",o=i.type==="PLUS_EQUALS"||i.type==="MINUS_EQUALS";if(!s||!o)return null;let a=e.slice(2);if(a.length===0)throw chunkELQQKZN3_cjs.c.parsing("COMPOUND_ASSIGN_REQUIRES_EXPRESSION",`"${r.value} ${i.value}" needs an expression on the right, e.g. "${r.value} ${i.value} 10".`);let l=r.value;this.accumulatorNames.add(l),this.vm.getVar(l)===void 0&&this.vm.setVar(l,chunkDA7M6H63_cjs.n(0));let c=i.type==="PLUS_EQUALS"?{type:"PLUS",text:"+"}:{type:"MINUS",text:"-"},u=[chunk72N3ZRVE_cjs.b("IDENT",l,[r]),chunk72N3ZRVE_cjs.b(c.type,c.text,[i]),chunk72N3ZRVE_cjs.b("LPAREN","(",[i]),...a,chunk72N3ZRVE_cjs.b("RPAREN",")",[i])],p=chunkRMCN5WFO_cjs.d(this.compileAdHoc(u),this.vm,void 0,void 0,this.makeLineContext(t),false);if(p.type==="error")throw p.error;if(p.type==="pending")throw chunkELQQKZN3_cjs.c.execution("COMPOUND_ASSIGN_ASYNC_UNSUPPORTED","A running total (+= / -=) cannot use an async operation (weather/stocks/currency) on its right-hand side.");return this.vm.setVar(l,p.value),p.value}resetAccumulators(){for(let e of this.accumulatorNames)this.vm.deleteVar(e);return this.accumulatorNames}trySymbolicGrammar(e,t=-1){if(e.length===0)return null;if(e[e.length-1].type==="THEREFORE"){let c=e.slice(0,-1);if(c.length===0)throw chunkELQQKZN3_cjs.c.parsing("THEREFORE_REQUIRES_EXPRESSION",'"=>" needs an expression or variable name before it.');if(c.length===1&&(c[0].type==="IDENT"||c[0].type==="UNIT")){let u=c[0].value,p=this.vm.getEquation(u),m=this.vm.getScalarEquation(u);if(p){let y=this.solveEquation(p,t);if(!(y.type===13&&y.value==="EQUATION_FACTOR_NOT_MATRIX")||!m)return y}if(m)return this.solveScalarEquation(m,t)}return this.simplifySymbolically(c,t)}if(chunkLTJV3VJE_cjs.b(e))return this.simplifySymbolically(e,t);if(e[0].type==="COLON"||e[0].type==="GLOBAL"||e[0].type==="GOAL_SEEK")return null;let i=e.findIndex(c=>c.type==="EQUALS");if(i===-1)return null;let s=this.parseFactorChain(e.slice(0,i));if(s===null)return this.tryStoreScalarEquation(e,i);let o=e.slice(i+1);if(s.length===1){let c=this.simplifySymbolically(o,t);return this.vm.setVar(s[0],c),c}let a=s[s.length-1],l=s.slice(0,-1);return this.vm.defineEquation(a,l,this.compileAdHoc(o)),this.vm.defineScalarEquation(a,this.compileAdHoc(e.slice(0,i)),this.compileAdHoc(o)),chunkDA7M6H63_cjs.t(`${a} stored as an equation \u2014 solve with "${a} =>"`)}tryStoreScalarEquation(e,t){if(e[1]?.type==="LPAREN"||t===0||t===e.length-1)return null;let r=e.slice(0,t),i=e.slice(t+1);if(i.some(a=>a.type==="EQUALS"))return null;let s=this.equationUnknowns(r,i);if(s.length!==1)return null;let o=s[0];return this.vm.defineScalarEquation(o,this.compileAdHoc(r),this.compileAdHoc(i)),chunkDA7M6H63_cjs.t(`${o} stored as an equation \u2014 solve with "${o} =>"`)}equationUnknowns(e,t){let r=[];for(let i of [...e,...t])i.type!=="IDENT"&&i.type!=="UNIT"||this.vm.getVar(i.value)===void 0&&(this.vm.hasUserFunction(i.value)||r.includes(i.value)||r.push(i.value));return r}solveScalarEquation(e,t=-1){let r=this.executeSymbolicTolerant(e.lhsProgram,t),i=this.executeSymbolicTolerant(e.rhsProgram,t);return chunkAUOE7MFI_cjs.i(r,i,e.variable)}lexToTokens(e,t){let r=[],i=false;this.lexer.resetExpression(e);for(let s of this.lexer)s.type!=="COMMENT"&&((s.type==="LPAREN"||s.type==="RPAREN")&&(i=true),r.push(s),t?.(s));return {tokens:r,hasParens:i}}prepareExpression(e,t,r,i,s=-1){let o=$e(e,this.config.validation);if(!o.passed)return {kind:"error",stage:"length",error:o.error.engineError};let a=t.filter(x=>x.type!=="COMMENT");if(a.length===0)return {kind:"empty"};let l=this.normalizer.normalize(a,i),c=ze(l,this.config.validation);if(!c.passed)return {kind:"error",stage:"complexity",error:c.engineError,normalizedTokens:l};let u,p=null;try{if(u=this.tryDefineUserUnit(l),u===null){let x=this.tryCompoundAssignment(l,s);x!==null&&(u=x,p=ke(l));}u===null&&(u=this.trySymbolicGrammar(l,s));}catch(x){let{reads:ne,writes:L}=ke(l);return {kind:"error",stage:"parse",error:chunkELQQKZN3_cjs.d(x),reads:ne,writes:L,normalizedTokens:l}}if(u!==null)return {kind:"symbolic-solve",normalizedTokens:l,value:u,reads:p?.reads,writes:p?.writes};let{reads:m,writes:y}=ke(l),f=this.bytecodeCache.get(e);if(f)return {kind:"ready",normalizedTokens:l,reads:m,writes:y,program:f,cached:true};let P=this.builderPool[this.builderPoolIndex++%this.builderPool.length];P.reset();let I,V=null;try{let x=_.track("parser",()=>(this.parseExpression(P,l,r),P.build()));I=x.result,V=x.alloc;}catch(x){return {kind:"error",stage:"parse",error:chunkELQQKZN3_cjs.d(x),reads:m,writes:y,normalizedTokens:l}}return this.cacheBytecode(e,I),{kind:"ready",normalizedTokens:l,reads:m,writes:y,program:I,cached:false,parserAlloc:V}}preflightAsync(e,t,r,i,s,o){if(!(t.hasAsync||this.resolverRegistry.size>0))return {kind:"proceed"};let a=new AbortController,l=()=>a.abort();this.keystrokeSignal?.addEventListener("abort",l,{once:true}),chunkTTFO4YDP_cjs.a.localControllerCreated("preflightAsync"),this.keystrokeSignal&&chunkTTFO4YDP_cjs.a.signalLinked("preflightAsync");let c=a.signal,u=this.resolverRegistry.preflightAll(e,t,"_engine",c,this.queryClient,this.config.network.enabled);if(u){this.resolveAsync({type:"pending",queryKey:u.queryKey,resolver:u.resolver,packageId:u.packageId||"_engine",signal:u.signal}),this.dag.registerLineDataSourceDependency(r,u.packageId||"_engine",[u.queryKey]),this.registerBackgroundRefresh(u);let p=chunkDA7M6H63_cjs.O(u.queryKey);return this.storeLineResult(r,p,t,s,o,i),{kind:"pending",value:p}}return this.keystrokeSignal?.removeEventListener("abort",l),{kind:"proceed"}}evaluateWithTokens(e,t,r,i){let s=this.prepareExpression(t,r,i,void 0,e);if(s.kind==="empty"){let p=chunkDA7M6H63_cjs.n(0);return this.lineCache.set(e,new H(p,{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},[],null),t),p}if(s.kind==="error")throw s.error;if(s.kind==="symbolic-solve")return this.storeLineResult(e,s.value,{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},s.reads??[],s.writes??[],t),s.value;let{normalizedTokens:o,reads:a,writes:l,program:c}=s,u=this.preflightAsync(o,c,e,t,a,l);return u.kind==="pending"?u.value:this.executeAndStore(c,e,t,a,l,"_engine")}evaluateLine(e,t){let r=this.evaluateLineWithDebug(e,t);if(r.error)throw r.engineError?r.engineError:chunkELQQKZN3_cjs.c.execution("EVALUATION_ERROR",r.error,{lineNumber:e});return chunkDA7M6H63_cjs.l(r.value)}evaluateLineWithDebug(e,t,r="expression"){let i=t.match(/^s`([^`]*)`$/);if(i){let s=i[1];return {...this.evaluateExpressionWithDiagnostic(s,e,r),inlineSolve:{start:0,end:t.length,expression:s,lineNumber:e,columnNumber:1}}}return this.evaluateExpressionWithDiagnostic(t,e,r)}addDiagnosticStage(e,t,r,i,s,o,a,l,c){e.push({stage:t,label:r,icon:i,colorClass:s,stepNumber:o,elapsedNs:a,skipped:l,output:c});}evaluateExpressionWithDiagnostic(e,t,r="expression"){let i=this.diagnosticPipeline,s=i.hasCollectors,o=this.timelineCollector?.parseletMatchCount??0,a=_.isEnabled(),l=[],c=[],u=0,p=$e(e,this.config.validation);if(!p.passed)return s&&this.addDiagnosticStage(c,"safety_length","Safety: Length","\u{1F6E1}\uFE0F","validate",2,u,false,{type:"safety_length",passed:false,expressionLength:e.length,maxLength:this.config.validation.maxExpressionLength,errorMessage:p.error.error}),{...p.error,debug:void 0,diagnostic:void 0};s&&(i.firePipelineStart({type:chunkHG4NPDN5_cjs.c.PipelineStart,elapsedNs:0,expression:e,inputType:r}),this.addDiagnosticStage(c,"pipeline_start","Pipeline Start","\u25B6","pipeline",1,u,false,{type:"pipeline_start",expression:e,inputType:r}),this.addDiagnosticStage(c,"safety_length","Safety: Length","\u{1F6E1}\uFE0F","validate",2,u,false,{type:"safety_length",passed:true,expressionLength:e.length,maxLength:this.config.validation.maxExpressionLength}));let m=s?h=>{i.fireTokenEmitted({type:chunkHG4NPDN5_cjs.c.TokenEmitted,elapsedNs:0,expression:e,token:{type:h.type,value:h.value,offset:h.offset||0,line:h.line||t,col:h.col||0}});}:void 0,y=_.track("lexer",()=>this.lexToTokens(e,m)),f=y.result.tokens,P=y.result.hasParens;if(a&&y.alloc&&l.push(y.alloc),s){let h={};for(let A of f)h[A.type]=(h[A.type]||0)+1;this.addDiagnosticStage(c,"lexer","Lexer","\u{1F524}","lexer",3,u,false,{type:"lexer",tokenCount:f.length,tokenTypes:h,hasParens:P,locale:this.localeCode,tokens:[...f]});let N=[];for(let A=0;A<f.length;A++){let oe=f[A];if(oe.type==="INLINE_SOLVE_START"){let D=-1;for(let j=A+1;j<f.length;j++)if(f[j].type==="BACKTICK_OPEN"){D=j;break}if(D>A){let sn=f.slice(A+1,D).map(on=>on.value).join("");N.push({startTokenIndex:A,endTokenIndex:D,expression:sn,columnNumber:oe.col||1}),A=D;}}}this.addDiagnosticStage(c,"line_classification","Line Classification","\u{1F4CB}","classify",3.5,u,false,{type:"line_classification",classification:"expression",skip:false,hasInlineSolve:N.length>0,inlineSolveSpans:N});}if(f.length===0){let h=chunkDA7M6H63_cjs.n(0);return this.lineCache.set(t,new H(h,{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},[],null),e),s&&i.firePipelineEnd({type:chunkHG4NPDN5_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:true,totalTokens:0,totalOpcodes:0}),{value:h,tokens:f,program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},debug:void 0,diagnostic:void 0}}let I=0,V=[],x=new Map,ne=s?h=>{I++,V.push(h),x.set(h.rule,(x.get(h.rule)||0)+1),i.fireTokenFused({type:chunkHG4NPDN5_cjs.c.TokenFused,elapsedNs:0,expression:e,ruleName:h.rule,sourceTokenCount:h.sourceTokens.length,fusedTokenType:h.fusedToken.type,fusedTokenValue:h.fusedToken.value});}:void 0;s&&this.normalizer.ruleCount>0&&i.fireNormalizerStart({type:chunkHG4NPDN5_cjs.c.NormalizerStart,elapsedNs:0,expression:e,inputTokenCount:f.length});let L=this.bytecodeCache.get(e);s&&!L&&this.parser.setDiagnosticPipeline(i,e);let b=this.prepareExpression(e,f,P,ne,t);a&&b.kind==="ready"&&b.parserAlloc&&l.push(b.parserAlloc),s&&!L&&this.parser.setDiagnosticPipeline(void 0,"");let S=b.kind==="empty"?f:b.normalizedTokens??f;if(s&&(this.normalizer.ruleCount>0?(i.fireNormalizerEnd({type:chunkHG4NPDN5_cjs.c.NormalizerEnd,elapsedNs:0,expression:e,outputTokenCount:S.length,fusionsCount:I}),this.addDiagnosticStage(c,"normalizer","Normalizer","\u{1F504}","normalizer",4,u,false,{type:"normalizer",inputTokenCount:f.length,outputTokenCount:S.length,fusions:V,rulesApplied:[...x.entries()].map(([h,N])=>({rule:h,count:N})),tokens:[...S],phrases:this.normalizer.getPhrases(),ruleShapes:this.normalizer.getRuleShapes(),candidatesPerPosition:this.normalizer.getCandidateCounts(S)})):this.addDiagnosticStage(c,"normalizer","Normalizer","\u{1F504}","normalizer",4,u,true,{type:"normalizer",inputTokenCount:f.length,outputTokenCount:f.length,fusions:[],rulesApplied:[],tokens:[...f],phrases:this.normalizer.getPhrases(),ruleShapes:this.normalizer.getRuleShapes(),candidatesPerPosition:this.normalizer.getCandidateCounts(f)})),b.kind==="empty"||b.kind==="error"&&b.stage==="length"){if(s&&i.firePipelineEnd({type:chunkHG4NPDN5_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:b.kind==="empty",totalTokens:f.length,totalOpcodes:0}),b.kind==="empty"){let h=chunkDA7M6H63_cjs.n(0);return this.lineCache.set(t,new H(h,{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},[],null),e),{value:h,tokens:f,program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},debug:void 0,diagnostic:void 0}}return {value:chunkDA7M6H63_cjs.n(0),tokens:[],program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},error:b.error.message,engineError:b.error,debug:void 0,diagnostic:void 0}}let re=ze(S,this.config.validation);if(b.kind==="error"&&b.stage==="complexity")return s&&(this.addDiagnosticStage(c,"safety_complexity","Safety: Complexity","\u{1F6E1}\uFE0F","validate",5,u,false,{type:"safety_complexity",passed:false,complexityScore:re.complexityScore??0,maxComplexity:this.config.validation.maxComplexity,breakdown:{tokenCount:S.length,functionCalls:0,nestingDepth:0},errorMessage:re.errorMessage}),i.firePipelineEnd({type:chunkHG4NPDN5_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:false,totalTokens:f.length,totalOpcodes:0})),{value:chunkDA7M6H63_cjs.n(0),tokens:[],program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},error:re.errorMessage,engineError:re.engineError,debug:void 0,diagnostic:void 0};if(s&&this.addDiagnosticStage(c,"safety_complexity","Safety: Complexity","\u{1F6E1}\uFE0F","validate",5,u,false,{type:"safety_complexity",passed:true,complexityScore:re.complexityScore??S.length,maxComplexity:this.config.validation.maxComplexity,breakdown:{tokenCount:S.length,functionCalls:0,nestingDepth:0}}),b.kind==="symbolic-solve"){s&&i.firePipelineEnd({type:chunkHG4NPDN5_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:true,totalTokens:f.length,totalOpcodes:0});let h={opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false};return this.storeLineResult(t,b.value,h,b.reads??[],b.writes??[],e),{value:b.value,tokens:S,program:h,debug:void 0,diagnostic:void 0}}let ge=b.reads??[],ie=b.writes??[];if(s&&(this.addDiagnosticStage(c,"readwrite","Read/Write","\u{1F4CB}","readwrite",6,u,false,{type:"readwrite",reads:ge,writes:ie,isAssignment:ie.length>0}),this.addDiagnosticStage(c,"cache_check","Cache Check","\u{1F4BE}","cache",7,u,false,{type:"cache_check",hit:!!L,cacheSize:this.bytecodeCache.size,cacheKey:e}),L?i.fireCacheHit({type:chunkHG4NPDN5_cjs.c.CacheHit,elapsedNs:0,expression:e,cache:"bytecode",key:e}):i.fireCacheMiss({type:chunkHG4NPDN5_cjs.c.CacheMiss,elapsedNs:0,expression:e,cache:"bytecode",key:e})),b.kind==="error"&&b.stage==="parse")return s&&i.firePipelineEnd({type:chunkHG4NPDN5_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:false,totalTokens:f.length,totalOpcodes:0}),{value:chunkDA7M6H63_cjs.n(0),tokens:S,program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},error:b.error.message,engineError:b.error,debug:void 0,diagnostic:void 0};if(b.kind!=="ready")throw chunkELQQKZN3_cjs.c.internal({code:"UNEXPECTED_ERROR",message:"Internal error: prepareExpression() returned an unexpected variant after all other cases were handled"});let E=b.program;s&&(this.addDiagnosticStage(c,"parser","Parser","\u{1F333}","parser",8,u,!!L,{type:"parser",parselets:[],uniqueParseletTypes:[],astDepth:0}),this.addDiagnosticStage(c,"compiler","Compiler","\u2699\uFE0F","compiler",9,u,!!L,{type:"compiler",opcodeCount:E.opcodes.length,numberConstants:E.numbers.length,stringConstants:E.strings.length,hasAsync:E.hasAsync,cached:!!L}),i.fireBytecodeBuilt({type:chunkHG4NPDN5_cjs.c.BytecodeBuilt,elapsedNs:0,expression:e,opcodesLength:E.opcodes.length,numbersLength:E.numbers.length,stringsLength:E.strings.length,isCached:!!L}));let nn=E.hasAsync||this.resolverRegistry.size>0,se=this.preflightAsync(S,E,t,e,ge,ie);if(s&&(se.kind==="pending"?this.addDiagnosticStage(c,"async_preflight","Async Preflight","\u{1F52E}","async",10,u,false,{type:"async_preflight",path:"pending",pendingQueryKey:se.value.value,resolverCount:this.resolverRegistry.size,skippedGuard:true}):nn?this.addDiagnosticStage(c,"async_preflight","Async Preflight","\u{1F52E}","async",10,u,false,{type:"async_preflight",path:"sync",resolverCount:this.resolverRegistry.size,skippedGuard:false}):this.addDiagnosticStage(c,"async_preflight","Async Preflight","\u{1F52E}","async",10,u,true,{type:"async_preflight",path:"sync",resolverCount:0,skippedGuard:true})),se.kind==="pending")return s&&i.firePipelineEnd({type:chunkHG4NPDN5_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:true,totalTokens:f.length,totalOpcodes:E.opcodes.length}),{value:se.value,tokens:S,program:E,debug:void 0,diagnostic:s?this.buildDiagnosticResult(c,se.value,S,E,null):void 0};let rn=s&&this.config.diagnostic.vmTraceEnabled===true,w;try{let h=_.track("vm",()=>this.executeAndStore(E,t,e,ge,ie,"_engine",rn?i:void 0,e),{cacheHit:!!L});w=h.result,a&&h.alloc&&l.push(h.alloc);}catch(h){let N=chunkELQQKZN3_cjs.d(h);return s&&i.firePipelineEnd({type:chunkHG4NPDN5_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:false,totalTokens:f.length,totalOpcodes:E.opcodes.length}),{value:chunkDA7M6H63_cjs.n(0),tokens:S,program:E,error:N.message,engineError:N,debug:void 0,diagnostic:void 0}}let de=w.type===12;if(s){let h=de?"pending":String(w.value??""),N=de?"Pending":w.unit?"Uom":"Number";this.addDiagnosticStage(c,"vm_execute","VM Execute","\u26A1","vm",11,u,false,{type:"vm_execute",totalInstructions:E.opcodes.length,stackDepth:this.vm.getStack().length,resultType:N,resultValue:h,isPending:de});}if(de)return s&&i.firePipelineEnd({type:chunkHG4NPDN5_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:true,totalTokens:f.length,totalOpcodes:E.opcodes.length}),{value:w,tokens:S,program:E,debug:void 0,diagnostic:s?this.buildDiagnosticResult(c,w,S,E,null):void 0};if(a&&l.length>0&&(this.lastTelemetry=_.createTelemetry(e,l,!!L)),s&&(this.addDiagnosticStage(c,"dag_registration","DAG Registration","\u{1F517}","dag",12,u,false,{type:"dag_registration",readsRegistered:ge,writesRegistered:ie,dataSourcesRegistered:[]}),this.addDiagnosticStage(c,"linecache","Line Cache","\u{1F4E6}","cache",13,u,false,{type:"linecache",lineNumber:t,expression:e,stored:true}),this.addDiagnosticStage(c,"result","Result","\u2713","result",14,u,false,{type:"result",rawValue:String(w.value),formattedValue:String(w.value),valueType:w.type===0?"Number":"Value",unit:w.unit}),i.fireVmHalt({type:chunkHG4NPDN5_cjs.c.VmHalt,elapsedNs:0,expression:e,result:w?{type:w.type,value:w.value,unit:w.unit}:void 0}),this.addDiagnosticStage(c,"pipeline_end","Pipeline End","\u23F9","pipeline",15,u,false,{type:"pipeline_end",success:true,totalTokens:f.length,totalOpcodes:E.opcodes.length,cacheHit:!!L}),i.firePipelineEnd({type:chunkHG4NPDN5_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:true,totalTokens:f.length,totalOpcodes:E.opcodes.length})),s){let N=i.collectReports()[0]?.toJSON(),A=N;if(N){let oe=N.parselets.slice(o),D={};for(let j of oe)D[j.parseletCategory]=(D[j.parseletCategory]??0)+1;A={...N,parselets:oe,summary:{...N.summary,totalParselets:Object.keys(D).length,parseCategories:D}};}return {value:w,tokens:S,program:E,debug:A,diagnostic:this.buildDiagnosticResult(c,w,S,E,null)}}return {value:w,tokens:S,program:E}}buildDiagnosticResult(e,t,r,i,s){return {stages:e,value:t,tokens:r,program:i,error:s,dagSnapshot:this.dag.getSnapshot(),cacheSnapshot:this.getCacheSnapshot(),batcherMetrics:this.getBatcherMetrics(),checkpoints:this.getCheckpoints()}}reEvaluateLine(e,t){let r=this.lineCache.get(e,t);if(!r)return;let i=this.bytecodeCache.get(t);if(!i)return;if(r.bytecode.hasAsync||this.resolverRegistry.size>0){let a=new AbortController,l=()=>a.abort();this.keystrokeSignal?.addEventListener("abort",l,{once:true}),chunkTTFO4YDP_cjs.a.localControllerCreated("reEvaluateLine preflight"),this.keystrokeSignal&&chunkTTFO4YDP_cjs.a.signalLinked("reEvaluateLine preflight");let c=a.signal,u=this.resolverRegistry.preflightAll([],r.bytecode,"_engine",c,this.queryClient,this.config.network.enabled);if(u)return this.resolveAsync({type:"pending",queryKey:u.queryKey,resolver:u.resolver,packageId:u.packageId||"_engine",signal:u.signal}),this.registerBackgroundRefresh(u),chunkDA7M6H63_cjs.O(u.queryKey);this.keystrokeSignal?.removeEventListener("abort",l);}let s=this.executeRaw(i,e);if(s.type==="pending")return this.resolveAsync(s),chunkDA7M6H63_cjs.O(s.queryKey);if(s.type==="error")throw s.error;let o=s.value;return r.result=o,o}getDag(){return this.dag}getLineCache(){return this.lineCache}getBytecodeCache(){return this.bytecodeCache}getVM(){return this.vm}getContext(){return this.context}getScopeManager(){return this.scopeManager}getLexer(){return this.lexer}getNormalizer(){return this.normalizer}getPackageCompletionItems(){let e=[];for(let t of this.packageCompletionItems.values())e.push(...t);return e}getParseletRegistry(){return {prefix:this.registry.getAllPrefix(),infix:this.registry.getAllInfix()}}tokenizeForClassification(e){this.lexer.resetExpression(e);let r=Array.from(this.lexer).filter(i=>i.type!=="COMMENT");return r.length===0?[]:this.normalizer.normalize(r)}getParser(){return this.parser}isDiagnosticMode(){return this.diagnosticPipeline.hasCollectors}setKeystrokeSignal(e){e?chunkTTFO4YDP_cjs.a.keystrokeSignalSet(e.aborted):chunkTTFO4YDP_cjs.a.keystrokeSignalCleared(),this.keystrokeSignal=e;}getCacheSnapshot(){let e=[];for(let[o,a]of this.bytecodeCache)e.push({expression:o,opcodesLength:a.opcodes.length,numbersLength:a.numbers.length,stringsLength:a.strings.length,hasAsync:a.hasAsync});let t=[];for(let o of this.lineCache.keys()){let a=o.indexOf(":"),l=a>0?parseInt(o.slice(0,a),10)||0:parseInt(o,10)||0,c=a>0?o.slice(a+1):void 0,u=c!==void 0?this.lineCache.get(l,c):this.lineCache.getEntryForLine(l);u&&t.push({key:o,lineNumber:l,resultType:String(u.result?.type??""),resultValue:String(u.result?.value??""),reads:u.readVariables??[],writeVar:u.writeVariable??null});}let s=this.queryClient.getQueryCache().getAll().map(o=>{let a=o.state.status==="success"?"resolved":o.state.status==="error"?"error":"in_flight";return {packageId:o.queryKey[0]??"unknown",resolvedCount:o.state.status==="success"?1:0,inFlightCount:o.state.status!=="success"&&o.state.status!=="error"?1:0,errorCount:o.state.status==="error"?1:0,entries:[{key:o.queryKey.join(":"),status:a}]}});return {bytecode:e,lineCache:t,asyncCache:s}}getBatcherMetrics(){return {pendingCount:this.batcher.pendingCount,dedupCount:this.batcher.dedupCount,workerOffloadCount:this.batcher.workerOffloadCount,listenerCount:this.batcher.listenerCount}}getCheckpoints(){let t=this.vm.checkpointer;return t?t.getAllCheckpoints().map(i=>({lineNumber:i.lineNumber,variables:Object.keys(i.variables),variableCount:Object.keys(i.variables).length})):[]}getLastTelemetry(){return this.lastTelemetry}evaluateExpression(e){return this.evaluateLine(-1,e)}explainLine(e){let{tokens:t}=this.lexToTokens(e),r=t.filter(s=>s.type!=="COMMENT"),i=this.normalizer.normalize(r);return Ke({expression:e,tokens:i,evaluate:s=>this.evaluateIsolated(s),locale:this.localeCode})}evaluateIsolated(e){let{tokens:t,hasParens:r}=this.lexToTokens(e),i=this.prepareExpression(e,t,r,void 0,-1);if(i.kind==="empty")return chunkDA7M6H63_cjs.n(0);if(i.kind==="error")throw i.error;if(i.kind==="symbolic-solve")return i.value;let s=this.executeRaw(i.program,-1);if(s.type==="error")throw s.error;if(s.type==="pending")throw chunkELQQKZN3_cjs.c.execution("EXPLAIN_ASYNC_UNSUPPORTED",`A derivation cannot be built for a line that resolves data asynchronously: "${e}"`,{expression:e});return s.value}compileExpression(e){let{tokens:t,hasParens:r}=this.lexToTokens(e),i=this.prepareExpression(e,t,r);if(i.kind==="empty")return {program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},tokens:[],reads:[],writes:[]};if(i.kind==="error")throw i.stage==="parse"&&(i.reads?.length||i.writes?.length)?new chunkELQQKZN3_cjs.b(i.error.category,{code:i.error.code,message:i.error.message,expected:i.error.expected,found:i.error.found,suggestion:i.error.suggestion,recoverable:i.error.recoverable,span:i.error.span,cause:i.error.cause,context:{...i.error.context,reads:i.reads??[],writes:i.writes??[]}}):i.error;return i.kind==="symbolic-solve"?{program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},tokens:i.normalizedTokens,reads:i.reads??[],writes:i.writes??[]}:{program:i.program,tokens:t,reads:i.reads,writes:i.writes}}tryCompileExpression(e){try{return this.tryCompileExpressionUnguarded(e)}catch{return  false}}tryCompileExpressionUnguarded(e){let{tokens:t,hasParens:r}=this.lexToTokens(e);return this.prepareExpression(e,t,r).kind!=="error"}executeCached(e,t=-1){if(e.opcodes.length===0)return chunkDA7M6H63_cjs.n(0);let r=this.executeRaw(e,t);if(r.type==="pending")return this.resolveAsync(r),chunkDA7M6H63_cjs.O(r.queryKey);if(r.type==="error")throw r.error;return r.value}evaluateNumber(e){let t=e.trim();if(/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(t)&&this.vm.getVar(t)===void 0)return NaN;try{let r=this.evaluateLine(-1,e);return r.isFault()?NaN:r.toNumber()}catch{return NaN}}clear(){this.batcher.clearAll(),this.backgroundRefresh?.clearAll(),this.queryClient.clear(),chunkZLRJ7TDP_cjs.b()===this.queryClient&&chunkZLRJ7TDP_cjs.a(null),this.dag.clear(),this.lineCache.clear(),this.scopeManager.clear(),this.bytecodeCache.clear(),this.vm.reset(),this.userUnits.clear(),this.accumulatorNames.clear(),this.lastTelemetry=null;}toJSON(){let e=this.dag.getSnapshot(),t=new Set;for(let c of Object.keys(e.dataSourceDeps)){let u=Number(c);Number.isNaN(u)||t.add(u);}let r=this.lineCache.snapshotEntries(),i=new Map;for(let{line:c,entry:u}of r){let p=t.has(c)||u.bytecode.hasAsync;p&&t.add(c);let m=u.writeVariable;if(m){let y=i.get(m);(!y||c>=y.line)&&i.set(m,{line:c,async:p});}}let s={};for(let[c,u]of this.vm.getVariableEntries())if(u.type!==12&&!i.get(c)?.async)try{s[c]=Be(u,`variable "${c}"`);}catch(p){if(p instanceof chunkELQQKZN3_cjs.b&&p.code===M.SNAPSHOT_UNSUPPORTED_VALUE)continue;throw p}let o=this.vm.getUserFunctionDefs().map(De),a=[];for(let{line:c,expression:u,entry:p}of r){if(t.has(c)||p.result.type===12)continue;let m;try{m=Be(p.result,`line ${c}`);}catch(y){if(y instanceof chunkELQQKZN3_cjs.b&&y.code===M.SNAPSHOT_UNSUPPORTED_VALUE)continue;throw y}a.push({line:c,expression:u,result:m,bytecode:ue(p.bytecode),reads:p.readVariables.slice(),writeVar:p.writeVariable});}let l=Array.from(this.bytecodeCache.entries()).map(([c,u])=>({expression:c,program:ue(u)}));return {format:Z,version:G,engineVersion:chunkUY3ID6JF_cjs.a,locale:this.localeCode,variables:s,userFunctions:o,lineCache:a,bytecodeCache:l}}static fromJSON(e,t={}){Wt(e);let r=t.locale??e.locale??"en",i=new Q({locale:r,diagnostics:t.diagnostics??false,config:t.config,packages:t.packages});return i.restoreSnapshot(e),i}restoreSnapshot(e){for(let[t,r]of Object.entries(e.variables))this.vm.setVar(t,Me(r));for(let t of e.userFunctions){let r=Ue(t);this.vm.defineUserFunction(r.name,r.params,r.program);}for(let t of e.lineCache){let r=new H(Me(t.result),pe(t.bytecode),t.reads.slice(),t.writeVar);this.lineCache.set(t.line,r,t.expression),this.dag.registerLine(t.line,t.reads,t.writeVar?[t.writeVar]:[]);}for(let{expression:t,program:r}of e.bytecodeCache)this.bytecodeCache.set(t,pe(r));}evaluateIncremental(e,t){let r=this.dag.getAffectedLinesInOrder(e);this.vm.setVar(e,chunkDA7M6H63_cjs.n(t));let i=new Map;for(let s of r){let o=this.lineCache.getEntryForLine(s);if(!o||o.bytecode.opcodes.length===0)continue;let a=this.executeRaw(o.bytecode,s);if(a.type==="pending"){this.resolveAsync(a);continue}if(a.type==="error"){let c=chunkDA7M6H63_cjs.P(a.error.code,a.error.message);i.set(s,c),o.result=c;continue}let l=a.value;i.set(s,l),o.result=l;}return i}};Q.GOAL_SEEK_MAX_NESTING_DEPTH=1,Q.WARMUP_EXPRESSIONS=["1 + 2 * 3","10.5 / 2 - 0.25","50% of 200","3 kg + 400 g","sqrt(144) + max(1, 2)","1 < 2 && 3 >= 3","half of 250",'"text" + "joined"'];var we=Q;var He=(()=>{throw new Error("engine.worker.ts was not processed by esbuild-plugin-inline-worker, so worker offload is unavailable")}),ee=null;function In(){return ee||(ee=new we),ee}var te=null;function Vn(){return te||(te=chunkRMCN5WFO_cjs.c(chunkAUOE7MFI_cjs.w,200,5e4)),te}function Bn(n){let e={lineId:n.lineId,expression:n.expression,compiledAgainstHash:n.textHash,strings:[],reads:[],writes:[],isVariableDef:false,error:null};try{let t=In(),{program:r,reads:i,writes:s}=t.compileExpression(n.expression),o=s.length>0,a=r.opcodes,l=r.numbers,c=a.buffer.slice(a.byteOffset,a.byteOffset+a.byteLength),u=l.buffer.slice(l.byteOffset,l.byteOffset+l.byteLength);return {...e,opcodesBuffer:c,numbersBuffer:u,opcodesLength:a.length,numbersLength:l.length,strings:[...r.strings],reads:i,writes:s,isVariableDef:o}}catch(t){return {...e,opcodesBuffer:new ArrayBuffer(0),numbersBuffer:new ArrayBuffer(0),opcodesLength:0,numbersLength:0,error:t instanceof Error?t.message:String(t)}}}function Mn(n){let e=[],t=[];for(let r of n.items){let i=Bn(r);e.push(i),i.opcodesBuffer.byteLength>0&&t.push(i.opcodesBuffer),i.numbersBuffer.byteLength>0&&t.push(i.numbersBuffer);}self.postMessage({id:n.id,type:"COMPILE_RESULT",results:e},t);}function Dn(n){let e=Vn();e.reset();let t=new Uint8Array(n.opcodesBuffer,0,n.opcodesLength),r=new Float64Array(n.numbersBuffer,0,n.numbersLength),i={opcodes:t,numbers:r,strings:n.strings};try{let s=chunkRMCN5WFO_cjs.d(i,e);if(s.type==="pending")return {lineNumber:n.lineNumber,valueType:12,value:0,isPending:!0,queryKey:s.queryKey};if(s.type==="error")return {lineNumber:n.lineNumber,valueType:13,value:0,isPending:!1,unit:s.error.message};let o=s.value;return {lineNumber:n.lineNumber,valueType:o.type,value:typeof o.value=="number"?o.value:typeof o.value=="bigint"?Number(o.value):0,unit:o.unit,isPending:!1}}catch{return {lineNumber:n.lineNumber,valueType:13,value:0,isPending:false,unit:"Worker execution failed"}}}function Un(n){let e=[];for(let t of n.items)e.push(Dn(t));self.postMessage({id:n.id,type:"EXECUTE_RESULT",results:e});}var _n=typeof self<"u"&&typeof window>"u",Fn=n=>{if(n.origin&&self.location&&n.origin!==self.location.origin)return;let e=n.data;switch(e.type){case "COMPILE_BATCH":Mn(e);break;case "EXECUTE_BATCH":Un(e);break;case "TERMINATE":{ee&&(ee.clear(),ee=null),te&&(te.reset(),te=null),self.postMessage({id:e.id,type:"COMPILE_RESULT",results:[]});break}default:self.postMessage({id:-1,type:"COMPILE_RESULT",results:[],error:`Unknown message type: ${e.type}`});}};_n&&(self.onmessage=Fn);var Zt=3e4,en=50,Ne=class{constructor(e){this.workers=[];this.nextWorker=0;this.nextId=1;this.pendingBatches=new Map;this.terminated=false;this._available=null;this.poolSize=Math.min(e??this.defaultPoolSize(),4);}defaultPoolSize(){return typeof navigator<"u"&&navigator.hardwareConcurrency?Math.min(navigator.hardwareConcurrency,4):2}isAvailable(){if(this.terminated)return  false;if(this._available!==null)return this._available;if(typeof Worker>"u")return this._available=false,false;try{return He().terminate(),this._available=!0,!0}catch{return this._available=false,false}}executeBatch(e,t){if(!this.isAvailable())return;if(e.length===0)return Promise.resolve([]);this.ensureWorkers();let r=[];for(let l of e){let c=t.get(l);if(!c||c.bytecode.opcodes.length===0)continue;let u=c.bytecode.opcodes,p=c.bytecode.numbers,m=u.buffer.slice(u.byteOffset,u.byteOffset+u.byteLength),y=p.buffer.slice(p.byteOffset,p.byteOffset+p.byteLength);r.push({lineNumber:l,opcodesBuffer:m,numbersBuffer:y,opcodesLength:u.length,numbersLength:p.length,strings:[...c.bytecode.strings]});}if(r.length===0)return Promise.resolve([]);let i=[];for(let l of r)l.opcodesBuffer.byteLength>0&&i.push(l.opcodesBuffer),l.numbersBuffer.byteLength>0&&i.push(l.numbersBuffer);let s=this.nextId++,o=this.nextWorkerIndex(),a=this.workers[o];return new Promise(l=>{let c=setTimeout(()=>{this.pendingBatches.has(s)&&this.failWorker(o,"WORKER_TIMEOUT",`Evaluation did not finish within ${Zt/1e3} seconds; the worker was replaced`);},Zt);this.pendingBatches.set(s,{id:s,lineNumbers:r.map(u=>u.lineNumber),workerIndex:o,resolve:u=>{clearTimeout(c),l(u);}}),a.postMessage({type:"EXECUTE_BATCH",id:s,items:r},i);})}clear(){for(let[,e]of this.pendingBatches)e.resolve([]);this.pendingBatches.clear();for(let e of this.workers)e.terminate();this.workers=[],this.nextWorker=0;}destroy(){this.terminated=true,this.clear();}ensureWorkers(){if(!(this.workers.length>0))for(let e=0;e<this.poolSize;e++)this.spawnWorker(e);}spawnWorker(e){let t=He();t.onmessage=r=>{this.handleWorkerMessage(r.data);},t.onerror=r=>{console.error(`[ExecutionPool] Worker ${e} error:`,r.message),this.failWorker(e,"WORKER_EXECUTION_ERROR",`Worker failed: ${r.message}`);},this.workers[e]=t;}failWorker(e,t,r){if(this.workers.length!==0){this.workers[e]?.terminate(),this.terminated||this.spawnWorker(e);for(let[i,s]of this.pendingBatches)s.workerIndex===e&&(this.pendingBatches.delete(i),s.resolve($n(s.lineNumbers,t,r)));}}nextWorkerIndex(){let e=this.nextWorker;return this.nextWorker=(this.nextWorker+1)%this.workers.length,e}handleWorkerMessage(e){if(e.type!=="EXECUTE_RESULT")return;let t=this.pendingBatches.get(e.id);t&&(this.pendingBatches.delete(e.id),t.resolve(e.results));}};function $n(n,e,t){return n.map(r=>({lineNumber:r,valueType:13,value:0,unit:t,isPending:false,errorCode:e}))}function tn(n){switch(n.valueType){case 0:return chunkDA7M6H63_cjs.n(n.value);case 1:return chunkDA7M6H63_cjs.r(n.value);case 2:return chunkDA7M6H63_cjs.s(BigInt(n.value));case 3:return chunkDA7M6H63_cjs.t(String(n.value));case 4:return chunkDA7M6H63_cjs.M(n.value);case 5:return chunkDA7M6H63_cjs.N(n.value);case 6:return chunkDA7M6H63_cjs.u(n.value,n.unit??"");case 7:return chunkDA7M6H63_cjs.n(n.value);case 10:return chunkDA7M6H63_cjs.L(n.value!==0);case 12:return chunkDA7M6H63_cjs.O(n.queryKey??"");case 13:return chunkDA7M6H63_cjs.P(n.errorCode??"WORKER_EXECUTION_ERROR",n.unit??"Unknown worker error");default:return chunkDA7M6H63_cjs.n(n.value)}}var Re=class Re{constructor(e,t,r,i=Re.DEFAULT_HIGH_WATER_MARK){this.pending=[];this.scheduled=false;this.cleared=false;this.executionPool=null;this.workerOffloadDispatchCount=0;this._streamController=null;this._testCaptures=null;this.onLineResult=null;this.warnedAboutMissingHook=false;this.dag=e,this.lineCache=t,this.vm=r,this.highWaterMark=i,this._eventStream=this.createEventStream();}warnIfUnwired(){this.onLineResult||this.listenerCount>0||this.warnedAboutMissingHook||(this.warnedAboutMissingHook=true,console.warn("[solve-engine] An async result resolved, but nothing is listening for it: no reader is attached to engine.getEventStream() and AsyncResolutionBatcher.onLineResult is not set. The value is in the cache; without one of those the line keeps showing as pending. Read the event stream and re-evaluate the lines it names (see the async guide), or set onLineResult to mirror resolved values into your own state. This warning appears once per batcher."));}createEventStream(){return new ReadableStream({start:e=>{this._streamController=e;},cancel:()=>{this._streamController=null;}},new CountQueuingStrategy({highWaterMark:this.highWaterMark}))}add(e){this.cleared=false;for(let t of this.pending)if(t.packageId===e.packageId&&t.queryKey===e.queryKey)return;this.pending.push(e),this.scheduled||(this.scheduled=true,queueMicrotask(()=>{try{this.flush();}catch(t){let r=chunkELQQKZN3_cjs.d(t);console.error(`[AsyncResolutionBatcher] flush() failed unexpectedly \u2014 this should never happen; please report: ${r.format()}`);}}));}getEventStream(){return this._eventStream}get pendingCount(){return this.pending.length}get dedupCount(){let e=new Set;for(let t of this.pending)e.add(`${t.packageId}:${t.queryKey}`);return Math.max(0,this.pending.length-e.size)}get listenerCount(){return this._eventStream.locked?1:0}get workerOffloadCount(){return this.workerOffloadDispatchCount}clearAll(){this.pending=[],this.scheduled=false,this.cleared=true,this._testCaptures=null,this.onLineResult=null;try{this._streamController?.close();}catch{}this._streamController=null,this._eventStream=this.createEventStream(),this.executionPool&&(this.executionPool.clear(),this.executionPool=null),this.workerOffloadDispatchCount=0;}flush(){if(this.scheduled=false,this.cleared||this.pending.length===0)return;let e=this.pending;this.pending=[];let t=new Map;for(let c of e){let u=`${c.packageId}:${c.queryKey}`;t.set(u,c);}let r=[],i=[];for(let c of t.values())c.isError?r.push(c):i.push(c);for(let c of r)c.signal.aborted||this.notifyListeners({type:"error",queryKey:c.queryKey,packageId:c.packageId,error:c.error??new Error("Unknown async resolution error")});let s=new Set,o=[],a=[...i,...r];for(let c of a){if(c.signal.aborted)continue;o.push(c.queryKey);let u=this.dag.getAffectedLinesByDataSource(c.packageId,[c.queryKey]);for(let p of u)s.add(p);}if(s.size===0){this.notifyListeners({type:"lines-updated",lineNumbers:[],affectedQueryKeys:o});return}let l=this.topologicalSort(Array.from(s));if(l.length>en){let c=new Map;for(let u of l)c.set(u,this.lineCache.getEntryForLine(u));this.reExecuteViaWorkerPool(l,c,o).catch(u=>{let p=chunkELQQKZN3_cjs.d(u);console.error(`[AsyncResolutionBatcher] reExecuteViaWorkerPool() failed unexpectedly: ${p.format()}`);});return}this.reExecuteMainThread(l,o);}topologicalSort(e){if(e.length<=1)return e;let t=new Map,r=new Map,i=new Map;for(let a of e)t.set(a,0),r.set(a,[]);for(let a of e){let l=this.dag.getWrites(a);for(let c of l)i.set(c,a);}for(let a of e){let l=this.dag.getDependencies(a);for(let c of l){let u=i.get(c);u!==void 0&&u!==a&&(r.get(u).push(a),t.set(a,(t.get(a)??0)+1));}}let s=[];for(let[a,l]of t)l===0&&s.push(a);if(s.length===0&&e.length>0)return [...e].sort((a,l)=>a-l);let o=[];for(;s.length>0;){let a=s.shift();o.push(a);for(let l of r.get(a)??[]){let c=(t.get(l)??1)-1;t.set(l,c),c===0&&s.push(l);}}if(o.length<e.length){let a=e.filter(l=>!o.includes(l)).sort((l,c)=>l-c);o.push(...a);}return o}async reExecuteViaWorkerPool(e,t,r){this.executionPool||(this.executionPool=new Ne);let i=this.executionPool.executeBatch(e,t);if(!i){this.reExecuteMainThread(e,r,t);return}this.workerOffloadDispatchCount++;let s=await i;if(this.cleared)return;let o=[];for(let a of s){let l=t.get(a.lineNumber);if(!l||a.isPending)continue;let c=tn(a);l.result=c,this.warnIfUnwired(),this.onLineResult?.(a.lineNumber,c),o.push(a.lineNumber);}this.cleared||(o.length>0||r.length>0)&&this.notifyListeners({type:"lines-updated",lineNumbers:o,affectedQueryKeys:r});}reExecuteMainThread(e,t,r){let i=[];for(let s of e){let o=r?r.get(s):this.lineCache.getEntryForLine(s);if(!o||o.bytecode.opcodes.length===0)continue;let a=this.vm.getStack().length;try{let l=chunkRMCN5WFO_cjs.d(o.bytecode,this.vm);for(;this.vm.getStack().length>a;)this.vm.pop();if(l.type==="value")o.result=l.value,this.warnIfUnwired(),this.onLineResult?.(s,l.value),i.push(s);else if(l.type==="error"){let c=chunkDA7M6H63_cjs.P(l.error.code,l.error.message);o.result=c,this.warnIfUnwired(),this.warnIfUnwired(),this.onLineResult?.(s,c),i.push(s);}}catch(l){for(;this.vm.getStack().length>a;)this.vm.pop();let c=chunkELQQKZN3_cjs.d(l),u=chunkDA7M6H63_cjs.P(c.code,c.message);o.result=u,this.warnIfUnwired(),this.onLineResult?.(s,u),i.push(s);}}return (i.length>0||t.length>0)&&this.notifyListeners({type:"lines-updated",lineNumbers:i,affectedQueryKeys:t}),i}notifyListeners(e){if(this._testCaptures&&this._testCaptures.push(e),this._streamController)try{this._streamController.enqueue(e);}catch{}}};Re.DEFAULT_HIGH_WATER_MARK=64;var Te=Re;exports.a=zn;exports.b=dn;exports.c=Dt;exports.d=Z;exports.e=G;exports.f=M;exports.g=He;exports.h=Te;exports.i=$e;exports.j=ze;exports.k=ke;exports.l=cr;exports.m=ur;exports.n=we;//# sourceMappingURL=chunk-RECRD45C.cjs.map
-//# sourceMappingURL=chunk-RECRD45C.cjs.map