solve-engine 2.25.0 → 2.27.0

package/dist/{chunk-57PSJQQW.js → chunk-VB6QMU2W.js}

@@ -1,3 +1,3 @@
-var i=(N=>(N.PARSING="PARSING",N.EXECUTION="EXECUTION",N.VALIDATION="VALIDATION",N.EXTERNAL="EXTERNAL",N.INTERNAL="INTERNAL",N.CONFIG="CONFIG",N))(i||{}),O=class O extends Error{constructor(r,_){let e=_.recoverable??true,n=e&&!O.captureRecoverableStacks,I=Error,N=I.stackTraceLimit;n&&(I.stackTraceLimit=0),super(_.message),n&&(I.stackTraceLimit=N),this.name="EngineError",this.category=r,this.code=_.code,this.expected=_.expected,this.found=_.found,this.suggestion=_.suggestion,this.recoverable=e,this.span=_.span,this.context=_.context,this.cause=_.cause,this.timestamp=new Date,!n&&Error.captureStackTrace&&Error.captureStackTrace(this,O);}isFatal(){return !this.recoverable}causeChain(){let r=[this],_=this.cause;for(;_!=null;)r.push(_),_=_ instanceof Error?_.cause:void 0;return r}format(){let r=[`error[${this.code}]: ${this.message}`];return this.expected&&r.push(`  expected: ${this.expected}`),this.found&&r.push(`  found: ${this.found}`),this.suggestion&&r.push(`  suggestion: ${this.suggestion}`),r.join(`
-`)}toJSON(){return {name:this.name,category:this.category,code:this.code,message:this.message,expected:this.expected,found:this.found,suggestion:this.suggestion,recoverable:this.recoverable,span:this.span,context:this.context,timestamp:this.timestamp.toISOString()}}};O.captureRecoverableStacks=false;var t=O,T=class E{static build(r,_,e,n,I){let N=typeof e=="string"?{code:e,message:n,context:I}:e;return new t(r,{recoverable:_,...N})}static validation(r,_,e){return E.build("VALIDATION",true,r,_,e)}static parsing(r,_,e){return E.build("PARSING",true,r,_,e)}static execution(r,_,e){return E.build("EXECUTION",true,r,_,e)}static external(r,_,e){return E.build("EXTERNAL",true,r,_,e)}static internal(r,_,e){return E.build("INTERNAL",true,r,_,e)}static config(r,_,e){return E.build("CONFIG",false,r,_,e)}};function R(E){return E instanceof t?E:E instanceof Error?T.internal({code:"UNEXPECTED_ERROR",message:E.message,context:{originalErrorName:E.name},cause:E,recoverable:true}):T.internal({code:"UNKNOWN_ERROR",message:"An unknown error occurred",context:{error:String(E)},recoverable:true})}function o(E){return {ok:true,value:E}}function A(E){return {ok:false,error:E}}function s(E){return E.ok}function S(E){return !E.ok}function C(E,r){return E.ok?o(r(E.value)):E}function D(E,r){return E.ok?E:A(r(E.error))}function L(E,r){return E.ok?r(E.value):E}function a(E,r){return E.ok?E.value:r}function U(E,r){return E.ok?r.ok(E.value):r.err(E.error)}function u(E){let r=[];for(let _ of E){if(!_.ok)return _;r.push(_.value);}return o(r)}function c(E){if(E.ok)return E.value;throw E.error}function P(E,r=R){try{return o(E())}catch(_){return A(r(_))}}async function M(E,r=R){try{return o(await E())}catch(_){return A(r(_))}}var g={INVALID_NUMBER_LITERAL:"INVALID_NUMBER_LITERAL",UNTERMINATED_STRING:"UNTERMINATED_STRING",NO_PREFIX_PARSELET:"NO_PREFIX_PARSELET",UNEXPECTED_END_OF_INPUT:"UNEXPECTED_END_OF_INPUT",UNEXPECTED_TOKEN_TYPE:"UNEXPECTED_TOKEN_TYPE",NESTING_DEPTH_EXCEEDED:"NESTING_DEPTH_EXCEEDED",UNEXPECTED_END:"UNEXPECTED_END",UNEXPECTED_TRAILING_TOKEN:"UNEXPECTED_TRAILING_TOKEN",PARSE_ERROR:"PARSE_ERROR",TOO_MANY_NUMERIC_CONSTANTS:"TOO_MANY_NUMERIC_CONSTANTS",BYTECODE_OPERAND_OUT_OF_RANGE:"BYTECODE_OPERAND_OUT_OF_RANGE",TOO_MANY_STRING_CONSTANTS:"TOO_MANY_STRING_CONSTANTS",NO_MATCHING_PHRASE_ALTERNATIVE:"NO_MATCHING_PHRASE_ALTERNATIVE",INVALID_PHRASE_PATTERN:"INVALID_PHRASE_PATTERN",PHRASE_KEYWORD_MISMATCH:"PHRASE_KEYWORD_MISMATCH",USER_FUNCTION_INVALID_PARAM_NAME:"USER_FUNCTION_INVALID_PARAM_NAME",USER_FUNCTION_NO_PARAMS:"USER_FUNCTION_NO_PARAMS",FUNCTION_BODY_MUST_BE_SYNCHRONOUS:"FUNCTION_BODY_MUST_BE_SYNCHRONOUS",TOO_MANY_FUNCTION_DEFINITIONS:"TOO_MANY_FUNCTION_DEFINITIONS",TOO_MANY_ANONYMOUS_BODIES:"TOO_MANY_ANONYMOUS_BODIES",UNKNOWN_PLUGIN_FUNCTION:"UNKNOWN_PLUGIN_FUNCTION",EVALUATION_ERROR:"EVALUATION_ERROR",INSTRUCTION_LIMIT_EXCEEDED:"INSTRUCTION_LIMIT_EXCEEDED",STACK_LIMIT_EXCEEDED:"STACK_LIMIT_EXCEEDED",ALLOCATION_LIMIT_EXCEEDED:"ALLOCATION_LIMIT_EXCEEDED",STACK_UNDERFLOW:"STACK_UNDERFLOW",UNDEFINED_VARIABLE:"UNDEFINED_VARIABLE",GLOBAL_VARIABLE_NOT_RESOLVED:"GLOBAL_VARIABLE_NOT_RESOLVED",UNKNOWN_FUNCTION:"UNKNOWN_FUNCTION",UNEXPECTED_PENDING_RESULT:"UNEXPECTED_PENDING_RESULT",UNDEFINED_FUNCTION:"UNDEFINED_FUNCTION",FUNCTION_ARITY_MISMATCH:"FUNCTION_ARITY_MISMATCH",BUILTIN_ARITY_MISMATCH:"BUILTIN_ARITY_MISMATCH",USER_FUNCTION_ASYNC_UNSUPPORTED:"USER_FUNCTION_ASYNC_UNSUPPORTED",MAP_REDUCE_ASYNC_UNSUPPORTED:"MAP_REDUCE_ASYNC_UNSUPPORTED",SYMBOLIC_ASYNC_UNSUPPORTED:"SYMBOLIC_ASYNC_UNSUPPORTED",EXPLAIN_ASYNC_UNSUPPORTED:"EXPLAIN_ASYNC_UNSUPPORTED",FUNCTION_RECURSION_LIMIT_EXCEEDED:"FUNCTION_RECURSION_LIMIT_EXCEEDED",FUNCTION_CALL_LIMIT_EXCEEDED:"FUNCTION_CALL_LIMIT_EXCEEDED",DATE_OFFSET_LIMIT_EXCEEDED:"DATE_OFFSET_LIMIT_EXCEEDED",WORKDAY_OFFSET_EXPECTED_DATE:"WORKDAY_OFFSET_EXPECTED_DATE",WORKDAYS_BETWEEN_EXPECTED_DATES:"WORKDAYS_BETWEEN_EXPECTED_DATES",WORKDAYS_BETWEEN_RANGE_TOO_LARGE:"WORKDAYS_BETWEEN_RANGE_TOO_LARGE",BIGINT_SHIFT_LIMIT_EXCEEDED:"BIGINT_SHIFT_LIMIT_EXCEEDED",BIGINT_POW_LIMIT_EXCEEDED:"BIGINT_POW_LIMIT_EXCEEDED",BIGINT_INEXACT_OPERAND:"BIGINT_INEXACT_OPERAND",BIGINT_DIVISION_BY_ZERO:"BIGINT_DIVISION_BY_ZERO",INTERNAL_MISSING_FUNCTION_BODY:"INTERNAL_MISSING_FUNCTION_BODY",INTERNAL_MISSING_ANONYMOUS_BODY:"INTERNAL_MISSING_ANONYMOUS_BODY",UNKNOWN_BUILTIN_FUNCTION:"UNKNOWN_BUILTIN_FUNCTION",MALFORMED_BYTECODE_TRUNCATED:"MALFORMED_BYTECODE_TRUNCATED",MALFORMED_BYTECODE_CONSTANT_INDEX:"MALFORMED_BYTECODE_CONSTANT_INDEX",MALFORMED_BYTECODE_OPERAND_TYPE:"MALFORMED_BYTECODE_OPERAND_TYPE",MALFORMED_BYTECODE_BODY_KIND:"MALFORMED_BYTECODE_BODY_KIND",MALFORMED_BYTECODE_BIGINT_LITERAL:"MALFORMED_BYTECODE_BIGINT_LITERAL",MALFORMED_BYTECODE_PROGRAM:"MALFORMED_BYTECODE_PROGRAM",SYMBOLIC_RATIONAL_OVERFLOW:"SYMBOLIC_RATIONAL_OVERFLOW",SYMBOLIC_NONFINITE_OPERAND:"SYMBOLIC_NONFINITE_OPERAND",SYMBOLIC_DIVISION_BY_ZERO:"SYMBOLIC_DIVISION_BY_ZERO",SYMBOLIC_NODE_LIMIT_EXCEEDED:"SYMBOLIC_NODE_LIMIT_EXCEEDED",SYMBOLIC_UNSUPPORTED_FUNCTION:"SYMBOLIC_UNSUPPORTED_FUNCTION",SYMBOLIC_FACTOR_LIMIT_EXCEEDED:"SYMBOLIC_FACTOR_LIMIT_EXCEEDED",SYMBOLIC_SOLVE_UNSUPPORTED:"SYMBOLIC_SOLVE_UNSUPPORTED",SYMBOLIC_SOLVE_INCOMPLETE:"SYMBOLIC_SOLVE_INCOMPLETE",SOLVE_REQUIRES_VARIABLE_NAME:"SOLVE_REQUIRES_VARIABLE_NAME",SYMBOLIC_DERIVATIVE_ORDER_LIMIT:"SYMBOLIC_DERIVATIVE_ORDER_LIMIT",SYMBOLIC_INTEGRAL_UNSUPPORTED:"SYMBOLIC_INTEGRAL_UNSUPPORTED",SYMBOLIC_TAYLOR_DEGREE_LIMIT:"SYMBOLIC_TAYLOR_DEGREE_LIMIT",SYMBOLIC_TAYLOR_INEXACT:"SYMBOLIC_TAYLOR_INEXACT",SYMBOLIC_REQUIRES_VARIABLE_NAME:"SYMBOLIC_REQUIRES_VARIABLE_NAME",SYMBOLIC_JACOBIAN_NO_VARIABLES:"SYMBOLIC_JACOBIAN_NO_VARIABLES",INTERNAL_RATIONAL_PARSE:"INTERNAL_RATIONAL_PARSE",EXPRESSION_TOO_LONG:"EXPRESSION_TOO_LONG",EXPRESSION_TOO_COMPLEX:"EXPRESSION_TOO_COMPLEX",DOCUMENT_TOO_LARGE:"DOCUMENT_TOO_LARGE",NORMALIZED_TOKEN_LIMIT_EXCEEDED:"NORMALIZED_TOKEN_LIMIT_EXCEEDED",THEREFORE_REQUIRES_EXPRESSION:"THEREFORE_REQUIRES_EXPRESSION",THEREFORE_ASYNC_UNSUPPORTED:"THEREFORE_ASYNC_UNSUPPORTED",COMPOUND_ASSIGN_REQUIRES_EXPRESSION:"COMPOUND_ASSIGN_REQUIRES_EXPRESSION",COMPOUND_ASSIGN_ASYNC_UNSUPPORTED:"COMPOUND_ASSIGN_ASYNC_UNSUPPORTED",UNKNOWN_SAVINGS_PERIOD:"UNKNOWN_SAVINGS_PERIOD",INVALID_TIME_LITERAL:"INVALID_TIME_LITERAL",NETWORK_DISABLED:"NETWORK_DISABLED",SNAPSHOT_VERSION_MISMATCH:"SNAPSHOT_VERSION_MISMATCH",SNAPSHOT_MALFORMED:"SNAPSHOT_MALFORMED",SNAPSHOT_UNSUPPORTED_VALUE:"SNAPSHOT_UNSUPPORTED_VALUE",CONFIG_PATH_NOT_FOUND:"CONFIG_PATH_NOT_FOUND",INVALID_CONFIG_PATH:"INVALID_CONFIG_PATH",CONFIG_SECTION_NOT_FOUND:"CONFIG_SECTION_NOT_FOUND",CONFIG_PROPERTY_NOT_FOUND:"CONFIG_PROPERTY_NOT_FOUND",PLUGIN_OPERATOR_COLLISION:"PLUGIN_OPERATOR_COLLISION",PLUGIN_KEYWORD_COLLISION:"PLUGIN_KEYWORD_COLLISION",PLUGIN_UNIT_COLLISION:"PLUGIN_UNIT_COLLISION",PACKAGE_ENGINE_VERSION_MISMATCH:"PACKAGE_ENGINE_VERSION_MISMATCH",PACKAGE_ENGINE_VERSION_INVALID_RANGE:"PACKAGE_ENGINE_VERSION_INVALID_RANGE",OPCODE_POOL_EXHAUSTED:"OPCODE_POOL_EXHAUSTED",PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED:"PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED",PLUGIN_FUNCTION_INDEX_TOO_LARGE:"PLUGIN_FUNCTION_INDEX_TOO_LARGE",INVALID_RATE_UNIT:"INVALID_RATE_UNIT",INVALID_TIMECODE_UNIT:"INVALID_TIMECODE_UNIT",UNEXPECTED_ERROR:"UNEXPECTED_ERROR",UNKNOWN_ERROR:"UNKNOWN_ERROR"};export{i as a,t as b,T as c,R as d,o as e,A as f,s as g,S as h,C as i,D as j,L as k,a as l,U as m,u as n,c as o,P as p,M as q,g as r};//# sourceMappingURL=chunk-57PSJQQW.js.map
-//# sourceMappingURL=chunk-57PSJQQW.js.map
+var i=(e=>(e.PARSING="PARSING",e.EXECUTION="EXECUTION",e.VALIDATION="VALIDATION",e.EXTERNAL="EXTERNAL",e.INTERNAL="INTERNAL",e.CONFIG="CONFIG",e))(i||{}),O=class O extends Error{constructor(r,N){let _=N.recoverable??true,n=_&&!O.captureRecoverableStacks,I=Error,e=I.stackTraceLimit;n&&(I.stackTraceLimit=0),super(N.message),n&&(I.stackTraceLimit=e),this.name="EngineError",this.category=r,this.code=N.code,this.expected=N.expected,this.found=N.found,this.suggestion=N.suggestion,this.recoverable=_,this.span=N.span,this.context=N.context,this.cause=N.cause,this.timestamp=new Date,!n&&Error.captureStackTrace&&Error.captureStackTrace(this,O);}isFatal(){return !this.recoverable}causeChain(){let r=[this],N=this.cause;for(;N!=null;)r.push(N),N=N instanceof Error?N.cause:void 0;return r}format(){let r=[`error[${this.code}]: ${this.message}`];return this.expected&&r.push(`  expected: ${this.expected}`),this.found&&r.push(`  found: ${this.found}`),this.suggestion&&r.push(`  suggestion: ${this.suggestion}`),r.join(`
+`)}toJSON(){return {name:this.name,category:this.category,code:this.code,message:this.message,expected:this.expected,found:this.found,suggestion:this.suggestion,recoverable:this.recoverable,span:this.span,context:this.context,timestamp:this.timestamp.toISOString()}}};O.captureRecoverableStacks=false;var t=O,T=class E{static build(r,N,_,n,I){let e=typeof _=="string"?{code:_,message:n,context:I}:_;return new t(r,{recoverable:N,...e})}static validation(r,N,_){return E.build("VALIDATION",true,r,N,_)}static parsing(r,N,_){return E.build("PARSING",true,r,N,_)}static execution(r,N,_){return E.build("EXECUTION",true,r,N,_)}static external(r,N,_){return E.build("EXTERNAL",true,r,N,_)}static internal(r,N,_){return E.build("INTERNAL",true,r,N,_)}static config(r,N,_){return E.build("CONFIG",false,r,N,_)}};function R(E){return E instanceof t?E:E instanceof Error?T.internal({code:"UNEXPECTED_ERROR",message:E.message,context:{originalErrorName:E.name},cause:E,recoverable:true}):T.internal({code:"UNKNOWN_ERROR",message:"An unknown error occurred",context:{error:String(E)},recoverable:true})}function o(E){return {ok:true,value:E}}function A(E){return {ok:false,error:E}}function s(E){return E.ok}function D(E){return !E.ok}function C(E,r){return E.ok?o(r(E.value)):E}function S(E,r){return E.ok?E:A(r(E.error))}function L(E,r){return E.ok?r(E.value):E}function U(E,r){return E.ok?E.value:r}function a(E,r){return E.ok?r.ok(E.value):r.err(E.error)}function u(E){let r=[];for(let N of E){if(!N.ok)return N;r.push(N.value);}return o(r)}function c(E){if(E.ok)return E.value;throw E.error}function M(E,r=R){try{return o(E())}catch(N){return A(r(N))}}async function P(E,r=R){try{return o(await E())}catch(N){return A(r(N))}}var g={INVALID_NUMBER_LITERAL:"INVALID_NUMBER_LITERAL",UNTERMINATED_STRING:"UNTERMINATED_STRING",NO_PREFIX_PARSELET:"NO_PREFIX_PARSELET",UNEXPECTED_END_OF_INPUT:"UNEXPECTED_END_OF_INPUT",UNEXPECTED_TOKEN_TYPE:"UNEXPECTED_TOKEN_TYPE",NESTING_DEPTH_EXCEEDED:"NESTING_DEPTH_EXCEEDED",UNEXPECTED_END:"UNEXPECTED_END",UNEXPECTED_TRAILING_TOKEN:"UNEXPECTED_TRAILING_TOKEN",PARSE_ERROR:"PARSE_ERROR",TOO_MANY_NUMERIC_CONSTANTS:"TOO_MANY_NUMERIC_CONSTANTS",BYTECODE_OPERAND_OUT_OF_RANGE:"BYTECODE_OPERAND_OUT_OF_RANGE",TOO_MANY_STRING_CONSTANTS:"TOO_MANY_STRING_CONSTANTS",NO_MATCHING_PHRASE_ALTERNATIVE:"NO_MATCHING_PHRASE_ALTERNATIVE",INVALID_PHRASE_PATTERN:"INVALID_PHRASE_PATTERN",PHRASE_KEYWORD_MISMATCH:"PHRASE_KEYWORD_MISMATCH",USER_FUNCTION_INVALID_PARAM_NAME:"USER_FUNCTION_INVALID_PARAM_NAME",USER_FUNCTION_NO_PARAMS:"USER_FUNCTION_NO_PARAMS",FUNCTION_BODY_MUST_BE_SYNCHRONOUS:"FUNCTION_BODY_MUST_BE_SYNCHRONOUS",TOO_MANY_FUNCTION_DEFINITIONS:"TOO_MANY_FUNCTION_DEFINITIONS",TOO_MANY_ANONYMOUS_BODIES:"TOO_MANY_ANONYMOUS_BODIES",UNKNOWN_PLUGIN_FUNCTION:"UNKNOWN_PLUGIN_FUNCTION",EVALUATION_ERROR:"EVALUATION_ERROR",INSTRUCTION_LIMIT_EXCEEDED:"INSTRUCTION_LIMIT_EXCEEDED",STACK_LIMIT_EXCEEDED:"STACK_LIMIT_EXCEEDED",ALLOCATION_LIMIT_EXCEEDED:"ALLOCATION_LIMIT_EXCEEDED",STACK_UNDERFLOW:"STACK_UNDERFLOW",UNDEFINED_VARIABLE:"UNDEFINED_VARIABLE",GLOBAL_VARIABLE_NOT_RESOLVED:"GLOBAL_VARIABLE_NOT_RESOLVED",UNKNOWN_FUNCTION:"UNKNOWN_FUNCTION",UNEXPECTED_PENDING_RESULT:"UNEXPECTED_PENDING_RESULT",UNDEFINED_FUNCTION:"UNDEFINED_FUNCTION",FUNCTION_ARITY_MISMATCH:"FUNCTION_ARITY_MISMATCH",BUILTIN_ARITY_MISMATCH:"BUILTIN_ARITY_MISMATCH",USER_FUNCTION_ASYNC_UNSUPPORTED:"USER_FUNCTION_ASYNC_UNSUPPORTED",MAP_REDUCE_ASYNC_UNSUPPORTED:"MAP_REDUCE_ASYNC_UNSUPPORTED",SYMBOLIC_ASYNC_UNSUPPORTED:"SYMBOLIC_ASYNC_UNSUPPORTED",EXPLAIN_ASYNC_UNSUPPORTED:"EXPLAIN_ASYNC_UNSUPPORTED",FUNCTION_RECURSION_LIMIT_EXCEEDED:"FUNCTION_RECURSION_LIMIT_EXCEEDED",FUNCTION_CALL_LIMIT_EXCEEDED:"FUNCTION_CALL_LIMIT_EXCEEDED",DATE_OFFSET_LIMIT_EXCEEDED:"DATE_OFFSET_LIMIT_EXCEEDED",WORKDAY_OFFSET_EXPECTED_DATE:"WORKDAY_OFFSET_EXPECTED_DATE",WORKDAYS_BETWEEN_EXPECTED_DATES:"WORKDAYS_BETWEEN_EXPECTED_DATES",WORKDAYS_BETWEEN_RANGE_TOO_LARGE:"WORKDAYS_BETWEEN_RANGE_TOO_LARGE",BIGINT_SHIFT_LIMIT_EXCEEDED:"BIGINT_SHIFT_LIMIT_EXCEEDED",BIGINT_POW_LIMIT_EXCEEDED:"BIGINT_POW_LIMIT_EXCEEDED",BIGINT_INEXACT_OPERAND:"BIGINT_INEXACT_OPERAND",BIGINT_DIVISION_BY_ZERO:"BIGINT_DIVISION_BY_ZERO",INTERNAL_MISSING_FUNCTION_BODY:"INTERNAL_MISSING_FUNCTION_BODY",INTERNAL_MISSING_ANONYMOUS_BODY:"INTERNAL_MISSING_ANONYMOUS_BODY",UNKNOWN_BUILTIN_FUNCTION:"UNKNOWN_BUILTIN_FUNCTION",MALFORMED_BYTECODE_TRUNCATED:"MALFORMED_BYTECODE_TRUNCATED",MALFORMED_BYTECODE_CONSTANT_INDEX:"MALFORMED_BYTECODE_CONSTANT_INDEX",MALFORMED_BYTECODE_OPERAND_TYPE:"MALFORMED_BYTECODE_OPERAND_TYPE",MALFORMED_BYTECODE_BODY_KIND:"MALFORMED_BYTECODE_BODY_KIND",MALFORMED_BYTECODE_BIGINT_LITERAL:"MALFORMED_BYTECODE_BIGINT_LITERAL",MALFORMED_BYTECODE_PROGRAM:"MALFORMED_BYTECODE_PROGRAM",SYMBOLIC_RATIONAL_OVERFLOW:"SYMBOLIC_RATIONAL_OVERFLOW",SYMBOLIC_NONFINITE_OPERAND:"SYMBOLIC_NONFINITE_OPERAND",SYMBOLIC_DIVISION_BY_ZERO:"SYMBOLIC_DIVISION_BY_ZERO",SYMBOLIC_NODE_LIMIT_EXCEEDED:"SYMBOLIC_NODE_LIMIT_EXCEEDED",SYMBOLIC_UNSUPPORTED_FUNCTION:"SYMBOLIC_UNSUPPORTED_FUNCTION",SYMBOLIC_FACTOR_LIMIT_EXCEEDED:"SYMBOLIC_FACTOR_LIMIT_EXCEEDED",SYMBOLIC_SOLVE_UNSUPPORTED:"SYMBOLIC_SOLVE_UNSUPPORTED",SYMBOLIC_SOLVE_INCOMPLETE:"SYMBOLIC_SOLVE_INCOMPLETE",SOLVE_REQUIRES_VARIABLE_NAME:"SOLVE_REQUIRES_VARIABLE_NAME",SYMBOLIC_DERIVATIVE_ORDER_LIMIT:"SYMBOLIC_DERIVATIVE_ORDER_LIMIT",SYMBOLIC_INTEGRAL_UNSUPPORTED:"SYMBOLIC_INTEGRAL_UNSUPPORTED",SYMBOLIC_TAYLOR_DEGREE_LIMIT:"SYMBOLIC_TAYLOR_DEGREE_LIMIT",SYMBOLIC_TAYLOR_INEXACT:"SYMBOLIC_TAYLOR_INEXACT",SYMBOLIC_REQUIRES_VARIABLE_NAME:"SYMBOLIC_REQUIRES_VARIABLE_NAME",SYMBOLIC_JACOBIAN_NO_VARIABLES:"SYMBOLIC_JACOBIAN_NO_VARIABLES",INTERNAL_RATIONAL_PARSE:"INTERNAL_RATIONAL_PARSE",EXPRESSION_TOO_LONG:"EXPRESSION_TOO_LONG",EXPRESSION_TOO_COMPLEX:"EXPRESSION_TOO_COMPLEX",DOCUMENT_TOO_LARGE:"DOCUMENT_TOO_LARGE",NORMALIZED_TOKEN_LIMIT_EXCEEDED:"NORMALIZED_TOKEN_LIMIT_EXCEEDED",THEREFORE_REQUIRES_EXPRESSION:"THEREFORE_REQUIRES_EXPRESSION",THEREFORE_ASYNC_UNSUPPORTED:"THEREFORE_ASYNC_UNSUPPORTED",COMPOUND_ASSIGN_REQUIRES_EXPRESSION:"COMPOUND_ASSIGN_REQUIRES_EXPRESSION",COMPOUND_ASSIGN_ASYNC_UNSUPPORTED:"COMPOUND_ASSIGN_ASYNC_UNSUPPORTED",UNKNOWN_SAVINGS_PERIOD:"UNKNOWN_SAVINGS_PERIOD",INVALID_TIME_LITERAL:"INVALID_TIME_LITERAL",NETWORK_DISABLED:"NETWORK_DISABLED",TEMPORAL_IMPLEMENTATION_INVALID:"TEMPORAL_IMPLEMENTATION_INVALID",TEMPORAL_TIME_ZONE_UNKNOWN:"TEMPORAL_TIME_ZONE_UNKNOWN",SNAPSHOT_VERSION_MISMATCH:"SNAPSHOT_VERSION_MISMATCH",SNAPSHOT_MALFORMED:"SNAPSHOT_MALFORMED",SNAPSHOT_UNSUPPORTED_VALUE:"SNAPSHOT_UNSUPPORTED_VALUE",CONFIG_PATH_NOT_FOUND:"CONFIG_PATH_NOT_FOUND",INVALID_CONFIG_PATH:"INVALID_CONFIG_PATH",CONFIG_SECTION_NOT_FOUND:"CONFIG_SECTION_NOT_FOUND",CONFIG_PROPERTY_NOT_FOUND:"CONFIG_PROPERTY_NOT_FOUND",CALENDAR_TEMPORAL_UNAVAILABLE:"CALENDAR_TEMPORAL_UNAVAILABLE",PLUGIN_OPERATOR_COLLISION:"PLUGIN_OPERATOR_COLLISION",PLUGIN_KEYWORD_COLLISION:"PLUGIN_KEYWORD_COLLISION",PLUGIN_UNIT_COLLISION:"PLUGIN_UNIT_COLLISION",PACKAGE_ENGINE_VERSION_MISMATCH:"PACKAGE_ENGINE_VERSION_MISMATCH",PACKAGE_ENGINE_VERSION_INVALID_RANGE:"PACKAGE_ENGINE_VERSION_INVALID_RANGE",OPCODE_POOL_EXHAUSTED:"OPCODE_POOL_EXHAUSTED",PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED:"PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED",PLUGIN_FUNCTION_INDEX_TOO_LARGE:"PLUGIN_FUNCTION_INDEX_TOO_LARGE",INVALID_RATE_UNIT:"INVALID_RATE_UNIT",INVALID_TIMECODE_UNIT:"INVALID_TIMECODE_UNIT",UNEXPECTED_ERROR:"UNEXPECTED_ERROR",UNKNOWN_ERROR:"UNKNOWN_ERROR"},B={DATETIME_ZONE_UNKNOWN:"DATETIME_ZONE_UNKNOWN",DATETIME_NOT_CONVERTIBLE:"DATETIME_NOT_CONVERTIBLE",DATE_ZONE_UNKNOWN:"DATE_ZONE_UNKNOWN"};export{i as a,t as b,T as c,R as d,o as e,A as f,s as g,D as h,C as i,S as j,L as k,U as l,a as m,u as n,c as o,M as p,P as q,g as r,B as s};//# sourceMappingURL=chunk-VB6QMU2W.js.map
+//# sourceMappingURL=chunk-VB6QMU2W.js.map

