solve-engine 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/{chunk-RIN643A3.js → chunk-GPPLSM2Z.js}

@@ -47,6 +47,18 @@ var TokenTypes = {
   PI: "PI",
   E: "E",
   MOD: "MOD",
+  // The English word "and", which is NOT the same thing as "+" even though it
+  // adds. It used to map straight onto PLUS in the locale keyword map, which
+  // made "3 and 4" evaluate to 7 correctly and then quietly broke every phrase
+  // that uses "and" as a list separator: "average of 36, 42, 19 and 81" parsed
+  // its last argument as "19 + 81" and returned 178/3 rather than 178/4.
+  //
+  // Giving it its own type lets a parselet tell the two apart. It is still an
+  // infix addition (see ArithmeticPackage.ts) so "3 and 4" is unchanged, but it
+  // binds at BindingPower.Conjunction, one step looser than Sum, so a phrase
+  // parselet can parse an argument at Conjunction and get "1 + 2" whole while
+  // still stopping at "and".
+  AND_CONJ: "AND_CONJ",
   OF: "OF",
   INCREASE_BY: "INCREASE_BY",
   DECREASE_BY: "DECREASE_BY",
@@ -106,6 +118,13 @@ var TokenTypes = {
   ELSE: "ELSE",
   AS: "AS",
   CONVERTER_NAME: "CONVERTER_NAME",
+  // Rounding (packages/converters/). "rounded" is a bare keyword: it is a
+  // past participle with no plausible use as a :variableName, the same
+  // accepted-risk category as "between"/"from". TO_NEAREST and
+  // DECIMAL_PLACES are fused, since "to" already means percentage change.
+  ROUNDED: "ROUNDED",
+  TO_NEAREST: "TO_NEAREST",
+  DECIMAL_PLACES: "DECIMAL_PLACES",
   // Fused two-word phrase tokens (see MathPhrasesPackage.ts's `phrases`
   // field), deliberately NOT bare single-word keywords: "average"
   // "total", "count", etc. are common variable names, and this codebase
@@ -122,8 +141,26 @@ var TokenTypes = {
   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",
+  // Bare "is", the trigger for the solve-for-the-unknown percentage family
+  // (packages/percentage/IsWhatParselet.ts). Safe as a bare keyword: it is a
+  // verb, not a plausible :variableName, and the "is to" proportion phrase is
+  // fused earlier so it still wins.
+  IS: "IS",
+  PCT_ON: "PCT_ON",
+  PCT_OFF: "PCT_OFF",
+  OF_WHAT: "OF_WHAT",
+  OFF_WHAT: "OFF_WHAT",
+  ON_WHAT: "ON_WHAT",
   // CLAMP stays a bare single-word keyword: "clamp X between Y and Z" has
   // the value X between the trigger and "between", so it can't be
   // phrase-fused like the others above (same structural reason
@@ -206,6 +243,23 @@ var TokenTypes = {
   // create an unintended coupling if "@" is ever wired up.
   OVER: "OVER",
   RATE_AT: "RATE_AT",
+  // The investment grammar's connectives (packages/finance/), same
+  // accepted-risk category as OVER/RATE_AT above. "after"/"for" are
+  // prepositions; "compounding", "invested" and "returned" are participles,
+  // and none is a plausible `:variableName`.
+  //
+  // "after" and "for" are the pivots Soulver's own documented syntax uses,
+  // `$1,000 after 3 years at 7%` and `$1,000 for 3 years at 7% compounding
+  // monthly`. This package originally substituted "over" for both and said so
+  // in CompoundInterestParselet.ts's doc comment; the documented spellings now
+  // work as well, and "over" is kept so nothing that already parsed stops.
+  AFTER: "AFTER",
+  PRESENT_VALUE_OF: "PRESENT_VALUE_OF",
+  ANNUAL_RETURN_ON: "ANNUAL_RETURN_ON",
+  FOR_DURATION: "FOR_DURATION",
+  COMPOUNDING: "COMPOUNDING",
+  INVESTED: "INVESTED",
+  RETURNED: "RETURNED",
   // Fused phrase tokens (see FinancePackage.ts's `phrases` field)
   // deliberately NOT bare single-word keywords: "interest", "tax", "vat",
   // "repayment", "principal" etc. are all common, plausible variable names
@@ -226,6 +280,7 @@ var TokenTypes = {
   TOTAL_LOAN_INTEREST_ON: "TOTAL_LOAN_INTEREST_ON",
   TAX_ON: "TAX_ON",
   TAX_OFF: "TAX_OFF",
+  TAX_IN_PHRASE: "TAX_IN_PHRASE",
   // Inflation-adjusted value (packages/finance/) -- fused phrase
   // tokens (see FinancePackage.ts's `phrases` field), same reasoning
   // as the tax/interest phrases above: "what"/"was"/"value"/"worth"
@@ -278,6 +333,10 @@ var TokenTypes = {
   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",
   // `<unit> between <date> and <date>`, fused UNIT+BETWEEN, exactly like
   // UNTIL_UNIT/SINCE_UNIT above.
@@ -350,5 +409,5 @@ function registerAllTokenTypes() {
 }
 
 export { TokenTypes, registerAllTokenTypes, registerTokenType, tokenTypeId, tokenTypeName };
-//# sourceMappingURL=chunk-RIN643A3.js.map
-//# sourceMappingURL=chunk-RIN643A3.js.map
+//# sourceMappingURL=chunk-GPPLSM2Z.js.map
+//# sourceMappingURL=chunk-GPPLSM2Z.js.map

package/dist/chunk-GPPLSM2Z.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lexer/Token.ts"],"names":[],"mappings":"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","file":"chunk-GPPLSM2Z.js","sourcesContent":["/**\n * Lexer token produced by {@link ExpressionLexer} and consumed by parsers.\n *\n * Each token carries:\n * - `type`: string name (e.g. \"NUMBER\", \"PLUS\") for diagnostics and parselet lookup\n * - `typeId`: integer ID for O(1) comparison in parser hot paths\n * - `value`/`text`: the token's semantic value and raw source text\n * - `offset`/`line`/`col`: source position for error messages and highlighting\n */\nexport interface Token {\n\t/** String token type (e.g., \"NUMBER\", \"PLUS\", \"IDENT\"). Used by ParseletRegistry string-keyed maps and error messages. */\n\ttype: string;\n\t/** Integer token type ID for fast comparison in Parser hot path.\n\t * Populated by the Lexer via registerTokenType(). Use tokenTypeId(type) to get a type's ID. */\n\ttypeId: number;\n\tvalue: string;\n\ttext: string;\n\toffset: number;\n\tlineBreaks: number;\n\tline: number;\n\tcol: number;\n\t/**\n\t * End offset of the source text this token was fused from, exclusive.\n\t *\n\t * Only set on tokens the normalizer built by fusing several lexer tokens\n\t * into one, and only there because those are the tokens whose `value` no\n\t * longer describes the text they came from. `10 frames` fuses into a\n\t * FRAME_COUNT whose value is `10`, so `offset + value.length` would cover\n\t * two characters of a nine-character phrase.\n\t *\n\t * Evaluation never reads this. It exists so that a consumer painting a line\n\t * (see `LanguageService.getSemanticTokens`) can highlight a fused phrase as\n\t * the one thing the parser will see rather than as its parts.\n\t */\n\tsourceEnd?: number;\n}\n\n/**\n * Canonical token type name constants.\n * All token types used by the lexer, parser, and VM are defined here.\n * Custom/plugin token types should be registered via {@link registerTokenType}.\n */\nexport const TokenTypes = {\n  NUMBER: \"NUMBER\",\n  BIGINT: \"BIGINT\",\n  STRING: \"STRING\",\n  IDENT: \"IDENT\",\n  PLUS: \"PLUS\",\n  MINUS: \"MINUS\",\n  STAR: \"STAR\",\n  SLASH: \"SLASH\",\n  CARET: \"CARET\",\n  PERCENT: \"PERCENT\",\n  LSHIFT: \"LSHIFT\",\n  RSHIFT: \"RSHIFT\",\n  URSHIFT: \"URSHIFT\",\n  LPAREN: \"LPAREN\",\n  RPAREN: \"RPAREN\",\n  LBRACKET: \"LBRACKET\",\n  RBRACKET: \"RBRACKET\",\n  LBRACE: \"LBRACE\",\n  RBRACE: \"RBRACE\",\n  COMMA: \"COMMA\",\n  DOT: \"DOT\",\n  COLON: \"COLON\",\n  SEMICOLON: \"SEMICOLON\",\n  EQUALS: \"EQUALS\",\n  DOLLAR: \"DOLLAR\",\n  POUND: \"POUND\",\n  EURO: \"EURO\",\n  YEN: \"YEN\",\n  RUBLE: \"RUBLE\",\n  WON: \"WON\",\n  QUESTION: \"QUESTION\",\n  BANG: \"BANG\",\n  BIT_AND: \"BIT_AND\",\n  BIT_OR: \"BIT_OR\",\n  BIT_NOT: \"BIT_NOT\",\n  KEYWORD: \"KEYWORD\",\n  EOF: \"EOF\",\n  ERROR: \"ERROR\",\n  WS: \"WS\",\n  NEWLINE: \"NEWLINE\",\n  DATETIME_LITERAL: \"DATETIME_LITERAL\",\n  DURATION: \"DURATION\",\n  UNIT: \"UNIT\",\n  ROLL: \"ROLL\",\n  PI: \"PI\",\n  E: \"E\",\n  MOD: \"MOD\",\n  // The English word \"and\", which is NOT the same thing as \"+\" even though it\n  // adds. It used to map straight onto PLUS in the locale keyword map, which\n  // made \"3 and 4\" evaluate to 7 correctly and then quietly broke every phrase\n  // that uses \"and\" as a list separator: \"average of 36, 42, 19 and 81\" parsed\n  // its last argument as \"19 + 81\" and returned 178/3 rather than 178/4.\n  //\n  // Giving it its own type lets a parselet tell the two apart. It is still an\n  // infix addition (see ArithmeticPackage.ts) so \"3 and 4\" is unchanged, but it\n  // binds at BindingPower.Conjunction, one step looser than Sum, so a phrase\n  // parselet can parse an argument at Conjunction and get \"1 + 2\" whole while\n  // still stopping at \"and\".\n  AND_CONJ: \"AND_CONJ\",\n  OF: \"OF\",\n  INCREASE_BY: \"INCREASE_BY\",\n  DECREASE_BY: \"DECREASE_BY\",\n  // Percentage solve-for-unknown (packages/percentage/), \"N% of what is\n  // X\" solves N% * base = X for base. Fused as a full 3-word phrase (see\n  // PercentagePackage.ts's `phrases` field) rather than a bare \"what\"\n  // keyword, \"what\" is common enough as a variable name to be worth the\n  // same phrase-fusion treatment this codebase gives \"total\"/\"average\"/etc.\n  OF_WHAT_IS: \"OF_WHAT_IS\",\n  // Sibling solve-for-unknown forms accounting for a +/-1 offset, \"N% on\n  // what is X\" (increase) / \"N% off what is X\" (decrease). Same\n  // phrase-fusion reasoning as OF_WHAT_IS above.\n  ON_WHAT_IS: \"ON_WHAT_IS\",\n  OFF_WHAT_IS: \"OFF_WHAT_IS\",\n  NOW: \"NOW\",\n  TODAY: \"TODAY\",\n  TOMORROW: \"TOMORROW\",\n  YESTERDAY: \"YESTERDAY\",\n  DURATION_DAY: \"DURATION_DAY\",\n  DURATION_WEEK: \"DURATION_WEEK\",\n  DURATION_MONTH: \"DURATION_MONTH\",\n  DURATION_YEAR: \"DURATION_YEAR\",\n  DURATION_HOUR: \"DURATION_HOUR\",\n  DURATION_MINUTE: \"DURATION_MINUTE\",\n  DURATION_SECOND: \"DURATION_SECOND\",\n  FUNC: \"FUNC\",\n  CONVERT: \"CONVERT\",\n  TO: \"TO\",\n  BEST: \"BEST\",\n  NEXT: \"NEXT\",\n  LAST: \"LAST\",\n  UNTIL: \"UNTIL\",\n  SINCE: \"SINCE\",\n  BETWEEN: \"BETWEEN\",\n  FROM: \"FROM\",\n  INCREASE: \"INCREASE\",\n  DECREASE: \"DECREASE\",\n  UNICODE_MATH: \"UNICODE_MATH\",\n  TIMES_BY: \"TIMES_BY\",\n  MULTIPLY_BY: \"MULTIPLY_BY\",\n  DIVIDE_BY: \"DIVIDE_BY\",\n  NEQ: \"NEQ\",\n  IN: \"IN\",\n  BIT_XOR: \"BIT_XOR\",\n  EQUALITY: \"EQUALITY\",\n  GTE: \"GTE\",\n  LTE: \"LTE\",\n  LT: \"LT\",\n  GT: \"GT\",\n  LOGICAL_AND: \"LOGICAL_AND\",\n  LOGICAL_OR: \"LOGICAL_OR\",\n  OR: \"OR\",\n  TRUE: \"TRUE\",\n  FALSE: \"FALSE\",\n  IF: \"IF\",\n  THEN: \"THEN\",\n  ELSE: \"ELSE\",\n  AS: \"AS\",\n  CONVERTER_NAME: \"CONVERTER_NAME\",\n  // Rounding (packages/converters/). \"rounded\" is a bare keyword: it is a\n  // past participle with no plausible use as a :variableName, the same\n  // accepted-risk category as \"between\"/\"from\". TO_NEAREST and\n  // DECIMAL_PLACES are fused, since \"to\" already means percentage change.\n  ROUNDED: \"ROUNDED\",\n  TO_NEAREST: \"TO_NEAREST\",\n  DECIMAL_PLACES: \"DECIMAL_PLACES\",\n  // Fused two-word phrase tokens (see MathPhrasesPackage.ts's `phrases`\n  // field), deliberately NOT bare single-word keywords: \"average\"\n  // \"total\", \"count\", etc. are common variable names, and this codebase\n  // has a tested policy that colon-prefixed variable names can't be\n  // keyword-shaped words (see VariableParselet.ts's doc comment). Fusing\n  // the full \"<word> of\"/\"<word> between\" phrase means the bare word\n  // itself never becomes its own token type, so \":total = ...\" keeps\n  // working exactly as before.\n  AVERAGE_OF: \"AVERAGE_OF\",\n  MEDIAN_OF: \"MEDIAN_OF\",\n  TOTAL_OF: \"TOTAL_OF\",\n  COUNT_OF: \"COUNT_OF\",\n  LARGER_OF: \"LARGER_OF\",\n  SMALLER_OF: \"SMALLER_OF\",\n  HALF_OF: \"HALF_OF\",\n  MIDPOINT_BETWEEN: \"MIDPOINT_BETWEEN\",\n  REMAINDER_OF: \"REMAINDER_OF\",\n  NTH_ROOT: \"NTH_ROOT\",\n  LOG_PHRASE: \"LOG_PHRASE\",\n  LOG_BASE: \"LOG_BASE\",\n  GCD_OF: \"GCD_OF\",\n  LCM_OF: \"LCM_OF\",\n  SQUARE_ROOT_OF: \"SQUARE_ROOT_OF\",\n  CUBE_ROOT_OF: \"CUBE_ROOT_OF\",\n  RANDOM_NUMBER: \"RANDOM_NUMBER\",\n  IS_TO: \"IS_TO\",\n  // Bare \"is\", the trigger for the solve-for-the-unknown percentage family\n  // (packages/percentage/IsWhatParselet.ts). Safe as a bare keyword: it is a\n  // verb, not a plausible :variableName, and the \"is to\" proportion phrase is\n  // fused earlier so it still wins.\n  IS: \"IS\",\n  PCT_ON: \"PCT_ON\",\n  PCT_OFF: \"PCT_OFF\",\n  OF_WHAT: \"OF_WHAT\",\n  OFF_WHAT: \"OFF_WHAT\",\n  ON_WHAT: \"ON_WHAT\",\n  // CLAMP stays a bare single-word keyword: \"clamp X between Y and Z\" has\n  // the value X between the trigger and \"between\", so it can't be\n  // phrase-fused like the others above (same structural reason\n  // ClampParselet.ts is hand-written instead of PhrasePattern-based).\n  // Matches this codebase's existing accepted risk for \"between\"/\"from\"/\n  // \"next\"/\"last\"/\"best\", also bare, also can't be used as `:name`.\n  CLAMP: \"CLAMP\",\n  // map/reduce/sum/prod (packages/mapreduce/), bare single-word keywords\n  // each with its own dedicated parselet (custom argument grammar: a bare\n  // builtin/user-function name, an inline transform expression, or\n  // `name=collection` zipped pairs, none of which fit the ordinary\n  // FunctionCallParselet path, so these can't just reuse the generic FUNC\n  // token type the way sqrt/abs/... do).\n  MAP: \"MAP\",\n  REDUCE: \"REDUCE\",\n  SUM_FN: \"SUM_FN\",\n  PROD_FN: \"PROD_FN\",\n  // The algebra verbs (packages/symbolic/), fused from an ordinary IDENT only\n  // when immediately followed by `(`, so `factor`/`solve`/`expand` stay usable\n  // as variable names. Declared here rather than left to be minted on first use\n  // by `tokenTypeId()`, which is what {@link registerAllTokenTypes} exists for:\n  // a lazily-minted id depends on what else happened to be minted before it, so\n  // in a single-process run the id a normalizer rule produces can stop matching\n  // the id the parselet was registered under. Every token type a built-in\n  // package relies on belongs in this table.\n  EXPAND_FN: \"EXPAND_FN\",\n  FACTOR_FN: \"FACTOR_FN\",\n  SOLVE_FN: \"SOLVE_FN\",\n  DER_FN: \"DER_FN\",\n  INTEGRAL_FN: \"INTEGRAL_FN\",\n  TAYLOR_FN: \"TAYLOR_FN\",\n  JACOBIAN_FN: \"JACOBIAN_FN\",\n  CONJ_FN: \"CONJ_FN\",\n  RE_FN: \"RE_FN\",\n  IM_FN: \"IM_FN\",\n  CANCEL_FN: \"CANCEL_FN\",\n  APART_FN: \"APART_FN\",\n  // The imaginary-literal suffix, fused from a number followed immediately by\n  // `i`. Same registration reasoning as the verbs above.\n  IMAGINARY: \"IMAGINARY\",\n  // `=>`, \"therefore\"/solve operator. The algebra itself lives in symbolic/;\n  // packages/symbolic/ carries the grammar surface for the named operations.\n  // A genuine 2-char lexer token (ExpressionLexer.ts's TWO_CHAR_OPS table),\n  // same mechanism as ==/!=/>=/<=, not a normalizer-level fusion, \"=\" then\n  // \">\" is the opposite char order from GTE's \">=\", so there's no collision.\n  THEREFORE: \"THEREFORE\",\n  // Timezone query phrases (see TimePackage.ts's `phrases` field). Same\n  // phrase-fusion reasoning as above: \"time\"/\"date\"/\"difference\" are\n  // common variable names, so the fused trigger is the full phrase.\n  // CITY_NAME is the fused-token type for multi-word city/country names\n  // (e.g. \"new york\"). See timezones/CityZones.ts's MULTI_WORD_CITY_ZONES.\n  TIME_IN: \"TIME_IN\",\n  DATE_IN: \"DATE_IN\",\n  TIME_DIFFERENCE_BETWEEN: \"TIME_DIFFERENCE_BETWEEN\",\n  CITY_NAME: \"CITY_NAME\",\n  BACKTICK_OPEN: \"BACKTICK_OPEN\",\n  INLINE_SOLVE_START: \"INLINE_SOLVE_START\",\n  // Comment marker, `#` or `//` to end of line. Emitted by\n  // ExpressionLexer.tokenizeComment()/tokenizeOperator() but never reaches\n  // a parselet: ExpressionEngine.prepareExpression() filters COMMENT\n  // tokens out of the stream before normalization/parsing (see\n  // ExpressionEngine.ts's \"Filter COMMENT tokens\" comments). Listed here\n  // for discoverability even though tokenTypeId() would lazily register\n  // it anyway on first use.\n  COMMENT: \"COMMENT\",\n  // Vector types (referenced in locale keywordMap as vec2→VEC2, etc.)\n  VEC2: \"VEC2\",\n  VEC3: \"VEC3\",\n  VEC4: \"VEC4\",\n  FLOAT: \"FLOAT\",\n  GLOBAL: \"GLOBAL\",\n  // ── Finance (packages/finance/) ──\n  // OVER/RATE_AT are bare single-word keywords (not phrase-fused): both are\n  // prepositions with near-zero plausibility as a variable name (nobody\n  // writes \":over = 5\" or \":at = 3\"), the same accepted-risk category as\n  // this codebase's existing bare \"between\"/\"from\"/\"next\"/\"last\"/\"best\"\n  // keywords (see VariableParselet.ts's doc comment). RATE_AT is deliberately\n  // NOT named \"AT\", that name is already reserved (dormant) for a future\n  // \"@\" symbol token in TokenNormalizer.NON_WORD_NAMES; reusing it here would\n  // create an unintended coupling if \"@\" is ever wired up.\n  OVER: \"OVER\",\n  RATE_AT: \"RATE_AT\",\n  // The investment grammar's connectives (packages/finance/), same\n  // accepted-risk category as OVER/RATE_AT above. \"after\"/\"for\" are\n  // prepositions; \"compounding\", \"invested\" and \"returned\" are participles,\n  // and none is a plausible `:variableName`.\n  //\n  // \"after\" and \"for\" are the pivots Soulver's own documented syntax uses,\n  // `$1,000 after 3 years at 7%` and `$1,000 for 3 years at 7% compounding\n  // monthly`. This package originally substituted \"over\" for both and said so\n  // in CompoundInterestParselet.ts's doc comment; the documented spellings now\n  // work as well, and \"over\" is kept so nothing that already parsed stops.\n  AFTER: \"AFTER\",\n  PRESENT_VALUE_OF: \"PRESENT_VALUE_OF\",\n  ANNUAL_RETURN_ON: \"ANNUAL_RETURN_ON\",\n  FOR_DURATION: \"FOR_DURATION\",\n  COMPOUNDING: \"COMPOUNDING\",\n  INVESTED: \"INVESTED\",\n  RETURNED: \"RETURNED\",\n  // Fused phrase tokens (see FinancePackage.ts's `phrases` field)\n  // deliberately NOT bare single-word keywords: \"interest\", \"tax\", \"vat\",\n  // \"repayment\", \"principal\" etc. are all common, plausible variable names\n  // (a shipped playground example uses \":total = :subtotal + :tax\". See\n  // MathPhrasesPackage.ts's doc comment for the regression this caused\n  // once already). Fusing the full \"<word> on\"/\"<word> off\" phrase means\n  // the bare leading word itself never becomes its own token type, so\n  // \":tax = ...\" keeps working exactly as before.\n  COMPOUND_INTEREST_ON: \"COMPOUND_INTEREST_ON\",\n  INTEREST_ON: \"INTEREST_ON\",\n  DAILY_REPAYMENT_ON: \"DAILY_REPAYMENT_ON\",\n  MONTHLY_REPAYMENT_ON: \"MONTHLY_REPAYMENT_ON\",\n  ANNUAL_REPAYMENT_ON: \"ANNUAL_REPAYMENT_ON\",\n  TOTAL_REPAYMENT_ON: \"TOTAL_REPAYMENT_ON\",\n  DAILY_LOAN_INTEREST_ON: \"DAILY_LOAN_INTEREST_ON\",\n  MONTHLY_LOAN_INTEREST_ON: \"MONTHLY_LOAN_INTEREST_ON\",\n  ANNUAL_LOAN_INTEREST_ON: \"ANNUAL_LOAN_INTEREST_ON\",\n  TOTAL_LOAN_INTEREST_ON: \"TOTAL_LOAN_INTEREST_ON\",\n  TAX_ON: \"TAX_ON\",\n  TAX_OFF: \"TAX_OFF\",\n  TAX_IN_PHRASE: \"TAX_IN_PHRASE\",\n  // Inflation-adjusted value (packages/finance/) -- fused phrase\n  // tokens (see FinancePackage.ts's `phrases` field), same reasoning\n  // as the tax/interest phrases above: \"what\"/\"was\"/\"value\"/\"worth\"\n  // are all plausible variable names, so only the full phrases are\n  // ever claimed as keywords, never the bare leading word.\n  WHAT_IS: \"WHAT_IS\",\n  WHAT_WAS: \"WHAT_WAS\",\n  VALUE_OF: \"VALUE_OF\",\n  WORTH_IN: \"WORTH_IN\",\n  // Bare single-word keyword (not phrase-fused) -- \"assuming\" has\n  // near-zero plausibility as a variable name, the same accepted-risk\n  // category as this codebase's existing bare \"over\"/\"at\" keywords\n  // (see the OVER/RATE_AT comment above). Registered so its bare word\n  // is a recognized phrase-starter (`canStartPhrase`), which suppresses\n  // implicit-multiply insertion between the futureYear NUMBER and this\n  // word in \"value of $X in <year> assuming N% inflation\" -- without\n  // this, \"<year> assuming\" was silently rewritten to \"<year> *\n  // assuming\" before parsing ever ran.\n  ASSUMING: \"ASSUMING\",\n  // Fused by a custom NormalizerRule (not `phrases`), carrying the\n  // year as its value -- see\n  // finance/normalizer/InYearDollarsNormalizerRule.ts.\n  IN_YEAR_DOLLARS: \"IN_YEAR_DOLLARS\",\n  // Cooking/UoM (packages/uom/) -- fused ingredient name (single- or\n  // multi-word, e.g. \"butter\"/\"olive oil\") carrying the matched name\n  // as its value. NOT a bare-word phrase-trie keyword -- see\n  // uom/normalizer/IngredientNameNormalizerRule.ts's doc comment for\n  // why this is a context-sensitive NormalizerRule instead (so a bare\n  // `:butter = 5` variable definition is completely unaffected).\n  INGREDIENT_NAME: \"INGREDIENT_NAME\",\n  // ── Datetime, workdays/weekdays/timestamps (packages/datetime/) ──\n  // Fused phrase tokens (see DatetimePackage.ts's `phrases` field)\n  // deliberately NOT bare single-word keywords: \"workdays\"/\"weekday\"/\n  // \"timestamp\"/\"date\" are all plausible variable names, same\n  // reasoning/regression risk as MathPhrasesPackage.ts's \"total\" note and\n  // FinancePackage.ts's \"tax\" note above. Fusing the full phrase means the\n  // bare leading word itself never becomes its own token type, so e.g.\n  // \":timestamp = 5\" keeps working.\n  WORKDAYS_IN: \"WORKDAYS_IN\",\n  WEEKDAY_ON: \"WEEKDAY_ON\",\n  CURRENT_TIMESTAMP: \"CURRENT_TIMESTAMP\",\n  TO_DATE: \"TO_DATE\",\n  TO_TIMESTAMP: \"TO_TIMESTAMP\",\n  // Natural-question forms over the same date fields, \"what day is it in\n  // 30 days\", \"what month is it on 25/12/2026\", \"what week is it\". Each is\n  // a fully-fused phrase for the same reason as WEEKDAY_ON above: claiming\n  // bare \"day\"/\"month\"/\"week\" as keywords would break \":day = 5\" and\n  // collide with the UNIT tokens of the same name.\n  WEEKDAY_IN: \"WEEKDAY_IN\",\n  MONTH_ON: \"MONTH_ON\",\n  MONTH_IN: \"MONTH_IN\",\n  WEEK_ON: \"WEEK_ON\",\n  DAYS_IN_PERIOD: \"DAYS_IN_PERIOD\",\n  IN_TWO_UNITS: \"IN_TWO_UNITS\",\n  PER_UNIT: \"PER_UNIT\",\n  AT_RATE: \"AT_RATE\",\n  WEEK_IN: \"WEEK_IN\",\n  // `<unit> between <date> and <date>`, fused UNIT+BETWEEN, exactly like\n  // UNTIL_UNIT/SINCE_UNIT above.\n  BETWEEN_UNIT: \"BETWEEN_UNIT\",\n  // Postfix day-type predicates, \"<date> is a weekend\" / \"is a workday\".\n  IS_WEEKEND: \"IS_WEEKEND\",\n  IS_WORKDAY: \"IS_WORKDAY\",\n  // ── Time, video timecode (packages/time/) ──\n  // Fused from a raw `HH:MM:SS:FF` token sequence (see\n  // packages/time/normalizer/VideoTimecodeNormalizerRule.ts) and from\n  // `NUMBER frames` (see FrameCountNormalizerRule.ts), not a bare-keyword\n  // collision risk the way the datetime tokens above are, since neither\n  // fusion claims a plain English word as its own token type.\n  VIDEO_TIMECODE: \"VIDEO_TIMECODE\",\n  FRAME_COUNT: \"FRAME_COUNT\",\n  // \"@\". See ExpressionLexer.ts's OP_MAP entry for why this was\n  // previously dormant/unproduced despite being anticipated by name here\n  // and in TokenNormalizer.ts's NON_WORD_NAMES.\n  AT: \"AT\",\n  // Generic token for every currency symbol added AFTER the original\n  // DOLLAR/POUND/EURO/YEN/RUBLE/WON set (each of which kept its own\n  // specific token type for backward compatibility). See\n  // uom/CurrencyAliases.ts's CURRENCY_SYMBOL_ALIASES and\n  // ExpressionLexer.ts's dispatch for the full symbol list. One shared\n  // type avoids needing a new TokenTypes entry + TokenCategoryMap entry +\n  // CurrencyPackage.ts prefixParselets entry per additional symbol.\n  CURRENCY_SYMBOL: \"CURRENCY_SYMBOL\",\n  // ── Cross-line data access (packages/lines/) ──\n  // \"prev\" -- bare keyword (nothing to phrase-fuse against, same shape as\n  // CLAMP -- accepted collision risk per that package's own precedent).\n  PREV: \"PREV\",\n  // \"line1\" / \"line 1\" / \"l1\" -- fused by LineRefNormalizerRule (never a\n  // bare lexer keyword, so \":line = 5\"/\":l = 5\" stay untouched). Carries\n  // the parsed line number as its .value.\n  LINE_REF: \"LINE_REF\",\n  // \"sum(\" / \"total(\" -- fused ONLY when immediately followed by LPAREN\n  // (see LineRefNormalizerRule's lookahead guard), so \":sum = 100\" and\n  // MathPhrases' \"total of X, Y\" (no paren after \"of\") are unaffected.\n  SUM_RANGE_CALL: \"SUM_RANGE_CALL\",\n  AVERAGE_RANGE_CALL: \"AVERAGE_RANGE_CALL\",\n  // \"total above\" / \"sum above\" / \"average above\" -- phrase-fused (see\n  // LinesPackage.ts's `phrases` field), a deliberate departure from\n  // Numi/Numbr's bare \"total\"/\"sum\" wording to avoid the exact bare-\n  // keyword collision this codebase already regressed on once.\n  TOTAL_ABOVE: \"TOTAL_ABOVE\",\n  SUM_ABOVE: \"SUM_ABOVE\",\n  AVERAGE_ABOVE: \"AVERAGE_ABOVE\",\n} as const;\n\n/**\n * A token's kind, as a string.\n *\n * Deliberately open rather than an enum: a package registers its own token\n * types at runtime, and a closed set would make that impossible.\n */\nexport type TokenType = (typeof TokenTypes)[keyof typeof TokenTypes];\n\n// ── Integer Token Type ID System ──────────────────────────────────────────────\n// Enables O(1) integer comparison in Parser hot path instead of string hashing.\n\n/** Auto-incrementing integer ID for each token type. */\nlet _nextTokenTypeId = 0;\n\n/** String → integer ID lookup. Populated lazily via registerTokenType(). */\nconst _tokenTypeNameToId = new Map<string, number>();\n\n/** Integer ID → string lookup. For debug/error messages. */\nconst _tokenTypeIdToName = new Map<number, string>();\n\n/**\n * Register a token type name and get back its integer ID.\n * Idempotent, returns existing ID if already registered.\n * Call once per token type at module initialization time.\n */\nexport function registerTokenType(name: string): number {\n\tconst existing = _tokenTypeNameToId.get(name);\n\tif (existing !== undefined) return existing;\n\tconst id = _nextTokenTypeId++;\n\t_tokenTypeNameToId.set(name, id);\n\t_tokenTypeIdToName.set(id, name);\n\treturn id;\n}\n\n/**\n * Get the integer ID for a token type name.\n * Lazily registers unknown token types on first access, enabling plugin providers\n * to define custom token types (VEC2, VEC3, etc.) without pre-registration.\n * All built-in TokenTypes are pre-registered via registerAllTokenTypes().\n */\nexport function tokenTypeId(name: string): number {\n\treturn registerTokenType(name);  // registerTokenType is idempotent\n}\n\n/**\n * Get the string name for a token type ID (for error messages and debugging).\n * Returns `UNKNOWN_${id}` if the ID is not registered.\n */\nexport function tokenTypeName(id: number): string {\n\treturn _tokenTypeIdToName.get(id) ?? `UNKNOWN_${id}`;\n}\n\n/**\n * Bootstrap all known token types from TokenTypes at module load.\n * Call this once after TokenTypes is defined.\n */\nexport function registerAllTokenTypes(): void {\n\tfor (const name of Object.values(TokenTypes)) {\n\t\tregisterTokenType(name);\n\t}\n}\n"]}

package/dist/{chunk-4QADQTWS.js → chunk-KHJUSHFU.js}

@@ -1,8 +1,9 @@
 import { VariableResolver } from './chunk-GCM5JHMX.js';
-import { sharedCurrencyExchange } from './chunk-DM3LMRBC.js';
-import { powNode, callNode, simplifySymbolic, sameShape, cancelSymbolic, complexNode, complex, RATIONAL_ZERO, rationalFromNumber, freeVariables, symbolicToEntry, rowMajorToColumnMajor, expandSymbolic, matrixMultiply, inverse, determinant, transpose, constNode, rationalToNumber, toPolynomial, polyDegree, polyCoefficients, rationalNeg, substitute, rationalDiv, isRationalZero, varNode, isRationalOne, RATIONAL_ONE, polyUnivariateVar, rationalMul, fromPolynomial, rationalCompare, coefficientGcd, polynomialDivide, isZeroPolynomial, rationalAdd, rationalSub, exactIntegerSqrt, surdNode, compareMonomials, COMPLEX_I, exactRationalSqrt, symbolicKey, monomialFromKey, monomialToKey, signedSurdNode, exactIntegerCbrt } from './chunk-34RRD7PC.js';
-import { errorValue, symbolicValue, numberValue, bigIntValue, uomValue, matrixValue, hexValue, stringValue } from './chunk-BVAR5J2F.js';
-import { getMeasure, convertUnit } from './chunk-NH2O2AUR.js';
+import { sharedCurrencyExchange } from './chunk-UKPGSAZW.js';
+import { powNode, callNode, simplifySymbolic, sameShape, cancelSymbolic, complexNode, complex, RATIONAL_ZERO, rationalFromNumber, freeVariables, symbolicToEntry, rowMajorToColumnMajor, expandSymbolic, matrixMultiply, inverse, determinant, transpose, constNode, rationalToNumber, toPolynomial, polyDegree, polyCoefficients, rationalNeg, substitute, rationalDiv, isRationalZero, varNode, isRationalOne, RATIONAL_ONE, polyUnivariateVar, rationalMul, fromPolynomial, rationalCompare, coefficientGcd, polynomialDivide, isZeroPolynomial, rationalAdd, rationalSub, exactIntegerSqrt, surdNode, compareMonomials, COMPLEX_I, exactRationalSqrt, symbolicKey, monomialFromKey, monomialToKey, signedSurdNode, exactIntegerCbrt } from './chunk-CYFK5SY2.js';
+import { errorValue, symbolicValue, numberValue, bigIntValue, uomValue, matrixValue, percentageValue, stringValue, hexValue } from './chunk-BVAR5J2F.js';
+import { getMeasure, convertUnit } from './chunk-WC5FFSHB.js';
+import { UNIT_TABLE } from './chunk-PCPX42KL.js';
 import { ErrorFactory } from './chunk-6RDSQURE.js';
 
 // src/symbolic/MultivariateFactor.ts
@@ -1687,6 +1688,19 @@ function adjustForInflation(amount, fromYear, toYear) {
 }
 
 // src/vm/VMBuiltins.ts
+var ANGLE_KIND = 0;
+function angleInRadians(value) {
+  if (value.type === 6 /* Uom */ && value.unit !== void 0) {
+    const entry = UNIT_TABLE[value.unit.toLowerCase()];
+    if (entry !== void 0 && entry[0] === ANGLE_KIND) return value.toNumber() * entry[1];
+  }
+  return value.toNumber();
+}
+function pluraliseUnit(unit, count) {
+  if (count === 1) return unit;
+  const plural = `${unit}s`;
+  return UNIT_TABLE[plural.toLowerCase()] === void 0 ? unit : plural;
+}
 var builtinFunctions = {
   // ── Populated below ──
   // sqrt: a negative argument has a complex answer now that there is a complex
@@ -1701,9 +1715,10 @@ var builtinFunctions = {
   // valid alias for det(a) (index 64), reusing the SAME implementation
   // not a separate one. Plain-number abs is unaffected.
   1: (args) => args[0].type === 7 /* Matrix */ ? determinant(args[0].value) : numberValue(Math.abs(args[0].toNumber())),
-  2: (args) => numberValue(Math.sin(args[0].toNumber())),
-  3: (args) => numberValue(Math.cos(args[0].toNumber())),
-  4: (args) => numberValue(Math.tan(args[0].toNumber())),
+  // sin/cos/tan accept an angle with a unit; see angleInRadians().
+  2: (args) => numberValue(Math.sin(angleInRadians(args[0]))),
+  3: (args) => numberValue(Math.cos(angleInRadians(args[0]))),
+  4: (args) => numberValue(Math.tan(angleInRadians(args[0]))),
   5: (args) => numberValue(Math.log(args[0].toNumber())),
   6: (args) => numberValue(Math.ceil(args[0].toNumber())),
   7: (args) => numberValue(Math.floor(args[0].toNumber())),
@@ -2017,11 +2032,13 @@ var builtinFunctions = {
     const { monthlyPayment } = amortizeLoan(principal, rate, years);
     return args[0].type === 6 /* Uom */ ? uomValue(monthlyPayment, args[0].unit) : numberValue(monthlyPayment);
   },
-  // taxAdd(amount, rate) -> amount * (1 + rate). Backs "tax on $X at R%" /
-  // "VAT on $X at R%". No default rate is baked in anywhere, the caller
-  // always supplies one explicitly, since tax rates vary by region and
-  // change over time; this package makes no assumption about which rate
-  // applies.
+  // taxAdd(amount, rate) -> amount * (1 + rate), the tax-inclusive total.
+  // Backs the taxAdd() function-call form, whose name promises exactly this.
+  // The "tax on $X at R%" PHRASE does NOT use it, see index 86.
+  //
+  // No default rate is baked in anywhere, the caller always supplies one
+  // explicitly, since tax rates vary by region and change over time; this
+  // package makes no assumption about which rate applies.
   58: (args) => {
     const amount = args[0].toNumber();
     const rate = args[1].toNumber();
@@ -2237,6 +2254,206 @@ var builtinFunctions = {
     const value = args[0];
     if (value.type !== 9 /* Symbolic */) return value;
     return symbolicToValue(apartSymbolic(value.value));
+  },
+  // taxIn(amount, rate) -> amount - amount/(1 + rate), the tax already
+  // contained in a tax-INCLUSIVE total. Backs "tax in/of/from $X at R%".
+  // The complement of taxRemove (index 59): the two sum to the gross amount.
+  85: (args) => {
+    const amount = args[0].toNumber();
+    const rate = args[1].toNumber();
+    if (1 + rate <= 0) {
+      return errorValue("INVALID_RATE", `taxIn: rate ${rate} makes (1 + rate) non-positive`);
+    }
+    const tax = amount - amount / (1 + rate);
+    return args[0].type === 6 /* Uom */ ? uomValue(tax, args[0].unit) : numberValue(tax);
+  },
+  // taxOn(amount, rate) -> amount * rate, the tax itself.
+  //
+  // The "tax on $X at R%" phrase used to compile to taxAdd (index 58) and
+  // answer $345.00 for "tax on $300 at 15%". Soulver answers $45.00, and
+  // "the tax on $300" is the tax, not the bill. The total is "$300 + 15%",
+  // which reads as a relative increase (see PercentParselet.ts), or
+  // taxAdd(300, 0.15) for the function form.
+  86: (args) => {
+    const amount = args[0].toNumber();
+    const rate = args[1].toNumber();
+    const tax = amount * rate;
+    return args[0].type === 6 /* Uom */ ? uomValue(tax, args[0].unit) : numberValue(tax);
+  },
+  // ── Degree-taking trig (sind/cosd/tand and the inverses) ──────────────
+  // The "d" spellings take and return degrees rather than radians, which is
+  // the convention every scientific calculator uses. sin(90 degrees) is the
+  // other way to say the same thing; both exist because both get typed.
+  87: (args) => numberValue(Math.sin(args[0].toNumber() * Math.PI / 180)),
+  88: (args) => numberValue(Math.cos(args[0].toNumber() * Math.PI / 180)),
+  89: (args) => numberValue(Math.tan(args[0].toNumber() * Math.PI / 180)),
+  90: (args) => numberValue(Math.asin(args[0].toNumber()) * 180 / Math.PI),
+  91: (args) => numberValue(Math.acos(args[0].toNumber()) * 180 / Math.PI),
+  92: (args) => numberValue(Math.atan(args[0].toNumber()) * 180 / Math.PI),
+  // daysCount(n) -> n labelled as days. "days in Q3" is a count of days
+  // and should say so; a bare 92 loses what was being counted.
+  93: (args) => uomValue(args[0].toNumber(), "days"),
+  // asTwoUnits(value, majorUnit, minorUnit) -> "12 min 30 s".
+  //
+  // "12.5 minutes in minutes and seconds" asks for one quantity split
+  // across two units, which every other conversion path cannot express:
+  // they each produce a single number in a single unit.
+  //
+  // The whole part goes to the major unit and the remainder to the minor,
+  // so nothing is lost. A pair that is not ordered major-then-minor, or
+  // that spans two different measures, reports rather than guessing.
+  94: (args) => {
+    const major = args[1].value;
+    const minor = args[2].value;
+    const majorEntry = UNIT_TABLE[major.toLowerCase()];
+    const minorEntry = UNIT_TABLE[minor.toLowerCase()];
+    if (majorEntry === void 0 || minorEntry === void 0) {
+      return errorValue("UNKNOWN_UNIT", `${major} and ${minor}: one of these is not a unit`);
+    }
+    if (majorEntry[0] !== minorEntry[0]) {
+      return errorValue("INCOMPATIBLE_UNITS", `${major} and ${minor} measure different things`);
+    }
+    if (minorEntry[1] >= majorEntry[1]) {
+      return errorValue("INCOMPATIBLE_UNITS", `${major} and ${minor}: name the larger unit first`);
+    }
+    const source = args[0];
+    const sourceEntry = source.type === 6 /* Uom */ && source.unit !== void 0 ? UNIT_TABLE[source.unit.toLowerCase()] : void 0;
+    const inBase = source.toNumber() * (sourceEntry?.[1] ?? majorEntry[1]);
+    const majorCount = Math.floor(inBase / majorEntry[1]);
+    const minorCount = Math.round((inBase - majorCount * majorEntry[1]) / minorEntry[1] * 1e3) / 1e3;
+    return stringValue(`${majorCount} ${major} ${minorCount} ${minor}`);
+  },
+  // makeRate(value, denominatorUnit) -> value per that unit.
+  //
+  // `3 hours / day` is a rate, `3 hours / 3 days` is a division. The
+  // difference is whether a number was written in the denominator, which
+  // is decided at parse time, so this only ever receives the rate case.
+  //
+  // Building the rate directly rather than dividing by an implied 1 is the
+  // whole point: a division makes same-measure units cancel, which turned
+  // `3 hours / day` into 0.125 when that shortcut was tried.
+  95: (args) => {
+    const source = args[0];
+    const denominator = String(args[1].value);
+    const numerator = source.type === 6 /* Uom */ && source.unit !== void 0 ? source.unit : "";
+    if (numerator.includes("/")) {
+      return errorValue("INVALID_RATE_UNIT", `${numerator}/${denominator}: that is already a rate`);
+    }
+    return uomValue(source.toNumber(), `${numerator}/${denominator}`);
+  },
+  // atRate(quantity, rate) -> whichever of the two the question implies.
+  //
+  //   30 hours at $30/hour   $900      a duration at a price per duration
+  //   $500 at $20/hour       25 hours   money at a price per duration
+  //
+  // Both are written with the same word and mean opposite operations. Which
+  // one applies is decided by which half of the rate the left side matches:
+  // match the denominator and you are buying that many, match the numerator
+  // and you are asking how many it buys.
+  96: (args) => {
+    const left = args[0];
+    const rate = args[1];
+    if (rate.type !== 6 /* Uom */ || rate.unit === void 0 || !rate.unit.includes("/")) {
+      return errorValue("INVALID_RATE", 'at: the right-hand side has to be a rate, as in "$30/hour"');
+    }
+    const slash = rate.unit.indexOf("/");
+    const numerator = rate.unit.slice(0, slash);
+    const denominator = rate.unit.slice(slash + 1);
+    const leftUnit = left.type === 6 /* Uom */ ? left.unit : void 0;
+    const denominatorEntry = UNIT_TABLE[denominator.toLowerCase()];
+    const leftEntry = leftUnit === void 0 ? void 0 : UNIT_TABLE[leftUnit.toLowerCase()];
+    if (leftEntry !== void 0 && denominatorEntry !== void 0 && leftEntry[0] === denominatorEntry[0]) {
+      const inDenominator = left.toNumber() * leftEntry[1] / denominatorEntry[1];
+      const total = inDenominator * rate.toNumber();
+      return numerator === "" ? numberValue(total) : uomValue(total, numerator);
+    }
+    if (leftUnit !== void 0 && leftUnit === numerator) {
+      const count = left.toNumber() / rate.toNumber();
+      return uomValue(count, pluraliseUnit(denominator, count));
+    }
+    if (leftUnit === void 0) {
+      const total = left.toNumber() * rate.toNumber();
+      return numerator === "" ? numberValue(total) : uomValue(total, numerator);
+    }
+    return errorValue("INCOMPATIBLE_UNITS", `at: ${leftUnit} matches neither side of ${rate.unit}`);
+  },
+  // ── Investments (packages/finance/) ────────────────────────────────────
+  // compoundFutureValueEvery(principal, rate, years, periodsPerYear)
+  // FV = P(1 + r/n)^(n·y). Index 51 is the same formula with n fixed at 1;
+  // this one backs "compounding monthly"/"quarterly"/"daily"/"weekly".
+  // Kept separate rather than widening 51, because 51 is also the public
+  // compoundInterest(principal, rate, years) call and its arity is part of
+  // that contract.
+  80: (args) => {
+    const principal = args[0].toNumber();
+    const rate = args[1].toNumber();
+    const years = args[2].toNumber();
+    const perYear = args[3].toNumber();
+    if (perYear <= 0) {
+      return errorValue("INVALID_RATE", `compounding: ${perYear} periods per year is not a period`);
+    }
+    if (1 + rate / perYear <= 0) {
+      return errorValue("INVALID_RATE", `compounding: rate ${rate} makes each period non-positive`);
+    }
+    const fv = principal * Math.pow(1 + rate / perYear, perYear * years);
+    return args[0].type === 6 /* Uom */ ? uomValue(fv, args[0].unit) : numberValue(fv);
+  },
+  // compoundInterestEarnedEvery(principal, rate, years, periodsPerYear)
+  // The interest-only portion of index 80, i.e. FV - P.
+  81: (args) => {
+    const principal = args[0].toNumber();
+    const rate = args[1].toNumber();
+    const years = args[2].toNumber();
+    const perYear = args[3].toNumber();
+    if (perYear <= 0 || 1 + rate / perYear <= 0) {
+      return errorValue("INVALID_RATE", `compounding: rate ${rate} over ${perYear} periods per year is not usable`);
+    }
+    const interest = principal * (Math.pow(1 + rate / perYear, perYear * years) - 1);
+    return args[0].type === 6 /* Uom */ ? uomValue(interest, args[0].unit) : numberValue(interest);
+  },
+  // presentValue(futureValue, rate, years) -> FV / (1 + r)^y, what a sum
+  // promised in the future is worth today. The inverse of index 51.
+  82: (args) => {
+    const future = args[0].toNumber();
+    const rate = args[1].toNumber();
+    const years = args[2].toNumber();
+    if (1 + rate <= 0) {
+      return errorValue("INVALID_RATE", `presentValue: rate ${rate} makes (1 + rate) non-positive`);
+    }
+    const pv = future / Math.pow(1 + rate, years);
+    return args[0].type === 6 /* Uom */ ? uomValue(pv, args[0].unit) : numberValue(pv);
+  },
+  // returnOnInvestment(invested, returned) -> (returned - invested) /
+  // invested, the gain as a multiple of what was put in. $500 in and $1,500
+  // out is 2x, not 3x: ROI conventionally measures the profit against the
+  // cost, so doubling your money is 1x return and tripling it is 2x. The
+  // money multiple (3x here) is a different figure; `$1,500 / $500` gives it.
+  83: (args) => {
+    const invested = args[0].toNumber();
+    const returned = args[1].toNumber();
+    if (invested === 0) {
+      return errorValue("INVALID_RATE", "roi: nothing was invested, so there is no return on it");
+    }
+    return numberValue((returned - invested) / invested);
+  },
+  // annualisedReturn(invested, returned, years) -> CAGR, the constant
+  // yearly rate that turns `invested` into `returned` over `years`:
+  // (returned/invested)^(1/years) - 1. Returned as a Percentage so it
+  // renders "13.99%" rather than 0.1399.
+  84: (args) => {
+    const invested = args[0].toNumber();
+    const returned = args[1].toNumber();
+    const years = args[2].toNumber();
+    if (invested <= 0) {
+      return errorValue("INVALID_RATE", "annual return: the amount invested must be positive");
+    }
+    if (years <= 0) {
+      return errorValue("INVALID_RATE", "annual return: the period must be longer than zero");
+    }
+    if (returned <= 0) {
+      return errorValue("INVALID_RATE", "annual return: nothing was returned, so there is no annual rate");
+    }
+    return percentageValue(Math.pow(returned / invested, 1 / years) - 1);
   }
 };
 function applyComplexAccessor(name, value) {
@@ -2388,5 +2605,5 @@ function globalDagKey(name) {
 }
 
 export { CPI_MAX_YEAR, CPI_MIN_YEAR, OpRegistry, SYMBOLIC_NATIVE_BUILTINS, adjustForInflation, allocatePluginFunctionIndex, asConverterRegistry, binaryOp, builtinFunctions, createEngineContext, defaultEngineContext, globalDagKey, pluginFunctionRegistry, registerAsConverter, sharedGlobalVariableStore, sharedOpRegistry, solveEquationValues, symbolicBuiltin, symbolicNeg, symbolicPow, unifyUom, unregisterAsConverter };
-//# sourceMappingURL=chunk-4QADQTWS.js.map
-//# sourceMappingURL=chunk-4QADQTWS.js.map
+//# sourceMappingURL=chunk-KHJUSHFU.js.map
+//# sourceMappingURL=chunk-KHJUSHFU.js.map