package/dist/chunk-VB6QMU2W.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors/EngineError.ts","../src/errors/Result.ts","../src/errors/ErrorCode.ts"],"names":["ErrorCategory","_EngineError","category","init","recoverable","skipStack","errorCtor","previousLimit","chain","current","lines","EngineError","ErrorFactory","_ErrorFactory","defaultRecoverable","codeOrInit","message","context","normalizeUnknownError","error","ok","value","err","isOk","r","isErr","map","fn","mapErr","andThen","unwrapOr","fallback","match","arms","combine","results","values","throwIfErr","tryCatch","normalize","e","tryCatchAsync","CoreErrorCodes","DatetimeErrorCodes"],"mappings":"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","file":"chunk-VB6QMU2W.js","sourcesContent":["/**\n * The engine's structured error type, the \"Rust/Go-style, verbose, easy to\n * tell the issue\" half of the error-handling redesign (the other half is\n * `Result.ts`).\n *\n * Historical note: an earlier version of this class (`UnifiedErrorFramework.ts`,\n * still the import path most of the codebase uses. See that file, now a\n * pure re-export barrel) had a much larger field set (`severity`,\n * `recovery`, a 5-value enum, `ErrorRecoveryManager`) that was almost\n * entirely dead: nothing downstream ever read `.severity`/`.recovery`,\n * only `.message` reliably survived to a caller. This version is smaller\n * and deliberately keeps only fields something actually consumes.\n */\n\nimport type { ErrorCode } from \"@solve-js/errors/ErrorCode\";\n\n/** A character-offset (and optional line/col) span into the original expression text, for a future \"underline the offending token\" UI, not yet wired to one. */\nexport interface SourceSpan {\n  start: number;\n  end: number;\n  line?: number;\n  col?: number;\n}\n\n/**\n * Error classification, kept from the original framework, now actually\n * consulted: it's the `format()` header and lets host code group errors\n * by pipeline stage without string-matching `.code`.\n */\nexport enum ErrorCategory {\n  /** Errors during expression parsing. */\n  PARSING = \"PARSING\",\n  /** Errors during bytecode execution. */\n  EXECUTION = \"EXECUTION\",\n  /** Errors from input validation (safety limits, config). */\n  VALIDATION = \"VALIDATION\",\n  /** Errors from external services/APIs (currency rates, weather, stocks). */\n  EXTERNAL = \"EXTERNAL\",\n  /** Internal engine invariant violations. See `recoverable`'s doc comment. */\n  INTERNAL = \"INTERNAL\",\n  /** Configuration errors. */\n  CONFIG = \"CONFIG\",\n}\n\n/** Fields accepted when constructing an {@link EngineError}. */\nexport interface EngineErrorInit {\n  /** Catalog code. See `errors/ErrorCode.ts`. Not a free string: every code used by a BUILT-IN package should be registered there so `ErrorCodeCatalog.spec.ts` can catch collisions/typos. Third-party packages may still use any string here, `EngineError.code`'s runtime type is `string`. */\n  code: ErrorCode | (string & {});\n  /** Short, single-line, `Error.message`-compatible. Existing `.toThrow(/pattern/)`/`.message` assertions keep working against this field, richer detail goes in `expected`/`found`/`suggestion`, not crammed into this string. */\n  message: string;\n  /** What the parser/validator/VM expected to see, in plain words, e.g. \"a city name\", \"a 4-digit year\", \"end of expression\". */\n  expected?: string;\n  /** What was actually found instead, e.g. \"end of expression\", `NUMBER \"5\"`, the offending token's literal text. */\n  found?: string;\n  /** An actionable, worked-example fix, e.g. `e.g. \"weather in London\"`. Mirrors this codebase's best existing messages (`WEATHER_EXPECTED_CITY`, `AS_CONVERTER_EXPECTED_NAME`). */\n  suggestion?: string;\n  /**\n   * Whether this engine instance is still usable. `true` for everything that\n   * went wrong on ONE line, whether the line's fault (bad syntax, an unknown\n   * variable, a safety limit exceeded), the environment's (an external API\n   * down), or the engine's own (corrupted bytecode, a stack underflow from a\n   * buggy plugin). `false` is for the far rarer case where there is no working\n   * engine to go on with: a configuration or package-registration failure,\n   * which is what `ErrorFactory.config()` is for and the only factory method\n   * that still defaults to it.\n   *\n   * The category answers a different question, and the two used to be answered\n   * as one. Category INTERNAL says whose fault this is, the engine's, worth\n   * reporting as a bug. `recoverable` says whether the host may carry on, and\n   * after an internal slip on one line it may:\n   * `__tests__/hardening/RobustnessEngineLifecycle.spec.ts` alternates a\n   * throwing line with a good one five hundred times and every answer stays\n   * correct. Reporting that as `isFatal()` told a host the opposite, and a host\n   * that honours the name would tear a document down over one bad line.\n   *\n   * This has never gated \"does evaluation of the rest of the document\n   * continue\"; with this engine's per-line containment it always does, even for\n   * a `recoverable: false` error (see `ARCHITECTURE.md`'s async-batcher/Tier-2\n   * hardening notes). It gates what a host is TOLD. See\n   * {@link EngineError.isFatal}.\n   */\n  recoverable?: boolean;\n  /** Character-offset span into the source expression, when available. Not yet threaded through every call site, populate opportunistically, don't block on retrofitting every existing throw site. */\n  span?: SourceSpan;\n  /** Free-form structured context. The one field the pre-existing framework's real consumer (`ThreeTierEvaluator.ts`'s DAG-preservation-on-compile-error path) actually reads, kept name- and shape-compatible on purpose. */\n  context?: Record<string, unknown>;\n  /** The underlying error this one wraps, if any, passed straight through to native `Error.cause` (ES2022), so Node's default printer, most loggers, and `instanceof Error` tooling understand the chain for free. */\n  cause?: unknown;\n}\n\n/**\n * The engine's structured error type. Still a real `Error` subclass (so\n * `throw`/`catch`/`instanceof Error` all keep working exactly as before),\n * but now every field except the removed `severity`/`recovery` pair is\n * something real code reads.\n */\nexport class EngineError extends Error {\n  readonly category: ErrorCategory;\n  readonly code: string;\n  readonly expected?: string;\n  readonly found?: string;\n  readonly suggestion?: string;\n  readonly recoverable: boolean;\n  readonly span?: SourceSpan;\n  readonly context?: Record<string, unknown>;\n  readonly timestamp: Date;\n  /**\n   * Set explicitly (not via `super(message, {cause})`). This repo's\n   * `tsconfig.json` targets ES6/ES5-ES7 lib, which predates TypeScript's\n   * ES2022 `Error` constructor `cause`-option overload. `Error.prototype.cause`\n   * is still a real runtime feature in every target this engine actually\n   * runs in (Node 16.9+, all evergreen browsers, Electron/Obsidian's\n   * bundled Chromium) regardless of the TS lib target used to type-check\n   * against it, assigning it directly gets the same Node-printer/logger\n   * interop with no build-config change needed.\n   */\n  readonly cause?: unknown;\n\n  /**\n   * Whether a recoverable error captures a JavaScript stack trace.\n   *\n   * Off, because a recoverable EngineError is a value rather than a fault. A\n   * line of prose in a notepad is not an expression, so parsing it fails, and\n   * that failure is the answer for that line rather than a bug to debug. The\n   * engine builds one such error per non-expression line.\n   *\n   * Capturing a stack is not cheap, and its cost grows with how deep the stack\n   * is when it happens. Measured through `parseDocument`, where the throw site\n   * sits about a dozen frames down, each capture cost around 62 microseconds\n   * and a 250-line document built 74 of them: a CPU profile put the\n   * constructor at 46% of the whole pipeline, more than lexing, normalising,\n   * parsing and executing put together.\n   *\n   * Turn it on to debug where a recoverable error is raised from. Errors that\n   * are NOT recoverable always capture, since those are the genuine faults.\n   *\n   * @example\n   * ```ts\n   * EngineError.captureRecoverableStacks = true;\n   * ```\n   */\n  static captureRecoverableStacks = false;\n\n  constructor(category: ErrorCategory, init: EngineErrorInit) {\n    // Before super(), which is legal as long as `this` is untouched. V8 reads\n    // `Error.stackTraceLimit` while constructing the Error, so zeroing it\n    // across the super() call is what actually skips the capture; there is no\n    // per-instance switch for it.\n    const recoverable = init.recoverable ?? true;\n    const skipStack = recoverable && !EngineError.captureRecoverableStacks;\n    // `stackTraceLimit` is a V8 extension, present in Node and every\n    // Chromium-based browser but absent from the DOM lib, so it is reached\n    // through a narrow local view rather than by widening the global type.\n    // Where it does not exist, reading and writing it are both harmless and\n    // the stack is captured as before.\n    const errorCtor = Error as unknown as { stackTraceLimit?: number };\n    const previousLimit = errorCtor.stackTraceLimit;\n    if (skipStack) errorCtor.stackTraceLimit = 0;\n    super(init.message);\n    if (skipStack) errorCtor.stackTraceLimit = previousLimit;\n\n    this.name = \"EngineError\";\n    this.category = category;\n    this.code = init.code;\n    this.expected = init.expected;\n    this.found = init.found;\n    this.suggestion = init.suggestion;\n    this.recoverable = recoverable;\n    this.span = init.span;\n    this.context = init.context;\n    this.cause = init.cause;\n    this.timestamp = new Date();\n    // Only for the faults. super() has already captured a stack for those, and\n    // this second call recaptures it purely to drop this constructor's own\n    // frame; doing that for every error meant paying the whole cost twice.\n    if (!skipStack && Error.captureStackTrace) {\n      Error.captureStackTrace(this, EngineError);\n    }\n  }\n\n  /** `!recoverable`. See `EngineErrorInit.recoverable`'s doc comment for what this actually gates (message framing/telemetry, not whether evaluation continues). */\n  isFatal(): boolean {\n    return !this.recoverable;\n  }\n\n  /** Walk `.cause` repeatedly, collecting the full chain (this error first). */\n  causeChain(): unknown[] {\n    const chain: unknown[] = [this];\n    let current: unknown = this.cause;\n    while (current !== undefined && current !== null) {\n      chain.push(current);\n      current = current instanceof Error ? (current as Error & { cause?: unknown }).cause : undefined;\n    }\n    return chain;\n  }\n\n  /**\n   * Rust/Go-style multi-line renderer, the NEW thing a host/CLI/test\n   * reaches for when it wants the full, verbose picture, as distinct from\n   * `.message` (kept short and stable for existing assertions). Example:\n   *\n   * ```\n   * error[WEATHER_EXPECTED_CITY]: Expected a city name after \"weather in\"\n   *   expected: a city name\n   *   found: end of expression\n   *   suggestion: e.g. \"weather in London\"\n   * ```\n   */\n  format(): string {\n    const lines = [`error[${this.code}]: ${this.message}`];\n    if (this.expected) lines.push(`  expected: ${this.expected}`);\n    if (this.found) lines.push(`  found: ${this.found}`);\n    if (this.suggestion) lines.push(`  suggestion: ${this.suggestion}`);\n    return lines.join(\"\\n\");\n  }\n\n  toJSON(): Record<string, unknown> {\n    return {\n      name: this.name,\n      category: this.category,\n      code: this.code,\n      message: this.message,\n      expected: this.expected,\n      found: this.found,\n      suggestion: this.suggestion,\n      recoverable: this.recoverable,\n      span: this.span,\n      context: this.context,\n      timestamp: this.timestamp.toISOString(),\n    };\n  }\n}\n\n/**\n * Factory for creating classified `EngineError`s. Every method accepts\n * EITHER the original, minimal 3-arg shape (`code, message, context?`\n * every existing call site across the codebase keeps compiling unchanged)\n * OR the richer `EngineErrorInit` object (for `expected`/`found`/\n * `suggestion`/`recoverable`/`span`/`cause`), upgrade a call site to the\n * richer form only when you're already touching it, no separate churn\n * pass required.\n */\nexport class ErrorFactory {\n  private static build(\n    category: ErrorCategory,\n    defaultRecoverable: boolean,\n    codeOrInit: string | EngineErrorInit,\n    message?: string,\n    context?: Record<string, unknown>,\n  ): EngineError {\n    const init: EngineErrorInit =\n      typeof codeOrInit === \"string\"\n        ? { code: codeOrInit, message: message!, context }\n        : codeOrInit;\n    return new EngineError(category, { recoverable: defaultRecoverable, ...init });\n  }\n\n  static validation(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static validation(init: EngineErrorInit): EngineError;\n  static validation(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.VALIDATION, true, codeOrInit, message, context);\n  }\n\n  static parsing(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static parsing(init: EngineErrorInit): EngineError;\n  static parsing(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.PARSING, true, codeOrInit, message, context);\n  }\n\n  static execution(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static execution(init: EngineErrorInit): EngineError;\n  static execution(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.EXECUTION, true, codeOrInit, message, context);\n  }\n\n  static external(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static external(init: EngineErrorInit): EngineError;\n  static external(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.EXTERNAL, true, codeOrInit, message, context);\n  }\n\n  /**\n   * Reserve for genuine engine-internal invariant violations (corrupted\n   * bytecode, a stack underflow from a buggy plugin, an \"impossible\" state),\n   * not for user-input errors: the category is a bug report.\n   *\n   * Defaults `recoverable: true` all the same, because every one of these sites\n   * is an invariant that failed on ONE line and none of them leaves the engine\n   * unusable. This used to default to `false`, which conflated \"the engine's\n   * fault\" with \"the engine is finished\" and told a host to tear a document\n   * down over a line it could simply have shown an error against. A site that\n   * has looked at its own case and concluded the instance really is gone can\n   * still pass `recoverable: false` explicitly. See {@link\n   * EngineErrorInit.recoverable}.\n   */\n  static internal(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static internal(init: EngineErrorInit): EngineError;\n  static internal(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.INTERNAL, true, codeOrInit, message, context);\n  }\n\n  /** Defaults `recoverable: false`, and is now the only method that does: a configuration or package-registration failure is the one class that leaves no working engine to carry on with, rather than one bad line in a document. */\n  static config(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static config(init: EngineErrorInit): EngineError;\n  static config(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.CONFIG, false, codeOrInit, message, context);\n  }\n}\n\n/**\n * Normalize any thrown value into an `EngineError`, an `EngineError`\n * passes through as-is; a plain `Error` gets wrapped (message preserved,\n * original attached via `cause`); anything else becomes a generic\n * \"unknown error\" wrapping the stringified value. Used at every\n * throw-space/Result-space boundary (`Result.tryCatch`'s default\n * `normalize`, the VM's outer execution try/catch, `AsyncResolutionBatcher`'s\n * per-line containment) so a raw `TypeError` from a genuine engine bug\n * still surfaces as a structured, catalogued error instead of an opaque\n * uncaught exception.\n *\n * Both branches state RECOVERABLE explicitly, while keeping the INTERNAL\n * category. The two fields answer different questions and were previously\n * answering the same one:\n *\n *   category INTERNAL  whose fault is this? The engine's. Worth reporting.\n *   recoverable        is this engine instance still usable? Yes.\n *\n * Everything reaching here is by definition something the engine did not\n * anticipate on ONE line, and per-line containment means the next line\n * evaluates normally, which `__tests__/hardening/RobustnessEngineLifecycle`\n * demonstrates over hundreds of alternating failure/success pairs. Reporting\n * that as `isFatal()` told a host the opposite, and a host that honours the\n * name would tear a document down over a single bad line. The \"this is an\n * engine bug rather than your syntax\" signal a caller wants for telemetry is\n * the CATEGORY, which is unchanged.\n *\n * The flag is written out here rather than inherited from\n * `ErrorFactory.internal()`, which now defaults the same way, so that this\n * function's contract survives a future change to that default.\n */\nexport function normalizeUnknownError(error: unknown): EngineError {\n  if (error instanceof EngineError) return error;\n  if (error instanceof Error) {\n    return ErrorFactory.internal({\n      code: \"UNEXPECTED_ERROR\",\n      message: error.message,\n      context: { originalErrorName: error.name },\n      cause: error,\n      recoverable: true,\n    });\n  }\n  return ErrorFactory.internal({\n    code: \"UNKNOWN_ERROR\",\n    message: \"An unknown error occurred\",\n    context: { error: String(error) },\n    recoverable: true,\n  });\n}\n","import { type EngineError, normalizeUnknownError } from \"@solve-js/errors/EngineError\";\n\n/**\n * A Rust-style `Result<T, E>`, the value half of this engine's error-handling\n * redesign. `E` defaults to `EngineError` (this engine's structured error\n * type) but every combinator here is generic over `E`, so `Result` works\n * equally well for a domain that isn't `EngineError`-shaped.\n *\n * This exact shape used to live in `errors/UnifiedErrorFramework.ts` (kept\n * there as a barrel re-export for backward compatibility), moved here as\n * its own module because it's genuinely generic (no dependency on\n * `EngineError` beyond the default type parameter) and because the engine\n * is migrating callers to it incrementally: parsing/VM/package code that\n * expects \"a failure is a possibility, not an exception\" returns\n * `Result<T, EngineError>` instead of throwing; two explicit adapters\n * {@link throwIfErr} and {@link tryCatch}, are the sanctioned way to cross\n * the boundary between Result-based code and still-throw-based code during\n * the migration (and permanently, at the public API boundary. See\n * `ExpressionEngine.evaluateExpression()`'s documented throw contract).\n */\nexport type Result<T, E = EngineError> =\n  | { ok: true; value: T }\n  | { ok: false; error: E };\n\n/** Wrap a successful value. */\nexport function ok<T>(value: T): Result<T, never> {\n  return { ok: true, value };\n}\n\n/** Wrap a failure. */\nexport function err<E>(error: E): Result<never, E> {\n  return { ok: false, error };\n}\n\n/**\n * Narrow a {@link Result} to its success arm.\n *\n * @param r - The result to test.\n * @returns True when it succeeded, narrowing `r` so `r.value` is reachable.\n */\nexport function isOk<T, E>(r: Result<T, E>): r is { ok: true; value: T } {\n  return r.ok;\n}\n\n/**\n * Narrow a {@link Result} to its failure arm.\n *\n * @param r - The result to test.\n * @returns True when it failed, narrowing `r` so `r.error` is reachable.\n */\nexport function isErr<T, E>(r: Result<T, E>): r is { ok: false; error: E } {\n  return !r.ok;\n}\n\n/** Transform the success value; a failure passes through untouched. */\nexport function map<T, U, E>(r: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  return r.ok ? ok(fn(r.value)) : r;\n}\n\n/** Transform the error; a success passes through untouched. */\nexport function mapErr<T, E, F>(r: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  return r.ok ? r : err(fn(r.error));\n}\n\n/** Chain a Result-returning operation onto a success (a.k.a. flatMap/bind). */\nexport function andThen<T, U, E>(r: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  return r.ok ? fn(r.value) : r;\n}\n\n/** Unwrap a success, or return `fallback` for a failure. Never throws. */\nexport function unwrapOr<T, E>(r: Result<T, E>, fallback: T): T {\n  return r.ok ? r.value : fallback;\n}\n\n/** Exhaustive pattern-match, the `match`/`switch` a Rust enum gets for free. */\nexport function match<T, E, R>(r: Result<T, E>, arms: { ok: (value: T) => R; err: (error: E) => R }): R {\n  return r.ok ? arms.ok(r.value) : arms.err(r.error);\n}\n\n/**\n * Combine several Results into one, succeeds with a tuple of all values\n * iff every input succeeded; otherwise fails with the FIRST error\n * encountered (left-to-right), matching this codebase's existing\n * fail-fast convention elsewhere (e.g. `BytecodeBuilder`'s constant-pool\n * limit checks).\n */\nexport function combine<T extends readonly unknown[], E>(\n  results: { [K in keyof T]: Result<T[K], E> },\n): Result<T, E> {\n  const values: unknown[] = [];\n  for (const r of results as readonly Result<unknown, E>[]) {\n    if (!r.ok) return r;\n    values.push(r.value);\n  }\n  return ok(values as unknown as T);\n}\n\n/**\n * Cross from Result-space back to throw-space, the sanctioned boundary\n * adapter for callers (public API surface, older not-yet-migrated code,\n * tests) that still want exception-based control flow. Throws `r.error`\n * as-is (an `EngineError` is already a real `Error` subclass, so this\n * needs no wrapping).\n */\nexport function throwIfErr<T, E>(r: Result<T, E>): T {\n  if (r.ok) return r.value;\n  throw r.error;\n}\n\n/**\n * Cross from throw-space into Result-space, runs `fn`, converting any\n * thrown value into a Result via `normalize` (defaults to\n * {@link normalizeUnknownError}). The inverse of {@link throwIfErr}; the\n * pairing that lets Result-based and throw-based code interoperate during\n * an incremental migration instead of requiring a single flag-day rewrite.\n */\nexport function tryCatch<T>(\n  fn: () => T,\n  normalize: (e: unknown) => EngineError = normalizeUnknownError,\n): Result<T, EngineError> {\n  try {\n    return ok(fn());\n  } catch (e) {\n    return err(normalize(e));\n  }\n}\n\n/** Async sibling of {@link tryCatch}. */\nexport async function tryCatchAsync<T>(\n  fn: () => Promise<T>,\n  normalize: (e: unknown) => EngineError = normalizeUnknownError,\n): Promise<Result<T, EngineError>> {\n  try {\n    return ok(await fn());\n  } catch (e) {\n    return err(normalize(e));\n  }\n}\n","/**\n * The built-in error-code catalog, one typed const object per domain\n * unioned together here for autocomplete/exhaustiveness in core engine\n * code. Deliberately NOT one central enum: `IEnginePackage` is documented\n * public SDK surface for third-party packages (see `api/PackageRegistry.ts`),\n * and a closed enum would block an external package author from defining\n * their own codes without editing this file. `EngineError.code`'s runtime\n * type stays `string` for exactly that reason. This catalog is for the\n * codes THIS repo owns and wants collision/typo checking on (see\n * `__tests__/errors/ErrorCodeCatalog.spec.ts`), not a hard runtime\n * whitelist.\n *\n * As each package migrates to `Result<void, EngineError>` (see this\n * session's error-handling-refactor plan, Phase 5), it should export its\n * own small `XxxErrorCodes` const object co-located with its parselets\n * exactly like `CoreErrorCodes` below, just scoped to one domain, and get\n * unioned into `ErrorCode` here. Until a package migrates, its existing\n * free-string codes keep working (ErrorFactory accepts any string); they\n * just aren't caught by the catalog's uniqueness/orphan checks yet.\n */\n\n/**\n * Codes used directly by the parser/VM/engine/errors layers themselves\n * confirmed against the current source, not aspirational. Grouped by\n * pipeline stage via the comments, not a naming prefix (these predate any\n * naming convention and renaming them is out of scope for introducing the\n * catalog, only NEW codes need to follow a scoped/prefixed style, see\n * `STACK_UNDERFLOW` etc. below).\n */\nexport const CoreErrorCodes = {\n  // ── Parser (parser/PrecedenceParser.ts, parser/BytecodeBuilder.ts, parser/PhrasePattern.ts) ──\n  INVALID_NUMBER_LITERAL: \"INVALID_NUMBER_LITERAL\",\n  /** A `\"` that never meets its closing partner (`lexer/ExpressionLexer.ts`'s `tokenizeString()`). Previously the tokenizer ran off the end of the input and returned what it had, so `\"abc` lexed to an ordinary String and an unterminated literal was indistinguishable from a terminated one. */\n  UNTERMINATED_STRING: \"UNTERMINATED_STRING\",\n  NO_PREFIX_PARSELET: \"NO_PREFIX_PARSELET\",\n  UNEXPECTED_END_OF_INPUT: \"UNEXPECTED_END_OF_INPUT\",\n  UNEXPECTED_TOKEN_TYPE: \"UNEXPECTED_TOKEN_TYPE\",\n  NESTING_DEPTH_EXCEEDED: \"NESTING_DEPTH_EXCEEDED\",\n  UNEXPECTED_END: \"UNEXPECTED_END\",\n  UNEXPECTED_TRAILING_TOKEN: \"UNEXPECTED_TRAILING_TOKEN\",\n  PARSE_ERROR: \"PARSE_ERROR\",\n  TOO_MANY_NUMERIC_CONSTANTS: \"TOO_MANY_NUMERIC_CONSTANTS\",\n  /** A raw bytecode operand outside 0 to 255, or a jump patch outside the emitted stream (`parser/BytecodeBuilder.ts`'s `emitIndex`, `emitByte`, `patchJump`). `build()` keeps one byte per operand, so 300 used to become 44 with no error and the program read the wrong constant or plugin function. A package-authoring fault, reported at compile time. */\n  BYTECODE_OPERAND_OUT_OF_RANGE: \"BYTECODE_OPERAND_OUT_OF_RANGE\",\n  TOO_MANY_STRING_CONSTANTS: \"TOO_MANY_STRING_CONSTANTS\",\n  NO_MATCHING_PHRASE_ALTERNATIVE: \"NO_MATCHING_PHRASE_ALTERNATIVE\",\n  INVALID_PHRASE_PATTERN: \"INVALID_PHRASE_PATTERN\",\n  PHRASE_KEYWORD_MISMATCH: \"PHRASE_KEYWORD_MISMATCH\",\n  /** User-defined-function definition parsing (`f(x, y) = ...`), an invalid token where a parameter name was expected. */\n  USER_FUNCTION_INVALID_PARAM_NAME: \"USER_FUNCTION_INVALID_PARAM_NAME\",\n  /** `f() = ...` with zero parameters, indistinguishable from a plain no-arg function call, so rejected at definition time. */\n  USER_FUNCTION_NO_PARAMS: \"USER_FUNCTION_NO_PARAMS\",\n  /** A user-defined function body calling an async plugin (weather/stocks/currency/...), rejected at definition time; v1 scope excludes async function bodies. */\n  FUNCTION_BODY_MUST_BE_SYNCHRONOUS: \"FUNCTION_BODY_MUST_BE_SYNCHRONOUS\",\n  /** `BytecodeBuilder`'s `userFunctionBodies` side-table exceeding its capacity. Same class as `TOO_MANY_NUMERIC_CONSTANTS`/`TOO_MANY_STRING_CONSTANTS` below. */\n  TOO_MANY_FUNCTION_DEFINITIONS: \"TOO_MANY_FUNCTION_DEFINITIONS\",\n  /** `BytecodeBuilder`'s `anonymousBodies` side-table (map/reduce inline transform bodies) exceeding its capacity. Same class as `TOO_MANY_FUNCTION_DEFINITIONS` above. */\n  TOO_MANY_ANONYMOUS_BODIES: \"TOO_MANY_ANONYMOUS_BODIES\",\n  /** New with the 2.0 descriptor redesign: a parselet emits a plugin call by NAME (`BytecodeBuilder.emitPluginCall(name, argCount)`) and the engine resolves that name to the index it assigned at registration. This fires when the name is absent from the builder's name->index map: the package used a `pluginFunctions` name it never declared, or the expression was parsed before that package registered. Not a user-input error; a package-authoring/registration fault. See `parser/BytecodeBuilder.ts`'s `emitPluginCall()`. */\n  UNKNOWN_PLUGIN_FUNCTION: \"UNKNOWN_PLUGIN_FUNCTION\",\n\n  // ── VM (vm/VM.ts, vm/OpRegistry.ts, vm/VMBuiltins.ts) ──\n  EVALUATION_ERROR: \"EVALUATION_ERROR\",\n  INSTRUCTION_LIMIT_EXCEEDED: \"INSTRUCTION_LIMIT_EXCEEDED\",\n  STACK_LIMIT_EXCEEDED: \"STACK_LIMIT_EXCEEDED\",\n  /** One evaluation asking for more elements (collection Values, matrix cells) than `vm.maxAllocatedElements` allows. The counter the two limits above cannot be: both are checked between opcodes, so neither can see what a single opcode allocates inside a loop of its own. See `vm/AllocationBudget.ts`. Recoverable, since it describes this expression rather than the engine. */\n  ALLOCATION_LIMIT_EXCEEDED: \"ALLOCATION_LIMIT_EXCEEDED\",\n  /** New this phase. See `VM.ts`'s `safePop()`: a stack-underflow (corrupted bytecode, a buggy plugin) is now a controlled EngineError instead of a raw TypeError. Category INTERNAL, since it is an engine or plugin fault rather than a typed line, but recoverable: it happened on one line and the engine is still usable. */\n  STACK_UNDERFLOW: \"STACK_UNDERFLOW\",\n  UNDEFINED_VARIABLE: \"UNDEFINED_VARIABLE\",\n  /** New this phase, the Tier-2/`LOAD_GLOBAL_VAR` hardening: a global variable read before its async preflight resolved, surfaced as a controlled error instead of pushing `undefined`. */\n  GLOBAL_VARIABLE_NOT_RESOLVED: \"GLOBAL_VARIABLE_NOT_RESOLVED\",\n  UNKNOWN_FUNCTION: \"UNKNOWN_FUNCTION\",\n  /** `unwrapEvalResult()`'s pending-when-expecting-value case, a caller-contract violation, not user-input. */\n  UNEXPECTED_PENDING_RESULT: \"UNEXPECTED_PENDING_RESULT\",\n  /** User-defined-function call/definition errors (`CALL_USER_FUNCTION`/`DEFINE_USER_FUNCTION` opcodes), calling a name with no matching definition, calling with the wrong argument count, and the deliberate v1 restriction that a function body can't itself contain async work. */\n  UNDEFINED_FUNCTION: \"UNDEFINED_FUNCTION\",\n  FUNCTION_ARITY_MISMATCH: \"FUNCTION_ARITY_MISMATCH\",\n  /** The same mistake against a BUILT-IN rather than a user-defined function (`sqrt()`, `atan2(1)`, `sqrt(1,2,3)`). Separate from `FUNCTION_ARITY_MISMATCH` above because the two are raised by different opcodes and a host may want to word them differently. Checked at the `CALL_BUILTIN` dispatch against `vm/VMBuiltinArity.ts`; recoverable, since it is a typo in the line, not an engine fault. */\n  BUILTIN_ARITY_MISMATCH: \"BUILTIN_ARITY_MISMATCH\",\n  USER_FUNCTION_ASYNC_UNSUPPORTED: \"USER_FUNCTION_ASYNC_UNSUPPORTED\",\n  /** A map/reduce transform body (inline expression or user-defined function) calling an async plugin. Same v1 scope restriction as `USER_FUNCTION_ASYNC_UNSUPPORTED` above, enforced both at parse time (`MAP_REDUCE_TRANSFORM_MUST_BE_SYNCHRONOUS`, packages/mapreduce/) and as a defense-in-depth runtime backstop here. */\n  MAP_REDUCE_ASYNC_UNSUPPORTED: \"MAP_REDUCE_ASYNC_UNSUPPORTED\",\n  /** An algebra verb's expression argument (`BIND_UNKNOWN`'s body) calling an async plugin. Same v1 scope restriction as the two above, and likewise refused at parse time first (`SYMBOLIC_ARGUMENT_MUST_BE_SYNCHRONOUS`, packages/symbolic/). */\n  SYMBOLIC_ASYNC_UNSUPPORTED: \"SYMBOLIC_ASYNC_UNSUPPORTED\",\n  /** `explainLine()` asked to derive a line that resolves data asynchronously (a live-data or async-plugin line). A derivation is a sequence of settled intermediate values, which a pending result has none of, so the line is refused rather than explained with a hole in it. */\n  EXPLAIN_ASYNC_UNSUPPORTED: \"EXPLAIN_ASYNC_UNSUPPORTED\",\n  /** `pushCallFrame()`'s recursion guard, a nested `CALL_USER_FUNCTION` re-enters `executeBytecode()`, so `maxInstructions` alone can't catch e.g. `f(x) = f(x)`; this is the dedicated backstop. `recoverable: true` (the default for `.execution()`), ordinary user-written infinite recursion, not an engine bug; the guard exists precisely so it surfaces as a clear error instead of overflowing the native call stack uncatchably. */\n  FUNCTION_RECURSION_LIMIT_EXCEEDED: \"FUNCTION_RECURSION_LIMIT_EXCEEDED\",\n  /** The companion to the code above, and the half it could never see: how MANY user-defined-function calls one evaluation makes, rather than how deeply they nest. A twenty-two-line doubling chain nests twenty-two deep (legal) and makes two million calls (a fatal heap abort). Counted in `vm/AllocationBudget.ts`, because the tally has to survive `executeBytecode()` re-entering itself. Recoverable. */\n  FUNCTION_CALL_LIMIT_EXCEEDED: \"FUNCTION_CALL_LIMIT_EXCEEDED\",\n  /** A `<date> + N workdays` offset outside `date.maxOffsetYears`/`minOffsetYears`. Workdays are the one date offset that walks the calendar a day at a time, so the one whose cost is the offset; every other one moves a Date field once. Recoverable. */\n  DATE_OFFSET_LIMIT_EXCEEDED: \"DATE_OFFSET_LIMIT_EXCEEDED\",\n  /** The anchor of `N working days after/before/from <expr>` was not a date (e.g. `5 working days after 3`). The grammar guarantees the count is a number, so this only fires on the anchor. Emitted as a recoverable Error value, not thrown, matching the datetime package's other type guards. See `vm/VM.ts`'s `DATE_WORKDAY_OFFSET` case. */\n  WORKDAY_OFFSET_EXPECTED_DATE: \"WORKDAY_OFFSET_EXPECTED_DATE\",\n  /** An endpoint of `working days between <expr> and <expr>` was not a date. Recoverable Error value. See `vm/VM.ts`'s `DATE_WORKDAYS_BETWEEN` case. */\n  WORKDAYS_BETWEEN_EXPECTED_DATES: \"WORKDAYS_BETWEEN_EXPECTED_DATES\",\n  /** The two endpoints of `working days between <expr> and <expr>` are further apart than `date.maxOffsetYears`/`minOffsetYears` allow the count's calendar walk to run. Recoverable Error value, the between-count's equivalent of `DATE_OFFSET_LIMIT_EXCEEDED`. See `vm/VM.ts`'s `DATE_WORKDAYS_BETWEEN` case. */\n  WORKDAYS_BETWEEN_RANGE_TOO_LARGE: \"WORKDAYS_BETWEEN_RANGE_TOO_LARGE\",\n  /** A `<<`/`>>` with a bigint operand whose exact result would pass `MAX_EXACT_SHIFT_BITS`, whichever operand is the bigint. Both spellings refuse as of 1.0.0: a bigint on the left used to fall through to `x * 2^n` in doubles and report a 19,870-digit integer as Infinity. See `vm/VM.ts`'s `bigIntShift()`. Recoverable. */\n  BIGINT_SHIFT_LIMIT_EXCEEDED: \"BIGINT_SHIFT_LIMIT_EXCEEDED\",\n  /** The same ceiling for `^`, the operator it was written for: `2n ^ 100000` asks for the same 100,001-bit integer `1n << 100000` does, so the two spellings answer the same way. Also new in 1.0.0, and for the same reason: this used to fall through to the double path and answer Infinity. A fractional or negative exponent (`4n ^ 0.5`, `2n ^ -1`) has no exact answer to bound and still uses the double path. See `vm/VM.ts`'s `MAX_EXACT_POW_BITS`. Recoverable. */\n  BIGINT_POW_LIMIT_EXCEEDED: \"BIGINT_POW_LIMIT_EXCEEDED\",\n  /** An operand with no whole-number form (a fraction, an infinity, a NaN) meeting a bigint: `1n + 0.5`, `1n & 1.5`, `5n/pi`. `BigInt()` answers those with a raw RangeError, which the VM relabelled UNEXPECTED_ERROR, so a typo in the line was reported as an engine fault. Recoverable; see `vm/VMConversion.ts`'s `toBigIntOperand()`. */\n  BIGINT_INEXACT_OPERAND: \"BIGINT_INEXACT_OPERAND\",\n  /** `10n / 0n` and `10n mod 0n`. Deliberately NOT what `1 / 0` does, which is Infinity: a bigint division is exact integer division (`7n / 2n` is 3n), and integer division by zero has no answer, exactly as it has none in C, Java, Python or JavaScript's own BigInt. Previously V8's own RangeError, relabelled UNEXPECTED_ERROR. Recoverable; see `vm/VMConversion.ts`'s `bigIntDivisionByZero()`. */\n  BIGINT_DIVISION_BY_ZERO: \"BIGINT_DIVISION_BY_ZERO\",\n  /** `DEFINE_USER_FUNCTION`'s body-index lookup failing, a compiler/VM invariant violation (the opcode stream referenced a `userFunctionBodies` slot that doesn't exist), never a user-input error. */\n  INTERNAL_MISSING_FUNCTION_BODY: \"INTERNAL_MISSING_FUNCTION_BODY\",\n  /** `MAP_INVOKE`/`REDUCE_INVOKE`'s anonymous-body-index lookup failing. Same class as `INTERNAL_MISSING_FUNCTION_BODY` above, for the `anonymousBodies` side-table instead of `userFunctionBodies`. */\n  INTERNAL_MISSING_ANONYMOUS_BODY: \"INTERNAL_MISSING_ANONYMOUS_BODY\",\n  /** `CALL_BUILTIN` naming an index no builtin is registered at. It used to pop its arguments and push nothing, so the opcode after it read a neighbour's operand as its own; now an Error value on the stack, the shape `map`/`reduce` already used for the same fault. Bytecode-level, so unreachable from source without a compiler or snapshot fault. */\n  UNKNOWN_BUILTIN_FUNCTION: \"UNKNOWN_BUILTIN_FUNCTION\",\n\n  // ── Malformed bytecode on the public `./vm` surface (vm/VM.ts) ──\n  //\n  // `executeBytecode` is exported, so a bytecode program is caller input in\n  // the same sense an expression string is, and these five say so. They are\n  // VALIDATION rather than INTERNAL for exactly that reason: before they\n  // existed, every one of these cases reached a raw TypeError (`BigInt(undefined)`,\n  // `code.toUpperCase()` on a boolean, destructuring a program that was not\n  // there), which normalised to UNEXPECTED_ERROR and told the caller the\n  // engine was broken when their eleven bytes were. Reachable from ordinary\n  // source only through a compiler bug, which is why the messages name the\n  // opcode and the operand rather than the user's line.\n  /** An operand byte read past the end of the stream: the program ends in the middle of an instruction. */\n  MALFORMED_BYTECODE_TRUNCATED: \"MALFORMED_BYTECODE_TRUNCATED\",\n  /** A constant-pool operand indexing a `numbers`/`strings` entry that does not exist, or that is not of the pool's type. */\n  MALFORMED_BYTECODE_CONSTANT_INDEX: \"MALFORMED_BYTECODE_CONSTANT_INDEX\",\n  /** A unit or converter name read off the value stack that is not a string. Distinct from the pool case above: the operand is a Value another opcode pushed, not a pool entry. */\n  MALFORMED_BYTECODE_OPERAND_TYPE: \"MALFORMED_BYTECODE_OPERAND_TYPE\",\n  /** `MAP_INVOKE`/`REDUCE_INVOKE` carrying a body kind other than 0/1/2. Used to fall through every arm with no body and recurse into `executeBytecode(undefined)`. */\n  MALFORMED_BYTECODE_BODY_KIND: \"MALFORMED_BYTECODE_BODY_KIND\",\n  /** A `PUSH_BIGINT` pool entry that is not a whole number, e.g. `\"1.000\"`. `BigInt()` answers that with a raw SyntaxError. */\n  MALFORMED_BYTECODE_BIGINT_LITERAL: \"MALFORMED_BYTECODE_BIGINT_LITERAL\",\n  /** `executeBytecode()` called with something that is not a runnable program at all. Checked before the destructure that used to throw outside the function's own try/catch. */\n  MALFORMED_BYTECODE_PROGRAM: \"MALFORMED_BYTECODE_PROGRAM\",\n\n  // ── Symbolic algebra (symbolic/, vm/SymbolicOps.ts) ──\n  /** A coefficient grew past `RATIONAL_MAX_BITS`, e.g. repeated exact elimination multiplying denominators together. */\n  SYMBOLIC_RATIONAL_OVERFLOW: \"SYMBOLIC_RATIONAL_OVERFLOW\",\n  /** `NaN` or `±Infinity` reaching a symbolic expression, neither of which has an exact rational value. */\n  SYMBOLIC_NONFINITE_OPERAND: \"SYMBOLIC_NONFINITE_OPERAND\",\n  /** Division by an exactly-zero rational. Exact, unlike the double comparison it replaced, which could not distinguish a true zero from `5.551e-17`. */\n  SYMBOLIC_DIVISION_BY_ZERO: \"SYMBOLIC_DIVISION_BY_ZERO\",\n  /** A tree exceeding `SYMBOLIC_MAX_NODES` entering the simplifier. */\n  SYMBOLIC_NODE_LIMIT_EXCEEDED: \"SYMBOLIC_NODE_LIMIT_EXCEEDED\",\n  /** A builtin with no symbolic reading (`min`, `random`, the finance block, ...) applied to an expression still containing an unknown. Returned rather than computing against `toNumber()`'s placeholder zero. */\n  SYMBOLIC_UNSUPPORTED_FUNCTION: \"SYMBOLIC_UNSUPPORTED_FUNCTION\",\n  /** The rational-root search exceeding `FACTOR_MAX_ROOT_CANDIDATES`. The candidate set is the product of two divisor sets, so a highly-composite coefficient escapes quickly. */\n  SYMBOLIC_FACTOR_LIMIT_EXCEEDED: \"SYMBOLIC_FACTOR_LIMIT_EXCEEDED\",\n  /** An equation outside what the solver attempts: not a polynomial, above the degree ceiling, or non-linear in the unknown while another unknown is present. */\n  SYMBOLIC_SOLVE_UNSUPPORTED: \"SYMBOLIC_SOLVE_UNSUPPORTED\",\n  /** Some but not all of an equation's roots were found. Reported rather than returned, because a partial list of roots looks exactly like a complete one. */\n  SYMBOLIC_SOLVE_INCOMPLETE: \"SYMBOLIC_SOLVE_INCOMPLETE\",\n  /** `solve`'s second argument not being a bare name. */\n  SOLVE_REQUIRES_VARIABLE_NAME: \"SOLVE_REQUIRES_VARIABLE_NAME\",\n  /** A derivative order outside 0..`DERIVATIVE_MAX_ORDER`. */\n  SYMBOLIC_DERIVATIVE_ORDER_LIMIT: \"SYMBOLIC_DERIVATIVE_ORDER_LIMIT\",\n  /** An expression with no known elementary antiderivative. Reported rather than approximated, since a wrong integral is indistinguishable from a right one at the point of use. */\n  SYMBOLIC_INTEGRAL_UNSUPPORTED: \"SYMBOLIC_INTEGRAL_UNSUPPORTED\",\n  /** A Taylor degree outside 0..`TAYLOR_MAX_DEGREE`. */\n  SYMBOLIC_TAYLOR_DEGREE_LIMIT: \"SYMBOLIC_TAYLOR_DEGREE_LIMIT\",\n  /** A Taylor coefficient that does not reduce to an exact number at the expansion point. */\n  SYMBOLIC_TAYLOR_INEXACT: \"SYMBOLIC_TAYLOR_INEXACT\",\n  /** An algebra verb's variable-name argument not being a bare name. */\n  SYMBOLIC_REQUIRES_VARIABLE_NAME: \"SYMBOLIC_REQUIRES_VARIABLE_NAME\",\n  /** `jacobian` called with expressions containing no unknown to differentiate against. */\n  SYMBOLIC_JACOBIAN_NO_VARIABLES: \"SYMBOLIC_JACOBIAN_NO_VARIABLES\",\n  /** A finite number whose decimal form could not be read back, which the regex covering every `Number.prototype.toString` output should make unreachable. */\n  INTERNAL_RATIONAL_PARSE: \"INTERNAL_RATIONAL_PARSE\",\n\n  // ── Engine (engine/ExpressionEngine.ts, engine/ExpressionEngineSafety.ts, engine/AsyncResolutionBatcher.ts) ──\n  EXPRESSION_TOO_LONG: \"EXPRESSION_TOO_LONG\",\n  EXPRESSION_TOO_COMPLEX: \"EXPRESSION_TOO_COMPLEX\",\n  /** A document with more lines than `performance.maxDocumentLines`. The per-line limits above bound what one line may ask for and say nothing about how many lines there are; two hundred thousand of `1 + 1` exhausted the heap on the line records alone. Recoverable. */\n  DOCUMENT_TOO_LARGE: \"DOCUMENT_TOO_LARGE\",\n  NORMALIZED_TOKEN_LIMIT_EXCEEDED: \"NORMALIZED_TOKEN_LIMIT_EXCEEDED\",\n  /** `\"=>\"` with nothing before it, needs an expression or variable name to solve/simplify. */\n  THEREFORE_REQUIRES_EXPRESSION: \"THEREFORE_REQUIRES_EXPRESSION\",\n  /** A `\"=>\"`-triggered expression called an async plugin (weather/stocks/currency). Same v1 scope restriction as user-function/map-reduce bodies. */\n  THEREFORE_ASYNC_UNSUPPORTED: \"THEREFORE_ASYNC_UNSUPPORTED\",\n  /** A compound assignment (`name += expr` / `name -= expr`) with nothing on the right, a line half-typed on the way to `total += 5`. */\n  COMPOUND_ASSIGN_REQUIRES_EXPRESSION: \"COMPOUND_ASSIGN_REQUIRES_EXPRESSION\",\n  /** A running total (`+= / -=`) whose right-hand side calls an async plugin (weather/stocks/currency). The same v1 scope restriction as the `\"=>\"` and user-function bodies. */\n  COMPOUND_ASSIGN_ASYNC_UNSUPPORTED: \"COMPOUND_ASSIGN_ASYNC_UNSUPPORTED\",\n  /** A savings-goal contribution period that is not one of daily/weekly/monthly/yearly (`how long to save $X at $Y <period>`). Names the accepted set. */\n  UNKNOWN_SAVINGS_PERIOD: \"UNKNOWN_SAVINGS_PERIOD\",\n  /** Colon-separated numbers that are not a time any clock can show (\"24:00\", \"9:60\", \"100:5\"). Raised by the labeled-line fallback, which used to answer them with whatever stood after the colon. */\n  INVALID_TIME_LITERAL: \"INVALID_TIME_LITERAL\",\n  /** A live-data form evaluated on an engine whose host switched the network off (`network.enabled: false`, see `constants/Configuration.ts`'s `NetworkConfig`). A recoverable Error value, raised by the VM for a currency conversion with no primed rate and for a plugin function that returned a promise, and by `createQueryResolver`'s plugin function when its preflight was skipped. Names the setting, so the reader knows it is policy rather than an outage. */\n  NETWORK_DISABLED: \"NETWORK_DISABLED\",\n\n  // ── Temporal calendar backend (temporal/TemporalCalendar.ts) ──\n  /** `createTemporalCalendar()` was handed something that is not a usable `Temporal` implementation: no `Now.instant`, `Now.timeZoneId`, `Instant.fromEpochMilliseconds` or `PlainDateTime.from`. Raised at construction, naming the missing member, rather than letting the first date computation fail on it obscurely. */\n  TEMPORAL_IMPLEMENTATION_INVALID: \"TEMPORAL_IMPLEMENTATION_INVALID\",\n  /** The `timeZone` given to `createTemporalCalendar()` is not one the `Temporal` implementation knows. Raised at construction, so a misspelt zone is a configuration error the host sees once, not a `RangeError` from inside every date the engine computes. */\n  TEMPORAL_TIME_ZONE_UNKNOWN: \"TEMPORAL_TIME_ZONE_UNKNOWN\",\n\n  // ── Snapshot / restore (engine/EngineSnapshot.ts, engine/ExpressionEngine.ts) ──\n  /** `fromJSON()` handed an object that is not a snapshot at all, or whose serialised-shape version does not match this engine's reader. The versioning gate that refuses an incompatible snapshot clearly rather than restoring it wrongly. See `engine/EngineSnapshot.ts`'s `assertRestorable()`. */\n  SNAPSHOT_VERSION_MISMATCH: \"SNAPSHOT_VERSION_MISMATCH\",\n  /** A snapshot with the right envelope but internally inconsistent contents (an unrecognised number sentinel, an unknown value tag). Distinct from a version mismatch: the format is right, the payload is not. */\n  SNAPSHOT_MALFORMED: \"SNAPSHOT_MALFORMED\",\n  /** A value the v1 snapshot format cannot yet represent (a symbolic/algebra value, a symbolic matrix cell). Deferred to a follow-up; refused by name rather than dropped silently. */\n  SNAPSHOT_UNSUPPORTED_VALUE: \"SNAPSHOT_UNSUPPORTED_VALUE\",\n\n  // ── Config (constants/Configuration.ts) ──\n  CONFIG_PATH_NOT_FOUND: \"CONFIG_PATH_NOT_FOUND\",\n  INVALID_CONFIG_PATH: \"INVALID_CONFIG_PATH\",\n  CONFIG_SECTION_NOT_FOUND: \"CONFIG_SECTION_NOT_FOUND\",\n  CONFIG_PROPERTY_NOT_FOUND: \"CONFIG_PROPERTY_NOT_FOUND\",\n\n  // ── Package/lexer registration-time collisions (lexer/ExpressionLexer.ts) ──\n  /** `calendar: \"temporal\"` was asked for on a runtime with no `Temporal`. Refused rather than silently computing on `Date`, because a host that named Temporal did so to be sure what it was computing on. Recoverable. */\n  CALENDAR_TEMPORAL_UNAVAILABLE: \"CALENDAR_TEMPORAL_UNAVAILABLE\",\n  PLUGIN_OPERATOR_COLLISION: \"PLUGIN_OPERATOR_COLLISION\",\n  PLUGIN_KEYWORD_COLLISION: \"PLUGIN_KEYWORD_COLLISION\",\n  PLUGIN_UNIT_COLLISION: \"PLUGIN_UNIT_COLLISION\",\n  /** A package's declared `IEnginePackage.engineVersion` semver range doesn't satisfy the running engine's ENGINE_VERSION. See api/EngineVersionCompatibility.ts. */\n  PACKAGE_ENGINE_VERSION_MISMATCH: \"PACKAGE_ENGINE_VERSION_MISMATCH\",\n  /** A package's declared `IEnginePackage.engineVersion` isn't a parseable semver range at all (a typo in the package's own descriptor). */\n  PACKAGE_ENGINE_VERSION_INVALID_RANGE: \"PACKAGE_ENGINE_VERSION_INVALID_RANGE\",\n  /** `OpRegistry.allocateOpcode()`'s dynamic opcode pool (started at 201) exhausted, too many packages calling it. */\n  OPCODE_POOL_EXHAUSTED: \"OPCODE_POOL_EXHAUSTED\",\n  /** `VMBuiltins.allocatePluginFunctionIndex()`'s index pool (up to 65536, two opcode-stream bytes) exhausted. */\n  PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED: \"PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED\",\n  /** A plugin-function index exceeds the two-byte (65535) `CALL_PLUGIN_WIDE` bytecode operand. */\n  PLUGIN_FUNCTION_INDEX_TOO_LARGE: \"PLUGIN_FUNCTION_INDEX_TOO_LARGE\",\n\n  // ── vm/Value.ts caller-contract violations (check isRateUnit()/isTimecodeUnit() first) ──\n  INVALID_RATE_UNIT: \"INVALID_RATE_UNIT\",\n  INVALID_TIMECODE_UNIT: \"INVALID_TIMECODE_UNIT\",\n\n  // ── errors/EngineError.ts's own fallback normalization ──\n  UNEXPECTED_ERROR: \"UNEXPECTED_ERROR\",\n  UNKNOWN_ERROR: \"UNKNOWN_ERROR\",\n} as const;\n\n/** Every error code the engine's own layers can produce, from {@link CoreErrorCodes}. */\nexport type CoreErrorCode = (typeof CoreErrorCodes)[keyof typeof CoreErrorCodes];\n\n/**\n * Codes for the datetime forms whose failure is raised OUTSIDE the datetime\n * package.\n *\n * These sit here rather than beside the datetime parselets, which is where a\n * package's own code object belongs, because the two sites that raise them are\n * `vm/VM.ts` (the `in <zone>` branch of the unit-conversion opcode) and\n * `calendar/DateCalendar.ts` (the zone-bound backend factory), and neither may\n * import from `packages/`. A code object in the datetime package would put the\n * name a core file needs on the wrong side of that line.\n */\nexport const DatetimeErrorCodes = {\n  /** `2026-04-03 in Atlantis`: a Datetime met `in <name>` and the name is neither a zone this engine knows nor a unit. Before this code the epoch-millisecond payload was simply labelled with the name, and the line answered a fourteen-digit quantity in a unit called Atlantis. */\n  DATETIME_ZONE_UNKNOWN: \"DATETIME_ZONE_UNKNOWN\",\n  /** `2026-04-03 in furlongs`: the same handler, where the name IS a real unit. Separate from `DATETIME_ZONE_UNKNOWN` because the two mistakes have different fixes: one is a misspelt zone, the other is a category error, and a message that suggests checking the spelling of `furlongs` would be no help at all. */\n  DATETIME_NOT_CONVERTIBLE: \"DATETIME_NOT_CONVERTIBLE\",\n  /** `dateCalendarInZone(\"Europe/Atlantis\")`: the zone-bound `Date` backend factory, given a zone this runtime's `Intl` cannot format with. Raised at construction rather than per line, because a backend that cannot compute in the zone it was asked for must not silently answer in another one. */\n  DATE_ZONE_UNKNOWN: \"DATE_ZONE_UNKNOWN\",\n} as const;\n\n/** Every code from {@link DatetimeErrorCodes}. */\nexport type DatetimeErrorCode = (typeof DatetimeErrorCodes)[keyof typeof DatetimeErrorCodes];\n\n/**\n * The aggregated catalog type. Currently `CoreErrorCode` and\n * `DatetimeErrorCode`, union in each package's own code-object type here as\n * Phase 5 converts it, e.g. `CoreErrorCode | WeatherErrorCode | ...`.\n */\nexport type ErrorCode = CoreErrorCode | DatetimeErrorCode;\n"]}

package/dist/chunk-VQO54ZMA.js

@@ -0,0 +1,2 @@
+import {c as c$2}from'./chunk-JP4JMQOG.js';import {b,a as a$2,e,d}from'./chunk-YG7UWQFV.js';import {b as b$1}from'./chunk-BLJ6E577.js';import {c,a}from'./chunk-FAO6DQ74.js';import {a as a$1}from'./chunk-LHLW7JLS.js';import {c as c$1}from'./chunk-VB6QMU2W.js';var D=/^\d{1,3}(\.\d{3}){2,}$/,T=/^\d*\.\d*$/,n=class n{constructor(e,t=50,r="en",l,a=b$1){this.tokens=[];this.current=0;this.depth=0;this.currentExpression="";this.infixMinBindingPower=0;this.registry=e,this.maxDepth=t,this.localeCode=r;let p=a$1(r).display;this.decimalSeparator=p.decimalSeparator,this.thousandsSeparator=p.thousandsSeparator,this.pluginFunctionIndex=l,this.calendar=a;}getLocaleCode(){return this.localeCode}getCalendar(){return this.calendar}setDiagnosticPipeline(e,t){this.diagnosticPipeline=e,this.currentExpression=t??"";}load(e,t){if(t===false){this.tokens=e,this.current=0,this.depth=0;return}let r=c(a.LPAREN),l=c(a.RPAREN),a$1=0;for(let p=0;p<e.length;p++)e[p].typeId===r?a$1++:e[p].typeId===l&&a$1--;this.tokens=a$1===0?e:this.balanceParens(e,a$1),this.current=0,this.depth=0;}balanceParens(e,t){let r=e.slice();if(t>0){let l=c(a.RPAREN);for(let a$1=0;a$1<t;a$1++){let p=e[e.length-1];r.push({type:a.RPAREN,typeId:l,value:")",text:")",offset:p?p.offset+p.text.length:0,lineBreaks:0,line:p?p.line:1,col:p?p.col+p.text.length:1});}}else if(t<0){let l=c(a.LPAREN);for(let a$1=0;a$1<-t;a$1++)r.unshift({type:a.LPAREN,typeId:l,value:"(",text:"(",offset:0,lineBreaks:0,line:1,col:1});}return r}parseExpression(e=0,t){let r=this.builder;t&&(this.builder=t),this.depth++;try{if(this.depth>this.maxDepth)throw c$1.parsing("NESTING_DEPTH_EXCEEDED",`Parse nesting depth ${this.depth} exceeds maximum of ${this.maxDepth}`,{maxDepth:this.maxDepth,currentDepth:this.depth});this.parseExpressionBody(e);}finally{this.depth--,t&&(this.builder=r);}}parseExpressionBody(e){let t=this.consume();if(!t)throw c$1.parsing({code:"UNEXPECTED_END",message:"Unexpected end of expression",span:this.spanAtEnd()});this.parsePrefix(t);let r=this.tokens,l=r.length,a=n.BP_TABLE,p=this.registry,o=this.builder,h=this.current;for(;h<l;){let d=r[h];if(!d)break;let c=a[d.typeId];if(c>0){if(c<=e)break;if(this.diagnosticPipeline){let I=p.getInfix(d.typeId);I&&this.fireParseletMatched(I,d,false,c);}this.current=++h;let f=d.typeId;if(f===n.PERCENT_ID)o.emitOpcode(10),o.emitNumber(100),o.emitOpcode(23),o.emitOpcode(74);else if(!(f===n.CARET_ID&&this.tryEmitMatrixCaretOp(o))){let I=f===n.CARET_ID?c-1:c+1;this.parseExpression(I,o),o.emitOpcode(n.INFIX_OPCODE[f]);}}else {let f=p.getInfix(d.typeId);if(!f||f.bindingPower<=e)break;this.current=++h,this.diagnosticPipeline&&this.fireParseletMatched(f,d,false,f.bindingPower);let I=this.infixMinBindingPower;this.infixMinBindingPower=e;try{f.parse(this,t,d,o);}finally{this.infixMinBindingPower=I;}}h=this.current;}this.current=h;}parsePrefix(e$1){let t=this.builder,r=e$1.typeId;if(this.diagnosticPipeline){let a=this.registry.getPrefix(r);a&&this.fireParseletMatched(a,e$1,true);}switch(r){case n.NUMBER_ID:{let a,p=null,o=e$1.value;if(this.decimalSeparator==="."){let h=0,d=o.length>0;for(let c=0;c<o.length;c++){let f=o.charCodeAt(c);if(!(f>=48&&f<=57)){if(f===46&&h===0){h=1;continue}d=false;break}}if(d){if(h===1){t.emitOpcode(16),t.emitString(o);return}t.emitOpcode(10),t.emitNumber(+o);return}}if(o.startsWith("0x")||o.startsWith("0X")){if(a=parseInt(o,16),Number.isNaN(a))throw c$1.parsing({code:"INVALID_NUMBER_LITERAL",message:`Invalid hex literal: "${o}"`,context:{raw:o},span:this.spanOf(e$1)})}else if(o.startsWith("0b")||o.startsWith("0B")){if(a=parseInt(o.slice(2),2),Number.isNaN(a))throw c$1.parsing({code:"INVALID_NUMBER_LITERAL",message:`Invalid binary literal: "${o}"`,context:{raw:o},span:this.spanOf(e$1)})}else if(o.startsWith("0o")||o.startsWith("0O")){if(a=parseInt(o.slice(2),8),Number.isNaN(a))throw c$1.parsing({code:"INVALID_NUMBER_LITERAL",message:`Invalid octal literal: "${o}"`,context:{raw:o},span:this.spanOf(e$1)})}else if(D.test(o))a=parseFloat(o.split(".").join(""));else {let h=this.decimalSeparator,d=this.thousandsSeparator,c=o;d&&c.indexOf(d)!==-1&&(c=c.split(d).join("")),h&&h!=="."&&(c=c.replace(h,".")),a=parseFloat(c),T.test(c)&&(p=c);}if(p!==null){t.emitOpcode(16),t.emitString(p);return}t.emitOpcode(10),t.emitNumber(a);return}case n.BIGINT_ID:{t.emitOpcode(11),t.emitString(e(e$1.value,this.localeCode));return}case n.STRING_ID:{t.emitOpcode(13),t.emitString(e$1.value);return}case n.IDENT_ID:{if(this.peek()?.typeId===n.LPAREN_ID){this.parseUserFunctionDefOrCall(e$1,t);return}t.emitOpcode(60),t.emitString(e$1.value);return}case n.LPAREN_ID:{this.parseExpression(0,t);let a$1=1;for(;this.match(a.COMMA);)this.parseExpression(0,t),a$1++;this.consume(a.RPAREN),a$1>1&&(t.emitOpcode(152),t.emitIndex(1),t.emitIndex(a$1));return}case n.MINUS_ID:{this.parseExpression(a$2.Prefix,t),t.emitOpcode(26);return}case n.PLUS_ID:{this.parseExpression(a$2.Prefix,t),t.emitOpcode(27);return}case n.KEYWORD_ID:}let l=this.registry.getPrefix(r);if(!l)throw c$1.parsing({code:"NO_PREFIX_PARSELET",message:`No prefix parselet found for token: ${e$1.type} ("${e$1.value}")`,context:{tokenType:e$1.type,tokenValue:e$1.value},span:this.spanOf(e$1)});l.parse(this,e$1,t);}tryEmitMatrixCaretOp(e){for(let t of n.CARET_SUFFIX_RULES)if(t.matches(this))return t.emit(this,e),true;return  false}findMatchingRParen(e){let t=0;for(let r=e;r<this.tokens.length;r++){let l=this.tokens[r];if(l.typeId===n.LPAREN_ID)t++;else if(l.typeId===n.RPAREN_ID&&(t--,t===0))return r}return null}parseUserFunctionDefOrCall(e,t){let r=this.findMatchingRParen(this.current);if(r===null){t.emitOpcode(60),t.emitString(e.value);return}this.tokens[r+1]?.type===a.EQUALS?this.parseUserFunctionDefinition(e,t):this.parseUserFunctionCall(e,t);}consumeParamName(){let e=this.peek();if(e?.type===a.IDENT||e?.type===a.UNIT)return this.consume(),e.value;throw c$1.parsing({code:"USER_FUNCTION_INVALID_PARAM_NAME",message:`Expected a parameter name but got "${e?.type??"end of input"}"${e?` ("${e.value}")`:""}`,context:{actualType:e?.type},span:e?this.spanOf(e):this.spanAtEnd()})}parseUserFunctionDefinition(e,t){this.consume(a.LPAREN);let r=[];if(this.peek()?.type!==a.RPAREN)for(r.push(this.consumeParamName());this.match(a.COMMA);)r.push(this.consumeParamName());if(this.consume(a.RPAREN),this.consume(a.EQUALS),r.length===0)throw c$1.parsing({code:"USER_FUNCTION_NO_PARAMS",message:`"${e.value}()" has no parameters -- user-defined functions need at least one (a zero-argument definition is indistinguishable from a plain function CALL with no args, which this grammar doesn't otherwise support)`,context:{name:e.value},span:this.spanOf(e)});let l=new d(this.pluginFunctionIndex);this.parseExpression(a$2.Lowest,l),this.setBuilder(t);let a$1=l.build();if(a$1.hasAsync)throw c$1.parsing({code:"FUNCTION_BODY_MUST_BE_SYNCHRONOUS",message:`"${e.value}(...)"'s body calls an async operation (weather, stocks, currency, ...) \u2014 user-defined function bodies must be synchronous`,context:{name:e.value},span:this.spanOf(e)});let p=t.emitUserFunctionBody(e.value,r,a$1);t.emitOpcode(150),t.emitIndex(p),t.emitOpcode(13),t.emitString(`${e.value}(${r.join(", ")}) defined`);}parseUserFunctionCall(e,t){this.consume(a.LPAREN);let r=0;if(this.peek()?.type!==a.RPAREN)for(this.parseExpression(a$2.Lowest,t),r++;this.match(a.COMMA);)this.parseExpression(a$2.Lowest,t),r++;this.consume(a.RPAREN),t.emitOpcode(151),t.emitString(e.value),t.emitByte(r);}spanOf(e){return {start:e.offset,end:e.sourceEnd??e.offset+e.text.length,line:e.line,col:e.col}}spanAtEnd(){let e=this.tokens[this.tokens.length-1];if(!e)return {start:0,end:0};let t=e.sourceEnd??e.offset+e.text.length;return {start:t,end:t,line:e.line,col:e.col+(t-e.offset)}}consume(e){let t=this.tokens[this.current];if(!t)throw c$1.parsing({code:"UNEXPECTED_END_OF_INPUT",message:"Unexpected end of input",span:this.spanAtEnd()});if(e!==void 0){let r=c(e);if(t.typeId!==r)throw c$1.parsing({code:"UNEXPECTED_TOKEN_TYPE",message:`Expected token type "${e}" but got "${t.type}" ("${t.value}")`,context:{expectedType:e,actualType:t.type,actualValue:t.value},span:this.spanOf(t)})}return this.current++,t}match(e){let t=this.peek();return t&&t.typeId===c(e)?(this.advance(),true):false}peek(){return this.tokens[this.current]}peekAt(e){return this.tokens[this.current+e]}previous(){return this.current>0?this.tokens[this.current-1]:void 0}advance(){this.current++;}setBuilder(e){this.builder=e;}fireParseletMatched(e,t,r,l){let a=this.diagnosticPipeline,p={type:c$2.ParseletMatched,elapsedNs:0,expression:this.currentExpression,tokenType:t.type,tokenValue:t.value,parseletCategory:e.category,parseletType:e.constructor?.name??"unknown",isPrefix:r,bindingPower:l,tokenOffset:t.offset||0};a.fireParseletMatched(p);}};n.BP_TABLE=b(),n.NUMBER_ID=c(a.NUMBER),n.BIGINT_ID=c(a.BIGINT),n.STRING_ID=c(a.STRING),n.IDENT_ID=c(a.IDENT),n.LPAREN_ID=c(a.LPAREN),n.RPAREN_ID=c(a.RPAREN),n.MINUS_ID=c(a.MINUS),n.PLUS_ID=c(a.PLUS),n.KEYWORD_ID=c(a.KEYWORD),n.STAR_ID=c(a.STAR),n.SLASH_ID=c(a.SLASH),n.MOD_ID=c(a.MOD),n.CARET_ID=c(a.CARET),n.LSHIFT_ID=c(a.LSHIFT),n.RSHIFT_ID=c(a.RSHIFT),n.URSHIFT_ID=c(a.URSHIFT),n.BIT_AND_ID=c(a.BIT_AND),n.BIT_OR_ID=c(a.BIT_OR),n.BIT_XOR_ID=c(a.BIT_XOR),n.PERCENT_ID=c(a.PERCENT),n.OF_ID=c(a.OF),n.INFIX_OPCODE={[c(a.PLUS)]:20,[c(a.MINUS)]:21,[c(a.STAR)]:22,[c(a.SLASH)]:23,[c(a.MOD)]:24,[c(a.CARET)]:25,[c(a.LSHIFT)]:30,[c(a.RSHIFT)]:31,[c(a.URSHIFT)]:32,[c(a.BIT_AND)]:33,[c(a.BIT_OR)]:34,[c(a.BIT_XOR)]:35,[c(a.OF)]:22},n.CARET_SUFFIX_RULES=[{name:"transpose (^T)",matches:e=>{let t=e.peek();return t?.type===a.IDENT&&t.value==="T"},emit:(e,t)=>{e.advance(),t.emitOpcode(51),t.emitIndex(63),t.emitIndex(1);}},{name:"inverse (^-1)",matches:e=>{if(e.peek()?.typeId!==n.MINUS_ID)return  false;let r=e.peekAt(1);return r?.type===a.NUMBER&&r.value==="1"},emit:(e,t)=>{e.advance(),e.advance(),t.emitOpcode(51),t.emitIndex(65),t.emitIndex(1);}}];var v=n;var m=class{constructor(){this.prefixParselets=new Map;this.infixParselets=new Map;this.prefixById=new Map;this.infixById=new Map;}registerPrefix(e,t){let r=this.prefixParselets.get(e);r&&r!==t&&console.warn(`[ParseletRegistry] Prefix parselet for token "${e}" is already registered (category: "${r.category??"unknown"}"). Overwriting with a new parselet (category: "${t.category??"unknown"}") \u2014 the previous parselet is now unreachable. Two packages may be claiming the same token type.`),this.prefixParselets.set(e,t),this.prefixById.set(c(e),t);}registerInfix(e,t){let r=this.infixParselets.get(e);r&&r!==t&&console.warn(`[ParseletRegistry] Infix parselet for token "${e}" is already registered (category: "${r.category??"unknown"}"). Overwriting with a new parselet (category: "${t.category??"unknown"}") \u2014 the previous parselet is now unreachable. Two packages may be claiming the same token type.`),this.infixParselets.set(e,t),this.infixById.set(c(e),t);}getAllPrefix(){let e=[];for(let[t,r]of this.prefixParselets)e.push({tokenType:t,bindingPower:r.bindingPower??a$2.Prefix,category:r.category});return e}getAllInfix(){let e=[];for(let[t,r]of this.infixParselets){let l=r.bindingPower??0;e.push({tokenType:t,leftBindingPower:l,rightBindingPower:l+1,category:r.category});}return e}get prefixCount(){return this.prefixParselets.size}get infixCount(){return this.infixParselets.size}getPrefix(e){return typeof e=="number"?this.prefixById.get(e):this.prefixParselets.get(e)}getInfix(e){return typeof e=="number"?this.infixById.get(e):this.infixParselets.get(e)}hasPrefix(e){return this.prefixParselets.has(e)}hasInfix(e){return this.infixParselets.has(e)}clear(){this.prefixParselets.clear(),this.infixParselets.clear(),this.prefixById.clear(),this.infixById.clear();}},$=new m;export{v as a,m as b,$ as c};//# sourceMappingURL=chunk-VQO54ZMA.js.map
+//# sourceMappingURL=chunk-VQO54ZMA.js.map

package/dist/chunk-VQO54ZMA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parser/PrecedenceParser.ts","../src/parser/registry/ParseletRegistry.ts"],"names":["CHAINED_DOT_THOUSANDS_GROUPS","PLAIN_DECIMAL","_PrecedenceParser","parseletRegistry","maxDepth","localeCode","pluginFunctionIndex","calendar","DATE_CALENDAR","display","getLocale","pipeline","expression","tokens","hasParens","LPAREN_ID","tokenTypeId","TokenTypes","RPAREN_ID","openCount","i","result","lastToken","minBp","_builder","outerBuilder","ErrorFactory","token","len","bpTable","registry","builder","idx","lookahead","bp","infixParselet","typeId","rightBp","outerMinBindingPower","parselet","v","decimalText","raw","dots","plain","c","decimalSep","thousandsSep","normalized","bigIntLiteralDigits","count","BindingPower","prefixParselet","rule","openIdx","depth","t","nameToken","closeIdx","params","bodyBuilder","BytecodeBuilder","bodyProgram","bodyIdx","argCount","last","end","expectedType","expectedId","offset","isPrefix","bindingPower","event","DiagnosticEventType","buildBindingPowerTable","p","next","afterMinus","PrecedenceParser","ParseletRegistry","tokenType","existing","left","sharedParseletRegistry"],"mappings":"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","file":"chunk-VQO54ZMA.js","sourcesContent":["import { ParseletRegistry } from \"@solve-js/parser/registry/ParseletRegistry\";\nimport { Token, tokenTypeId, TokenTypes } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport type { SourceSpan } from \"@solve-js/errors/EngineError\";\nimport { DiagnosticPipeline, DiagnosticEventType, type DiagnosticEvent } from \"@solve-js/diagnostics\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower, buildBindingPowerTable } from \"@solve-js/parser/BindingPower\";\nimport { getLocale } from \"@solve-js/constants/locales\";\nimport { bigIntLiteralDigits } from \"@solve-js/parser/BigIntLiteral\";\nimport type { CalendarBackend } from \"@solve-js/calendar/CalendarBackend\";\nimport { DATE_CALENDAR } from \"@solve-js/calendar/DateCalendar\";\n\n/**\n * Matches a CHAINED thousands-grouped integer using \".\" as the group\n * separator (e.g. \"1.234.567\"), independent of locale. Kept in sync with\n * the identical constant in NumberParselet.ts (not imported from there\n * that file transitively re-imports PrecedenceParser via Parser.ts's\n * `export { PrecedenceParser as Parser }`, so importing the other\n * direction would create a circular dependency for the sake of one\n * regex literal). See NumberParselet.ts's copy for the full explanation.\n */\nconst CHAINED_DOT_THOUSANDS_GROUPS = /^\\d{1,3}(\\.\\d{3}){2,}$/;\n\n/**\n * A plain fractional literal: digits, exactly one dot, digits, nothing else.\n *\n * The gate for compiling to PUSH_DECIMAL. It admits \"0.10\", \"1.005\", \".5\" and\n * \"5.\" and refuses anything with an exponent (\"2.5e-3\"), which parses as an\n * ordinary double instead, since scientific notation has no exact base-ten\n * value this representation would keep.\n */\nconst PLAIN_DECIMAL = /^\\d*\\.\\d*$/;\n\n/**\n * ── Hybrid Precedence Climbing Parser ─────────────────────────────────────────\n *\n * Two-tier dispatch strategy:\n *\n *   Tier 1 (Fast Path): Inline switch on token.typeId for built-in operators.\n *     - Prefix: NUMBER, IDENT, LPAREN, MINUS, PLUS, STRING\n *     - Infix:  checked via static BP_TABLE (Uint8Array indexed by typeId)\n *     - No Map.get(), no parselet function call overhead for ~95% of tokens\n *\n *   Tier 2 (Plugin Path): ParseletRegistry fallback for custom/plugin tokens.\n *     - Prefix: Map.get(tokenTypeId) for PrefixParselet\n *     - Infix:  Map.get(tokenTypeId) for InfixParselet\n *     - Full flexibility for custom syntax\n *\n * The parser emits directly to a BytecodeBuilder, no AST intermediate.\n * Implements the same public API as the legacy Parser class so existing\n * parselets continue to work without modification.\n */\nexport class PrecedenceParser {\n  private tokens: Token[] = [];\n  private current = 0;\n  private depth = 0;\n  private maxDepth: number;\n\n  /** Cached registry reference, avoids property chain in hot loop */\n  private registry: ParseletRegistry;\n\n  /** BytecodeBuilder, set before each parseExpression call */\n  private builder!: BytecodeBuilder;\n\n  /** Diagnostic pipeline for parselet-matched events */\n  private diagnosticPipeline: DiagnosticPipeline | undefined;\n  private currentExpression: string = \"\";\n  private localeCode: string;\n\n  /** The locale's decimal separator, cached from {@link localeCode}. */\n  private readonly decimalSeparator: string;\n\n  /** The locale's thousands separator, cached from {@link localeCode}. */\n  private readonly thousandsSeparator: string;\n\n  /**\n   * The calendar backend of the engine this parser belongs to, for the few\n   * parselets that read a fused date literal or the current year while\n   * parsing (`days in <period>`, the stocks and historical-currency date\n   * phrases). The literal was built through the same backend by the\n   * normaliser, so reading it back here through any other could name the\n   * wrong day. The `Date` backend for a parser built outside an engine.\n   */\n  private readonly calendar: CalendarBackend;\n\n  /**\n   * The binding power the current infix parselet is being invoked at, i.e. the\n   * `minBp` of the expression it sits inside. Set immediately before each Tier-2\n   * parselet runs. A parselet that decides whether to swallow a following\n   * loose operator (UomLiteralParselet with a trailing `in`/`to`) reads this to\n   * respect precedence it cannot otherwise see: `120 km / 2 hours in kph` must\n   * group as `(120 km / 2 hours) in kph`, not `120 km / (2 hours in kph)`.\n   */\n  infixMinBindingPower = 0;\n\n  /**\n   * Static binding power table, built once at module load, shared across all instances.\n   * Index = tokenTypeId, value = binding power (0 = not a built-in infix).\n   */\n  static readonly BP_TABLE: Uint8Array = buildBindingPowerTable();\n\n  // ── Pre-computed token type IDs for inline dispatch ────────────────────────\n  // Prefix built-ins\n  private static readonly NUMBER_ID   = tokenTypeId(TokenTypes.NUMBER);\n  private static readonly BIGINT_ID   = tokenTypeId(TokenTypes.BIGINT);\n  private static readonly STRING_ID   = tokenTypeId(TokenTypes.STRING);\n  private static readonly IDENT_ID    = tokenTypeId(TokenTypes.IDENT);\n  private static readonly LPAREN_ID   = tokenTypeId(TokenTypes.LPAREN);\n  private static readonly RPAREN_ID   = tokenTypeId(TokenTypes.RPAREN);\n  private static readonly MINUS_ID    = tokenTypeId(TokenTypes.MINUS);\n  private static readonly PLUS_ID     = tokenTypeId(TokenTypes.PLUS);\n  private static readonly KEYWORD_ID  = tokenTypeId(TokenTypes.KEYWORD);\n\n  // Infix built-ins (Tier 1, full inline emission)\n  private static readonly STAR_ID     = tokenTypeId(TokenTypes.STAR);\n  private static readonly SLASH_ID    = tokenTypeId(TokenTypes.SLASH);\n  private static readonly MOD_ID      = tokenTypeId(TokenTypes.MOD);\n  private static readonly CARET_ID    = tokenTypeId(TokenTypes.CARET);\n  private static readonly LSHIFT_ID   = tokenTypeId(TokenTypes.LSHIFT);\n  private static readonly RSHIFT_ID   = tokenTypeId(TokenTypes.RSHIFT);\n  private static readonly URSHIFT_ID  = tokenTypeId(TokenTypes.URSHIFT);\n  private static readonly BIT_AND_ID  = tokenTypeId(TokenTypes.BIT_AND);\n  private static readonly BIT_OR_ID   = tokenTypeId(TokenTypes.BIT_OR);\n  private static readonly BIT_XOR_ID  = tokenTypeId(TokenTypes.BIT_XOR);\n  private static readonly PERCENT_ID  = tokenTypeId(TokenTypes.PERCENT);\n  private static readonly OF_ID       = tokenTypeId(TokenTypes.OF);\n\n  /**\n   * Inline opcode map for Tier 1 infix operators.\n   * tokenTypeId → OpCode. PERCENT and CARET are handled specially (not in this map).\n   */\n  private static readonly INFIX_OPCODE: Record<number, OpCode> = {\n    [tokenTypeId(TokenTypes.PLUS)]:    OpCode.ADD,\n    [tokenTypeId(TokenTypes.MINUS)]:   OpCode.SUB,\n    [tokenTypeId(TokenTypes.STAR)]:    OpCode.MUL,\n    [tokenTypeId(TokenTypes.SLASH)]:   OpCode.DIV,\n    [tokenTypeId(TokenTypes.MOD)]:     OpCode.MOD,\n    [tokenTypeId(TokenTypes.CARET)]:   OpCode.EXP,\n    [tokenTypeId(TokenTypes.LSHIFT)]:  OpCode.LSHIFT,\n    [tokenTypeId(TokenTypes.RSHIFT)]:  OpCode.RSHIFT,\n    [tokenTypeId(TokenTypes.URSHIFT)]: OpCode.URSHIFT,\n    [tokenTypeId(TokenTypes.BIT_AND)]: OpCode.BIT_AND,\n    [tokenTypeId(TokenTypes.BIT_OR)]:  OpCode.BIT_OR,\n    [tokenTypeId(TokenTypes.BIT_XOR)]: OpCode.BIT_XOR,\n    [tokenTypeId(TokenTypes.OF)]:      OpCode.MUL,\n  };\n\n  /** Shared with every BytecodeBuilder so a nested-body builder resolves plugin calls by name. */\n  private pluginFunctionIndex?: ReadonlyMap<string, number>;\n\n  constructor(\n    parseletRegistry: ParseletRegistry,\n    maxDepth = 50,\n    localeCode = \"en\",\n    pluginFunctionIndex?: ReadonlyMap<string, number>,\n    calendar: CalendarBackend = DATE_CALENDAR,\n  ) {\n    this.registry = parseletRegistry;\n    this.maxDepth = maxDepth;\n    this.localeCode = localeCode;\n    // Read once, not once per number literal. `localeCode` is set here and\n    // never reassigned, so these cannot go stale, and the profile had\n    // getLocale() plus its property chain inside the hot NUMBER path.\n    const display = getLocale(localeCode).display;\n    this.decimalSeparator = display.decimalSeparator;\n    this.thousandsSeparator = display.thousandsSeparator;\n    this.pluginFunctionIndex = pluginFunctionIndex;\n    this.calendar = calendar;\n  }\n\n  /** Get locale code for NumberParselet to normalize separators */\n  getLocaleCode(): string {\n    return this.localeCode;\n  }\n\n  /**\n   * The calendar backend a parselet reads a date with at parse time: the\n   * engine's own, so a fused literal reads back through the backend that\n   * built it. See the field's doc for the sites that need it.\n   */\n  getCalendar(): CalendarBackend {\n    return this.calendar;\n  }\n\n  /**\n   * Set the diagnostic pipeline for parselet matching events.\n   * Cleared after each non-cached parse to avoid holding refs.\n   */\n  setDiagnosticPipeline(pipeline: DiagnosticPipeline | undefined, expression: string): void {\n    this.diagnosticPipeline = pipeline;\n    this.currentExpression = expression ?? \"\";\n  }\n\n  /**\n   * Load tokens for parsing. Identical to Parser.load().\n   *\n   * @param hasParens - if false, skips the O(n) paren balance scan (~90% of expressions)\n   */\n  load(tokens: Token[], hasParens?: boolean): void {\n    if (hasParens === false) {\n      this.tokens = tokens;\n      this.current = 0;\n      this.depth = 0;\n      return;\n    }\n    // Paren scan: count balance to skip array copy for balanced expressions.\n    const LPAREN_ID = tokenTypeId(TokenTypes.LPAREN);\n    const RPAREN_ID = tokenTypeId(TokenTypes.RPAREN);\n    let openCount = 0;\n    for (let i = 0; i < tokens.length; i++) {\n      if (tokens[i].typeId === LPAREN_ID) openCount++;\n      else if (tokens[i].typeId === RPAREN_ID) openCount--;\n    }\n    this.tokens = openCount === 0 ? tokens : this.balanceParens(tokens, openCount);\n    this.current = 0;\n    this.depth = 0;\n  }\n\n  /**\n   * Auto-balance unmatched parentheses.\n   */\n  private balanceParens(tokens: Token[], openCount: number): Token[] {\n    const result = tokens.slice();\n    if (openCount > 0) {\n      const RPAREN_ID = tokenTypeId(TokenTypes.RPAREN);\n      for (let i = 0; i < openCount; i++) {\n        const lastToken = tokens[tokens.length - 1];\n        result.push({\n          type: TokenTypes.RPAREN,\n          typeId: RPAREN_ID,\n          value: \")\",\n          text: \")\",\n          offset: lastToken ? lastToken.offset + lastToken.text.length : 0,\n          lineBreaks: 0,\n          line: lastToken ? lastToken.line : 1,\n          col: lastToken ? lastToken.col + lastToken.text.length : 1,\n        } as Token);\n      }\n    } else if (openCount < 0) {\n      const LPAREN_ID = tokenTypeId(TokenTypes.LPAREN);\n      for (let i = 0; i < -openCount; i++) {\n        result.unshift({\n          type: TokenTypes.LPAREN,\n          typeId: LPAREN_ID,\n          value: \"(\",\n          text: \"(\",\n          offset: 0,\n          lineBreaks: 0,\n          line: 1,\n          col: 1,\n        } as Token);\n      }\n    }\n    return result;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Main entry point: precedence climbing parse expression\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Parse a full expression starting at the current token position.\n   *\n   * @param minBp - minimum binding power (precedence climbing threshold).\n   *   For left-associative operators, the recursive call uses `bp + 1`.\n   *   For right-associative operators (^), it uses `bp - 1`.\n   * @param _builder - accepted for parselet API compatibility; always uses `this.builder`.\n   */\n  parseExpression(minBp: number = 0, _builder?: BytecodeBuilder): void {\n    // Accept builder via parameter for backward compatibility with the old Parser API.\n    // The ExpressionEngine always calls setBuilder() before parseExpression(),\n    // but tests and parselets pass builder as a parameter. A builder passed\n    // here is in force for this parse only: a parselet compiling a nested body\n    // into its own builder gets the outer one back afterwards.\n    const outerBuilder = this.builder;\n    if (_builder) {\n      this.builder = _builder;\n    }\n    // Depth is restored in a finally rather than on each return, because a\n    // parselet that throws part way through a line (the common case while\n    // someone is typing) used to leave the counter one higher for good.\n    this.depth++;\n    try {\n      if (this.depth > this.maxDepth) {\n        throw ErrorFactory.parsing(\n          \"NESTING_DEPTH_EXCEEDED\",\n          `Parse nesting depth ${this.depth} exceeds maximum of ${this.maxDepth}`,\n          { maxDepth: this.maxDepth, currentDepth: this.depth }\n        );\n      }\n      this.parseExpressionBody(minBp);\n    } finally {\n      this.depth--;\n      if (_builder) this.builder = outerBuilder;\n    }\n  }\n\n  /** The prefix and infix loop of {@link parseExpression}, run with the depth already counted and the builder in place. */\n  private parseExpressionBody(minBp: number): void {\n    const token = this.consume();\n    if (!token) {\n      throw ErrorFactory.parsing({ code: \"UNEXPECTED_END\", message: \"Unexpected end of expression\", span: this.spanAtEnd() });\n    }\n\n    // ── Prefix ──────────────────────────────────────────────────────────────\n    this.parsePrefix(token);\n\n    // ── Infix loop (precedence climbing with inline Tier 1 dispatch) ──────────\n    const tokens = this.tokens;\n    const len = tokens.length;\n    const bpTable = PrecedenceParser.BP_TABLE;\n    const registry = this.registry;\n    const builder = this.builder;\n    let idx = this.current;\n\n    while (idx < len) {\n      const lookahead = tokens[idx];\n      if (!lookahead) break;\n\n      const bp = bpTable[lookahead.typeId];\n      if (bp > 0) {\n        // Tier 1: Built-in infix, full inline emission, zero parselet delegation\n        if (bp <= minBp) break;\n\n        if (this.diagnosticPipeline) {\n          // Fast path skips the registry, but built-ins are still registered\n          // there (for introspection/tests), look them up only in this\n          // diagnostics-only branch so the playground's \"matched parselets\"\n          // view isn't permanently blind to every arithmetic operator.\n          const infixParselet = registry.getInfix(lookahead.typeId);\n          if (infixParselet) {\n            this.fireParseletMatched(infixParselet, lookahead, false, bp);\n          }\n        }\n\n        this.current = ++idx;\n        const typeId = lookahead.typeId;\n\n        if (typeId === PrecedenceParser.PERCENT_ID) {\n          // Postfix: no right operand. \"50%\" → Percentage holding 0.5.\n          //\n          // Must stay byte-for-byte equivalent to PercentParselet, which is\n          // the Tier-2 registration of the same operator. This path is the one\n          // that actually runs for ordinary expressions, so a change made only\n          // in the parselet does nothing at all: that is exactly how the\n          // divide-by-100 here outlived its replacement and kept `200 + 10%`\n          // answering 200.10.\n          builder.emitOpcode(OpCode.PUSH_NUMBER);\n          builder.emitNumber(100);\n          builder.emitOpcode(OpCode.DIV);\n          builder.emitOpcode(OpCode.TO_PERCENTAGE);\n        } else if (typeId === PrecedenceParser.CARET_ID && this.tryEmitMatrixCaretOp(builder)) {\n          // `^T` (transpose) or `^-1` (inverse), already fully handled\n          // including consuming their own trailing tokens.\n        } else {\n          // Infix: parse right operand, then emit opcode.\n          // Right-associative for CARET (^), left-associative for all others.\n          //\n          // The threshold has to be bp - 1, not bp. The loop above breaks on\n          // `bp <= minBp`, so a right operand parsed at `bp` stops at the next\n          // `^` exactly as one parsed at `bp + 1` does: the old special case\n          // was dead code and \"2 ^ 3 ^ 2\" grouped left, answering 64. One\n          // below lets the recursive call keep consuming `^`, which is what\n          // makes it 2^(3^2) = 512, as in mathematics, Python, Ruby and\n          // JavaScript's `**`.\n          //\n          // Nothing else sits between Exponent (50) and Product (40), so\n          // 49 cannot collide with another operator's level. Unary minus is\n          // unaffected: it parses its operand at Prefix (60), above `^`\n          // either way, so \"-2 ^ 2\" is still (-2)^2 = 4.\n          const rightBp = (typeId === PrecedenceParser.CARET_ID) ? bp - 1 : bp + 1;\n          this.parseExpression(rightBp, builder);\n          builder.emitOpcode(PrecedenceParser.INFIX_OPCODE[typeId]);\n        }\n      } else {\n        // Tier 2: Plugin parselet fallback, full flexibility for custom syntax\n        const infixParselet = registry.getInfix(lookahead.typeId);\n        if (!infixParselet) break;\n        if (infixParselet.bindingPower <= minBp) break;\n\n        this.current = ++idx;\n\n        if (this.diagnosticPipeline) {\n          this.fireParseletMatched(infixParselet, lookahead, false, infixParselet.bindingPower);\n        }\n        // Expose the level this parselet is bound at, so one that peeks past its\n        // own token (a unit literal weighing whether a trailing `in`/`to` is\n        // its own or an outer operator's) can respect precedence. See\n        // infixMinBindingPower's doc comment.\n        const outerMinBindingPower = this.infixMinBindingPower;\n        this.infixMinBindingPower = minBp;\n        try {\n          // Parselet handles its own recursion for right operand internally\n          infixParselet.parse(this, token, lookahead, builder);\n        } finally {\n          this.infixMinBindingPower = outerMinBindingPower;\n        }\n      }\n\n      idx = this.current;\n    }\n\n    this.current = idx;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Prefix dispatch: inline switch for built-ins, parselet registry for plugins\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Parse a prefix token. Built-in tokens (NUMBER, IDENT, LPAREN, etc.) are\n   * handled inline with zero registry lookup. Everything else falls through\n   * to the parselet registry (Tier 2).\n   */\n  private parsePrefix(token: Token): void {\n    const builder = this.builder;\n    const typeId = token.typeId;\n\n    if (this.diagnosticPipeline) {\n      // Fast path below skips the registry for built-ins, but they're still\n      // registered there (for introspection/tests), look up here so the\n      // playground's \"matched parselets\" view isn't permanently blind to\n      // every number, identifier, paren, and unary operator.\n      const parselet = this.registry.getPrefix(typeId);\n      if (parselet) {\n        this.fireParseletMatched(parselet, token, true);\n      }\n    }\n\n    switch (typeId) {\n      // ── Numeric literals ──────────────────────────────────────────────────\n      case PrecedenceParser.NUMBER_ID: {\n        // Parse number with locale-aware separator normalization\n        let v: number;\n        // The exact dot-decimal text for a literal written with a fractional\n        // point, so it can be pushed as PUSH_DECIMAL and keep its precision\n        // where it later meets money. Stays null for every integer shape\n        // (hex/bin/oct, chained-dot grouping, plain integers), which push the\n        // ordinary PUSH_NUMBER and are unchanged.\n        let decimalText: string | null = null;\n        const raw = token.value;\n\n        // Fast path: plain digits, with at most one \".\".\n        //\n        // Most literals in a document are `144`, `1200`, `0.85`. The general\n        // path below reaches the same answer for them only after six\n        // startsWith() calls, two regular expressions and a split/join that\n        // allocated whether or not the separator was present; a CPU profile put\n        // this whole case at over a third of parse-and-compile. One character\n        // scan settles it instead.\n        //\n        // Guarded on the decimal separator being \".\", which is what makes a\n        // lone dot unambiguous. Where \".\" groups thousands instead, `1.234`\n        // means one thousand two hundred and thirty-four, so that locale has to\n        // keep taking the general path.\n        if (this.decimalSeparator === \".\") {\n          let dots = 0;\n          let plain = raw.length > 0;\n          for (let i = 0; i < raw.length; i++) {\n            const c = raw.charCodeAt(i);\n            if (c >= 48 && c <= 57) continue;\n            if (c === 46 && dots === 0) { dots = 1; continue; }\n            plain = false;\n            break;\n          }\n          if (plain) {\n            // One dot with digits optional on either side is exactly what\n            // PLAIN_DECIMAL matches, so this agrees with it: that is the signal\n            // for the exact-decimal opcode rather than a double.\n            if (dots === 1) {\n              builder.emitOpcode(OpCode.PUSH_DECIMAL);\n              builder.emitString(raw);\n              return;\n            }\n            builder.emitOpcode(OpCode.PUSH_NUMBER);\n            builder.emitNumber(+raw);\n            return;\n          }\n        }\n\n        if (raw.startsWith(\"0x\") || raw.startsWith(\"0X\")) {\n          v = parseInt(raw, 16);\n          // A prefix with no digits after it (\"0x\" alone) makes parseInt\n          // return NaN. This used to push straight through as a silent\n          // NaN Number value instead of a visible error.\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing({ code: \"INVALID_NUMBER_LITERAL\", message: `Invalid hex literal: \"${raw}\"`, context: { raw }, span: this.spanOf(token) });\n          }\n        } else if (raw.startsWith(\"0b\") || raw.startsWith(\"0B\")) {\n          v = parseInt(raw.slice(2), 2);\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing({ code: \"INVALID_NUMBER_LITERAL\", message: `Invalid binary literal: \"${raw}\"`, context: { raw }, span: this.spanOf(token) });\n          }\n        } else if (raw.startsWith(\"0o\") || raw.startsWith(\"0O\")) {\n          v = parseInt(raw.slice(2), 8);\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing({ code: \"INVALID_NUMBER_LITERAL\", message: `Invalid octal literal: \"${raw}\"`, context: { raw }, span: this.spanOf(token) });\n          }\n        } else if (CHAINED_DOT_THOUSANDS_GROUPS.test(raw)) {\n          // The lexer accepts \".\" as a thousands-group separator\n          // independent of locale (ExpressionLexer's number-scanning\n          // \"Thousands separators\" block), but the locale-based\n          // normalization below only strips the ACTIVE locale's own\n          // configured thousandsSeparator character, for \"en\" that's\n          // \",\", not \".\", so a chained dot-grouped literal like\n          // \"1.234.567\" fell through to parseFloat() untouched, which\n          // stops at the second \".\" and silently truncated it to 1.234\n          // (over 99% of the digits dropped, with no error). This is the\n          // REAL number-parsing path for actual evaluation, Tier 1 of\n          // the two-tier dispatch above always returns for NUMBER_ID, so\n          // NumberParselet.parse() (which has the identical fix) never\n          // actually runs except via direct unit tests / the \"matched\n          // parselets\" diagnostic display.\n          v = parseFloat(raw.split(\".\").join(\"\"));\n        } else {\n          const decimalSep = this.decimalSeparator;\n          const thousandsSep = this.thousandsSeparator;\n          let normalized = raw;\n          // Replace thousands separator with empty string (split+join avoids per-call RegExp compilation).\n          // The indexOf guard stops that pair allocating an array and a string\n          // for the many literals that contain no separator at all.\n          if (thousandsSep && normalized.indexOf(thousandsSep) !== -1) {\n            normalized = normalized.split(thousandsSep).join(\"\");\n          }\n          // Replace locale decimal separator with \".\" for JavaScript parsing\n          if (decimalSep && decimalSep !== \".\") {\n            normalized = normalized.replace(decimalSep, \".\");\n          }\n          v = parseFloat(normalized);\n          // A plain fractional literal (digits, one dot, digits) is what carries\n          // an exact decimal. Scientific notation like \"2.5e-3\" has a dot too\n          // but no exact base-ten form worth the trouble, so it stays a\n          // PUSH_NUMBER double, and so does any integer (grouping stripped).\n          if (PLAIN_DECIMAL.test(normalized)) decimalText = normalized;\n        }\n        if (decimalText !== null) {\n          builder.emitOpcode(OpCode.PUSH_DECIMAL);\n          builder.emitString(decimalText);\n          return;\n        }\n        builder.emitOpcode(OpCode.PUSH_NUMBER);\n        builder.emitNumber(v);\n        return;\n      }\n\n      case PrecedenceParser.BIGINT_ID: {\n        // Strips the `n` and any thousands grouping the lexer coalesced in.\n        // This used to be `raw.slice(0, -1)` and nothing else, so `1.000n`\n        // reached BigInt(\"1.000\") and threw a raw SyntaxError. See\n        // parser/BigIntLiteral.ts, which the parselet tier shares.\n        builder.emitOpcode(OpCode.PUSH_BIGINT);\n        builder.emitString(bigIntLiteralDigits(token.value, this.localeCode));\n        return;\n      }\n\n      case PrecedenceParser.STRING_ID: {\n        builder.emitOpcode(OpCode.PUSH_STRING);\n        builder.emitString(token.value);\n        return;\n      }\n\n      // ── Identifiers (variables) ────────────────────────────────────────────\n      case PrecedenceParser.IDENT_ID: {\n        // An identifier immediately followed by \"(\" may be a user-defined\n        // function DEFINITION (`f(x) = ...`) or CALL (`f(5)`). See\n        // parseUserFunctionDefOrCall's doc comment for the full\n        // disambiguation. Only the (cheap) LPAREN check runs for the\n        // overwhelmingly common case of a bare identifier with nothing\n        // following it.\n        if (this.peek()?.typeId === PrecedenceParser.LPAREN_ID) {\n          this.parseUserFunctionDefOrCall(token, builder);\n          return;\n        }\n        // IDENT tokens map to LOAD_VAR by default. The IdentifierParselet\n        // and VariableParselet add STORE_VAR for assignments, those are\n        // handled via the parselet registry below. Note this is also how a\n        // user-defined function's own PARAMETER references compile. See\n        // UserFunctionDef's doc comment in BytecodeBuilder.ts for why there\n        // is no separate parameter-load opcode: `LOAD_VAR` resolution\n        // dynamically checks the VM's innermost call frame first.\n        builder.emitOpcode(OpCode.LOAD_VAR);\n        builder.emitString(token.value);\n        return;\n      }\n\n      // ── Grouping / bare-tuple vector literal ─────────────────────────────────\n      // `(expr)` groups for precedence; `(x, y[, z[, w]])` is the bare-tuple\n      // vector literal documented as an alternative to vec2/vec3/vec4(...)\n      // (wiki: Arithmetic/Vector). This Tier-1 case is what actually runs for\n      // every LPAREN in production parsing, GroupParselet.ts mirrors this\n      // logic for registry-introspection/diagnostic-listing purposes, but a\n      // package can never override LPAREN's dispatch here (Tier 1 always\n      // wins over the ParseletRegistry fallback below), so both must be kept\n      // in sync by hand.\n      case PrecedenceParser.LPAREN_ID: {\n        this.parseExpression(0, builder);\n        let count = 1;\n        while (this.match(TokenTypes.COMMA)) {\n          this.parseExpression(0, builder);\n          count++;\n        }\n        this.consume(TokenTypes.RPAREN);\n        if (count > 1) {\n          // Legacy bare-tuple vector sugar, a 1xN row-vector Matrix (see\n          // packages/vector/parselets/VectorParselet.ts's comment).\n          builder.emitOpcode(OpCode.MAT_NEW);\n          builder.emitIndex(1);\n          builder.emitIndex(count);\n        }\n        return;\n      }\n\n      // ── Unary operators ───────────────────────────────────────────────────\n      case PrecedenceParser.MINUS_ID: {\n        this.parseExpression(BindingPower.Prefix, builder);\n        builder.emitOpcode(OpCode.NEG);\n        return;\n      }\n\n      case PrecedenceParser.PLUS_ID: {\n        this.parseExpression(BindingPower.Prefix, builder);\n        builder.emitOpcode(OpCode.POS);\n        return;\n      }\n\n      // ── Keyword constants ─────────────────────────────────────────────────\n      case PrecedenceParser.KEYWORD_ID: {\n        // Keywords are handled by parselets (pi→PI, e→E, etc.)\n        // Fall through to registry below.\n      }\n    }\n\n    // ── Tier 2: Plugin/parselet prefix path ──────────────────────────────────\n    const prefixParselet = this.registry.getPrefix(typeId);\n    if (!prefixParselet) {\n      throw ErrorFactory.parsing({\n        code: \"NO_PREFIX_PARSELET\",\n        message: `No prefix parselet found for token: ${token.type} (\"${token.value}\")`,\n        context: { tokenType: token.type, tokenValue: token.value },\n        span: this.spanOf(token),\n      });\n    }\n\n    prefixParselet.parse(this, token, builder);\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // The \"Tier-1 shape-exception\" pattern\n  // ═══════════════════════════════════════════════════════════════════════════════\n  //\n  // Tier 1 exists purely for performance, avoid a Map lookup + parselet call\n  // on ~95% of tokens (see this file's own module doc comment above). A\n  // recurring consequence: any grammar shape tied to a Tier-1 token type can\n  // ONLY be implemented by hand-editing this switch, since a package-\n  // registered ParseletRegistry parselet for that same token type would\n  // simply never run in production (Tier 1 always wins over the registry\n  // fallback). Five confirmed instances of this tension exist in this file\n  // (plus one that had to move OUTSIDE it entirely):\n  //   1. NUMBER_ID, the full locale-aware number-literal parsing (hex/\n  //      binary/octal, chained-dot thousands grouping, decimal-separator\n  //      normalization) is inlined in parsePrefix() above; NumberParselet.ts's\n  //      own copy is dead code for real evaluation, kept registered only for\n  //      the \"matched parselets\" diagnostic view.\n  //   2. IDENT_ID, parseUserFunctionDefOrCall's lookahead (below) disambig-\n  //      uates a function DEFINITION from a CALL from a plain variable load.\n  //   3. LPAREN_ID, the bare-tuple vector-literal sugar (\"(x,y[,z[,w]])\" ->\n  //      MAT_NEW) is inlined in parsePrefix() above; GroupParselet.ts mirrors\n  //      it for introspection only and must be kept in sync by hand.\n  //   4. CARET_ID, the transpose/inverse suffix table just below.\n  //   5. PLUS_ID, the locale word \"and\" lexes as PLUS (Tier-1, fixed Sum\n  //      binding power), so a registry parselet can never intercept it the\n  //      way LogicalParselet.ts intercepts \"or\"/&&/||; unlike the other four,\n  //      there's no SHAPE to special-case on here (the token itself IS the\n  //      operator), so the workaround lives entirely outside this file, as a\n  //      runtime Boolean/Boolean type-check inside vm/VM.ts's OpCode.ADD\n  //      handler instead.\n  //\n  // Deliberate non-goal: none of this is exposed as an IEnginePackage\n  // extension point (unlike prefixParselets/infixParselets). Letting\n  // third-party packages register their own Tier-1 shape-matchers would put\n  // per-package matcher iteration on a genuinely hot path (every CARET/\n  // NUMBER/IDENT/LPAREN/PLUS token, matched or not), a materially bigger\n  // separate product decision than \"make this one table more concise,\" and\n  // not one this pattern write-up makes.\n\n  /**\n   * A single `^`-suffix shape: `matches` peeks ahead (consuming nothing) to\n   * check whether this shape starts at the current position; `emit` is only\n   * called immediately after `matches` returned true for that SAME position,\n   * and is responsible for consuming that shape's own trailing tokens and\n   * emitting its bytecode.\n   */\n  private static readonly CARET_SUFFIX_RULES: ReadonlyArray<{\n    name: string;\n    matches(parser: PrecedenceParser): boolean;\n    emit(parser: PrecedenceParser, builder: BytecodeBuilder): void;\n  }> = [\n    {\n      name: \"transpose (^T)\",\n      matches: (p) => {\n        const next = p.peek();\n        return next?.type === TokenTypes.IDENT && next.value === \"T\";\n      },\n      emit: (p, builder) => {\n        p.advance();\n        builder.emitOpcode(OpCode.CALL_BUILTIN);\n        builder.emitIndex(63); // transpose — see VMBuiltins.ts\n        builder.emitIndex(1);\n      },\n    },\n    {\n      name: \"inverse (^-1)\",\n      matches: (p) => {\n        const next = p.peek();\n        if (next?.typeId !== PrecedenceParser.MINUS_ID) return false;\n        const afterMinus = p.peekAt(1);\n        return afterMinus?.type === TokenTypes.NUMBER && afterMinus.value === \"1\";\n      },\n      emit: (p, builder) => {\n        p.advance();\n        p.advance();\n        builder.emitOpcode(OpCode.CALL_BUILTIN);\n        builder.emitIndex(65); // inv — see VMBuiltins.ts\n        builder.emitIndex(1);\n      },\n    },\n  ];\n\n  /**\n   * After a `^` token (already consumed by the Tier-1 infix loop above),\n   * checks {@link CARET_SUFFIX_RULES} in order for a shape that means\n   * something other than ordinary exponentiation: `^T` (transpose) and `^-1`\n   * (matrix inverse, LITERALLY the integer exponent `-1`; `^-2`, `^-1.5`\n   * etc. still mean ordinary exponentiation). On a match, the rule's `emit`\n   * consumes that shape's own tokens and this returns `true`. On no match,\n   * consumes NOTHING, returning `false` so the caller falls through to\n   * ordinary `EXP` parsing.\n   *\n   * Every rule dispatches purely on SHAPE, never on operand type (unknowable\n   * at parse time): `inv()`'s own handler (`VMBuiltins.ts` index 65) returns\n   * `1/x` for a plain Number, byte-identical to what `Math.pow(x, -1)`\n   * already computed for `x^-1` before this feature existed, and a real\n   * matrix inverse for a Matrix, so `5^-1` still means exactly what it always\n   * has; only a Matrix operand actually inverts.\n   *\n   * Adding a future `^`-suffix shape is a new table entry here, not a new\n   * if-block. See the \"Tier-1 shape-exception\" pattern write-up above for\n   * why this table can't instead be a package-registered parselet.\n   */\n  private tryEmitMatrixCaretOp(builder: BytecodeBuilder): boolean {\n    for (const rule of PrecedenceParser.CARET_SUFFIX_RULES) {\n      if (rule.matches(this)) {\n        rule.emit(this, builder);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // User-defined, parameterized, reusable functions (f(x) = 2*x + 1, then f(5))\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * From an LPAREN token index, scan forward tracking paren depth and\n   * return the index of the matching RPAREN, or `null` if the parens never\n   * balance before the token stream ends. No emission, no position\n   * advance. Same class of technique as {@link balanceParens}'s own\n   * pre-scan, just exposed mid-parse instead of only at `load()` time.\n   * `openIdx` must point AT the LPAREN itself.\n   */\n  private findMatchingRParen(openIdx: number): number | null {\n    let depth = 0;\n    for (let i = openIdx; i < this.tokens.length; i++) {\n      const t = this.tokens[i];\n      if (t.typeId === PrecedenceParser.LPAREN_ID) depth++;\n      else if (t.typeId === PrecedenceParser.RPAREN_ID) {\n        depth--;\n        if (depth === 0) return i;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Disambiguates a bare `IDENT` immediately followed by `(` between three\n   * things, using ONLY a bracket-depth scan (no backtracking, nothing is\n   * consumed until the shape is known):\n   * - `f(x) = expr`, a DEFINITION: the matching `)` is followed by `=`.\n   * - `f(5)`, a CALL to a (possibly not-yet-defined) function: anything\n   *   else. This was never valid syntax before this feature (a bare\n   *   `IDENT` immediately before `(` has no pre-existing \"plain variable\n   *   read + separately grouped `(...)`\" meaning to preserve, confirmed\n   *   via `BuiltinNormalizerRules.ts`'s `implicitMultiplyRule()`, which\n   *   only inserts an implicit `*` for `NUMBER/RPAREN` immediately before\n   *   `IDENT/LPAREN`, never for a bare `IDENT` immediately before\n   *   `LPAREN`). Always commits to a CALL; an unregistered name produces a\n   *   clear `UNDEFINED_FUNCTION` error at VM-execution time, the same\n   *   forward-reference philosophy `LOAD_VAR`/`UNDEFINED_VARIABLE` already\n   *   uses, rather than any parse-time registry lookup.\n   * If the parens never balance, this falls through to the ordinary\n   * `LOAD_VAR` path (a malformed expression surfaces its own parse error\n   * shortly after, from the normal expression grammar).\n   */\n  private parseUserFunctionDefOrCall(nameToken: Token, builder: BytecodeBuilder): void {\n    const closeIdx = this.findMatchingRParen(this.current);\n    if (closeIdx === null) {\n      builder.emitOpcode(OpCode.LOAD_VAR);\n      builder.emitString(nameToken.value);\n      return;\n    }\n    const afterClose = this.tokens[closeIdx + 1];\n    if (afterClose?.type === TokenTypes.EQUALS) {\n      this.parseUserFunctionDefinition(nameToken, builder);\n    } else {\n      this.parseUserFunctionCall(nameToken, builder);\n    }\n  }\n\n  /**\n   * A parameter name, accepted as either `IDENT` or `UNIT`, matches this\n   * codebase's established `:name = value` variable-name policy\n   * (`VariableParselet.ts` explicitly accepts `UNIT`-typed tokens too, e.g.\n   * `:b = 5` for the \"b\" bits unit) since common short parameter names\n   * like `h`/`l`/`b`/`t`/`s`/`m` collide with real unit abbreviations\n   * (hour, liter, bits, ton, second, meter, ...) and lex as `UNIT`, not\n   * `IDENT`.\n   */\n  private consumeParamName(): string {\n    const token = this.peek();\n    if (token?.type === TokenTypes.IDENT || token?.type === TokenTypes.UNIT) {\n      this.consume();\n      return token.value;\n    }\n    throw ErrorFactory.parsing({\n      code: \"USER_FUNCTION_INVALID_PARAM_NAME\",\n      message: `Expected a parameter name but got \"${token?.type ?? \"end of input\"}\"${token ? ` (\"${token.value}\")` : \"\"}`,\n      context: { actualType: token?.type },\n      span: token ? this.spanOf(token) : this.spanAtEnd(),\n    });\n  }\n\n  private parseUserFunctionDefinition(nameToken: Token, builder: BytecodeBuilder): void {\n    this.consume(TokenTypes.LPAREN);\n    const params: string[] = [];\n    if (this.peek()?.type !== TokenTypes.RPAREN) {\n      params.push(this.consumeParamName());\n      while (this.match(TokenTypes.COMMA)) {\n        params.push(this.consumeParamName());\n      }\n    }\n    this.consume(TokenTypes.RPAREN);\n    this.consume(TokenTypes.EQUALS);\n\n    if (params.length === 0) {\n      throw ErrorFactory.parsing({\n        code: \"USER_FUNCTION_NO_PARAMS\",\n        message: `\"${nameToken.value}()\" has no parameters -- user-defined functions need at least one (a zero-argument definition is indistinguishable from a plain function CALL with no args, which this grammar doesn't otherwise support)`,\n        context: { name: nameToken.value },\n        span: this.spanOf(nameToken),\n      });\n    }\n\n    // Compile the body into its OWN independent BytecodeBuilder, reusing\n    // the SAME parser/token stream but directing emission elsewhere.\n    // `parseExpression(minBp, _builder)` sets `this.builder = _builder`\n    // with NO automatic restore, explicitly restoring via `setBuilder()`\n    // afterward (not a `finally`, since a thrown parse error here should\n    // propagate as-is; there's no further use of `this.builder` on that\n    // path before the whole parse aborts) avoids silently emitting\n    // whatever parses next (in this same expression, or, via\n    // ExpressionEngine's builder pool, a LATER, unrelated line) into a\n    // stale, already-.build()'d body builder.\n    const bodyBuilder = new BytecodeBuilder(this.pluginFunctionIndex);\n    this.parseExpression(BindingPower.Lowest, bodyBuilder);\n    this.setBuilder(builder);\n\n    const bodyProgram = bodyBuilder.build();\n    if (bodyProgram.hasAsync) {\n      // v1 scope decision: a function body calling an async plugin\n      // (weather, stocks, currency, ...) isn't supported yet, propagating\n      // a 'pending' result up through a reentrant executeBytecode() call\n      // would need the OUTER expression's own bytecode position/stack\n      // state to also be resumable later, which this first pass doesn't\n      // implement. Rejecting at DEFINITION time (not call time) gives the\n      // clearest possible error, matching this codebase's \"never silently\n      // pretend to support something it doesn't\" convention (e.g.\n      // addBusinessDays()'s own disclosed holiday-exclusion scope-down).\n      throw ErrorFactory.parsing({\n        code: \"FUNCTION_BODY_MUST_BE_SYNCHRONOUS\",\n        message: `\"${nameToken.value}(...)\"'s body calls an async operation (weather, stocks, currency, ...) — user-defined function bodies must be synchronous`,\n        context: { name: nameToken.value },\n        span: this.spanOf(nameToken),\n      });\n    }\n\n    const bodyIdx = builder.emitUserFunctionBody(nameToken.value, params, bodyProgram);\n    builder.emitOpcode(OpCode.DEFINE_USER_FUNCTION);\n    builder.emitIndex(bodyIdx);\n\n    // A definition line has no single input value to echo back the way an\n    // assignment does, push a plain confirmation string, matching this\n    // codebase's \"never silently produce a misleading numeric 0\" principle.\n    builder.emitOpcode(OpCode.PUSH_STRING);\n    builder.emitString(`${nameToken.value}(${params.join(\", \")}) defined`);\n  }\n\n  private parseUserFunctionCall(nameToken: Token, builder: BytecodeBuilder): void {\n    this.consume(TokenTypes.LPAREN);\n    let argCount = 0;\n    if (this.peek()?.type !== TokenTypes.RPAREN) {\n      this.parseExpression(BindingPower.Lowest, builder);\n      argCount++;\n      while (this.match(TokenTypes.COMMA)) {\n        this.parseExpression(BindingPower.Lowest, builder);\n        argCount++;\n      }\n    }\n    this.consume(TokenTypes.RPAREN);\n\n    builder.emitOpcode(OpCode.CALL_USER_FUNCTION);\n    builder.emitString(nameToken.value);\n    builder.emitByte(argCount);\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Token stream navigation (identical API to Parser)\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /** The source span of `token`: where an editor underlines the error. */\n  private spanOf(token: Token): SourceSpan {\n    return { start: token.offset, end: token.sourceEnd ?? token.offset + token.text.length, line: token.line, col: token.col };\n  }\n\n  /** An empty span just after the last token: where a line that stops short is pointed at. */\n  private spanAtEnd(): SourceSpan {\n    const last = this.tokens[this.tokens.length - 1];\n    if (!last) return { start: 0, end: 0 };\n    const end = last.sourceEnd ?? last.offset + last.text.length;\n    return { start: end, end, line: last.line, col: last.col + (end - last.offset) };\n  }\n\n  consume(expectedType?: string): Token {\n    const token = this.tokens[this.current];\n    if (!token) {\n      throw ErrorFactory.parsing({ code: \"UNEXPECTED_END_OF_INPUT\", message: \"Unexpected end of input\", span: this.spanAtEnd() });\n    }\n    if (expectedType !== undefined) {\n      const expectedId = tokenTypeId(expectedType);\n      if (token.typeId !== expectedId) {\n        throw ErrorFactory.parsing({\n          code: \"UNEXPECTED_TOKEN_TYPE\",\n          message: `Expected token type \"${expectedType}\" but got \"${token.type}\" (\"${token.value}\")`,\n          context: { expectedType, actualType: token.type, actualValue: token.value },\n          span: this.spanOf(token),\n        });\n      }\n    }\n    this.current++;\n    return token;\n  }\n\n  match(expectedType: string): boolean {\n    const token = this.peek();\n    if (token && token.typeId === tokenTypeId(expectedType)) {\n      this.advance();\n      return true;\n    }\n    return false;\n  }\n\n  peek(): Token | undefined {\n    return this.tokens[this.current];\n  }\n\n  /**\n   * Read-only lookahead `offset` tokens past the current position, without\n   * consuming anything, `peekAt(0)` is equivalent to {@link peek}.\n   * `this.tokens` is a plain in-memory array (not a stream), so this is a\n   * simple, safe index read; no rewind/checkpoint mechanism is needed since\n   * nothing is consumed.\n   */\n  peekAt(offset: number): Token | undefined {\n    return this.tokens[this.current + offset];\n  }\n\n  previous(): Token | undefined {\n    return this.current > 0 ? this.tokens[this.current - 1] : undefined;\n  }\n\n  private advance(): void {\n    this.current++;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Builder access, set before parse, read by inline prefix handlers\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /** Set the builder to use for the current parse. Called by ExpressionEngine. */\n  setBuilder(builder: BytecodeBuilder): void {\n    this.builder = builder;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Diagnostics\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  private fireParseletMatched(\n    parselet: { category: string },\n    token: Token,\n    isPrefix: boolean,\n    bindingPower?: number\n  ): void {\n    const pipeline = this.diagnosticPipeline!;\n    const event: DiagnosticEvent & { type: \"parselet_matched\" } = {\n      type: DiagnosticEventType.ParseletMatched,\n      elapsedNs: 0,\n      expression: this.currentExpression,\n      tokenType: token.type,\n      tokenValue: token.value,\n      parseletCategory: parselet.category,\n      parseletType: parselet.constructor?.name ?? \"unknown\",\n      isPrefix,\n      bindingPower,\n      tokenOffset: token.offset || 0,\n    };\n    pipeline.fireParseletMatched(event);\n  }\n}\n","import { PrefixParselet, InfixParselet } from \"@solve-js/parser/Parselet\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\n\n/**\n * The one binding-power field a parselet may expose beyond what its interface\n * requires, read only for diagnostic display.\n *\n * `InfixParselet` requires `bindingPower`; `PrefixParselet` declares none, and\n * some prefix parselets carry one anyway. That single field is the whole\n * optional surface deliberately. A `leftBindingPower`/`rightBindingPower` pair\n * used to be read here as well, and reading a name off an object this way finds\n * PRIVATE fields too, since TypeScript's `private` exists only at compile time:\n * `BinaryOpParselet` holds a private `rightBindingPower` meaning \"the minimum\n * power to parse my right operand at\", which is a different quantity from \"the\n * power at which I bind to my right\" and differs from it by one. Reading it\n * silently reported that other number. So neither is read.\n *\n * `category` is not here: both interfaces already declare it.\n */\ninterface ParseletBindingPowers {\n\treadonly bindingPower?: number;\n}\n\n/** Reads the optional binding-power field off a parselet for diagnostics. */\nfunction bindingPowersOf(parselet: PrefixParselet | InfixParselet): ParseletBindingPowers {\n\treturn parselet as ParseletBindingPowers;\n}\n\n/**\n * Dual-keyed ParseletRegistry, accepts both string token types and\n * integer token type IDs for fast dispatch in the Parser hot path.\n *\n * Providers call registerPrefix(\"NUMBER\", ...) with string token types.\n * Internally, we populate both string-keyed and integer-keyed maps so\n * Parser.parseExpression() can use token.typeId (integer) for lookup\n * while diagnostics and error messages use token.type (string).\n *\n * Performance: Integer Map.get() avoids string hashing, saving ~2-5ns\n * per dispatch. With ~10-15 dispatches per expression, that's ~20-75ns.\n */\nexport class ParseletRegistry {\n\t// String-keyed maps (kept for diagnostics + backwards compat)\n\tprivate prefixParselets: Map<string, PrefixParselet> = new Map();\n\tprivate infixParselets: Map<string, InfixParselet> = new Map();\n\n\t// Integer-keyed maps for parser hot path\n\tprivate prefixById: Map<number, PrefixParselet> = new Map();\n\tprivate infixById: Map<number, InfixParselet> = new Map();\n\n\t/**\n\t * Register a prefix parselet for `tokenType`.\n\t *\n\t * If another parselet is already registered for this token type, it is\n\t * silently overwritten by default (`Map.set()` semantics), the old\n\t * parselet is simply unreachable from then on, with no error. This is\n\t * a real footgun for third-party packages: two packages independently\n\t * choosing the same custom token type will collide with zero signal\n\t * about which one \"won\". Mirrors ResolverRegistry.register()'s and\n\t * ExpressionEngine.registerPackage()'s existing \"warn and replace\"\n\t * pattern for the same class of problem at the resolver-namespace and\n\t * package-name levels.\n\t *\n\t * Note: this warns about registry-level collisions only. It does NOT\n\t * detect the separate case where `tokenType` is one of PrecedenceParser's\n\t * Tier-1 fast-path token types (NUMBER, STRING, IDENT, LPAREN, MINUS,\n\t * PLUS, and the Tier-1 infix operators), those are deliberately kept\n\t * registered here for introspection/diagnostics even though Tier-1\n\t * always intercepts them before this registry is consulted (see\n\t * PrecedenceParser.parsePrefix()'s docs), so warning there would\n\t * misfire on that intentional, already-documented pattern.\n\t */\n\tregisterPrefix(tokenType: string, parselet: PrefixParselet): void {\n\t\tconst existing = this.prefixParselets.get(tokenType);\n\t\tif (existing && existing !== parselet) {\n\t\t\tconsole.warn(\n\t\t\t\t`[ParseletRegistry] Prefix parselet for token \"${tokenType}\" is already registered ` +\n\t\t\t\t`(category: \"${existing.category ?? \"unknown\"}\"). Overwriting with a new ` +\n\t\t\t\t`parselet (category: \"${parselet.category ?? \"unknown\"}\") — the previous ` +\n\t\t\t\t`parselet is now unreachable. Two packages may be claiming the same token type.`,\n\t\t\t);\n\t\t}\n\t\tthis.prefixParselets.set(tokenType, parselet);\n\t\tthis.prefixById.set(tokenTypeId(tokenType), parselet);\n\t}\n\n\t/** Register an infix parselet for `tokenType`. See {@link registerPrefix} for the collision-warning behavior this mirrors. */\n\tregisterInfix(tokenType: string, parselet: InfixParselet): void {\n\t\tconst existing = this.infixParselets.get(tokenType);\n\t\tif (existing && existing !== parselet) {\n\t\t\tconsole.warn(\n\t\t\t\t`[ParseletRegistry] Infix parselet for token \"${tokenType}\" is already registered ` +\n\t\t\t\t`(category: \"${existing.category ?? \"unknown\"}\"). Overwriting with a new ` +\n\t\t\t\t`parselet (category: \"${parselet.category ?? \"unknown\"}\") — the previous ` +\n\t\t\t\t`parselet is now unreachable. Two packages may be claiming the same token type.`,\n\t\t\t);\n\t\t}\n\t\tthis.infixParselets.set(tokenType, parselet);\n\t\tthis.infixById.set(tokenTypeId(tokenType), parselet);\n\t}\n\n\t/**\n\t * Iterate all registered prefix parselets for diagnostic display.\n\t *\n\t * `PrefixParselet` declares no binding power, and this used to read a field\n\t * of that name and report 0 for every one of them. 0 is not a neutral\n\t * wrong answer: it is the value that means \"not an operator, stop the\n\t * expression\", so a host drawing a table from this was told none of them\n\t * bind at all. A prefix parselet in this parser has no per-parselet power\n\t * to report, they all bind at the prefix level and each chooses for itself\n\t * at what power to parse its own operand, so that level is what is\n\t * reported. A parselet that does carry its own `bindingPower` still wins.\n\t */\n\tgetAllPrefix(): Array<{ tokenType: string; bindingPower: number; category?: string }> {\n\t\tconst result: Array<{ tokenType: string; bindingPower: number; category?: string }> = [];\n\t\tfor (const [tokenType, parselet] of this.prefixParselets) {\n\t\t\tresult.push({\n\t\t\t\ttokenType,\n\t\t\t\tbindingPower: bindingPowersOf(parselet).bindingPower ?? BindingPower.Prefix,\n\t\t\t\tcategory: parselet.category,\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * Iterate all registered infix parselets for diagnostic display.\n\t *\n\t * The field an `InfixParselet` actually declares is `bindingPower`. This\n\t * used to read `leftBindingPower` and `rightBindingPower`, which no\n\t * parselet in this codebase declares, so both reads were `undefined`, both\n\t * fell to the `?? 0` default, and the public `getParseletRegistry()`\n\t * reported a binding power of 0 for every one of the ~60 infix operators.\n\t * A host building a precedence table from it was told `*` and `+` bind\n\t * equally, and that neither binds at all.\n\t *\n\t * The left/right split: `bindingPower` is the LEFT power, and the right is\n\t * one higher. That is the standard encoding for a left-associative\n\t * operator, and it is what the parser itself does, see\n\t * `PrecedenceParser.parseExpression()`'s `bp + 1` for the right operand.\n\t * Every operator is reported that way, `^` included. Associativity is not\n\t * something a parselet declares, it is a property of how each one calls\n\t * `parseExpression`, so this API cannot report it without a new field on\n\t * the interface. See {@link ParseletBindingPowers} for why scraping a\n\t * plausible-looking one off the parselet is worse than not reporting it.\n\t */\n\tgetAllInfix(): Array<{ tokenType: string; leftBindingPower: number; rightBindingPower: number; category?: string }> {\n\t\tconst result: Array<{ tokenType: string; leftBindingPower: number; rightBindingPower: number; category?: string }> = [];\n\t\tfor (const [tokenType, parselet] of this.infixParselets) {\n\t\t\tconst left = bindingPowersOf(parselet).bindingPower ?? 0;\n\t\t\tresult.push({\n\t\t\t\ttokenType,\n\t\t\t\tleftBindingPower: left,\n\t\t\t\trightBindingPower: left + 1,\n\t\t\t\tcategory: parselet.category,\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n\n\t/** Number of registered prefix parselets. */\n\tget prefixCount(): number { return this.prefixParselets.size; }\n\n\t/** Number of registered infix parselets. */\n\tget infixCount(): number { return this.infixParselets.size; }\n\n\t/**\n\t * Get prefix parselet by string token type OR integer typeId.\n\t * Fast path for integer IDs (Parser hot path), fallback for strings\n\t * (diagnostics, error messages, backwards compatibility).\n\t */\n\tgetPrefix(tokenType: string | number): PrefixParselet | undefined {\n\t\tif (typeof tokenType === 'number') return this.prefixById.get(tokenType);\n\t\treturn this.prefixParselets.get(tokenType);\n\t}\n\n\t/**\n\t * Get infix parselet by string token type OR integer typeId.\n\t * Fast path for integer IDs (Parser hot path), fallback for strings.\n\t */\n\tgetInfix(tokenType: string | number): InfixParselet | undefined {\n\t\tif (typeof tokenType === 'number') return this.infixById.get(tokenType);\n\t\treturn this.infixParselets.get(tokenType);\n\t}\n\n\thasPrefix(tokenType: string): boolean {\n\t\treturn this.prefixParselets.has(tokenType);\n\t}\n\n\thasInfix(tokenType: string): boolean {\n\t\treturn this.infixParselets.has(tokenType);\n\t}\n\n\tclear(): void {\n\t\tthis.prefixParselets.clear();\n\t\tthis.infixParselets.clear();\n\t\tthis.prefixById.clear();\n\t\tthis.infixById.clear();\n\t}\n}\n\n/**\n * A process-wide parselet registry.\n *\n * @deprecated An engine builds its own registry and does not read this one, so\n * registering here reaches nothing that evaluates. Nothing writes to it now\n * that the global package-registration path is gone; it remains only so the\n * `@solve-js/parser` escape hatch keeps a stable shape.\n */\nexport const sharedParseletRegistry = new ParseletRegistry();\n"]}

package/dist/{chunk-7DP57BA7.js → chunk-Y7XRA2EV.js}

@@ -1,2 +1,2 @@
-import {d as d$1}from'./chunk-JPFCXLJV.js';import {b}from'./chunk-OB2VX4IL.js';import {b as b$1}from'./chunk-57PSJQQW.js';var h=(s=>(s.Main="main",s.Inline="inline",s.String="string",s))(h||{});var n=class{constructor(e="en",t){this.currentState="main";this.hasPeeked=false;this.tokens=[];this.tokenIdx=0;this.expressionLexer=new b(e);}reset(e,t){let s=t??"main";if(this.currentState=s,this.hasPeeked=false,this.peekedToken=void 0,s==="main"){if(this.expressionLexer.classifyLine(e).skip){this.tokens=[],this.tokenIdx=0;return}this.expressionLexer.reset(e),this.tokens=this.expressionLexer.tokenizeAll(),this.tokenIdx=0;}else this.expressionLexer.reset(e),this.tokens=this.expressionLexer.tokenizeAll(),this.tokenIdx=0;}classifyLine(e){return this.expressionLexer.classifyLine(e)}findInlineSolves(e){return this.expressionLexer.findInlineSolves(e)}getKeywords(){return this.expressionLexer.getKeywords()}next(){if(this.hasPeeked)return this.hasPeeked=false,this.peekedToken;if(this.tokenIdx<this.tokens.length)return this.tokens[this.tokenIdx++]}peek(){return this.hasPeeked?this.peekedToken:(this.peekedToken=this.next(),this.hasPeeked=true,this.peekedToken)}[Symbol.iterator](){return this.tokens[Symbol.iterator]()}registerVocabulary(e){this.expressionLexer.registerVocabulary(e);}unregisterVocabulary(e){this.expressionLexer.unregisterVocabulary(e);}resetExpression(e){this.currentState="main",this.hasPeeked=false,this.peekedToken=void 0,this.expressionLexer.reset(e),this.tokens=this.expressionLexer.tokenizeAll(),this.tokenIdx=0;}scanDocument(e){return this.expressionLexer.scanDocument(e)}getState(){return this.currentState}setState(e){this.currentState=e;}getHighlightTokens(e){let t=this.expressionLexer.classifyLine(e);return t.skip&&e.startsWith("> ")?this.collectHighlightTokens(e.slice(2)):t.skip?[]:this.collectHighlightTokens(e)}getHighlightTokenObjects(e){let t=this.expressionLexer.classifyLine(e);return t.skip&&e.startsWith("> ")?this.collectTokenObjects(e.slice(2)):t.skip?[]:this.collectTokenObjects(e)}collectTokenObjects(e){this.currentState="main",this.hasPeeked=false,this.peekedToken=void 0,this.expressionLexer.reset(e);let t=[];try{this.expressionLexer.tokenizeInto(t);}catch(i){if(!(i instanceof b$1))throw i}let s=[];for(let i of t)i.type==="WS"||i.type==="NEWLINE"||i.type.startsWith("MD_")||i.type==="INLINE_SOLVE_START"||i.type==="BACKTICK_CLOSE"||s.push(i);return this.tokens=s,this.tokenIdx=0,s}collectHighlightTokens(e){return this.collectTokenObjects(e).map(t=>({type:t.type,value:t.value,offset:t.offset,col:t.col,length:t.text.length,category:d$1(t.type)}))}},d=new n("en",void 0);export{h as a,n as b,d as c};//# sourceMappingURL=chunk-7DP57BA7.js.map
-//# sourceMappingURL=chunk-7DP57BA7.js.map
+import {d as d$1}from'./chunk-JPFCXLJV.js';import {b}from'./chunk-RRUGQ6DM.js';import {b as b$1}from'./chunk-VB6QMU2W.js';var h=(s=>(s.Main="main",s.Inline="inline",s.String="string",s))(h||{});var n=class{constructor(e="en",t){this.currentState="main";this.hasPeeked=false;this.tokens=[];this.tokenIdx=0;this.expressionLexer=new b(e);}reset(e,t){let s=t??"main";if(this.currentState=s,this.hasPeeked=false,this.peekedToken=void 0,s==="main"){if(this.expressionLexer.classifyLine(e).skip){this.tokens=[],this.tokenIdx=0;return}this.expressionLexer.reset(e),this.tokens=this.expressionLexer.tokenizeAll(),this.tokenIdx=0;}else this.expressionLexer.reset(e),this.tokens=this.expressionLexer.tokenizeAll(),this.tokenIdx=0;}classifyLine(e){return this.expressionLexer.classifyLine(e)}findInlineSolves(e){return this.expressionLexer.findInlineSolves(e)}getKeywords(){return this.expressionLexer.getKeywords()}next(){if(this.hasPeeked)return this.hasPeeked=false,this.peekedToken;if(this.tokenIdx<this.tokens.length)return this.tokens[this.tokenIdx++]}peek(){return this.hasPeeked?this.peekedToken:(this.peekedToken=this.next(),this.hasPeeked=true,this.peekedToken)}[Symbol.iterator](){return this.tokens[Symbol.iterator]()}registerVocabulary(e){this.expressionLexer.registerVocabulary(e);}unregisterVocabulary(e){this.expressionLexer.unregisterVocabulary(e);}resetExpression(e){this.currentState="main",this.hasPeeked=false,this.peekedToken=void 0,this.expressionLexer.reset(e),this.tokens=this.expressionLexer.tokenizeAll(),this.tokenIdx=0;}scanDocument(e){return this.expressionLexer.scanDocument(e)}getState(){return this.currentState}setState(e){this.currentState=e;}getHighlightTokens(e){let t=this.expressionLexer.classifyLine(e);return t.skip&&e.startsWith("> ")?this.collectHighlightTokens(e.slice(2)):t.skip?[]:this.collectHighlightTokens(e)}getHighlightTokenObjects(e){let t=this.expressionLexer.classifyLine(e);return t.skip&&e.startsWith("> ")?this.collectTokenObjects(e.slice(2)):t.skip?[]:this.collectTokenObjects(e)}collectTokenObjects(e){this.currentState="main",this.hasPeeked=false,this.peekedToken=void 0,this.expressionLexer.reset(e);let t=[];try{this.expressionLexer.tokenizeInto(t);}catch(i){if(!(i instanceof b$1))throw i}let s=[];for(let i of t)i.type==="WS"||i.type==="NEWLINE"||i.type.startsWith("MD_")||i.type==="INLINE_SOLVE_START"||i.type==="BACKTICK_CLOSE"||s.push(i);return this.tokens=s,this.tokenIdx=0,s}collectHighlightTokens(e){return this.collectTokenObjects(e).map(t=>({type:t.type,value:t.value,offset:t.offset,col:t.col,length:t.text.length,category:d$1(t.type)}))}},d=new n("en",void 0);export{h as a,n as b,d as c};//# sourceMappingURL=chunk-Y7XRA2EV.js.map
+//# sourceMappingURL=chunk-Y7XRA2EV.js.map

package/dist/{chunk-7DP57BA7.js.map → chunk-Y7XRA2EV.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/lexer/LexerState.ts","../src/lexer/Lexer.ts"],"names":["LexerState","Lexer","localeCode","_tokenLookup","ExpressionLexer","input","state","newState","lineText","plugin","text","classification","raw","thrown","EngineError","result","token","getTokenCategory","sharedLexer"],"mappings":"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","file":"chunk-7DP57BA7.js","sourcesContent":["/**\n * Lexer state machine modes.\n * - Main: document-level scanning with markdown classification\n * - Inline: expression embedded in markdown inline solve (`s\\`...\\``)\n * - String: inside a double-quoted string literal\n */\nexport enum LexerState {\n\tMain = \"main\",\n\tInline = \"inline\",\n\tString = \"string\",\n}\n","import { ExpressionLexer, LineClassification, LexerVocabulary, type ScanLineResult } from \"./ExpressionLexer\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { EngineError } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { LexerState } from \"@solve-js/lexer/LexerState\";\nimport { getTokenCategory } from \"@solve-js/language/TokenCategoryMap\";\nimport type { TokenCategory } from \"@solve-js/language/TokenCategory\";\nimport type { TokenLookup } from \"@solve-js/lexer/TokenClassRegistry\";\n\n/**\n * Public tokenizer wrapper around {@link ExpressionLexer}.\n *\n * `ExpressionLexer` does the actual character-by-character scanning;\n * `Lexer` adds a materialized-token-array streaming interface\n * (`next()`/`peek()`) plus line-classification state (`reset()`) so\n * callers can iterate a line's tokens without re-scanning on each peek.\n *\n * Each `ExpressionEngine` instance owns its own `Lexer`, and packages\n * extend it via {@link registerVocabulary} (keywords, operators, units)\n * see `IEnginePackage.lexerVocabulary`.\n */\nexport class Lexer {\n  /** Expression-mode lexer (Phase A: V8-optimized, replaces moo) */\n  private expressionLexer: ExpressionLexer;\n  private currentState: LexerState = LexerState.Main;\n  private peekedToken: Token | undefined;\n  private hasPeeked = false;\n\n  // Materialized token array from the last reset() call, used for\n  // next()/peek() streaming access.\n  private tokens: Token[] = [];\n  private tokenIdx: number = 0;\n\n  /**\n   * @param localeCode - Locale code (e.g., \"en\", \"de\"). Defaults to \"en\".\n   * @param _tokenLookup - Ignored. The lexer never read the lookup it was\n   *   handed; the parameter stays so existing callers compile.\n   *   @deprecated Removed in 3.0.\n   */\n  constructor(localeCode = \"en\", _tokenLookup?: TokenLookup) {\n    this.expressionLexer = new ExpressionLexer(localeCode);\n  }\n\n  reset(input: string, state?: LexerState): void {\n    const newState = state ?? LexerState.Main;\n    this.currentState = newState;\n    this.hasPeeked = false;\n    this.peekedToken = undefined;\n\n    // Phase B: Main state classifies the line with the markdown scanner.\n    // Skip lines (headings, fences, HRs, etc.) produce empty token arrays.\n    // Expression lines and lines with inline solves are tokenized normally.\n    if (newState === LexerState.Main) {\n      const classification = this.expressionLexer.classifyLine(input);\n      if (classification.skip) {\n        this.tokens = [];\n        this.tokenIdx = 0;\n        return;\n      }\n      // Expression line or markdown line with inline solves, tokenize.\n      this.expressionLexer.reset(input);\n      this.tokens = this.expressionLexer.tokenizeAll();\n      this.tokenIdx = 0;\n    } else {\n      // Non-main states (Inline, String), expression tokenization.\n      this.expressionLexer.reset(input);\n      this.tokens = this.expressionLexer.tokenizeAll();\n      this.tokenIdx = 0;\n    }\n  }\n\n  /**\n   * Classify a single line of markdown text (Phase B).\n   * Delegates to the ExpressionLexer's character-by-character scanner.\n   */\n  classifyLine(lineText: string): LineClassification {\n    return this.expressionLexer.classifyLine(lineText);\n  }\n\n  /**\n   * Find all inline solve markers in a line (Phase B).\n   * Delegates to the ExpressionLexer's character-by-character scanner.\n   */\n  findInlineSolves(lineText: string) {\n    return this.expressionLexer.findInlineSolves(lineText);\n  }\n\n  /**\n   * Every keyword this lexer currently recognizes (locale + plugin-contributed),\n   * mapped to the token type it lexes to. Delegates to the ExpressionLexer.\n   */\n  getKeywords(): Record<string, string> {\n    return this.expressionLexer.getKeywords();\n  }\n\n  next(): Token | undefined {\n    if (this.hasPeeked) {\n      this.hasPeeked = false;\n      return this.peekedToken;\n    }\n    // Materialized token array (ExpressionLexer path).\n    if (this.tokenIdx < this.tokens.length) {\n      return this.tokens[this.tokenIdx++];\n    }\n    return undefined;\n  }\n\n  peek(): Token | undefined {\n    if (this.hasPeeked) return this.peekedToken;\n    this.peekedToken = this.next();\n    this.hasPeeked = true;\n    return this.peekedToken;\n  }\n\n  [Symbol.iterator](): Iterator<Token> {\n    return this.tokens[Symbol.iterator]();\n  }\n\n  /**\n   * Register a plugin to extend the lexer with custom tokens.\n   * Delegates to the underlying ExpressionLexer.\n   *\n   * @see LexerVocabulary for the supported extension points.\n   */\n  registerVocabulary(plugin: LexerVocabulary): void {\n    this.expressionLexer.registerVocabulary(plugin);\n  }\n\n  /**\n   * Unregister a plugin, removing its custom tokens from the lexer.\n   * Delegates to the underlying ExpressionLexer.\n   */\n  unregisterVocabulary(plugin: LexerVocabulary): void {\n    this.expressionLexer.unregisterVocabulary(plugin);\n  }\n\n  /**\n   * Reset the lexer for expression-only text, skips the classifyLine()\n   * overhead in reset() for callers that already know the input is an\n   * evaluable expression (e.g., after isEmptyLine() confirmed non-skip).\n   */\n  resetExpression(input: string): void {\n    this.currentState = LexerState.Main;\n    this.hasPeeked = false;\n    this.peekedToken = undefined;\n    this.expressionLexer.reset(input);\n    this.tokens = this.expressionLexer.tokenizeAll();\n    this.tokenIdx = 0;\n  }\n\n  /**\n   * Scan a full document in one pass, classifying each line and\n   * tokenizing non-skipped lines. Delegates to ExpressionLexer.\n   *\n   * @returns ScanLineResult[], one per line, with classification + tokens.\n   */\n  scanDocument(text: string): ScanLineResult[] {\n    return this.expressionLexer.scanDocument(text);\n  }\n\n  getState(): LexerState {\n    return this.currentState;\n  }\n\n  setState(state: LexerState): void {\n    this.currentState = state;\n  }\n\n  getHighlightTokens(lineText: string): {type: string; value: string; offset: number; col: number; length: number; category: TokenCategory | undefined}[] {\n    const classification = this.expressionLexer.classifyLine(lineText);\n\n    // For blockquote lines, strip the \"> \" prefix and tokenize the expression content.\n    // This lets expressions inside blockquotes (e.g., \"> 1 + 2\") get syntax highlighted\n    // while pure structural lines (headings, code fences) remain unhighlighted.\n    if (classification.skip && lineText.startsWith(\"> \")) {\n      return this.collectHighlightTokens(lineText.slice(2));\n    }\n\n    if (classification.skip) {\n      return [];\n    }\n\n    return this.collectHighlightTokens(lineText);\n  }\n\n  /**\n   * The same tokens {@link getHighlightTokens} reduces, before reduction.\n   *\n   * Exists because normalization operates on tokens, not on the flattened\n   * shape, and a consumer that wants phrase-fused highlighting has to run the\n   * normalizer between the two. See `LanguageService.getSemanticTokens`.\n   *\n   * @param lineText - One line of source.\n   * @returns Every token on the line that is worth painting, unreduced.\n   */\n  getHighlightTokenObjects(lineText: string): Token[] {\n    const classification = this.expressionLexer.classifyLine(lineText);\n    if (classification.skip && lineText.startsWith(\"> \")) {\n      return this.collectTokenObjects(lineText.slice(2));\n    }\n    if (classification.skip) return [];\n    return this.collectTokenObjects(lineText);\n  }\n\n  private collectTokenObjects(lineText: string): Token[] {\n    // Scanned into an array this method owns rather than through\n    // resetExpression(), which has nothing to hand back when the line faults\n    // part way. Highlighting is painted while the line is still being typed,\n    // and an unterminated string is what a line looks like between the\n    // opening quote and the closing one: the tokens read before the fault are\n    // the right thing to paint, and letting the throw escape blanked the line.\n    this.currentState = LexerState.Main;\n    this.hasPeeked = false;\n    this.peekedToken = undefined;\n    this.expressionLexer.reset(lineText);\n    const raw: Token[] = [];\n    try {\n      this.expressionLexer.tokenizeInto(raw);\n    } catch (thrown) {\n      if (!(thrown instanceof EngineError)) throw thrown;\n    }\n    const result: Token[] = [];\n    for (const token of raw) {\n      if (token.type === \"WS\" || token.type === \"NEWLINE\") continue;\n      if (token.type.startsWith(\"MD_\")) continue;\n      if (token.type === \"INLINE_SOLVE_START\" || token.type === \"BACKTICK_CLOSE\") continue;\n      result.push(token);\n    }\n    this.tokens = result;\n    this.tokenIdx = 0;\n    return result;\n  }\n\n  private collectHighlightTokens(lineText: string): {type: string; value: string; offset: number; col: number; length: number; category: TokenCategory | undefined}[] {\n    return this.collectTokenObjects(lineText).map(token => ({\n      type: token.type,\n      value: token.value,\n      offset: token.offset,\n      col: token.col,\n      // `text`, not `value`: this is a span into the source, and the two\n      // differ for a string literal, whose value is the payload while its\n      // text still carries the quote characters the reader typed.\n      length: token.text.length,\n      category: getTokenCategory(token.type),\n    }));\n  }\n}\n\n/**\n * A lexer for operations that do not depend on registered vocabulary.\n *\n * Line classification and inline-solve detection read characters looking for\n * headings, comment markers, fences and backtick spans, and never consult the\n * keyword, unit or operator tables. Every lexer therefore returns the same\n * answer, so the callers that have no engine to ask can use this one. Checked\n * by `__tests__/lexer/LineClassificationIsVocabularyIndependent.spec.ts`.\n *\n * Do not tokenize with this. An engine's own lexer carries the vocabulary its\n * packages registered; this one carries none.\n */\nexport const sharedLexer = new Lexer(\"en\", undefined);"]}
+{"version":3,"sources":["../src/lexer/LexerState.ts","../src/lexer/Lexer.ts"],"names":["LexerState","Lexer","localeCode","_tokenLookup","ExpressionLexer","input","state","newState","lineText","plugin","text","classification","raw","thrown","EngineError","result","token","getTokenCategory","sharedLexer"],"mappings":"0HAMO,IAAKA,CAAAA,CAAAA,CAAAA,CAAAA,GACXA,EAAA,IAAA,CAAO,MAAA,CACPA,EAAA,MAAA,CAAS,QAAA,CACTA,CAAAA,CAAA,MAAA,CAAS,QAAA,CAHEA,CAAAA,CAAAA,EAAAA,CAAAA,EAAA,ICcL,IAAMC,CAAAA,CAAN,KAAY,CAkBjB,WAAA,CAAYC,CAAAA,CAAa,KAAMC,CAAAA,CAA4B,CAf3D,IAAA,CAAQ,YAAA,CAA2B,MAAA,CAEnC,IAAA,CAAQ,UAAY,KAAA,CAIpB,IAAA,CAAQ,MAAA,CAAkB,EAAC,CAC3B,IAAA,CAAQ,SAAmB,CAAA,CASzB,IAAA,CAAK,eAAA,CAAkB,IAAIC,CAAAA,CAAgBF,CAAU,EACvD,CAEA,KAAA,CAAMG,CAAAA,CAAeC,CAAAA,CAA0B,CAC7C,IAAMC,EAAWD,CAAAA,EAAS,MAAA,CAQ1B,GAPA,IAAA,CAAK,YAAA,CAAeC,CAAAA,CACpB,KAAK,SAAA,CAAY,KAAA,CACjB,KAAK,WAAA,CAAc,MAAA,CAKfA,IAAa,MAAA,CAAiB,CAEhC,GADuB,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAaF,CAAK,CAAA,CAC3C,IAAA,CAAM,CACvB,IAAA,CAAK,MAAA,CAAS,GACd,IAAA,CAAK,QAAA,CAAW,CAAA,CAChB,MACF,CAEA,IAAA,CAAK,gBAAgB,KAAA,CAAMA,CAAK,CAAA,CAChC,IAAA,CAAK,MAAA,CAAS,IAAA,CAAK,gBAAgB,WAAA,EAAY,CAC/C,IAAA,CAAK,QAAA,CAAW,EAClB,CAAA,KAEE,KAAK,eAAA,CAAgB,KAAA,CAAMA,CAAK,CAAA,CAChC,IAAA,CAAK,MAAA,CAAS,KAAK,eAAA,CAAgB,WAAA,EAAY,CAC/C,IAAA,CAAK,QAAA,CAAW,EAEpB,CAMA,YAAA,CAAaG,CAAAA,CAAsC,CACjD,OAAO,IAAA,CAAK,gBAAgB,YAAA,CAAaA,CAAQ,CACnD,CAMA,gBAAA,CAAiBA,CAAAA,CAAkB,CACjC,OAAO,IAAA,CAAK,eAAA,CAAgB,gBAAA,CAAiBA,CAAQ,CACvD,CAMA,WAAA,EAAsC,CACpC,OAAO,IAAA,CAAK,eAAA,CAAgB,WAAA,EAC9B,CAEA,IAAA,EAA0B,CACxB,GAAI,IAAA,CAAK,SAAA,CACP,YAAK,SAAA,CAAY,KAAA,CACV,IAAA,CAAK,WAAA,CAGd,GAAI,IAAA,CAAK,SAAW,IAAA,CAAK,MAAA,CAAO,MAAA,CAC9B,OAAO,IAAA,CAAK,MAAA,CAAO,KAAK,QAAA,EAAU,CAGtC,CAEA,IAAA,EAA0B,CACxB,OAAI,KAAK,SAAA,CAAkB,IAAA,CAAK,WAAA,EAChC,IAAA,CAAK,WAAA,CAAc,IAAA,CAAK,MAAK,CAC7B,IAAA,CAAK,SAAA,CAAY,IAAA,CACV,IAAA,CAAK,WAAA,CACd,CAEA,CAAC,MAAA,CAAO,QAAQ,CAAA,EAAqB,CACnC,OAAO,KAAK,MAAA,CAAO,MAAA,CAAO,QAAQ,CAAA,EACpC,CAQA,mBAAmBC,CAAAA,CAA+B,CAChD,IAAA,CAAK,eAAA,CAAgB,kBAAA,CAAmBA,CAAM,EAChD,CAMA,oBAAA,CAAqBA,CAAAA,CAA+B,CAClD,IAAA,CAAK,eAAA,CAAgB,qBAAqBA,CAAM,EAClD,CAOA,eAAA,CAAgBJ,CAAAA,CAAqB,CACnC,KAAK,YAAA,CAAe,MAAA,CACpB,IAAA,CAAK,SAAA,CAAY,KAAA,CACjB,IAAA,CAAK,YAAc,MAAA,CACnB,IAAA,CAAK,gBAAgB,KAAA,CAAMA,CAAK,EAChC,IAAA,CAAK,MAAA,CAAS,IAAA,CAAK,eAAA,CAAgB,WAAA,EAAY,CAC/C,KAAK,QAAA,CAAW,EAClB,CAQA,YAAA,CAAaK,CAAAA,CAAgC,CAC3C,OAAO,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAaA,CAAI,CAC/C,CAEA,UAAuB,CACrB,OAAO,IAAA,CAAK,YACd,CAEA,QAAA,CAASJ,EAAyB,CAChC,IAAA,CAAK,YAAA,CAAeA,EACtB,CAEA,kBAAA,CAAmBE,EAAqI,CACtJ,IAAMG,CAAAA,CAAiB,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAaH,CAAQ,CAAA,CAKjE,OAAIG,CAAAA,CAAe,IAAA,EAAQH,CAAAA,CAAS,UAAA,CAAW,IAAI,CAAA,CAC1C,IAAA,CAAK,sBAAA,CAAuBA,CAAAA,CAAS,KAAA,CAAM,CAAC,CAAC,CAAA,CAGlDG,CAAAA,CAAe,IAAA,CACV,EAAC,CAGH,IAAA,CAAK,uBAAuBH,CAAQ,CAC7C,CAYA,wBAAA,CAAyBA,CAAAA,CAA2B,CAClD,IAAMG,CAAAA,CAAiB,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAaH,CAAQ,CAAA,CACjE,OAAIG,CAAAA,CAAe,IAAA,EAAQH,CAAAA,CAAS,UAAA,CAAW,IAAI,CAAA,CAC1C,KAAK,mBAAA,CAAoBA,CAAAA,CAAS,KAAA,CAAM,CAAC,CAAC,CAAA,CAE/CG,EAAe,IAAA,CAAa,EAAC,CAC1B,IAAA,CAAK,mBAAA,CAAoBH,CAAQ,CAC1C,CAEQ,mBAAA,CAAoBA,CAAAA,CAA2B,CAOrD,IAAA,CAAK,YAAA,CAAe,OACpB,IAAA,CAAK,SAAA,CAAY,MACjB,IAAA,CAAK,WAAA,CAAc,OACnB,IAAA,CAAK,eAAA,CAAgB,KAAA,CAAMA,CAAQ,CAAA,CACnC,IAAMI,EAAe,EAAC,CACtB,GAAI,CACF,IAAA,CAAK,eAAA,CAAgB,aAAaA,CAAG,EACvC,CAAA,MAASC,CAAAA,CAAQ,CACf,GAAI,EAAEA,CAAAA,YAAkBC,GAAAA,CAAAA,CAAc,MAAMD,CAC9C,CACA,IAAME,EAAkB,EAAC,CACzB,IAAA,IAAWC,CAAAA,IAASJ,CAAAA,CACdI,CAAAA,CAAM,OAAS,IAAA,EAAQA,CAAAA,CAAM,IAAA,GAAS,SAAA,EACtCA,CAAAA,CAAM,IAAA,CAAK,WAAW,KAAK,CAAA,EAC3BA,CAAAA,CAAM,IAAA,GAAS,oBAAA,EAAwBA,CAAAA,CAAM,OAAS,gBAAA,EAC1DD,CAAAA,CAAO,IAAA,CAAKC,CAAK,CAAA,CAEnB,OAAA,IAAA,CAAK,OAASD,CAAAA,CACd,IAAA,CAAK,QAAA,CAAW,CAAA,CACTA,CACT,CAEQ,uBAAuBP,CAAAA,CAAqI,CAClK,OAAO,IAAA,CAAK,mBAAA,CAAoBA,CAAQ,EAAE,GAAA,CAAIQ,CAAAA,GAAU,CACtD,IAAA,CAAMA,CAAAA,CAAM,IAAA,CACZ,MAAOA,CAAAA,CAAM,KAAA,CACb,MAAA,CAAQA,CAAAA,CAAM,MAAA,CACd,GAAA,CAAKA,EAAM,GAAA,CAIX,MAAA,CAAQA,CAAAA,CAAM,IAAA,CAAK,MAAA,CACnB,QAAA,CAAUC,IAAiBD,CAAAA,CAAM,IAAI,CACvC,CAAA,CAAE,CACJ,CACF,EAcaE,CAAAA,CAAc,IAAIjB,CAAAA,CAAM,IAAA,CAAM,MAAS","file":"chunk-Y7XRA2EV.js","sourcesContent":["/**\n * Lexer state machine modes.\n * - Main: document-level scanning with markdown classification\n * - Inline: expression embedded in markdown inline solve (`s\\`...\\``)\n * - String: inside a double-quoted string literal\n */\nexport enum LexerState {\n\tMain = \"main\",\n\tInline = \"inline\",\n\tString = \"string\",\n}\n","import { ExpressionLexer, LineClassification, LexerVocabulary, type ScanLineResult } from \"./ExpressionLexer\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { EngineError } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { LexerState } from \"@solve-js/lexer/LexerState\";\nimport { getTokenCategory } from \"@solve-js/language/TokenCategoryMap\";\nimport type { TokenCategory } from \"@solve-js/language/TokenCategory\";\nimport type { TokenLookup } from \"@solve-js/lexer/TokenClassRegistry\";\n\n/**\n * Public tokenizer wrapper around {@link ExpressionLexer}.\n *\n * `ExpressionLexer` does the actual character-by-character scanning;\n * `Lexer` adds a materialized-token-array streaming interface\n * (`next()`/`peek()`) plus line-classification state (`reset()`) so\n * callers can iterate a line's tokens without re-scanning on each peek.\n *\n * Each `ExpressionEngine` instance owns its own `Lexer`, and packages\n * extend it via {@link registerVocabulary} (keywords, operators, units)\n * see `IEnginePackage.lexerVocabulary`.\n */\nexport class Lexer {\n  /** Expression-mode lexer (Phase A: V8-optimized, replaces moo) */\n  private expressionLexer: ExpressionLexer;\n  private currentState: LexerState = LexerState.Main;\n  private peekedToken: Token | undefined;\n  private hasPeeked = false;\n\n  // Materialized token array from the last reset() call, used for\n  // next()/peek() streaming access.\n  private tokens: Token[] = [];\n  private tokenIdx: number = 0;\n\n  /**\n   * @param localeCode - Locale code (e.g., \"en\", \"de\"). Defaults to \"en\".\n   * @param _tokenLookup - Ignored. The lexer never read the lookup it was\n   *   handed; the parameter stays so existing callers compile.\n   *   @deprecated Removed in 3.0.\n   */\n  constructor(localeCode = \"en\", _tokenLookup?: TokenLookup) {\n    this.expressionLexer = new ExpressionLexer(localeCode);\n  }\n\n  reset(input: string, state?: LexerState): void {\n    const newState = state ?? LexerState.Main;\n    this.currentState = newState;\n    this.hasPeeked = false;\n    this.peekedToken = undefined;\n\n    // Phase B: Main state classifies the line with the markdown scanner.\n    // Skip lines (headings, fences, HRs, etc.) produce empty token arrays.\n    // Expression lines and lines with inline solves are tokenized normally.\n    if (newState === LexerState.Main) {\n      const classification = this.expressionLexer.classifyLine(input);\n      if (classification.skip) {\n        this.tokens = [];\n        this.tokenIdx = 0;\n        return;\n      }\n      // Expression line or markdown line with inline solves, tokenize.\n      this.expressionLexer.reset(input);\n      this.tokens = this.expressionLexer.tokenizeAll();\n      this.tokenIdx = 0;\n    } else {\n      // Non-main states (Inline, String), expression tokenization.\n      this.expressionLexer.reset(input);\n      this.tokens = this.expressionLexer.tokenizeAll();\n      this.tokenIdx = 0;\n    }\n  }\n\n  /**\n   * Classify a single line of markdown text (Phase B).\n   * Delegates to the ExpressionLexer's character-by-character scanner.\n   */\n  classifyLine(lineText: string): LineClassification {\n    return this.expressionLexer.classifyLine(lineText);\n  }\n\n  /**\n   * Find all inline solve markers in a line (Phase B).\n   * Delegates to the ExpressionLexer's character-by-character scanner.\n   */\n  findInlineSolves(lineText: string) {\n    return this.expressionLexer.findInlineSolves(lineText);\n  }\n\n  /**\n   * Every keyword this lexer currently recognizes (locale + plugin-contributed),\n   * mapped to the token type it lexes to. Delegates to the ExpressionLexer.\n   */\n  getKeywords(): Record<string, string> {\n    return this.expressionLexer.getKeywords();\n  }\n\n  next(): Token | undefined {\n    if (this.hasPeeked) {\n      this.hasPeeked = false;\n      return this.peekedToken;\n    }\n    // Materialized token array (ExpressionLexer path).\n    if (this.tokenIdx < this.tokens.length) {\n      return this.tokens[this.tokenIdx++];\n    }\n    return undefined;\n  }\n\n  peek(): Token | undefined {\n    if (this.hasPeeked) return this.peekedToken;\n    this.peekedToken = this.next();\n    this.hasPeeked = true;\n    return this.peekedToken;\n  }\n\n  [Symbol.iterator](): Iterator<Token> {\n    return this.tokens[Symbol.iterator]();\n  }\n\n  /**\n   * Register a plugin to extend the lexer with custom tokens.\n   * Delegates to the underlying ExpressionLexer.\n   *\n   * @see LexerVocabulary for the supported extension points.\n   */\n  registerVocabulary(plugin: LexerVocabulary): void {\n    this.expressionLexer.registerVocabulary(plugin);\n  }\n\n  /**\n   * Unregister a plugin, removing its custom tokens from the lexer.\n   * Delegates to the underlying ExpressionLexer.\n   */\n  unregisterVocabulary(plugin: LexerVocabulary): void {\n    this.expressionLexer.unregisterVocabulary(plugin);\n  }\n\n  /**\n   * Reset the lexer for expression-only text, skips the classifyLine()\n   * overhead in reset() for callers that already know the input is an\n   * evaluable expression (e.g., after isEmptyLine() confirmed non-skip).\n   */\n  resetExpression(input: string): void {\n    this.currentState = LexerState.Main;\n    this.hasPeeked = false;\n    this.peekedToken = undefined;\n    this.expressionLexer.reset(input);\n    this.tokens = this.expressionLexer.tokenizeAll();\n    this.tokenIdx = 0;\n  }\n\n  /**\n   * Scan a full document in one pass, classifying each line and\n   * tokenizing non-skipped lines. Delegates to ExpressionLexer.\n   *\n   * @returns ScanLineResult[], one per line, with classification + tokens.\n   */\n  scanDocument(text: string): ScanLineResult[] {\n    return this.expressionLexer.scanDocument(text);\n  }\n\n  getState(): LexerState {\n    return this.currentState;\n  }\n\n  setState(state: LexerState): void {\n    this.currentState = state;\n  }\n\n  getHighlightTokens(lineText: string): {type: string; value: string; offset: number; col: number; length: number; category: TokenCategory | undefined}[] {\n    const classification = this.expressionLexer.classifyLine(lineText);\n\n    // For blockquote lines, strip the \"> \" prefix and tokenize the expression content.\n    // This lets expressions inside blockquotes (e.g., \"> 1 + 2\") get syntax highlighted\n    // while pure structural lines (headings, code fences) remain unhighlighted.\n    if (classification.skip && lineText.startsWith(\"> \")) {\n      return this.collectHighlightTokens(lineText.slice(2));\n    }\n\n    if (classification.skip) {\n      return [];\n    }\n\n    return this.collectHighlightTokens(lineText);\n  }\n\n  /**\n   * The same tokens {@link getHighlightTokens} reduces, before reduction.\n   *\n   * Exists because normalization operates on tokens, not on the flattened\n   * shape, and a consumer that wants phrase-fused highlighting has to run the\n   * normalizer between the two. See `LanguageService.getSemanticTokens`.\n   *\n   * @param lineText - One line of source.\n   * @returns Every token on the line that is worth painting, unreduced.\n   */\n  getHighlightTokenObjects(lineText: string): Token[] {\n    const classification = this.expressionLexer.classifyLine(lineText);\n    if (classification.skip && lineText.startsWith(\"> \")) {\n      return this.collectTokenObjects(lineText.slice(2));\n    }\n    if (classification.skip) return [];\n    return this.collectTokenObjects(lineText);\n  }\n\n  private collectTokenObjects(lineText: string): Token[] {\n    // Scanned into an array this method owns rather than through\n    // resetExpression(), which has nothing to hand back when the line faults\n    // part way. Highlighting is painted while the line is still being typed,\n    // and an unterminated string is what a line looks like between the\n    // opening quote and the closing one: the tokens read before the fault are\n    // the right thing to paint, and letting the throw escape blanked the line.\n    this.currentState = LexerState.Main;\n    this.hasPeeked = false;\n    this.peekedToken = undefined;\n    this.expressionLexer.reset(lineText);\n    const raw: Token[] = [];\n    try {\n      this.expressionLexer.tokenizeInto(raw);\n    } catch (thrown) {\n      if (!(thrown instanceof EngineError)) throw thrown;\n    }\n    const result: Token[] = [];\n    for (const token of raw) {\n      if (token.type === \"WS\" || token.type === \"NEWLINE\") continue;\n      if (token.type.startsWith(\"MD_\")) continue;\n      if (token.type === \"INLINE_SOLVE_START\" || token.type === \"BACKTICK_CLOSE\") continue;\n      result.push(token);\n    }\n    this.tokens = result;\n    this.tokenIdx = 0;\n    return result;\n  }\n\n  private collectHighlightTokens(lineText: string): {type: string; value: string; offset: number; col: number; length: number; category: TokenCategory | undefined}[] {\n    return this.collectTokenObjects(lineText).map(token => ({\n      type: token.type,\n      value: token.value,\n      offset: token.offset,\n      col: token.col,\n      // `text`, not `value`: this is a span into the source, and the two\n      // differ for a string literal, whose value is the payload while its\n      // text still carries the quote characters the reader typed.\n      length: token.text.length,\n      category: getTokenCategory(token.type),\n    }));\n  }\n}\n\n/**\n * A lexer for operations that do not depend on registered vocabulary.\n *\n * Line classification and inline-solve detection read characters looking for\n * headings, comment markers, fences and backtick spans, and never consult the\n * keyword, unit or operator tables. Every lexer therefore returns the same\n * answer, so the callers that have no engine to ask can use this one. Checked\n * by `__tests__/lexer/LineClassificationIsVocabularyIndependent.spec.ts`.\n *\n * Do not tokenize with this. An engine's own lexer carries the vocabulary its\n * packages registered; this one carries none.\n */\nexport const sharedLexer = new Lexer(\"en\", undefined);"]}

package/dist/{chunk-5IJD5L3O.cjs → chunk-YBQOQTVL.cjs}

@@ -1,2 +1,2 @@
-'use strict';var R={NUMBER:"NUMBER",BIGINT:"BIGINT",STRING:"STRING",IDENT:"IDENT",PLUS:"PLUS",MINUS:"MINUS",PLUS_EQUALS:"PLUS_EQUALS",MINUS_EQUALS:"MINUS_EQUALS",STAR:"STAR",SLASH:"SLASH",PLUS_MINUS:"PLUS_MINUS",CARET:"CARET",PERCENT:"PERCENT",LSHIFT:"LSHIFT",RSHIFT:"RSHIFT",URSHIFT:"URSHIFT",LPAREN:"LPAREN",RPAREN:"RPAREN",LBRACKET:"LBRACKET",RBRACKET:"RBRACKET",LBRACE:"LBRACE",RBRACE:"RBRACE",COMMA:"COMMA",DOT:"DOT",COLON:"COLON",SEMICOLON:"SEMICOLON",EQUALS:"EQUALS",DOLLAR:"DOLLAR",POUND:"POUND",EURO:"EURO",YEN:"YEN",RUBLE:"RUBLE",WON:"WON",QUESTION:"QUESTION",BANG:"BANG",BIT_AND:"BIT_AND",BIT_OR:"BIT_OR",BIT_NOT:"BIT_NOT",KEYWORD:"KEYWORD",EOF:"EOF",ERROR:"ERROR",WS:"WS",NEWLINE:"NEWLINE",DATETIME_LITERAL:"DATETIME_LITERAL",DURATION:"DURATION",UNIT:"UNIT",ROLL:"ROLL",PI:"PI",E:"E",MOD:"MOD",AND_CONJ:"AND_CONJ",OF:"OF",INCREASE_BY:"INCREASE_BY",DECREASE_BY:"DECREASE_BY",OF_WHAT_IS:"OF_WHAT_IS",ON_WHAT_IS:"ON_WHAT_IS",OFF_WHAT_IS:"OFF_WHAT_IS",NOW:"NOW",TODAY:"TODAY",TOMORROW:"TOMORROW",YESTERDAY:"YESTERDAY",DURATION_DAY:"DURATION_DAY",DURATION_WEEK:"DURATION_WEEK",DURATION_MONTH:"DURATION_MONTH",DURATION_YEAR:"DURATION_YEAR",DURATION_HOUR:"DURATION_HOUR",DURATION_MINUTE:"DURATION_MINUTE",DURATION_SECOND:"DURATION_SECOND",FUNC:"FUNC",CONVERT:"CONVERT",TO:"TO",BEST:"BEST",NEXT:"NEXT",LAST:"LAST",UNTIL:"UNTIL",SINCE:"SINCE",BETWEEN:"BETWEEN",SPLIT:"SPLIT",SPLIT_WAYS:"SPLIT_WAYS",WAYS:"WAYS",PEOPLE:"PEOPLE",FROM:"FROM",INCREASE:"INCREASE",DECREASE:"DECREASE",UNICODE_MATH:"UNICODE_MATH",TIMES_BY:"TIMES_BY",MULTIPLY_BY:"MULTIPLY_BY",DIVIDE_BY:"DIVIDE_BY",NEQ:"NEQ",IN:"IN",BIT_XOR:"BIT_XOR",EQUALITY:"EQUALITY",GTE:"GTE",LTE:"LTE",LT:"LT",GT:"GT",LOGICAL_AND:"LOGICAL_AND",LOGICAL_OR:"LOGICAL_OR",OR:"OR",TRUE:"TRUE",FALSE:"FALSE",IF:"IF",THEN:"THEN",ELSE:"ELSE",AS:"AS",CONVERTER_NAME:"CONVERTER_NAME",ROUNDED:"ROUNDED",TO_NEAREST:"TO_NEAREST",DECIMAL_PLACES:"DECIMAL_PLACES",AVERAGE_OF:"AVERAGE_OF",MEDIAN_OF:"MEDIAN_OF",TOTAL_OF:"TOTAL_OF",COUNT_OF:"COUNT_OF",LARGER_OF:"LARGER_OF",SMALLER_OF:"SMALLER_OF",HALF_OF:"HALF_OF",MIDPOINT_BETWEEN:"MIDPOINT_BETWEEN",REMAINDER_OF:"REMAINDER_OF",NTH_ROOT:"NTH_ROOT",LOG_PHRASE:"LOG_PHRASE",LOG_BASE:"LOG_BASE",GCD_OF:"GCD_OF",LCM_OF:"LCM_OF",SQUARE_ROOT_OF:"SQUARE_ROOT_OF",CUBE_ROOT_OF:"CUBE_ROOT_OF",RANDOM_NUMBER:"RANDOM_NUMBER",IS_TO:"IS_TO",IS:"IS",PCT_ON:"PCT_ON",PCT_OFF:"PCT_OFF",PCT_UP:"PCT_UP",PCT_DOWN:"PCT_DOWN",OF_WHAT:"OF_WHAT",OFF_WHAT:"OFF_WHAT",ON_WHAT:"ON_WHAT",CLAMP:"CLAMP",MAP:"MAP",REDUCE:"REDUCE",SUM_FN:"SUM_FN",PROD_FN:"PROD_FN",EXPAND_FN:"EXPAND_FN",FACTOR_FN:"FACTOR_FN",SOLVE_FN:"SOLVE_FN",DER_FN:"DER_FN",INTEGRAL_FN:"INTEGRAL_FN",TAYLOR_FN:"TAYLOR_FN",JACOBIAN_FN:"JACOBIAN_FN",CONJ_FN:"CONJ_FN",RE_FN:"RE_FN",IM_FN:"IM_FN",CANCEL_FN:"CANCEL_FN",APART_FN:"APART_FN",IMAGINARY:"IMAGINARY",THEREFORE:"THEREFORE",TIME_IN:"TIME_IN",DATE_IN:"DATE_IN",TIME_DIFFERENCE_BETWEEN:"TIME_DIFFERENCE_BETWEEN",CITY_NAME:"CITY_NAME",BACKTICK_OPEN:"BACKTICK_OPEN",INLINE_SOLVE_START:"INLINE_SOLVE_START",COMMENT:"COMMENT",HEX_COLOUR:"HEX_COLOUR",TAG:"TAG",COLOUR_CALL:"COLOUR_CALL",VEC2:"VEC2",VEC3:"VEC3",VEC4:"VEC4",FLOAT:"FLOAT",GLOBAL:"GLOBAL",OVER:"OVER",RATE_AT:"RATE_AT",AFTER:"AFTER",PRESENT_VALUE_OF:"PRESENT_VALUE_OF",ANNUAL_RETURN_ON:"ANNUAL_RETURN_ON",FOR_DURATION:"FOR_DURATION",COMPOUNDING:"COMPOUNDING",INVESTED:"INVESTED",RETURNED:"RETURNED",COMPOUND_INTEREST_ON:"COMPOUND_INTEREST_ON",INTEREST_ON:"INTEREST_ON",DAILY_REPAYMENT_ON:"DAILY_REPAYMENT_ON",MONTHLY_REPAYMENT_ON:"MONTHLY_REPAYMENT_ON",ANNUAL_REPAYMENT_ON:"ANNUAL_REPAYMENT_ON",TOTAL_REPAYMENT_ON:"TOTAL_REPAYMENT_ON",DAILY_LOAN_INTEREST_ON:"DAILY_LOAN_INTEREST_ON",MONTHLY_LOAN_INTEREST_ON:"MONTHLY_LOAN_INTEREST_ON",ANNUAL_LOAN_INTEREST_ON:"ANNUAL_LOAN_INTEREST_ON",TOTAL_LOAN_INTEREST_ON:"TOTAL_LOAN_INTEREST_ON",TAX_ON:"TAX_ON",TAX_OFF:"TAX_OFF",TAX_IN_PHRASE:"TAX_IN_PHRASE",WHAT_IS:"WHAT_IS",WHAT_WAS:"WHAT_WAS",VALUE_OF:"VALUE_OF",WORTH_IN:"WORTH_IN",SAVINGS_HOW_LONG:"SAVINGS_HOW_LONG",SAVINGS_HOW_MUCH:"SAVINGS_HOW_MUCH",ASSUMING:"ASSUMING",IN_YEAR_DOLLARS:"IN_YEAR_DOLLARS",INGREDIENT_NAME:"INGREDIENT_NAME",WORKDAYS_IN:"WORKDAYS_IN",WEEKDAY_ON:"WEEKDAY_ON",CURRENT_TIMESTAMP:"CURRENT_TIMESTAMP",TO_DATE:"TO_DATE",TO_TIMESTAMP:"TO_TIMESTAMP",WEEKDAY_IN:"WEEKDAY_IN",MONTH_ON:"MONTH_ON",MONTH_IN:"MONTH_IN",WEEK_ON:"WEEK_ON",DAYS_IN_PERIOD:"DAYS_IN_PERIOD",IN_TWO_UNITS:"IN_TWO_UNITS",PER_UNIT:"PER_UNIT",AT_RATE:"AT_RATE",WEEK_IN:"WEEK_IN",BETWEEN_UNIT:"BETWEEN_UNIT",WORKDAYS_AFTER:"WORKDAYS_AFTER",WORKDAYS_BEFORE:"WORKDAYS_BEFORE",WORKDAYS_BETWEEN:"WORKDAYS_BETWEEN",IS_WEEKEND:"IS_WEEKEND",IS_WORKDAY:"IS_WORKDAY",VIDEO_TIMECODE:"VIDEO_TIMECODE",FRAME_COUNT:"FRAME_COUNT",AT:"AT",CURRENCY_SYMBOL:"CURRENCY_SYMBOL",PREV:"PREV",LINE_REF:"LINE_REF",SUM_RANGE_CALL:"SUM_RANGE_CALL",AVERAGE_RANGE_CALL:"AVERAGE_RANGE_CALL",TOTAL_ABOVE:"TOTAL_ABOVE",SUM_ABOVE:"SUM_ABOVE",AVERAGE_ABOVE:"AVERAGE_ABOVE",GOAL_SEEK:"GOAL_SEEK"},I=0,T=new Map,O=new Map;function A(E){let _=T.get(E);if(_!==void 0)return _;let N=I++;return T.set(E,N),O.set(N,E),N}function L(E){return A(E)}function S(E){return O.get(E)??`UNKNOWN_${E}`}function D(){for(let E of Object.values(R))A(E);}exports.a=R;exports.b=A;exports.c=L;exports.d=S;exports.e=D;//# sourceMappingURL=chunk-5IJD5L3O.cjs.map
-//# sourceMappingURL=chunk-5IJD5L3O.cjs.map
+'use strict';var R={NUMBER:"NUMBER",BIGINT:"BIGINT",STRING:"STRING",IDENT:"IDENT",PLUS:"PLUS",MINUS:"MINUS",PLUS_EQUALS:"PLUS_EQUALS",MINUS_EQUALS:"MINUS_EQUALS",STAR:"STAR",SLASH:"SLASH",PLUS_MINUS:"PLUS_MINUS",CARET:"CARET",PERCENT:"PERCENT",LSHIFT:"LSHIFT",RSHIFT:"RSHIFT",URSHIFT:"URSHIFT",LPAREN:"LPAREN",RPAREN:"RPAREN",LBRACKET:"LBRACKET",RBRACKET:"RBRACKET",LBRACE:"LBRACE",RBRACE:"RBRACE",COMMA:"COMMA",DOT:"DOT",COLON:"COLON",SEMICOLON:"SEMICOLON",EQUALS:"EQUALS",DOLLAR:"DOLLAR",POUND:"POUND",EURO:"EURO",YEN:"YEN",RUBLE:"RUBLE",WON:"WON",QUESTION:"QUESTION",BANG:"BANG",BIT_AND:"BIT_AND",BIT_OR:"BIT_OR",BIT_NOT:"BIT_NOT",KEYWORD:"KEYWORD",EOF:"EOF",ERROR:"ERROR",WS:"WS",NEWLINE:"NEWLINE",DATETIME_LITERAL:"DATETIME_LITERAL",DURATION:"DURATION",UNIT:"UNIT",ROLL:"ROLL",PI:"PI",E:"E",MOD:"MOD",AND_CONJ:"AND_CONJ",OF:"OF",INCREASE_BY:"INCREASE_BY",DECREASE_BY:"DECREASE_BY",OF_WHAT_IS:"OF_WHAT_IS",ON_WHAT_IS:"ON_WHAT_IS",OFF_WHAT_IS:"OFF_WHAT_IS",NOW:"NOW",TODAY:"TODAY",TOMORROW:"TOMORROW",YESTERDAY:"YESTERDAY",DURATION_DAY:"DURATION_DAY",DURATION_WEEK:"DURATION_WEEK",DURATION_MONTH:"DURATION_MONTH",DURATION_YEAR:"DURATION_YEAR",DURATION_HOUR:"DURATION_HOUR",DURATION_MINUTE:"DURATION_MINUTE",DURATION_SECOND:"DURATION_SECOND",FUNC:"FUNC",CONVERT:"CONVERT",TO:"TO",BEST:"BEST",NEXT:"NEXT",LAST:"LAST",UNTIL:"UNTIL",SINCE:"SINCE",BETWEEN:"BETWEEN",SPLIT:"SPLIT",SPLIT_WAYS:"SPLIT_WAYS",WAYS:"WAYS",PEOPLE:"PEOPLE",FROM:"FROM",INCREASE:"INCREASE",DECREASE:"DECREASE",UNICODE_MATH:"UNICODE_MATH",TIMES_BY:"TIMES_BY",MULTIPLY_BY:"MULTIPLY_BY",DIVIDE_BY:"DIVIDE_BY",NEQ:"NEQ",IN:"IN",BIT_XOR:"BIT_XOR",EQUALITY:"EQUALITY",GTE:"GTE",LTE:"LTE",LT:"LT",GT:"GT",LOGICAL_AND:"LOGICAL_AND",LOGICAL_OR:"LOGICAL_OR",OR:"OR",TRUE:"TRUE",FALSE:"FALSE",IF:"IF",THEN:"THEN",ELSE:"ELSE",AS:"AS",CONVERTER_NAME:"CONVERTER_NAME",ROUNDED:"ROUNDED",TO_NEAREST:"TO_NEAREST",DECIMAL_PLACES:"DECIMAL_PLACES",AVERAGE_OF:"AVERAGE_OF",MEDIAN_OF:"MEDIAN_OF",TOTAL_OF:"TOTAL_OF",COUNT_OF:"COUNT_OF",LARGER_OF:"LARGER_OF",SMALLER_OF:"SMALLER_OF",HALF_OF:"HALF_OF",MIDPOINT_BETWEEN:"MIDPOINT_BETWEEN",REMAINDER_OF:"REMAINDER_OF",NTH_ROOT:"NTH_ROOT",LOG_PHRASE:"LOG_PHRASE",LOG_BASE:"LOG_BASE",GCD_OF:"GCD_OF",LCM_OF:"LCM_OF",SQUARE_ROOT_OF:"SQUARE_ROOT_OF",CUBE_ROOT_OF:"CUBE_ROOT_OF",RANDOM_NUMBER:"RANDOM_NUMBER",IS_TO:"IS_TO",IS:"IS",PCT_ON:"PCT_ON",PCT_OFF:"PCT_OFF",PCT_UP:"PCT_UP",PCT_DOWN:"PCT_DOWN",OF_WHAT:"OF_WHAT",OFF_WHAT:"OFF_WHAT",ON_WHAT:"ON_WHAT",CLAMP:"CLAMP",MAP:"MAP",REDUCE:"REDUCE",SUM_FN:"SUM_FN",PROD_FN:"PROD_FN",EXPAND_FN:"EXPAND_FN",FACTOR_FN:"FACTOR_FN",SOLVE_FN:"SOLVE_FN",DER_FN:"DER_FN",INTEGRAL_FN:"INTEGRAL_FN",TAYLOR_FN:"TAYLOR_FN",JACOBIAN_FN:"JACOBIAN_FN",CONJ_FN:"CONJ_FN",RE_FN:"RE_FN",IM_FN:"IM_FN",CANCEL_FN:"CANCEL_FN",APART_FN:"APART_FN",IMAGINARY:"IMAGINARY",THEREFORE:"THEREFORE",TIME_IN:"TIME_IN",DATE_IN:"DATE_IN",TIME_DIFFERENCE_BETWEEN:"TIME_DIFFERENCE_BETWEEN",CITY_NAME:"CITY_NAME",BACKTICK_OPEN:"BACKTICK_OPEN",INLINE_SOLVE_START:"INLINE_SOLVE_START",COMMENT:"COMMENT",HEX_COLOUR:"HEX_COLOUR",TAG:"TAG",COLOUR_CALL:"COLOUR_CALL",VEC2:"VEC2",VEC3:"VEC3",VEC4:"VEC4",FLOAT:"FLOAT",GLOBAL:"GLOBAL",OVER:"OVER",RATE_AT:"RATE_AT",AFTER:"AFTER",PRESENT_VALUE_OF:"PRESENT_VALUE_OF",ANNUAL_RETURN_ON:"ANNUAL_RETURN_ON",FOR_DURATION:"FOR_DURATION",COMPOUNDING:"COMPOUNDING",INVESTED:"INVESTED",RETURNED:"RETURNED",COMPOUND_INTEREST_ON:"COMPOUND_INTEREST_ON",INTEREST_ON:"INTEREST_ON",DAILY_REPAYMENT_ON:"DAILY_REPAYMENT_ON",MONTHLY_REPAYMENT_ON:"MONTHLY_REPAYMENT_ON",ANNUAL_REPAYMENT_ON:"ANNUAL_REPAYMENT_ON",TOTAL_REPAYMENT_ON:"TOTAL_REPAYMENT_ON",DAILY_LOAN_INTEREST_ON:"DAILY_LOAN_INTEREST_ON",MONTHLY_LOAN_INTEREST_ON:"MONTHLY_LOAN_INTEREST_ON",ANNUAL_LOAN_INTEREST_ON:"ANNUAL_LOAN_INTEREST_ON",TOTAL_LOAN_INTEREST_ON:"TOTAL_LOAN_INTEREST_ON",TAX_ON:"TAX_ON",TAX_OFF:"TAX_OFF",TAX_IN_PHRASE:"TAX_IN_PHRASE",WHAT_IS:"WHAT_IS",WHAT_WAS:"WHAT_WAS",VALUE_OF:"VALUE_OF",WORTH_IN:"WORTH_IN",SAVINGS_HOW_LONG:"SAVINGS_HOW_LONG",SAVINGS_HOW_MUCH:"SAVINGS_HOW_MUCH",ASSUMING:"ASSUMING",IN_YEAR_DOLLARS:"IN_YEAR_DOLLARS",INGREDIENT_NAME:"INGREDIENT_NAME",WORKDAYS_IN:"WORKDAYS_IN",WEEKDAY_ON:"WEEKDAY_ON",CURRENT_TIMESTAMP:"CURRENT_TIMESTAMP",TO_DATE:"TO_DATE",TO_TIMESTAMP:"TO_TIMESTAMP",WEEKDAY_IN:"WEEKDAY_IN",MONTH_ON:"MONTH_ON",MONTH_IN:"MONTH_IN",WEEK_ON:"WEEK_ON",DAYS_IN_PERIOD:"DAYS_IN_PERIOD",IN_TWO_UNITS:"IN_TWO_UNITS",PER_UNIT:"PER_UNIT",AT_RATE:"AT_RATE",WEEK_IN:"WEEK_IN",BETWEEN_UNIT:"BETWEEN_UNIT",WORKDAYS_AFTER:"WORKDAYS_AFTER",WORKDAYS_BEFORE:"WORKDAYS_BEFORE",WORKDAYS_BETWEEN:"WORKDAYS_BETWEEN",IS_WEEKEND:"IS_WEEKEND",IS_WORKDAY:"IS_WORKDAY",VIDEO_TIMECODE:"VIDEO_TIMECODE",FRAME_COUNT:"FRAME_COUNT",AT:"AT",CURRENCY_SYMBOL:"CURRENCY_SYMBOL",PREV:"PREV",LINE_REF:"LINE_REF",SUM_RANGE_CALL:"SUM_RANGE_CALL",AVERAGE_RANGE_CALL:"AVERAGE_RANGE_CALL",TOTAL_ABOVE:"TOTAL_ABOVE",SUM_ABOVE:"SUM_ABOVE",AVERAGE_ABOVE:"AVERAGE_ABOVE",GOAL_SEEK:"GOAL_SEEK"},I=0,T=new Map,O=new Map;function A(E){let _=T.get(E);if(_!==void 0)return _;let N=I++;return T.set(E,N),O.set(N,E),N}function L(E){return A(E)}function S(E){return O.get(E)??`UNKNOWN_${E}`}function D(){for(let E of Object.values(R))A(E);}exports.a=R;exports.b=A;exports.c=L;exports.d=S;exports.e=D;//# sourceMappingURL=chunk-YBQOQTVL.cjs.map
+//# sourceMappingURL=chunk-YBQOQTVL.cjs.map